richtor 1.0.5 → 1.0.8

package/dist/typescript-SNUkGeOU.js

@@ -1,753 +0,0 @@
-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
-};