richtor 1.0.0

package/dist/typescript-SNUkGeOU.js

@@ -0,0 +1,753 @@
+const y = "[A-Za-z$_][0-9A-Za-z$_]*", x = [
+  "as",
+  // for exports
+  "in",
+  "of",
+  "if",
+  "for",
+  "while",
+  "finally",
+  "var",
+  "new",
+  "function",
+  "do",
+  "return",
+  "void",
+  "else",
+  "break",
+  "catch",
+  "instanceof",
+  "with",
+  "throw",
+  "case",
+  "default",
+  "try",
+  "switch",
+  "continue",
+  "typeof",
+  "delete",
+  "let",
+  "yield",
+  "const",
+  "class",
+  // JS handles these with a special rule
+  // "get",
+  // "set",
+  "debugger",
+  "async",
+  "await",
+  "static",
+  "import",
+  "from",
+  "export",
+  "extends",
+  // It's reached stage 3, which is "recommended for implementation":
+  "using"
+], k = [
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity"
+], D = [
+  // Fundamental objects
+  "Object",
+  "Function",
+  "Boolean",
+  "Symbol",
+  // numbers and dates
+  "Math",
+  "Date",
+  "Number",
+  "BigInt",
+  // text
+  "String",
+  "RegExp",
+  // Indexed collections
+  "Array",
+  "Float32Array",
+  "Float64Array",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Int32Array",
+  "Uint16Array",
+  "Uint32Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  // Keyed collections
+  "Set",
+  "Map",
+  "WeakSet",
+  "WeakMap",
+  // Structured data
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "Atomics",
+  "DataView",
+  "JSON",
+  // Control abstraction objects
+  "Promise",
+  "Generator",
+  "GeneratorFunction",
+  "AsyncFunction",
+  // Reflection
+  "Reflect",
+  "Proxy",
+  // Internationalization
+  "Intl",
+  // WebAssembly
+  "WebAssembly"
+], h = [
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+], B = [
+  "setInterval",
+  "setTimeout",
+  "clearInterval",
+  "clearTimeout",
+  "require",
+  "exports",
+  "eval",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape"
+], U = [
+  "arguments",
+  "this",
+  "super",
+  "console",
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "module",
+  "global"
+  // Node.js
+], P = [].concat(
+  B,
+  D,
+  h
+);
+function J(e) {
+  const a = e.regex, t = (s, { after: d }) => {
+    const S = "</" + s[0].slice(1);
+    return s.input.indexOf(S, d) !== -1;
+  }, n = y, b = {
+    begin: "<>",
+    end: "</>"
+  }, p = /<[A-Za-z0-9\\._:-]+\s*\/>/, i = {
+    begin: /<[A-Za-z0-9\\._:-]+/,
+    end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+    /**
+     * @param {RegExpMatchArray} match
+     * @param {CallbackResponse} response
+     */
+    isTrulyOpeningTag: (s, d) => {
+      const S = s[0].length + s.index, f = s.input[S];
+      if (
+        // HTML should not include another raw `<` inside a tag
+        // nested type?
+        // `<Array<Array<number>>`, etc.
+        f === "<" || // the , gives away that this is not HTML
+        // `<T, A extends keyof T, V>`
+        f === ","
+      ) {
+        d.ignoreMatch();
+        return;
+      }
+      f === ">" && (t(s, { after: S }) || d.ignoreMatch());
+      let O;
+      const L = s.input.substring(S);
+      if (O = L.match(/^\s*=/)) {
+        d.ignoreMatch();
+        return;
+      }
+      if ((O = L.match(/^\s+extends\s+/)) && O.index === 0) {
+        d.ignoreMatch();
+        return;
+      }
+    }
+  }, o = {
+    $pattern: y,
+    keyword: x,
+    literal: k,
+    built_in: P,
+    "variable.language": U
+  }, N = "[0-9](_?[0-9])*", l = `\\.(${N})`, g = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", u = {
+    className: "number",
+    variants: [
+      // DecimalLiteral
+      { begin: `(\\b(${g})((${l})|\\.)?|(${l}))[eE][+-]?(${N})\\b` },
+      { begin: `\\b(${g})\\b((${l})\\b|\\.)?|(${l})\\b` },
+      // DecimalBigIntegerLiteral
+      { begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
+      // NonDecimalIntegerLiteral
+      { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+      { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+      { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+      // LegacyOctalIntegerLiteral (does not include underscore separators)
+      // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+      { begin: "\\b0[0-7]+n?\\b" }
+    ],
+    relevance: 0
+  }, c = {
+    className: "subst",
+    begin: "\\$\\{",
+    end: "\\}",
+    keywords: o,
+    contains: []
+    // defined later
+  }, A = {
+    begin: ".?html`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        c
+      ],
+      subLanguage: "xml"
+    }
+  }, T = {
+    begin: ".?css`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        c
+      ],
+      subLanguage: "css"
+    }
+  }, r = {
+    begin: ".?gql`",
+    end: "",
+    starts: {
+      end: "`",
+      returnEnd: !1,
+      contains: [
+        e.BACKSLASH_ESCAPE,
+        c
+      ],
+      subLanguage: "graphql"
+    }
+  }, m = {
+    className: "string",
+    begin: "`",
+    end: "`",
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      c
+    ]
+  }, E = {
+    className: "comment",
+    variants: [
+      e.COMMENT(
+        /\/\*\*(?!\/)/,
+        "\\*/",
+        {
+          relevance: 0,
+          contains: [
+            {
+              begin: "(?=@[A-Za-z]+)",
+              relevance: 0,
+              contains: [
+                {
+                  className: "doctag",
+                  begin: "@[A-Za-z]+"
+                },
+                {
+                  className: "type",
+                  begin: "\\{",
+                  end: "\\}",
+                  excludeEnd: !0,
+                  excludeBegin: !0,
+                  relevance: 0
+                },
+                {
+                  className: "variable",
+                  begin: n + "(?=\\s*(-)|$)",
+                  endsParent: !0,
+                  relevance: 0
+                },
+                // eat spaces (not newlines) so we can find
+                // types or variables
+                {
+                  begin: /(?=[^\n])\s/,
+                  relevance: 0
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      e.C_BLOCK_COMMENT_MODE,
+      e.C_LINE_COMMENT_MODE
+    ]
+  }, R = [
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE,
+    A,
+    T,
+    r,
+    m,
+    // Skip numbers when they are part of a variable name
+    { match: /\$\d+/ },
+    u
+    // This is intentional:
+    // See https://github.com/highlightjs/highlight.js/issues/3288
+    // hljs.REGEXP_MODE
+  ];
+  c.contains = R.concat({
+    // we need to pair up {} inside our subst to prevent
+    // it from ending too early by matching another }
+    begin: /\{/,
+    end: /\}/,
+    keywords: o,
+    contains: [
+      "self"
+    ].concat(R)
+  });
+  const M = [].concat(E, c.contains), I = M.concat([
+    // eat recursive parens in sub expressions
+    {
+      begin: /(\s*)\(/,
+      end: /\)/,
+      keywords: o,
+      contains: ["self"].concat(M)
+    }
+  ]), _ = {
+    className: "params",
+    // convert this to negative lookbehind in v12
+    begin: /(\s*)\(/,
+    // to match the parms with
+    end: /\)/,
+    excludeBegin: !0,
+    excludeEnd: !0,
+    keywords: o,
+    contains: I
+  }, $ = {
+    variants: [
+      // class Car extends vehicle
+      {
+        match: [
+          /class/,
+          /\s+/,
+          n,
+          /\s+/,
+          /extends/,
+          /\s+/,
+          a.concat(n, "(", a.concat(/\./, n), ")*")
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class",
+          5: "keyword",
+          7: "title.class.inherited"
+        }
+      },
+      // class Car
+      {
+        match: [
+          /class/,
+          /\s+/,
+          n
+        ],
+        scope: {
+          1: "keyword",
+          3: "title.class"
+        }
+      }
+    ]
+  }, v = {
+    relevance: 0,
+    match: a.either(
+      // Hard coded exceptions
+      /\bJSON/,
+      // Float32Array, OutT
+      /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,
+      // CSSFactory, CSSFactoryT
+      /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,
+      // FPs, FPsT
+      /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/
+      // P
+      // single letters are not highlighted
+      // BLAH
+      // this will be flagged as a UPPER_CASE_CONSTANT instead
+    ),
+    className: "title.class",
+    keywords: {
+      _: [
+        // se we still get relevance credit for JS library classes
+        ...D,
+        ...h
+      ]
+    }
+  }, F = {
+    label: "use_strict",
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use (strict|asm)['"]/
+  }, G = {
+    variants: [
+      {
+        match: [
+          /function/,
+          /\s+/,
+          n,
+          /(?=\s*\()/
+        ]
+      },
+      // anonymous function
+      {
+        match: [
+          /function/,
+          /\s*(?=\()/
+        ]
+      }
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    label: "func.def",
+    contains: [_],
+    illegal: /%/
+  }, Z = {
+    relevance: 0,
+    match: /\b[A-Z][A-Z_0-9]+\b/,
+    className: "variable.constant"
+  };
+  function z(s) {
+    return a.concat("(?!", s.join("|"), ")");
+  }
+  const K = {
+    match: a.concat(
+      /\b/,
+      z([
+        ...B,
+        "super",
+        "import"
+      ].map((s) => `${s}\\s*\\(`)),
+      n,
+      a.lookahead(/\s*\(/)
+    ),
+    className: "title.function",
+    relevance: 0
+  }, H = {
+    begin: a.concat(/\./, a.lookahead(
+      a.concat(n, /(?![0-9A-Za-z$_(])/)
+    )),
+    end: n,
+    excludeBegin: !0,
+    keywords: "prototype",
+    className: "property",
+    relevance: 0
+  }, Y = {
+    match: [
+      /get|set/,
+      /\s+/,
+      n,
+      /(?=\()/
+    ],
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      {
+        // eat to avoid empty params
+        begin: /\(\)/
+      },
+      _
+    ]
+  }, w = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + e.UNDERSCORE_IDENT_RE + ")\\s*=>", W = {
+    match: [
+      /const|var|let/,
+      /\s+/,
+      n,
+      /\s*/,
+      /=\s*/,
+      /(async\s*)?/,
+      // async is optional
+      a.lookahead(w)
+    ],
+    keywords: "async",
+    className: {
+      1: "keyword",
+      3: "title.function"
+    },
+    contains: [
+      _
+    ]
+  };
+  return {
+    name: "JavaScript",
+    aliases: ["js", "jsx", "mjs", "cjs"],
+    keywords: o,
+    // this will be extended by TypeScript
+    exports: { PARAMS_CONTAINS: I, CLASS_REFERENCE: v },
+    illegal: /#(?![$_A-z])/,
+    contains: [
+      e.SHEBANG({
+        label: "shebang",
+        binary: "node",
+        relevance: 5
+      }),
+      F,
+      e.APOS_STRING_MODE,
+      e.QUOTE_STRING_MODE,
+      A,
+      T,
+      r,
+      m,
+      E,
+      // Skip numbers when they are part of a variable name
+      { match: /\$\d+/ },
+      u,
+      v,
+      {
+        scope: "attr",
+        match: n + a.lookahead(":"),
+        relevance: 0
+      },
+      W,
+      {
+        // "value" container
+        begin: "(" + e.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+        keywords: "return throw case",
+        relevance: 0,
+        contains: [
+          E,
+          e.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: w,
+            returnBegin: !0,
+            end: "\\s*=>",
+            contains: [
+              {
+                className: "params",
+                variants: [
+                  {
+                    begin: e.UNDERSCORE_IDENT_RE,
+                    relevance: 0
+                  },
+                  {
+                    className: null,
+                    begin: /\(\s*\)/,
+                    skip: !0
+                  },
+                  {
+                    begin: /(\s*)\(/,
+                    end: /\)/,
+                    excludeBegin: !0,
+                    excludeEnd: !0,
+                    keywords: o,
+                    contains: I
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            // could be a comma delimited list of params to a function call
+            begin: /,/,
+            relevance: 0
+          },
+          {
+            match: /\s+/,
+            relevance: 0
+          },
+          {
+            // JSX
+            variants: [
+              { begin: b.begin, end: b.end },
+              { match: p },
+              {
+                begin: i.begin,
+                // we carefully check the opening tag to see if it truly
+                // is a tag and not a false positive
+                "on:begin": i.isTrulyOpeningTag,
+                end: i.end
+              }
+            ],
+            subLanguage: "xml",
+            contains: [
+              {
+                begin: i.begin,
+                end: i.end,
+                skip: !0,
+                contains: ["self"]
+              }
+            ]
+          }
+        ]
+      },
+      G,
+      {
+        // prevent this from getting swallowed up by function
+        // since they appear "function like"
+        beginKeywords: "while if switch catch for"
+      },
+      {
+        // 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*\\{",
+        // end parens
+        returnBegin: !0,
+        label: "func.def",
+        contains: [
+          _,
+          e.inherit(e.TITLE_MODE, { begin: n, className: "title.function" })
+        ]
+      },
+      // catch ... so it won't trigger the property rule below
+      {
+        match: /\.\.\./,
+        relevance: 0
+      },
+      H,
+      // hack: prevents detection of keywords in some circumstances
+      // .keyword()
+      // $keyword = x
+      {
+        match: "\\$" + n,
+        relevance: 0
+      },
+      {
+        match: [/\bconstructor(?=\s*\()/],
+        className: { 1: "title.function" },
+        contains: [_]
+      },
+      K,
+      Z,
+      $,
+      Y,
+      {
+        match: /\$[(.]/
+        // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+      }
+    ]
+  };
+}
+function X(e) {
+  const a = e.regex, t = J(e), n = y, b = [
+    "any",
+    "void",
+    "number",
+    "boolean",
+    "string",
+    "object",
+    "never",
+    "symbol",
+    "bigint",
+    "unknown"
+  ], p = {
+    begin: [
+      /namespace/,
+      /\s+/,
+      e.IDENT_RE
+    ],
+    beginScope: {
+      1: "keyword",
+      3: "title.class"
+    }
+  }, i = {
+    beginKeywords: "interface",
+    end: /\{/,
+    excludeEnd: !0,
+    keywords: {
+      keyword: "interface extends",
+      built_in: b
+    },
+    contains: [t.exports.CLASS_REFERENCE]
+  }, o = {
+    className: "meta",
+    relevance: 10,
+    begin: /^\s*['"]use strict['"]/
+  }, N = [
+    "type",
+    // "namespace",
+    "interface",
+    "public",
+    "private",
+    "protected",
+    "implements",
+    "declare",
+    "abstract",
+    "readonly",
+    "enum",
+    "override",
+    "satisfies"
+  ], l = {
+    $pattern: y,
+    keyword: x.concat(N),
+    literal: k,
+    built_in: P.concat(b),
+    "variable.language": U
+  }, g = {
+    className: "meta",
+    begin: "@" + n
+  }, u = (r, m, C) => {
+    const E = r.contains.findIndex((R) => R.label === m);
+    if (E === -1)
+      throw new Error("can not find mode to replace");
+    r.contains.splice(E, 1, C);
+  };
+  Object.assign(t.keywords, l), t.exports.PARAMS_CONTAINS.push(g);
+  const c = t.contains.find((r) => r.scope === "attr"), A = Object.assign(
+    {},
+    c,
+    { match: a.concat(n, a.lookahead(/\s*\?:/)) }
+  );
+  t.exports.PARAMS_CONTAINS.push([
+    t.exports.CLASS_REFERENCE,
+    // class reference for highlighting the params types
+    c,
+    // highlight the params key
+    A
+    // Added for optional property assignment highlighting
+  ]), t.contains = t.contains.concat([
+    g,
+    p,
+    i,
+    A
+    // Added for optional property assignment highlighting
+  ]), u(t, "shebang", e.SHEBANG()), u(t, "use_strict", o);
+  const T = t.contains.find((r) => r.label === "func.def");
+  return T.relevance = 0, Object.assign(t, {
+    name: "TypeScript",
+    aliases: [
+      "ts",
+      "tsx",
+      "mts",
+      "cts"
+    ]
+  }), t;
+}
+export {
+  X as default
+};