@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/dist/commonjs/brace-expressions.js

@@ -0,0 +1,121 @@
+import { __exports as braceExpressions } from "../../../../../../../_virtual/brace-expressions.js";
+var hasRequiredBraceExpressions;
+function requireBraceExpressions() {
+  if (hasRequiredBraceExpressions) return braceExpressions;
+  hasRequiredBraceExpressions = 1;
+  Object.defineProperty(braceExpressions, "__esModule", { value: true });
+  braceExpressions.parseClass = void 0;
+  const posixClasses = {
+    "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+    "[:alpha:]": ["\\p{L}\\p{Nl}", true],
+    "[:ascii:]": ["\\x00-\\x7f", false],
+    "[:blank:]": ["\\p{Zs}\\t", true],
+    "[:cntrl:]": ["\\p{Cc}", true],
+    "[:digit:]": ["\\p{Nd}", true],
+    "[:graph:]": ["\\p{Z}\\p{C}", true, true],
+    "[:lower:]": ["\\p{Ll}", true],
+    "[:print:]": ["\\p{C}", true],
+    "[:punct:]": ["\\p{P}", true],
+    "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+    "[:upper:]": ["\\p{Lu}", true],
+    "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+    "[:xdigit:]": ["A-Fa-f0-9", false]
+  };
+  const braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+  const regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+  const rangesToString = (ranges) => ranges.join("");
+  const parseClass = (glob, position) => {
+    const pos = position;
+    if (glob.charAt(pos) !== "[") {
+      throw new Error("not in a brace expression");
+    }
+    const ranges = [];
+    const negs = [];
+    let i = pos + 1;
+    let sawStart = false;
+    let uflag = false;
+    let escaping = false;
+    let negate = false;
+    let endPos = pos;
+    let rangeStart = "";
+    WHILE: while (i < glob.length) {
+      const c = glob.charAt(i);
+      if ((c === "!" || c === "^") && i === pos + 1) {
+        negate = true;
+        i++;
+        continue;
+      }
+      if (c === "]" && sawStart && !escaping) {
+        endPos = i + 1;
+        break;
+      }
+      sawStart = true;
+      if (c === "\\") {
+        if (!escaping) {
+          escaping = true;
+          i++;
+          continue;
+        }
+      }
+      if (c === "[" && !escaping) {
+        for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+          if (glob.startsWith(cls, i)) {
+            if (rangeStart) {
+              return ["$.", false, glob.length - pos, true];
+            }
+            i += cls.length;
+            if (neg)
+              negs.push(unip);
+            else
+              ranges.push(unip);
+            uflag = uflag || u;
+            continue WHILE;
+          }
+        }
+      }
+      escaping = false;
+      if (rangeStart) {
+        if (c > rangeStart) {
+          ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+        } else if (c === rangeStart) {
+          ranges.push(braceEscape(c));
+        }
+        rangeStart = "";
+        i++;
+        continue;
+      }
+      if (glob.startsWith("-]", i + 1)) {
+        ranges.push(braceEscape(c + "-"));
+        i += 2;
+        continue;
+      }
+      if (glob.startsWith("-", i + 1)) {
+        rangeStart = c;
+        i += 2;
+        continue;
+      }
+      ranges.push(braceEscape(c));
+      i++;
+    }
+    if (endPos < i) {
+      return ["", false, 0, false];
+    }
+    if (!ranges.length && !negs.length) {
+      return ["$.", false, glob.length - pos, true];
+    }
+    if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
+      const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+      return [regexpEscape(r), false, endPos - pos, false];
+    }
+    const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
+    const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
+    const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
+    return [comb, uflag, endPos - pos, true];
+  };
+  braceExpressions.parseClass = parseClass;
+  return braceExpressions;
+}
+export {
+  requireBraceExpressions as __require
+};
+//# sourceMappingURL=brace-expressions.js.map

