@common.js/object-scan 20.0.4

package/lib/core/parser-result.js

@@ -0,0 +1,218 @@
+"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"));
+var _parserValueJs = require("./parser-value.js");
+var _parserRefJs = require("./parser-ref.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 _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 _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 _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+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 throwError = function(msg, input) {
+    var context = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    throw new Error(Object.entries(context).reduce(function(p, param) {
+        var _param = _slicedToArray(param, 2), k = _param[0], v = _param[1];
+        return "".concat(p, ", ").concat(k, " ").concat(v);
+    }, "".concat(msg, ": ").concat(input)));
+};
+var getSimple = function(arr) {
+    return arr.length === 1 ? arr[0] : arr;
+};
+var arraySelectorRegex = /^[?*+\d]+$/;
+var _default = function(input) {
+    var cResult = [];
+    cResult.or = true;
+    var inArray = false;
+    var excludeNext = false;
+    var cursor = 0;
+    // group related
+    var parentStack = [];
+    var newChild = function(asOr) {
+        if (cResult.excluded === true) {
+            (0, _assertJs.default)(excludeNext === false);
+            excludeNext = true;
+        }
+        parentStack.push(cResult);
+        cResult = [];
+        cResult.or = asOr;
+    };
+    var finishChild = function() {
+        var parent = parentStack.pop();
+        var child = getSimple(cResult);
+        if (parent.or === true && child.or === true) {
+            var _parent;
+            (_parent = parent).push.apply(_parent, _toConsumableArray(child));
+        } else {
+            parent.push(child);
+        }
+        cResult = parent;
+    };
+    newChild(false);
+    return {
+        setInArray: function(flag, idx) {
+            if (inArray === flag) {
+                throwError(inArray ? "Bad Array Start" : "Bad Array Terminator", input, {
+                    char: idx
+                });
+            }
+            inArray = flag;
+        },
+        finishElement: function(idx, err, fins) {
+            var ref = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {}, _finReq = ref.finReq, finReq = _finReq === void 0 ? false : _finReq, _group = ref.group, group = _group === void 0 ? false : _group;
+            var isFinished = cursor === idx;
+            if (isFinished) {
+                if (!fins.includes(input[idx - 1] || null)) {
+                    throwError(err, input, {
+                        char: idx
+                    });
+                }
+                cursor += 1;
+            } else {
+                if (finReq) {
+                    throwError(err, input, {
+                        char: idx
+                    });
+                }
+                var ele = input.slice(cursor, idx);
+                if (group && ![
+                    "**",
+                    "++"
+                ].includes(ele)) {
+                    throwError("Bad Group Start", input, {
+                        char: idx
+                    });
+                }
+                if (inArray && !(arraySelectorRegex.test(ele) || ele.startsWith("(") && ele.endsWith(")"))) {
+                    throwError("Bad Array Selector", input, {
+                        selector: ele
+                    });
+                }
+                if (group) {
+                    cResult.push(new _parserRefJs.Ref(ele));
+                } else {
+                    cResult.push(new _parserValueJs.Value(inArray ? "[".concat(ele, "]") : ele, excludeNext));
+                    excludeNext = false;
+                }
+                cursor = idx + 1;
+            }
+        },
+        startExclusion: function(idx) {
+            if (excludeNext !== false) {
+                throwError("Redundant Exclusion", input, {
+                    char: idx
+                });
+            }
+            excludeNext = true;
+        },
+        startGroup: function() {
+            newChild(true);
+            if (excludeNext) {
+                cResult.excluded = true;
+                excludeNext = false;
+            }
+            newChild(false);
+        },
+        newGroupElement: function() {
+            finishChild();
+            newChild(false);
+        },
+        finishGroup: function(idx) {
+            if (parentStack.length < 2) {
+                throwError("Unexpected Group Terminator", input, {
+                    char: idx
+                });
+            }
+            finishChild();
+            finishChild();
+            (0, _assertJs.default)(Array.isArray(cResult));
+            var refMaybe = cResult[cResult.length - 2];
+            if (_instanceof(refMaybe, _parserRefJs.Ref) && refMaybe.left === true) {
+                cResult.push(refMaybe.link);
+            }
+        },
+        finalizeResult: function() {
+            finishChild();
+            (0, _assertJs.default)(excludeNext === false);
+            if (parentStack.length !== 0) {
+                throwError("Non Terminated Group", input);
+            }
+            if (inArray) {
+                throwError("Non Terminated Array", input);
+            }
+            return getSimple(cResult);
+        }
+    };
+};

