@common.js/object-scan 20.0.4

package/lib/index.min.js

@@ -0,0 +1,1443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return a;
+    }
+});
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+var e = {};
+(function() {
+    e.d = function(t, r) {
+        for(var n in r){
+            if (e.o(r, n) && !e.o(t, n)) {
+                Object.defineProperty(t, n, {
+                    enumerable: true,
+                    get: r[n]
+                });
+            }
+        }
+    };
+})();
+(function() {
+    e.o = function(e, t) {
+        return Object.prototype.hasOwnProperty.call(e, t);
+    };
+})();
+if (typeof e !== "undefined") e.ab = new URL(".", require("url").pathToFileURL(__filename).toString()).pathname.slice(require("url").pathToFileURL(__filename).toString().match(/^file:\/\/\/\w:/) ? 1 : 0, -1) + "/";
+var t = {};
+e.d(t, {
+    A: function() {
+        return lib;
+    }
+});
+var assert = function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "Internal Logic Error";
+    if (!e) {
+        throw new Error(typeof t === "function" ? t() : t);
+    }
+};
+var Value = function Value(e, t) {
+    "use strict";
+    _classCallCheck(this, Value);
+    this.value = e;
+    this.excluded = t;
+    this.isSimpleStarRec = e === "**";
+    this.isRegexStarRec = e.startsWith("**(") && e.endsWith(")");
+    this.isStarRec = this.isSimpleStarRec || this.isRegexStarRec;
+};
+var Ref = /*#__PURE__*/ function() {
+    "use strict";
+    function Ref(e) {
+        var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+        _classCallCheck(this, Ref);
+        this.left = t === null;
+        this.link = t === null ? new Ref(e, this) : t;
+        this.type = e;
+        this.isStarRec = this.type === "**";
+        this.node = null;
+        this.pointer = null;
+    }
+    _createClass(Ref, [
+        {
+            key: "setPointer",
+            value: function setPointer(e) {
+                this.pointer = e;
+                this.link.pointer = e;
+            }
+        },
+        {
+            key: "setNode",
+            value: function setNode(e) {
+                this.node = e;
+                this.link.node = e;
+            }
+        }
+    ]);
+    return Ref;
+}();
+var throwError = function(e, t) {
+    var r = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    throw new Error(Object.entries(r).reduce(function(e, param) {
+        var _param = _slicedToArray(param, 2), _$t = _param[0], r = _param[1];
+        return "".concat(e, ", ").concat(_$t, " ").concat(r);
+    }, "".concat(e, ": ").concat(t)));
+};
+var getSimple = function(e) {
+    return e.length === 1 ? e[0] : e;
+};
+var r = /^[?*+\d]+$/;
+var parser_result = function(e) {
+    var t = [];
+    t.or = true;
+    var n = false;
+    var s = false;
+    var i = 0;
+    var l = [];
+    var newChild = function(e) {
+        if (t.excluded === true) {
+            assert(s === false);
+            s = true;
+        }
+        l.push(t);
+        t = [];
+        t.or = e;
+    };
+    var finishChild = function() {
+        var e = l.pop();
+        var r = getSimple(t);
+        if (e.or === true && r.or === true) {
+            var _e;
+            (_e = e).push.apply(_e, _toConsumableArray(r));
+        } else {
+            e.push(r);
+        }
+        t = e;
+    };
+    newChild(false);
+    return {
+        setInArray: function(t, r) {
+            if (n === t) {
+                throwError(n ? "Bad Array Start" : "Bad Array Terminator", e, {
+                    char: r
+                });
+            }
+            n = t;
+        },
+        finishElement: function(l, a, o) {
+            var ref = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {}, tmp = ref.finReq, c = tmp === void 0 ? false : tmp, tmp1 = ref.group, u = tmp1 === void 0 ? false : tmp1;
+            var f = i === l;
+            if (f) {
+                if (!o.includes(e[l - 1] || null)) {
+                    throwError(a, e, {
+                        char: l
+                    });
+                }
+                i += 1;
+            } else {
+                if (c) {
+                    throwError(a, e, {
+                        char: l
+                    });
+                }
+                var _$o = e.slice(i, l);
+                if (u && ![
+                    "**",
+                    "++"
+                ].includes(_$o)) {
+                    throwError("Bad Group Start", e, {
+                        char: l
+                    });
+                }
+                if (n && !(r.test(_$o) || _$o.startsWith("(") && _$o.endsWith(")"))) {
+                    throwError("Bad Array Selector", e, {
+                        selector: _$o
+                    });
+                }
+                if (u) {
+                    t.push(new Ref(_$o));
+                } else {
+                    t.push(new Value(n ? "[".concat(_$o, "]") : _$o, s));
+                    s = false;
+                }
+                i = l + 1;
+            }
+        },
+        startExclusion: function(t) {
+            if (s !== false) {
+                throwError("Redundant Exclusion", e, {
+                    char: t
+                });
+            }
+            s = true;
+        },
+        startGroup: function() {
+            newChild(true);
+            if (s) {
+                t.excluded = true;
+                s = false;
+            }
+            newChild(false);
+        },
+        newGroupElement: function() {
+            finishChild();
+            newChild(false);
+        },
+        finishGroup: function(r) {
+            if (l.length < 2) {
+                throwError("Unexpected Group Terminator", e, {
+                    char: r
+                });
+            }
+            finishChild();
+            finishChild();
+            assert(Array.isArray(t));
+            var n = t[t.length - 2];
+            if (_instanceof(n, Ref) && n.left === true) {
+                t.push(n.link);
+            }
+        },
+        finalizeResult: function() {
+            finishChild();
+            assert(s === false);
+            if (l.length !== 0) {
+                throwError("Non Terminated Group", e);
+            }
+            if (n) {
+                throwError("Non Terminated Array", e);
+            }
+            return getSimple(t);
+        }
+    };
+};
+var parser_throwError = function(e, t) {
+    var r = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    throw new Error(Object.entries(r).reduce(function(e, param) {
+        var _param = _slicedToArray(param, 2), _$t = _param[0], r = _param[1];
+        return "".concat(e, ", ").concat(_$t, " ").concat(r);
+    }, "".concat(e, ": ").concat(t)));
+};
+var parse = function(e, t) {
+    if (e === "") {
+        return new Value("", false);
+    }
+    if (Array.isArray(e)) {
+        if (e.length === 0) {
+            return new Value("", false);
+        }
+        return e.map(function(r, n) {
+            if (typeof r === "number") {
+                if (!t.useArraySelector) {
+                    parser_throwError("Forbidden Array Selector", JSON.stringify(e), {
+                        idx: n
+                    });
+                }
+                return new Value("[".concat(r, "]"), false);
+            }
+            return new Value(r.replaceAll("\\", "\\\\"), false);
+        });
+    }
+    var r = parser_result(e);
+    var n = e.length;
+    var s = false;
+    var i = 0;
+    for(var l = 0; l < n; l += 1){
+        var n1 = e[l];
+        if (s === false) {
+            if (i === 0) {
+                switch(n1){
+                    case ".":
+                        r.finishElement(l, "Bad Path Separator", [
+                            "]",
+                            "}"
+                        ]);
+                        break;
+                    case "[":
+                        if (!t.useArraySelector) {
+                            parser_throwError("Forbidden Array Selector", e, {
+                                char: l
+                            });
+                        }
+                        r.finishElement(l, "Bad Array Start", [
+                            null,
+                            "!",
+                            "{",
+                            ",",
+                            "}",
+                            "]"
+                        ]);
+                        r.setInArray(true, l);
+                        break;
+                    case "]":
+                        r.finishElement(l, "Bad Array Terminator", [
+                            "}"
+                        ]);
+                        r.setInArray(false, l);
+                        break;
+                    case "{":
+                        r.finishElement(l, "Bad Group Start", [
+                            null,
+                            "!",
+                            ".",
+                            "[",
+                            "{",
+                            ","
+                        ], {
+                            group: true
+                        });
+                        r.startGroup();
+                        break;
+                    case ",":
+                        r.finishElement(l, "Bad Group Separator", [
+                            "]",
+                            "}"
+                        ]);
+                        r.newGroupElement();
+                        break;
+                    case "}":
+                        r.finishElement(l, "Bad Group Terminator", [
+                            "]",
+                            "}"
+                        ]);
+                        r.finishGroup(l);
+                        break;
+                    case "!":
+                        r.finishElement(l, "Bad Exclusion", [
+                            null,
+                            ".",
+                            ",",
+                            "{",
+                            "["
+                        ], {
+                            finReq: true
+                        });
+                        r.startExclusion(l);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            switch(n1){
+                case "(":
+                    i += 1;
+                    break;
+                case ")":
+                    if (i === 0) {
+                        parser_throwError("Unexpected Parentheses", e, {
+                            char: l
+                        });
+                    }
+                    i -= 1;
+                    break;
+                default:
+                    break;
+            }
+        }
+        s = n1 === "\\" ? !s : false;
+    }
+    if (s !== false) {
+        parser_throwError("Dangling Escape", e, {
+            char: n - 1
+        });
+    }
+    if (i !== 0) {
+        parser_throwError("Unterminated Parentheses", e);
+    }
+    r.finishElement(n, "Bad Terminator", [
+        "]",
+        "}"
+    ]);
+    return r.finalizeResult();
+};
+var n = {
+    parse: parse
+};
+var iterator = function(e, t) {
+    var r = [
+        e
+    ];
+    var n = [
+        null
+    ];
+    var s = [];
+    var i = [];
+    var l = 0;
+    var a = true;
+    while(l !== -1){
+        var _$e = r[l];
+        if (Array.isArray(_$e)) {
+            if (_$e.or !== true) {
+                var _r, _n;
+                (_r = r).splice.apply(_r, [
+                    l,
+                    1
+                ].concat(_toConsumableArray(_$e)));
+                (_n = n).splice.apply(_n, [
+                    l,
+                    1
+                ].concat(_toConsumableArray(new Array(_$e.length).fill(n[l]))));
+                if (n[l] !== null) {
+                    i[n[l]] += _$e.length - 1;
+                }
+            } else {
+                if (s[l] === undefined) {
+                    s[l] = 0;
+                    i[l] = 0;
+                } else if (i[l] !== 0) {
+                    r.splice(l + 1, i[l]);
+                    n.splice(l + 1, i[l]);
+                    i[l] = 0;
+                }
+                if (s[l] < _$e.length) {
+                    r.splice(l + 1, 0, _$e[s[l]]);
+                    n.splice(l + 1, 0, l);
+                    s[l] = (s[l] || 0) + 1;
+                    i[l] += 1;
+                    a = true;
+                    l += 1;
+                } else {
+                    s[l] = 0;
+                    l -= 1;
+                }
+            }
+        } else if (a === true) {
+            t("ADD", _$e);
+            if (l === r.length - 1) {
+                t("FIN", _$e);
+                a = false;
+            } else {
+                l += 1;
+            }
+        } else {
+            t("RM", _$e);
+            l -= 1;
+        }
+    }
+};
+var compiler_iterator = function(e, t, r, param) {
+    var n = param.onAdd, s = param.onFin;
+    var i = [
+        [
+            [
+                e,
+                null
+            ]
+        ]
+    ];
+    var l = false;
+    iterator(r, function(r, a) {
+        if (r === "RM") {
+            if (a.excluded === true) {
+                l = false;
+            }
+            i.length -= 2;
+        } else if (r === "ADD") {
+            if (a.excluded === true) {
+                if (l) {
+                    throw new Error('Redundant Exclusion: "'.concat(t, '"'));
+                }
+                l = true;
+            }
+            var _$e = [];
+            var _$r = i[i.length - 2];
+            i[i.length - 1].forEach(function(param) {
+                var _param = _slicedToArray(param, 2), _$t = _param[0], s = _param[1];
+                return n(_$t, s, a, _$r, function(r) {
+                    return _$e.push([
+                        r,
+                        _$t
+                    ]);
+                });
+            });
+            i.push(a, _$e);
+        } else {
+            i[i.length - 1].filter(function(param) {
+                var _param = _slicedToArray(param, 1), _$t = _param[0];
+                return _$t !== e;
+            }).forEach(function(param) {
+                var _param = _slicedToArray(param, 2), _$e = _param[0], _$t = _param[1];
+                return s(_$e, _$t, a, l);
+            });
+        }
+    });
+};
+var s = /[?!,.*+[\](){}\\]/g;
+var helper_escape = function(e) {
+    return e.replace(s, "\\$&");
+};
+var i = /[\\^$*+?.()|[\]{}]/;
+var asRegex = function(e) {
+    var t = e.charCodeAt(0) === 94;
+    var r = e.charCodeAt(e.length - 1) === 36;
+    var n = e.slice(t ? 1 : 0, r ? -1 : undefined);
+    if (i.test(n)) {
+        try {
+            return new RegExp(e);
+        } catch (e1) {
+            throw new Error('Invalid Regex: "'.concat(e, '"'));
+        }
+    }
+    if (t && r) {
+        return {
+            test: function(e) {
+                return String(e) === n;
+            }
+        };
+    }
+    if (t) {
+        return {
+            test: function(e) {
+                return String(e).startsWith(n);
+            }
+        };
+    }
+    if (r) {
+        return {
+            test: function(e) {
+                return String(e).endsWith(n);
+            }
+        };
+    }
+    return {
+        test: function(e) {
+            return String(e).includes(n);
+        }
+    };
+};
+var toPath = function(e) {
+    var t = "";
+    for(var r = 0, n = e.length; r < n; r += 1){
+        var n1 = e[r];
+        if (typeof n1 === "number") {
+            t += "[".concat(n1, "]");
+        } else {
+            if (t.length > 0) {
+                t += ".";
+            }
+            t += helper_escape(n1);
+        }
+    }
+    return t;
+};
+var formatNeedle = function(e) {
+    return Array.isArray(e) ? toPath(e) : e;
+};
+var l = [
+    "-",
+    "/",
+    "\\",
+    "^",
+    "$",
+    "*",
+    "+",
+    "?",
+    ".",
+    "(",
+    ")",
+    "|",
+    "[",
+    "]",
+    "{",
+    "}"
+];
+var parseValue = function(e) {
+    var t = "";
+    var r = false;
+    var n = true;
+    for(var s = 0; s < e.length; s += 1){
+        var i = e[s];
+        if (!r && i === "\\") {
+            r = true;
+        } else if (!r && i === "*") {
+            n = false;
+            t += ".*";
+        } else if (!r && i === "+") {
+            n = false;
+            t += ".+";
+        } else if (!r && i === "?") {
+            n = false;
+            t += ".";
+        } else {
+            if (l.includes(i)) {
+                n = false;
+                t += "\\";
+            }
+            t += i;
+            r = false;
+        }
+    }
+    if (n) {
+        return {
+            test: function(e) {
+                return String(e) === t;
+            }
+        };
+    }
+    if (t === ".+") {
+        return {
+            test: function(e) {
+                return e !== "";
+            }
+        };
+    }
+    return new RegExp("^".concat(t, "$"));
+};
+var compileValue = function(e) {
+    if ((e.startsWith("**(") || e.startsWith("++(")) && e.endsWith(")")) {
+        return asRegex(e.slice(3, -1));
+    }
+    if (e.startsWith("[(") && e.endsWith(")]")) {
+        return asRegex(e.slice(2, -2));
+    }
+    if (e.startsWith("(") && e.endsWith(")")) {
+        return asRegex(e.slice(1, -1));
+    }
+    if (e.startsWith("[") && e.endsWith("]")) {
+        return parseValue(e.slice(1, -1));
+    }
+    return parseValue(e);
+};
+var Node = /*#__PURE__*/ function() {
+    "use strict";
+    function Node(e, t) {
+        _classCallCheck(this, Node);
+        t.nodes.push(this);
+        this.value = e;
+        this.ctx = t;
+        this.order = t.counter;
+        this.children = [];
+        this.match = false;
+        this.matches = false;
+        this.needles = [];
+        this.leafNeedles = [];
+        this.leafNeedlesExclude = [];
+        this.leafNeedlesMatch = [];
+        this.isArrayTarget = e.startsWith("[") && e.endsWith("]");
+        this.isSimpleStarRec = e === "**";
+        this.isSimplePlusRec = e === "++";
+        this.isSimpleRec = this.isSimpleStarRec || this.isSimplePlusRec;
+        this.isRegexStarRec = e.startsWith("**(") && e.endsWith(")");
+        this.isRegexPlusRec = e.startsWith("++(") && e.endsWith(")");
+        this.isStarRec = this.isSimpleStarRec || this.isRegexStarRec;
+        this.isPlusRec = this.isSimplePlusRec || this.isRegexPlusRec;
+        this.isRec = this.isStarRec || this.isPlusRec;
+        this.isAnyArrayTarget = e === "[*]";
+        this.isAnyObjTarget = e === "*";
+        if (this.isSimpleRec || this.isAnyObjTarget || this.isAnyArrayTarget) {
+            this.regex = null;
+        } else {
+            var r = t.regex;
+            if (!(e in r)) {
+                r[e] = compileValue(e);
+            }
+            this.regex = r[e];
+        }
+    }
+    _createClass(Node, [
+        {
+            key: "recMatch",
+            value: function recMatch(e) {
+                if (!this.isRec) {
+                    return false;
+                }
+                if (this.isSimpleRec) {
+                    return true;
+                }
+                return this.regex.test(e);
+            }
+        },
+        {
+            key: "typeMatch",
+            value: function typeMatch(e, t) {
+                if (this.isSimpleRec) {
+                    return true;
+                }
+                if (this.isAnyArrayTarget) {
+                    return t;
+                }
+                if (this.isAnyObjTarget) {
+                    return !t;
+                }
+                if (t !== this.isArrayTarget && !this.isRec) {
+                    return false;
+                }
+                return this.regex.test(e);
+            }
+        },
+        {
+            key: "add",
+            value: function add(e) {
+                this.children.push(e);
+            }
+        },
+        {
+            key: "get",
+            value: function get(e) {
+                return this.children.find(function(param) {
+                    var t = param.value;
+                    return t === e;
+                });
+            }
+        },
+        {
+            key: "markMatches",
+            value: function markMatches() {
+                this.matches = true;
+            }
+        },
+        {
+            key: "addNeedle",
+            value: function addNeedle(e) {
+                if (!this.needles.includes(e)) {
+                    this.needles.push(e);
+                }
+            }
+        },
+        {
+            key: "setRoots",
+            value: function setRoots(e) {
+                this.roots = e;
+            }
+        },
+        {
+            key: "finish",
+            value: function finish(e, t, r) {
+                this.addNeedle(e);
+                if (!this.leafNeedles.includes(e)) {
+                    this.leafNeedles.push(e);
+                }
+                var n = t ? this.leafNeedlesExclude : this.leafNeedlesMatch;
+                if (!n.includes(e)) {
+                    n.push(e);
+                }
+                this.match = !t;
+                this.matches = this.match;
+                this.index = r;
+            }
+        }
+    ]);
+    return Node;
+}();
+var applyNeedle = function(e, t, r, n) {
+    compiler_iterator(e, t, r, {
+        onAdd: function(e, r, s, i, l) {
+            e.addNeedle(t);
+            if (_instanceof(s, Ref)) {
+                if (s.left === true) {
+                    if (s.isStarRec) {
+                        s.setPointer(e);
+                    }
+                    s.setNode(new Node("*", n));
+                    n.links.push(e, s.node);
+                    l(s.node);
+                } else {
+                    s.target = "target" in i ? i.target : r.get(i.value);
+                    n.links.push(s.target, s.node);
+                    if (s.pointer !== null) {
+                        l(s.pointer);
+                        s.setPointer(null);
+                    }
+                    l(e);
+                }
+                return;
+            }
+            var a = s.isStarRec && s.value === (i === null || i === void 0 ? void 0 : i.value);
+            if (a && n.strict) {
+                throw new Error('Redundant Recursion: "'.concat(t, '"'));
+            }
+            if (!a) {
+                var _$t = e.get(s.value);
+                if (_$t === undefined) {
+                    _$t = new Node(s.value, n);
+                    e.add(_$t);
+                }
+                l(_$t);
+            } else {
+                s.target = e;
+            }
+            if (s.isStarRec) {
+                l(e);
+            }
+        },
+        onFin: function(e, r, s, i) {
+            if (n.strict && s.isSimpleStarRec) {
+                var _$e = r.children.filter(function(param) {
+                    var _$e = param.value;
+                    return ![
+                        "",
+                        "**"
+                    ].includes(_$e);
+                });
+                if (_$e.length !== 0) {
+                    throw new Error('Needle Target Invalidated: "'.concat(_$e[0].needles[0], '" by "').concat(t, '"'));
+                }
+            }
+            if (n.strict && e.leafNeedles.length !== 0) {
+                var _$r = formatNeedle(e.leafNeedles[0]);
+                var _$n = formatNeedle(t);
+                throw new Error('Redundant Needle Target: "'.concat(_$r, '" vs "').concat(_$n, '"'));
+            }
+            e.finish(t, i, n.counter);
+            n.counter += 1;
+        }
+    });
+};
+var finalizeTower = function(e, t) {
+    var _loop = function() {
+        var _$e = r.pop();
+        var _$t = r.pop();
+        var n = _$t.children;
+        _$t.children = _toConsumableArray(_$e.children.filter(function(e) {
+            return !n.includes(e);
+        })).concat(_toConsumableArray(n));
+    };
+    var r = t.links;
+    while(r.length !== 0)_loop();
+    if (t.useArraySelector === false) {
+        e.setRoots(e.children.filter(function(param) {
+            var _$e = param.isStarRec, _$t = param.value;
+            return _$e || _$t === "";
+        }));
+    }
+    var n = t.nodes;
+    while(n.length !== 0){
+        var _$e = n.pop();
+        var _$t = _$e.children;
+        _$t.reverse();
+        if (_$t.some(function(param) {
+            var _$e = param.matches;
+            return _$e;
+        })) {
+            _$e.markMatches();
+        }
+    }
+};
+var compile = function(e, t) {
+    t.counter = 0;
+    t.links = [];
+    t.nodes = [];
+    t.regex = Object.create(null);
+    var r = new Node("*", t);
+    for(var s = 0; s < e.length; s += 1){
+        var i = e[s];
+        var l = [
+            n.parse(i, t)
+        ];
+        applyNeedle(r, i, l, t);
+    }
+    finalizeTower(r, t);
+    return r;
+};
+var getUniques = function(e, t) {
+    var r = [];
+    for(var n = 0, s = e.length; n < s; n += 1){
+        var s1 = e[n][t];
+        for(var _$e = 0, _$t = s1.length; _$e < _$t; _$e += 1){
+            var _$t1 = s1[_$e];
+            if (!r.includes(_$t1)) {
+                r.push(_$t1);
+            }
+        }
+    }
+    return r;
+};
+var matchedBy = function(e) {
+    return getUniques(e, "leafNeedlesMatch");
+};
+var excludedBy = function(e) {
+    return getUniques(e, "leafNeedlesExclude");
+};
+var traversedBy = function(e) {
+    return getUniques(e, "needles");
+};
+var isLastLeafMatch = function(e) {
+    var t = -1;
+    var r = false;
+    var n = e.length;
+    while(n--){
+        var _n = e[n], s = _n.index, i = _n.match;
+        if (s > t) {
+            t = s;
+            r = i;
+        }
+    }
+    return r;
+};
+var formatPath = function(e, t) {
+    return t ? toPath(e) : _toConsumableArray(e);
+};
+var find_result = function(e, t) {
+    if (t.rtn === "context") {
+        return {
+            onMatch: function() {},
+            get: function() {
+                return e.context;
+            }
+        };
+    }
+    if (t.rtn === "bool") {
+        var e1 = false;
+        return {
+            onMatch: function() {
+                e1 = true;
+            },
+            get: function() {
+                return e1;
+            }
+        };
+    }
+    if (t.rtn === "count") {
+        var e2 = 0;
+        return {
+            onMatch: function() {
+                e2 += 1;
+            },
+            get: function() {
+                return e2;
+            }
+        };
+    }
+    if (t.rtn === "sum") {
+        var e3 = 0;
+        return {
+            onMatch: function(param) {
+                var _$t = param.value;
+                e3 += _$t;
+            },
+            get: function() {
+                return e3;
+            }
+        };
+    }
+    var r = [];
+    return {
+        onMatch: function() {
+            if (typeof t.rtn === "function") {
+                return function() {
+                    return r.push(t.rtn(e));
+                };
+            }
+            if (Array.isArray(t.rtn)) {
+                return function() {
+                    return r.push(t.rtn.map(function(t) {
+                        return e[t];
+                    }));
+                };
+            }
+            return function() {
+                return r.push(e[t.rtn]);
+            };
+        }(),
+        get: function() {
+            return t.abort ? r[0] : r;
+        }
+    };
+};
+var find = function(e, t, r) {
+    var _loop = function() {
+        a = s.pop();
+        o = s.pop();
+        c = s.pop();
+        u = s.pop();
+        var _$e = i.length - a;
+        for(var _$t = 0; _$t < _$e; _$t += 1){
+            l.pop();
+            i.pop();
+        }
+        if (_$e === -1) {
+            l.push(f);
+            i.push(o);
+            f = f[o];
+        } else if (o !== null) {
+            i[i.length - 1] = o;
+            f = l[l.length - 1][o];
+        } else {
+            f = n.haystack;
+        }
+        if (u) {
+            if (r.filterFn === undefined || r.filterFn(h) !== false) {
+                d.onMatch(h);
+                if (r.abort) {
+                    s.length = 0;
+                }
+            }
+            return "continue";
+        }
+        if (!c.some(function(param) {
+            var _$e = param.matches;
+            return _$e;
+        })) {
+            return "continue";
+        }
+        var p = r.useArraySelector === false && Array.isArray(f);
+        if (!p && isLastLeafMatch(c)) {
+            s.push(true, c, o, a);
+            u = true;
+        }
+        if ((r.breakFn === undefined || r.breakFn(h) !== true) && _instanceof(f, Object)) {
+            var _loop = function(i1, l1) {
+                var l = n1[i1];
+                var o = [];
+                if (p) {
+                    var _o;
+                    (_o = o).push.apply(_o, _toConsumableArray(c));
+                    if (a === 0) {
+                        var _o1;
+                        (_o1 = o).push.apply(_o1, _toConsumableArray(t.roots));
+                    }
+                } else {
+                    for(var _$t = 0, _$r = c.length; _$t !== _$r; _$t += 1){
+                        var _$r1 = c[_$t];
+                        if (_$r1.recMatch(l)) {
+                            o.push(_$r1);
+                        }
+                        var n = _$r1.children;
+                        var s1 = n.length;
+                        while(s1--){
+                            var _$t1 = n[s1];
+                            if (_$t1.typeMatch(l, _$e1)) {
+                                o.push(_$t1);
+                            }
+                        }
+                    }
+                }
+                if (r.orderByNeedles) {
+                    o.index = Buffer.from(o.map(function(param) {
+                        var _$e = param.order;
+                        return _$e;
+                    }).sort());
+                    var _$e = s.length - 3;
+                    var _$t2 = _$e - i1 * 4;
+                    while(_$e !== _$t2 && Buffer.compare(o.index, s[_$e].index) === 1){
+                        _$e -= 4;
+                    }
+                    s.splice(_$e + 3, 0, false, o, l, a + 1);
+                } else {
+                    s.push(false, o, l, a + 1);
+                }
+            };
+            var _$e1 = Array.isArray(f);
+            var n1 = _$e1 ? f.map(function(e, t) {
+                return t;
+            }).filter(function() {
+                return true;
+            }) : Object.keys(f);
+            if (!_$e1 && r.compareFn) {
+                n1.sort(r.compareFn(h));
+            }
+            if (!r.reverse) {
+                n1.reverse();
+            }
+            for(var i1 = 0, l1 = n1.length; i1 < l1; i1 += 1)_loop(i1, l1);
+        }
+    };
+    var n = {
+        haystack: e,
+        context: r.context
+    };
+    if (r.beforeFn !== undefined) {
+        var _$e = r.beforeFn(n);
+        if (_$e !== undefined) {
+            n.haystack = _$e;
+        }
+    }
+    var s = [
+        false,
+        [
+            t
+        ],
+        null,
+        0
+    ];
+    var i = [];
+    var l = [];
+    var a;
+    var o;
+    var c;
+    var u;
+    var f = n.haystack;
+    var h = {
+        getKey: function() {
+            var _$e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : r.joined;
+            return formatPath(i, _$e);
+        },
+        get key () {
+            return h.getKey();
+        },
+        getValue: function() {
+            return f;
+        },
+        get value () {
+            return h.getValue();
+        },
+        getEntry: function() {
+            var _$e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : r.joined;
+            return [
+                formatPath(i, _$e),
+                f
+            ];
+        },
+        get entry () {
+            return h.getEntry();
+        },
+        getIsMatch: function() {
+            return u;
+        },
+        get isMatch () {
+            return h.getIsMatch();
+        },
+        getMatchedBy: function() {
+            return matchedBy(c);
+        },
+        get matchedBy () {
+            return h.getMatchedBy();
+        },
+        getExcludedBy: function() {
+            return excludedBy(c);
+        },
+        get excludedBy () {
+            return h.getExcludedBy();
+        },
+        getTraversedBy: function() {
+            return traversedBy(c);
+        },
+        get traversedBy () {
+            return h.getTraversedBy();
+        },
+        getGproperty: function() {
+            return i[i.length - 2];
+        },
+        get gproperty () {
+            return h.getGproperty();
+        },
+        getProperty: function() {
+            return i[i.length - 1];
+        },
+        get property () {
+            return h.getProperty();
+        },
+        getGparent: function() {
+            return l[l.length - 2];
+        },
+        get gparent () {
+            return h.getGparent();
+        },
+        getParent: function() {
+            return l[l.length - 1];
+        },
+        get parent () {
+            return h.getParent();
+        },
+        getParents: function() {
+            return _toConsumableArray(l).reverse();
+        },
+        get parents () {
+            return h.getParents();
+        },
+        getIsCircular: function() {
+            return l.includes(f);
+        },
+        get isCircular () {
+            return h.getIsCircular();
+        },
+        getIsLeaf: function() {
+            return !_instanceof(f, Object);
+        },
+        get isLeaf () {
+            return h.getIsLeaf();
+        },
+        getDepth: function() {
+            return i.length;
+        },
+        get depth () {
+            return h.getDepth();
+        },
+        get result () {
+            return h.getResult();
+        },
+        context: n.context
+    };
+    var d = find_result(h, r);
+    h.getResult = function() {
+        return d.get();
+    };
+    if (r.useArraySelector || !Array.isArray(n.haystack)) {
+        var _$e1 = t.get("");
+        if (_$e1 !== undefined) {
+            s[1].push(_$e1);
+        }
+    }
+    do _loop();
+    while (s.length !== 0);
+    n.result = d.get();
+    if (r.afterFn !== undefined) {
+        var _$e2 = r.afterFn(n);
+        if (_$e2 !== undefined) {
+            n.result = _$e2;
+        }
+    }
+    return n.result;
+};
+var expect = function(e, t, r) {
+    assert(r.includes(_typeof(e[t])), function() {
+        return 'Option "'.concat(t, '" not one of [').concat(r.join(", "), "]");
+    });
+};
+var context = function(e) {
+    var t = _objectSpread({
+        filterFn: undefined,
+        breakFn: undefined,
+        beforeFn: undefined,
+        afterFn: undefined,
+        compareFn: undefined,
+        reverse: true,
+        orderByNeedles: false,
+        abort: false,
+        rtn: undefined,
+        joined: false,
+        useArraySelector: true,
+        strict: true
+    }, e);
+    assert(Object.keys(t).length === 12, "Unexpected Option provided");
+    expect(t, "filterFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(t, "breakFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(t, "beforeFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(t, "afterFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(t, "compareFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(t, "reverse", [
+        "boolean"
+    ]);
+    expect(t, "orderByNeedles", [
+        "boolean"
+    ]);
+    expect(t, "abort", [
+        "boolean"
+    ]);
+    assert(typeof t.rtn === "function" && t.rtn.length === 1 || [
+        undefined,
+        "context",
+        "key",
+        "value",
+        "entry",
+        "property",
+        "gproperty",
+        "parent",
+        "gparent",
+        "parents",
+        "isMatch",
+        "matchedBy",
+        "excludedBy",
+        "traversedBy",
+        "isCircular",
+        "isLeaf",
+        "depth",
+        "bool",
+        "count",
+        "sum"
+    ].includes(t.rtn) || Array.isArray(t.rtn) && t.rtn.every(function(e) {
+        return [
+            "key",
+            "value",
+            "entry",
+            "property",
+            "gproperty",
+            "parent",
+            "gparent",
+            "parents",
+            "isMatch",
+            "matchedBy",
+            "excludedBy",
+            "traversedBy",
+            "isCircular",
+            "isLeaf",
+            "depth"
+        ].includes(e);
+    }), 'Option "rtn" is malformed');
+    expect(t, "joined", [
+        "boolean"
+    ]);
+    expect(t, "useArraySelector", [
+        "boolean"
+    ]);
+    expect(t, "strict", [
+        "boolean"
+    ]);
+    return t;
+};
+var lib = function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    assert(Array.isArray(e), 'Argument "needles" expected to be Array');
+    assert(_instanceof(t, Object) && !Array.isArray(t), 'Argument "opts" expected to be Object');
+    if (e.length === 0) {
+        return function(e, t) {
+            return t === undefined ? [] : t;
+        };
+    }
+    var r = context(t);
+    var n = compile(e, r);
+    return function(e, t) {
+        return find(e, n, _objectSpreadProps(_objectSpread({
+            context: t
+        }, r), {
+            rtn: r.rtn || (t === undefined ? "key" : "context")
+        }));
+    };
+};
+var a = t.A;