package/dist/node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/dist/commonjs/brace-expressions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brace-expressions.js","sources":["../../../../../../../../node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/dist/commonjs/brace-expressions.js"],"sourcesContent":["\"use strict\";\n// translate the various posix character classes into unicode properties\n// this works across all unicode locales\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseClass = void 0;\n// { <posix class>: [<translation>, /u flag required, negated]\nconst posixClasses = {\n    '[:alnum:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}', true],\n    '[:alpha:]': ['\\\\p{L}\\\\p{Nl}', true],\n    '[:ascii:]': ['\\\\x' + '00-\\\\x' + '7f', false],\n    '[:blank:]': ['\\\\p{Zs}\\\\t', true],\n    '[:cntrl:]': ['\\\\p{Cc}', true],\n    '[:digit:]': ['\\\\p{Nd}', true],\n    '[:graph:]': ['\\\\p{Z}\\\\p{C}', true, true],\n    '[:lower:]': ['\\\\p{Ll}', true],\n    '[:print:]': ['\\\\p{C}', true],\n    '[:punct:]': ['\\\\p{P}', true],\n    '[:space:]': ['\\\\p{Z}\\\\t\\\\r\\\\n\\\\v\\\\f', true],\n    '[:upper:]': ['\\\\p{Lu}', true],\n    '[:word:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}\\\\p{Pc}', true],\n    '[:xdigit:]': ['A-Fa-f0-9', false],\n};\n// only need to escape a few things inside of brace expressions\n// escapes: [ \\ ] -\nconst braceEscape = (s) => s.replace(/[[\\]\\\\-]/g, '\\\\$&');\n// escape all regexp magic characters\nconst regexpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n// everything has already been escaped, we just have to join\nconst rangesToString = (ranges) => ranges.join('');\n// takes a glob string at a posix brace expression, and returns\n// an equivalent regular expression source, and boolean indicating\n// whether the /u flag needs to be applied, and the number of chars\n// consumed to parse the character class.\n// This also removes out of order ranges, and returns ($.) if the\n// entire class just no good.\nconst parseClass = (glob, position) => {\n    const pos = position;\n    /* c8 ignore start */\n    if (glob.charAt(pos) !== '[') {\n        throw new Error('not in a brace expression');\n    }\n    /* c8 ignore stop */\n    const ranges = [];\n    const negs = [];\n    let i = pos + 1;\n    let sawStart = false;\n    let uflag = false;\n    let escaping = false;\n    let negate = false;\n    let endPos = pos;\n    let rangeStart = '';\n    WHILE: while (i < glob.length) {\n        const c = glob.charAt(i);\n        if ((c === '!' || c === '^') && i === pos + 1) {\n            negate = true;\n            i++;\n            continue;\n        }\n        if (c === ']' && sawStart && !escaping) {\n            endPos = i + 1;\n            break;\n        }\n        sawStart = true;\n        if (c === '\\\\') {\n            if (!escaping) {\n                escaping = true;\n                i++;\n                continue;\n            }\n            // escaped \\ char, fall through and treat like normal char\n        }\n        if (c === '[' && !escaping) {\n            // either a posix class, a collation equivalent, or just a [\n            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {\n                if (glob.startsWith(cls, i)) {\n                    // invalid, [a-[] is fine, but not [a-[:alpha]]\n                    if (rangeStart) {\n                        return ['$.', false, glob.length - pos, true];\n                    }\n                    i += cls.length;\n                    if (neg)\n                        negs.push(unip);\n                    else\n                        ranges.push(unip);\n                    uflag = uflag || u;\n                    continue WHILE;\n                }\n            }\n        }\n        // now it's just a normal character, effectively\n        escaping = false;\n        if (rangeStart) {\n            // throw this range away if it's not valid, but others\n            // can still match.\n            if (c > rangeStart) {\n                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));\n            }\n            else if (c === rangeStart) {\n                ranges.push(braceEscape(c));\n            }\n            rangeStart = '';\n            i++;\n            continue;\n        }\n        // now might be the start of a range.\n        // can be either c-d or c-] or c<more...>] or c] at this point\n        if (glob.startsWith('-]', i + 1)) {\n            ranges.push(braceEscape(c + '-'));\n            i += 2;\n            continue;\n        }\n        if (glob.startsWith('-', i + 1)) {\n            rangeStart = c;\n            i += 2;\n            continue;\n        }\n        // not the start of a range, just a single character\n        ranges.push(braceEscape(c));\n        i++;\n    }\n    if (endPos < i) {\n        // didn't see the end of the class, not a valid class,\n        // but might still be valid as a literal match.\n        return ['', false, 0, false];\n    }\n    // if we got no ranges and no negates, then we have a range that\n    // cannot possibly match anything, and that poisons the whole glob\n    if (!ranges.length && !negs.length) {\n        return ['$.', false, glob.length - pos, true];\n    }\n    // if we got one positive range, and it's a single character, then that's\n    // not actually a magic pattern, it's just that one literal character.\n    // we should not treat that as \"magic\", we should just return the literal\n    // character. [_] is a perfectly valid way to escape glob magic chars.\n    if (negs.length === 0 &&\n        ranges.length === 1 &&\n        /^\\\\?.$/.test(ranges[0]) &&\n        !negate) {\n        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];\n        return [regexpEscape(r), false, endPos - pos, false];\n    }\n    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';\n    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';\n    const comb = ranges.length && negs.length\n        ? '(' + sranges + '|' + snegs + ')'\n        : ranges.length\n            ? sranges\n            : snegs;\n    return [comb, uflag, endPos - pos, true];\n};\nexports.parseClass = parseClass;\n//# sourceMappingURL=brace-expressions.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/dist/commonjs/escape.js