package/lib/core/parser-value.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Value", {
+    enumerable: true,
+    get: function() {
+        return Value;
+    }
+});
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+var Value = function Value(value, excluded) {
+    "use strict";
+    _classCallCheck(this, Value);
+    this.value = value;
+    this.excluded = excluded;
+    this.isSimpleStarRec = value === "**";
+    this.isRegexStarRec = value.startsWith("**(") && value.endsWith(")");
+    this.isStarRec = this.isSimpleStarRec || this.isRegexStarRec;
+};

package/lib/core/parser.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _parserValueJs = require("./parser-value.js");
+var _parserResultJs = /*#__PURE__*/ _interopRequireDefault(require("./parser-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 _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 throwError = function(msg, input) {
+    var context = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    throw new Error(Object.entries(context).reduce(function(p, param) {
+        var _param = _slicedToArray(param, 2), k = _param[0], v = _param[1];
+        return "".concat(p, ", ").concat(k, " ").concat(v);
+    }, "".concat(msg, ": ").concat(input)));
+};
+var parse = function(input, ctx) {
+    if (input === "") {
+        return new _parserValueJs.Value("", false);
+    }
+    if (Array.isArray(input)) {
+        if (input.length === 0) {
+            return new _parserValueJs.Value("", false);
+        }
+        return input.map(function(e, idx) {
+            if (typeof e === "number") {
+                if (!ctx.useArraySelector) {
+                    throwError("Forbidden Array Selector", JSON.stringify(input), {
+                        idx: idx
+                    });
+                }
+                return new _parserValueJs.Value("[".concat(e, "]"), false);
+            }
+            return new _parserValueJs.Value(e.replaceAll("\\", "\\\\"), false);
+        });
+    }
+    var result = (0, _parserResultJs.default)(input);
+    var inputLength = input.length;
+    var escaped = false;
+    var bracketDepth = 0;
+    for(var idx = 0; idx < inputLength; idx += 1){
+        var char = input[idx];
+        if (escaped === false) {
+            if (bracketDepth === 0) {
+                switch(char){
+                    case ".":
+                        result.finishElement(idx, "Bad Path Separator", [
+                            "]",
+                            "}"
+                        ]);
+                        break;
+                    case "[":
+                        if (!ctx.useArraySelector) {
+                            throwError("Forbidden Array Selector", input, {
+                                char: idx
+                            });
+                        }
+                        result.finishElement(idx, "Bad Array Start", [
+                            null,
+                            "!",
+                            "{",
+                            ",",
+                            "}",
+                            "]"
+                        ]);
+                        result.setInArray(true, idx);
+                        break;
+                    case "]":
+                        result.finishElement(idx, "Bad Array Terminator", [
+                            "}"
+                        ]);
+                        result.setInArray(false, idx);
+                        break;
+                    case "{":
+                        result.finishElement(idx, "Bad Group Start", [
+                            null,
+                            "!",
+                            ".",
+                            "[",
+                            "{",
+                            ","
+                        ], {
+                            group: true
+                        });
+                        result.startGroup();
+                        break;
+                    case ",":
+                        result.finishElement(idx, "Bad Group Separator", [
+                            "]",
+                            "}"
+                        ]);
+                        result.newGroupElement();
+                        break;
+                    case "}":
+                        result.finishElement(idx, "Bad Group Terminator", [
+                            "]",
+                            "}"
+                        ]);
+                        result.finishGroup(idx);
+                        break;
+                    case "!":
+                        result.finishElement(idx, "Bad Exclusion", [
+                            null,
+                            ".",
+                            ",",
+                            "{",
+                            "["
+                        ], {
+                            finReq: true
+                        });
+                        result.startExclusion(idx);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            switch(char){
+                case "(":
+                    bracketDepth += 1;
+                    break;
+                case ")":
+                    if (bracketDepth === 0) {
+                        throwError("Unexpected Parentheses", input, {
+                            char: idx
+                        });
+                    }
+                    bracketDepth -= 1;
+                    break;
+                default:
+                    break;
+            }
+        }
+        escaped = char === "\\" ? !escaped : false;
+    }
+    if (escaped !== false) {
+        throwError("Dangling Escape", input, {
+            char: inputLength - 1
+        });
+    }
+    if (bracketDepth !== 0) {
+        throwError("Unterminated Parentheses", input);
+    }
+    result.finishElement(inputLength, "Bad Terminator", [
+        "]",
+        "}"
+    ]);
+    return result.finalizeResult();
+};
+var _default = {
+    parse: parse
+};

package/lib/generic/assert.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _default = function(condition) {
+    var message = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "Internal Logic Error";
+    if (!condition) {
+        throw new Error(typeof message === "function" ? message() : message);
+    }
+};

package/lib/generic/helper.js

@@ -0,0 +1,85 @@
+"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, {
+    escape: function() {
+        return escape;
+    },
+    asRegex: function() {
+        return asRegex;
+    },
+    toPath: function() {
+        return toPath;
+    },
+    formatNeedle: function() {
+        return formatNeedle;
+    }
+});
+var specialChars = /[?!,.*+[\](){}\\]/g;
+var escape = function(input) {
+    return input.replace(specialChars, "\\$&");
+};
+var regexMetaChars = /[\\^$*+?.()|[\]{}]/;
+var asRegex = function(regexStr) {
+    var hasStart = regexStr.charCodeAt(0) === 94; // '^' is char code 94
+    var hasEnd = regexStr.charCodeAt(regexStr.length - 1) === 36; // '$' is char code 36
+    var content = regexStr.slice(hasStart ? 1 : 0, hasEnd ? -1 : undefined);
+    if (regexMetaChars.test(content)) {
+        try {
+            return new RegExp(regexStr);
+        } catch (e) {
+            throw new Error('Invalid Regex: "'.concat(regexStr, '"'));
+        }
+    }
+    if (hasStart && hasEnd) {
+        return {
+            test: function(v) {
+                return String(v) === content;
+            }
+        };
+    }
+    if (hasStart) {
+        return {
+            test: function(v) {
+                return String(v).startsWith(content);
+            }
+        };
+    }
+    if (hasEnd) {
+        return {
+            test: function(v) {
+                return String(v).endsWith(content);
+            }
+        };
+    }
+    return {
+        test: function(v) {
+            return String(v).includes(content);
+        }
+    };
+};
+var toPath = function(input) {
+    var result = "";
+    for(var i = 0, len = input.length; i < len; i += 1){
+        var char = input[i];
+        if (typeof char === "number") {
+            result += "[".concat(char, "]");
+        } else {
+            if (result.length > 0) {
+                result += ".";
+            }
+            result += escape(char);
+        }
+    }
+    return result;
+};
+var formatNeedle = function(n) {
+    return Array.isArray(n) ? toPath(n) : n;
+};

package/lib/generic/iterator.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+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 _default = function(tree, cb) {
+    var stack = [
+        tree
+    ];
+    var parent = [
+        null
+    ];
+    var count = [];
+    var depth = [];
+    var idx = 0;
+    var inc = true;
+    while(idx !== -1){
+        var e = stack[idx];
+        if (Array.isArray(e)) {
+            if (e.or !== true) {
+                var _stack, _parent;
+                (_stack = stack).splice.apply(_stack, [
+                    idx,
+                    1
+                ].concat(_toConsumableArray(e)));
+                (_parent = parent).splice.apply(_parent, [
+                    idx,
+                    1
+                ].concat(_toConsumableArray(new Array(e.length).fill(parent[idx]))));
+                if (parent[idx] !== null) {
+                    depth[parent[idx]] += e.length - 1;
+                }
+            } else {
+                if (count[idx] === undefined) {
+                    count[idx] = 0;
+                    depth[idx] = 0;
+                } else if (depth[idx] !== 0) {
+                    stack.splice(idx + 1, depth[idx]);
+                    parent.splice(idx + 1, depth[idx]);
+                    depth[idx] = 0;
+                }
+                if (count[idx] < e.length) {
+                    stack.splice(idx + 1, 0, e[count[idx]]);
+                    parent.splice(idx + 1, 0, idx);
+                    count[idx] = (count[idx] || 0) + 1;
+                    depth[idx] += 1;
+                    inc = true;
+                    idx += 1;
+                } else {
+                    count[idx] = 0;
+                    idx -= 1;
+                }
+            }
+        } else if (inc === true) {
+            cb("ADD", e);
+            if (idx === stack.length - 1) {
+                cb("FIN", e);
+                inc = false;
+            } else {
+                idx += 1;
+            }
+        } else {
+            cb("RM", e);
+            idx -= 1;
+        }
+    }
+};