"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Union = void 0;
var stream_1 = require("stream");
var _a = require("fs-monkey/lib/util/lists"), fsAsyncMethods = _a.fsAsyncMethods, fsSyncMethods = _a.fsSyncMethods;
var SPECIAL_METHODS = new Set([
    "existsSync",
    "readdir",
    "readdirSync",
    "createReadStream",
    "createWriteStream",
    "watch",
    "watchFile",
    "unwatchFile",
]);
var SPECIAL_ERRORS = new Set(["ENOTDIR", "EEXIST"]);
var createFSProxy = function (watchers) {
    return new Proxy({}, {
        get: function (_obj, property) {
            var e_1, _a;
            var funcCallers = [];
            var prop;
            try {
                for (var watchers_1 = __values(watchers), watchers_1_1 = watchers_1.next(); !watchers_1_1.done; watchers_1_1 = watchers_1.next()) {
                    var watcher = watchers_1_1.value;
                    prop = watcher[property];
                    // if we're a function we wrap it in a bigger caller;
                    if (typeof prop === "function") {
                        funcCallers.push([watcher, prop]);
                    }
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (watchers_1_1 && !watchers_1_1.done && (_a = watchers_1.return)) _a.call(watchers_1);
                }
                finally { if (e_1) throw e_1.error; }
            }
            if (funcCallers.length) {
                return function () {
                    var e_2, _a;
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    try {
                        for (var funcCallers_1 = __values(funcCallers), funcCallers_1_1 = funcCallers_1.next(); !funcCallers_1_1.done; funcCallers_1_1 = funcCallers_1.next()) {
                            var _b = __read(funcCallers_1_1.value, 2), watcher = _b[0], func = _b[1];
                            func.apply(watcher, args);
                        }
                    }
                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
                    finally {
                        try {
                            if (funcCallers_1_1 && !funcCallers_1_1.done && (_a = funcCallers_1.return)) _a.call(funcCallers_1);
                        }
                        finally { if (e_2) throw e_2.error; }
                    }
                };
            }
            else {
                return prop;
            }
        },
    });
};
var fsPromisesMethods = [
    "access",
    "copyFile",
    "open",
    "opendir",
    "rename",
    "truncate",
    "rmdir",
    "mkdir",
    "readdir",
    "readlink",
    "symlink",
    "lstat",
    "stat",
    "link",
    "unlink",
    "chmod",
    "lchmod",
    "lchown",
    "chown",
    "utimes",
    "realpath",
    "mkdtemp",
    "writeFile",
    "appendFile",
    "readFile",
];
/**
 * Union object represents a stack of filesystems
 */