@@ -0,0 +1,17 @@
+import { __exports as _escape } from "../../../../../../../_virtual/escape.js";
+var hasRequired_escape;
+function require_escape() {
+  if (hasRequired_escape) return _escape;
+  hasRequired_escape = 1;
+  Object.defineProperty(_escape, "__esModule", { value: true });
+  _escape.escape = void 0;
+  const escape = (s, { windowsPathsNoEscape = false } = {}) => {
+    return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+  };
+  _escape.escape = escape;
+  return _escape;
+}
+export {
+  require_escape as __require
+};
+//# sourceMappingURL=escape.js.map

package/dist/node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/dist/commonjs/escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.js","sources":["../../../../../../../../node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/dist/commonjs/escape.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.escape = void 0;\n/**\n * Escape all magic characters in a glob pattern.\n *\n * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}\n * option is used, then characters are escaped by wrapping in `[]`, because\n * a magic character wrapped in a character class can only be satisfied by\n * that exact character.  In this mode, `\\` is _not_ escaped, because it is\n * not interpreted as a magic character, but instead as a path separator.\n */\nconst escape = (s, { windowsPathsNoEscape = false, } = {}) => {\n    // don't need to escape +@! because we escape the parens\n    // that make those magic, and escaping ! as [!] isn't valid,\n    // because [!]] is a valid glob class meaning not ']'.\n    return windowsPathsNoEscape\n        ? s.replace(/[?*()[\\]]/g, '[$&]')\n        : s.replace(/[?*()[\\]\\\\]/g, '\\\\$&');\n};\nexports.escape = escape;\n//# sourceMappingURL=escape.js.map"],"names":[],"mappings":";;;;;AACA,SAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM;AAC5D,UAAA,SAAiB;AAUjB,QAAM,SAAS,CAAC,GAAG,EAAE,uBAAuB,MAAK,IAAM,OAAO;AAI1D,WAAO,uBACD,EAAE,QAAQ,cAAc,MAAM,IAC9B,EAAE,QAAQ,gBAAgB,MAAM;AAAA,EAC1C;AACA,UAAA,SAAiB;;;","x_google_ignoreList":[0]}