@common.js/object-scan 20.0.4

package/lib/core/find.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _findUtilJs = require("./find-util.js");
+var _findResultJs = /*#__PURE__*/ _interopRequireDefault(require("./find-result.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 _default = function(haystack_, search_, ctx) {
+    var _loop = function() {
+        depth = stack.pop();
+        segment = stack.pop();
+        searches = stack.pop();
+        isMatch = stack.pop();
+        var diff = path.length - depth;
+        for(var idx = 0; idx < diff; idx += 1){
+            parents.pop();
+            path.pop();
+        }
+        if (diff === -1) {
+            parents.push(haystack);
+            path.push(segment);
+            haystack = haystack[segment];
+        } else if (segment !== null) {
+            path[path.length - 1] = segment;
+            haystack = parents[parents.length - 1][segment];
+        } else {
+            haystack = state.haystack;
+        }
+        if (isMatch) {
+            if (ctx.filterFn === undefined || ctx.filterFn(kwargs) !== false) {
+                result.onMatch(kwargs);
+                if (ctx.abort) {
+                    stack.length = 0;
+                }
+            }
+            // eslint-disable-next-line no-continue
+            return "continue";
+        }
+        if (!searches.some(function(param) {
+            var matches = param.matches;
+            return matches;
+        })) {
+            // eslint-disable-next-line no-continue
+            return "continue";
+        }
+        var autoTraverseArray = ctx.useArraySelector === false && Array.isArray(haystack);
+        if (!autoTraverseArray && (0, _findUtilJs.isLastLeafMatch)(searches)) {
+            stack.push(true, searches, segment, depth);
+            isMatch = true;
+        }
+        if ((ctx.breakFn === undefined || ctx.breakFn(kwargs) !== true) && _instanceof(haystack, Object)) {
+            var _loop = function(kIdx, kLen) {
+                var key = keys[kIdx];
+                var searchesOut = [];
+                if (autoTraverseArray) {
+                    var _searchesOut;
+                    (_searchesOut = searchesOut).push.apply(_searchesOut, _toConsumableArray(searches));
+                    if (depth === 0) {
+                        var _searchesOut1;
+                        (_searchesOut1 = searchesOut).push.apply(_searchesOut1, _toConsumableArray(search_.roots));
+                    }
+                } else {
+                    for(var sIdx = 0, sLen = searches.length; sIdx !== sLen; sIdx += 1){
+                        var search = searches[sIdx];
+                        if (search.recMatch(key)) {
+                            searchesOut.push(search);
+                        }
+                        var children = search.children;
+                        var eIdx = children.length;
+                        // eslint-disable-next-line no-plusplus
+                        while(eIdx--){
+                            var child = children[eIdx];
+                            if (child.typeMatch(key, isArray)) {
+                                searchesOut.push(child);
+                            }
+                        }
+                    }
+                }
+                if (ctx.orderByNeedles) {
+                    searchesOut.index = Buffer.from(searchesOut.map(function(param) {
+                        var order = param.order;
+                        return order;
+                    }).sort());
+                    var checkIdx = stack.length - 3;
+                    var checkIdxMin = checkIdx - kIdx * 4;
+                    while(checkIdx !== checkIdxMin && Buffer.compare(searchesOut.index, stack[checkIdx].index) === 1){
+                        checkIdx -= 4;
+                    }
+                    stack.splice(checkIdx + 3, 0, false, searchesOut, key, depth + 1);
+                } else {
+                    stack.push(false, searchesOut, key, depth + 1);
+                }
+            };
+            var isArray = Array.isArray(haystack);
+            var keys = isArray ? haystack.map(function(_, i) {
+                return i;
+            }).filter(function() {
+                return true;
+            }) : Object.keys(haystack);
+            if (!isArray && ctx.compareFn) {
+                keys.sort(ctx.compareFn(kwargs));
+            }
+            if (!ctx.reverse) {
+                keys.reverse();
+            }
+            for(var kIdx = 0, kLen = keys.length; kIdx < kLen; kIdx += 1)_loop(kIdx, kLen);
+        }
+    };
+    var state = {
+        haystack: haystack_,
+        context: ctx.context
+    };
+    if (ctx.beforeFn !== undefined) {
+        var r = ctx.beforeFn(state);
+        if (r !== undefined) {
+            state.haystack = r;
+        }
+    }
+    var stack = [
+        false,
+        [
+            search_
+        ],
+        null,
+        0
+    ];
+    var path = [];
+    var parents = [];
+    var depth;
+    var segment;
+    var searches;
+    var isMatch;
+    var haystack = state.haystack;
+    var kwargs = {
+        getKey: function() {
+            var joined = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : ctx.joined;
+            return (0, _findUtilJs.formatPath)(path, joined);
+        },
+        get key () {
+            return kwargs.getKey();
+        },
+        getValue: function() {
+            return haystack;
+        },
+        get value () {
+            return kwargs.getValue();
+        },
+        getEntry: function() {
+            var joined = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : ctx.joined;
+            return [
+                (0, _findUtilJs.formatPath)(path, joined),
+                haystack
+            ];
+        },
+        get entry () {
+            return kwargs.getEntry();
+        },
+        getIsMatch: function() {
+            return isMatch;
+        },
+        get isMatch () {
+            return kwargs.getIsMatch();
+        },
+        getMatchedBy: function() {
+            return (0, _findUtilJs.matchedBy)(searches);
+        },
+        get matchedBy () {
+            return kwargs.getMatchedBy();
+        },
+        getExcludedBy: function() {
+            return (0, _findUtilJs.excludedBy)(searches);
+        },
+        get excludedBy () {
+            return kwargs.getExcludedBy();
+        },
+        getTraversedBy: function() {
+            return (0, _findUtilJs.traversedBy)(searches);
+        },
+        get traversedBy () {
+            return kwargs.getTraversedBy();
+        },
+        getGproperty: function() {
+            return path[path.length - 2];
+        },
+        get gproperty () {
+            return kwargs.getGproperty();
+        },
+        getProperty: function() {
+            return path[path.length - 1];
+        },
+        get property () {
+            return kwargs.getProperty();
+        },
+        getGparent: function() {
+            return parents[parents.length - 2];
+        },
+        get gparent () {
+            return kwargs.getGparent();
+        },
+        getParent: function() {
+            return parents[parents.length - 1];
+        },
+        get parent () {
+            return kwargs.getParent();
+        },
+        getParents: function() {
+            return _toConsumableArray(parents).reverse();
+        },
+        get parents () {
+            return kwargs.getParents();
+        },
+        getIsCircular: function() {
+            return parents.includes(haystack);
+        },
+        get isCircular () {
+            return kwargs.getIsCircular();
+        },
+        getIsLeaf: function() {
+            return !_instanceof(haystack, Object);
+        },
+        get isLeaf () {
+            return kwargs.getIsLeaf();
+        },
+        getDepth: function() {
+            return path.length;
+        },
+        get depth () {
+            return kwargs.getDepth();
+        },
+        /* getResult: <defined-below> */ get result () {
+            return kwargs.getResult();
+        },
+        context: state.context
+    };
+    var result = (0, _findResultJs.default)(kwargs, ctx);
+    kwargs.getResult = function() {
+        return result.get();
+    };
+    if (ctx.useArraySelector || !Array.isArray(state.haystack)) {
+        var child = search_.get("");
+        if (child !== undefined) {
+            stack[1].push(child);
+        }
+    }
+    do _loop();
+    while (stack.length !== 0);
+    state.result = result.get();
+    if (ctx.afterFn !== undefined) {
+        var r1 = ctx.afterFn(state);
+        if (r1 !== undefined) {
+            state.result = r1;
+        }
+    }
+    return state.result;
+};

package/lib/core/node-util.js

@@ -0,0 +1,94 @@
+"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, {
+    parseValue: function() {
+        return parseValue;
+    },
+    compileValue: function() {
+        return compileValue;
+    }
+});
+var _helperJs = require("../generic/helper.js");
+var charsToEscape = [
+    "-",
+    "/",
+    "\\",
+    "^",
+    "$",
+    "*",
+    "+",
+    "?",
+    ".",
+    "(",
+    ")",
+    "|",
+    "[",
+    "]",
+    "{",
+    "}"
+];
+var parseValue = function(value) {
+    var regex = "";
+    var escaped = false;
+    var simple = true;
+    for(var idx = 0; idx < value.length; idx += 1){
+        var char = value[idx];
+        if (!escaped && char === "\\") {
+            escaped = true;
+        } else if (!escaped && char === "*") {
+            simple = false;
+            regex += ".*";
+        } else if (!escaped && char === "+") {
+            simple = false;
+            regex += ".+";
+        } else if (!escaped && char === "?") {
+            simple = false;
+            regex += ".";
+        } else {
+            if (charsToEscape.includes(char)) {
+                simple = false;
+                regex += "\\";
+            }
+            regex += char;
+            escaped = false;
+        }
+    }
+    if (simple) {
+        return {
+            test: function(v) {
+                return String(v) === regex;
+            }
+        };
+    }
+    if (regex === ".+") {
+        return {
+            test: function(v) {
+                return v !== "";
+            }
+        };
+    }
+    return new RegExp("^".concat(regex, "$"));
+};
+var compileValue = function(value) {
+    if ((value.startsWith("**(") || value.startsWith("++(")) && value.endsWith(")")) {
+        return (0, _helperJs.asRegex)(value.slice(3, -1));
+    }
+    if (value.startsWith("[(") && value.endsWith(")]")) {
+        return (0, _helperJs.asRegex)(value.slice(2, -2));
+    }
+    if (value.startsWith("(") && value.endsWith(")")) {
+        return (0, _helperJs.asRegex)(value.slice(1, -1));
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+        return parseValue(value.slice(1, -1));
+    }
+    return parseValue(value);
+};

