@veracity/ai 1.0.1 → 2.0.1

package/dist/{typescript-Bx5cZccb.js → typescript-Cg8DWaxm.js}

@@ -1,4 +1,4 @@
-const T = "[A-Za-z$_][0-9A-Za-z$_]*", L = [
+const m = "[A-Za-z$_][0-9A-Za-z$_]*", x = [
   "as",
   // for exports
   "in",
@@ -41,14 +41,14 @@ const T = "[A-Za-z$_][0-9A-Za-z$_]*", L = [
   "from",
   "export",
   "extends"
-], x = [
+], D = [
   "true",
   "false",
   "null",
   "undefined",
   "NaN",
   "Infinity"
-], D = [
+], k = [
   // Fundamental objects
   "Object",
   "Function",
@@ -98,7 +98,7 @@ const T = "[A-Za-z$_][0-9A-Za-z$_]*", L = [
   "Intl",
   // WebAssembly
   "WebAssembly"
-], k = [
+], B = [
   "Error",
   "EvalError",
   "InternalError",
@@ -107,7 +107,7 @@ const T = "[A-Za-z$_][0-9A-Za-z$_]*", L = [
   "SyntaxError",
   "TypeError",
   "URIError"
-], B = [
+], U = [
   "setInterval",
   "setTimeout",
   "clearInterval",
@@ -137,62 +137,62 @@ const T = "[A-Za-z$_][0-9A-Za-z$_]*", L = [
   "module",
   "global"
   // Node.js
-], U = [].concat(
-  B,
-  D,
-  k
+], P = [].concat(
+  U,
+  k,
+  B
 );
-function W(e) {
-  const n = e.regex, f = (s, { after: i }) => {
-    const b = "</" + s[0].slice(1);
-    return s.input.indexOf(b, i) !== -1;
-  }, t = T, u = {
+function J(n) {
+  const e = n.regex, f = (a, { after: l }) => {
+    const u = "</" + a[0].slice(1);
+    return a.input.indexOf(u, l) !== -1;
+  }, t = m, g = {
     begin: "<>",
     end: "</>"
-  }, R = /<[A-Za-z0-9\\._:-]+\s*\/>/, r = {
+  }, R = /<[A-Za-z0-9\\._:-]+\s*\/>/, o = {
     begin: /<[A-Za-z0-9\\._:-]+/,
     end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
     /**
      * @param {RegExpMatchArray} match
      * @param {CallbackResponse} response
      */
-    isTrulyOpeningTag: (s, i) => {
-      const b = s[0].length + s.index, m = s.input[b];
+    isTrulyOpeningTag: (a, l) => {
+      const u = a[0].length + a.index, T = a.input[u];
       if (
         // HTML should not include another raw `<` inside a tag
         // nested type?
         // `<Array<Array<number>>`, etc.
-        m === "<" || // the , gives away that this is not HTML
+        T === "<" || // the , gives away that this is not HTML
         // `<T, A extends keyof T, V>`
-        m === ","
+        T === ","
       ) {
-        i.ignoreMatch();
+        l.ignoreMatch();
         return;
       }
-      m === ">" && (f(s, { after: b }) || i.ignoreMatch());
-      let I;
-      const w = s.input.substring(b);
-      if (I = w.match(/^\s*=/)) {
-        i.ignoreMatch();
+      T === ">" && (f(a, { after: u }) || l.ignoreMatch());
+      let p;
+      const L = a.input.substring(u);
+      if (p = L.match(/^\s*=/)) {
+        l.ignoreMatch();
         return;
       }
-      if ((I = w.match(/^\s+extends\s+/)) && I.index === 0) {
-        i.ignoreMatch();
+      if ((p = L.match(/^\s+extends\s+/)) && p.index === 0) {
+        l.ignoreMatch();
         return;
       }
     }
   }, c = {
-    $pattern: T,
-    keyword: L,
-    literal: x,
-    built_in: U,
+    $pattern: m,
+    keyword: x,
+    literal: D,
+    built_in: P,
     "variable.language": h
-  }, g = "[0-9](_?[0-9])*", o = `\\.(${g})`, l = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", A = {
+  }, A = "[0-9](_?[0-9])*", i = `\\.(${A})`, E = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", _ = {
     className: "number",
     variants: [
       // DecimalLiteral
-      { begin: `(\\b(${l})((${o})|\\.)?|(${o}))[eE][+-]?(${g})\\b` },
-      { begin: `\\b(${l})\\b((${o})\\b|\\.)?|(${o})\\b` },
+      { begin: `(\\b(${E})((${i})|\\.)?|(${i}))[eE][+-]?(${A})\\b` },
+      { begin: `\\b(${E})\\b((${i})\\b|\\.)?|(${i})\\b` },
       // DecimalBigIntegerLiteral
       { begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
       // NonDecimalIntegerLiteral
@@ -204,61 +204,61 @@ function W(e) {
       { begin: "\\b0[0-7]+n?\\b" }
     ],
     relevance: 0
-  }, a = {
+  }, r = {
     className: "subst",
     begin: "\\$\\{",
     end: "\\}",
     keywords: c,
     contains: []
     // defined later
-  }, _ = {
-    begin: "html`",
+  }, s = {
+    begin: ".?html`",
     end: "",
     starts: {
       end: "`",
       returnEnd: !1,
       contains: [
-        e.BACKSLASH_ESCAPE,
-        a
+        n.BACKSLASH_ESCAPE,
+        r
       ],
       subLanguage: "xml"
     }
   }, S = {
-    begin: "css`",
+    begin: ".?css`",
     end: "",
     starts: {
       end: "`",
       returnEnd: !1,
       contains: [
-        e.BACKSLASH_ESCAPE,
-        a
+        n.BACKSLASH_ESCAPE,
+        r
       ],
       subLanguage: "css"
     }
-  }, E = {
-    begin: "gql`",
+  }, N = {
+    begin: ".?gql`",
     end: "",
     starts: {
       end: "`",
       returnEnd: !1,
       contains: [
-        e.BACKSLASH_ESCAPE,
-        a
+        n.BACKSLASH_ESCAPE,
+        r
       ],
       subLanguage: "graphql"
     }
-  }, N = {
+  }, d = {
     className: "string",
     begin: "`",
     end: "`",
     contains: [
-      e.BACKSLASH_ESCAPE,
-      a
+      n.BACKSLASH_ESCAPE,
+      r
     ]
   }, y = {
     className: "comment",
     variants: [
-      e.COMMENT(
+      n.COMMENT(
         /\/\*\*(?!\/)/,
         "\\*/",
         {
@@ -297,24 +297,24 @@ function W(e) {
           ]
         }
       ),
-      e.C_BLOCK_COMMENT_MODE,
-      e.C_LINE_COMMENT_MODE
+      n.C_BLOCK_COMMENT_MODE,
+      n.C_LINE_COMMENT_MODE
     ]
-  }, C = [
-    e.APOS_STRING_MODE,
-    e.QUOTE_STRING_MODE,
-    _,
+  }, O = [
+    n.APOS_STRING_MODE,
+    n.QUOTE_STRING_MODE,
+    s,
     S,
-    E,
     N,
+    d,
     // Skip numbers when they are part of a variable name
     { match: /\$\d+/ },
-    A
+    _
     // This is intentional:
     // See https://github.com/highlightjs/highlight.js/issues/3288
     // hljs.REGEXP_MODE
   ];
-  a.contains = C.concat({
+  r.contains = O.concat({
     // we need to pair up {} inside our subst to prevent
     // it from ending too early by matching another }
     begin: /\{/,
@@ -322,25 +322,27 @@ function W(e) {
     keywords: c,
     contains: [
       "self"
-    ].concat(C)
+    ].concat(O)
   });
-  const O = [].concat(y, a.contains), p = O.concat([
+  const M = [].concat(y, r.contains), I = M.concat([
     // eat recursive parens in sub expressions
     {
-      begin: /\(/,
+      begin: /(\s*)\(/,
       end: /\)/,
       keywords: c,
-      contains: ["self"].concat(O)
+      contains: ["self"].concat(M)
     }
-  ]), d = {
+  ]), b = {
     className: "params",
-    begin: /\(/,
+    // convert this to negative lookbehind in v12
+    begin: /(\s*)\(/,
+    // to match the parms with 
     end: /\)/,
     excludeBegin: !0,
     excludeEnd: !0,
     keywords: c,
-    contains: p
-  }, P = {
+    contains: I
+  }, $ = {
     variants: [
       // class Car extends vehicle
       {
@@ -351,7 +353,7 @@ function W(e) {
           /\s+/,
           /extends/,
           /\s+/,
-          n.concat(t, "(", n.concat(/\./, t), ")*")
+          e.concat(t, "(", e.concat(/\./, t), ")*")
         ],
         scope: {
           1: "keyword",
@@ -373,9 +375,9 @@ function W(e) {
         }
       }
     ]
-  }, M = {
+  }, v = {
     relevance: 0,
-    match: n.either(
+    match: e.either(
       // Hard coded exceptions
       /\bJSON/,
       // Float32Array, OutT
@@ -393,16 +395,16 @@ function W(e) {
     keywords: {
       _: [
         // se we still get relevance credit for JS library classes
-        ...D,
-        ...k
+        ...k,
+        ...B
       ]
     }
-  }, $ = {
+  }, F = {
     label: "use_strict",
     className: "meta",
     relevance: 10,
     begin: /^\s*['"]use (strict|asm)['"]/
-  }, F = {
+  }, G = {
     variants: [
       {
         match: [
@@ -425,39 +427,39 @@ function W(e) {
       3: "title.function"
     },
     label: "func.def",
-    contains: [d],
+    contains: [b],
     illegal: /%/
   }, Z = {
     relevance: 0,
     match: /\b[A-Z][A-Z_0-9]+\b/,
     className: "variable.constant"
   };
-  function z(s) {
-    return n.concat("(?!", s.join("|"), ")");
+  function z(a) {
+    return e.concat("(?!", a.join("|"), ")");
   }
-  const G = {
-    match: n.concat(
+  const H = {
+    match: e.concat(
       /\b/,
       z([
-        ...B,
+        ...U,
         "super",
         "import"
-      ]),
+      ].map((a) => `${a}\\s*\\(`)),
       t,
-      n.lookahead(/\(/)
+      e.lookahead(/\s*\(/)
     ),
     className: "title.function",
     relevance: 0
   }, K = {
-    begin: n.concat(/\./, n.lookahead(
-      n.concat(t, /(?![0-9A-Za-z$_(])/)
+    begin: e.concat(/\./, e.lookahead(
+      e.concat(t, /(?![0-9A-Za-z$_(])/)
     )),
     end: t,
     excludeBegin: !0,
     keywords: "prototype",
     className: "property",
     relevance: 0
-  }, H = {
+  }, Y = {
     match: [
       /get|set/,
       /\s+/,
@@ -473,9 +475,9 @@ function W(e) {
         // eat to avoid empty params
         begin: /\(\)/
       },
-      d
+      b
     ]
-  }, v = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>", Y = {
+  }, w = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + n.UNDERSCORE_IDENT_RE + ")\\s*=>", W = {
     match: [
       /const|var|let/,
       /\s+/,
@@ -484,7 +486,7 @@ function W(e) {
       /=\s*/,
       /(async\s*)?/,
       // async is optional
-      n.lookahead(v)
+      e.lookahead(w)
     ],
     keywords: "async",
     className: {
@@ -492,7 +494,7 @@ function W(e) {
       3: "title.function"
     },
     contains: [
-      d
+      b
     ]
   };
   return {
@@ -500,46 +502,46 @@ function W(e) {
     aliases: ["js", "jsx", "mjs", "cjs"],
     keywords: c,
     // this will be extended by TypeScript
-    exports: { PARAMS_CONTAINS: p, CLASS_REFERENCE: M },
+    exports: { PARAMS_CONTAINS: I, CLASS_REFERENCE: v },
     illegal: /#(?![$_A-z])/,
     contains: [
-      e.SHEBANG({
+      n.SHEBANG({
         label: "shebang",
         binary: "node",
         relevance: 5
       }),
-      $,
-      e.APOS_STRING_MODE,
-      e.QUOTE_STRING_MODE,
-      _,
+      F,
+      n.APOS_STRING_MODE,
+      n.QUOTE_STRING_MODE,
+      s,
       S,
-      E,
       N,
+      d,
       y,
       // Skip numbers when they are part of a variable name
       { match: /\$\d+/ },
-      A,
-      M,
+      _,
+      v,
       {
         className: "attr",
-        begin: t + n.lookahead(":"),
+        begin: t + e.lookahead(":"),
         relevance: 0
       },
-      Y,
+      W,
       {
         // "value" container
-        begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+        begin: "(" + n.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
         keywords: "return throw case",
         relevance: 0,
         contains: [
           y,
-          e.REGEXP_MODE,
+          n.REGEXP_MODE,
           {
             className: "function",
             // we have to count the parens to make sure we actually have the
             // correct bounding ( ) before the =>.  There could be any number of
             // sub-expressions inside also surrounded by parens.
-            begin: v,
+            begin: w,
             returnBegin: !0,
             end: "\\s*=>",
             contains: [
@@ -547,7 +549,7 @@ function W(e) {
                 className: "params",
                 variants: [
                   {
-                    begin: e.UNDERSCORE_IDENT_RE,
+                    begin: n.UNDERSCORE_IDENT_RE,
                     relevance: 0
                   },
                   {
@@ -556,12 +558,12 @@ function W(e) {
                     skip: !0
                   },
                   {
-                    begin: /\(/,
+                    begin: /(\s*)\(/,
                     end: /\)/,
                     excludeBegin: !0,
                     excludeEnd: !0,
                     keywords: c,
-                    contains: p
+                    contains: I
                   }
                 ]
               }
@@ -579,21 +581,21 @@ function W(e) {
           {
             // JSX
             variants: [
-              { begin: u.begin, end: u.end },
+              { begin: g.begin, end: g.end },
               { match: R },
               {
-                begin: r.begin,
+                begin: o.begin,
                 // we carefully check the opening tag to see if it truly
                 // is a tag and not a false positive
-                "on:begin": r.isTrulyOpeningTag,
-                end: r.end
+                "on:begin": o.isTrulyOpeningTag,
+                end: o.end
               }
             ],
             subLanguage: "xml",
             contains: [
               {
-                begin: r.begin,
-                end: r.end,
+                begin: o.begin,
+                end: o.end,
                 skip: !0,
                 contains: ["self"]
               }
@@ -601,7 +603,7 @@ function W(e) {
           }
         ]
       },
-      F,
+      G,
       {
         // prevent this from getting swallowed up by function
         // since they appear "function like"
@@ -611,13 +613,13 @@ function W(e) {
         // we have to count the parens to make sure we actually have the correct
         // bounding ( ).  There could be any number of sub-expressions inside
         // also surrounded by parens.
-        begin: "\\b(?!function)" + e.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+        begin: "\\b(?!function)" + n.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
         // end parens
         returnBegin: !0,
         label: "func.def",
         contains: [
-          d,
-          e.inherit(e.TITLE_MODE, { begin: t, className: "title.function" })
+          b,
+          n.inherit(n.TITLE_MODE, { begin: t, className: "title.function" })
         ]
       },
       // catch ... so it won't trigger the property rule below
@@ -636,12 +638,12 @@ function W(e) {
       {
         match: [/\bconstructor(?=\s*\()/],
         className: { 1: "title.function" },
-        contains: [d]
+        contains: [b]
       },
-      G,
-      Z,
-      P,
       H,
+      Z,
+      $,
+      Y,
       {
         match: /\$[(.]/
         // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
@@ -649,8 +651,8 @@ function W(e) {
     ]
   };
 }
-function X(e) {
-  const n = W(e), f = T, t = [
+function X(n) {
+  const e = J(n), f = m, t = [
     "any",
     "void",
     "number",
@@ -661,11 +663,16 @@ function X(e) {
     "symbol",
     "bigint",
     "unknown"
-  ], u = {
-    beginKeywords: "namespace",
-    end: /\{/,
-    excludeEnd: !0,
-    contains: [n.exports.CLASS_REFERENCE]
+  ], g = {
+    begin: [
+      /namespace/,
+      /\s+/,
+      n.IDENT_RE
+    ],
+    beginScope: {
+      1: "keyword",
+      3: "title.class"
+    }
   }, R = {
     beginKeywords: "interface",
     end: /\{/,
@@ -674,14 +681,14 @@ function X(e) {
       keyword: "interface extends",
       built_in: t
     },
-    contains: [n.exports.CLASS_REFERENCE]
-  }, r = {
+    contains: [e.exports.CLASS_REFERENCE]
+  }, o = {
     className: "meta",
     relevance: 10,
     begin: /^\s*['"]use strict['"]/
   }, c = [
     "type",
-    "namespace",
+    // "namespace",
     "interface",
     "public",
     "private",
@@ -691,29 +698,37 @@ function X(e) {
     "abstract",
     "readonly",
     "enum",
-    "override"
-  ], g = {
-    $pattern: T,
-    keyword: L.concat(c),
-    literal: x,
-    built_in: U.concat(t),
+    "override",
+    "satisfies"
+  ], A = {
+    $pattern: m,
+    keyword: x.concat(c),
+    literal: D,
+    built_in: P.concat(t),
     "variable.language": h
-  }, o = {
+  }, i = {
     className: "meta",
     begin: "@" + f
-  }, l = (a, _, S) => {
-    const E = a.contains.findIndex((N) => N.label === _);
-    if (E === -1)
+  }, E = (s, S, N) => {
+    const d = s.contains.findIndex((C) => C.label === S);
+    if (d === -1)
       throw new Error("can not find mode to replace");
-    a.contains.splice(E, 1, S);
+    s.contains.splice(d, 1, N);
   };
-  Object.assign(n.keywords, g), n.exports.PARAMS_CONTAINS.push(o), n.contains = n.contains.concat([
-    o,
-    u,
+  Object.assign(e.keywords, A), e.exports.PARAMS_CONTAINS.push(i);
+  const _ = e.contains.find((s) => s.className === "attr");
+  e.exports.PARAMS_CONTAINS.push([
+    e.exports.CLASS_REFERENCE,
+    // class reference for highlighting the params types
+    _
+    // highlight the params key
+  ]), e.contains = e.contains.concat([
+    i,
+    g,
     R
-  ]), l(n, "shebang", e.SHEBANG()), l(n, "use_strict", r);
-  const A = n.contains.find((a) => a.label === "func.def");
-  return A.relevance = 0, Object.assign(n, {
+  ]), E(e, "shebang", n.SHEBANG()), E(e, "use_strict", o);
+  const r = e.contains.find((s) => s.label === "func.def");
+  return r.relevance = 0, Object.assign(e, {
     name: "TypeScript",
     aliases: [
       "ts",
@@ -721,7 +736,7 @@ function X(e) {
       "mts",
       "cts"
     ]
-  }), n;
+  }), e;
 }
 export {
   X as default

package/dist/utils/CancellationToken.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CancellationToken.d.ts","sourceRoot":"","sources":["../../src/utils/CancellationToken.ts"],"names":[],"mappings":"AAEA,qBAAa,iBAAiB;IAC1B,uBAAuB,EAAE,OAAO,CAAS;IACzC,SAAS,YAAiB,IAAI,EAAI;IAElC,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI;IAQhC,MAAM;IAUN,cAAc,CAAC,QAAQ,EAAE,MAAM,IAAI;IAInC,4BAA4B;CAK/B;AAED,qBAAa,qBAAsB,SAAQ,iBAAiB;IACxD,WAAW;IAIX,cAAc;IAId,MAAM;IAIN,MAAM,KAAK,SAAS,0BAEnB;IAED,OAAO,CAAC,MAAM,CAAC,UAAU,CAAwB;CACpD"}
+{"version":3,"file":"CancellationToken.d.ts","sourceRoot":"","sources":["../../src/utils/CancellationToken.ts"],"names":[],"mappings":"AAEA,qBAAa,iBAAiB;IAC5B,uBAAuB,EAAE,OAAO,CAAS;IACzC,SAAS,YAAiB,IAAI,EAAI;IAElC,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI;IAQhC,MAAM;IAUN,cAAc,CAAC,QAAQ,EAAE,MAAM,IAAI;IAInC,4BAA4B;CAK7B;AAED,qBAAa,qBAAsB,SAAQ,iBAAiB;IAC1D,WAAW;IAIX,cAAc;IAId,MAAM;IAIN,MAAM,KAAK,SAAS,0BAEnB;IAED,OAAO,CAAC,MAAM,CAAC,UAAU,CAAwB;CAClD"}