var Union = /** @class */ (function () {
    function Union() {
        var e_3, _a, e_4, _b, e_5, _c, e_6, _d;
        var _this = this;
        this.fss = [];
        this.ReadStream = stream_1.Readable;
        this.WriteStream = stream_1.Writable;
        this.promises = {};
        this.unwatchFile = function () {
            var e_7, _a;
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            try {
                for (var _b = __values(_this.fss), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var fs = _c.value;
                    try {
                        fs.unwatchFile.apply(fs, args);
                    }
                    catch (e) {
                        // dunno what to do here...
                    }
                }
            }
            catch (e_7_1) { e_7 = { error: e_7_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_7) throw e_7.error; }
            }
        };
        this.watch = function () {
            var e_8, _a;
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            var watchers = [];
            try {
                for (var _b = __values(_this.fss), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var fs = _c.value;
                    try {
                        var watcher = fs.watch.apply(fs, args);
                        watchers.push(watcher);
                    }
                    catch (e) {
                        // dunno what to do here...
                    }
                }
            }
            catch (e_8_1) { e_8 = { error: e_8_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_8) throw e_8.error; }
            }
            // return a proxy to call functions on these props
            return createFSProxy(watchers);
        };
        this.watchFile = function () {
            var e_9, _a;
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            try {
                for (var _b = __values(_this.fss), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var fs = _c.value;
                    try {
                        fs.watchFile.apply(fs, args);
                    }
                    catch (e) {
                        // dunno what to do here...
                    }
                }
            }
            catch (e_9_1) { e_9 = { error: e_9_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_9) throw e_9.error; }
            }
        };
        this.existsSync = function (path) {
            var e_10, _a;
            try {
                for (var _b = __values(_this.fss), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var fs = _c.value;
                    try {
                        if (fs.existsSync(path)) {
                            return true;
                        }
                    }
                    catch (e) {
                        // ignore
                    }
                }
            }
            catch (e_10_1) { e_10 = { error: e_10_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_10) throw e_10.error; }
            }
            return false;
        };
        this.readdir = function () {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            var lastarg = args.length - 1;
            var cb = args[lastarg];
            if (typeof cb !== "function") {
                cb = null;
                lastarg++;
            }
            var lastError = null;
            var result = new Map();
            var pathExists = false;
            var iterate = function (i, error) {
                if (i === void 0) { i = 0; }
                if (error) {
                    if (SPECIAL_ERRORS.has(error["code"])) {
                        // Immediately fail with this error.
                        // see comment in readdirSync
                        if (cb) {
                            cb(error);
                        }
                        return;
                    }
                    error.prev = lastError;
                    lastError = error;
                }
                // Already tried all file systems; return the last error if every attempt failed.
                if (i >= _this.fss.length) {
                    // last one
                    if (cb) {
                        if (pathExists) {
                            cb(null, _this.sortedArrayFromReaddirResult(result));
                        }
                        else {
                            cb(error || Error("No file systems attached."));
                        }
                    }
                    return;
                }
                // Replace `callback` with our intermediate function.
                args[lastarg] = function (err, resArg) {
                    var e_11, _a;
                    if (!err) {
                        pathExists = true;
                    }
                    if (result.size === 0 && err) {
                        return iterate(i + 1, err);
                    }
                    if (resArg) {
                        try {
                            for (var resArg_1 = __values(resArg), resArg_1_1 = resArg_1.next(); !resArg_1_1.done; resArg_1_1 = resArg_1.next()) {
                                var res = resArg_1_1.value;
                                result.set(_this.pathFromReaddirEntry(res), res);
                            }
                        }
                        catch (e_11_1) { e_11 = { error: e_11_1 }; }
                        finally {
                            try {
                                if (resArg_1_1 && !resArg_1_1.done && (_a = resArg_1.return)) _a.call(resArg_1);
                            }
                            finally { if (e_11) throw e_11.error; }
                        }
                    }
                    if (i === _this.fss.length - 1) {
                        return cb(null, _this.sortedArrayFromReaddirResult(result));
                    }
                    else {
                        return iterate(i + 1, error);
                    }
                };
                var j = _this.fss.length - i - 1;
                var fs = _this.fss[j];
                var func = fs.readdir;
                if (!func)
                    iterate(i + 1, Error("Method not supported: readdir"));
                else
                    func.apply(fs, args);
            };
            iterate();
        };
        this.readdirSync = function () {
            var e_12, _a;
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            var lastError = null;
            var result = new Map();
            var pathExists = false;
            for (var i = _this.fss.length - 1; i >= 0; i--) {
                var fs = _this.fss[i];
                try {
                    if (!fs.readdirSync)
                        throw Error("Method not supported: \"readdirSync\" with args \"".concat(args, "\""));
                    try {
                        for (var _b = (e_12 = void 0, __values(fs.readdirSync.apply(fs, args))), _c = _b.next(); !_c.done; _c = _b.next()) {
                            var res = _c.value;
                            result.set(_this.pathFromReaddirEntry(res), res);
                        }
                    }
                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
                    finally {
                        try {
                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                        }
                        finally { if (e_12) throw e_12.error; }
                    }
                    pathExists = true;
                }
                catch (err) {
                    if (SPECIAL_ERRORS.has(err.code)) {
                        // The file *does* exist in this filesystem in the union, but an ENOTDIR or EEXIST error happened
                        // (or anything in SPECIAL_ERRORS).
                        // E.g., if you try to get a directory listing on a file one fs doesn't have the file and the
                        // the other fs has the file, then the one that has it throws ENOTDIR, which is what this
                        // function should throw.  I hit this problem when working the cpython unit tests
                        // for Lib/test/test_exceptions.py, which check the error code when trying to get a directory
                        // listing on a file.
                        throw err;
                    }
                    err.prev = lastError;
                    lastError = err;
                    if (!i && !pathExists) {
                        // Last one and the path didn't exist in any case above.
                        // NOTE: In upstream this function has a bug when there's 2 filesystems with this.fss[1] having the
                        // directory but it is empty and this.fss[0] not having the directory.  In that case checking the
                        // size doesn't work to know if the directory exists.  In particular, the fix at
                        // https://github.com/streamich/unionfs/pull/348 is incorrect.
                        throw err;
                    }
                    else {
                        // Ignore error...
                        // continue;
                    }
                }
            }
            return _this.sortedArrayFromReaddirResult(result);
        };
        this.readdirPromise = function () {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            return __awaiter(_this, void 0, void 0, function () {
                var lastError, result, i, fs, _a, _b, res, e_13_1, err_1;
                var e_13, _c;
                return __generator(this, function (_d) {
                    switch (_d.label) {
                        case 0:
                            lastError = null;
                            result = new Map();
                            i = this.fss.length - 1;
                            _d.label = 1;
                        case 1:
                            if (!(i >= 0)) return [3 /*break*/, 13];
                            fs = this.fss[i];
                            _d.label = 2;
                        case 2:
                            _d.trys.push([2, 11, , 12]);
                            if (!fs.promises || !fs.promises.readdir)
                                throw Error("Method not supported: \"readdirSync\" with args \"".concat(args, "\""));
                            _d.label = 3;
                        case 3:
                            _d.trys.push([3, 8, 9, 10]);
                            e_13 = void 0;
                            return [4 /*yield*/, fs.promises.readdir.apply(fs, args)];
                        case 4:
                            _a = (__values.apply(void 0, [_d.sent()])), _b = _a.next();
                            _d.label = 5;
                        case 5:
                            if (!!_b.done) return [3 /*break*/, 7];
                            res = _b.value;
                            result.set(this.pathFromReaddirEntry(res), res);
                            _d.label = 6;
                        case 6:
                            _b = _a.next();
                            return [3 /*break*/, 5];
                        case 7: return [3 /*break*/, 10];
                        case 8:
                            e_13_1 = _d.sent();
                            e_13 = { error: e_13_1 };
                            return [3 /*break*/, 10];
                        case 9:
                            try {
                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                            }
                            finally { if (e_13) throw e_13.error; }
                            return [7 /*endfinally*/];
                        case 10: return [3 /*break*/, 12];
                        case 11:
                            err_1 = _d.sent();
                            err_1.prev = lastError;
                            lastError = err_1;
                            if (result.size === 0 && !i) {
                                // last one
                                throw err_1;
                            }
                            else {
                                // Ignore error...
                                // continue;
                            }
                            return [3 /*break*/, 12];
                        case 12:
                            i--;
                            return [3 /*break*/, 1];
                        case 13: return [2 /*return*/, this.sortedArrayFromReaddirResult(result)];
                    }
                });
            });
        };
        this.pathFromReaddirEntry = function (readdirEntry) {
            if (readdirEntry instanceof Buffer || typeof readdirEntry === "string") {
                return String(readdirEntry);
            }
            return readdirEntry.name;
        };
        this.sortedArrayFromReaddirResult = function (readdirResult) {
            var e_14, _a;
            var array = [];
            try {
                for (var _b = __values(Array.from(readdirResult.keys()).sort()), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var key = _c.value;
                    var value = readdirResult.get(key);
                    if (value !== undefined)
                        array.push(value);
                }
            }
            catch (e_14_1) { e_14 = { error: e_14_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_14) throw e_14.error; }
            }
            return array;
        };
        this.createReadStream = function (path) {
            var e_15, _a;
            var lastError = null;
            try {
                for (var _b = __values(_this.fss), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var fs = _c.value;
                    try {
                        if (!fs.createReadStream)
                            throw Error("Method not supported: \"createReadStream\"");
                        if (fs.existsSync && !fs.existsSync(path)) {
                            throw new Error("file \"".concat(path, "\" does not exists"));
                        }
                        var stream = fs.createReadStream(path);
                        if (!stream) {
                            throw new Error("no valid stream");
                        }
                        _this.ReadStream = fs.ReadStream;
                        return stream;
                    }
                    catch (err) {
                        lastError = err;
                    }
                }
            }
            catch (e_15_1) { e_15 = { error: e_15_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_15) throw e_15.error; }
            }
            throw lastError;
        };
        this.createWriteStream = function (path) {
            var e_16, _a;
            var lastError = null;
            try {
                for (var _b = __values(_this.fss), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var fs = _c.value;
                    try {
                        if (!fs.createWriteStream)
                            throw Error("Method not supported: \"createWriteStream\"");
                        fs.statSync(path); //we simply stat first to exit early for mocked fs'es
                        //TODO which filesystem to write to?
                        var stream = fs.createWriteStream(path);
                        if (!stream) {
                            throw new Error("no valid stream");
                        }
                        _this.WriteStream = fs.WriteStream;
                        return stream;
                    }
                    catch (err) {
                        lastError = err;
                    }
                }
            }
            catch (e_16_1) { e_16 = { error: e_16_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_16) throw e_16.error; }
            }
            throw lastError;
        };
        var _loop_1 = function (method) {
            if (!SPECIAL_METHODS.has(method)) {
                // check we don't already have a property for this method
                this_1[method] = function () {
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    return _this.syncMethod(method, args);
                };
            }
        };
        var this_1 = this;
        try {
            for (var fsSyncMethods_1 = __values(fsSyncMethods), fsSyncMethods_1_1 = fsSyncMethods_1.next(); !fsSyncMethods_1_1.done; fsSyncMethods_1_1 = fsSyncMethods_1.next()) {
                var method = fsSyncMethods_1_1.value;
                _loop_1(method);
            }
        }
        catch (e_3_1) { e_3 = { error: e_3_1 }; }
        finally {
            try {
                if (fsSyncMethods_1_1 && !fsSyncMethods_1_1.done && (_a = fsSyncMethods_1.return)) _a.call(fsSyncMethods_1);
            }
            finally { if (e_3) throw e_3.error; }
        }
        var _loop_2 = function (method) {
            if (!SPECIAL_METHODS.has(method)) {
                // check we don't already have a property for this method
                this_2[method] = function () {
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    return _this.asyncMethod(method, args);
                };
            }
        };
        var this_2 = this;
        try {
            for (var fsAsyncMethods_1 = __values(fsAsyncMethods), fsAsyncMethods_1_1 = fsAsyncMethods_1.next(); !fsAsyncMethods_1_1.done; fsAsyncMethods_1_1 = fsAsyncMethods_1.next()) {
                var method = fsAsyncMethods_1_1.value;
                _loop_2(method);
            }
        }
        catch (e_4_1) { e_4 = { error: e_4_1 }; }
        finally {
            try {
                if (fsAsyncMethods_1_1 && !fsAsyncMethods_1_1.done && (_b = fsAsyncMethods_1.return)) _b.call(fsAsyncMethods_1);
            }
            finally { if (e_4) throw e_4.error; }
        }
        var _loop_3 = function (method) {
            if (method === "readdir") {
                this_3.promises[method] = this_3.readdirPromise;
                return "continue";
            }
            this_3.promises[method] = function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                return _this.promiseMethod(method, args);
            };
        };
        var this_3 = this;
        try {
            for (var fsPromisesMethods_1 = __values(fsPromisesMethods), fsPromisesMethods_1_1 = fsPromisesMethods_1.next(); !fsPromisesMethods_1_1.done; fsPromisesMethods_1_1 = fsPromisesMethods_1.next()) {
                var method = fsPromisesMethods_1_1.value;
                _loop_3(method);
            }
        }
        catch (e_5_1) { e_5 = { error: e_5_1 }; }
        finally {
            try {
                if (fsPromisesMethods_1_1 && !fsPromisesMethods_1_1.done && (_c = fsPromisesMethods_1.return)) _c.call(fsPromisesMethods_1);
            }
            finally { if (e_5) throw e_5.error; }
        }
        try {
            for (var _e = __values(SPECIAL_METHODS.values()), _f = _e.next(); !_f.done; _f = _e.next()) {
                var method = _f.value;
                // bind special methods to support
                // const { method } = ufs;
                this[method] = this[method].bind(this);
            }
        }
        catch (e_6_1) { e_6 = { error: e_6_1 }; }
        finally {
            try {
                if (_f && !_f.done && (_d = _e.return)) _d.call(_e);
            }
            finally { if (e_6) throw e_6.error; }
        }
    }
    /**
     * Adds a filesystem to the list of filesystems in the union
     * The new filesystem object is added as the last filesystem used
     * when searching for a file.
     *
     * @param fs the filesystem interface to be added to the queue of FS's
     * @returns this instance of a unionFS
     */
    Union.prototype.use = function (fs) {
        this.fss.push(fs);
        return this;
    };
    Union.prototype.syncMethod = function (method, args) {
        var lastError = null;
        for (var i = this.fss.length - 1; i >= 0; i--) {
            var fs = this.fss[i];
            try {
                if (!fs[method])
                    throw Error("Method not supported: \"".concat(method, "\" with args \"").concat(args, "\""));
                return fs[method].apply(fs, args);
            }
            catch (err) {
                if (SPECIAL_ERRORS.has(err["code"])) { // see comment in readdirSync
                    throw err;
                }
                err.prev = lastError;
                lastError = err;
                if (!i) {
                    // last one
                    throw err;
                }
                else {
                    // Ignore error...
                    // continue;
                }
            }
        }
    };
    Union.prototype.asyncMethod = function (method, args) {
        var _this = this;
        var lastarg = args.length - 1;
        var cb = args[lastarg];
        if (typeof cb !== "function") {
            cb = null;
            lastarg++;
        }
        var lastError = null;
        var iterate = function (i, err) {
            if (i === void 0) { i = 0; }
            if (err != null && SPECIAL_ERRORS.has(err === null || err === void 0 ? void 0 : err["code"])) { // see comment in readdirSync
                if (cb) {
                    cb(err);
                }
                return;
            }
            if (err) {
                err.prev = lastError;
                lastError = err;
            }
            // Already tried all file systems, return the last error.
            if (i >= _this.fss.length) {
                // last one
                if (cb)
                    cb(err || Error("No file systems attached."));
                return;
            }
            // Replace `callback` with our intermediate function.
            args[lastarg] = function (err) {
                if (err)
                    return iterate(i + 1, err);
                if (cb)
                    cb.apply(cb, arguments);
            };
            var j = _this.fss.length - i - 1;
            var fs = _this.fss[j];
            var func = fs[method];
            if (!func)
                iterate(i + 1, Error("Method not supported: " + method));
            else
                func.apply(fs, args);
        };
        iterate();
    };
    Union.prototype.promiseMethod = function (method, args) {
        return __awaiter(this, void 0, void 0, function () {
            var lastError, i, theFs, promises, err_2;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        lastError = null;
                        i = this.fss.length - 1;
                        _a.label = 1;
                    case 1:
                        if (!(i >= 0)) return [3 /*break*/, 6];
                        theFs = this.fss[i];
                        promises = theFs.promises;
                        _a.label = 2;
                    case 2:
                        _a.trys.push([2, 4, , 5]);
                        if (!promises || !promises[method]) {
                            throw Error("Promise of method not supported: \"".concat(String(method), "\" with args \"").concat(args, "\""));
                        }
                        return [4 /*yield*/, promises[method].apply(promises, args)];
                    case 3: 
                    // return promises[method](...args);
                    return [2 /*return*/, _a.sent()];
                    case 4:
                        err_2 = _a.sent();
                        err_2.prev = lastError;
                        lastError = err_2;
                        if (!i) {
                            // last one
                            throw err_2;
                        }
                        else {
                            // Ignore error...
                            // continue;
                        }
                        return [3 /*break*/, 5];
                    case 5:
                        i--;
                        return [3 /*break*/, 1];
                    case 6: return [2 /*return*/];
                }
            });
        });
    };
    return Union;
}());
exports.Union = Union;