package/lib/core/node.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Node", {
+    enumerable: true,
+    get: function() {
+        return Node;
+    }
+});
+var _nodeUtilJs = require("./node-util.js");
+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;
+}
+var Node = /*#__PURE__*/ function() {
+    "use strict";
+    function Node(value, ctx) {
+        _classCallCheck(this, Node);
+        ctx.nodes.push(this);
+        this.value = value;
+        this.ctx = ctx;
+        this.order = ctx.counter;
+        this.children = [];
+        this.match = false;
+        this.matches = false;
+        this.needles = [];
+        this.leafNeedles = [];
+        this.leafNeedlesExclude = [];
+        this.leafNeedlesMatch = [];
+        this.isArrayTarget = value.startsWith("[") && value.endsWith("]");
+        this.isSimpleStarRec = value === "**";
+        this.isSimplePlusRec = value === "++";
+        this.isSimpleRec = this.isSimpleStarRec || this.isSimplePlusRec;
+        this.isRegexStarRec = value.startsWith("**(") && value.endsWith(")");
+        this.isRegexPlusRec = value.startsWith("++(") && value.endsWith(")");
+        this.isStarRec = this.isSimpleStarRec || this.isRegexStarRec;
+        this.isPlusRec = this.isSimplePlusRec || this.isRegexPlusRec;
+        this.isRec = this.isStarRec || this.isPlusRec;
+        this.isAnyArrayTarget = value === "[*]";
+        this.isAnyObjTarget = value === "*";
+        if (this.isSimpleRec || this.isAnyObjTarget || this.isAnyArrayTarget) {
+            this.regex = null;
+        } else {
+            var regex = ctx.regex;
+            if (!(value in regex)) {
+                regex[value] = (0, _nodeUtilJs.compileValue)(value);
+            }
+            this.regex = regex[value];
+        }
+    }
+    _createClass(Node, [
+        {
+            key: "recMatch",
+            value: function recMatch(key) {
+                if (!this.isRec) {
+                    return false;
+                }
+                if (this.isSimpleRec) {
+                    return true;
+                }
+                return this.regex.test(key);
+            }
+        },
+        {
+            key: "typeMatch",
+            value: function typeMatch(key, isArray) {
+                if (this.isSimpleRec) {
+                    return true;
+                }
+                if (this.isAnyArrayTarget) {
+                    return isArray;
+                }
+                if (this.isAnyObjTarget) {
+                    return !isArray;
+                }
+                if (isArray !== this.isArrayTarget && !this.isRec) {
+                    return false;
+                }
+                return this.regex.test(key);
+            }
+        },
+        {
+            key: "add",
+            value: function add(v) {
+                this.children.push(v);
+            }
+        },
+        {
+            key: "get",
+            value: function get(k) {
+                return this.children.find(function(param) {
+                    var value = param.value;
+                    return value === k;
+                });
+            }
+        },
+        {
+            key: "markMatches",
+            value: function markMatches() {
+                this.matches = true;
+            }
+        },
+        {
+            key: "addNeedle",
+            value: function addNeedle(needle) {
+                if (!this.needles.includes(needle)) {
+                    this.needles.push(needle);
+                }
+            }
+        },
+        {
+            key: "setRoots",
+            value: function setRoots(roots) {
+                this.roots = roots;
+            }
+        },
+        {
+            key: "finish",
+            value: function finish(needle, excluded, index) {
+                this.addNeedle(needle);
+                if (!this.leafNeedles.includes(needle)) {
+                    this.leafNeedles.push(needle);
+                }
+                var target = excluded ? this.leafNeedlesExclude : this.leafNeedlesMatch;
+                if (!target.includes(needle)) {
+                    target.push(needle);
+                }
+                this.match = !excluded;
+                this.matches = this.match;
+                this.index = index;
+            }
+        }
+    ]);
+    return Node;
+}();

package/lib/core/parser-ref.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Ref", {
+    enumerable: true,
+    get: function() {
+        return Ref;
+    }
+});
+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;
+}
+var Ref = /*#__PURE__*/ function() {
+    "use strict";
+    function Ref(type) {
+        var link = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+        _classCallCheck(this, Ref);
+        this.left = link === null;
+        this.link = link === null ? new Ref(type, this) : link;
+        this.type = type;
+        this.isStarRec = this.type === "**";
+        this.node = null;
+        this.pointer = null;
+    }
+    _createClass(Ref, [
+        {
+            key: "setPointer",
+            value: function setPointer(pointer) {
+                this.pointer = pointer;
+                this.link.pointer = pointer;
+            }
+        },
+        {
+            key: "setNode",
+            value: function setNode(node) {
+                this.node = node;
+                this.link.node = node;
+            }
+        }
+    ]);
+    return Ref;
+}();