@common.js/object-scan 20.0.4

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2022 Lukas Siemon
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @common.js/object-scan
+
+The [object-scan](https://www.npmjs.com/package/object-scan) package exported as CommonJS modules.
+
+Exported from [object-scan@20.0.4](https://www.npmjs.com/package/object-scan/v/20.0.4) using https://github.com/etienne-martin/common.js.

package/lib/core/compiler-iterator.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _iteratorJs = /*#__PURE__*/ _interopRequireDefault(require("../generic/iterator.js"));
+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 _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+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 _default = function(tower, needle, tree, param) {
+    var onAdd = param.onAdd, onFin = param.onFin;
+    var stack = [
+        [
+            [
+                tower,
+                null
+            ]
+        ]
+    ];
+    var excluded = false;
+    (0, _iteratorJs.default)(tree, function(type, v) {
+        if (type === "RM") {
+            if (v.excluded === true) {
+                excluded = false;
+            }
+            stack.length -= 2;
+        } else if (type === "ADD") {
+            if (v.excluded === true) {
+                if (excluded) {
+                    throw new Error('Redundant Exclusion: "'.concat(needle, '"'));
+                }
+                excluded = true;
+            }
+            var toAdd = [];
+            var vParent = stack[stack.length - 2];
+            stack[stack.length - 1].forEach(function(param) {
+                var _param = _slicedToArray(param, 2), cur = _param[0], parent = _param[1];
+                return onAdd(cur, parent, v, vParent, function(e) {
+                    return toAdd.push([
+                        e,
+                        cur
+                    ]);
+                });
+            });
+            stack.push(v, toAdd);
+        } else {
+            stack[stack.length - 1].filter(function(param) {
+                var _param = _slicedToArray(param, 1), cur = _param[0];
+                return cur !== tower;
+            }).forEach(function(param) {
+                var _param = _slicedToArray(param, 2), cur = _param[0], parent = _param[1];
+                return onFin(cur, parent, v, excluded);
+            });
+        }
+    });
+};

package/lib/core/compiler.js

@@ -0,0 +1,164 @@
+/* compile needles to hierarchical map object */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "compile", {
+    enumerable: true,
+    get: function() {
+        return compile;
+    }
+});
+var _parserJs = /*#__PURE__*/ _interopRequireDefault(require("./parser.js"));
+var _compilerIteratorJs = /*#__PURE__*/ _interopRequireDefault(require("./compiler-iterator.js"));
+var _parserRefJs = require("./parser-ref.js");
+var _nodeJs = require("./node.js");
+var _helperJs = require("../generic/helper.js");
+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 _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+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 _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+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 applyNeedle = function(tower, needle, tree, ctx) {
+    (0, _compilerIteratorJs.default)(tower, needle, tree, {
+        onAdd: function(cur, parent, v, vParent, next) {
+            cur.addNeedle(needle);
+            if (_instanceof(v, _parserRefJs.Ref)) {
+                if (v.left === true) {
+                    if (v.isStarRec) {
+                        v.setPointer(cur);
+                    }
+                    v.setNode(new _nodeJs.Node("*", ctx));
+                    ctx.links.push(cur, v.node);
+                    next(v.node);
+                } else {
+                    // eslint-disable-next-line no-param-reassign
+                    v.target = "target" in vParent ? vParent.target : parent.get(vParent.value);
+                    ctx.links.push(v.target, v.node);
+                    if (v.pointer !== null) {
+                        next(v.pointer);
+                        v.setPointer(null);
+                    }
+                    next(cur);
+                }
+                return;
+            }
+            var redundantRecursion = v.isStarRec && v.value === (vParent === null || vParent === void 0 ? void 0 : vParent.value);
+            if (redundantRecursion && ctx.strict) {
+                throw new Error('Redundant Recursion: "'.concat(needle, '"'));
+            }
+            if (!redundantRecursion) {
+                var node = cur.get(v.value);
+                if (node === undefined) {
+                    node = new _nodeJs.Node(v.value, ctx);
+                    cur.add(node);
+                }
+                next(node);
+            } else {
+                // eslint-disable-next-line no-param-reassign
+                v.target = cur;
+            }
+            if (v.isStarRec) {
+                next(cur);
+            }
+        },
+        onFin: function(cur, parent, v, excluded) {
+            if (ctx.strict && v.isSimpleStarRec) {
+                var unnecessary = parent.children.filter(function(param) {
+                    var value = param.value;
+                    return ![
+                        "",
+                        "**"
+                    ].includes(value);
+                });
+                if (unnecessary.length !== 0) {
+                    throw new Error('Needle Target Invalidated: "'.concat(unnecessary[0].needles[0], '" by "').concat(needle, '"'));
+                }
+            }
+            if (ctx.strict && cur.leafNeedles.length !== 0) {
+                var nLeft = (0, _helperJs.formatNeedle)(cur.leafNeedles[0]);
+                var nRight = (0, _helperJs.formatNeedle)(needle);
+                throw new Error('Redundant Needle Target: "'.concat(nLeft, '" vs "').concat(nRight, '"'));
+            }
+            cur.finish(needle, excluded, ctx.counter);
+            ctx.counter += 1;
+        }
+    });
+};
+var finalizeTower = function(tower, ctx) {
+    var _loop = function() {
+        var child = links.pop();
+        var parent = links.pop();
+        var children = parent.children;
+        parent.children = _toConsumableArray(child.children.filter(function(c) {
+            return !children.includes(c);
+        })).concat(_toConsumableArray(children));
+    };
+    var links = ctx.links;
+    while(links.length !== 0)_loop();
+    if (ctx.useArraySelector === false) {
+        tower.setRoots(tower.children.filter(function(param) {
+            var isStarRec = param.isStarRec, value = param.value;
+            return isStarRec || value === "";
+        }));
+    }
+    var nodes = ctx.nodes;
+    while(nodes.length !== 0){
+        var node = nodes.pop();
+        var children = node.children;
+        children.reverse();
+        if (children.some(function(param) {
+            var matches = param.matches;
+            return matches;
+        })) {
+            node.markMatches();
+        }
+    }
+};
+var compile = function(needles, ctx) {
+    ctx.counter = 0;
+    ctx.links = [];
+    ctx.nodes = [];
+    ctx.regex = Object.create(null);
+    var tower = new _nodeJs.Node("*", ctx);
+    for(var idx = 0; idx < needles.length; idx += 1){
+        var needle = needles[idx];
+        var tree = [
+            _parserJs.default.parse(needle, ctx)
+        ];
+        applyNeedle(tower, needle, tree, ctx);
+    }
+    finalizeTower(tower, ctx);
+    return tower;
+};

package/lib/core/context.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _assertJs = /*#__PURE__*/ _interopRequireDefault(require("../generic/assert.js"));
+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 _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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;
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+var expect = function(opts, option, types) {
+    (0, _assertJs.default)(types.includes(_typeof(opts[option])), function() {
+        return 'Option "'.concat(option, '" not one of [').concat(types.join(", "), "]");
+    });
+};
+var _default = function(opts) {
+    var ctx = _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
+    }, opts);
+    (0, _assertJs.default)(Object.keys(ctx).length === 12, "Unexpected Option provided");
+    expect(ctx, "filterFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(ctx, "breakFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(ctx, "beforeFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(ctx, "afterFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(ctx, "compareFn", [
+        "function",
+        "undefined"
+    ]);
+    expect(ctx, "reverse", [
+        "boolean"
+    ]);
+    expect(ctx, "orderByNeedles", [
+        "boolean"
+    ]);
+    expect(ctx, "abort", [
+        "boolean"
+    ]);
+    (0, _assertJs.default)(typeof ctx.rtn === "function" && ctx.rtn.length === 1 || [
+        undefined,
+        "context",
+        "key",
+        "value",
+        "entry",
+        "property",
+        "gproperty",
+        "parent",
+        "gparent",
+        "parents",
+        "isMatch",
+        "matchedBy",
+        "excludedBy",
+        "traversedBy",
+        "isCircular",
+        "isLeaf",
+        "depth",
+        "bool",
+        "count",
+        "sum"
+    ].includes(ctx.rtn) || Array.isArray(ctx.rtn) && ctx.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(ctx, "joined", [
+        "boolean"
+    ]);
+    expect(ctx, "useArraySelector", [
+        "boolean"
+    ]);
+    expect(ctx, "strict", [
+        "boolean"
+    ]);
+    return ctx;
+};

package/lib/core/find-result.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _default = function(kwargs, ctx) {
+    if (ctx.rtn === "context") {
+        return {
+            onMatch: function() {},
+            get: function() {
+                return kwargs.context;
+            }
+        };
+    }
+    if (ctx.rtn === "bool") {
+        var result = false;
+        return {
+            onMatch: function() {
+                result = true;
+            },
+            get: function() {
+                return result;
+            }
+        };
+    }
+    if (ctx.rtn === "count") {
+        var result1 = 0;
+        return {
+            onMatch: function() {
+                result1 += 1;
+            },
+            get: function() {
+                return result1;
+            }
+        };
+    }
+    if (ctx.rtn === "sum") {
+        var result2 = 0;
+        return {
+            onMatch: function(param) {
+                var value = param.value;
+                result2 += value;
+            },
+            get: function() {
+                return result2;
+            }
+        };
+    }
+    var result3 = [];
+    return {
+        onMatch: function() {
+            if (typeof ctx.rtn === "function") {
+                return function() {
+                    return result3.push(ctx.rtn(kwargs));
+                };
+            }
+            if (Array.isArray(ctx.rtn)) {
+                return function() {
+                    return result3.push(ctx.rtn.map(function(rtn) {
+                        return kwargs[rtn];
+                    }));
+                };
+            }
+            return function() {
+                return result3.push(kwargs[ctx.rtn]);
+            };
+        }(),
+        get: function() {
+            return ctx.abort ? result3[0] : result3;
+        }
+    };
+};

package/lib/core/find-util.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    matchedBy: function() {
+        return matchedBy;
+    },
+    excludedBy: function() {
+        return excludedBy;
+    },
+    traversedBy: function() {
+        return traversedBy;
+    },
+    isLastLeafMatch: function() {
+        return isLastLeafMatch;
+    },
+    formatPath: function() {
+        return formatPath;
+    }
+});
+var _helperJs = require("../generic/helper.js");
+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 _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+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 _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+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 getUniques = function(searches, key) {
+    var result = [];
+    for(var i = 0, lenS = searches.length; i < lenS; i += 1){
+        var needles = searches[i][key];
+        for(var j = 0, lenN = needles.length; j < lenN; j += 1){
+            var needle = needles[j];
+            if (!result.includes(needle)) {
+                result.push(needle);
+            }
+        }
+    }
+    return result;
+};
+var matchedBy = function(searches) {
+    return getUniques(searches, "leafNeedlesMatch");
+};
+var excludedBy = function(searches) {
+    return getUniques(searches, "leafNeedlesExclude");
+};
+var traversedBy = function(searches) {
+    return getUniques(searches, "needles");
+};
+var isLastLeafMatch = function(searches) {
+    var maxLeafIndex = -1;
+    var maxLeafMatch = false;
+    var idx = searches.length;
+    // eslint-disable-next-line no-plusplus
+    while(idx--){
+        var _idx = searches[idx], index = _idx.index, match = _idx.match;
+        if (index > maxLeafIndex) {
+            maxLeafIndex = index;
+            maxLeafMatch = match;
+        }
+    }
+    return maxLeafMatch;
+};
+var formatPath = function(input, joined) {
+    return joined ? (0, _helperJs.toPath)(input) : _toConsumableArray(input);
+};