var s, o;
function p() {
  if (o)
    return s;
  o = 1;
  const c = [
    "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"
  ], d = [
    "true",
    "false",
    "null",
    "undefined",
    "NaN",
    "Infinity"
  ], l = [
    // 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"
  ], u = [
    "Error",
    "EvalError",
    "InternalError",
    "RangeError",
    "ReferenceError",
    "SyntaxError",
    "TypeError",
    "URIError"
  ], E = [
    "setInterval",
    "setTimeout",
    "clearInterval",
    "clearTimeout",
    "require",
    "exports",
    "eval",
    "isFinite",
    "isNaN",
    "parseFloat",
    "parseInt",
    "decodeURI",
    "decodeURIComponent",
    "encodeURI",
    "encodeURIComponent",
    "escape",
    "unescape"
  ], S = [].concat(
    E,
    l,
    u
  );
  function _(e) {
    const A = [
      "npm",
      "print"
    ], g = [
      "yes",
      "no",
      "on",
      "off",
      "it",
      "that",
      "void"
    ], I = [
      "then",
      "unless",
      "until",
      "loop",
      "of",
      "by",
      "when",
      "and",
      "or",
      "is",
      "isnt",
      "not",
      "it",
      "that",
      "otherwise",
      "from",
      "to",
      "til",
      "fallthrough",
      "case",
      "enum",
      "native",
      "list",
      "map",
      "__hasProp",
      "__extends",
      "__slice",
      "__bind",
      "__indexOf"
    ], t = {
      keyword: c.concat(I),
      literal: d.concat(g),
      built_in: S.concat(A)
    }, n = "[A-Za-z$_](?:-[0-9A-Za-z$_]|[0-9A-Za-z$_])*", b = e.inherit(e.TITLE_MODE, { begin: n }), r = {
      className: "subst",
      begin: /#\{/,
      end: /\}/,
      keywords: t
    }, i = {
      className: "subst",
      begin: /#[A-Za-z$_]/,
      end: /(?:-[0-9A-Za-z$_]|[0-9A-Za-z$_])*/,
      keywords: t
    }, a = [
      e.BINARY_NUMBER_MODE,
      {
        className: "number",
        begin: "(\\b0[xX][a-fA-F0-9_]+)|(\\b\\d(\\d|_\\d)*(\\.(\\d(\\d|_\\d)*)?)?(_*[eE]([-+]\\d(_\\d|\\d)*)?)?[_a-z]*)",
        relevance: 0,
        starts: {
          end: "(\\s*/)?",
          relevance: 0
        }
        // a number tries to eat the following slash to prevent treating it as a regexp
      },
      {
        className: "string",
        variants: [
          {
            begin: /'''/,
            end: /'''/,
            contains: [e.BACKSLASH_ESCAPE]
          },
          {
            begin: /'/,
            end: /'/,
            contains: [e.BACKSLASH_ESCAPE]
          },
          {
            begin: /"""/,
            end: /"""/,
            contains: [
              e.BACKSLASH_ESCAPE,
              r,
              i
            ]
          },
          {
            begin: /"/,
            end: /"/,
            contains: [
              e.BACKSLASH_ESCAPE,
              r,
              i
            ]
          },
          {
            begin: /\\/,
            end: /(\s|$)/,
            excludeEnd: !0
          }
        ]
      },
      {
        className: "regexp",
        variants: [
          {
            begin: "//",
            end: "//[gim]*",
            contains: [
              r,
              e.HASH_COMMENT_MODE
            ]
          },
          {
            // regex can't start with space to parse x / 2 / 3 as two divisions
            // regex can't start with *, and it supports an "illegal" in the main mode
            begin: /\/(?![ *])(\\.|[^\\\n])*?\/[gim]*(?=\W)/
          }
        ]
      },
      { begin: "@" + n },
      {
        begin: "``",
        end: "``",
        excludeBegin: !0,
        excludeEnd: !0,
        subLanguage: "javascript"
      }
    ];
    r.contains = a;
    const y = {
      className: "params",
      begin: "\\(",
      returnBegin: !0,
      /* We need another contained nameless mode to not have every nested
      pair of parens to be called "params" */
      contains: [
        {
          begin: /\(/,
          end: /\)/,
          keywords: t,
          contains: ["self"].concat(a)
        }
      ]
    }, f = { begin: "(#=>|=>|\\|>>|-?->|!->)" }, m = {
      variants: [
        { match: [
          /class\s+/,
          n,
          /\s+extends\s+/,
          n
        ] },
        { match: [
          /class\s+/,
          n
        ] }
      ],
      scope: {
        2: "title.class",
        4: "title.class.inherited"
      },
      keywords: t
    };
    return {
      name: "LiveScript",
      aliases: ["ls"],
      keywords: t,
      illegal: /\/\*/,
      contains: a.concat([
        e.COMMENT("\\/\\*", "\\*\\/"),
        e.HASH_COMMENT_MODE,
        f,
        // relevance booster
        {
          className: "function",
          contains: [
            b,
            y
          ],
          returnBegin: !0,
          variants: [
            {
              begin: "(" + n + "\\s*(?:=|:=)\\s*)?(\\(.*\\)\\s*)?\\B->\\*?",
              end: "->\\*?"
            },
            {
              begin: "(" + n + "\\s*(?:=|:=)\\s*)?!?(\\(.*\\)\\s*)?\\B[-~]{1,2}>\\*?",
              end: "[-~]{1,2}>\\*?"
            },
            {
              begin: "(" + n + "\\s*(?:=|:=)\\s*)?(\\(.*\\)\\s*)?\\B!?[-~]{1,2}>\\*?",
              end: "!?[-~]{1,2}>\\*?"
            }
          ]
        },
        m,
        {
          begin: n + ":",
          end: ":",
          returnBegin: !0,
          returnEnd: !0,
          relevance: 0
        }
      ])
    };
  }
  return s = _, s;
}
export {
  p as __require
};
