{"version":3,"file":"static/js/refractor-prismjs-vendor.0abbb2f3.5925778d.js","mappings":"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","sources":["../../node_modules/refractor/lib/prism-core.js","../../node_modules/refractor/lib/core.js","../../node_modules/refractor/lang/scheme.js","../../node_modules/refractor/lang/textile.js","../../node_modules/refractor/lang/uri.js","../../node_modules/refractor/lang/scala.js","../../node_modules/refractor/lang/stylus.js","../../node_modules/refractor/lang/twig.js","../../node_modules/refractor/lang/qsharp.js","../../node_modules/refractor/lang/q.js","../../node_modules/refractor/lang/qml.js","../../node_modules/refractor/lang/qore.js","../../node_modules/refractor/lang/racket.js","../../node_modules/refractor/lang/tsx.js","../../node_modules/refractor/lang/reason.js","../../node_modules/refractor/lang/rego.js","../../node_modules/refractor/lang/renpy.js","../../node_modules/refractor/lang/rescript.js","../../node_modules/refractor/lang/rest.js","../../node_modules/refractor/lang/rip.js","../../node_modules/refractor/lang/roboconf.js","../../node_modules/refractor/lang/robotframework.js","../../node_modules/refractor/lang/sas.js","../../node_modules/refractor/lang/shell-session.js","../../node_modules/refractor/lang/smali.js","../../node_modules/refractor/lang/smalltalk.js","../../node_modules/refractor/lang/smarty.js","../../node_modules/refractor/lang/sml.js","../../node_modules/refractor/lang/solidity.js","../../node_modules/refractor/lang/solution-file.js","../../node_modules/refractor/lang/soy.js","../../node_modules/refractor/lang/turtle.js","../../node_modules/refractor/lang/sparql.js","../../node_modules/refractor/lang/splunk-spl.js","../../node_modules/refractor/lang/sqf.js","../../node_modules/refractor/lang/squirrel.js","../../node_modules/refractor/lang/stan.js","../../node_modules/refractor/lang/stata.js","../../node_modules/refractor/lang/supercollider.js","../../node_modules/refractor/lang/systemd.js","../../node_modules/refractor/lang/t4-templating.js","../../node_modules/refractor/lang/t4-cs.js","../../node_modules/refractor/lang/t4-vb.js","../../node_modules/refractor/lang/tap.js","../../node_modules/refractor/lang/tcl.js","../../node_modules/refractor/lang/tt2.js","../../node_modules/refractor/lang/toml.js","../../node_modules/refractor/lang/tremor.js","../../node_modules/refractor/lang/typoscript.js","../../node_modules/refractor/lang/unrealscript.js","../../node_modules/refractor/lang/uorazor.js","../../node_modules/refractor/lang/v.js","../../node_modules/refractor/lang/vala.js","../../node_modules/refractor/lang/velocity.js","../../node_modules/refractor/lang/verilog.js","../../node_modules/refractor/lang/vhdl.js","../../node_modules/refractor/lang/vim.js","../../node_modules/refractor/lang/visual-basic.js","../../node_modules/refractor/lang/warpscript.js","../../node_modules/refractor/lang/wasm.js","../../node_modules/refractor/lang/web-idl.js","../../node_modules/refractor/lang/wgsl.js","../../node_modules/refractor/lang/wiki.js","../../node_modules/refractor/lang/wolfram.js","../../node_modules/refractor/lang/wren.js","../../node_modules/refractor/lang/xeora.js","../../node_modules/refractor/lang/xml-doc.js","../../node_modules/refractor/lang/xojo.js","../../node_modules/refractor/lang/xquery.js","../../node_modules/refractor/lang/yang.js","../../node_modules/refractor/lang/zig.js","../../node_modules/refractor/lib/all.js","../../node_modules/refractor/lang/vbnet.js","../../node_modules/refractor/lang/swift.js","../../node_modules/refractor/lang/yaml.js","../../node_modules/refractor/lang/typescript.js","../../node_modules/refractor/lang/rust.js","../../node_modules/refractor/lib/common.js","../../node_modules/refractor/lang/r.js","../../node_modules/refractor/lang/regex.js","../../node_modules/refractor/lang/sass.js","../../node_modules/refractor/lang/ruby.js","../../node_modules/refractor/lang/sql.js","../../node_modules/refractor/lang/scss.js"],"sourcesContent":["// @ts-nocheck\n\n// This is a slimmed down version of `prism-core.js`, to remove globals,\n// document, workers, `util.encode`, `Token.stringify`\n\n// Private helper vars\nvar lang = /(?:^|\\s)lang(?:uage)?-([\\w-]+)(?=\\s|$)/i\nvar uniqueId = 0\n\n// The grammar object for plaintext\nvar plainTextGrammar = {}\n\nvar _ = {\n  /**\n   * A namespace for utility methods.\n   *\n   * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may\n   * change or disappear at any time.\n   *\n   * @namespace\n   * @memberof Prism\n   */\n  util: {\n    /**\n     * Returns the name of the type of the given value.\n     *\n     * @param {any} o\n     * @returns {string}\n     * @example\n     * type(null)      === 'Null'\n     * type(undefined) === 'Undefined'\n     * type(123)       === 'Number'\n     * type('foo')     === 'String'\n     * type(true)      === 'Boolean'\n     * type([1, 2])    === 'Array'\n     * type({})        === 'Object'\n     * type(String)    === 'Function'\n     * type(/abc+/)    === 'RegExp'\n     */\n    type: function (o) {\n      return Object.prototype.toString.call(o).slice(8, -1)\n    },\n\n    /**\n     * Returns a unique number for the given object. Later calls will still return the same number.\n     *\n     * @param {Object} obj\n     * @returns {number}\n     */\n    objId: function (obj) {\n      if (!obj['__id']) {\n        Object.defineProperty(obj, '__id', {value: ++uniqueId})\n      }\n      return obj['__id']\n    },\n\n    /**\n     * Creates a deep clone of the given object.\n     *\n     * The main intended use of this function is to clone language definitions.\n     *\n     * @param {T} o\n     * @param {Record<number, any>} [visited]\n     * @returns {T}\n     * @template T\n     */\n    clone: function deepClone(o, visited) {\n      visited = visited || {}\n\n      var clone\n      var id\n      switch (_.util.type(o)) {\n        case 'Object':\n          id = _.util.objId(o)\n          if (visited[id]) {\n            return visited[id]\n          }\n          clone = /** @type {Record<string, any>} */ ({})\n          visited[id] = clone\n\n          for (var key in o) {\n            if (o.hasOwnProperty(key)) {\n              clone[key] = deepClone(o[key], visited)\n            }\n          }\n\n          return /** @type {any} */ (clone)\n\n        case 'Array':\n          id = _.util.objId(o)\n          if (visited[id]) {\n            return visited[id]\n          }\n          clone = []\n          visited[id] = clone\n\n          o.forEach(function (v, i) {\n            clone[i] = deepClone(v, visited)\n          })\n\n          return /** @type {any} */ (clone)\n\n        default:\n          return o\n      }\n    }\n  },\n\n  /**\n   * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.\n   *\n   * @namespace\n   * @memberof Prism\n   * @public\n   */\n  languages: {\n    /**\n     * The grammar for plain, unformatted text.\n     */\n    plain: plainTextGrammar,\n    plaintext: plainTextGrammar,\n    text: plainTextGrammar,\n    txt: plainTextGrammar,\n\n    /**\n     * Creates a deep copy of the language with the given id and appends the given tokens.\n     *\n     * If a token in `redef` also appears in the copied language, then the existing token in the copied language\n     * will be overwritten at its original position.\n     *\n     * ## Best practices\n     *\n     * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)\n     * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to\n     * understand the language definition because, normally, the order of tokens matters in Prism grammars.\n     *\n     * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.\n     * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.\n     *\n     * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.\n     * @param {Grammar} redef The new tokens to append.\n     * @returns {Grammar} The new language created.\n     * @public\n     * @example\n     * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {\n     *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token\n     *     // at its original position\n     *     'comment': { ... },\n     *     // CSS doesn't have a 'color' token, so this token will be appended\n     *     'color': /\\b(?:red|green|blue)\\b/\n     * });\n     */\n    extend: function (id, redef) {\n      var lang = _.util.clone(_.languages[id])\n\n      for (var key in redef) {\n        lang[key] = redef[key]\n      }\n\n      return lang\n    },\n\n    /**\n     * Inserts tokens _before_ another token in a language definition or any other grammar.\n     *\n     * ## Usage\n     *\n     * This helper method makes it easy to modify existing languages. For example, the CSS language definition\n     * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded\n     * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the\n     * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do\n     * this:\n     *\n     * ```js\n     * Prism.languages.markup.style = {\n     *     // token\n     * };\n     * ```\n     *\n     * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens\n     * before existing tokens. For the CSS example above, you would use it like this:\n     *\n     * ```js\n     * Prism.languages.insertBefore('markup', 'cdata', {\n     *     'style': {\n     *         // token\n     *     }\n     * });\n     * ```\n     *\n     * ## Special cases\n     *\n     * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar\n     * will be ignored.\n     *\n     * This behavior can be used to insert tokens after `before`:\n     *\n     * ```js\n     * Prism.languages.insertBefore('markup', 'comment', {\n     *     'comment': Prism.languages.markup.comment,\n     *     // tokens after 'comment'\n     * });\n     * ```\n     *\n     * ## Limitations\n     *\n     * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object\n     * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave\n     * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily\n     * deleting properties which is necessary to insert at arbitrary positions.\n     *\n     * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.\n     * Instead, it will create a new object and replace all references to the target object with the new one. This\n     * can be done without temporarily deleting properties, so the iteration order is well-defined.\n     *\n     * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if\n     * you hold the target object in a variable, then the value of the variable will not change.\n     *\n     * ```js\n     * var oldMarkup = Prism.languages.markup;\n     * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });\n     *\n     * assert(oldMarkup !== Prism.languages.markup);\n     * assert(newMarkup === Prism.languages.markup);\n     * ```\n     *\n     * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the\n     * object to be modified.\n     * @param {string} before The key to insert before.\n     * @param {Grammar} insert An object containing the key-value pairs to be inserted.\n     * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the\n     * object to be modified.\n     *\n     * Defaults to `Prism.languages`.\n     * @returns {Grammar} The new grammar object.\n     * @public\n     */\n    insertBefore: function (inside, before, insert, root) {\n      root = root || /** @type {any} */ (_.languages)\n      var grammar = root[inside]\n      /** @type {Grammar} */\n      var ret = {}\n\n      for (var token in grammar) {\n        if (grammar.hasOwnProperty(token)) {\n          if (token == before) {\n            for (var newToken in insert) {\n              if (insert.hasOwnProperty(newToken)) {\n                ret[newToken] = insert[newToken]\n              }\n            }\n          }\n\n          // Do not insert token which also occur in insert. See #1525\n          if (!insert.hasOwnProperty(token)) {\n            ret[token] = grammar[token]\n          }\n        }\n      }\n\n      var old = root[inside]\n      root[inside] = ret\n\n      // Update references in other language definitions\n      _.languages.DFS(_.languages, function (key, value) {\n        if (value === old && key != inside) {\n          this[key] = ret\n        }\n      })\n\n      return ret\n    },\n\n    // Traverse a language definition with Depth First Search\n    DFS: function DFS(o, callback, type, visited) {\n      visited = visited || {}\n\n      var objId = _.util.objId\n\n      for (var i in o) {\n        if (o.hasOwnProperty(i)) {\n          callback.call(o, i, o[i], type || i)\n\n          var property = o[i]\n          var propertyType = _.util.type(property)\n\n          if (propertyType === 'Object' && !visited[objId(property)]) {\n            visited[objId(property)] = true\n            DFS(property, callback, null, visited)\n          } else if (propertyType === 'Array' && !visited[objId(property)]) {\n            visited[objId(property)] = true\n            DFS(property, callback, i, visited)\n          }\n        }\n      }\n    }\n  },\n\n  plugins: {},\n\n  /**\n   * Low-level function, only use if you know what you’re doing. It accepts a string of text as input\n   * and the language definitions to use, and returns a string with the HTML produced.\n   *\n   * The following hooks will be run:\n   * 1. `before-tokenize`\n   * 2. `after-tokenize`\n   * 3. `wrap`: On each {@link Token}.\n   *\n   * @param {string} text A string with the code to be highlighted.\n   * @param {Grammar} grammar An object containing the tokens to use.\n   *\n   * Usually a language definition like `Prism.languages.markup`.\n   * @param {string} language The name of the language definition passed to `grammar`.\n   * @returns {string} The highlighted HTML.\n   * @memberof Prism\n   * @public\n   * @example\n   * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');\n   */\n  highlight: function (text, grammar, language) {\n    var env = {\n      code: text,\n      grammar: grammar,\n      language: language\n    }\n    _.hooks.run('before-tokenize', env)\n    if (!env.grammar) {\n      throw new Error('The language \"' + env.language + '\" has no grammar.')\n    }\n    env.tokens = _.tokenize(env.code, env.grammar)\n    _.hooks.run('after-tokenize', env)\n    return Token.stringify(_.util.encode(env.tokens), env.language)\n  },\n\n  /**\n   * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input\n   * and the language definitions to use, and returns an array with the tokenized code.\n   *\n   * When the language definition includes nested tokens, the function is called recursively on each of these tokens.\n   *\n   * This method could be useful in other contexts as well, as a very crude parser.\n   *\n   * @param {string} text A string with the code to be highlighted.\n   * @param {Grammar} grammar An object containing the tokens to use.\n   *\n   * Usually a language definition like `Prism.languages.markup`.\n   * @returns {TokenStream} An array of strings and tokens, a token stream.\n   * @memberof Prism\n   * @public\n   * @example\n   * let code = `var foo = 0;`;\n   * let tokens = Prism.tokenize(code, Prism.languages.javascript);\n   * tokens.forEach(token => {\n   *     if (token instanceof Prism.Token && token.type === 'number') {\n   *         console.log(`Found numeric literal: ${token.content}`);\n   *     }\n   * });\n   */\n  tokenize: function (text, grammar) {\n    var rest = grammar.rest\n    if (rest) {\n      for (var token in rest) {\n        grammar[token] = rest[token]\n      }\n\n      delete grammar.rest\n    }\n\n    var tokenList = new LinkedList()\n    addAfter(tokenList, tokenList.head, text)\n\n    matchGrammar(text, tokenList, grammar, tokenList.head, 0)\n\n    return toArray(tokenList)\n  },\n\n  /**\n   * @namespace\n   * @memberof Prism\n   * @public\n   */\n  hooks: {\n    all: {},\n\n    /**\n     * Adds the given callback to the list of callbacks for the given hook.\n     *\n     * The callback will be invoked when the hook it is registered for is run.\n     * Hooks are usually directly run by a highlight function but you can also run hooks yourself.\n     *\n     * One callback function can be registered to multiple hooks and the same hook multiple times.\n     *\n     * @param {string} name The name of the hook.\n     * @param {HookCallback} callback The callback function which is given environment variables.\n     * @public\n     */\n    add: function (name, callback) {\n      var hooks = _.hooks.all\n\n      hooks[name] = hooks[name] || []\n\n      hooks[name].push(callback)\n    },\n\n    /**\n     * Runs a hook invoking all registered callbacks with the given environment variables.\n     *\n     * Callbacks will be invoked synchronously and in the order in which they were registered.\n     *\n     * @param {string} name The name of the hook.\n     * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.\n     * @public\n     */\n    run: function (name, env) {\n      var callbacks = _.hooks.all[name]\n\n      if (!callbacks || !callbacks.length) {\n        return\n      }\n\n      for (var i = 0, callback; (callback = callbacks[i++]); ) {\n        callback(env)\n      }\n    }\n  },\n\n  Token: Token\n}\n\n// Typescript note:\n// The following can be used to import the Token type in JSDoc:\n//\n//   @typedef {InstanceType<import(\"./prism-core\")[\"Token\"]>} Token\n\n/**\n * Creates a new token.\n *\n * @param {string} type See {@link Token#type type}\n * @param {string | TokenStream} content See {@link Token#content content}\n * @param {string|string[]} [alias] The alias(es) of the token.\n * @param {string} [matchedStr=\"\"] A copy of the full string this token was created from.\n * @class\n * @global\n * @public\n */\nfunction Token(type, content, alias, matchedStr) {\n  /**\n   * The type of the token.\n   *\n   * This is usually the key of a pattern in a {@link Grammar}.\n   *\n   * @type {string}\n   * @see GrammarToken\n   * @public\n   */\n  this.type = type\n  /**\n   * The strings or tokens contained by this token.\n   *\n   * This will be a token stream if the pattern matched also defined an `inside` grammar.\n   *\n   * @type {string | TokenStream}\n   * @public\n   */\n  this.content = content\n  /**\n   * The alias(es) of the token.\n   *\n   * @type {string|string[]}\n   * @see GrammarToken\n   * @public\n   */\n  this.alias = alias\n  // Copy of the full string this token was created from\n  this.length = (matchedStr || '').length | 0\n}\n\n/**\n * A token stream is an array of strings and {@link Token Token} objects.\n *\n * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process\n * them.\n *\n * 1. No adjacent strings.\n * 2. No empty strings.\n *\n *    The only exception here is the token stream that only contains the empty string and nothing else.\n *\n * @typedef {Array<string | Token>} TokenStream\n * @global\n * @public\n */\n\n/**\n * @param {RegExp} pattern\n * @param {number} pos\n * @param {string} text\n * @param {boolean} lookbehind\n * @returns {RegExpExecArray | null}\n */\nfunction matchPattern(pattern, pos, text, lookbehind) {\n  pattern.lastIndex = pos\n  var match = pattern.exec(text)\n  if (match && lookbehind && match[1]) {\n    // change the match to remove the text matched by the Prism lookbehind group\n    var lookbehindLength = match[1].length\n    match.index += lookbehindLength\n    match[0] = match[0].slice(lookbehindLength)\n  }\n  return match\n}\n\n/**\n * @param {string} text\n * @param {LinkedList<string | Token>} tokenList\n * @param {any} grammar\n * @param {LinkedListNode<string | Token>} startNode\n * @param {number} startPos\n * @param {RematchOptions} [rematch]\n * @returns {void}\n * @private\n *\n * @typedef RematchOptions\n * @property {string} cause\n * @property {number} reach\n */\nfunction matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {\n  for (var token in grammar) {\n    if (!grammar.hasOwnProperty(token) || !grammar[token]) {\n      continue\n    }\n\n    var patterns = grammar[token]\n    patterns = Array.isArray(patterns) ? patterns : [patterns]\n\n    for (var j = 0; j < patterns.length; ++j) {\n      if (rematch && rematch.cause == token + ',' + j) {\n        return\n      }\n\n      var patternObj = patterns[j]\n      var inside = patternObj.inside\n      var lookbehind = !!patternObj.lookbehind\n      var greedy = !!patternObj.greedy\n      var alias = patternObj.alias\n\n      if (greedy && !patternObj.pattern.global) {\n        // Without the global flag, lastIndex won't work\n        var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0]\n        patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g')\n      }\n\n      /** @type {RegExp} */\n      var pattern = patternObj.pattern || patternObj\n\n      for (\n        // iterate the token list and keep track of the current token/string position\n        var currentNode = startNode.next, pos = startPos;\n        currentNode !== tokenList.tail;\n        pos += currentNode.value.length, currentNode = currentNode.next\n      ) {\n        if (rematch && pos >= rematch.reach) {\n          break\n        }\n\n        var str = currentNode.value\n\n        if (tokenList.length > text.length) {\n          // Something went terribly wrong, ABORT, ABORT!\n          return\n        }\n\n        if (str instanceof Token) {\n          continue\n        }\n\n        var removeCount = 1 // this is the to parameter of removeBetween\n        var match\n\n        if (greedy) {\n          match = matchPattern(pattern, pos, text, lookbehind)\n          if (!match || match.index >= text.length) {\n            break\n          }\n\n          var from = match.index\n          var to = match.index + match[0].length\n          var p = pos\n\n          // find the node that contains the match\n          p += currentNode.value.length\n          while (from >= p) {\n            currentNode = currentNode.next\n            p += currentNode.value.length\n          }\n          // adjust pos (and p)\n          p -= currentNode.value.length\n          pos = p\n\n          // the current node is a Token, then the match starts inside another Token, which is invalid\n          if (currentNode.value instanceof Token) {\n            continue\n          }\n\n          // find the last node which is affected by this match\n          for (\n            var k = currentNode;\n            k !== tokenList.tail && (p < to || typeof k.value === 'string');\n            k = k.next\n          ) {\n            removeCount++\n            p += k.value.length\n          }\n          removeCount--\n\n          // replace with the new match\n          str = text.slice(pos, p)\n          match.index -= pos\n        } else {\n          match = matchPattern(pattern, 0, str, lookbehind)\n          if (!match) {\n            continue\n          }\n        }\n\n        // eslint-disable-next-line no-redeclare\n        var from = match.index\n        var matchStr = match[0]\n        var before = str.slice(0, from)\n        var after = str.slice(from + matchStr.length)\n\n        var reach = pos + str.length\n        if (rematch && reach > rematch.reach) {\n          rematch.reach = reach\n        }\n\n        var removeFrom = currentNode.prev\n\n        if (before) {\n          removeFrom = addAfter(tokenList, removeFrom, before)\n          pos += before.length\n        }\n\n        removeRange(tokenList, removeFrom, removeCount)\n\n        var wrapped = new Token(\n          token,\n          inside ? _.tokenize(matchStr, inside) : matchStr,\n          alias,\n          matchStr\n        )\n        currentNode = addAfter(tokenList, removeFrom, wrapped)\n\n        if (after) {\n          addAfter(tokenList, currentNode, after)\n        }\n\n        if (removeCount > 1) {\n          // at least one Token object was removed, so we have to do some rematching\n          // this can only happen if the current pattern is greedy\n\n          /** @type {RematchOptions} */\n          var nestedRematch = {\n            cause: token + ',' + j,\n            reach: reach\n          }\n          matchGrammar(\n            text,\n            tokenList,\n            grammar,\n            currentNode.prev,\n            pos,\n            nestedRematch\n          )\n\n          // the reach might have been extended because of the rematching\n          if (rematch && nestedRematch.reach > rematch.reach) {\n            rematch.reach = nestedRematch.reach\n          }\n        }\n      }\n    }\n  }\n}\n\n/**\n * @typedef LinkedListNode\n * @property {T} value\n * @property {LinkedListNode<T> | null} prev The previous node.\n * @property {LinkedListNode<T> | null} next The next node.\n * @template T\n * @private\n */\n\n/**\n * @template T\n * @private\n */\nfunction LinkedList() {\n  /** @type {LinkedListNode<T>} */\n  var head = {value: null, prev: null, next: null}\n  /** @type {LinkedListNode<T>} */\n  var tail = {value: null, prev: head, next: null}\n  head.next = tail\n\n  /** @type {LinkedListNode<T>} */\n  this.head = head\n  /** @type {LinkedListNode<T>} */\n  this.tail = tail\n  this.length = 0\n}\n\n/**\n * Adds a new node with the given value to the list.\n *\n * @param {LinkedList<T>} list\n * @param {LinkedListNode<T>} node\n * @param {T} value\n * @returns {LinkedListNode<T>} The added node.\n * @template T\n */\nfunction addAfter(list, node, value) {\n  // assumes that node != list.tail && values.length >= 0\n  var next = node.next\n\n  var newNode = {value: value, prev: node, next: next}\n  node.next = newNode\n  next.prev = newNode\n  list.length++\n\n  return newNode\n}\n/**\n * Removes `count` nodes after the given node. The given node will not be removed.\n *\n * @param {LinkedList<T>} list\n * @param {LinkedListNode<T>} node\n * @param {number} count\n * @template T\n */\nfunction removeRange(list, node, count) {\n  var next = node.next\n  for (var i = 0; i < count && next !== list.tail; i++) {\n    next = next.next\n  }\n  node.next = next\n  next.prev = node\n  list.length -= i\n}\n/**\n * @param {LinkedList<T>} list\n * @returns {T[]}\n * @template T\n */\nfunction toArray(list) {\n  var array = []\n  var node = list.head.next\n  while (node !== list.tail) {\n    array.push(node.value)\n    node = node.next\n  }\n  return array\n}\n\nexport const Prism = _\n\n// some additional documentation/types\n\n/**\n * The expansion of a simple `RegExp` literal to support additional properties.\n *\n * @typedef GrammarToken\n * @property {RegExp} pattern The regular expression of the token.\n * @property {boolean} [lookbehind=false] If `true`, then the first capturing group of `pattern` will (effectively)\n * behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token.\n * @property {boolean} [greedy=false] Whether the token is greedy.\n * @property {string|string[]} [alias] An optional alias or list of aliases.\n * @property {Grammar} [inside] The nested grammar of this token.\n *\n * The `inside` grammar will be used to tokenize the text value of each token of this kind.\n *\n * This can be used to make nested and even recursive language definitions.\n *\n * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into\n * each another.\n * @global\n * @public\n */\n\n/**\n * @typedef Grammar\n * @type {Object<string, RegExp | GrammarToken | Array<RegExp | GrammarToken>>}\n * @property {Grammar} [rest] An optional grammar object that will be appended to this grammar.\n * @global\n * @public\n */\n\n/**\n * A function which will invoked after an element was successfully highlighted.\n *\n * @callback HighlightCallback\n * @param {Element} element The element successfully highlighted.\n * @returns {void}\n * @global\n * @public\n */\n\n/**\n * @callback HookCallback\n * @param {Object<string, any>} env The environment variables of the hook.\n * @returns {void}\n * @global\n * @public\n */\n","/**\n * @typedef _Token A hidden Prism token\n * @property {string} type\n * @property {string} content\n * @property {string} alias\n * @property {number} length\n *\n * @typedef _Env A hidden Prism environment\n * @property {string} type\n * @property {string} tag\n * @property {Text|RefractorElement|Array<Text|RefractorElement>} content\n * @property {Array<string>} classes\n * @property {Record<string, string>} attributes\n * @property {string} language\n *\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {Omit<Element, 'children'> & {children: Array<RefractorElement|Text>}} RefractorElement\n * @typedef {Omit<Root, 'children'> & {children: Array<RefractorElement|Text>}} RefractorRoot\n *\n * @typedef {import('prismjs').Languages} Languages\n * @typedef {import('prismjs').Grammar} Grammar Whatever this is, Prism handles it.\n * @typedef {((prism: unknown) => void) & {displayName: string, aliases?: Array<string>}} Syntax A refractor syntax function\n *\n * @typedef Refractor Virtual syntax highlighting\n * @property {highlight} highlight\n * @property {alias} alias\n * @property {register} register\n * @property {registered} registered\n * @property {listLanguages} listLanguages\n * @property {Languages} languages\n */\n\n// Load all stuff in `prism.js` itself, except for `prism-file-highlight.js`.\n// The wrapped non-leaky grammars are loaded instead of Prism’s originals.\nimport {h} from 'hastscript'\nimport {parseEntities} from 'parse-entities'\nimport {Prism} from './prism-core.js'\n\nconst own = {}.hasOwnProperty\n\n// Inherit.\nfunction Refractor() {}\n\nRefractor.prototype = Prism\n\n/** @type {Refractor} */\n// @ts-expect-error: TS is wrong.\nexport const refractor = new Refractor()\n\n// Create.\nrefractor.highlight = highlight\nrefractor.register = register\nrefractor.alias = alias\nrefractor.registered = registered\nrefractor.listLanguages = listLanguages\n\n// @ts-expect-error Overwrite Prism.\nrefractor.util.encode = encode\n// @ts-expect-error Overwrite Prism.\nrefractor.Token.stringify = stringify\n\n/**\n * Highlight `value` (code) as `language` (programming language).\n *\n * @param {string} value\n *   Code to highlight.\n * @param {string|Grammar} language\n *   Programming language name, alias, or grammar.\n * @returns {RefractorRoot}\n *   Node representing highlighted code.\n */\nfunction highlight(value, language) {\n  if (typeof value !== 'string') {\n    throw new TypeError('Expected `string` for `value`, got `' + value + '`')\n  }\n\n  /** @type {Grammar} */\n  let grammar\n  /** @type {string|undefined} */\n  let name\n\n  // `name` is a grammar object.\n  // This was called internally by Prism.js before 1.28.0.\n  /* c8 ignore next 2 */\n  if (language && typeof language === 'object') {\n    grammar = language\n  } else {\n    name = language\n\n    if (typeof name !== 'string') {\n      throw new TypeError('Expected `string` for `name`, got `' + name + '`')\n    }\n\n    if (own.call(refractor.languages, name)) {\n      grammar = refractor.languages[name]\n    } else {\n      throw new Error('Unknown language: `' + name + '` is not registered')\n    }\n  }\n\n  return {\n    type: 'root',\n    // @ts-expect-error: we hacked Prism to accept and return the things we want.\n    children: Prism.highlight.call(refractor, value, grammar, name)\n  }\n}\n\n/**\n * Register a syntax.\n *\n * @param {Syntax} syntax\n *   Language function made for refractor, as in, the files in\n *   `refractor/lang/*.js`.\n * @returns {void}\n */\nfunction register(syntax) {\n  if (typeof syntax !== 'function' || !syntax.displayName) {\n    throw new Error('Expected `function` for `syntax`, got `' + syntax + '`')\n  }\n\n  // Do not duplicate registrations.\n  if (!own.call(refractor.languages, syntax.displayName)) {\n    syntax(refractor)\n  }\n}\n\n/**\n * Register aliases for already registered languages.\n *\n * @param {Record<string, string|Array<string>>|string} language\n * @param {string|Array<string>} [alias]\n * @returns {void}\n */\nfunction alias(language, alias) {\n  const languages = refractor.languages\n  /** @type {Record<string, string|Array<string>>} */\n  let map = {}\n\n  if (typeof language === 'string') {\n    if (alias) {\n      map[language] = alias\n    }\n  } else {\n    map = language\n  }\n\n  /** @type {string} */\n  let key\n\n  for (key in map) {\n    if (own.call(map, key)) {\n      const value = map[key]\n      const list = typeof value === 'string' ? [value] : value\n      let index = -1\n\n      while (++index < list.length) {\n        languages[list[index]] = languages[key]\n      }\n    }\n  }\n}\n\n/**\n * Check whether an `alias` or `language` is registered.\n *\n * @param {string} aliasOrLanguage\n * @returns {boolean}\n */\nfunction registered(aliasOrLanguage) {\n  if (typeof aliasOrLanguage !== 'string') {\n    throw new TypeError(\n      'Expected `string` for `aliasOrLanguage`, got `' + aliasOrLanguage + '`'\n    )\n  }\n\n  return own.call(refractor.languages, aliasOrLanguage)\n}\n\n/**\n * List all registered languages (names and aliases).\n *\n * @returns {Array<string>}\n */\nfunction listLanguages() {\n  const languages = refractor.languages\n  /** @type {Array<string>} */\n  const list = []\n  /** @type {string} */\n  let language\n\n  for (language in languages) {\n    if (\n      own.call(languages, language) &&\n      typeof languages[language] === 'object'\n    ) {\n      list.push(language)\n    }\n  }\n\n  return list\n}\n\n/**\n * @param {string|_Token|Array<string|_Token>} value\n * @param {string} language\n * @returns {Text|RefractorElement|Array<Text|RefractorElement>}\n */\nfunction stringify(value, language) {\n  if (typeof value === 'string') {\n    return {type: 'text', value}\n  }\n\n  if (Array.isArray(value)) {\n    /** @type {Array<Text|RefractorElement>} */\n    const result = []\n    let index = -1\n\n    while (++index < value.length) {\n      if (\n        value[index] !== '' &&\n        value[index] !== null &&\n        value[index] !== undefined\n      ) {\n        // @ts-expect-error Assume no sub-arrays.\n        result.push(stringify(value[index], language))\n      }\n    }\n\n    return result\n  }\n\n  /** @type {_Env} */\n  const env = {\n    type: value.type,\n    content: stringify(value.content, language),\n    tag: 'span',\n    classes: ['token', value.type],\n    attributes: {},\n    language\n  }\n\n  if (value.alias) {\n    env.classes.push(\n      ...(typeof value.alias === 'string' ? [value.alias] : value.alias)\n    )\n  }\n\n  // @ts-expect-error Prism.\n  refractor.hooks.run('wrap', env)\n\n  // @ts-expect-error Hush, it’s fine.\n  return h(\n    env.tag + '.' + env.classes.join('.'),\n    attributes(env.attributes),\n    env.content\n  )\n}\n\n/**\n * @template {unknown} T\n * @param {T} tokens\n * @returns {T}\n */\nfunction encode(tokens) {\n  return tokens\n}\n\n/**\n * @param {Record<string, string>} attrs\n * @returns {Record<string, string>}\n */\nfunction attributes(attrs) {\n  /** @type {string} */\n  let key\n\n  for (key in attrs) {\n    if (own.call(attrs, key)) {\n      attrs[key] = parseEntities(attrs[key])\n    }\n  }\n\n  return attrs\n}\n","// @ts-nocheck\nscheme.displayName = 'scheme'\nscheme.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function scheme(Prism) {\n  ;(function (Prism) {\n    Prism.languages.scheme = {\n      // this supports \"normal\" single-line comments:\n      //   ; comment\n      // and (potentially nested) multiline comments:\n      //   #| comment #| nested |# still comment |#\n      // (only 1 level of nesting is supported)\n      comment:\n        /;.*|#;\\s*(?:\\((?:[^()]|\\([^()]*\\))*\\)|\\[(?:[^\\[\\]]|\\[[^\\[\\]]*\\])*\\])|#\\|(?:[^#|]|#(?!\\|)|\\|(?!#)|#\\|(?:[^#|]|#(?!\\|)|\\|(?!#))*\\|#)*\\|#/,\n      string: {\n        pattern: /\"(?:[^\"\\\\]|\\\\.)*\"/,\n        greedy: true\n      },\n      symbol: {\n        pattern: /'[^()\\[\\]#'\\s]+/,\n        greedy: true\n      },\n      char: {\n        pattern:\n          /#\\\\(?:[ux][a-fA-F\\d]+\\b|[-a-zA-Z]+\\b|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|\\S)/,\n        greedy: true\n      },\n      'lambda-parameter': [\n        // https://www.cs.cmu.edu/Groups/AI/html/r4rs/r4rs_6.html#SEC30\n        {\n          pattern:\n            /((?:^|[^'`#])[(\\[]lambda\\s+)(?:[^|()\\[\\]'\\s]+|\\|(?:[^\\\\|]|\\\\.)*\\|)/,\n          lookbehind: true\n        },\n        {\n          pattern: /((?:^|[^'`#])[(\\[]lambda\\s+[(\\[])[^()\\[\\]']+/,\n          lookbehind: true\n        }\n      ],\n      keyword: {\n        pattern:\n          /((?:^|[^'`#])[(\\[])(?:begin|case(?:-lambda)?|cond(?:-expand)?|define(?:-library|-macro|-record-type|-syntax|-values)?|defmacro|delay(?:-force)?|do|else|except|export|guard|if|import|include(?:-ci|-library-declarations)?|lambda|let(?:rec)?(?:-syntax|-values|\\*)?|let\\*-values|only|parameterize|prefix|(?:quasi-?)?quote|rename|set!|syntax-(?:case|rules)|unless|unquote(?:-splicing)?|when)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      builtin: {\n        // all functions of the base library of R7RS plus some of built-ins of R5Rs\n        pattern:\n          /((?:^|[^'`#])[(\\[])(?:abs|and|append|apply|assoc|ass[qv]|binary-port\\?|boolean=?\\?|bytevector(?:-append|-copy|-copy!|-length|-u8-ref|-u8-set!|\\?)?|caar|cadr|call-with-(?:current-continuation|port|values)|call\\/cc|car|cdar|cddr|cdr|ceiling|char(?:->integer|-ready\\?|\\?|<\\?|<=\\?|=\\?|>\\?|>=\\?)|close-(?:input-port|output-port|port)|complex\\?|cons|current-(?:error|input|output)-port|denominator|dynamic-wind|eof-object\\??|eq\\?|equal\\?|eqv\\?|error|error-object(?:-irritants|-message|\\?)|eval|even\\?|exact(?:-integer-sqrt|-integer\\?|\\?)?|expt|features|file-error\\?|floor(?:-quotient|-remainder|\\/)?|flush-output-port|for-each|gcd|get-output-(?:bytevector|string)|inexact\\??|input-port(?:-open\\?|\\?)|integer(?:->char|\\?)|lcm|length|list(?:->string|->vector|-copy|-ref|-set!|-tail|\\?)?|make-(?:bytevector|list|parameter|string|vector)|map|max|member|memq|memv|min|modulo|negative\\?|newline|not|null\\?|number(?:->string|\\?)|numerator|odd\\?|open-(?:input|output)-(?:bytevector|string)|or|output-port(?:-open\\?|\\?)|pair\\?|peek-char|peek-u8|port\\?|positive\\?|procedure\\?|quotient|raise|raise-continuable|rational\\?|rationalize|read-(?:bytevector|bytevector!|char|error\\?|line|string|u8)|real\\?|remainder|reverse|round|set-c[ad]r!|square|string(?:->list|->number|->symbol|->utf8|->vector|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\\?|<\\?|<=\\?|=\\?|>\\?|>=\\?)?|substring|symbol(?:->string|\\?|=\\?)|syntax-error|textual-port\\?|truncate(?:-quotient|-remainder|\\/)?|u8-ready\\?|utf8->string|values|vector(?:->list|->string|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\\?)?|with-exception-handler|write-(?:bytevector|char|string|u8)|zero\\?)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      operator: {\n        pattern: /((?:^|[^'`#])[(\\[])(?:[-+*%/]|[<>]=?|=>?)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      number: {\n        // The number pattern from [the R7RS spec](https://small.r7rs.org/attachment/r7rs.pdf).\n        //\n        // <number>      := <num 2>|<num 8>|<num 10>|<num 16>\n        // <num R>       := <prefix R><complex R>\n        // <complex R>   := <real R>(?:@<real R>|<imaginary R>)?|<imaginary R>\n        // <imaginary R> := [+-](?:<ureal R>|(?:inf|nan)\\.0)?i\n        // <real R>      := [+-]?<ureal R>|[+-](?:inf|nan)\\.0\n        // <ureal R>     := <uint R>(?:\\/<uint R>)?\n        //                | <decimal R>\n        //\n        // <decimal 10>  := (?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?\n        // <uint R>      := <digit R>+\n        // <prefix R>    := <radix R>(?:#[ei])?|(?:#[ei])?<radix R>\n        // <radix 2>     := #b\n        // <radix 8>     := #o\n        // <radix 10>    := (?:#d)?\n        // <radix 16>    := #x\n        // <digit 2>     := [01]\n        // <digit 8>     := [0-7]\n        // <digit 10>    := \\d\n        // <digit 16>    := [0-9a-f]\n        //\n        // The problem with this grammar is that the resulting regex is way to complex, so we simplify by grouping all\n        // non-decimal bases together. This results in a decimal (dec) and combined binary, octal, and hexadecimal (box)\n        // pattern:\n        pattern: RegExp(\n          SortedBNF({\n            '<ureal dec>':\n              /\\d+(?:\\/\\d+)|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[esfdl][+-]?\\d+)?/.source,\n            '<real dec>': /[+-]?<ureal dec>|[+-](?:inf|nan)\\.0/.source,\n            '<imaginary dec>': /[+-](?:<ureal dec>|(?:inf|nan)\\.0)?i/.source,\n            '<complex dec>':\n              /<real dec>(?:@<real dec>|<imaginary dec>)?|<imaginary dec>/\n                .source,\n            '<num dec>': /(?:#d(?:#[ei])?|#[ei](?:#d)?)?<complex dec>/.source,\n            '<ureal box>': /[0-9a-f]+(?:\\/[0-9a-f]+)?/.source,\n            '<real box>': /[+-]?<ureal box>|[+-](?:inf|nan)\\.0/.source,\n            '<imaginary box>': /[+-](?:<ureal box>|(?:inf|nan)\\.0)?i/.source,\n            '<complex box>':\n              /<real box>(?:@<real box>|<imaginary box>)?|<imaginary box>/\n                .source,\n            '<num box>': /#[box](?:#[ei])?|(?:#[ei])?#[box]<complex box>/\n              .source,\n            '<number>': /(^|[()\\[\\]\\s])(?:<num dec>|<num box>)(?=[()\\[\\]\\s]|$)/\n              .source\n          }),\n          'i'\n        ),\n        lookbehind: true\n      },\n      boolean: {\n        pattern: /(^|[()\\[\\]\\s])#(?:[ft]|false|true)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      function: {\n        pattern:\n          /((?:^|[^'`#])[(\\[])(?:[^|()\\[\\]'\\s]+|\\|(?:[^\\\\|]|\\\\.)*\\|)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      identifier: {\n        pattern: /(^|[()\\[\\]\\s])\\|(?:[^\\\\|]|\\\\.)*\\|(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true,\n        greedy: true\n      },\n      punctuation: /[()\\[\\]']/\n    }\n\n    /**\n     * Given a topologically sorted BNF grammar, this will return the RegExp source of last rule of the grammar.\n     *\n     * @param {Record<string, string>} grammar\n     * @returns {string}\n     */\n    function SortedBNF(grammar) {\n      for (var key in grammar) {\n        grammar[key] = grammar[key].replace(/<[\\w\\s]+>/g, function (key) {\n          return '(?:' + grammar[key].trim() + ')'\n        })\n      }\n      // return the last item\n      return grammar[key]\n    }\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorMarkup from './markup.js'\ntextile.displayName = 'textile'\ntextile.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function textile(Prism) {\n  Prism.register(refractorMarkup)\n  ;(function (Prism) {\n    // We don't allow for pipes inside parentheses\n    // to not break table pattern |(. foo |). bar |\n    var modifierRegex = /\\([^|()\\n]+\\)|\\[[^\\]\\n]+\\]|\\{[^}\\n]+\\}/.source\n    // Opening and closing parentheses which are not a modifier\n    // This pattern is necessary to prevent exponential backtracking\n    var parenthesesRegex = /\\)|\\((?![^|()\\n]+\\))/.source\n    /**\n     * @param {string} source\n     * @param {string} [flags]\n     */\n    function withModifier(source, flags) {\n      return RegExp(\n        source\n          .replace(/<MOD>/g, function () {\n            return '(?:' + modifierRegex + ')'\n          })\n          .replace(/<PAR>/g, function () {\n            return '(?:' + parenthesesRegex + ')'\n          }),\n        flags || ''\n      )\n    }\n    var modifierTokens = {\n      css: {\n        pattern: /\\{[^{}]+\\}/,\n        inside: {\n          rest: Prism.languages.css\n        }\n      },\n      'class-id': {\n        pattern: /(\\()[^()]+(?=\\))/,\n        lookbehind: true,\n        alias: 'attr-value'\n      },\n      lang: {\n        pattern: /(\\[)[^\\[\\]]+(?=\\])/,\n        lookbehind: true,\n        alias: 'attr-value'\n      },\n      // Anything else is punctuation (the first pattern is for row/col spans inside tables)\n      punctuation: /[\\\\\\/]\\d+|\\S/\n    }\n    var textile = (Prism.languages.textile = Prism.languages.extend('markup', {\n      phrase: {\n        pattern: /(^|\\r|\\n)\\S[\\s\\S]*?(?=$|\\r?\\n\\r?\\n|\\r\\r)/,\n        lookbehind: true,\n        inside: {\n          // h1. Header 1\n          'block-tag': {\n            pattern: withModifier(/^[a-z]\\w*(?:<MOD>|<PAR>|[<>=])*\\./.source),\n            inside: {\n              modifier: {\n                pattern: withModifier(\n                  /(^[a-z]\\w*)(?:<MOD>|<PAR>|[<>=])+(?=\\.)/.source\n                ),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              tag: /^[a-z]\\w*/,\n              punctuation: /\\.$/\n            }\n          },\n          // # List item\n          // * List item\n          list: {\n            pattern: withModifier(/^[*#]+<MOD>*\\s+\\S.*/.source, 'm'),\n            inside: {\n              modifier: {\n                pattern: withModifier(/(^[*#]+)<MOD>+/.source),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              punctuation: /^[*#]+/\n            }\n          },\n          // | cell | cell | cell |\n          table: {\n            // Modifiers can be applied to the row: {color:red}.|1|2|3|\n            // or the cell: |{color:red}.1|2|3|\n            pattern: withModifier(\n              /^(?:(?:<MOD>|<PAR>|[<>=^~])+\\.\\s*)?(?:\\|(?:(?:<MOD>|<PAR>|[<>=^~_]|[\\\\/]\\d+)+\\.|(?!(?:<MOD>|<PAR>|[<>=^~_]|[\\\\/]\\d+)+\\.))[^|]*)+\\|/\n                .source,\n              'm'\n            ),\n            inside: {\n              modifier: {\n                // Modifiers for rows after the first one are\n                // preceded by a pipe and a line feed\n                pattern: withModifier(\n                  /(^|\\|(?:\\r?\\n|\\r)?)(?:<MOD>|<PAR>|[<>=^~_]|[\\\\/]\\d+)+(?=\\.)/\n                    .source\n                ),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              punctuation: /\\||^\\./\n            }\n          },\n          inline: {\n            // eslint-disable-next-line regexp/no-super-linear-backtracking\n            pattern: withModifier(\n              /(^|[^a-zA-Z\\d])(\\*\\*|__|\\?\\?|[*_%@+\\-^~])<MOD>*.+?\\2(?![a-zA-Z\\d])/\n                .source\n            ),\n            lookbehind: true,\n            inside: {\n              // Note: superscripts and subscripts are not handled specifically\n\n              // *bold*, **bold**\n              bold: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^(\\*\\*?)<MOD>*).+?(?=\\2)/.source),\n                lookbehind: true\n              },\n              // _italic_, __italic__\n              italic: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^(__?)<MOD>*).+?(?=\\2)/.source),\n                lookbehind: true\n              },\n              // ??cite??\n              cite: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^\\?\\?<MOD>*).+?(?=\\?\\?)/.source),\n                lookbehind: true,\n                alias: 'string'\n              },\n              // @code@\n              code: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^@<MOD>*).+?(?=@)/.source),\n                lookbehind: true,\n                alias: 'keyword'\n              },\n              // +inserted+\n              inserted: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^\\+<MOD>*).+?(?=\\+)/.source),\n                lookbehind: true\n              },\n              // -deleted-\n              deleted: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^-<MOD>*).+?(?=-)/.source),\n                lookbehind: true\n              },\n              // %span%\n              span: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^%<MOD>*).+?(?=%)/.source),\n                lookbehind: true\n              },\n              modifier: {\n                pattern: withModifier(\n                  /(^\\*\\*|__|\\?\\?|[*_%@+\\-^~])<MOD>+/.source\n                ),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              punctuation: /[*_%?@+\\-^~]+/\n            }\n          },\n          // [alias]http://example.com\n          'link-ref': {\n            pattern: /^\\[[^\\]]+\\]\\S+$/m,\n            inside: {\n              string: {\n                pattern: /(^\\[)[^\\]]+(?=\\])/,\n                lookbehind: true\n              },\n              url: {\n                pattern: /(^\\])\\S+$/,\n                lookbehind: true\n              },\n              punctuation: /[\\[\\]]/\n            }\n          },\n          // \"text\":http://example.com\n          // \"text\":link-ref\n          link: {\n            // eslint-disable-next-line regexp/no-super-linear-backtracking\n            pattern: withModifier(\n              /\"<MOD>*[^\"]+\":.+?(?=[^\\w/]?(?:\\s|$))/.source\n            ),\n            inside: {\n              text: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^\"<MOD>*)[^\"]+(?=\")/.source),\n                lookbehind: true\n              },\n              modifier: {\n                pattern: withModifier(/(^\")<MOD>+/.source),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              url: {\n                pattern: /(:).+/,\n                lookbehind: true\n              },\n              punctuation: /[\":]/\n            }\n          },\n          // !image.jpg!\n          // !image.jpg(Title)!:http://example.com\n          image: {\n            pattern: withModifier(\n              /!(?:<MOD>|<PAR>|[<>=])*(?![<>=])[^!\\s()]+(?:\\([^)]+\\))?!(?::.+?(?=[^\\w/]?(?:\\s|$)))?/\n                .source\n            ),\n            inside: {\n              source: {\n                pattern: withModifier(\n                  /(^!(?:<MOD>|<PAR>|[<>=])*)(?![<>=])[^!\\s()]+(?:\\([^)]+\\))?(?=!)/\n                    .source\n                ),\n                lookbehind: true,\n                alias: 'url'\n              },\n              modifier: {\n                pattern: withModifier(/(^!)(?:<MOD>|<PAR>|[<>=])+/.source),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              url: {\n                pattern: /(:).+/,\n                lookbehind: true\n              },\n              punctuation: /[!:]/\n            }\n          },\n          // Footnote[1]\n          footnote: {\n            pattern: /\\b\\[\\d+\\]/,\n            alias: 'comment',\n            inside: {\n              punctuation: /\\[|\\]/\n            }\n          },\n          // CSS(Cascading Style Sheet)\n          acronym: {\n            pattern: /\\b[A-Z\\d]+\\([^)]+\\)/,\n            inside: {\n              comment: {\n                pattern: /(\\()[^()]+(?=\\))/,\n                lookbehind: true\n              },\n              punctuation: /[()]/\n            }\n          },\n          // Prism(C)\n          mark: {\n            pattern: /\\b\\((?:C|R|TM)\\)/,\n            alias: 'comment',\n            inside: {\n              punctuation: /[()]/\n            }\n          }\n        }\n      }\n    }))\n    var phraseInside = textile['phrase'].inside\n    var nestedPatterns = {\n      inline: phraseInside['inline'],\n      link: phraseInside['link'],\n      image: phraseInside['image'],\n      footnote: phraseInside['footnote'],\n      acronym: phraseInside['acronym'],\n      mark: phraseInside['mark']\n    }\n\n    // Only allow alpha-numeric HTML tags, not XML tags\n    textile.tag.pattern =\n      /<\\/?(?!\\d)[a-z0-9]+(?:\\s+[^\\s>\\/=]+(?:=(?:(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|[^\\s'\">=]+))?)*\\s*\\/?>/i\n\n    // Allow some nesting\n    var phraseInlineInside = phraseInside['inline'].inside\n    phraseInlineInside['bold'].inside = nestedPatterns\n    phraseInlineInside['italic'].inside = nestedPatterns\n    phraseInlineInside['inserted'].inside = nestedPatterns\n    phraseInlineInside['deleted'].inside = nestedPatterns\n    phraseInlineInside['span'].inside = nestedPatterns\n\n    // Allow some styles inside table cells\n    var phraseTableInside = phraseInside['table'].inside\n    phraseTableInside['inline'] = nestedPatterns['inline']\n    phraseTableInside['link'] = nestedPatterns['link']\n    phraseTableInside['image'] = nestedPatterns['image']\n    phraseTableInside['footnote'] = nestedPatterns['footnote']\n    phraseTableInside['acronym'] = nestedPatterns['acronym']\n    phraseTableInside['mark'] = nestedPatterns['mark']\n  })(Prism)\n}\n","// @ts-nocheck\nuri.displayName = 'uri'\nuri.aliases = ['url']\n\n/** @type {import('../core.js').Syntax} */\nexport default function uri(Prism) {\n  // https://tools.ietf.org/html/rfc3986#appendix-A\n\n  Prism.languages.uri = {\n    scheme: {\n      pattern: /^[a-z][a-z0-9+.-]*:/im,\n      greedy: true,\n      inside: {\n        'scheme-delimiter': /:$/\n      }\n    },\n    fragment: {\n      pattern: /#[\\w\\-.~!$&'()*+,;=%:@/?]*/,\n      inside: {\n        'fragment-delimiter': /^#/\n      }\n    },\n    query: {\n      pattern: /\\?[\\w\\-.~!$&'()*+,;=%:@/?]*/,\n      inside: {\n        'query-delimiter': {\n          pattern: /^\\?/,\n          greedy: true\n        },\n        'pair-delimiter': /[&;]/,\n        pair: {\n          pattern: /^[^=][\\s\\S]*/,\n          inside: {\n            key: /^[^=]+/,\n            value: {\n              pattern: /(^=)[\\s\\S]+/,\n              lookbehind: true\n            }\n          }\n        }\n      }\n    },\n    authority: {\n      pattern: RegExp(\n        /^\\/\\//.source +\n          // [ userinfo \"@\" ]\n          /(?:[\\w\\-.~!$&'()*+,;=%:]*@)?/.source +\n          // host\n          ('(?:' +\n            // IP-literal\n            /\\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\\.[\\w\\-.~!$&'()*+,;=]+)\\]/\n              .source +\n            '|' +\n            // IPv4address or registered name\n            /[\\w\\-.~!$&'()*+,;=%]*/.source +\n            ')') +\n          // [ \":\" port ]\n          /(?::\\d*)?/.source,\n        'm'\n      ),\n      inside: {\n        'authority-delimiter': /^\\/\\//,\n        'user-info-segment': {\n          pattern: /^[\\w\\-.~!$&'()*+,;=%:]*@/,\n          inside: {\n            'user-info-delimiter': /@$/,\n            'user-info': /^[\\w\\-.~!$&'()*+,;=%:]+/\n          }\n        },\n        'port-segment': {\n          pattern: /:\\d*$/,\n          inside: {\n            'port-delimiter': /^:/,\n            port: /^\\d+/\n          }\n        },\n        host: {\n          pattern: /[\\s\\S]+/,\n          inside: {\n            'ip-literal': {\n              pattern: /^\\[[\\s\\S]+\\]$/,\n              inside: {\n                'ip-literal-delimiter': /^\\[|\\]$/,\n                'ipv-future': /^v[\\s\\S]+/,\n                'ipv6-address': /^[\\s\\S]+/\n              }\n            },\n            'ipv4-address':\n              /^(?:(?:[03-9]\\d?|[12]\\d{0,2})\\.){3}(?:[03-9]\\d?|[12]\\d{0,2})$/\n          }\n        }\n      }\n    },\n    path: {\n      pattern: /^[\\w\\-.~!$&'()*+,;=%:@/]+/m,\n      inside: {\n        'path-separator': /\\//\n      }\n    }\n  }\n  Prism.languages.url = Prism.languages.uri\n}\n","// @ts-nocheck\nimport refractorJava from './java.js'\nscala.displayName = 'scala'\nscala.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function scala(Prism) {\n  Prism.register(refractorJava)\n  Prism.languages.scala = Prism.languages.extend('java', {\n    'triple-quoted-string': {\n      pattern: /\"\"\"[\\s\\S]*?\"\"\"/,\n      greedy: true,\n      alias: 'string'\n    },\n    string: {\n      pattern: /(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    keyword:\n      /<-|=>|\\b(?:abstract|case|catch|class|def|derives|do|else|enum|extends|extension|final|finally|for|forSome|given|if|implicit|import|infix|inline|lazy|match|new|null|object|opaque|open|override|package|private|protected|return|sealed|self|super|this|throw|trait|transparent|try|type|using|val|var|while|with|yield)\\b/,\n    number:\n      /\\b0x(?:[\\da-f]*\\.)?[\\da-f]+|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e\\d+)?[dfl]?/i,\n    builtin:\n      /\\b(?:Any|AnyRef|AnyVal|Boolean|Byte|Char|Double|Float|Int|Long|Nothing|Short|String|Unit)\\b/,\n    symbol: /'[^\\d\\s\\\\]\\w*/\n  })\n  Prism.languages.insertBefore('scala', 'triple-quoted-string', {\n    'string-interpolation': {\n      pattern:\n        /\\b[a-z]\\w*(?:\"\"\"(?:[^$]|\\$(?:[^{]|\\{(?:[^{}]|\\{[^{}]*\\})*\\}))*?\"\"\"|\"(?:[^$\"\\r\\n]|\\$(?:[^{]|\\{(?:[^{}]|\\{[^{}]*\\})*\\}))*\")/i,\n      greedy: true,\n      inside: {\n        id: {\n          pattern: /^\\w+/,\n          greedy: true,\n          alias: 'function'\n        },\n        escape: {\n          pattern: /\\\\\\$\"|\\$[$\"]/,\n          greedy: true,\n          alias: 'symbol'\n        },\n        interpolation: {\n          pattern: /\\$(?:\\w+|\\{(?:[^{}]|\\{[^{}]*\\})*\\})/,\n          greedy: true,\n          inside: {\n            punctuation: /^\\$\\{?|\\}$/,\n            expression: {\n              pattern: /[\\s\\S]+/,\n              inside: Prism.languages.scala\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n  })\n  delete Prism.languages.scala['class-name']\n  delete Prism.languages.scala['function']\n  delete Prism.languages.scala['constant']\n}\n","// @ts-nocheck\nstylus.displayName = 'stylus'\nstylus.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function stylus(Prism) {\n  ;(function (Prism) {\n    var unit = {\n      pattern: /(\\b\\d+)(?:%|[a-z]+)/,\n      lookbehind: true\n    }\n    // 123 -123 .123 -.123 12.3 -12.3\n    var number = {\n      pattern: /(^|[^\\w.-])-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/,\n      lookbehind: true\n    }\n    var inside = {\n      comment: {\n        pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n        lookbehind: true\n      },\n      url: {\n        pattern: /\\burl\\(([\"']?).*?\\1\\)/i,\n        greedy: true\n      },\n      string: {\n        pattern: /(\"|')(?:(?!\\1)[^\\\\\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*\\1/,\n        greedy: true\n      },\n      interpolation: null,\n      // See below\n      func: null,\n      // See below\n      important: /\\B!(?:important|optional)\\b/i,\n      keyword: {\n        pattern: /(^|\\s+)(?:(?:else|for|if|return|unless)(?=\\s|$)|@[\\w-]+)/,\n        lookbehind: true\n      },\n      hexcode: /#[\\da-f]{3,6}/i,\n      color: [\n        /\\b(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)\\b/i,\n        {\n          pattern:\n            /\\b(?:hsl|rgb)\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}%?\\s*,\\s*\\d{1,3}%?\\s*\\)\\B|\\b(?:hsl|rgb)a\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}%?\\s*,\\s*\\d{1,3}%?\\s*,\\s*(?:0|0?\\.\\d+|1)\\s*\\)\\B/i,\n          inside: {\n            unit: unit,\n            number: number,\n            function: /[\\w-]+(?=\\()/,\n            punctuation: /[(),]/\n          }\n        }\n      ],\n      entity: /\\\\[\\da-f]{1,8}/i,\n      unit: unit,\n      boolean: /\\b(?:false|true)\\b/,\n      operator: [\n        // We want non-word chars around \"-\" because it is\n        // accepted in property names.\n        /~|[+!\\/%<>?=]=?|[-:]=|\\*[*=]?|\\.{2,3}|&&|\\|\\||\\B-\\B|\\b(?:and|in|is(?: a| defined| not|nt)?|not|or)\\b/\n      ],\n      number: number,\n      punctuation: /[{}()\\[\\];:,]/\n    }\n    inside['interpolation'] = {\n      pattern: /\\{[^\\r\\n}:]+\\}/,\n      alias: 'variable',\n      inside: {\n        delimiter: {\n          pattern: /^\\{|\\}$/,\n          alias: 'punctuation'\n        },\n        rest: inside\n      }\n    }\n    inside['func'] = {\n      pattern: /[\\w-]+\\([^)]*\\).*/,\n      inside: {\n        function: /^[^(]+/,\n        rest: inside\n      }\n    }\n    Prism.languages.stylus = {\n      'atrule-declaration': {\n        pattern: /(^[ \\t]*)@.+/m,\n        lookbehind: true,\n        inside: {\n          atrule: /^@[\\w-]+/,\n          rest: inside\n        }\n      },\n      'variable-declaration': {\n        pattern: /(^[ \\t]*)[\\w$-]+\\s*.?=[ \\t]*(?:\\{[^{}]*\\}|\\S.*|$)/m,\n        lookbehind: true,\n        inside: {\n          variable: /^\\S+/,\n          rest: inside\n        }\n      },\n      statement: {\n        pattern: /(^[ \\t]*)(?:else|for|if|return|unless)[ \\t].+/m,\n        lookbehind: true,\n        inside: {\n          keyword: /^\\S+/,\n          rest: inside\n        }\n      },\n      // A property/value pair cannot end with a comma or a brace\n      // It cannot have indented content unless it ended with a semicolon\n      'property-declaration': {\n        pattern:\n          /((?:^|\\{)([ \\t]*))(?:[\\w-]|\\{[^}\\r\\n]+\\})+(?:\\s*:\\s*|[ \\t]+)(?!\\s)[^{\\r\\n]*(?:;|[^{\\r\\n,]$(?!(?:\\r?\\n|\\r)(?:\\{|\\2[ \\t])))/m,\n        lookbehind: true,\n        inside: {\n          property: {\n            pattern: /^[^\\s:]+/,\n            inside: {\n              interpolation: inside.interpolation\n            }\n          },\n          rest: inside\n        }\n      },\n      // A selector can contain parentheses only as part of a pseudo-element\n      // It can span multiple lines.\n      // It must end with a comma or an accolade or have indented content.\n      selector: {\n        pattern:\n          /(^[ \\t]*)(?:(?=\\S)(?:[^{}\\r\\n:()]|::?[\\w-]+(?:\\([^)\\r\\n]*\\)|(?![\\w-]))|\\{[^}\\r\\n]+\\})+)(?:(?:\\r?\\n|\\r)(?:\\1(?:(?=\\S)(?:[^{}\\r\\n:()]|::?[\\w-]+(?:\\([^)\\r\\n]*\\)|(?![\\w-]))|\\{[^}\\r\\n]+\\})+)))*(?:,$|\\{|(?=(?:\\r?\\n|\\r)(?:\\{|\\1[ \\t])))/m,\n        lookbehind: true,\n        inside: {\n          interpolation: inside.interpolation,\n          comment: inside.comment,\n          punctuation: /[{},]/\n        }\n      },\n      func: inside.func,\n      string: inside.string,\n      comment: {\n        pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n        lookbehind: true,\n        greedy: true\n      },\n      interpolation: inside.interpolation,\n      punctuation: /[{}()\\[\\];:.]/\n    }\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorMarkupTemplating from './markup-templating.js'\ntwig.displayName = 'twig'\ntwig.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function twig(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  Prism.languages.twig = {\n    comment: /^\\{#[\\s\\S]*?#\\}$/,\n    'tag-name': {\n      pattern: /(^\\{%-?\\s*)\\w+/,\n      lookbehind: true,\n      alias: 'keyword'\n    },\n    delimiter: {\n      pattern: /^\\{[{%]-?|-?[%}]\\}$/,\n      alias: 'punctuation'\n    },\n    string: {\n      pattern: /(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      inside: {\n        punctuation: /^['\"]|['\"]$/\n      }\n    },\n    keyword: /\\b(?:even|if|odd)\\b/,\n    boolean: /\\b(?:false|null|true)\\b/,\n    number: /\\b0x[\\dA-Fa-f]+|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee][-+]?\\d+)?/,\n    operator: [\n      {\n        pattern:\n          /(\\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\\s)/,\n        lookbehind: true\n      },\n      /[=<>]=?|!=|\\*\\*?|\\/\\/?|\\?:?|[-+~%|]/\n    ],\n    punctuation: /[()\\[\\]{}:.,]/\n  }\n  Prism.hooks.add('before-tokenize', function (env) {\n    if (env.language !== 'twig') {\n      return\n    }\n    var pattern = /\\{(?:#[\\s\\S]*?#|%[\\s\\S]*?%|\\{[\\s\\S]*?\\})\\}/g\n    Prism.languages['markup-templating'].buildPlaceholders(env, 'twig', pattern)\n  })\n  Prism.hooks.add('after-tokenize', function (env) {\n    Prism.languages['markup-templating'].tokenizePlaceholders(env, 'twig')\n  })\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nqsharp.displayName = 'qsharp'\nqsharp.aliases = ['qs']\n\n/** @type {import('../core.js').Syntax} */\nexport default function qsharp(Prism) {\n  Prism.register(refractorClike)\n  ;(function (Prism) {\n    /**\n     * Replaces all placeholders \"<<n>>\" of given pattern with the n-th replacement (zero based).\n     *\n     * Note: This is a simple text based replacement. Be careful when using backreferences!\n     *\n     * @param {string} pattern the given pattern.\n     * @param {string[]} replacements a list of replacement which can be inserted into the given pattern.\n     * @returns {string} the pattern with all placeholders replaced with their corresponding replacements.\n     * @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source\n     */\n    function replace(pattern, replacements) {\n      return pattern.replace(/<<(\\d+)>>/g, function (m, index) {\n        return '(?:' + replacements[+index] + ')'\n      })\n    }\n    /**\n     * @param {string} pattern\n     * @param {string[]} replacements\n     * @param {string} [flags]\n     * @returns {RegExp}\n     */\n    function re(pattern, replacements, flags) {\n      return RegExp(replace(pattern, replacements), flags || '')\n    }\n\n    /**\n     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.\n     *\n     * @param {string} pattern\n     * @param {number} depthLog2\n     * @returns {string}\n     */\n    function nested(pattern, depthLog2) {\n      for (var i = 0; i < depthLog2; i++) {\n        pattern = pattern.replace(/<<self>>/g, function () {\n          return '(?:' + pattern + ')'\n        })\n      }\n      return pattern.replace(/<<self>>/g, '[^\\\\s\\\\S]')\n    }\n\n    // https://docs.microsoft.com/en-us/azure/quantum/user-guide/language/typesystem/\n    // https://github.com/microsoft/qsharp-language/tree/main/Specifications/Language/5_Grammar\n    var keywordKinds = {\n      // keywords which represent a return or variable type\n      type: 'Adj BigInt Bool Ctl Double false Int One Pauli PauliI PauliX PauliY PauliZ Qubit Range Result String true Unit Zero',\n      // all other keywords\n      other:\n        'Adjoint adjoint apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new newtype open operation repeat return self set until use using while within'\n    }\n    // keywords\n    function keywordsToPattern(words) {\n      return '\\\\b(?:' + words.trim().replace(/ /g, '|') + ')\\\\b'\n    }\n    var keywords = RegExp(\n      keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.other)\n    )\n\n    // types\n    var identifier = /\\b[A-Za-z_]\\w*\\b/.source\n    var qualifiedName = replace(/<<0>>(?:\\s*\\.\\s*<<0>>)*/.source, [identifier])\n    var typeInside = {\n      keyword: keywords,\n      punctuation: /[<>()?,.:[\\]]/\n    }\n\n    // strings\n    var regularString = /\"(?:\\\\.|[^\\\\\"])*\"/.source\n    Prism.languages.qsharp = Prism.languages.extend('clike', {\n      comment: /\\/\\/.*/,\n      string: [\n        {\n          pattern: re(/(^|[^$\\\\])<<0>>/.source, [regularString]),\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      'class-name': [\n        {\n          // open Microsoft.Quantum.Canon;\n          // open Microsoft.Quantum.Canon as CN;\n          pattern: re(/(\\b(?:as|open)\\s+)<<0>>(?=\\s*(?:;|as\\b))/.source, [\n            qualifiedName\n          ]),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // namespace Quantum.App1;\n          pattern: re(/(\\bnamespace\\s+)<<0>>(?=\\s*\\{)/.source, [qualifiedName]),\n          lookbehind: true,\n          inside: typeInside\n        }\n      ],\n      keyword: keywords,\n      number:\n        /(?:\\b0(?:x[\\da-f]+|b[01]+|o[0-7]+)|(?:\\B\\.\\d+|\\b\\d+(?:\\.\\d*)?)(?:e[-+]?\\d+)?)l?\\b/i,\n      operator:\n        /\\band=|\\bor=|\\band\\b|\\bnot\\b|\\bor\\b|<[-=]|[-=]>|>>>=?|<<<=?|\\^\\^\\^=?|\\|\\|\\|=?|&&&=?|w\\/=?|~~~|[*\\/+\\-^=!%]=?/,\n      punctuation: /::|[{}[\\];(),.:]/\n    })\n    Prism.languages.insertBefore('qsharp', 'number', {\n      range: {\n        pattern: /\\.\\./,\n        alias: 'operator'\n      }\n    })\n\n    // single line\n    var interpolationExpr = nested(\n      replace(/\\{(?:[^\"{}]|<<0>>|<<self>>)*\\}/.source, [regularString]),\n      2\n    )\n    Prism.languages.insertBefore('qsharp', 'string', {\n      'interpolation-string': {\n        pattern: re(/\\$\"(?:\\\\.|<<0>>|[^\\\\\"{])*\"/.source, [interpolationExpr]),\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern: re(/((?:^|[^\\\\])(?:\\\\\\\\)*)<<0>>/.source, [\n              interpolationExpr\n            ]),\n            lookbehind: true,\n            inside: {\n              punctuation: /^\\{|\\}$/,\n              expression: {\n                pattern: /[\\s\\S]+/,\n                alias: 'language-qsharp',\n                inside: Prism.languages.qsharp\n              }\n            }\n          },\n          string: /[\\s\\S]+/\n        }\n      }\n    })\n  })(Prism)\n  Prism.languages.qs = Prism.languages.qsharp\n}\n","// @ts-nocheck\nq.displayName = 'q'\nq.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function q(Prism) {\n  Prism.languages.q = {\n    string: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n    comment: [\n      // From http://code.kx.com/wiki/Reference/Slash:\n      // When / is following a space (or a right parenthesis, bracket, or brace), it is ignored with the rest of the line.\n      {\n        pattern: /([\\t )\\]}])\\/.*/,\n        lookbehind: true,\n        greedy: true\n      },\n      // From http://code.kx.com/wiki/Reference/Slash:\n      // A line which has / as its first character and contains at least one other non-whitespace character is a whole-line comment and is ignored entirely.\n      // A / on a line by itself begins a multiline comment which is terminated by the next \\ on a line by itself.\n      // If a / is not matched by a \\, the multiline comment is unterminated and continues to end of file.\n      // The / and \\ must be the first char on the line, but may be followed by any amount of whitespace.\n      {\n        pattern:\n          /(^|\\r?\\n|\\r)\\/[\\t ]*(?:(?:\\r?\\n|\\r)(?:.*(?:\\r?\\n|\\r(?!\\n)))*?(?:\\\\(?=[\\t ]*(?:\\r?\\n|\\r))|$)|\\S.*)/,\n        lookbehind: true,\n        greedy: true\n      },\n      // From http://code.kx.com/wiki/Reference/Slash:\n      // A \\ on a line by itself with no preceding matching / will comment to end of file.\n      {\n        pattern: /^\\\\[\\t ]*(?:\\r?\\n|\\r)[\\s\\S]+/m,\n        greedy: true\n      },\n      {\n        pattern: /^#!.+/m,\n        greedy: true\n      }\n    ],\n    symbol: /`(?::\\S+|[\\w.]*)/,\n    datetime: {\n      pattern:\n        /0N[mdzuvt]|0W[dtz]|\\d{4}\\.\\d\\d(?:m|\\.\\d\\d(?:T(?:\\d\\d(?::\\d\\d(?::\\d\\d(?:[.:]\\d\\d\\d)?)?)?)?)?[dz]?)|\\d\\d:\\d\\d(?::\\d\\d(?:[.:]\\d\\d\\d)?)?[uvt]?/,\n      alias: 'number'\n    },\n    // The negative look-ahead prevents bad highlighting\n    // of verbs 0: and 1:\n    number:\n      /\\b(?![01]:)(?:0N[hje]?|0W[hj]?|0[wn]|0x[\\da-fA-F]+|\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?[hjfeb]?)/,\n    keyword:\n      /\\\\\\w+\\b|\\b(?:abs|acos|aj0?|all|and|any|asc|asin|asof|atan|attr|avgs?|binr?|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|ej|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|identity|idesc|if|ij|in|insert|inter|inv|keys?|last|like|list|ljf?|load|log|lower|lsq|ltime|ltrim|mavg|maxs?|mcount|md5|mdev|med|meta|mins?|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|plist|prds?|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ssr?|string|sublist|sums?|sv|svar|system|tables|tan|til|trim|txf|type|uj|ungroup|union|update|upper|upsert|value|var|views?|vs|wavg|where|while|within|wj1?|wsum|ww|xasc|xbar|xcols?|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)\\b/,\n    adverb: {\n      pattern: /['\\/\\\\]:?|\\beach\\b/,\n      alias: 'function'\n    },\n    verb: {\n      pattern: /(?:\\B\\.\\B|\\b[01]:|<[=>]?|>=?|[:+\\-*%,!?~=|$&#@^]):?|\\b_\\b:?/,\n      alias: 'operator'\n    },\n    punctuation: /[(){}\\[\\];.]/\n  }\n}\n","// @ts-nocheck\nimport refractorJavascript from './javascript.js'\nqml.displayName = 'qml'\nqml.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function qml(Prism) {\n  Prism.register(refractorJavascript)\n  ;(function (Prism) {\n    var jsString = /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|'(?:\\\\.|[^\\\\'\\r\\n])*'/.source\n    var jsComment = /\\/\\/.*(?!.)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\//.source\n    var jsExpr =\n      /(?:[^\\\\()[\\]{}\"'/]|<string>|\\/(?![*/])|<comment>|\\(<expr>*\\)|\\[<expr>*\\]|\\{<expr>*\\}|\\\\[\\s\\S])/.source\n        .replace(/<string>/g, function () {\n          return jsString\n        })\n        .replace(/<comment>/g, function () {\n          return jsComment\n        })\n\n    // the pattern will blow up, so only a few iterations\n    for (var i = 0; i < 2; i++) {\n      jsExpr = jsExpr.replace(/<expr>/g, function () {\n        return jsExpr\n      })\n    }\n    jsExpr = jsExpr.replace(/<expr>/g, '[^\\\\s\\\\S]')\n    Prism.languages.qml = {\n      comment: {\n        pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n        greedy: true\n      },\n      'javascript-function': {\n        pattern: RegExp(\n          /((?:^|;)[ \\t]*)function\\s+(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*\\s*\\(<js>*\\)\\s*\\{<js>*\\}/.source.replace(\n            /<js>/g,\n            function () {\n              return jsExpr\n            }\n          ),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'language-javascript',\n        inside: Prism.languages.javascript\n      },\n      'class-name': {\n        pattern: /((?:^|[:;])[ \\t]*)(?!\\d)\\w+(?=[ \\t]*\\{|[ \\t]+on\\b)/m,\n        lookbehind: true\n      },\n      property: [\n        {\n          pattern: /((?:^|[;{])[ \\t]*)(?!\\d)\\w+(?:\\.\\w+)*(?=[ \\t]*:)/m,\n          lookbehind: true\n        },\n        {\n          pattern:\n            /((?:^|[;{])[ \\t]*)property[ \\t]+(?!\\d)\\w+(?:\\.\\w+)*[ \\t]+(?!\\d)\\w+(?:\\.\\w+)*(?=[ \\t]*:)/m,\n          lookbehind: true,\n          inside: {\n            keyword: /^property/,\n            property: /\\w+(?:\\.\\w+)*/\n          }\n        }\n      ],\n      'javascript-expression': {\n        pattern: RegExp(\n          /(:[ \\t]*)(?![\\s;}[])(?:(?!$|[;}])<js>)+/.source.replace(\n            /<js>/g,\n            function () {\n              return jsExpr\n            }\n          ),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'language-javascript',\n        inside: Prism.languages.javascript\n      },\n      string: {\n        pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n        greedy: true\n      },\n      keyword: /\\b(?:as|import|on)\\b/,\n      punctuation: /[{}[\\]:;,]/\n    }\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nqore.displayName = 'qore'\nqore.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function qore(Prism) {\n  Prism.register(refractorClike)\n  Prism.languages.qore = Prism.languages.extend('clike', {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:\\/\\/|#).*)/,\n      lookbehind: true\n    },\n    // Overridden to allow unescaped multi-line strings\n    string: {\n      pattern: /(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:bool|date|float|int|list|number|string)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\\b/,\n    boolean: /\\b(?:false|true)\\b/i,\n    function: /\\$?\\b(?!\\d)\\w+(?=\\()/,\n    number:\n      /\\b(?:0b[01]+|0x(?:[\\da-f]*\\.)?[\\da-fp\\-]+|(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:e\\d+)?[df]|(?:\\d+(?:\\.\\d+)?|\\.\\d+))\\b/i,\n    operator: {\n      pattern:\n        /(^|[^.])(?:\\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\\|[|=]?|[*\\/%^]=?|[~?])/,\n      lookbehind: true\n    },\n    variable: /\\$(?!\\d)\\w+\\b/\n  })\n}\n","// @ts-nocheck\nimport refractorScheme from './scheme.js'\nracket.displayName = 'racket'\nracket.aliases = ['rkt']\n\n/** @type {import('../core.js').Syntax} */\nexport default function racket(Prism) {\n  Prism.register(refractorScheme)\n  Prism.languages.racket = Prism.languages.extend('scheme', {\n    'lambda-parameter': {\n      // the racket lambda syntax is a lot more complex, so we won't even attempt to capture it.\n      // this will just prevent false positives of the `function` pattern\n      pattern: /([(\\[]lambda\\s+[(\\[])[^()\\[\\]'\\s]+/,\n      lookbehind: true\n    }\n  })\n  Prism.languages.insertBefore('racket', 'string', {\n    lang: {\n      pattern: /^#lang.+/m,\n      greedy: true,\n      alias: 'keyword'\n    }\n  })\n  Prism.languages.rkt = Prism.languages.racket\n}\n","// @ts-nocheck\nimport refractorJsx from './jsx.js'\nimport refractorTypescript from './typescript.js'\ntsx.displayName = 'tsx'\ntsx.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function tsx(Prism) {\n  Prism.register(refractorJsx)\n  Prism.register(refractorTypescript)\n  ;(function (Prism) {\n    var typescript = Prism.util.clone(Prism.languages.typescript)\n    Prism.languages.tsx = Prism.languages.extend('jsx', typescript)\n\n    // doesn't work with TS because TS is too complex\n    delete Prism.languages.tsx['parameter']\n    delete Prism.languages.tsx['literal-property']\n\n    // This will prevent collisions between TSX tags and TS generic types.\n    // Idea by https://github.com/karlhorky\n    // Discussion: https://github.com/PrismJS/prism/issues/2594#issuecomment-710666928\n    var tag = Prism.languages.tsx.tag\n    tag.pattern = RegExp(\n      /(^|[^\\w$]|(?=<\\/))/.source + '(?:' + tag.pattern.source + ')',\n      tag.pattern.flags\n    )\n    tag.lookbehind = true\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nreason.displayName = 'reason'\nreason.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function reason(Prism) {\n  Prism.register(refractorClike)\n  Prism.languages.reason = Prism.languages.extend('clike', {\n    string: {\n      pattern: /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n\"])*\"/,\n      greedy: true\n    },\n    // 'class-name' must be matched *after* 'constructor' defined below\n    'class-name': /\\b[A-Z]\\w*/,\n    keyword:\n      /\\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\\b/,\n    operator:\n      /\\.{3}|:[:=]|\\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\\-*\\/]\\.?|\\b(?:asr|land|lor|lsl|lsr|lxor|mod)\\b/\n  })\n  Prism.languages.insertBefore('reason', 'class-name', {\n    char: {\n      pattern: /'(?:\\\\x[\\da-f]{2}|\\\\o[0-3][0-7][0-7]|\\\\\\d{3}|\\\\.|[^'\\\\\\r\\n])'/,\n      greedy: true\n    },\n    // Negative look-ahead prevents from matching things like String.capitalize\n    constructor: /\\b[A-Z]\\w*\\b(?!\\s*\\.)/,\n    label: {\n      pattern: /\\b[a-z]\\w*(?=::)/,\n      alias: 'symbol'\n    }\n  })\n\n  // We can't match functions property, so let's not even try.\n  delete Prism.languages.reason.function\n}\n","// @ts-nocheck\nrego.displayName = 'rego'\nrego.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function rego(Prism) {\n  // https://www.openpolicyagent.org/docs/latest/policy-reference/\n\n  Prism.languages.rego = {\n    comment: /#.*/,\n    property: {\n      pattern:\n        /(^|[^\\\\.])(?:\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|`[^`]*`|\\b[a-z_]\\w*\\b)(?=\\s*:(?!=))/i,\n      lookbehind: true,\n      greedy: true\n    },\n    string: {\n      pattern: /(^|[^\\\\])\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|`[^`]*`/,\n      lookbehind: true,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:as|default|else|import|not|null|package|set(?=\\s*\\()|some|with)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    function: {\n      pattern: /\\b[a-z_]\\w*\\b(?:\\s*\\.\\s*\\b[a-z_]\\w*\\b)*(?=\\s*\\()/i,\n      inside: {\n        namespace: /\\b\\w+\\b(?=\\s*\\.)/,\n        punctuation: /\\./\n      }\n    },\n    number: /-?\\b\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?\\b/i,\n    operator: /[-+*/%|&]|[<>:=]=?|!=|\\b_\\b/,\n    punctuation: /[,;.\\[\\]{}()]/\n  }\n}\n","// @ts-nocheck\nrenpy.displayName = 'renpy'\nrenpy.aliases = ['rpy']\n\n/** @type {import('../core.js').Syntax} */\nexport default function renpy(Prism) {\n  Prism.languages.renpy = {\n    comment: {\n      pattern: /(^|[^\\\\])#.+/,\n      lookbehind: true\n    },\n    string: {\n      pattern:\n        /(\"\"\"|''')[\\s\\S]+?\\1|(\"|')(?:\\\\.|(?!\\2)[^\\\\])*\\2|(?:^#?(?:(?:[0-9a-fA-F]){3}|[0-9a-fA-F]{6})$)/m,\n      greedy: true\n    },\n    function: /\\b[a-z_]\\w*(?=\\()/i,\n    property:\n      /\\b(?:Update|UpdateVersion|action|activate_sound|adv_nvl_transition|after_load_transition|align|alpha|alt|anchor|antialias|area|auto|background|bar_invert|bar_resizing|bar_vertical|black_color|bold|bottom_bar|bottom_gutter|bottom_margin|bottom_padding|box_reverse|box_wrap|can_update|caret|child|color|crop|default_afm_enable|default_afm_time|default_fullscreen|default_text_cps|developer|directory_name|drag_handle|drag_joined|drag_name|drag_raise|draggable|dragged|drop_shadow|drop_shadow_color|droppable|dropped|easein|easeout|edgescroll|end_game_transition|end_splash_transition|enter_replay_transition|enter_sound|enter_transition|enter_yesno_transition|executable_name|exit_replay_transition|exit_sound|exit_transition|exit_yesno_transition|fadein|fadeout|first_indent|first_spacing|fit_first|focus|focus_mask|font|foreground|game_main_transition|get_installed_packages|google_play_key|google_play_salt|ground|has_music|has_sound|has_voice|height|help|hinting|hover|hover_background|hover_color|hover_sound|hovered|hyperlink_functions|idle|idle_color|image_style|include_update|insensitive|insensitive_background|insensitive_color|inside|intra_transition|italic|justify|kerning|keyboard_focus|language|layer_clipping|layers|layout|left_bar|left_gutter|left_margin|left_padding|length|line_leading|line_overlap_split|line_spacing|linear|main_game_transition|main_menu_music|maximum|min_width|minimum|minwidth|modal|mouse|mousewheel|name|narrator_menu|newline_indent|nvl_adv_transition|offset|order_reverse|outlines|overlay_functions|pos|position|prefix|radius|range|rest_indent|right_bar|right_gutter|right_margin|right_padding|rotate|rotate_pad|ruby_style|sample_sound|save_directory|say_attribute_transition|screen_height|screen_width|scrollbars|selected_hover|selected_hover_color|selected_idle|selected_idle_color|selected_insensitive|show_side_image|show_two_window|side_spacing|side_xpos|side_ypos|size|size_group|slow_cps|slow_cps_multiplier|spacing|strikethrough|subpixel|text_align|text_style|text_xpos|text_y_fudge|text_ypos|thumb|thumb_offset|thumb_shadow|thumbnail_height|thumbnail_width|time|top_bar|top_gutter|top_margin|top_padding|translations|underline|unscrollable|update|value|version|version_name|version_tuple|vertical|width|window_hide_transition|window_icon|window_left_padding|window_show_transition|window_title|windows_icon|xadjustment|xalign|xanchor|xanchoraround|xaround|xcenter|xfill|xinitial|xmargin|xmaximum|xminimum|xoffset|xofsset|xpadding|xpos|xsize|xzoom|yadjustment|yalign|yanchor|yanchoraround|yaround|ycenter|yfill|yinitial|ymargin|ymaximum|yminimum|yoffset|ypadding|ypos|ysize|ysizexysize|yzoom|zoom|zorder)\\b/,\n    tag: /\\b(?:bar|block|button|buttoscreenn|drag|draggroup|fixed|frame|grid|[hv]box|hotbar|hotspot|image|imagebutton|imagemap|input|key|label|menu|mm_menu_frame|mousearea|nvl|parallel|screen|self|side|tag|text|textbutton|timer|vbar|viewport|window)\\b|\\$/,\n    keyword:\n      /\\b(?:None|add|adjustment|alignaround|allow|angle|animation|around|as|assert|behind|box_layout|break|build|cache|call|center|changed|child_size|choice|circles|class|clear|clicked|clipping|clockwise|config|contains|continue|corner1|corner2|counterclockwise|def|default|define|del|delay|disabled|disabled_text|dissolve|elif|else|event|except|exclude|exec|expression|fade|finally|for|from|function|global|gm_root|has|hide|id|if|import|in|init|is|jump|knot|lambda|left|less_rounded|mm_root|movie|music|null|on|onlayer|pass|pause|persistent|play|print|python|queue|raise|random|renpy|repeat|return|right|rounded_window|scene|scope|set|show|slow|slow_abortable|slow_done|sound|stop|store|style|style_group|substitute|suffix|theme|transform|transform_anchor|transpose|try|ui|unhovered|updater|use|voice|while|widget|widget_hover|widget_selected|widget_text|yield)\\b/,\n    boolean: /\\b(?:[Ff]alse|[Tt]rue)\\b/,\n    number:\n      /(?:\\b(?:0[bo])?(?:(?:\\d|0x[\\da-f])[\\da-f]*(?:\\.\\d*)?)|\\B\\.\\d+)(?:e[+-]?\\d+)?j?/i,\n    operator:\n      /[-+%=]=?|!=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]|\\b(?:and|at|not|or|with)\\b/,\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.rpy = Prism.languages.renpy\n}\n","// @ts-nocheck\nrescript.displayName = 'rescript'\nrescript.aliases = ['res']\n\n/** @type {import('../core.js').Syntax} */\nexport default function rescript(Prism) {\n  Prism.languages.rescript = {\n    comment: {\n      pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n      greedy: true\n    },\n    char: {\n      pattern: /'(?:[^\\r\\n\\\\]|\\\\(?:.|\\w+))'/,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n\"])*\"/,\n      greedy: true\n    },\n    'class-name': /\\b[A-Z]\\w*|@[a-z.]*|#[A-Za-z]\\w*|#\\d/,\n    function: {\n      pattern: /[a-zA-Z]\\w*(?=\\()|(\\.)[a-z]\\w*/,\n      lookbehind: true\n    },\n    number:\n      /(?:\\b0x(?:[\\da-f]+(?:\\.[\\da-f]*)?|\\.[\\da-f]+)(?:p[+-]?\\d+)?|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?)[ful]{0,4}/i,\n    boolean: /\\b(?:false|true)\\b/,\n    'attr-value': /[A-Za-z]\\w*(?==)/,\n    constant: {\n      pattern: /(\\btype\\s+)[a-z]\\w*/,\n      lookbehind: true\n    },\n    tag: {\n      pattern: /(<)[a-z]\\w*|(?:<\\/)[a-z]\\w*/,\n      lookbehind: true,\n      inside: {\n        operator: /<|>|\\//\n      }\n    },\n    keyword:\n      /\\b(?:and|as|assert|begin|bool|class|constraint|do|done|downto|else|end|exception|external|float|for|fun|function|if|in|include|inherit|initializer|int|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|string|switch|then|to|try|type|when|while|with)\\b/,\n    operator:\n      /\\.{3}|:[:=]?|\\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\\-*\\/]\\.?|\\b(?:asr|land|lor|lsl|lsr|lxor|mod)\\b/,\n    punctuation: /[(){}[\\],;.]/\n  }\n  Prism.languages.insertBefore('rescript', 'string', {\n    'template-string': {\n      pattern:\n        /`(?:\\\\[\\s\\S]|\\$\\{(?:[^{}]|\\{(?:[^{}]|\\{[^}]*\\})*\\})+\\}|(?!\\$\\{)[^\\\\`])*`/,\n      greedy: true,\n      inside: {\n        'template-punctuation': {\n          pattern: /^`|`$/,\n          alias: 'string'\n        },\n        interpolation: {\n          pattern:\n            /((?:^|[^\\\\])(?:\\\\{2})*)\\$\\{(?:[^{}]|\\{(?:[^{}]|\\{[^}]*\\})*\\})+\\}/,\n          lookbehind: true,\n          inside: {\n            'interpolation-punctuation': {\n              pattern: /^\\$\\{|\\}$/,\n              alias: 'tag'\n            },\n            rest: Prism.languages.rescript\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n  })\n  Prism.languages.res = Prism.languages.rescript\n}\n","// @ts-nocheck\nrest.displayName = 'rest'\nrest.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function rest(Prism) {\n  Prism.languages.rest = {\n    table: [\n      {\n        pattern:\n          /(^[\\t ]*)(?:\\+[=-]+)+\\+(?:\\r?\\n|\\r)(?:\\1[+|].+[+|](?:\\r?\\n|\\r))+\\1(?:\\+[=-]+)+\\+/m,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\||(?:\\+[=-]+)+\\+/\n        }\n      },\n      {\n        pattern:\n          /(^[\\t ]*)=+ [ =]*=(?:(?:\\r?\\n|\\r)\\1.+)+(?:\\r?\\n|\\r)\\1=+ [ =]*=(?=(?:\\r?\\n|\\r){2}|\\s*$)/m,\n        lookbehind: true,\n        inside: {\n          punctuation: /[=-]+/\n        }\n      }\n    ],\n    // Directive-like patterns\n\n    'substitution-def': {\n      pattern: /(^[\\t ]*\\.\\. )\\|(?:[^|\\s](?:[^|]*[^|\\s])?)\\| [^:]+::/m,\n      lookbehind: true,\n      inside: {\n        substitution: {\n          pattern: /^\\|(?:[^|\\s]|[^|\\s][^|]*[^|\\s])\\|/,\n          alias: 'attr-value',\n          inside: {\n            punctuation: /^\\||\\|$/\n          }\n        },\n        directive: {\n          pattern: /( )(?! )[^:]+::/,\n          lookbehind: true,\n          alias: 'function',\n          inside: {\n            punctuation: /::$/\n          }\n        }\n      }\n    },\n    'link-target': [\n      {\n        pattern: /(^[\\t ]*\\.\\. )\\[[^\\]]+\\]/m,\n        lookbehind: true,\n        alias: 'string',\n        inside: {\n          punctuation: /^\\[|\\]$/\n        }\n      },\n      {\n        pattern: /(^[\\t ]*\\.\\. )_(?:`[^`]+`|(?:[^:\\\\]|\\\\.)+):/m,\n        lookbehind: true,\n        alias: 'string',\n        inside: {\n          punctuation: /^_|:$/\n        }\n      }\n    ],\n    directive: {\n      pattern: /(^[\\t ]*\\.\\. )[^:]+::/m,\n      lookbehind: true,\n      alias: 'function',\n      inside: {\n        punctuation: /::$/\n      }\n    },\n    comment: {\n      // The two alternatives try to prevent highlighting of blank comments\n      pattern:\n        /(^[\\t ]*\\.\\.)(?:(?: .+)?(?:(?:\\r?\\n|\\r).+)+| .+)(?=(?:\\r?\\n|\\r){2}|$)/m,\n      lookbehind: true\n    },\n    title: [\n      // Overlined and underlined\n      {\n        pattern:\n          /^(([!\"#$%&'()*+,\\-.\\/:;<=>?@\\[\\\\\\]^_`{|}~])\\2+)(?:\\r?\\n|\\r).+(?:\\r?\\n|\\r)\\1$/m,\n        inside: {\n          punctuation:\n            /^[!\"#$%&'()*+,\\-.\\/:;<=>?@\\[\\\\\\]^_`{|}~]+|[!\"#$%&'()*+,\\-.\\/:;<=>?@\\[\\\\\\]^_`{|}~]+$/,\n          important: /.+/\n        }\n      },\n      // Underlined only\n      {\n        pattern:\n          /(^|(?:\\r?\\n|\\r){2}).+(?:\\r?\\n|\\r)([!\"#$%&'()*+,\\-.\\/:;<=>?@\\[\\\\\\]^_`{|}~])\\2+(?=\\r?\\n|\\r|$)/,\n        lookbehind: true,\n        inside: {\n          punctuation: /[!\"#$%&'()*+,\\-.\\/:;<=>?@\\[\\\\\\]^_`{|}~]+$/,\n          important: /.+/\n        }\n      }\n    ],\n    hr: {\n      pattern:\n        /((?:\\r?\\n|\\r){2})([!\"#$%&'()*+,\\-.\\/:;<=>?@\\[\\\\\\]^_`{|}~])\\2{3,}(?=(?:\\r?\\n|\\r){2})/,\n      lookbehind: true,\n      alias: 'punctuation'\n    },\n    field: {\n      pattern: /(^[\\t ]*):[^:\\r\\n]+:(?= )/m,\n      lookbehind: true,\n      alias: 'attr-name'\n    },\n    'command-line-option': {\n      pattern:\n        /(^[\\t ]*)(?:[+-][a-z\\d]|(?:--|\\/)[a-z\\d-]+)(?:[ =](?:[a-z][\\w-]*|<[^<>]+>))?(?:, (?:[+-][a-z\\d]|(?:--|\\/)[a-z\\d-]+)(?:[ =](?:[a-z][\\w-]*|<[^<>]+>))?)*(?=(?:\\r?\\n|\\r)? {2,}\\S)/im,\n      lookbehind: true,\n      alias: 'symbol'\n    },\n    'literal-block': {\n      pattern: /::(?:\\r?\\n|\\r){2}([ \\t]+)(?![ \\t]).+(?:(?:\\r?\\n|\\r)\\1.+)*/,\n      inside: {\n        'literal-block-punctuation': {\n          pattern: /^::/,\n          alias: 'punctuation'\n        }\n      }\n    },\n    'quoted-literal-block': {\n      pattern:\n        /::(?:\\r?\\n|\\r){2}([!\"#$%&'()*+,\\-.\\/:;<=>?@\\[\\\\\\]^_`{|}~]).*(?:(?:\\r?\\n|\\r)\\1.*)*/,\n      inside: {\n        'literal-block-punctuation': {\n          pattern: /^(?:::|([!\"#$%&'()*+,\\-.\\/:;<=>?@\\[\\\\\\]^_`{|}~])\\1*)/m,\n          alias: 'punctuation'\n        }\n      }\n    },\n    'list-bullet': {\n      pattern:\n        /(^[\\t ]*)(?:[*+\\-•‣⁃]|\\(?(?:\\d+|[a-z]|[ivxdclm]+)\\)|(?:\\d+|[a-z]|[ivxdclm]+)\\.)(?= )/im,\n      lookbehind: true,\n      alias: 'punctuation'\n    },\n    'doctest-block': {\n      pattern: /(^[\\t ]*)>>> .+(?:(?:\\r?\\n|\\r).+)*/m,\n      lookbehind: true,\n      inside: {\n        punctuation: /^>>>/\n      }\n    },\n    inline: [\n      {\n        pattern:\n          /(^|[\\s\\-:\\/'\"<(\\[{])(?::[^:]+:`.*?`|`.*?`:[^:]+:|(\\*\\*?|``?|\\|)(?!\\s)(?:(?!\\2).)*\\S\\2(?=[\\s\\-.,:;!?\\\\\\/'\")\\]}]|$))/m,\n        lookbehind: true,\n        inside: {\n          bold: {\n            pattern: /(^\\*\\*).+(?=\\*\\*$)/,\n            lookbehind: true\n          },\n          italic: {\n            pattern: /(^\\*).+(?=\\*$)/,\n            lookbehind: true\n          },\n          'inline-literal': {\n            pattern: /(^``).+(?=``$)/,\n            lookbehind: true,\n            alias: 'symbol'\n          },\n          role: {\n            pattern: /^:[^:]+:|:[^:]+:$/,\n            alias: 'function',\n            inside: {\n              punctuation: /^:|:$/\n            }\n          },\n          'interpreted-text': {\n            pattern: /(^`).+(?=`$)/,\n            lookbehind: true,\n            alias: 'attr-value'\n          },\n          substitution: {\n            pattern: /(^\\|).+(?=\\|$)/,\n            lookbehind: true,\n            alias: 'attr-value'\n          },\n          punctuation: /\\*\\*?|``?|\\|/\n        }\n      }\n    ],\n    link: [\n      {\n        pattern: /\\[[^\\[\\]]+\\]_(?=[\\s\\-.,:;!?\\\\\\/'\")\\]}]|$)/,\n        alias: 'string',\n        inside: {\n          punctuation: /^\\[|\\]_$/\n        }\n      },\n      {\n        pattern:\n          /(?:\\b[a-z\\d]+(?:[_.:+][a-z\\d]+)*_?_|`[^`]+`_?_|_`[^`]+`)(?=[\\s\\-.,:;!?\\\\\\/'\")\\]}]|$)/i,\n        alias: 'string',\n        inside: {\n          punctuation: /^_?`|`$|`?_?_$/\n        }\n      }\n    ],\n    // Line block start,\n    // quote attribution,\n    // explicit markup start,\n    // and anonymous hyperlink target shortcut (__)\n    punctuation: {\n      pattern: /(^[\\t ]*)(?:\\|(?= |$)|(?:---?|—|\\.\\.|__)(?= )|\\.\\.$)/m,\n      lookbehind: true\n    }\n  }\n}\n","// @ts-nocheck\nrip.displayName = 'rip'\nrip.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function rip(Prism) {\n  Prism.languages.rip = {\n    comment: {\n      pattern: /#.*/,\n      greedy: true\n    },\n    char: {\n      pattern: /\\B`[^\\s`'\",.:;#\\/\\\\()<>\\[\\]{}]\\b/,\n      greedy: true\n    },\n    string: {\n      pattern: /(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    regex: {\n      pattern:\n        /(^|[^/])\\/(?!\\/)(?:\\[[^\\n\\r\\]]*\\]|\\\\.|[^/\\\\\\r\\n\\[])+\\/(?=\\s*(?:$|[\\r\\n,.;})]))/,\n      lookbehind: true,\n      greedy: true\n    },\n    keyword:\n      /(?:=>|->)|\\b(?:case|catch|class|else|exit|finally|if|raise|return|switch|try)\\b/,\n    builtin: /@|\\bSystem\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    date: /\\b\\d{4}-\\d{2}-\\d{2}\\b/,\n    time: /\\b\\d{2}:\\d{2}:\\d{2}\\b/,\n    datetime: /\\b\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\b/,\n    symbol: /:[^\\d\\s`'\",.:;#\\/\\\\()<>\\[\\]{}][^\\s`'\",.:;#\\/\\\\()<>\\[\\]{}]*/,\n    number: /[+-]?\\b(?:\\d+\\.\\d+|\\d+)\\b/,\n    punctuation: /(?:\\.{2,3})|[`,.:;=\\/\\\\()<>\\[\\]{}]/,\n    reference: /[^\\d\\s`'\",.:;#\\/\\\\()<>\\[\\]{}][^\\s`'\",.:;#\\/\\\\()<>\\[\\]{}]*/\n  }\n}\n","// @ts-nocheck\nroboconf.displayName = 'roboconf'\nroboconf.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function roboconf(Prism) {\n  Prism.languages.roboconf = {\n    comment: /#.*/,\n    keyword: {\n      pattern:\n        /(^|\\s)(?:(?:external|import)\\b|(?:facet|instance of)(?=[ \\t]+[\\w-]+[ \\t]*\\{))/,\n      lookbehind: true\n    },\n    component: {\n      pattern: /[\\w-]+(?=[ \\t]*\\{)/,\n      alias: 'variable'\n    },\n    property: /[\\w.-]+(?=[ \\t]*:)/,\n    value: {\n      pattern: /(=[ \\t]*(?![ \\t]))[^,;]+/,\n      lookbehind: true,\n      alias: 'attr-value'\n    },\n    optional: {\n      pattern: /\\(optional\\)/,\n      alias: 'builtin'\n    },\n    wildcard: {\n      pattern: /(\\.)\\*/,\n      lookbehind: true,\n      alias: 'operator'\n    },\n    punctuation: /[{},.;:=]/\n  }\n}\n","// @ts-nocheck\nrobotframework.displayName = 'robotframework'\nrobotframework.aliases = ['robot']\n\n/** @type {import('../core.js').Syntax} */\nexport default function robotframework(Prism) {\n  ;(function (Prism) {\n    var comment = {\n      pattern: /(^[ \\t]*| {2}|\\t)#.*/m,\n      lookbehind: true,\n      greedy: true\n    }\n    var variable = {\n      pattern: /((?:^|[^\\\\])(?:\\\\{2})*)[$@&%]\\{(?:[^{}\\r\\n]|\\{[^{}\\r\\n]*\\})*\\}/,\n      lookbehind: true,\n      inside: {\n        punctuation: /^[$@&%]\\{|\\}$/\n      }\n    }\n    function createSection(name, inside) {\n      var extendecInside = {}\n      extendecInside['section-header'] = {\n        pattern: /^ ?\\*{3}.+?\\*{3}/,\n        alias: 'keyword'\n      }\n\n      // copy inside tokens\n      for (var token in inside) {\n        extendecInside[token] = inside[token]\n      }\n      extendecInside['tag'] = {\n        pattern: /([\\r\\n](?: {2}|\\t)[ \\t]*)\\[[-\\w]+\\]/,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\[|\\]/\n        }\n      }\n      extendecInside['variable'] = variable\n      extendecInside['comment'] = comment\n      return {\n        pattern: RegExp(\n          /^ ?\\*{3}[ \\t]*<name>[ \\t]*\\*{3}(?:.|[\\r\\n](?!\\*{3}))*/.source.replace(\n            /<name>/g,\n            function () {\n              return name\n            }\n          ),\n          'im'\n        ),\n        alias: 'section',\n        inside: extendecInside\n      }\n    }\n    var docTag = {\n      pattern:\n        /(\\[Documentation\\](?: {2}|\\t)[ \\t]*)(?![ \\t]|#)(?:.|(?:\\r\\n?|\\n)[ \\t]*\\.{3})+/,\n      lookbehind: true,\n      alias: 'string'\n    }\n    var testNameLike = {\n      pattern: /([\\r\\n] ?)(?!#)(?:\\S(?:[ \\t]\\S)*)+/,\n      lookbehind: true,\n      alias: 'function',\n      inside: {\n        variable: variable\n      }\n    }\n    var testPropertyLike = {\n      pattern: /([\\r\\n](?: {2}|\\t)[ \\t]*)(?!\\[|\\.{3}|#)(?:\\S(?:[ \\t]\\S)*)+/,\n      lookbehind: true,\n      inside: {\n        variable: variable\n      }\n    }\n    Prism.languages['robotframework'] = {\n      settings: createSection('Settings', {\n        documentation: {\n          pattern:\n            /([\\r\\n] ?Documentation(?: {2}|\\t)[ \\t]*)(?![ \\t]|#)(?:.|(?:\\r\\n?|\\n)[ \\t]*\\.{3})+/,\n          lookbehind: true,\n          alias: 'string'\n        },\n        property: {\n          pattern: /([\\r\\n] ?)(?!\\.{3}|#)(?:\\S(?:[ \\t]\\S)*)+/,\n          lookbehind: true\n        }\n      }),\n      variables: createSection('Variables'),\n      'test-cases': createSection('Test Cases', {\n        'test-name': testNameLike,\n        documentation: docTag,\n        property: testPropertyLike\n      }),\n      keywords: createSection('Keywords', {\n        'keyword-name': testNameLike,\n        documentation: docTag,\n        property: testPropertyLike\n      }),\n      tasks: createSection('Tasks', {\n        'task-name': testNameLike,\n        documentation: docTag,\n        property: testPropertyLike\n      }),\n      comment: comment\n    }\n    Prism.languages.robot = Prism.languages['robotframework']\n  })(Prism)\n}\n","// @ts-nocheck\nsas.displayName = 'sas'\nsas.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function sas(Prism) {\n  ;(function (Prism) {\n    var stringPattern = /(?:\"(?:\"\"|[^\"])*\"(?!\")|'(?:''|[^'])*'(?!'))/.source\n    var number = /\\b(?:\\d[\\da-f]*x|\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?)\\b/i\n    var numericConstant = {\n      pattern: RegExp(stringPattern + '[bx]'),\n      alias: 'number'\n    }\n    var macroVariable = {\n      pattern: /&[a-z_]\\w*/i\n    }\n    var macroKeyword = {\n      pattern:\n        /((?:^|\\s|=|\\())%(?:ABORT|BY|CMS|COPY|DISPLAY|DO|ELSE|END|EVAL|GLOBAL|GO|GOTO|IF|INC|INCLUDE|INDEX|INPUT|KTRIM|LENGTH|LET|LIST|LOCAL|PUT|QKTRIM|QSCAN|QSUBSTR|QSYSFUNC|QUPCASE|RETURN|RUN|SCAN|SUBSTR|SUPERQ|SYMDEL|SYMEXIST|SYMGLOBL|SYMLOCAL|SYSCALL|SYSEVALF|SYSEXEC|SYSFUNC|SYSGET|SYSRPUT|THEN|TO|TSO|UNQUOTE|UNTIL|UPCASE|WHILE|WINDOW)\\b/i,\n      lookbehind: true,\n      alias: 'keyword'\n    }\n    var step = {\n      pattern: /(^|\\s)(?:proc\\s+\\w+|data(?!=)|quit|run)\\b/i,\n      alias: 'keyword',\n      lookbehind: true\n    }\n    var comment = [\n      /\\/\\*[\\s\\S]*?\\*\\//,\n      {\n        pattern: /(^[ \\t]*|;\\s*)\\*[^;]*;/m,\n        lookbehind: true\n      }\n    ]\n    var string = {\n      pattern: RegExp(stringPattern),\n      greedy: true\n    }\n    var punctuation = /[$%@.(){}\\[\\];,\\\\]/\n    var func = {\n      pattern: /%?\\b\\w+(?=\\()/,\n      alias: 'keyword'\n    }\n    var args = {\n      function: func,\n      'arg-value': {\n        pattern: /(=\\s*)[A-Z\\.]+/i,\n        lookbehind: true\n      },\n      operator: /=/,\n      'macro-variable': macroVariable,\n      arg: {\n        pattern: /[A-Z]+/i,\n        alias: 'keyword'\n      },\n      number: number,\n      'numeric-constant': numericConstant,\n      punctuation: punctuation,\n      string: string\n    }\n    var format = {\n      pattern: /\\b(?:format|put)\\b=?[\\w'$.]+/i,\n      inside: {\n        keyword: /^(?:format|put)(?==)/i,\n        equals: /=/,\n        format: {\n          pattern: /(?:\\w|\\$\\d)+\\.\\d?/,\n          alias: 'number'\n        }\n      }\n    }\n    var altformat = {\n      pattern: /\\b(?:format|put)\\s+[\\w']+(?:\\s+[$.\\w]+)+(?=;)/i,\n      inside: {\n        keyword: /^(?:format|put)/i,\n        format: {\n          pattern: /[\\w$]+\\.\\d?/,\n          alias: 'number'\n        }\n      }\n    }\n    var globalStatements = {\n      pattern:\n        /((?:^|\\s)=?)(?:catname|checkpoint execute_always|dm|endsas|filename|footnote|%include|libname|%list|lock|missing|options|page|resetline|%run|sasfile|skip|sysecho|title\\d?)\\b/i,\n      lookbehind: true,\n      alias: 'keyword'\n    }\n    var submitStatement = {\n      pattern: /(^|\\s)(?:submit(?:\\s+(?:load|norun|parseonly))?|endsubmit)\\b/i,\n      lookbehind: true,\n      alias: 'keyword'\n    }\n    var actionSets =\n      /aStore|accessControl|aggregation|audio|autotune|bayesianNetClassifier|bioMedImage|boolRule|builtins|cardinality|cdm|clustering|conditionalRandomFields|configuration|copula|countreg|dataDiscovery|dataPreprocess|dataSciencePilot|dataStep|decisionTree|deduplication|deepLearn|deepNeural|deepRnn|ds2|ecm|entityRes|espCluster|explainModel|factmac|fastKnn|fcmpact|fedSql|freqTab|gVarCluster|gam|gleam|graphSemiSupLearn|hiddenMarkovModel|hyperGroup|ica|image|iml|kernalPca|langModel|ldaTopic|loadStreams|mbc|mixed|mlTools|modelPublishing|network|neuralNet|nmf|nonParametricBayes|nonlinear|optNetwork|optimization|panel|pca|percentile|phreg|pls|qkb|qlim|quantreg|recommend|regression|reinforcementLearn|robustPca|ruleMining|sampling|sandwich|sccasl|search(?:Analytics)?|sentimentAnalysis|sequence|session(?:Prop)?|severity|simSystem|simple|smartData|sparkEmbeddedProcess|sparseML|spatialreg|spc|stabilityMonitoring|svDataDescription|svm|table|text(?:Filters|Frequency|Mining|Parse|Rule(?:Develop|Score)|Topic|Util)|timeData|transpose|tsInfo|tsReconcile|uniTimeSeries|varReduce/\n        .source\n    var casActions = {\n      pattern: RegExp(\n        /(^|\\s)(?:action\\s+)?(?:<act>)\\.[a-z]+\\b[^;]+/.source.replace(\n          /<act>/g,\n          function () {\n            return actionSets\n          }\n        ),\n        'i'\n      ),\n      lookbehind: true,\n      inside: {\n        keyword: RegExp(\n          /(?:<act>)\\.[a-z]+\\b/.source.replace(/<act>/g, function () {\n            return actionSets\n          }),\n          'i'\n        ),\n        action: {\n          pattern: /(?:action)/i,\n          alias: 'keyword'\n        },\n        comment: comment,\n        function: func,\n        'arg-value': args['arg-value'],\n        operator: args.operator,\n        argument: args.arg,\n        number: number,\n        'numeric-constant': numericConstant,\n        punctuation: punctuation,\n        string: string\n      }\n    }\n    var keywords = {\n      pattern:\n        /((?:^|\\s)=?)(?:after|analysis|and|array|barchart|barwidth|begingraph|by|call|cas|cbarline|cfill|class(?:lev)?|close|column|computed?|contains|continue|data(?==)|define|delete|describe|document|do\\s+over|do|dol|drop|dul|else|end(?:comp|source)?|entryTitle|eval(?:uate)?|exec(?:ute)?|exit|file(?:name)?|fill(?:attrs)?|flist|fnc|function(?:list)?|global|goto|group(?:by)?|headline|headskip|histogram|if|infile|keep|keylabel|keyword|label|layout|leave|legendlabel|length|libname|loadactionset|merge|midpoints|_?null_|name|noobs|nowd|ods|options|or|otherwise|out(?:put)?|over(?:lay)?|plot|print|put|raise|ranexp|rannor|rbreak|retain|return|select|session|sessref|set|source|statgraph|sum|summarize|table|temp|terminate|then\\s+do|then|title\\d?|to|var|when|where|xaxisopts|y2axisopts|yaxisopts)\\b/i,\n      lookbehind: true\n    }\n    Prism.languages.sas = {\n      datalines: {\n        pattern: /^([ \\t]*)(?:cards|(?:data)?lines);[\\s\\S]+?^[ \\t]*;/im,\n        lookbehind: true,\n        alias: 'string',\n        inside: {\n          keyword: {\n            pattern: /^(?:cards|(?:data)?lines)/i\n          },\n          punctuation: /;/\n        }\n      },\n      'proc-sql': {\n        pattern:\n          /(^proc\\s+(?:fed)?sql(?:\\s+[\\w|=]+)?;)[\\s\\S]+?(?=^(?:proc\\s+\\w+|data|quit|run);|(?![\\s\\S]))/im,\n        lookbehind: true,\n        inside: {\n          sql: {\n            pattern: RegExp(\n              /^[ \\t]*(?:select|alter\\s+table|(?:create|describe|drop)\\s+(?:index|table(?:\\s+constraints)?|view)|create\\s+unique\\s+index|insert\\s+into|update)(?:<str>|[^;\"'])+;/.source.replace(\n                /<str>/g,\n                function () {\n                  return stringPattern\n                }\n              ),\n              'im'\n            ),\n            alias: 'language-sql',\n            inside: Prism.languages.sql\n          },\n          'global-statements': globalStatements,\n          'sql-statements': {\n            pattern:\n              /(^|\\s)(?:disconnect\\s+from|begin|commit|exec(?:ute)?|reset|rollback|validate)\\b/i,\n            lookbehind: true,\n            alias: 'keyword'\n          },\n          number: number,\n          'numeric-constant': numericConstant,\n          punctuation: punctuation,\n          string: string\n        }\n      },\n      'proc-groovy': {\n        pattern:\n          /(^proc\\s+groovy(?:\\s+[\\w|=]+)?;)[\\s\\S]+?(?=^(?:proc\\s+\\w+|data|quit|run);|(?![\\s\\S]))/im,\n        lookbehind: true,\n        inside: {\n          comment: comment,\n          groovy: {\n            pattern: RegExp(\n              /(^[ \\t]*submit(?:\\s+(?:load|norun|parseonly))?)(?:<str>|[^\"'])+?(?=endsubmit;)/.source.replace(\n                /<str>/g,\n                function () {\n                  return stringPattern\n                }\n              ),\n              'im'\n            ),\n            lookbehind: true,\n            alias: 'language-groovy',\n            inside: Prism.languages.groovy\n          },\n          keyword: keywords,\n          'submit-statement': submitStatement,\n          'global-statements': globalStatements,\n          number: number,\n          'numeric-constant': numericConstant,\n          punctuation: punctuation,\n          string: string\n        }\n      },\n      'proc-lua': {\n        pattern:\n          /(^proc\\s+lua(?:\\s+[\\w|=]+)?;)[\\s\\S]+?(?=^(?:proc\\s+\\w+|data|quit|run);|(?![\\s\\S]))/im,\n        lookbehind: true,\n        inside: {\n          comment: comment,\n          lua: {\n            pattern: RegExp(\n              /(^[ \\t]*submit(?:\\s+(?:load|norun|parseonly))?)(?:<str>|[^\"'])+?(?=endsubmit;)/.source.replace(\n                /<str>/g,\n                function () {\n                  return stringPattern\n                }\n              ),\n              'im'\n            ),\n            lookbehind: true,\n            alias: 'language-lua',\n            inside: Prism.languages.lua\n          },\n          keyword: keywords,\n          'submit-statement': submitStatement,\n          'global-statements': globalStatements,\n          number: number,\n          'numeric-constant': numericConstant,\n          punctuation: punctuation,\n          string: string\n        }\n      },\n      'proc-cas': {\n        pattern:\n          /(^proc\\s+cas(?:\\s+[\\w|=]+)?;)[\\s\\S]+?(?=^(?:proc\\s+\\w+|quit|data);|(?![\\s\\S]))/im,\n        lookbehind: true,\n        inside: {\n          comment: comment,\n          'statement-var': {\n            pattern: /((?:^|\\s)=?)saveresult\\s[^;]+/im,\n            lookbehind: true,\n            inside: {\n              statement: {\n                pattern: /^saveresult\\s+\\S+/i,\n                inside: {\n                  keyword: /^(?:saveresult)/i\n                }\n              },\n              rest: args\n            }\n          },\n          'cas-actions': casActions,\n          statement: {\n            pattern:\n              /((?:^|\\s)=?)(?:default|(?:un)?set|on|output|upload)[^;]+/im,\n            lookbehind: true,\n            inside: args\n          },\n          step: step,\n          keyword: keywords,\n          function: func,\n          format: format,\n          altformat: altformat,\n          'global-statements': globalStatements,\n          number: number,\n          'numeric-constant': numericConstant,\n          punctuation: punctuation,\n          string: string\n        }\n      },\n      'proc-args': {\n        pattern: RegExp(\n          /(^proc\\s+\\w+\\s+)(?!\\s)(?:[^;\"']|<str>)+;/.source.replace(\n            /<str>/g,\n            function () {\n              return stringPattern\n            }\n          ),\n          'im'\n        ),\n        lookbehind: true,\n        inside: args\n      },\n      /*Special keywords within macros*/\n      'macro-keyword': macroKeyword,\n      'macro-variable': macroVariable,\n      'macro-string-functions': {\n        pattern:\n          /((?:^|\\s|=))%(?:BQUOTE|NRBQUOTE|NRQUOTE|NRSTR|QUOTE|STR)\\(.*?(?:[^%]\\))/i,\n        lookbehind: true,\n        inside: {\n          function: {\n            pattern: /%(?:BQUOTE|NRBQUOTE|NRQUOTE|NRSTR|QUOTE|STR)/i,\n            alias: 'keyword'\n          },\n          'macro-keyword': macroKeyword,\n          'macro-variable': macroVariable,\n          'escaped-char': {\n            pattern: /%['\"()<>=¬^~;,#]/\n          },\n          punctuation: punctuation\n        }\n      },\n      'macro-declaration': {\n        pattern: /^%macro[^;]+(?=;)/im,\n        inside: {\n          keyword: /%macro/i\n        }\n      },\n      'macro-end': {\n        pattern: /^%mend[^;]+(?=;)/im,\n        inside: {\n          keyword: /%mend/i\n        }\n      },\n      /*%_zscore(headcir, _lhc, _mhc, _shc, headcz, headcpct, _Fheadcz); */\n      macro: {\n        pattern: /%_\\w+(?=\\()/,\n        alias: 'keyword'\n      },\n      input: {\n        pattern: /\\binput\\s[-\\w\\s/*.$&]+;/i,\n        inside: {\n          input: {\n            alias: 'keyword',\n            pattern: /^input/i\n          },\n          comment: comment,\n          number: number,\n          'numeric-constant': numericConstant\n        }\n      },\n      'options-args': {\n        pattern: /(^options)[-'\"|/\\\\<>*+=:()\\w\\s]*(?=;)/im,\n        lookbehind: true,\n        inside: args\n      },\n      'cas-actions': casActions,\n      comment: comment,\n      function: func,\n      format: format,\n      altformat: altformat,\n      'numeric-constant': numericConstant,\n      datetime: {\n        // '1jan2013'd, '9:25:19pm't, '18jan2003:9:27:05am'dt\n        pattern: RegExp(stringPattern + '(?:dt?|t)'),\n        alias: 'number'\n      },\n      string: string,\n      step: step,\n      keyword: keywords,\n      // In SAS Studio syntax highlighting, these operators are styled like keywords\n      'operator-keyword': {\n        pattern: /\\b(?:eq|ge|gt|in|le|lt|ne|not)\\b/i,\n        alias: 'operator'\n      },\n      // Decimal (1.2e23), hexadecimal (0c1x)\n      number: number,\n      operator: /\\*\\*?|\\|\\|?|!!?|¦¦?|<[>=]?|>[<=]?|[-+\\/=&]|[~¬^]=?/,\n      punctuation: punctuation\n    }\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorBash from './bash.js'\nshellSession.displayName = 'shell-session'\nshellSession.aliases = ['sh-session', 'shellsession']\n\n/** @type {import('../core.js').Syntax} */\nexport default function shellSession(Prism) {\n  Prism.register(refractorBash)\n  ;(function (Prism) {\n    // CAREFUL!\n    // The following patterns are concatenated, so the group referenced by a back reference is non-obvious!\n\n    var strings = [\n      // normal string\n      /\"(?:\\\\[\\s\\S]|\\$\\([^)]+\\)|\\$(?!\\()|`[^`]+`|[^\"\\\\`$])*\"/.source,\n      /'[^']*'/.source,\n      /\\$'(?:[^'\\\\]|\\\\[\\s\\S])*'/.source,\n      // here doc\n      // 2 capturing groups\n      /<<-?\\s*([\"']?)(\\w+)\\1\\s[\\s\\S]*?[\\r\\n]\\2/.source\n    ].join('|')\n    Prism.languages['shell-session'] = {\n      command: {\n        pattern: RegExp(\n          // user info\n          /^/.source +\n            '(?:' +\n            // <user> \":\" ( <path> )?\n            (/[^\\s@:$#%*!/\\\\]+@[^\\r\\n@:$#%*!/\\\\]+(?::[^\\0-\\x1F$#%*?\"<>:;|]+)?/\n              .source +\n              '|' +\n              // <path>\n              // Since the path pattern is quite general, we will require it to start with a special character to\n              // prevent false positives.\n              /[/~.][^\\0-\\x1F$#%*?\"<>@:;|]*/.source) +\n            ')?' +\n            // shell symbol\n            /[$#%](?=\\s)/.source +\n            // bash command\n            /(?:[^\\\\\\r\\n \\t'\"<$]|[ \\t](?:(?!#)|#.*$)|\\\\(?:[^\\r]|\\r\\n?)|\\$(?!')|<(?!<)|<<str>>)+/.source.replace(\n              /<<str>>/g,\n              function () {\n                return strings\n              }\n            ),\n          'm'\n        ),\n        greedy: true,\n        inside: {\n          info: {\n            // foo@bar:~/files$ exit\n            // foo@bar$ exit\n            // ~/files$ exit\n            pattern: /^[^#$%]+/,\n            alias: 'punctuation',\n            inside: {\n              user: /^[^\\s@:$#%*!/\\\\]+@[^\\r\\n@:$#%*!/\\\\]+/,\n              punctuation: /:/,\n              path: /[\\s\\S]+/\n            }\n          },\n          bash: {\n            pattern: /(^[$#%]\\s*)\\S[\\s\\S]*/,\n            lookbehind: true,\n            alias: 'language-bash',\n            inside: Prism.languages.bash\n          },\n          'shell-symbol': {\n            pattern: /^[$#%]/,\n            alias: 'important'\n          }\n        }\n      },\n      output: /.(?:.*(?:[\\r\\n]|.$))*/\n    }\n    Prism.languages['sh-session'] = Prism.languages['shellsession'] =\n      Prism.languages['shell-session']\n  })(Prism)\n}\n","// @ts-nocheck\nsmali.displayName = 'smali'\nsmali.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function smali(Prism) {\n  // Test files for the parser itself:\n  // https://github.com/JesusFreke/smali/tree/master/smali/src/test/resources/LexerTest\n\n  Prism.languages.smali = {\n    comment: /#.*/,\n    string: {\n      pattern: /\"(?:[^\\r\\n\\\\\"]|\\\\.)*\"|'(?:[^\\r\\n\\\\']|\\\\(?:.|u[\\da-fA-F]{4}))'/,\n      greedy: true\n    },\n    'class-name': {\n      pattern:\n        /(^|[^L])L(?:(?:\\w+|`[^`\\r\\n]*`)\\/)*(?:[\\w$]+|`[^`\\r\\n]*`)(?=\\s*;)/,\n      lookbehind: true,\n      inside: {\n        'class-name': {\n          pattern: /(^L|\\/)(?:[\\w$]+|`[^`\\r\\n]*`)$/,\n          lookbehind: true\n        },\n        namespace: {\n          pattern: /^(L)(?:(?:\\w+|`[^`\\r\\n]*`)\\/)+/,\n          lookbehind: true,\n          inside: {\n            punctuation: /\\//\n          }\n        },\n        builtin: /^L/\n      }\n    },\n    builtin: [\n      {\n        // Reference: https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields#types\n        pattern: /([();\\[])[BCDFIJSVZ]+/,\n        lookbehind: true\n      },\n      {\n        // e.g. .field mWifiOnUid:I\n        pattern: /([\\w$>]:)[BCDFIJSVZ]/,\n        lookbehind: true\n      }\n    ],\n    keyword: [\n      {\n        pattern: /(\\.end\\s+)[\\w-]+/,\n        lookbehind: true\n      },\n      {\n        pattern: /(^|[^\\w.-])\\.(?!\\d)[\\w-]+/,\n        lookbehind: true\n      },\n      {\n        pattern:\n          /(^|[^\\w.-])(?:abstract|annotation|bridge|constructor|enum|final|interface|private|protected|public|runtime|static|synthetic|system|transient)(?![\\w.-])/,\n        lookbehind: true\n      }\n    ],\n    function: {\n      pattern: /(^|[^\\w.-])(?:\\w+|<[\\w$-]+>)(?=\\()/,\n      lookbehind: true\n    },\n    field: {\n      pattern: /[\\w$]+(?=:)/,\n      alias: 'variable'\n    },\n    register: {\n      pattern: /(^|[^\\w.-])[vp]\\d(?![\\w.-])/,\n      lookbehind: true,\n      alias: 'variable'\n    },\n    boolean: {\n      pattern: /(^|[^\\w.-])(?:false|true)(?![\\w.-])/,\n      lookbehind: true\n    },\n    number: {\n      pattern:\n        /(^|[^/\\w.-])-?(?:NAN|INFINITY|0x(?:[\\dA-F]+(?:\\.[\\dA-F]*)?|\\.[\\dA-F]+)(?:p[+-]?[\\dA-F]+)?|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?)[dflst]?(?![\\w.-])/i,\n      lookbehind: true\n    },\n    label: {\n      pattern: /(:)\\w+/,\n      lookbehind: true,\n      alias: 'property'\n    },\n    operator: /->|\\.\\.|[\\[=]/,\n    punctuation: /[{}(),;:]/\n  }\n}\n","// @ts-nocheck\nsmalltalk.displayName = 'smalltalk'\nsmalltalk.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function smalltalk(Prism) {\n  Prism.languages.smalltalk = {\n    comment: {\n      pattern: /\"(?:\"\"|[^\"])*\"/,\n      greedy: true\n    },\n    char: {\n      pattern: /\\$./,\n      greedy: true\n    },\n    string: {\n      pattern: /'(?:''|[^'])*'/,\n      greedy: true\n    },\n    symbol: /#[\\da-z]+|#(?:-|([+\\/\\\\*~<>=@%|&?!])\\1?)|#(?=\\()/i,\n    'block-arguments': {\n      pattern: /(\\[\\s*):[^\\[|]*\\|/,\n      lookbehind: true,\n      inside: {\n        variable: /:[\\da-z]+/i,\n        punctuation: /\\|/\n      }\n    },\n    'temporary-variables': {\n      pattern: /\\|[^|]+\\|/,\n      inside: {\n        variable: /[\\da-z]+/i,\n        punctuation: /\\|/\n      }\n    },\n    keyword: /\\b(?:new|nil|self|super)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    number: [\n      /\\d+r-?[\\dA-Z]+(?:\\.[\\dA-Z]+)?(?:e-?\\d+)?/,\n      /\\b\\d+(?:\\.\\d+)?(?:e-?\\d+)?/\n    ],\n    operator: /[<=]=?|:=|~[~=]|\\/\\/?|\\\\\\\\|>[>=]?|[!^+\\-*&|,@]/,\n    punctuation: /[.;:?\\[\\](){}]/\n  }\n}\n","// @ts-nocheck\nimport refractorMarkupTemplating from './markup-templating.js'\nsmarty.displayName = 'smarty'\nsmarty.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function smarty(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.smarty = {\n      comment: {\n        pattern: /^\\{\\*[\\s\\S]*?\\*\\}/,\n        greedy: true\n      },\n      'embedded-php': {\n        pattern: /^\\{php\\}[\\s\\S]*?\\{\\/php\\}/,\n        greedy: true,\n        inside: {\n          smarty: {\n            pattern: /^\\{php\\}|\\{\\/php\\}$/,\n            inside: null // see below\n          },\n\n          php: {\n            pattern: /[\\s\\S]+/,\n            alias: 'language-php',\n            inside: Prism.languages.php\n          }\n        }\n      },\n      string: [\n        {\n          pattern: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n          greedy: true,\n          inside: {\n            interpolation: {\n              pattern: /\\{[^{}]*\\}|`[^`]*`/,\n              inside: {\n                'interpolation-punctuation': {\n                  pattern: /^[{`]|[`}]$/,\n                  alias: 'punctuation'\n                },\n                expression: {\n                  pattern: /[\\s\\S]+/,\n                  inside: null // see below\n                }\n              }\n            },\n\n            variable: /\\$\\w+/\n          }\n        },\n        {\n          pattern: /'(?:\\\\.|[^'\\\\\\r\\n])*'/,\n          greedy: true\n        }\n      ],\n      keyword: {\n        pattern: /(^\\{\\/?)[a-z_]\\w*\\b(?!\\()/i,\n        lookbehind: true,\n        greedy: true\n      },\n      delimiter: {\n        pattern: /^\\{\\/?|\\}$/,\n        greedy: true,\n        alias: 'punctuation'\n      },\n      number: /\\b0x[\\dA-Fa-f]+|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee][-+]?\\d+)?/,\n      variable: [\n        /\\$(?!\\d)\\w+/,\n        /#(?!\\d)\\w+#/,\n        {\n          pattern: /(\\.|->|\\w\\s*=)(?!\\d)\\w+\\b(?!\\()/,\n          lookbehind: true\n        },\n        {\n          pattern: /(\\[)(?!\\d)\\w+(?=\\])/,\n          lookbehind: true\n        }\n      ],\n      function: {\n        pattern: /(\\|\\s*)@?[a-z_]\\w*|\\b[a-z_]\\w*(?=\\()/i,\n        lookbehind: true\n      },\n      'attr-name': /\\b[a-z_]\\w*(?=\\s*=)/i,\n      boolean: /\\b(?:false|no|off|on|true|yes)\\b/,\n      punctuation: /[\\[\\](){}.,:`]|->/,\n      operator: [\n        /[+\\-*\\/%]|==?=?|[!<>]=?|&&|\\|\\|?/,\n        /\\bis\\s+(?:not\\s+)?(?:div|even|odd)(?:\\s+by)?\\b/,\n        /\\b(?:and|eq|gt?e|gt|lt?e|lt|mod|neq?|not|or)\\b/\n      ]\n    }\n    Prism.languages.smarty['embedded-php'].inside.smarty.inside =\n      Prism.languages.smarty\n    Prism.languages.smarty.string[0].inside.interpolation.inside.expression.inside =\n      Prism.languages.smarty\n    var string = /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"|'(?:\\\\.|[^'\\\\\\r\\n])*'/\n    var smartyPattern = RegExp(\n      // comments\n      /\\{\\*[\\s\\S]*?\\*\\}/.source +\n        '|' +\n        // php tags\n        /\\{php\\}[\\s\\S]*?\\{\\/php\\}/.source +\n        '|' +\n        // smarty blocks\n        /\\{(?:[^{}\"']|<str>|\\{(?:[^{}\"']|<str>|\\{(?:[^{}\"']|<str>)*\\})*\\})*\\}/.source.replace(\n          /<str>/g,\n          function () {\n            return string.source\n          }\n        ),\n      'g'\n    )\n\n    // Tokenize all inline Smarty expressions\n    Prism.hooks.add('before-tokenize', function (env) {\n      var smartyLiteralStart = '{literal}'\n      var smartyLiteralEnd = '{/literal}'\n      var smartyLiteralMode = false\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'smarty',\n        smartyPattern,\n        function (match) {\n          // Smarty tags inside {literal} block are ignored\n          if (match === smartyLiteralEnd) {\n            smartyLiteralMode = false\n          }\n          if (!smartyLiteralMode) {\n            if (match === smartyLiteralStart) {\n              smartyLiteralMode = true\n            }\n            return true\n          }\n          return false\n        }\n      )\n    })\n\n    // Re-insert the tokens after tokenizing\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'smarty')\n    })\n  })(Prism)\n}\n","// @ts-nocheck\nsml.displayName = 'sml'\nsml.aliases = ['smlnj']\n\n/** @type {import('../core.js').Syntax} */\nexport default function sml(Prism) {\n  // https://smlfamily.github.io/sml97-defn.pdf\n  // https://people.mpi-sws.org/~rossberg/sml.html\n  ;(function (Prism) {\n    var keywords =\n      /\\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\\b/i\n    Prism.languages.sml = {\n      // allow one level of nesting\n      comment:\n        /\\(\\*(?:[^*(]|\\*(?!\\))|\\((?!\\*)|\\(\\*(?:[^*(]|\\*(?!\\))|\\((?!\\*))*\\*\\))*\\*\\)/,\n      string: {\n        pattern: /#?\"(?:[^\"\\\\]|\\\\.)*\"/,\n        greedy: true\n      },\n      'class-name': [\n        {\n          // This is only an approximation since the real grammar is context-free\n          //\n          // Why the main loop so complex?\n          // The main loop is approximately the same as /(?:\\s*(?:[*,]|->)\\s*<TERMINAL>)*/ which is, obviously, a lot\n          // simpler. The difference is that if a comma is the last iteration of the loop, then the terminal must be\n          // followed by a long identifier.\n          pattern: RegExp(\n            /((?:^|[^:]):\\s*)<TERMINAL>(?:\\s*(?:(?:\\*|->)\\s*<TERMINAL>|,\\s*<TERMINAL>(?:(?=<NOT-LAST>)|(?!<NOT-LAST>)\\s+<LONG-ID>)))*/.source\n              .replace(/<NOT-LAST>/g, function () {\n                return /\\s*(?:[*,]|->)/.source\n              })\n              .replace(/<TERMINAL>/g, function () {\n                return /(?:'[\\w']*|<LONG-ID>|\\((?:[^()]|\\([^()]*\\))*\\)|\\{(?:[^{}]|\\{[^{}]*\\})*\\})(?:\\s+<LONG-ID>)*/\n                  .source\n              })\n              .replace(/<LONG-ID>/g, function () {\n                return /(?!<KEYWORD>)[a-z\\d_][\\w'.]*/.source\n              })\n              .replace(/<KEYWORD>/g, function () {\n                return keywords.source\n              }),\n            'i'\n          ),\n          lookbehind: true,\n          greedy: true,\n          inside: null // see below\n        },\n        {\n          pattern:\n            /((?:^|[^\\w'])(?:datatype|exception|functor|signature|structure|type)\\s+)[a-z_][\\w'.]*/i,\n          lookbehind: true\n        }\n      ],\n      function: {\n        pattern: /((?:^|[^\\w'])fun\\s+)[a-z_][\\w'.]*/i,\n        lookbehind: true\n      },\n      keyword: keywords,\n      variable: {\n        pattern: /(^|[^\\w'])'[\\w']*/,\n        lookbehind: true\n      },\n      number: /~?\\b(?:\\d+(?:\\.\\d+)?(?:e~?\\d+)?|0x[\\da-f]+)\\b/i,\n      word: {\n        pattern: /\\b0w(?:\\d+|x[\\da-f]+)\\b/i,\n        alias: 'constant'\n      },\n      boolean: /\\b(?:false|true)\\b/i,\n      operator: /\\.\\.\\.|:[>=:]|=>?|->|[<>]=?|[!+\\-*/^#|@~]/,\n      punctuation: /[(){}\\[\\].:,;]/\n    }\n    Prism.languages.sml['class-name'][0].inside = Prism.languages.sml\n    Prism.languages.smlnj = Prism.languages.sml\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nsolidity.displayName = 'solidity'\nsolidity.aliases = ['sol']\n\n/** @type {import('../core.js').Syntax} */\nexport default function solidity(Prism) {\n  Prism.register(refractorClike)\n  Prism.languages.solidity = Prism.languages.extend('clike', {\n    'class-name': {\n      pattern:\n        /(\\b(?:contract|enum|interface|library|new|struct|using)\\s+)(?!\\d)[\\w$]+/,\n      lookbehind: true\n    },\n    keyword:\n      /\\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\\b/,\n    operator: /=>|->|:=|=:|\\*\\*|\\+\\+|--|\\|\\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/\n  })\n  Prism.languages.insertBefore('solidity', 'keyword', {\n    builtin:\n      /\\b(?:address|bool|byte|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|string|bytes(?:[1-9]|[12]\\d|3[0-2])?)\\b/\n  })\n  Prism.languages.insertBefore('solidity', 'number', {\n    version: {\n      pattern: /([<>]=?|\\^)\\d+\\.\\d+\\.\\d+\\b/,\n      lookbehind: true,\n      alias: 'number'\n    }\n  })\n  Prism.languages.sol = Prism.languages.solidity\n}\n","// @ts-nocheck\nsolutionFile.displayName = 'solution-file'\nsolutionFile.aliases = ['sln']\n\n/** @type {import('../core.js').Syntax} */\nexport default function solutionFile(Prism) {\n  ;(function (Prism) {\n    var guid = {\n      // https://en.wikipedia.org/wiki/Universally_unique_identifier#Format\n      pattern: /\\{[\\da-f]{8}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{12}\\}/i,\n      alias: 'constant',\n      inside: {\n        punctuation: /[{}]/\n      }\n    }\n    Prism.languages['solution-file'] = {\n      comment: {\n        pattern: /#.*/,\n        greedy: true\n      },\n      string: {\n        pattern: /\"[^\"\\r\\n]*\"|'[^'\\r\\n]*'/,\n        greedy: true,\n        inside: {\n          guid: guid\n        }\n      },\n      object: {\n        // Foo\n        //   Bar(\"abs\") = 9\n        //   EndBar\n        //   Prop = TRUE\n        // EndFoo\n        pattern:\n          /^([ \\t]*)(?:([A-Z]\\w*)\\b(?=.*(?:\\r\\n?|\\n)(?:\\1[ \\t].*(?:\\r\\n?|\\n))*\\1End\\2(?=[ \\t]*$))|End[A-Z]\\w*(?=[ \\t]*$))/m,\n        lookbehind: true,\n        greedy: true,\n        alias: 'keyword'\n      },\n      property: {\n        pattern: /^([ \\t]*)(?!\\s)[^\\r\\n\"#=()]*[^\\s\"#=()](?=\\s*=)/m,\n        lookbehind: true,\n        inside: {\n          guid: guid\n        }\n      },\n      guid: guid,\n      number: /\\b\\d+(?:\\.\\d+)*\\b/,\n      boolean: /\\b(?:FALSE|TRUE)\\b/,\n      operator: /=/,\n      punctuation: /[(),]/\n    }\n    Prism.languages['sln'] = Prism.languages['solution-file']\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorMarkupTemplating from './markup-templating.js'\nsoy.displayName = 'soy'\nsoy.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function soy(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    var stringPattern = /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/\n    var numberPattern = /\\b\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?\\b|\\b0x[\\dA-F]+\\b/\n    Prism.languages.soy = {\n      comment: [\n        /\\/\\*[\\s\\S]*?\\*\\//,\n        {\n          pattern: /(\\s)\\/\\/.*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      'command-arg': {\n        pattern:\n          /(\\{+\\/?\\s*(?:alias|call|delcall|delpackage|deltemplate|namespace|template)\\s+)\\.?[\\w.]+/,\n        lookbehind: true,\n        alias: 'string',\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      parameter: {\n        pattern: /(\\{+\\/?\\s*@?param\\??\\s+)\\.?[\\w.]+/,\n        lookbehind: true,\n        alias: 'variable'\n      },\n      keyword: [\n        {\n          pattern:\n            /(\\{+\\/?[^\\S\\r\\n]*)(?:\\\\[nrt]|alias|call|case|css|default|delcall|delpackage|deltemplate|else(?:if)?|fallbackmsg|for(?:each)?|if(?:empty)?|lb|let|literal|msg|namespace|nil|@?param\\??|rb|sp|switch|template|xid)/,\n          lookbehind: true\n        },\n        /\\b(?:any|as|attributes|bool|css|float|html|in|int|js|list|map|null|number|string|uri)\\b/\n      ],\n      delimiter: {\n        pattern: /^\\{+\\/?|\\/?\\}+$/,\n        alias: 'punctuation'\n      },\n      property: /\\w+(?==)/,\n      variable: {\n        pattern: /\\$[^\\W\\d]\\w*(?:\\??(?:\\.\\w+|\\[[^\\]]+\\]))*/,\n        inside: {\n          string: {\n            pattern: stringPattern,\n            greedy: true\n          },\n          number: numberPattern,\n          punctuation: /[\\[\\].?]/\n        }\n      },\n      string: {\n        pattern: stringPattern,\n        greedy: true\n      },\n      function: [\n        /\\w+(?=\\()/,\n        {\n          pattern: /(\\|[^\\S\\r\\n]*)\\w+/,\n          lookbehind: true\n        }\n      ],\n      boolean: /\\b(?:false|true)\\b/,\n      number: numberPattern,\n      operator: /\\?:?|<=?|>=?|==?|!=|[+*/%-]|\\b(?:and|not|or)\\b/,\n      punctuation: /[{}()\\[\\]|.,:]/\n    }\n\n    // Tokenize all inline Soy expressions\n    Prism.hooks.add('before-tokenize', function (env) {\n      var soyPattern = /\\{\\{.+?\\}\\}|\\{.+?\\}|\\s\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//g\n      var soyLitteralStart = '{literal}'\n      var soyLitteralEnd = '{/literal}'\n      var soyLitteralMode = false\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'soy',\n        soyPattern,\n        function (match) {\n          // Soy tags inside {literal} block are ignored\n          if (match === soyLitteralEnd) {\n            soyLitteralMode = false\n          }\n          if (!soyLitteralMode) {\n            if (match === soyLitteralStart) {\n              soyLitteralMode = true\n            }\n            return true\n          }\n          return false\n        }\n      )\n    })\n\n    // Re-insert the tokens after tokenizing\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'soy')\n    })\n  })(Prism)\n}\n","// @ts-nocheck\nturtle.displayName = 'turtle'\nturtle.aliases = ['trig']\n\n/** @type {import('../core.js').Syntax} */\nexport default function turtle(Prism) {\n  Prism.languages.turtle = {\n    comment: {\n      pattern: /#.*/,\n      greedy: true\n    },\n    'multiline-string': {\n      pattern:\n        /\"\"\"(?:(?:\"\"?)?(?:[^\"\\\\]|\\\\.))*\"\"\"|'''(?:(?:''?)?(?:[^'\\\\]|\\\\.))*'''/,\n      greedy: true,\n      alias: 'string',\n      inside: {\n        comment: /#.*/\n      }\n    },\n    string: {\n      pattern: /\"(?:[^\\\\\"\\r\\n]|\\\\.)*\"|'(?:[^\\\\'\\r\\n]|\\\\.)*'/,\n      greedy: true\n    },\n    url: {\n      pattern:\n        /<(?:[^\\x00-\\x20<>\"{}|^`\\\\]|\\\\(?:u[\\da-fA-F]{4}|U[\\da-fA-F]{8}))*>/,\n      greedy: true,\n      inside: {\n        punctuation: /[<>]/\n      }\n    },\n    function: {\n      pattern:\n        /(?:(?![-.\\d\\xB7])[-.\\w\\xB7\\xC0-\\uFFFD]+)?:(?:(?![-.])(?:[-.:\\w\\xC0-\\uFFFD]|%[\\da-f]{2}|\\\\.)+)?/i,\n      inside: {\n        'local-name': {\n          pattern: /([^:]*:)[\\s\\S]+/,\n          lookbehind: true\n        },\n        prefix: {\n          pattern: /[\\s\\S]+/,\n          inside: {\n            punctuation: /:/\n          }\n        }\n      }\n    },\n    number: /[+-]?\\b\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?/i,\n    punctuation: /[{}.,;()[\\]]|\\^\\^/,\n    boolean: /\\b(?:false|true)\\b/,\n    keyword: [/(?:\\ba|@prefix|@base)\\b|=/, /\\b(?:base|graph|prefix)\\b/i],\n    tag: {\n      pattern: /@[a-z]+(?:-[a-z\\d]+)*/i,\n      inside: {\n        punctuation: /@/\n      }\n    }\n  }\n  Prism.languages.trig = Prism.languages['turtle']\n}\n","// @ts-nocheck\nimport refractorTurtle from './turtle.js'\nsparql.displayName = 'sparql'\nsparql.aliases = ['rq']\n\n/** @type {import('../core.js').Syntax} */\nexport default function sparql(Prism) {\n  Prism.register(refractorTurtle)\n  Prism.languages.sparql = Prism.languages.extend('turtle', {\n    boolean: /\\b(?:false|true)\\b/i,\n    variable: {\n      pattern: /[?$]\\w+/,\n      greedy: true\n    }\n  })\n  Prism.languages.insertBefore('sparql', 'punctuation', {\n    keyword: [\n      /\\b(?:A|ADD|ALL|AS|ASC|ASK|BNODE|BY|CLEAR|CONSTRUCT|COPY|CREATE|DATA|DEFAULT|DELETE|DESC|DESCRIBE|DISTINCT|DROP|EXISTS|FILTER|FROM|GROUP|HAVING|INSERT|INTO|LIMIT|LOAD|MINUS|MOVE|NAMED|NOT|NOW|OFFSET|OPTIONAL|ORDER|RAND|REDUCED|SELECT|SEPARATOR|SERVICE|SILENT|STRUUID|UNION|USING|UUID|VALUES|WHERE)\\b/i,\n      /\\b(?:ABS|AVG|BIND|BOUND|CEIL|COALESCE|CONCAT|CONTAINS|COUNT|DATATYPE|DAY|ENCODE_FOR_URI|FLOOR|GROUP_CONCAT|HOURS|IF|IRI|isBLANK|isIRI|isLITERAL|isNUMERIC|isURI|LANG|LANGMATCHES|LCASE|MAX|MD5|MIN|MINUTES|MONTH|REGEX|REPLACE|ROUND|sameTerm|SAMPLE|SECONDS|SHA1|SHA256|SHA384|SHA512|STR|STRAFTER|STRBEFORE|STRDT|STRENDS|STRLANG|STRLEN|STRSTARTS|SUBSTR|SUM|TIMEZONE|TZ|UCASE|URI|YEAR)\\b(?=\\s*\\()/i,\n      /\\b(?:BASE|GRAPH|PREFIX)\\b/i\n    ]\n  })\n  Prism.languages.rq = Prism.languages.sparql\n}\n","// @ts-nocheck\nsplunkSpl.displayName = 'splunk-spl'\nsplunkSpl.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function splunkSpl(Prism) {\n  Prism.languages['splunk-spl'] = {\n    comment: /`comment\\(\"(?:\\\\.|[^\\\\\"])*\"\\)`/,\n    string: {\n      pattern: /\"(?:\\\\.|[^\\\\\"])*\"/,\n      greedy: true\n    },\n    // https://docs.splunk.com/Documentation/Splunk/7.3.0/SearchReference/ListOfSearchCommands\n    keyword:\n      /\\b(?:abstract|accum|addcoltotals|addinfo|addtotals|analyzefields|anomalies|anomalousvalue|anomalydetection|append|appendcols|appendcsv|appendlookup|appendpipe|arules|associate|audit|autoregress|bin|bucket|bucketdir|chart|cluster|cofilter|collect|concurrency|contingency|convert|correlate|datamodel|dbinspect|dedup|delete|delta|diff|erex|eval|eventcount|eventstats|extract|fieldformat|fields|fieldsummary|filldown|fillnull|findtypes|folderize|foreach|format|from|gauge|gentimes|geom|geomfilter|geostats|head|highlight|history|iconify|input|inputcsv|inputlookup|iplocation|join|kmeans|kv|kvform|loadjob|localize|localop|lookup|makecontinuous|makemv|makeresults|map|mcollect|metadata|metasearch|meventcollect|mstats|multikv|multisearch|mvcombine|mvexpand|nomv|outlier|outputcsv|outputlookup|outputtext|overlap|pivot|predict|rangemap|rare|regex|relevancy|reltime|rename|replace|rest|return|reverse|rex|rtorder|run|savedsearch|script|scrub|search|searchtxn|selfjoin|sendemail|set|setfields|sichart|sirare|sistats|sitimechart|sitop|sort|spath|stats|strcat|streamstats|table|tags|tail|timechart|timewrap|top|transaction|transpose|trendline|tscollect|tstats|typeahead|typelearner|typer|union|uniq|untable|where|x11|xmlkv|xmlunescape|xpath|xyseries)\\b/i,\n    'operator-word': {\n      pattern: /\\b(?:and|as|by|not|or|xor)\\b/i,\n      alias: 'operator'\n    },\n    function: /\\b\\w+(?=\\s*\\()/,\n    property: /\\b\\w+(?=\\s*=(?!=))/,\n    date: {\n      // MM/DD/YYYY(:HH:MM:SS)?\n      pattern: /\\b\\d{1,2}\\/\\d{1,2}\\/\\d{1,4}(?:(?::\\d{1,2}){3})?\\b/,\n      alias: 'number'\n    },\n    number: /\\b\\d+(?:\\.\\d+)?\\b/,\n    boolean: /\\b(?:f|false|t|true)\\b/i,\n    operator: /[<>=]=?|[-+*/%|]/,\n    punctuation: /[()[\\],]/\n  }\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nsqf.displayName = 'sqf'\nsqf.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function sqf(Prism) {\n  Prism.register(refractorClike)\n  Prism.languages.sqf = Prism.languages.extend('clike', {\n    string: {\n      pattern: /\"(?:(?:\"\")?[^\"])*\"(?!\")|'(?:[^'])*'/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:breakOut|breakTo|call|case|catch|default|do|echo|else|execFSM|execVM|exitWith|for|forEach|forEachMember|forEachMemberAgent|forEachMemberTeam|from|goto|if|nil|preprocessFile|preprocessFileLineNumbers|private|scopeName|spawn|step|switch|then|throw|to|try|while|with)\\b/i,\n    boolean: /\\b(?:false|true)\\b/i,\n    function:\n      /\\b(?:abs|accTime|acos|action|actionIDs|actionKeys|actionKeysImages|actionKeysNames|actionKeysNamesArray|actionName|actionParams|activateAddons|activatedAddons|activateKey|add3DENConnection|add3DENEventHandler|add3DENLayer|addAction|addBackpack|addBackpackCargo|addBackpackCargoGlobal|addBackpackGlobal|addCamShake|addCuratorAddons|addCuratorCameraArea|addCuratorEditableObjects|addCuratorEditingArea|addCuratorPoints|addEditorObject|addEventHandler|addForce|addForceGeneratorRTD|addGoggles|addGroupIcon|addHandgunItem|addHeadgear|addItem|addItemCargo|addItemCargoGlobal|addItemPool|addItemToBackpack|addItemToUniform|addItemToVest|addLiveStats|addMagazine|addMagazineAmmoCargo|addMagazineCargo|addMagazineCargoGlobal|addMagazineGlobal|addMagazinePool|addMagazines|addMagazineTurret|addMenu|addMenuItem|addMissionEventHandler|addMPEventHandler|addMusicEventHandler|addOwnedMine|addPlayerScores|addPrimaryWeaponItem|addPublicVariableEventHandler|addRating|addResources|addScore|addScoreSide|addSecondaryWeaponItem|addSwitchableUnit|addTeamMember|addToRemainsCollector|addTorque|addUniform|addVehicle|addVest|addWaypoint|addWeapon|addWeaponCargo|addWeaponCargoGlobal|addWeaponGlobal|addWeaponItem|addWeaponPool|addWeaponTurret|admin|agent|agents|AGLToASL|aimedAtTarget|aimPos|airDensityCurveRTD|airDensityRTD|airplaneThrottle|airportSide|AISFinishHeal|alive|all3DENEntities|allAirports|allControls|allCurators|allCutLayers|allDead|allDeadMen|allDisplays|allGroups|allMapMarkers|allMines|allMissionObjects|allow3DMode|allowCrewInImmobile|allowCuratorLogicIgnoreAreas|allowDamage|allowDammage|allowFileOperations|allowFleeing|allowGetIn|allowSprint|allPlayers|allSimpleObjects|allSites|allTurrets|allUnits|allUnitsUAV|allVariables|ammo|ammoOnPylon|animate|animateBay|animateDoor|animatePylon|animateSource|animationNames|animationPhase|animationSourcePhase|animationState|append|apply|armoryPoints|arrayIntersect|asin|ASLToAGL|ASLToATL|assert|assignAsCargo|assignAsCargoIndex|assignAsCommander|assignAsDriver|assignAsGunner|assignAsTurret|assignCurator|assignedCargo|assignedCommander|assignedDriver|assignedGunner|assignedItems|assignedTarget|assignedTeam|assignedVehicle|assignedVehicleRole|assignItem|assignTeam|assignToAirport|atan|atan2|atg|ATLToASL|attachedObject|attachedObjects|attachedTo|attachObject|attachTo|attackEnabled|backpack|backpackCargo|backpackContainer|backpackItems|backpackMagazines|backpackSpaceFor|behaviour|benchmark|binocular|blufor|boundingBox|boundingBoxReal|boundingCenter|briefingName|buildingExit|buildingPos|buldozer_EnableRoadDiag|buldozer_IsEnabledRoadDiag|buldozer_LoadNewRoads|buldozer_reloadOperMap|buttonAction|buttonSetAction|cadetMode|callExtension|camCommand|camCommit|camCommitPrepared|camCommitted|camConstuctionSetParams|camCreate|camDestroy|cameraEffect|cameraEffectEnableHUD|cameraInterest|cameraOn|cameraView|campaignConfigFile|camPreload|camPreloaded|camPrepareBank|camPrepareDir|camPrepareDive|camPrepareFocus|camPrepareFov|camPrepareFovRange|camPreparePos|camPrepareRelPos|camPrepareTarget|camSetBank|camSetDir|camSetDive|camSetFocus|camSetFov|camSetFovRange|camSetPos|camSetRelPos|camSetTarget|camTarget|camUseNVG|canAdd|canAddItemToBackpack|canAddItemToUniform|canAddItemToVest|cancelSimpleTaskDestination|canFire|canMove|canSlingLoad|canStand|canSuspend|canTriggerDynamicSimulation|canUnloadInCombat|canVehicleCargo|captive|captiveNum|cbChecked|cbSetChecked|ceil|channelEnabled|cheatsEnabled|checkAIFeature|checkVisibility|civilian|className|clear3DENAttribute|clear3DENInventory|clearAllItemsFromBackpack|clearBackpackCargo|clearBackpackCargoGlobal|clearForcesRTD|clearGroupIcons|clearItemCargo|clearItemCargoGlobal|clearItemPool|clearMagazineCargo|clearMagazineCargoGlobal|clearMagazinePool|clearOverlay|clearRadio|clearVehicleInit|clearWeaponCargo|clearWeaponCargoGlobal|clearWeaponPool|clientOwner|closeDialog|closeDisplay|closeOverlay|collapseObjectTree|collect3DENHistory|collectiveRTD|combatMode|commandArtilleryFire|commandChat|commander|commandFire|commandFollow|commandFSM|commandGetOut|commandingMenu|commandMove|commandRadio|commandStop|commandSuppressiveFire|commandTarget|commandWatch|comment|commitOverlay|compile|compileFinal|completedFSM|composeText|configClasses|configFile|configHierarchy|configName|configNull|configProperties|configSourceAddonList|configSourceMod|configSourceModList|confirmSensorTarget|connectTerminalToUAV|controlNull|controlsGroupCtrl|copyFromClipboard|copyToClipboard|copyWaypoints|cos|count|countEnemy|countFriendly|countSide|countType|countUnknown|create3DENComposition|create3DENEntity|createAgent|createCenter|createDialog|createDiaryLink|createDiaryRecord|createDiarySubject|createDisplay|createGearDialog|createGroup|createGuardedPoint|createLocation|createMarker|createMarkerLocal|createMenu|createMine|createMissionDisplay|createMPCampaignDisplay|createSimpleObject|createSimpleTask|createSite|createSoundSource|createTask|createTeam|createTrigger|createUnit|createVehicle|createVehicleCrew|createVehicleLocal|crew|ctAddHeader|ctAddRow|ctClear|ctCurSel|ctData|ctFindHeaderRows|ctFindRowHeader|ctHeaderControls|ctHeaderCount|ctRemoveHeaders|ctRemoveRows|ctrlActivate|ctrlAddEventHandler|ctrlAngle|ctrlAutoScrollDelay|ctrlAutoScrollRewind|ctrlAutoScrollSpeed|ctrlChecked|ctrlClassName|ctrlCommit|ctrlCommitted|ctrlCreate|ctrlDelete|ctrlEnable|ctrlEnabled|ctrlFade|ctrlHTMLLoaded|ctrlIDC|ctrlIDD|ctrlMapAnimAdd|ctrlMapAnimClear|ctrlMapAnimCommit|ctrlMapAnimDone|ctrlMapCursor|ctrlMapMouseOver|ctrlMapScale|ctrlMapScreenToWorld|ctrlMapWorldToScreen|ctrlModel|ctrlModelDirAndUp|ctrlModelScale|ctrlParent|ctrlParentControlsGroup|ctrlPosition|ctrlRemoveAllEventHandlers|ctrlRemoveEventHandler|ctrlScale|ctrlSetActiveColor|ctrlSetAngle|ctrlSetAutoScrollDelay|ctrlSetAutoScrollRewind|ctrlSetAutoScrollSpeed|ctrlSetBackgroundColor|ctrlSetChecked|ctrlSetDisabledColor|ctrlSetEventHandler|ctrlSetFade|ctrlSetFocus|ctrlSetFont|ctrlSetFontH1|ctrlSetFontH1B|ctrlSetFontH2|ctrlSetFontH2B|ctrlSetFontH3|ctrlSetFontH3B|ctrlSetFontH4|ctrlSetFontH4B|ctrlSetFontH5|ctrlSetFontH5B|ctrlSetFontH6|ctrlSetFontH6B|ctrlSetFontHeight|ctrlSetFontHeightH1|ctrlSetFontHeightH2|ctrlSetFontHeightH3|ctrlSetFontHeightH4|ctrlSetFontHeightH5|ctrlSetFontHeightH6|ctrlSetFontHeightSecondary|ctrlSetFontP|ctrlSetFontPB|ctrlSetFontSecondary|ctrlSetForegroundColor|ctrlSetModel|ctrlSetModelDirAndUp|ctrlSetModelScale|ctrlSetPixelPrecision|ctrlSetPosition|ctrlSetScale|ctrlSetStructuredText|ctrlSetText|ctrlSetTextColor|ctrlSetTextColorSecondary|ctrlSetTextSecondary|ctrlSetTooltip|ctrlSetTooltipColorBox|ctrlSetTooltipColorShade|ctrlSetTooltipColorText|ctrlShow|ctrlShown|ctrlText|ctrlTextHeight|ctrlTextSecondary|ctrlTextWidth|ctrlType|ctrlVisible|ctRowControls|ctRowCount|ctSetCurSel|ctSetData|ctSetHeaderTemplate|ctSetRowTemplate|ctSetValue|ctValue|curatorAddons|curatorCamera|curatorCameraArea|curatorCameraAreaCeiling|curatorCoef|curatorEditableObjects|curatorEditingArea|curatorEditingAreaType|curatorMouseOver|curatorPoints|curatorRegisteredObjects|curatorSelected|curatorWaypointCost|current3DENOperation|currentChannel|currentCommand|currentMagazine|currentMagazineDetail|currentMagazineDetailTurret|currentMagazineTurret|currentMuzzle|currentNamespace|currentTask|currentTasks|currentThrowable|currentVisionMode|currentWaypoint|currentWeapon|currentWeaponMode|currentWeaponTurret|currentZeroing|cursorObject|cursorTarget|customChat|customRadio|cutFadeOut|cutObj|cutRsc|cutText|damage|date|dateToNumber|daytime|deActivateKey|debriefingText|debugFSM|debugLog|deg|delete3DENEntities|deleteAt|deleteCenter|deleteCollection|deleteEditorObject|deleteGroup|deleteGroupWhenEmpty|deleteIdentity|deleteLocation|deleteMarker|deleteMarkerLocal|deleteRange|deleteResources|deleteSite|deleteStatus|deleteTeam|deleteVehicle|deleteVehicleCrew|deleteWaypoint|detach|detectedMines|diag_activeMissionFSMs|diag_activeScripts|diag_activeSQFScripts|diag_activeSQSScripts|diag_captureFrame|diag_captureFrameToFile|diag_captureSlowFrame|diag_codePerformance|diag_drawMode|diag_dynamicSimulationEnd|diag_enable|diag_enabled|diag_fps|diag_fpsMin|diag_frameNo|diag_lightNewLoad|diag_list|diag_log|diag_logSlowFrame|diag_mergeConfigFile|diag_recordTurretLimits|diag_setLightNew|diag_tickTime|diag_toggle|dialog|diarySubjectExists|didJIP|didJIPOwner|difficulty|difficultyEnabled|difficultyEnabledRTD|difficultyOption|direction|directSay|disableAI|disableCollisionWith|disableConversation|disableDebriefingStats|disableMapIndicators|disableNVGEquipment|disableRemoteSensors|disableSerialization|disableTIEquipment|disableUAVConnectability|disableUserInput|displayAddEventHandler|displayCtrl|displayNull|displayParent|displayRemoveAllEventHandlers|displayRemoveEventHandler|displaySetEventHandler|dissolveTeam|distance|distance2D|distanceSqr|distributionRegion|do3DENAction|doArtilleryFire|doFire|doFollow|doFSM|doGetOut|doMove|doorPhase|doStop|doSuppressiveFire|doTarget|doWatch|drawArrow|drawEllipse|drawIcon|drawIcon3D|drawLine|drawLine3D|drawLink|drawLocation|drawPolygon|drawRectangle|drawTriangle|driver|drop|dynamicSimulationDistance|dynamicSimulationDistanceCoef|dynamicSimulationEnabled|dynamicSimulationSystemEnabled|east|edit3DENMissionAttributes|editObject|editorSetEventHandler|effectiveCommander|emptyPositions|enableAI|enableAIFeature|enableAimPrecision|enableAttack|enableAudioFeature|enableAutoStartUpRTD|enableAutoTrimRTD|enableCamShake|enableCaustics|enableChannel|enableCollisionWith|enableCopilot|enableDebriefingStats|enableDiagLegend|enableDynamicSimulation|enableDynamicSimulationSystem|enableEndDialog|enableEngineArtillery|enableEnvironment|enableFatigue|enableGunLights|enableInfoPanelComponent|enableIRLasers|enableMimics|enablePersonTurret|enableRadio|enableReload|enableRopeAttach|enableSatNormalOnDetail|enableSaving|enableSentences|enableSimulation|enableSimulationGlobal|enableStamina|enableStressDamage|enableTeamSwitch|enableTraffic|enableUAVConnectability|enableUAVWaypoints|enableVehicleCargo|enableVehicleSensor|enableWeaponDisassembly|endl|endLoadingScreen|endMission|engineOn|enginesIsOnRTD|enginesPowerRTD|enginesRpmRTD|enginesTorqueRTD|entities|environmentEnabled|estimatedEndServerTime|estimatedTimeLeft|evalObjectArgument|everyBackpack|everyContainer|exec|execEditorScript|exp|expectedDestination|exportJIPMessages|eyeDirection|eyePos|face|faction|fadeMusic|fadeRadio|fadeSound|fadeSpeech|failMission|fillWeaponsFromPool|find|findCover|findDisplay|findEditorObject|findEmptyPosition|findEmptyPositionReady|findIf|findNearestEnemy|finishMissionInit|finite|fire|fireAtTarget|firstBackpack|flag|flagAnimationPhase|flagOwner|flagSide|flagTexture|fleeing|floor|flyInHeight|flyInHeightASL|fog|fogForecast|fogParams|forceAddUniform|forceAtPositionRTD|forcedMap|forceEnd|forceFlagTexture|forceFollowRoad|forceGeneratorRTD|forceMap|forceRespawn|forceSpeed|forceWalk|forceWeaponFire|forceWeatherChange|forgetTarget|format|formation|formationDirection|formationLeader|formationMembers|formationPosition|formationTask|formatText|formLeader|freeLook|fromEditor|fuel|fullCrew|gearIDCAmmoCount|gearSlotAmmoCount|gearSlotData|get3DENActionState|get3DENAttribute|get3DENCamera|get3DENConnections|get3DENEntity|get3DENEntityID|get3DENGrid|get3DENIconsVisible|get3DENLayerEntities|get3DENLinesVisible|get3DENMissionAttribute|get3DENMouseOver|get3DENSelected|getAimingCoef|getAllEnvSoundControllers|getAllHitPointsDamage|getAllOwnedMines|getAllSoundControllers|getAmmoCargo|getAnimAimPrecision|getAnimSpeedCoef|getArray|getArtilleryAmmo|getArtilleryComputerSettings|getArtilleryETA|getAssignedCuratorLogic|getAssignedCuratorUnit|getBackpackCargo|getBleedingRemaining|getBurningValue|getCameraViewDirection|getCargoIndex|getCenterOfMass|getClientState|getClientStateNumber|getCompatiblePylonMagazines|getConnectedUAV|getContainerMaxLoad|getCursorObjectParams|getCustomAimCoef|getDammage|getDescription|getDir|getDirVisual|getDLCAssetsUsage|getDLCAssetsUsageByName|getDLCs|getDLCUsageTime|getEditorCamera|getEditorMode|getEditorObjectScope|getElevationOffset|getEngineTargetRpmRTD|getEnvSoundController|getFatigue|getFieldManualStartPage|getForcedFlagTexture|getFriend|getFSMVariable|getFuelCargo|getGroupIcon|getGroupIconParams|getGroupIcons|getHideFrom|getHit|getHitIndex|getHitPointDamage|getItemCargo|getMagazineCargo|getMarkerColor|getMarkerPos|getMarkerSize|getMarkerType|getMass|getMissionConfig|getMissionConfigValue|getMissionDLCs|getMissionLayerEntities|getMissionLayers|getModelInfo|getMousePosition|getMusicPlayedTime|getNumber|getObjectArgument|getObjectChildren|getObjectDLC|getObjectMaterials|getObjectProxy|getObjectTextures|getObjectType|getObjectViewDistance|getOxygenRemaining|getPersonUsedDLCs|getPilotCameraDirection|getPilotCameraPosition|getPilotCameraRotation|getPilotCameraTarget|getPlateNumber|getPlayerChannel|getPlayerScores|getPlayerUID|getPlayerUIDOld|getPos|getPosASL|getPosASLVisual|getPosASLW|getPosATL|getPosATLVisual|getPosVisual|getPosWorld|getPylonMagazines|getRelDir|getRelPos|getRemoteSensorsDisabled|getRepairCargo|getResolution|getRotorBrakeRTD|getShadowDistance|getShotParents|getSlingLoad|getSoundController|getSoundControllerResult|getSpeed|getStamina|getStatValue|getSuppression|getTerrainGrid|getTerrainHeightASL|getText|getTotalDLCUsageTime|getTrimOffsetRTD|getUnitLoadout|getUnitTrait|getUserMFDText|getUserMFDValue|getVariable|getVehicleCargo|getWeaponCargo|getWeaponSway|getWingsOrientationRTD|getWingsPositionRTD|getWPPos|glanceAt|globalChat|globalRadio|goggles|group|groupChat|groupFromNetId|groupIconSelectable|groupIconsVisible|groupId|groupOwner|groupRadio|groupSelectedUnits|groupSelectUnit|grpNull|gunner|gusts|halt|handgunItems|handgunMagazine|handgunWeapon|handsHit|hasInterface|hasPilotCamera|hasWeapon|hcAllGroups|hcGroupParams|hcLeader|hcRemoveAllGroups|hcRemoveGroup|hcSelected|hcSelectGroup|hcSetGroup|hcShowBar|hcShownBar|headgear|hideBody|hideObject|hideObjectGlobal|hideSelection|hint|hintC|hintCadet|hintSilent|hmd|hostMission|htmlLoad|HUDMovementLevels|humidity|image|importAllGroups|importance|in|inArea|inAreaArray|incapacitatedState|independent|inflame|inflamed|infoPanel|infoPanelComponentEnabled|infoPanelComponents|infoPanels|inGameUISetEventHandler|inheritsFrom|initAmbientLife|inPolygon|inputAction|inRangeOfArtillery|insertEditorObject|intersect|is3DEN|is3DENMultiplayer|isAbleToBreathe|isAgent|isAimPrecisionEnabled|isArray|isAutoHoverOn|isAutonomous|isAutoStartUpEnabledRTD|isAutotest|isAutoTrimOnRTD|isBleeding|isBurning|isClass|isCollisionLightOn|isCopilotEnabled|isDamageAllowed|isDedicated|isDLCAvailable|isEngineOn|isEqualTo|isEqualType|isEqualTypeAll|isEqualTypeAny|isEqualTypeArray|isEqualTypeParams|isFilePatchingEnabled|isFlashlightOn|isFlatEmpty|isForcedWalk|isFormationLeader|isGroupDeletedWhenEmpty|isHidden|isInRemainsCollector|isInstructorFigureEnabled|isIRLaserOn|isKeyActive|isKindOf|isLaserOn|isLightOn|isLocalized|isManualFire|isMarkedForCollection|isMultiplayer|isMultiplayerSolo|isNil|isNull|isNumber|isObjectHidden|isObjectRTD|isOnRoad|isPipEnabled|isPlayer|isRealTime|isRemoteExecuted|isRemoteExecutedJIP|isServer|isShowing3DIcons|isSimpleObject|isSprintAllowed|isStaminaEnabled|isSteamMission|isStreamFriendlyUIEnabled|isStressDamageEnabled|isText|isTouchingGround|isTurnedOut|isTutHintsEnabled|isUAVConnectable|isUAVConnected|isUIContext|isUniformAllowed|isVehicleCargo|isVehicleRadarOn|isVehicleSensorEnabled|isWalking|isWeaponDeployed|isWeaponRested|itemCargo|items|itemsWithMagazines|join|joinAs|joinAsSilent|joinSilent|joinString|kbAddDatabase|kbAddDatabaseTargets|kbAddTopic|kbHasTopic|kbReact|kbRemoveTopic|kbTell|kbWasSaid|keyImage|keyName|knowsAbout|land|landAt|landResult|language|laserTarget|lbAdd|lbClear|lbColor|lbColorRight|lbCurSel|lbData|lbDelete|lbIsSelected|lbPicture|lbPictureRight|lbSelection|lbSetColor|lbSetColorRight|lbSetCurSel|lbSetData|lbSetPicture|lbSetPictureColor|lbSetPictureColorDisabled|lbSetPictureColorSelected|lbSetPictureRight|lbSetPictureRightColor|lbSetPictureRightColorDisabled|lbSetPictureRightColorSelected|lbSetSelectColor|lbSetSelectColorRight|lbSetSelected|lbSetText|lbSetTextRight|lbSetTooltip|lbSetValue|lbSize|lbSort|lbSortByValue|lbText|lbTextRight|lbValue|leader|leaderboardDeInit|leaderboardGetRows|leaderboardInit|leaderboardRequestRowsFriends|leaderboardRequestRowsGlobal|leaderboardRequestRowsGlobalAroundUser|leaderboardsRequestUploadScore|leaderboardsRequestUploadScoreKeepBest|leaderboardState|leaveVehicle|libraryCredits|libraryDisclaimers|lifeState|lightAttachObject|lightDetachObject|lightIsOn|lightnings|limitSpeed|linearConversion|lineBreak|lineIntersects|lineIntersectsObjs|lineIntersectsSurfaces|lineIntersectsWith|linkItem|list|listObjects|listRemoteTargets|listVehicleSensors|ln|lnbAddArray|lnbAddColumn|lnbAddRow|lnbClear|lnbColor|lnbColorRight|lnbCurSelRow|lnbData|lnbDeleteColumn|lnbDeleteRow|lnbGetColumnsPosition|lnbPicture|lnbPictureRight|lnbSetColor|lnbSetColorRight|lnbSetColumnsPos|lnbSetCurSelRow|lnbSetData|lnbSetPicture|lnbSetPictureColor|lnbSetPictureColorRight|lnbSetPictureColorSelected|lnbSetPictureColorSelectedRight|lnbSetPictureRight|lnbSetText|lnbSetTextRight|lnbSetValue|lnbSize|lnbSort|lnbSortByValue|lnbText|lnbTextRight|lnbValue|load|loadAbs|loadBackpack|loadFile|loadGame|loadIdentity|loadMagazine|loadOverlay|loadStatus|loadUniform|loadVest|local|localize|locationNull|locationPosition|lock|lockCameraTo|lockCargo|lockDriver|locked|lockedCargo|lockedDriver|lockedTurret|lockIdentity|lockTurret|lockWP|log|logEntities|logNetwork|logNetworkTerminate|lookAt|lookAtPos|magazineCargo|magazines|magazinesAllTurrets|magazinesAmmo|magazinesAmmoCargo|magazinesAmmoFull|magazinesDetail|magazinesDetailBackpack|magazinesDetailUniform|magazinesDetailVest|magazinesTurret|magazineTurretAmmo|mapAnimAdd|mapAnimClear|mapAnimCommit|mapAnimDone|mapCenterOnCamera|mapGridPosition|markAsFinishedOnSteam|markerAlpha|markerBrush|markerColor|markerDir|markerPos|markerShape|markerSize|markerText|markerType|max|members|menuAction|menuAdd|menuChecked|menuClear|menuCollapse|menuData|menuDelete|menuEnable|menuEnabled|menuExpand|menuHover|menuPicture|menuSetAction|menuSetCheck|menuSetData|menuSetPicture|menuSetValue|menuShortcut|menuShortcutText|menuSize|menuSort|menuText|menuURL|menuValue|min|mineActive|mineDetectedBy|missionConfigFile|missionDifficulty|missionName|missionNamespace|missionStart|missionVersion|modelToWorld|modelToWorldVisual|modelToWorldVisualWorld|modelToWorldWorld|modParams|moonIntensity|moonPhase|morale|move|move3DENCamera|moveInAny|moveInCargo|moveInCommander|moveInDriver|moveInGunner|moveInTurret|moveObjectToEnd|moveOut|moveTime|moveTo|moveToCompleted|moveToFailed|musicVolume|name|nameSound|nearEntities|nearestBuilding|nearestLocation|nearestLocations|nearestLocationWithDubbing|nearestObject|nearestObjects|nearestTerrainObjects|nearObjects|nearObjectsReady|nearRoads|nearSupplies|nearTargets|needReload|netId|netObjNull|newOverlay|nextMenuItemIndex|nextWeatherChange|nMenuItems|numberOfEnginesRTD|numberToDate|objectCurators|objectFromNetId|objectParent|objNull|objStatus|onBriefingGear|onBriefingGroup|onBriefingNotes|onBriefingPlan|onBriefingTeamSwitch|onCommandModeChanged|onDoubleClick|onEachFrame|onGroupIconClick|onGroupIconOverEnter|onGroupIconOverLeave|onHCGroupSelectionChanged|onMapSingleClick|onPlayerConnected|onPlayerDisconnected|onPreloadFinished|onPreloadStarted|onShowNewObject|onTeamSwitch|openCuratorInterface|openDLCPage|openDSInterface|openMap|openSteamApp|openYoutubeVideo|opfor|orderGetIn|overcast|overcastForecast|owner|param|params|parseNumber|parseSimpleArray|parseText|parsingNamespace|particlesQuality|pi|pickWeaponPool|pitch|pixelGrid|pixelGridBase|pixelGridNoUIScale|pixelH|pixelW|playableSlotsNumber|playableUnits|playAction|playActionNow|player|playerRespawnTime|playerSide|playersNumber|playGesture|playMission|playMove|playMoveNow|playMusic|playScriptedMission|playSound|playSound3D|position|positionCameraToWorld|posScreenToWorld|posWorldToScreen|ppEffectAdjust|ppEffectCommit|ppEffectCommitted|ppEffectCreate|ppEffectDestroy|ppEffectEnable|ppEffectEnabled|ppEffectForceInNVG|precision|preloadCamera|preloadObject|preloadSound|preloadTitleObj|preloadTitleRsc|primaryWeapon|primaryWeaponItems|primaryWeaponMagazine|priority|processDiaryLink|processInitCommands|productVersion|profileName|profileNamespace|profileNameSteam|progressLoadingScreen|progressPosition|progressSetPosition|publicVariable|publicVariableClient|publicVariableServer|pushBack|pushBackUnique|putWeaponPool|queryItemsPool|queryMagazinePool|queryWeaponPool|rad|radioChannelAdd|radioChannelCreate|radioChannelRemove|radioChannelSetCallSign|radioChannelSetLabel|radioVolume|rain|rainbow|random|rank|rankId|rating|rectangular|registeredTasks|registerTask|reload|reloadEnabled|remoteControl|remoteExec|remoteExecCall|remoteExecutedOwner|remove3DENConnection|remove3DENEventHandler|remove3DENLayer|removeAction|removeAll3DENEventHandlers|removeAllActions|removeAllAssignedItems|removeAllContainers|removeAllCuratorAddons|removeAllCuratorCameraAreas|removeAllCuratorEditingAreas|removeAllEventHandlers|removeAllHandgunItems|removeAllItems|removeAllItemsWithMagazines|removeAllMissionEventHandlers|removeAllMPEventHandlers|removeAllMusicEventHandlers|removeAllOwnedMines|removeAllPrimaryWeaponItems|removeAllWeapons|removeBackpack|removeBackpackGlobal|removeCuratorAddons|removeCuratorCameraArea|removeCuratorEditableObjects|removeCuratorEditingArea|removeDrawIcon|removeDrawLinks|removeEventHandler|removeFromRemainsCollector|removeGoggles|removeGroupIcon|removeHandgunItem|removeHeadgear|removeItem|removeItemFromBackpack|removeItemFromUniform|removeItemFromVest|removeItems|removeMagazine|removeMagazineGlobal|removeMagazines|removeMagazinesTurret|removeMagazineTurret|removeMenuItem|removeMissionEventHandler|removeMPEventHandler|removeMusicEventHandler|removeOwnedMine|removePrimaryWeaponItem|removeSecondaryWeaponItem|removeSimpleTask|removeSwitchableUnit|removeTeamMember|removeUniform|removeVest|removeWeapon|removeWeaponAttachmentCargo|removeWeaponCargo|removeWeaponGlobal|removeWeaponTurret|reportRemoteTarget|requiredVersion|resetCamShake|resetSubgroupDirection|resistance|resize|resources|respawnVehicle|restartEditorCamera|reveal|revealMine|reverse|reversedMouseY|roadAt|roadsConnectedTo|roleDescription|ropeAttachedObjects|ropeAttachedTo|ropeAttachEnabled|ropeAttachTo|ropeCreate|ropeCut|ropeDestroy|ropeDetach|ropeEndPosition|ropeLength|ropes|ropeUnwind|ropeUnwound|rotorsForcesRTD|rotorsRpmRTD|round|runInitScript|safeZoneH|safeZoneW|safeZoneWAbs|safeZoneX|safeZoneXAbs|safeZoneY|save3DENInventory|saveGame|saveIdentity|saveJoysticks|saveOverlay|saveProfileNamespace|saveStatus|saveVar|savingEnabled|say|say2D|say3D|score|scoreSide|screenshot|screenToWorld|scriptDone|scriptName|scriptNull|scudState|secondaryWeapon|secondaryWeaponItems|secondaryWeaponMagazine|select|selectBestPlaces|selectDiarySubject|selectedEditorObjects|selectEditorObject|selectionNames|selectionPosition|selectLeader|selectMax|selectMin|selectNoPlayer|selectPlayer|selectRandom|selectRandomWeighted|selectWeapon|selectWeaponTurret|sendAUMessage|sendSimpleCommand|sendTask|sendTaskResult|sendUDPMessage|serverCommand|serverCommandAvailable|serverCommandExecutable|serverName|serverTime|set|set3DENAttribute|set3DENAttributes|set3DENGrid|set3DENIconsVisible|set3DENLayer|set3DENLinesVisible|set3DENLogicType|set3DENMissionAttribute|set3DENMissionAttributes|set3DENModelsVisible|set3DENObjectType|set3DENSelected|setAccTime|setActualCollectiveRTD|setAirplaneThrottle|setAirportSide|setAmmo|setAmmoCargo|setAmmoOnPylon|setAnimSpeedCoef|setAperture|setApertureNew|setArmoryPoints|setAttributes|setAutonomous|setBehaviour|setBleedingRemaining|setBrakesRTD|setCameraInterest|setCamShakeDefParams|setCamShakeParams|setCamUseTI|setCaptive|setCenterOfMass|setCollisionLight|setCombatMode|setCompassOscillation|setConvoySeparation|setCuratorCameraAreaCeiling|setCuratorCoef|setCuratorEditingAreaType|setCuratorWaypointCost|setCurrentChannel|setCurrentTask|setCurrentWaypoint|setCustomAimCoef|setCustomWeightRTD|setDamage|setDammage|setDate|setDebriefingText|setDefaultCamera|setDestination|setDetailMapBlendPars|setDir|setDirection|setDrawIcon|setDriveOnPath|setDropInterval|setDynamicSimulationDistance|setDynamicSimulationDistanceCoef|setEditorMode|setEditorObjectScope|setEffectCondition|setEngineRpmRTD|setFace|setFaceAnimation|setFatigue|setFeatureType|setFlagAnimationPhase|setFlagOwner|setFlagSide|setFlagTexture|setFog|setForceGeneratorRTD|setFormation|setFormationTask|setFormDir|setFriend|setFromEditor|setFSMVariable|setFuel|setFuelCargo|setGroupIcon|setGroupIconParams|setGroupIconsSelectable|setGroupIconsVisible|setGroupId|setGroupIdGlobal|setGroupOwner|setGusts|setHideBehind|setHit|setHitIndex|setHitPointDamage|setHorizonParallaxCoef|setHUDMovementLevels|setIdentity|setImportance|setInfoPanel|setLeader|setLightAmbient|setLightAttenuation|setLightBrightness|setLightColor|setLightDayLight|setLightFlareMaxDistance|setLightFlareSize|setLightIntensity|setLightnings|setLightUseFlare|setLocalWindParams|setMagazineTurretAmmo|setMarkerAlpha|setMarkerAlphaLocal|setMarkerBrush|setMarkerBrushLocal|setMarkerColor|setMarkerColorLocal|setMarkerDir|setMarkerDirLocal|setMarkerPos|setMarkerPosLocal|setMarkerShape|setMarkerShapeLocal|setMarkerSize|setMarkerSizeLocal|setMarkerText|setMarkerTextLocal|setMarkerType|setMarkerTypeLocal|setMass|setMimic|setMousePosition|setMusicEffect|setMusicEventHandler|setName|setNameSound|setObjectArguments|setObjectMaterial|setObjectMaterialGlobal|setObjectProxy|setObjectTexture|setObjectTextureGlobal|setObjectViewDistance|setOvercast|setOwner|setOxygenRemaining|setParticleCircle|setParticleClass|setParticleFire|setParticleParams|setParticleRandom|setPilotCameraDirection|setPilotCameraRotation|setPilotCameraTarget|setPilotLight|setPiPEffect|setPitch|setPlateNumber|setPlayable|setPlayerRespawnTime|setPos|setPosASL|setPosASL2|setPosASLW|setPosATL|setPosition|setPosWorld|setPylonLoadOut|setPylonsPriority|setRadioMsg|setRain|setRainbow|setRandomLip|setRank|setRectangular|setRepairCargo|setRotorBrakeRTD|setShadowDistance|setShotParents|setSide|setSimpleTaskAlwaysVisible|setSimpleTaskCustomData|setSimpleTaskDescription|setSimpleTaskDestination|setSimpleTaskTarget|setSimpleTaskType|setSimulWeatherLayers|setSize|setSkill|setSlingLoad|setSoundEffect|setSpeaker|setSpeech|setSpeedMode|setStamina|setStaminaScheme|setStatValue|setSuppression|setSystemOfUnits|setTargetAge|setTaskMarkerOffset|setTaskResult|setTaskState|setTerrainGrid|setText|setTimeMultiplier|setTitleEffect|setToneMapping|setToneMappingParams|setTrafficDensity|setTrafficDistance|setTrafficGap|setTrafficSpeed|setTriggerActivation|setTriggerArea|setTriggerStatements|setTriggerText|setTriggerTimeout|setTriggerType|setType|setUnconscious|setUnitAbility|setUnitLoadout|setUnitPos|setUnitPosWeak|setUnitRank|setUnitRecoilCoefficient|setUnitTrait|setUnloadInCombat|setUserActionText|setUserMFDText|setUserMFDValue|setVariable|setVectorDir|setVectorDirAndUp|setVectorUp|setVehicleAmmo|setVehicleAmmoDef|setVehicleArmor|setVehicleCargo|setVehicleId|setVehicleInit|setVehicleLock|setVehiclePosition|setVehicleRadar|setVehicleReceiveRemoteTargets|setVehicleReportOwnPosition|setVehicleReportRemoteTargets|setVehicleTIPars|setVehicleVarName|setVelocity|setVelocityModelSpace|setVelocityTransformation|setViewDistance|setVisibleIfTreeCollapsed|setWantedRpmRTD|setWaves|setWaypointBehaviour|setWaypointCombatMode|setWaypointCompletionRadius|setWaypointDescription|setWaypointForceBehaviour|setWaypointFormation|setWaypointHousePosition|setWaypointLoiterRadius|setWaypointLoiterType|setWaypointName|setWaypointPosition|setWaypointScript|setWaypointSpeed|setWaypointStatements|setWaypointTimeout|setWaypointType|setWaypointVisible|setWeaponReloadingTime|setWind|setWindDir|setWindForce|setWindStr|setWingForceScaleRTD|setWPPos|show3DIcons|showChat|showCinemaBorder|showCommandingMenu|showCompass|showCuratorCompass|showGPS|showHUD|showLegend|showMap|shownArtilleryComputer|shownChat|shownCompass|shownCuratorCompass|showNewEditorObject|shownGPS|shownHUD|shownMap|shownPad|shownRadio|shownScoretable|shownUAVFeed|shownWarrant|shownWatch|showPad|showRadio|showScoretable|showSubtitles|showUAVFeed|showWarrant|showWatch|showWaypoint|showWaypoints|side|sideAmbientLife|sideChat|sideEmpty|sideEnemy|sideFriendly|sideLogic|sideRadio|sideUnknown|simpleTasks|simulationEnabled|simulCloudDensity|simulCloudOcclusion|simulInClouds|simulWeatherSync|sin|size|sizeOf|skill|skillFinal|skipTime|sleep|sliderPosition|sliderRange|sliderSetPosition|sliderSetRange|sliderSetSpeed|sliderSpeed|slingLoadAssistantShown|soldierMagazines|someAmmo|sort|soundVolume|speaker|speed|speedMode|splitString|sqrt|squadParams|stance|startLoadingScreen|stop|stopEngineRTD|stopped|str|sunOrMoon|supportInfo|suppressFor|surfaceIsWater|surfaceNormal|surfaceType|swimInDepth|switchableUnits|switchAction|switchCamera|switchGesture|switchLight|switchMove|synchronizedObjects|synchronizedTriggers|synchronizedWaypoints|synchronizeObjectsAdd|synchronizeObjectsRemove|synchronizeTrigger|synchronizeWaypoint|systemChat|systemOfUnits|tan|targetKnowledge|targets|targetsAggregate|targetsQuery|taskAlwaysVisible|taskChildren|taskCompleted|taskCustomData|taskDescription|taskDestination|taskHint|taskMarkerOffset|taskNull|taskParent|taskResult|taskState|taskType|teamMember|teamMemberNull|teamName|teams|teamSwitch|teamSwitchEnabled|teamType|terminate|terrainIntersect|terrainIntersectASL|terrainIntersectAtASL|text|textLog|textLogFormat|tg|time|timeMultiplier|titleCut|titleFadeOut|titleObj|titleRsc|titleText|toArray|toFixed|toLower|toString|toUpper|triggerActivated|triggerActivation|triggerArea|triggerAttachedVehicle|triggerAttachObject|triggerAttachVehicle|triggerDynamicSimulation|triggerStatements|triggerText|triggerTimeout|triggerTimeoutCurrent|triggerType|turretLocal|turretOwner|turretUnit|tvAdd|tvClear|tvCollapse|tvCollapseAll|tvCount|tvCurSel|tvData|tvDelete|tvExpand|tvExpandAll|tvPicture|tvPictureRight|tvSetColor|tvSetCurSel|tvSetData|tvSetPicture|tvSetPictureColor|tvSetPictureColorDisabled|tvSetPictureColorSelected|tvSetPictureRight|tvSetPictureRightColor|tvSetPictureRightColorDisabled|tvSetPictureRightColorSelected|tvSetSelectColor|tvSetText|tvSetTooltip|tvSetValue|tvSort|tvSortByValue|tvText|tvTooltip|tvValue|type|typeName|typeOf|UAVControl|uiNamespace|uiSleep|unassignCurator|unassignItem|unassignTeam|unassignVehicle|underwater|uniform|uniformContainer|uniformItems|uniformMagazines|unitAddons|unitAimPosition|unitAimPositionVisual|unitBackpack|unitIsUAV|unitPos|unitReady|unitRecoilCoefficient|units|unitsBelowHeight|unlinkItem|unlockAchievement|unregisterTask|updateDrawIcon|updateMenuItem|updateObjectTree|useAIOperMapObstructionTest|useAISteeringComponent|useAudioTimeForMoves|userInputDisabled|vectorAdd|vectorCos|vectorCrossProduct|vectorDiff|vectorDir|vectorDirVisual|vectorDistance|vectorDistanceSqr|vectorDotProduct|vectorFromTo|vectorMagnitude|vectorMagnitudeSqr|vectorModelToWorld|vectorModelToWorldVisual|vectorMultiply|vectorNormalized|vectorUp|vectorUpVisual|vectorWorldToModel|vectorWorldToModelVisual|vehicle|vehicleCargoEnabled|vehicleChat|vehicleRadio|vehicleReceiveRemoteTargets|vehicleReportOwnPosition|vehicleReportRemoteTargets|vehicles|vehicleVarName|velocity|velocityModelSpace|verifySignature|vest|vestContainer|vestItems|vestMagazines|viewDistance|visibleCompass|visibleGPS|visibleMap|visiblePosition|visiblePositionASL|visibleScoretable|visibleWatch|waitUntil|waves|waypointAttachedObject|waypointAttachedVehicle|waypointAttachObject|waypointAttachVehicle|waypointBehaviour|waypointCombatMode|waypointCompletionRadius|waypointDescription|waypointForceBehaviour|waypointFormation|waypointHousePosition|waypointLoiterRadius|waypointLoiterType|waypointName|waypointPosition|waypoints|waypointScript|waypointsEnabledUAV|waypointShow|waypointSpeed|waypointStatements|waypointTimeout|waypointTimeoutCurrent|waypointType|waypointVisible|weaponAccessories|weaponAccessoriesCargo|weaponCargo|weaponDirection|weaponInertia|weaponLowered|weapons|weaponsItems|weaponsItemsCargo|weaponState|weaponsTurret|weightRTD|west|WFSideText|wind|windDir|windRTD|windStr|wingsForcesRTD|worldName|worldSize|worldToModel|worldToModelVisual|worldToScreen)\\b/i,\n    number:\n      /(?:\\$|\\b0x)[\\da-f]+\\b|(?:\\B\\.\\d+|\\b\\d+(?:\\.\\d+)?)(?:e[+-]?\\d+)?\\b/i,\n    operator: /##|>>|&&|\\|\\||[!=<>]=?|[-+*/%#^]|\\b(?:and|mod|not|or)\\b/i,\n    'magic-variable': {\n      pattern:\n        /\\b(?:this|thisList|thisTrigger|_exception|_fnc_scriptName|_fnc_scriptNameParent|_forEachIndex|_this|_thisEventHandler|_thisFSM|_thisScript|_x)\\b/i,\n      alias: 'keyword'\n    },\n    constant: /\\bDIK(?:_[a-z\\d]+)+\\b/i\n  })\n  Prism.languages.insertBefore('sqf', 'string', {\n    macro: {\n      pattern: /(^[ \\t]*)#[a-z](?:[^\\r\\n\\\\]|\\\\(?:\\r\\n|[\\s\\S]))*/im,\n      lookbehind: true,\n      greedy: true,\n      alias: 'property',\n      inside: {\n        directive: {\n          pattern: /#[a-z]+\\b/i,\n          alias: 'keyword'\n        },\n        comment: Prism.languages.sqf.comment\n      }\n    }\n  })\n  delete Prism.languages.sqf['class-name']\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nsquirrel.displayName = 'squirrel'\nsquirrel.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function squirrel(Prism) {\n  Prism.register(refractorClike)\n  Prism.languages.squirrel = Prism.languages.extend('clike', {\n    comment: [\n      Prism.languages.clike['comment'][0],\n      {\n        pattern: /(^|[^\\\\:])(?:\\/\\/|#).*/,\n        lookbehind: true,\n        greedy: true\n      }\n    ],\n    string: {\n      pattern: /(^|[^\\\\\"'@])(?:@\"(?:[^\"]|\"\")*\"(?!\")|\"(?:[^\\\\\\r\\n\"]|\\\\.)*\")/,\n      lookbehind: true,\n      greedy: true\n    },\n    'class-name': {\n      pattern: /(\\b(?:class|enum|extends|instanceof)\\s+)\\w+(?:\\.\\w+)*/,\n      lookbehind: true,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    keyword:\n      /\\b(?:__FILE__|__LINE__|base|break|case|catch|class|clone|const|constructor|continue|default|delete|else|enum|extends|for|foreach|function|if|in|instanceof|local|null|resume|return|static|switch|this|throw|try|typeof|while|yield)\\b/,\n    number: /\\b(?:0x[0-9a-fA-F]+|\\d+(?:\\.(?:\\d+|[eE][+-]?\\d+))?)\\b/,\n    operator: /\\+\\+|--|<=>|<[-<]|>>>?|&&?|\\|\\|?|[-+*/%!=<>]=?|[~^]|::?/,\n    punctuation: /[(){}\\[\\],;.]/\n  })\n  Prism.languages.insertBefore('squirrel', 'string', {\n    char: {\n      pattern: /(^|[^\\\\\"'])'(?:[^\\\\']|\\\\(?:[xuU][0-9a-fA-F]{0,8}|[\\s\\S]))'/,\n      lookbehind: true,\n      greedy: true\n    }\n  })\n  Prism.languages.insertBefore('squirrel', 'operator', {\n    'attribute-punctuation': {\n      pattern: /<\\/|\\/>/,\n      alias: 'important'\n    },\n    lambda: {\n      pattern: /@(?=\\()/,\n      alias: 'operator'\n    }\n  })\n}\n","// @ts-nocheck\nstan.displayName = 'stan'\nstan.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function stan(Prism) {\n  ;(function (Prism) {\n    // https://mc-stan.org/docs/2_28/reference-manual/bnf-grammars.html\n\n    var higherOrderFunctions =\n      /\\b(?:algebra_solver|algebra_solver_newton|integrate_1d|integrate_ode|integrate_ode_bdf|integrate_ode_rk45|map_rect|ode_(?:adams|bdf|ckrk|rk45)(?:_tol)?|ode_adjoint_tol_ctl|reduce_sum|reduce_sum_static)\\b/\n    Prism.languages.stan = {\n      comment: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\/|#(?!include).*/,\n      string: {\n        // String literals can contain spaces and any printable ASCII characters except for \" and \\\n        // https://mc-stan.org/docs/2_24/reference-manual/print-statements-section.html#string-literals\n        pattern: /\"[\\x20\\x21\\x23-\\x5B\\x5D-\\x7E]*\"/,\n        greedy: true\n      },\n      directive: {\n        pattern: /^([ \\t]*)#include\\b.*/m,\n        lookbehind: true,\n        alias: 'property'\n      },\n      'function-arg': {\n        pattern: RegExp(\n          '(' +\n            higherOrderFunctions.source +\n            /\\s*\\(\\s*/.source +\n            ')' +\n            /[a-zA-Z]\\w*/.source\n        ),\n        lookbehind: true,\n        alias: 'function'\n      },\n      constraint: {\n        pattern: /(\\b(?:int|matrix|real|row_vector|vector)\\s*)<[^<>]*>/,\n        lookbehind: true,\n        inside: {\n          expression: {\n            pattern: /(=\\s*)\\S(?:\\S|\\s+(?!\\s))*?(?=\\s*(?:>$|,\\s*\\w+\\s*=))/,\n            lookbehind: true,\n            inside: null // see below\n          },\n\n          property: /\\b[a-z]\\w*(?=\\s*=)/i,\n          operator: /=/,\n          punctuation: /^<|>$|,/\n        }\n      },\n      keyword: [\n        {\n          pattern:\n            /\\bdata(?=\\s*\\{)|\\b(?:functions|generated|model|parameters|quantities|transformed)\\b/,\n          alias: 'program-block'\n        },\n        /\\b(?:array|break|cholesky_factor_corr|cholesky_factor_cov|complex|continue|corr_matrix|cov_matrix|data|else|for|if|in|increment_log_prob|int|matrix|ordered|positive_ordered|print|real|reject|return|row_vector|simplex|target|unit_vector|vector|void|while)\\b/,\n        // these are functions that are known to take another function as their first argument.\n        higherOrderFunctions\n      ],\n      function: /\\b[a-z]\\w*(?=\\s*\\()/i,\n      number:\n        /(?:\\b\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\B\\.\\d+(?:_\\d+)*)(?:E[+-]?\\d+(?:_\\d+)*)?i?(?!\\w)/i,\n      boolean: /\\b(?:false|true)\\b/,\n      operator: /<-|\\.[*/]=?|\\|\\|?|&&|[!=<>+\\-*/]=?|['^%~?:]/,\n      punctuation: /[()\\[\\]{},;]/\n    }\n    Prism.languages.stan.constraint.inside.expression.inside =\n      Prism.languages.stan\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorJava from './java.js'\nimport refractorMata from './mata.js'\nimport refractorPython from './python.js'\nstata.displayName = 'stata'\nstata.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function stata(Prism) {\n  Prism.register(refractorJava)\n  Prism.register(refractorMata)\n  Prism.register(refractorPython)\n  // https://www.stata.com/manuals/u.pdf\n  // https://www.stata.com/manuals/p.pdf\n\n  Prism.languages.stata = {\n    comment: [\n      {\n        pattern: /(^[ \\t]*)\\*.*/m,\n        lookbehind: true,\n        greedy: true\n      },\n      {\n        pattern: /(^|\\s)\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n        lookbehind: true,\n        greedy: true\n      }\n    ],\n    'string-literal': {\n      pattern: /\"[^\"\\r\\n]*\"|[‘`']\".*?\"[’`']/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /\\$\\{[^{}]*\\}|[‘`']\\w[^’`'\\r\\n]*[’`']/,\n          inside: {\n            punctuation: /^\\$\\{|\\}$/,\n            expression: {\n              pattern: /[\\s\\S]+/,\n              inside: null // see below\n            }\n          }\n        },\n\n        string: /[\\s\\S]+/\n      }\n    },\n    mata: {\n      pattern: /(^[ \\t]*mata[ \\t]*:)[\\s\\S]+?(?=^end\\b)/m,\n      lookbehind: true,\n      greedy: true,\n      alias: 'language-mata',\n      inside: Prism.languages.mata\n    },\n    java: {\n      pattern: /(^[ \\t]*java[ \\t]*:)[\\s\\S]+?(?=^end\\b)/m,\n      lookbehind: true,\n      greedy: true,\n      alias: 'language-java',\n      inside: Prism.languages.java\n    },\n    python: {\n      pattern: /(^[ \\t]*python[ \\t]*:)[\\s\\S]+?(?=^end\\b)/m,\n      lookbehind: true,\n      greedy: true,\n      alias: 'language-python',\n      inside: Prism.languages.python\n    },\n    command: {\n      pattern:\n        /(^[ \\t]*(?:\\.[ \\t]+)?(?:(?:bayes|bootstrap|by|bysort|capture|collect|fmm|fp|frame|jackknife|mfp|mi|nestreg|noisily|permute|quietly|rolling|simulate|statsby|stepwise|svy|version|xi)\\b[^:\\r\\n]*:[ \\t]*|(?:capture|noisily|quietly|version)[ \\t]+)?)[a-zA-Z]\\w*/m,\n      lookbehind: true,\n      greedy: true,\n      alias: 'keyword'\n    },\n    variable: /\\$\\w+|[‘`']\\w[^’`'\\r\\n]*[’`']/,\n    keyword:\n      /\\b(?:bayes|bootstrap|by|bysort|capture|clear|collect|fmm|fp|frame|if|in|jackknife|mi[ \\t]+estimate|mfp|nestreg|noisily|of|permute|quietly|rolling|simulate|sort|statsby|stepwise|svy|varlist|version|xi)\\b/,\n    boolean: /\\b(?:off|on)\\b/,\n    number: /\\b\\d+(?:\\.\\d+)?\\b|\\B\\.\\d+/,\n    function: /\\b[a-z_]\\w*(?=\\()/i,\n    operator: /\\+\\+|--|##?|[<>!=~]=?|[+\\-*^&|/]/,\n    punctuation: /[(){}[\\],:]/\n  }\n  Prism.languages.stata[\n    'string-literal'\n  ].inside.interpolation.inside.expression.inside = Prism.languages.stata\n}\n","// @ts-nocheck\nsupercollider.displayName = 'supercollider'\nsupercollider.aliases = ['sclang']\n\n/** @type {import('../core.js').Syntax} */\nexport default function supercollider(Prism) {\n  Prism.languages.supercollider = {\n    comment: {\n      pattern:\n        /\\/\\/.*|\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*\\*\\//,\n      greedy: true\n    },\n    string: {\n      pattern: /(^|[^\\\\])\"(?:[^\"\\\\]|\\\\[\\s\\S])*\"/,\n      lookbehind: true,\n      greedy: true\n    },\n    char: {\n      pattern: /\\$(?:[^\\\\\\r\\n]|\\\\.)/,\n      greedy: true\n    },\n    symbol: {\n      pattern: /(^|[^\\\\])'(?:[^'\\\\]|\\\\[\\s\\S])*'|\\\\\\w+/,\n      lookbehind: true,\n      greedy: true\n    },\n    keyword: /\\b(?:_|arg|classvar|const|nil|var|while)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    label: {\n      pattern: /\\b[a-z_]\\w*(?=\\s*:)/,\n      alias: 'property'\n    },\n    number:\n      /\\b(?:inf|pi|0x[0-9a-fA-F]+|\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?(?:pi)?|\\d+r[0-9a-zA-Z]+(?:\\.[0-9a-zA-Z]+)?|\\d+[sb]{1,4}\\d*)\\b/,\n    'class-name': /\\b[A-Z]\\w*\\b/,\n    operator:\n      /\\.{2,3}|#(?![[{])|&&|[!=]==?|\\+>>|\\+{1,3}|-[->]|=>|>>|\\?\\?|@\\|?@|\\|(?:@|[!=]=)?\\||!\\?|<[!=>]|\\*{1,2}|<{2,3}\\*?|[-!%&/<>?@|=`]/,\n    punctuation: /[{}()[\\].:,;]|#[[{]/\n  }\n  Prism.languages.sclang = Prism.languages.supercollider\n}\n","// @ts-nocheck\nsystemd.displayName = 'systemd'\nsystemd.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function systemd(Prism) {\n  // https://www.freedesktop.org/software/systemd/man/systemd.syntax.html\n\n  ;(function (Prism) {\n    var comment = {\n      pattern: /^[;#].*/m,\n      greedy: true\n    }\n    var quotesSource = /\"(?:[^\\r\\n\"\\\\]|\\\\(?:[^\\r]|\\r\\n?))*\"(?!\\S)/.source\n    Prism.languages.systemd = {\n      comment: comment,\n      section: {\n        pattern: /^\\[[^\\n\\r\\[\\]]*\\](?=[ \\t]*$)/m,\n        greedy: true,\n        inside: {\n          punctuation: /^\\[|\\]$/,\n          'section-name': {\n            pattern: /[\\s\\S]+/,\n            alias: 'selector'\n          }\n        }\n      },\n      key: {\n        pattern: /^[^\\s=]+(?=[ \\t]*=)/m,\n        greedy: true,\n        alias: 'attr-name'\n      },\n      value: {\n        // This pattern is quite complex because of two properties:\n        //  1) Quotes (strings) must be preceded by a space. Since we can't use lookbehinds, we have to \"resolve\"\n        //     the lookbehind. You will see this in the main loop where spaces are handled separately.\n        //  2) Line continuations.\n        //     After line continuations, empty lines and comments are ignored so we have to consume them.\n        pattern: RegExp(\n          /(=[ \\t]*(?!\\s))/.source +\n            // the value either starts with quotes or not\n            '(?:' +\n            quotesSource +\n            '|(?=[^\"\\r\\n]))' +\n            // main loop\n            '(?:' +\n            (/[^\\s\\\\]/.source +\n              // handle spaces separately because of quotes\n              '|' +\n              '[ \\t]+(?:(?![ \\t\"])|' +\n              quotesSource +\n              ')' +\n              // line continuation\n              '|' +\n              /\\\\[\\r\\n]+(?:[#;].*[\\r\\n]+)*(?![#;])/.source) +\n            ')*'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'attr-value',\n        inside: {\n          comment: comment,\n          quoted: {\n            pattern: RegExp(/(^|\\s)/.source + quotesSource),\n            lookbehind: true,\n            greedy: true\n          },\n          punctuation: /\\\\$/m,\n          boolean: {\n            pattern: /^(?:false|no|off|on|true|yes)$/,\n            greedy: true\n          }\n        }\n      },\n      punctuation: /=/\n    }\n  })(Prism)\n}\n","// @ts-nocheck\nt4Templating.displayName = 't4-templating'\nt4Templating.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function t4Templating(Prism) {\n  ;(function (Prism) {\n    function createBlock(prefix, inside, contentAlias) {\n      return {\n        pattern: RegExp('<#' + prefix + '[\\\\s\\\\S]*?#>'),\n        alias: 'block',\n        inside: {\n          delimiter: {\n            pattern: RegExp('^<#' + prefix + '|#>$'),\n            alias: 'important'\n          },\n          content: {\n            pattern: /[\\s\\S]+/,\n            inside: inside,\n            alias: contentAlias\n          }\n        }\n      }\n    }\n    function createT4(insideLang) {\n      var grammar = Prism.languages[insideLang]\n      var className = 'language-' + insideLang\n      return {\n        block: {\n          pattern: /<#[\\s\\S]+?#>/,\n          inside: {\n            directive: createBlock('@', {\n              'attr-value': {\n                pattern: /=(?:(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|[^\\s'\">=]+)/,\n                inside: {\n                  punctuation: /^=|^[\"']|[\"']$/\n                }\n              },\n              keyword: /\\b\\w+(?=\\s)/,\n              'attr-name': /\\b\\w+/\n            }),\n            expression: createBlock('=', grammar, className),\n            'class-feature': createBlock('\\\\+', grammar, className),\n            standard: createBlock('', grammar, className)\n          }\n        }\n      }\n    }\n    Prism.languages['t4-templating'] = Object.defineProperty({}, 'createT4', {\n      value: createT4\n    })\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorCsharp from './csharp.js'\nimport refractorT4Templating from './t4-templating.js'\nt4Cs.displayName = 't4-cs'\nt4Cs.aliases = ['t4']\n\n/** @type {import('../core.js').Syntax} */\nexport default function t4Cs(Prism) {\n  Prism.register(refractorCsharp)\n  Prism.register(refractorT4Templating)\n  Prism.languages.t4 = Prism.languages['t4-cs'] =\n    Prism.languages['t4-templating'].createT4('csharp')\n}\n","// @ts-nocheck\nimport refractorT4Templating from './t4-templating.js'\nimport refractorVbnet from './vbnet.js'\nt4Vb.displayName = 't4-vb'\nt4Vb.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function t4Vb(Prism) {\n  Prism.register(refractorT4Templating)\n  Prism.register(refractorVbnet)\n  Prism.languages['t4-vb'] = Prism.languages['t4-templating'].createT4('vbnet')\n}\n","// @ts-nocheck\nimport refractorYaml from './yaml.js'\ntap.displayName = 'tap'\ntap.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function tap(Prism) {\n  Prism.register(refractorYaml)\n  // https://en.wikipedia.org/wiki/Test_Anything_Protocol\n\n  Prism.languages.tap = {\n    fail: /not ok[^#{\\n\\r]*/,\n    pass: /ok[^#{\\n\\r]*/,\n    pragma: /pragma [+-][a-z]+/,\n    bailout: /bail out!.*/i,\n    version: /TAP version \\d+/i,\n    plan: /\\b\\d+\\.\\.\\d+(?: +#.*)?/,\n    subtest: {\n      pattern: /# Subtest(?:: .*)?/,\n      greedy: true\n    },\n    punctuation: /[{}]/,\n    directive: /#.*/,\n    yamlish: {\n      pattern: /(^[ \\t]*)---[\\s\\S]*?[\\r\\n][ \\t]*\\.\\.\\.$/m,\n      lookbehind: true,\n      inside: Prism.languages.yaml,\n      alias: 'language-yaml'\n    }\n  }\n}\n","// @ts-nocheck\ntcl.displayName = 'tcl'\ntcl.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function tcl(Prism) {\n  Prism.languages.tcl = {\n    comment: {\n      pattern: /(^|[^\\\\])#.*/,\n      lookbehind: true\n    },\n    string: {\n      pattern: /\"(?:[^\"\\\\\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*\"/,\n      greedy: true\n    },\n    variable: [\n      {\n        pattern: /(\\$)(?:::)?(?:[a-zA-Z0-9]+::)*\\w+/,\n        lookbehind: true\n      },\n      {\n        pattern: /(\\$)\\{[^}]+\\}/,\n        lookbehind: true\n      },\n      {\n        pattern: /(^[\\t ]*set[ \\t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\\w+/m,\n        lookbehind: true\n      }\n    ],\n    function: {\n      pattern: /(^[\\t ]*proc[ \\t]+)\\S+/m,\n      lookbehind: true\n    },\n    builtin: [\n      {\n        pattern:\n          /(^[\\t ]*)(?:break|class|continue|error|eval|exit|for|foreach|if|proc|return|switch|while)\\b/m,\n        lookbehind: true\n      },\n      /\\b(?:else|elseif)\\b/\n    ],\n    scope: {\n      pattern: /(^[\\t ]*)(?:global|upvar|variable)\\b/m,\n      lookbehind: true,\n      alias: 'constant'\n    },\n    keyword: {\n      pattern:\n        /(^[\\t ]*|\\[)(?:Safe_Base|Tcl|after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|scan|seek|set|socket|source|split|string|subst|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|test|vars|wordBreak(?:After|Before))|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\\b/m,\n      lookbehind: true\n    },\n    operator:\n      /!=?|\\*\\*?|==|&&?|\\|\\|?|<[=<]?|>[=>]?|[-+~\\/%?^]|\\b(?:eq|in|ne|ni)\\b/,\n    punctuation: /[{}()\\[\\]]/\n  }\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nimport refractorMarkupTemplating from './markup-templating.js'\ntt2.displayName = 'tt2'\ntt2.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function tt2(Prism) {\n  Prism.register(refractorClike)\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.tt2 = Prism.languages.extend('clike', {\n      comment: /#.*|\\[%#[\\s\\S]*?%\\]/,\n      keyword:\n        /\\b(?:BLOCK|CALL|CASE|CATCH|CLEAR|DEBUG|DEFAULT|ELSE|ELSIF|END|FILTER|FINAL|FOREACH|GET|IF|IN|INCLUDE|INSERT|LAST|MACRO|META|NEXT|PERL|PROCESS|RAWPERL|RETURN|SET|STOP|SWITCH|TAGS|THROW|TRY|UNLESS|USE|WHILE|WRAPPER)\\b/,\n      punctuation: /[[\\]{},()]/\n    })\n    Prism.languages.insertBefore('tt2', 'number', {\n      operator: /=[>=]?|!=?|<=?|>=?|&&|\\|\\|?|\\b(?:and|not|or)\\b/,\n      variable: {\n        pattern: /\\b[a-z]\\w*(?:\\s*\\.\\s*(?:\\d+|\\$?[a-z]\\w*))*\\b/i\n      }\n    })\n    Prism.languages.insertBefore('tt2', 'keyword', {\n      delimiter: {\n        pattern: /^(?:\\[%|%%)-?|-?%\\]$/,\n        alias: 'punctuation'\n      }\n    })\n    Prism.languages.insertBefore('tt2', 'string', {\n      'single-quoted-string': {\n        pattern: /'[^\\\\']*(?:\\\\[\\s\\S][^\\\\']*)*'/,\n        greedy: true,\n        alias: 'string'\n      },\n      'double-quoted-string': {\n        pattern: /\"[^\\\\\"]*(?:\\\\[\\s\\S][^\\\\\"]*)*\"/,\n        greedy: true,\n        alias: 'string',\n        inside: {\n          variable: {\n            pattern: /\\$(?:[a-z]\\w*(?:\\.(?:\\d+|\\$?[a-z]\\w*))*)/i\n          }\n        }\n      }\n    })\n\n    // The different types of TT2 strings \"replace\" the C-like standard string\n    delete Prism.languages.tt2.string\n    Prism.hooks.add('before-tokenize', function (env) {\n      var tt2Pattern = /\\[%[\\s\\S]+?%\\]/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'tt2',\n        tt2Pattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'tt2')\n    })\n  })(Prism)\n}\n","// @ts-nocheck\ntoml.displayName = 'toml'\ntoml.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function toml(Prism) {\n  ;(function (Prism) {\n    var key = /(?:[\\w-]+|'[^'\\n\\r]*'|\"(?:\\\\.|[^\\\\\"\\r\\n])*\")/.source\n\n    /**\n     * @param {string} pattern\n     */\n    function insertKey(pattern) {\n      return pattern.replace(/__/g, function () {\n        return key\n      })\n    }\n    Prism.languages.toml = {\n      comment: {\n        pattern: /#.*/,\n        greedy: true\n      },\n      table: {\n        pattern: RegExp(\n          insertKey(\n            /(^[\\t ]*\\[\\s*(?:\\[\\s*)?)__(?:\\s*\\.\\s*__)*(?=\\s*\\])/.source\n          ),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'class-name'\n      },\n      key: {\n        pattern: RegExp(\n          insertKey(/(^[\\t ]*|[{,]\\s*)__(?:\\s*\\.\\s*__)*(?=\\s*=)/.source),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'property'\n      },\n      string: {\n        pattern:\n          /\"\"\"(?:\\\\[\\s\\S]|[^\\\\])*?\"\"\"|'''[\\s\\S]*?'''|'[^'\\n\\r]*'|\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n        greedy: true\n      },\n      date: [\n        {\n          // Offset Date-Time, Local Date-Time, Local Date\n          pattern:\n            /\\b\\d{4}-\\d{2}-\\d{2}(?:[T\\s]\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})?)?\\b/i,\n          alias: 'number'\n        },\n        {\n          // Local Time\n          pattern: /\\b\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?\\b/,\n          alias: 'number'\n        }\n      ],\n      number:\n        /(?:\\b0(?:x[\\da-zA-Z]+(?:_[\\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\\b|[-+]?\\b\\d+(?:_\\d+)*(?:\\.\\d+(?:_\\d+)*)?(?:[eE][+-]?\\d+(?:_\\d+)*)?\\b|[-+]?\\b(?:inf|nan)\\b/,\n      boolean: /\\b(?:false|true)\\b/,\n      punctuation: /[.,=[\\]{}]/\n    }\n  })(Prism)\n}\n","// @ts-nocheck\ntremor.displayName = 'tremor'\ntremor.aliases = ['trickle', 'troy']\n\n/** @type {import('../core.js').Syntax} */\nexport default function tremor(Prism) {\n  ;(function (Prism) {\n    Prism.languages.tremor = {\n      comment: {\n        pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:--|\\/\\/|#).*)/,\n        lookbehind: true\n      },\n      'interpolated-string': null,\n      // see below\n      extractor: {\n        pattern: /\\b[a-z_]\\w*\\|(?:[^\\r\\n\\\\|]|\\\\(?:\\r\\n|[\\s\\S]))*\\|/i,\n        greedy: true,\n        inside: {\n          regex: {\n            pattern: /(^re)\\|[\\s\\S]+/,\n            lookbehind: true\n          },\n          function: /^\\w+/,\n          value: /\\|[\\s\\S]+/\n        }\n      },\n      identifier: {\n        pattern: /`[^`]*`/,\n        greedy: true\n      },\n      function: /\\b[a-z_]\\w*(?=\\s*(?:::\\s*<|\\())\\b/,\n      keyword:\n        /\\b(?:args|as|by|case|config|connect|connector|const|copy|create|default|define|deploy|drop|each|emit|end|erase|event|flow|fn|for|from|group|having|insert|into|intrinsic|let|links|match|merge|mod|move|of|operator|patch|pipeline|recur|script|select|set|sliding|state|stream|to|tumbling|update|use|when|where|window|with)\\b/,\n      boolean: /\\b(?:false|null|true)\\b/i,\n      number:\n        /\\b(?:0b[01_]*|0x[0-9a-fA-F_]*|\\d[\\d_]*(?:\\.\\d[\\d_]*)?(?:[Ee][+-]?[\\d_]+)?)\\b/,\n      'pattern-punctuation': {\n        pattern: /%(?=[({[])/,\n        alias: 'punctuation'\n      },\n      operator:\n        /[-+*\\/%~!^]=?|=[=>]?|&[&=]?|\\|[|=]?|<<?=?|>>?>?=?|(?:absent|and|not|or|present|xor)\\b/,\n      punctuation: /::|[;\\[\\]()\\{\\},.:]/\n    }\n    var interpolationPattern =\n      /#\\{(?:[^\"{}]|\\{[^{}]*\\}|\"(?:[^\"\\\\\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*\")*\\}/.source\n    Prism.languages.tremor['interpolated-string'] = {\n      pattern: RegExp(\n        /(^|[^\\\\])/.source +\n          '(?:' +\n          '\"\"\"(?:' +\n          /[^\"\\\\#]|\\\\[\\s\\S]|\"(?!\"\")|#(?!\\{)/.source +\n          '|' +\n          interpolationPattern +\n          ')*\"\"\"' +\n          '|' +\n          '\"(?:' +\n          /[^\"\\\\\\r\\n#]|\\\\(?:\\r\\n|[\\s\\S])|#(?!\\{)/.source +\n          '|' +\n          interpolationPattern +\n          ')*\"' +\n          ')'\n      ),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: RegExp(interpolationPattern),\n          inside: {\n            punctuation: /^#\\{|\\}$/,\n            expression: {\n              pattern: /[\\s\\S]+/,\n              inside: Prism.languages.tremor\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n    Prism.languages.troy = Prism.languages['tremor']\n    Prism.languages.trickle = Prism.languages['tremor']\n  })(Prism)\n}\n","// @ts-nocheck\ntyposcript.displayName = 'typoscript'\ntyposcript.aliases = ['tsconfig']\n\n/** @type {import('../core.js').Syntax} */\nexport default function typoscript(Prism) {\n  ;(function (Prism) {\n    var keywords =\n      /\\b(?:ACT|ACTIFSUB|CARRAY|CASE|CLEARGIF|COA|COA_INT|CONSTANTS|CONTENT|CUR|EDITPANEL|EFFECT|EXT|FILE|FLUIDTEMPLATE|FORM|FRAME|FRAMESET|GIFBUILDER|GMENU|GMENU_FOLDOUT|GMENU_LAYERS|GP|HMENU|HRULER|HTML|IENV|IFSUB|IMAGE|IMGMENU|IMGMENUITEM|IMGTEXT|IMG_RESOURCE|INCLUDE_TYPOSCRIPT|JSMENU|JSMENUITEM|LLL|LOAD_REGISTER|NO|PAGE|RECORDS|RESTORE_REGISTER|TEMPLATE|TEXT|TMENU|TMENUITEM|TMENU_LAYERS|USER|USER_INT|_GIFBUILDER|global|globalString|globalVar)\\b/\n    Prism.languages.typoscript = {\n      comment: [\n        {\n          // multiline comments /* */\n          pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n          lookbehind: true\n        },\n        {\n          // double-slash comments - ignored when backslashes or colon is found in front\n          // also ignored whenever directly after an equal-sign, because it would probably be an url without protocol\n          pattern: /(^|[^\\\\:= \\t]|(?:^|[^= \\t])[ \\t]+)\\/\\/.*/,\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          // hash comments - ignored when leading quote is found for hex colors in strings\n          pattern: /(^|[^\"'])#.*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      function: [\n        {\n          // old include style\n          pattern:\n            /<INCLUDE_TYPOSCRIPT:\\s*source\\s*=\\s*(?:\"[^\"\\r\\n]*\"|'[^'\\r\\n]*')\\s*>/,\n          inside: {\n            string: {\n              pattern: /\"[^\"\\r\\n]*\"|'[^'\\r\\n]*'/,\n              inside: {\n                keyword: keywords\n              }\n            },\n            keyword: {\n              pattern: /INCLUDE_TYPOSCRIPT/\n            }\n          }\n        },\n        {\n          // new include style\n          pattern: /@import\\s*(?:\"[^\"\\r\\n]*\"|'[^'\\r\\n]*')/,\n          inside: {\n            string: /\"[^\"\\r\\n]*\"|'[^'\\r\\n]*'/\n          }\n        }\n      ],\n      string: {\n        pattern: /^([^=]*=[< ]?)(?:(?!\\]\\n).)*/,\n        lookbehind: true,\n        inside: {\n          function: /\\{\\$.*\\}/,\n          // constants include\n          keyword: keywords,\n          number: /^\\d+$/,\n          punctuation: /[,|:]/\n        }\n      },\n      keyword: keywords,\n      number: {\n        // special highlighting for indexes of arrays in tags\n        pattern: /\\b\\d+\\s*[.{=]/,\n        inside: {\n          operator: /[.{=]/\n        }\n      },\n      tag: {\n        pattern: /\\.?[-\\w\\\\]+\\.?/,\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      punctuation: /[{}[\\];(),.:|]/,\n      operator: /[<>]=?|[!=]=?=?|--?|\\+\\+?|&&?|\\|\\|?|[?*/~^%]/\n    }\n    Prism.languages.tsconfig = Prism.languages.typoscript\n  })(Prism)\n}\n","// @ts-nocheck\nunrealscript.displayName = 'unrealscript'\nunrealscript.aliases = ['uc', 'uscript']\n\n/** @type {import('../core.js').Syntax} */\nexport default function unrealscript(Prism) {\n  Prism.languages.unrealscript = {\n    comment: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n    string: {\n      pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    category: {\n      pattern:\n        /(\\b(?:(?:autoexpand|hide|show)categories|var)\\s*\\()[^()]+(?=\\))/,\n      lookbehind: true,\n      greedy: true,\n      alias: 'property'\n    },\n    metadata: {\n      pattern: /(\\w\\s*)<\\s*\\w+\\s*=[^<>|=\\r\\n]+(?:\\|\\s*\\w+\\s*=[^<>|=\\r\\n]+)*>/,\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        property: /\\b\\w+(?=\\s*=)/,\n        operator: /=/,\n        punctuation: /[<>|]/\n      }\n    },\n    macro: {\n      pattern: /`\\w+/,\n      alias: 'property'\n    },\n    'class-name': {\n      pattern:\n        /(\\b(?:class|enum|extends|interface|state(?:\\(\\))?|struct|within)\\s+)\\w+/,\n      lookbehind: true\n    },\n    keyword:\n      /\\b(?:abstract|actor|array|auto|autoexpandcategories|bool|break|byte|case|class|classgroup|client|coerce|collapsecategories|config|const|continue|default|defaultproperties|delegate|dependson|deprecated|do|dontcollapsecategories|editconst|editinlinenew|else|enum|event|exec|export|extends|final|float|for|forcescriptorder|foreach|function|goto|guid|hidecategories|hidedropdown|if|ignores|implements|inherits|input|int|interface|iterator|latent|local|material|name|native|nativereplication|noexport|nontransient|noteditinlinenew|notplaceable|operator|optional|out|pawn|perobjectconfig|perobjectlocalized|placeable|postoperator|preoperator|private|protected|reliable|replication|return|server|showcategories|simulated|singular|state|static|string|struct|structdefault|structdefaultproperties|switch|texture|transient|travel|unreliable|until|var|vector|while|within)\\b/,\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n    boolean: /\\b(?:false|true)\\b/,\n    number: /\\b0x[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i,\n    // https://docs.unrealengine.com/udk/Three/UnrealScriptExpressions.html\n    operator:\n      />>|<<|--|\\+\\+|\\*\\*|[-+*/~!=<>$@]=?|&&?|\\|\\|?|\\^\\^?|[?:%]|\\b(?:ClockwiseFrom|Cross|Dot)\\b/,\n    punctuation: /[()[\\]{};,.]/\n  }\n  Prism.languages.uc = Prism.languages.uscript = Prism.languages.unrealscript\n}\n","// @ts-nocheck\nuorazor.displayName = 'uorazor'\nuorazor.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function uorazor(Prism) {\n  Prism.languages.uorazor = {\n    'comment-hash': {\n      pattern: /#.*/,\n      alias: 'comment',\n      greedy: true\n    },\n    'comment-slash': {\n      pattern: /\\/\\/.*/,\n      alias: 'comment',\n      greedy: true\n    },\n    string: {\n      pattern: /(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      inside: {\n        punctuation: /^['\"]|['\"]$/\n      },\n      greedy: true\n    },\n    'source-layers': {\n      pattern:\n        /\\b(?:arms|backpack|blue|bracelet|cancel|clear|cloak|criminal|earrings|enemy|facialhair|friend|friendly|gloves|gray|grey|ground|hair|head|innerlegs|innertorso|innocent|lefthand|middletorso|murderer|neck|nonfriendly|onehandedsecondary|outerlegs|outertorso|pants|red|righthand|ring|self|shirt|shoes|talisman|waist)\\b/i,\n      alias: 'function'\n    },\n    'source-commands': {\n      pattern:\n        /\\b(?:alliance|attack|cast|clearall|clearignore|clearjournal|clearlist|clearsysmsg|createlist|createtimer|dclick|dclicktype|dclickvar|dress|dressconfig|drop|droprelloc|emote|getlabel|guild|gumpclose|gumpresponse|hotkey|ignore|lasttarget|lift|lifttype|menu|menuresponse|msg|org|organize|organizer|overhead|pause|poplist|potion|promptresponse|pushlist|removelist|removetimer|rename|restock|say|scav|scavenger|script|setability|setlasttarget|setskill|settimer|setvar|sysmsg|target|targetloc|targetrelloc|targettype|undress|unignore|unsetvar|useobject|useonce|useskill|usetype|virtue|wait|waitforgump|waitformenu|waitforprompt|waitforstat|waitforsysmsg|waitfortarget|walk|wfsysmsg|wft|whisper|yell)\\b/,\n      alias: 'function'\n    },\n    'tag-name': {\n      pattern: /(^\\{%-?\\s*)\\w+/,\n      lookbehind: true,\n      alias: 'keyword'\n    },\n    delimiter: {\n      pattern: /^\\{[{%]-?|-?[%}]\\}$/,\n      alias: 'punctuation'\n    },\n    function:\n      /\\b(?:atlist|close|closest|count|counter|counttype|dead|dex|diffhits|diffmana|diffstam|diffweight|find|findbuff|finddebuff|findlayer|findtype|findtypelist|followers|gumpexists|hidden|hits|hp|hue|human|humanoid|ingump|inlist|insysmessage|insysmsg|int|invul|lhandempty|list|listexists|mana|maxhits|maxhp|maxmana|maxstam|maxweight|monster|mounted|name|next|noto|paralyzed|poisoned|position|prev|previous|queued|rand|random|rhandempty|skill|stam|str|targetexists|timer|timerexists|varexist|warmode|weight)\\b/,\n    keyword:\n      /\\b(?:and|as|break|continue|else|elseif|endfor|endif|endwhile|for|if|loop|not|or|replay|stop|while)\\b/,\n    boolean: /\\b(?:false|null|true)\\b/,\n    number: /\\b0x[\\dA-Fa-f]+|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee][-+]?\\d+)?/,\n    operator: [\n      {\n        pattern:\n          /(\\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\\s)/,\n        lookbehind: true\n      },\n      /[=<>]=?|!=|\\*\\*?|\\/\\/?|\\?:?|[-+~%|]/\n    ],\n    punctuation: /[()\\[\\]{}:.,]/\n  }\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nv.displayName = 'v'\nv.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function v(Prism) {\n  Prism.register(refractorClike)\n  ;(function (Prism) {\n    var interpolationExpr = {\n      pattern: /[\\s\\S]+/,\n      inside: null\n    }\n    Prism.languages.v = Prism.languages.extend('clike', {\n      string: {\n        pattern: /r?([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n        alias: 'quoted-string',\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern:\n              /((?:^|[^\\\\])(?:\\\\{2})*)\\$(?:\\{[^{}]*\\}|\\w+(?:\\.\\w+(?:\\([^\\(\\)]*\\))?|\\[[^\\[\\]]+\\])*)/,\n            lookbehind: true,\n            inside: {\n              'interpolation-variable': {\n                pattern: /^\\$\\w[\\s\\S]*$/,\n                alias: 'variable'\n              },\n              'interpolation-punctuation': {\n                pattern: /^\\$\\{|\\}$/,\n                alias: 'punctuation'\n              },\n              'interpolation-expression': interpolationExpr\n            }\n          }\n        }\n      },\n      'class-name': {\n        pattern: /(\\b(?:enum|interface|struct|type)\\s+)(?:C\\.)?\\w+/,\n        lookbehind: true\n      },\n      keyword:\n        /(?:\\b(?:__global|as|asm|assert|atomic|break|chan|const|continue|defer|else|embed|enum|fn|for|go(?:to)?|if|import|in|interface|is|lock|match|module|mut|none|or|pub|return|rlock|select|shared|sizeof|static|struct|type(?:of)?|union|unsafe)|\\$(?:else|for|if)|#(?:flag|include))\\b/,\n      number:\n        /\\b(?:0x[a-f\\d]+(?:_[a-f\\d]+)*|0b[01]+(?:_[01]+)*|0o[0-7]+(?:_[0-7]+)*|\\d+(?:_\\d+)*(?:\\.\\d+(?:_\\d+)*)?)\\b/i,\n      operator:\n        /~|\\?|[*\\/%^!=]=?|\\+[=+]?|-[=-]?|\\|[=|]?|&(?:=|&|\\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\\.\\.\\.?/,\n      builtin:\n        /\\b(?:any(?:_float|_int)?|bool|byte(?:ptr)?|charptr|f(?:32|64)|i(?:8|16|64|128|nt)|rune|size_t|string|u(?:16|32|64|128)|voidptr)\\b/\n    })\n    interpolationExpr.inside = Prism.languages.v\n    Prism.languages.insertBefore('v', 'string', {\n      char: {\n        pattern: /`(?:\\\\`|\\\\?[^`]{1,2})`/,\n        // using {1,2} instead of `u` flag for compatibility\n        alias: 'rune'\n      }\n    })\n    Prism.languages.insertBefore('v', 'operator', {\n      attribute: {\n        pattern:\n          /(^[\\t ]*)\\[(?:deprecated|direct_array_access|flag|inline|live|ref_only|typedef|unsafe_fn|windows_stdcall)\\]/m,\n        lookbehind: true,\n        alias: 'annotation',\n        inside: {\n          punctuation: /[\\[\\]]/,\n          keyword: /\\w+/\n        }\n      },\n      generic: {\n        pattern: /<\\w+>(?=\\s*[\\)\\{])/,\n        inside: {\n          punctuation: /[<>]/,\n          'class-name': /\\w+/\n        }\n      }\n    })\n    Prism.languages.insertBefore('v', 'function', {\n      'generic-function': {\n        // e.g. foo<T>( ...\n        pattern: /\\b\\w+\\s*<\\w+>(?=\\()/,\n        inside: {\n          function: /^\\w+/,\n          generic: {\n            pattern: /<\\w+>/,\n            inside: Prism.languages.v.generic.inside\n          }\n        }\n      }\n    })\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nvala.displayName = 'vala'\nvala.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function vala(Prism) {\n  Prism.register(refractorClike)\n  Prism.languages.vala = Prism.languages.extend('clike', {\n    // Classes copied from prism-csharp\n    'class-name': [\n      {\n        // (Foo bar, Bar baz)\n        pattern: /\\b[A-Z]\\w*(?:\\.\\w+)*\\b(?=(?:\\?\\s+|\\*?\\s+\\*?)\\w)/,\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      {\n        // [Foo]\n        pattern: /(\\[)[A-Z]\\w*(?:\\.\\w+)*\\b/,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      {\n        // class Foo : Bar\n        pattern:\n          /(\\b(?:class|interface)\\s+[A-Z]\\w*(?:\\.\\w+)*\\s*:\\s*)[A-Z]\\w*(?:\\.\\w+)*\\b/,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      {\n        // class Foo\n        pattern:\n          /((?:\\b(?:class|enum|interface|new|struct)\\s+)|(?:catch\\s+\\())[A-Z]\\w*(?:\\.\\w+)*\\b/,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\./\n        }\n      }\n    ],\n    keyword:\n      /\\b(?:abstract|as|assert|async|base|bool|break|case|catch|char|class|const|construct|continue|default|delegate|delete|do|double|dynamic|else|ensures|enum|errordomain|extern|finally|float|for|foreach|get|if|in|inline|int|int16|int32|int64|int8|interface|internal|is|lock|long|namespace|new|null|out|override|owned|params|private|protected|public|ref|requires|return|set|short|signal|sizeof|size_t|ssize_t|static|string|struct|switch|this|throw|throws|try|typeof|uchar|uint|uint16|uint32|uint64|uint8|ulong|unichar|unowned|ushort|using|value|var|virtual|void|volatile|weak|while|yield)\\b/i,\n    function: /\\b\\w+(?=\\s*\\()/,\n    number:\n      /(?:\\b0x[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?)(?:f|u?l?)?/i,\n    operator:\n      /\\+\\+|--|&&|\\|\\||<<=?|>>=?|=>|->|~|[+\\-*\\/%&^|=!<>]=?|\\?\\??|\\.\\.\\./,\n    punctuation: /[{}[\\];(),.:]/,\n    constant: /\\b[A-Z0-9_]+\\b/\n  })\n  Prism.languages.insertBefore('vala', 'string', {\n    'raw-string': {\n      pattern: /\"\"\"[\\s\\S]*?\"\"\"/,\n      greedy: true,\n      alias: 'string'\n    },\n    'template-string': {\n      pattern: /@\"[\\s\\S]*?\"/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /\\$(?:\\([^)]*\\)|[a-zA-Z]\\w*)/,\n          inside: {\n            delimiter: {\n              pattern: /^\\$\\(?|\\)$/,\n              alias: 'punctuation'\n            },\n            rest: Prism.languages.vala\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n  })\n  Prism.languages.insertBefore('vala', 'keyword', {\n    regex: {\n      pattern:\n        /\\/(?:\\[(?:[^\\]\\\\\\r\\n]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[imsx]{0,4}(?=\\s*(?:$|[\\r\\n,.;})\\]]))/,\n      greedy: true,\n      inside: {\n        'regex-source': {\n          pattern: /^(\\/)[\\s\\S]+(?=\\/[a-z]*$)/,\n          lookbehind: true,\n          alias: 'language-regex',\n          inside: Prism.languages.regex\n        },\n        'regex-delimiter': /^\\//,\n        'regex-flags': /^[a-z]+$/\n      }\n    }\n  })\n}\n","// @ts-nocheck\nimport refractorMarkup from './markup.js'\nvelocity.displayName = 'velocity'\nvelocity.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function velocity(Prism) {\n  Prism.register(refractorMarkup)\n  ;(function (Prism) {\n    Prism.languages.velocity = Prism.languages.extend('markup', {})\n    var velocity = {\n      variable: {\n        pattern:\n          /(^|[^\\\\](?:\\\\\\\\)*)\\$!?(?:[a-z][\\w-]*(?:\\([^)]*\\))?(?:\\.[a-z][\\w-]*(?:\\([^)]*\\))?|\\[[^\\]]+\\])*|\\{[^}]+\\})/i,\n        lookbehind: true,\n        inside: {} // See below\n      },\n\n      string: {\n        pattern: /\"[^\"]*\"|'[^']*'/,\n        greedy: true\n      },\n      number: /\\b\\d+\\b/,\n      boolean: /\\b(?:false|true)\\b/,\n      operator:\n        /[=!<>]=?|[+*/%-]|&&|\\|\\||\\.\\.|\\b(?:eq|g[et]|l[et]|n(?:e|ot))\\b/,\n      punctuation: /[(){}[\\]:,.]/\n    }\n    velocity.variable.inside = {\n      string: velocity['string'],\n      function: {\n        pattern: /([^\\w-])[a-z][\\w-]*(?=\\()/,\n        lookbehind: true\n      },\n      number: velocity['number'],\n      boolean: velocity['boolean'],\n      punctuation: velocity['punctuation']\n    }\n    Prism.languages.insertBefore('velocity', 'comment', {\n      unparsed: {\n        pattern: /(^|[^\\\\])#\\[\\[[\\s\\S]*?\\]\\]#/,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          punctuation: /^#\\[\\[|\\]\\]#$/\n        }\n      },\n      'velocity-comment': [\n        {\n          pattern: /(^|[^\\\\])#\\*[\\s\\S]*?\\*#/,\n          lookbehind: true,\n          greedy: true,\n          alias: 'comment'\n        },\n        {\n          pattern: /(^|[^\\\\])##.*/,\n          lookbehind: true,\n          greedy: true,\n          alias: 'comment'\n        }\n      ],\n      directive: {\n        pattern:\n          /(^|[^\\\\](?:\\\\\\\\)*)#@?(?:[a-z][\\w-]*|\\{[a-z][\\w-]*\\})(?:\\s*\\((?:[^()]|\\([^()]*\\))*\\))?/i,\n        lookbehind: true,\n        inside: {\n          keyword: {\n            pattern: /^#@?(?:[a-z][\\w-]*|\\{[a-z][\\w-]*\\})|\\bin\\b/,\n            inside: {\n              punctuation: /[{}]/\n            }\n          },\n          rest: velocity\n        }\n      },\n      variable: velocity['variable']\n    })\n    Prism.languages.velocity['tag'].inside['attr-value'].inside.rest =\n      Prism.languages.velocity\n  })(Prism)\n}\n","// @ts-nocheck\nverilog.displayName = 'verilog'\nverilog.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function verilog(Prism) {\n  Prism.languages.verilog = {\n    comment: {\n      pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"/,\n      greedy: true\n    },\n    'kernel-function': {\n      // support for any kernel function (ex: $display())\n      pattern: /\\B\\$\\w+\\b/,\n      alias: 'property'\n    },\n    // support for user defined constants (ex: `define)\n    constant: /\\B`\\w+\\b/,\n    function: /\\b\\w+(?=\\()/,\n    // support for verilog and system verilog keywords\n    keyword:\n      /\\b(?:alias|and|assert|assign|assume|automatic|before|begin|bind|bins|binsof|bit|break|buf|bufif0|bufif1|byte|case|casex|casez|cell|chandle|class|clocking|cmos|config|const|constraint|context|continue|cover|covergroup|coverpoint|cross|deassign|default|defparam|design|disable|dist|do|edge|else|end|endcase|endclass|endclocking|endconfig|endfunction|endgenerate|endgroup|endinterface|endmodule|endpackage|endprimitive|endprogram|endproperty|endsequence|endspecify|endtable|endtask|enum|event|expect|export|extends|extern|final|first_match|for|force|foreach|forever|fork|forkjoin|function|generate|genvar|highz0|highz1|if|iff|ifnone|ignore_bins|illegal_bins|import|incdir|include|initial|inout|input|inside|instance|int|integer|interface|intersect|join|join_any|join_none|large|liblist|library|local|localparam|logic|longint|macromodule|matches|medium|modport|module|nand|negedge|new|nmos|nor|noshowcancelled|not|notif0|notif1|null|or|output|package|packed|parameter|pmos|posedge|primitive|priority|program|property|protected|pull0|pull1|pulldown|pullup|pulsestyle_ondetect|pulsestyle_onevent|pure|rand|randc|randcase|randsequence|rcmos|real|realtime|ref|reg|release|repeat|return|rnmos|rpmos|rtran|rtranif0|rtranif1|scalared|sequence|shortint|shortreal|showcancelled|signed|small|solve|specify|specparam|static|string|strong0|strong1|struct|super|supply0|supply1|table|tagged|task|this|throughout|time|timeprecision|timeunit|tran|tranif0|tranif1|tri|tri0|tri1|triand|trior|trireg|type|typedef|union|unique|unsigned|use|uwire|var|vectored|virtual|void|wait|wait_order|wand|weak0|weak1|while|wildcard|wire|with|within|wor|xnor|xor)\\b/,\n    // bold highlighting for all verilog and system verilog logic blocks\n    important: /\\b(?:always|always_comb|always_ff|always_latch)\\b(?: *@)?/,\n    // support for time ticks, vectors, and real numbers\n    number:\n      /\\B##?\\d+|(?:\\b\\d+)?'[odbh] ?[\\da-fzx_?]+|\\b(?:\\d*[._])?\\d+(?:e[-+]?\\d+)?/i,\n    operator: /[-+{}^~%*\\/?=!<>&|]+/,\n    punctuation: /[[\\];(),.:]/\n  }\n}\n","// @ts-nocheck\nvhdl.displayName = 'vhdl'\nvhdl.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function vhdl(Prism) {\n  Prism.languages.vhdl = {\n    comment: /--.+/,\n    // support for all logic vectors\n    'vhdl-vectors': {\n      pattern: /\\b[oxb]\"[\\da-f_]+\"|\"[01uxzwlh-]+\"/i,\n      alias: 'number'\n    },\n    // support for operator overloading included\n    'quoted-function': {\n      pattern: /\"\\S+?\"(?=\\()/,\n      alias: 'function'\n    },\n    string: /\"(?:[^\\\\\"\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*\"/,\n    attribute: {\n      pattern: /\\b'\\w+/,\n      alias: 'attr-name'\n    },\n    // support for predefined attributes included\n    keyword:\n      /\\b(?:access|after|alias|all|architecture|array|assert|attribute|begin|block|body|buffer|bus|case|component|configuration|constant|disconnect|downto|else|elsif|end|entity|exit|file|for|function|generate|generic|group|guarded|if|impure|in|inertial|inout|is|label|library|linkage|literal|loop|map|new|next|null|of|on|open|others|out|package|port|postponed|private|procedure|process|pure|range|record|register|reject|report|return|select|severity|shared|signal|subtype|then|to|transport|type|unaffected|units|until|use|variable|view|wait|when|while|with)\\b/i,\n    boolean: /\\b(?:false|true)\\b/i,\n    function: /\\w+(?=\\()/,\n    // decimal, based, physical, and exponential numbers supported\n    number: /'[01uxzwlh-]'|\\b(?:\\d+#[\\da-f_.]+#|\\d[\\d_.]*)(?:e[-+]?\\d+)?/i,\n    operator:\n      /[<>]=?|:=|[-+*/&=]|\\b(?:abs|and|mod|nand|nor|not|or|rem|rol|ror|sla|sll|sra|srl|xnor|xor)\\b/i,\n    punctuation: /[{}[\\];(),.:]/\n  }\n}\n","// @ts-nocheck\nvim.displayName = 'vim'\nvim.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function vim(Prism) {\n  Prism.languages.vim = {\n    string: /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?:[^'\\r\\n]|'')*'/,\n    comment: /\".*/,\n    function: /\\b\\w+(?=\\()/,\n    keyword:\n      /\\b(?:N|Next|P|Print|X|XMLent|XMLns|ab|abbreviate|abc|abclear|abo|aboveleft|al|all|ar|arga|argadd|argd|argdelete|argdo|arge|argedit|argg|argglobal|argl|arglocal|args|argu|argument|as|ascii|b|bN|bNext|ba|bad|badd|ball|bd|bdelete|be|bel|belowright|bf|bfirst|bl|blast|bm|bmodified|bn|bnext|bo|botright|bp|bprevious|br|brea|break|breaka|breakadd|breakd|breakdel|breakl|breaklist|brewind|bro|browse|bufdo|buffer|buffers|bun|bunload|bw|bwipeout|c|cN|cNext|cNfcNfile|ca|cabbrev|cabc|cabclear|cad|caddb|caddbuffer|caddexpr|caddf|caddfile|cal|call|cat|catch|cb|cbuffer|cc|ccl|cclose|cd|ce|center|cex|cexpr|cf|cfile|cfir|cfirst|cg|cgetb|cgetbuffer|cgete|cgetexpr|cgetfile|change|changes|chd|chdir|che|checkpath|checkt|checktime|cl|cla|clast|clist|clo|close|cmapc|cmapclear|cn|cnew|cnewer|cnext|cnf|cnfile|cnorea|cnoreabbrev|co|col|colder|colo|colorscheme|comc|comclear|comp|compiler|con|conf|confirm|continue|cope|copen|copy|cp|cpf|cpfile|cprevious|cq|cquit|cr|crewind|cu|cuna|cunabbrev|cunmap|cw|cwindow|d|debugg|debuggreedy|delc|delcommand|delete|delf|delfunction|delm|delmarks|di|diffg|diffget|diffoff|diffpatch|diffpu|diffput|diffsplit|diffthis|diffu|diffupdate|dig|digraphs|display|dj|djump|dl|dlist|dr|drop|ds|dsearch|dsp|dsplit|e|earlier|echoe|echoerr|echom|echomsg|echon|edit|el|else|elsei|elseif|em|emenu|en|endf|endfo|endfor|endfun|endfunction|endif|endt|endtry|endw|endwhile|ene|enew|ex|exi|exit|exu|exusage|f|file|files|filetype|fin|fina|finally|find|fini|finish|fir|first|fix|fixdel|fo|fold|foldc|foldclose|foldd|folddoc|folddoclosed|folddoopen|foldo|foldopen|for|fu|fun|function|go|goto|gr|grep|grepa|grepadd|h|ha|hardcopy|help|helpf|helpfind|helpg|helpgrep|helpt|helptags|hid|hide|his|history|ia|iabbrev|iabc|iabclear|if|ij|ijump|il|ilist|imapc|imapclear|in|inorea|inoreabbrev|isearch|isp|isplit|iu|iuna|iunabbrev|iunmap|j|join|ju|jumps|k|kee|keepalt|keepj|keepjumps|keepmarks|l|lN|lNext|lNf|lNfile|la|lad|laddb|laddbuffer|laddexpr|laddf|laddfile|lan|language|last|later|lb|lbuffer|lc|lcd|lch|lchdir|lcl|lclose|left|lefta|leftabove|let|lex|lexpr|lf|lfile|lfir|lfirst|lg|lgetb|lgetbuffer|lgete|lgetexpr|lgetfile|lgr|lgrep|lgrepa|lgrepadd|lh|lhelpgrep|list|ll|lla|llast|lli|llist|lm|lmak|lmake|lmap|lmapc|lmapclear|ln|lne|lnew|lnewer|lnext|lnf|lnfile|lnoremap|lo|loadview|loc|lockmarks|lockv|lockvar|lol|lolder|lop|lopen|lp|lpf|lpfile|lprevious|lr|lrewind|ls|lt|ltag|lu|lunmap|lv|lvimgrep|lvimgrepa|lvimgrepadd|lw|lwindow|m|ma|mak|make|mark|marks|mat|match|menut|menutranslate|mk|mkexrc|mks|mksession|mksp|mkspell|mkv|mkvie|mkview|mkvimrc|mod|mode|move|mz|mzf|mzfile|mzscheme|n|nbkey|new|next|nmapc|nmapclear|noh|nohlsearch|norea|noreabbrev|nu|number|nun|nunmap|o|omapc|omapclear|on|only|open|opt|options|ou|ounmap|p|pc|pclose|pe|ped|pedit|perl|perld|perldo|po|pop|popu|popup|pp|ppop|pre|preserve|prev|previous|print|prof|profd|profdel|profile|promptf|promptfind|promptr|promptrepl|ps|psearch|ptN|ptNext|pta|ptag|ptf|ptfirst|ptj|ptjump|ptl|ptlast|ptn|ptnext|ptp|ptprevious|ptr|ptrewind|pts|ptselect|pu|put|pw|pwd|py|pyf|pyfile|python|q|qa|qall|quit|quita|quitall|r|read|rec|recover|red|redi|redir|redo|redr|redraw|redraws|redrawstatus|reg|registers|res|resize|ret|retab|retu|return|rew|rewind|ri|right|rightb|rightbelow|ru|rub|ruby|rubyd|rubydo|rubyf|rubyfile|runtime|rv|rviminfo|sN|sNext|sa|sal|sall|san|sandbox|sargument|sav|saveas|sb|sbN|sbNext|sba|sball|sbf|sbfirst|sbl|sblast|sbm|sbmodified|sbn|sbnext|sbp|sbprevious|sbr|sbrewind|sbuffer|scrip|scripte|scriptencoding|scriptnames|se|set|setf|setfiletype|setg|setglobal|setl|setlocal|sf|sfind|sfir|sfirst|sh|shell|sign|sil|silent|sim|simalt|sl|sla|slast|sleep|sm|smagic|smap|smapc|smapclear|sme|smenu|sn|snext|sni|sniff|sno|snomagic|snor|snoremap|snoreme|snoremenu|so|sor|sort|source|sp|spe|spelld|spelldump|spellgood|spelli|spellinfo|spellr|spellrepall|spellu|spellundo|spellw|spellwrong|split|spr|sprevious|sre|srewind|st|sta|stag|star|startg|startgreplace|startinsert|startr|startreplace|stj|stjump|stop|stopi|stopinsert|sts|stselect|sun|sunhide|sunm|sunmap|sus|suspend|sv|sview|syncbind|t|tN|tNext|ta|tab|tabN|tabNext|tabc|tabclose|tabd|tabdo|tabe|tabedit|tabf|tabfind|tabfir|tabfirst|tabl|tablast|tabm|tabmove|tabn|tabnew|tabnext|tabo|tabonly|tabp|tabprevious|tabr|tabrewind|tabs|tag|tags|tc|tcl|tcld|tcldo|tclf|tclfile|te|tearoff|tf|tfirst|th|throw|tj|tjump|tl|tlast|tm|tmenu|tn|tnext|to|topleft|tp|tprevious|tr|trewind|try|ts|tselect|tu|tunmenu|u|una|unabbreviate|undo|undoj|undojoin|undol|undolist|unh|unhide|unlet|unlo|unlockvar|unm|unmap|up|update|ve|verb|verbose|version|vert|vertical|vi|vie|view|vim|vimgrep|vimgrepa|vimgrepadd|visual|viu|viusage|vmapc|vmapclear|vne|vnew|vs|vsplit|vu|vunmap|w|wN|wNext|wa|wall|wh|while|win|winc|wincmd|windo|winp|winpos|winsize|wn|wnext|wp|wprevious|wq|wqa|wqall|write|ws|wsverb|wv|wviminfo|x|xa|xall|xit|xm|xmap|xmapc|xmapclear|xme|xmenu|xn|xnoremap|xnoreme|xnoremenu|xu|xunmap|y|yank)\\b/,\n    builtin:\n      /\\b(?:acd|ai|akm|aleph|allowrevins|altkeymap|ambiwidth|ambw|anti|antialias|arab|arabic|arabicshape|ari|arshape|autochdir|autocmd|autoindent|autoread|autowrite|autowriteall|aw|awa|background|backspace|backup|backupcopy|backupdir|backupext|backupskip|balloondelay|ballooneval|balloonexpr|bdir|bdlay|beval|bex|bexpr|bg|bh|bin|binary|biosk|bioskey|bk|bkc|bomb|breakat|brk|browsedir|bs|bsdir|bsk|bt|bufhidden|buflisted|buftype|casemap|ccv|cdpath|cedit|cfu|ch|charconvert|ci|cin|cindent|cink|cinkeys|cino|cinoptions|cinw|cinwords|clipboard|cmdheight|cmdwinheight|cmp|cms|columns|com|comments|commentstring|compatible|complete|completefunc|completeopt|consk|conskey|copyindent|cot|cpo|cpoptions|cpt|cscopepathcomp|cscopeprg|cscopequickfix|cscopetag|cscopetagorder|cscopeverbose|cspc|csprg|csqf|cst|csto|csverb|cuc|cul|cursorcolumn|cursorline|cwh|debug|deco|def|define|delcombine|dex|dg|dict|dictionary|diff|diffexpr|diffopt|digraph|dip|dir|directory|dy|ea|ead|eadirection|eb|ed|edcompatible|ef|efm|ei|ek|enc|encoding|endofline|eol|ep|equalalways|equalprg|errorbells|errorfile|errorformat|esckeys|et|eventignore|expandtab|exrc|fcl|fcs|fdc|fde|fdi|fdl|fdls|fdm|fdn|fdo|fdt|fen|fenc|fencs|fex|ff|ffs|fileencoding|fileencodings|fileformat|fileformats|fillchars|fk|fkmap|flp|fml|fmr|foldcolumn|foldenable|foldexpr|foldignore|foldlevel|foldlevelstart|foldmarker|foldmethod|foldminlines|foldnestmax|foldtext|formatexpr|formatlistpat|formatoptions|formatprg|fp|fs|fsync|ft|gcr|gd|gdefault|gfm|gfn|gfs|gfw|ghr|gp|grepformat|grepprg|gtl|gtt|guicursor|guifont|guifontset|guifontwide|guiheadroom|guioptions|guipty|guitablabel|guitabtooltip|helpfile|helpheight|helplang|hf|hh|hi|hidden|highlight|hk|hkmap|hkmapp|hkp|hl|hlg|hls|hlsearch|ic|icon|iconstring|ignorecase|im|imactivatekey|imak|imc|imcmdline|imd|imdisable|imi|iminsert|ims|imsearch|inc|include|includeexpr|incsearch|inde|indentexpr|indentkeys|indk|inex|inf|infercase|insertmode|invacd|invai|invakm|invallowrevins|invaltkeymap|invanti|invantialias|invar|invarab|invarabic|invarabicshape|invari|invarshape|invautochdir|invautoindent|invautoread|invautowrite|invautowriteall|invaw|invawa|invbackup|invballooneval|invbeval|invbin|invbinary|invbiosk|invbioskey|invbk|invbl|invbomb|invbuflisted|invcf|invci|invcin|invcindent|invcompatible|invconfirm|invconsk|invconskey|invcopyindent|invcp|invcscopetag|invcscopeverbose|invcst|invcsverb|invcuc|invcul|invcursorcolumn|invcursorline|invdeco|invdelcombine|invdg|invdiff|invdigraph|invdisable|invea|inveb|inved|invedcompatible|invek|invendofline|inveol|invequalalways|inverrorbells|invesckeys|invet|invex|invexpandtab|invexrc|invfen|invfk|invfkmap|invfoldenable|invgd|invgdefault|invguipty|invhid|invhidden|invhk|invhkmap|invhkmapp|invhkp|invhls|invhlsearch|invic|invicon|invignorecase|invim|invimc|invimcmdline|invimd|invincsearch|invinf|invinfercase|invinsertmode|invis|invjoinspaces|invjs|invlazyredraw|invlbr|invlinebreak|invlisp|invlist|invloadplugins|invlpl|invlz|invma|invmacatsui|invmagic|invmh|invml|invmod|invmodeline|invmodifiable|invmodified|invmore|invmousef|invmousefocus|invmousehide|invnu|invnumber|invodev|invopendevice|invpaste|invpi|invpreserveindent|invpreviewwindow|invprompt|invpvw|invreadonly|invremap|invrestorescreen|invrevins|invri|invrightleft|invrightleftcmd|invrl|invrlc|invro|invrs|invru|invruler|invsb|invsc|invscb|invscrollbind|invscs|invsecure|invsft|invshellslash|invshelltemp|invshiftround|invshortname|invshowcmd|invshowfulltag|invshowmatch|invshowmode|invsi|invsm|invsmartcase|invsmartindent|invsmarttab|invsmd|invsn|invsol|invspell|invsplitbelow|invsplitright|invspr|invsr|invssl|invsta|invstartofline|invstmp|invswapfile|invswf|invta|invtagbsearch|invtagrelative|invtagstack|invtbi|invtbidi|invtbs|invtermbidi|invterse|invtextauto|invtextmode|invtf|invtgst|invtildeop|invtimeout|invtitle|invto|invtop|invtr|invttimeout|invttybuiltin|invttyfast|invtx|invvb|invvisualbell|invwa|invwarn|invwb|invweirdinvert|invwfh|invwfw|invwildmenu|invwinfixheight|invwinfixwidth|invwiv|invwmnu|invwrap|invwrapscan|invwrite|invwriteany|invwritebackup|invws|isf|isfname|isi|isident|isk|iskeyword|isprint|joinspaces|js|key|keymap|keymodel|keywordprg|km|kmp|kp|langmap|langmenu|laststatus|lazyredraw|lbr|lcs|linebreak|lines|linespace|lisp|lispwords|listchars|loadplugins|lpl|lsp|lz|macatsui|magic|makeef|makeprg|matchpairs|matchtime|maxcombine|maxfuncdepth|maxmapdepth|maxmem|maxmempattern|maxmemtot|mco|mef|menuitems|mfd|mh|mis|mkspellmem|ml|mls|mm|mmd|mmp|mmt|modeline|modelines|modifiable|modified|more|mouse|mousef|mousefocus|mousehide|mousem|mousemodel|mouses|mouseshape|mouset|mousetime|mp|mps|msm|mzq|mzquantum|nf|noacd|noai|noakm|noallowrevins|noaltkeymap|noanti|noantialias|noar|noarab|noarabic|noarabicshape|noari|noarshape|noautochdir|noautoindent|noautoread|noautowrite|noautowriteall|noaw|noawa|nobackup|noballooneval|nobeval|nobin|nobinary|nobiosk|nobioskey|nobk|nobl|nobomb|nobuflisted|nocf|noci|nocin|nocindent|nocompatible|noconfirm|noconsk|noconskey|nocopyindent|nocp|nocscopetag|nocscopeverbose|nocst|nocsverb|nocuc|nocul|nocursorcolumn|nocursorline|nodeco|nodelcombine|nodg|nodiff|nodigraph|nodisable|noea|noeb|noed|noedcompatible|noek|noendofline|noeol|noequalalways|noerrorbells|noesckeys|noet|noex|noexpandtab|noexrc|nofen|nofk|nofkmap|nofoldenable|nogd|nogdefault|noguipty|nohid|nohidden|nohk|nohkmap|nohkmapp|nohkp|nohls|noic|noicon|noignorecase|noim|noimc|noimcmdline|noimd|noincsearch|noinf|noinfercase|noinsertmode|nois|nojoinspaces|nojs|nolazyredraw|nolbr|nolinebreak|nolisp|nolist|noloadplugins|nolpl|nolz|noma|nomacatsui|nomagic|nomh|noml|nomod|nomodeline|nomodifiable|nomodified|nomore|nomousef|nomousefocus|nomousehide|nonu|nonumber|noodev|noopendevice|nopaste|nopi|nopreserveindent|nopreviewwindow|noprompt|nopvw|noreadonly|noremap|norestorescreen|norevins|nori|norightleft|norightleftcmd|norl|norlc|noro|nors|noru|noruler|nosb|nosc|noscb|noscrollbind|noscs|nosecure|nosft|noshellslash|noshelltemp|noshiftround|noshortname|noshowcmd|noshowfulltag|noshowmatch|noshowmode|nosi|nosm|nosmartcase|nosmartindent|nosmarttab|nosmd|nosn|nosol|nospell|nosplitbelow|nosplitright|nospr|nosr|nossl|nosta|nostartofline|nostmp|noswapfile|noswf|nota|notagbsearch|notagrelative|notagstack|notbi|notbidi|notbs|notermbidi|noterse|notextauto|notextmode|notf|notgst|notildeop|notimeout|notitle|noto|notop|notr|nottimeout|nottybuiltin|nottyfast|notx|novb|novisualbell|nowa|nowarn|nowb|noweirdinvert|nowfh|nowfw|nowildmenu|nowinfixheight|nowinfixwidth|nowiv|nowmnu|nowrap|nowrapscan|nowrite|nowriteany|nowritebackup|nows|nrformats|numberwidth|nuw|odev|oft|ofu|omnifunc|opendevice|operatorfunc|opfunc|osfiletype|pa|para|paragraphs|paste|pastetoggle|patchexpr|patchmode|path|pdev|penc|pex|pexpr|pfn|ph|pheader|pi|pm|pmbcs|pmbfn|popt|preserveindent|previewheight|previewwindow|printdevice|printencoding|printexpr|printfont|printheader|printmbcharset|printmbfont|printoptions|prompt|pt|pumheight|pvh|pvw|qe|quoteescape|readonly|remap|report|restorescreen|revins|rightleft|rightleftcmd|rl|rlc|ro|rs|rtp|ruf|ruler|rulerformat|runtimepath|sbo|sc|scb|scr|scroll|scrollbind|scrolljump|scrolloff|scrollopt|scs|sect|sections|secure|sel|selection|selectmode|sessionoptions|sft|shcf|shellcmdflag|shellpipe|shellquote|shellredir|shellslash|shelltemp|shelltype|shellxquote|shiftround|shiftwidth|shm|shortmess|shortname|showbreak|showcmd|showfulltag|showmatch|showmode|showtabline|shq|si|sidescroll|sidescrolloff|siso|sj|slm|smartcase|smartindent|smarttab|smc|smd|softtabstop|sol|spc|spell|spellcapcheck|spellfile|spelllang|spellsuggest|spf|spl|splitbelow|splitright|sps|sr|srr|ss|ssl|ssop|stal|startofline|statusline|stl|stmp|su|sua|suffixes|suffixesadd|sw|swapfile|swapsync|swb|swf|switchbuf|sws|sxq|syn|synmaxcol|syntax|t_AB|t_AF|t_AL|t_CS|t_CV|t_Ce|t_Co|t_Cs|t_DL|t_EI|t_F1|t_F2|t_F3|t_F4|t_F5|t_F6|t_F7|t_F8|t_F9|t_IE|t_IS|t_K1|t_K3|t_K4|t_K5|t_K6|t_K7|t_K8|t_K9|t_KA|t_KB|t_KC|t_KD|t_KE|t_KF|t_KG|t_KH|t_KI|t_KJ|t_KK|t_KL|t_RI|t_RV|t_SI|t_Sb|t_Sf|t_WP|t_WS|t_ZH|t_ZR|t_al|t_bc|t_cd|t_ce|t_cl|t_cm|t_cs|t_da|t_db|t_dl|t_fs|t_k1|t_k2|t_k3|t_k4|t_k5|t_k6|t_k7|t_k8|t_k9|t_kB|t_kD|t_kI|t_kN|t_kP|t_kb|t_kd|t_ke|t_kh|t_kl|t_kr|t_ks|t_ku|t_le|t_mb|t_md|t_me|t_mr|t_ms|t_nd|t_op|t_se|t_so|t_sr|t_te|t_ti|t_ts|t_ue|t_us|t_ut|t_vb|t_ve|t_vi|t_vs|t_xs|tabline|tabpagemax|tabstop|tagbsearch|taglength|tagrelative|tagstack|tal|tb|tbi|tbidi|tbis|tbs|tenc|term|termbidi|termencoding|terse|textauto|textmode|textwidth|tgst|thesaurus|tildeop|timeout|timeoutlen|title|titlelen|titleold|titlestring|toolbar|toolbariconsize|top|tpm|tsl|tsr|ttimeout|ttimeoutlen|ttm|tty|ttybuiltin|ttyfast|ttym|ttymouse|ttyscroll|ttytype|tw|tx|uc|ul|undolevels|updatecount|updatetime|ut|vb|vbs|vdir|verbosefile|vfile|viewdir|viewoptions|viminfo|virtualedit|visualbell|vop|wak|warn|wb|wc|wcm|wd|weirdinvert|wfh|wfw|whichwrap|wi|wig|wildchar|wildcharm|wildignore|wildmenu|wildmode|wildoptions|wim|winaltkeys|window|winfixheight|winfixwidth|winheight|winminheight|winminwidth|winwidth|wiv|wiw|wm|wmh|wmnu|wmw|wop|wrap|wrapmargin|wrapscan|writeany|writebackup|writedelay|ww)\\b/,\n    number: /\\b(?:0x[\\da-f]+|\\d+(?:\\.\\d+)?)\\b/i,\n    operator:\n      /\\|\\||&&|[-+.]=?|[=!](?:[=~][#?]?)?|[<>]=?[#?]?|[*\\/%?]|\\b(?:is(?:not)?)\\b/,\n    punctuation: /[{}[\\](),;:]/\n  }\n}\n","// @ts-nocheck\nvisualBasic.displayName = 'visual-basic'\nvisualBasic.aliases = ['vb', 'vba']\n\n/** @type {import('../core.js').Syntax} */\nexport default function visualBasic(Prism) {\n  Prism.languages['visual-basic'] = {\n    comment: {\n      pattern: /(?:['‘’]|REM\\b)(?:[^\\r\\n_]|_(?:\\r\\n?|\\n)?)*/i,\n      inside: {\n        keyword: /^REM/i\n      }\n    },\n    directive: {\n      pattern:\n        /#(?:Const|Else|ElseIf|End|ExternalChecksum|ExternalSource|If|Region)(?:\\b_[ \\t]*(?:\\r\\n?|\\n)|.)+/i,\n      alias: 'property',\n      greedy: true\n    },\n    string: {\n      pattern: /\\$?[\"“”](?:[\"“”]{2}|[^\"“”])*[\"“”]C?/i,\n      greedy: true\n    },\n    date: {\n      pattern:\n        /#[ \\t]*(?:\\d+([/-])\\d+\\1\\d+(?:[ \\t]+(?:\\d+[ \\t]*(?:AM|PM)|\\d+:\\d+(?::\\d+)?(?:[ \\t]*(?:AM|PM))?))?|\\d+[ \\t]*(?:AM|PM)|\\d+:\\d+(?::\\d+)?(?:[ \\t]*(?:AM|PM))?)[ \\t]*#/i,\n      alias: 'number'\n    },\n    number:\n      /(?:(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)(?:E[+-]?\\d+)?|&[HO][\\dA-F]+)(?:[FRD]|U?[ILS])?/i,\n    boolean: /\\b(?:False|Nothing|True)\\b/i,\n    keyword:\n      /\\b(?:AddHandler|AddressOf|Alias|And(?:Also)?|As|Boolean|ByRef|Byte|ByVal|Call|Case|Catch|C(?:Bool|Byte|Char|Date|Dbl|Dec|Int|Lng|Obj|SByte|Short|Sng|Str|Type|UInt|ULng|UShort)|Char|Class|Const|Continue|Currency|Date|Decimal|Declare|Default|Delegate|Dim|DirectCast|Do|Double|Each|Else(?:If)?|End(?:If)?|Enum|Erase|Error|Event|Exit|Finally|For|Friend|Function|Get(?:Type|XMLNamespace)?|Global|GoSub|GoTo|Handles|If|Implements|Imports|In|Inherits|Integer|Interface|Is|IsNot|Let|Lib|Like|Long|Loop|Me|Mod|Module|Must(?:Inherit|Override)|My(?:Base|Class)|Namespace|Narrowing|New|Next|Not(?:Inheritable|Overridable)?|Object|Of|On|Operator|Option(?:al)?|Or(?:Else)?|Out|Overloads|Overridable|Overrides|ParamArray|Partial|Private|Property|Protected|Public|RaiseEvent|ReadOnly|ReDim|RemoveHandler|Resume|Return|SByte|Select|Set|Shadows|Shared|short|Single|Static|Step|Stop|String|Structure|Sub|SyncLock|Then|Throw|To|Try|TryCast|Type|TypeOf|U(?:Integer|Long|Short)|Until|Using|Variant|Wend|When|While|Widening|With(?:Events)?|WriteOnly|Xor)\\b/i,\n    operator: /[+\\-*/\\\\^<=>&#@$%!]|\\b_(?=[ \\t]*[\\r\\n])/,\n    punctuation: /[{}().,:?]/\n  }\n  Prism.languages.vb = Prism.languages['visual-basic']\n  Prism.languages.vba = Prism.languages['visual-basic']\n}\n","// @ts-nocheck\nwarpscript.displayName = 'warpscript'\nwarpscript.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function warpscript(Prism) {\n  Prism.languages.warpscript = {\n    comment: /#.*|\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n    string: {\n      pattern:\n        /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?:[^'\\\\\\r\\n]|\\\\.)*'|<'(?:[^\\\\']|'(?!>)|\\\\.)*'>/,\n      greedy: true\n    },\n    variable: /\\$\\S+/,\n    macro: {\n      pattern: /@\\S+/,\n      alias: 'property'\n    },\n    // WarpScript doesn't have any keywords, these are all functions under the control category\n    // https://www.warp10.io/tags/control\n    keyword:\n      /\\b(?:BREAK|CHECKMACRO|CONTINUE|CUDF|DEFINED|DEFINEDMACRO|EVAL|FAIL|FOR|FOREACH|FORSTEP|IFT|IFTE|MSGFAIL|NRETURN|RETHROW|RETURN|SWITCH|TRY|UDF|UNTIL|WHILE)\\b/,\n    number:\n      /[+-]?\\b(?:NaN|Infinity|\\d+(?:\\.\\d*)?(?:[Ee][+-]?\\d+)?|0x[\\da-fA-F]+|0b[01]+)\\b/,\n    boolean: /\\b(?:F|T|false|true)\\b/,\n    punctuation: /<%|%>|[{}[\\]()]/,\n    // Some operators from the \"operators\" category\n    // https://www.warp10.io/tags/operators\n    operator:\n      /==|&&?|\\|\\|?|\\*\\*?|>>>?|<<|[<>!~]=?|[-/%^]|\\+!?|\\b(?:AND|NOT|OR)\\b/\n  }\n}\n","// @ts-nocheck\nwasm.displayName = 'wasm'\nwasm.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function wasm(Prism) {\n  Prism.languages.wasm = {\n    comment: [\n      /\\(;[\\s\\S]*?;\\)/,\n      {\n        pattern: /;;.*/,\n        greedy: true\n      }\n    ],\n    string: {\n      pattern: /\"(?:\\\\[\\s\\S]|[^\"\\\\])*\"/,\n      greedy: true\n    },\n    keyword: [\n      {\n        pattern: /\\b(?:align|offset)=/,\n        inside: {\n          operator: /=/\n        }\n      },\n      {\n        pattern:\n          /\\b(?:(?:f32|f64|i32|i64)(?:\\.(?:abs|add|and|ceil|clz|const|convert_[su]\\/i(?:32|64)|copysign|ctz|demote\\/f64|div(?:_[su])?|eqz?|extend_[su]\\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|neg?|nearest|or|popcnt|promote\\/f32|reinterpret\\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|sqrt|store(?:8|16|32)?|sub|trunc(?:_[su]\\/f(?:32|64))?|wrap\\/i64|xor))?|memory\\.(?:grow|size))\\b/,\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      /\\b(?:anyfunc|block|br(?:_if|_table)?|call(?:_indirect)?|data|drop|elem|else|end|export|func|get_(?:global|local)|global|if|import|local|loop|memory|module|mut|nop|offset|param|result|return|select|set_(?:global|local)|start|table|tee_local|then|type|unreachable)\\b/\n    ],\n    variable: /\\$[\\w!#$%&'*+\\-./:<=>?@\\\\^`|~]+/,\n    number:\n      /[+-]?\\b(?:\\d(?:_?\\d)*(?:\\.\\d(?:_?\\d)*)?(?:[eE][+-]?\\d(?:_?\\d)*)?|0x[\\da-fA-F](?:_?[\\da-fA-F])*(?:\\.[\\da-fA-F](?:_?[\\da-fA-D])*)?(?:[pP][+-]?\\d(?:_?\\d)*)?)\\b|\\binf\\b|\\bnan(?::0x[\\da-fA-F](?:_?[\\da-fA-D])*)?\\b/,\n    punctuation: /[()]/\n  }\n}\n","// @ts-nocheck\nwebIdl.displayName = 'web-idl'\nwebIdl.aliases = ['webidl']\n\n/** @type {import('../core.js').Syntax} */\nexport default function webIdl(Prism) {\n  ;(function (Prism) {\n    var id = /(?:\\B-|\\b_|\\b)[A-Za-z][\\w-]*(?![\\w-])/.source\n    var type =\n      '(?:' +\n      /\\b(?:unsigned\\s+)?long\\s+long(?![\\w-])/.source +\n      '|' +\n      /\\b(?:unrestricted|unsigned)\\s+[a-z]+(?![\\w-])/.source +\n      '|' +\n      /(?!(?:unrestricted|unsigned)\\b)/.source +\n      id +\n      /(?:\\s*<(?:[^<>]|<[^<>]*>)*>)?/.source +\n      ')' +\n      /(?:\\s*\\?)?/.source\n    var typeInside = {}\n    Prism.languages['web-idl'] = {\n      comment: {\n        pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n        greedy: true\n      },\n      string: {\n        pattern: /\"[^\"]*\"/,\n        greedy: true\n      },\n      namespace: {\n        pattern: RegExp(/(\\bnamespace\\s+)/.source + id),\n        lookbehind: true\n      },\n      'class-name': [\n        {\n          pattern:\n            /(^|[^\\w-])(?:iterable|maplike|setlike)\\s*<(?:[^<>]|<[^<>]*>)*>/,\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          pattern: RegExp(\n            /(\\b(?:attribute|const|deleter|getter|optional|setter)\\s+)/.source +\n              type\n          ),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // callback return type\n          pattern: RegExp(\n            '(' + /\\bcallback\\s+/.source + id + /\\s*=\\s*/.source + ')' + type\n          ),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // typedef\n          pattern: RegExp(/(\\btypedef\\b\\s*)/.source + type),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          pattern: RegExp(\n            /(\\b(?:callback|dictionary|enum|interface(?:\\s+mixin)?)\\s+)(?!(?:interface|mixin)\\b)/\n              .source + id\n          ),\n          lookbehind: true\n        },\n        {\n          // inheritance\n          pattern: RegExp(/(:\\s*)/.source + id),\n          lookbehind: true\n        },\n        // includes and implements\n        RegExp(id + /(?=\\s+(?:implements|includes)\\b)/.source),\n        {\n          pattern: RegExp(/(\\b(?:implements|includes)\\s+)/.source + id),\n          lookbehind: true\n        },\n        {\n          // function return type, parameter types, and dictionary members\n          pattern: RegExp(\n            type +\n              '(?=' +\n              /\\s*(?:\\.{3}\\s*)?/.source +\n              id +\n              /\\s*[(),;=]/.source +\n              ')'\n          ),\n          inside: typeInside\n        }\n      ],\n      builtin:\n        /\\b(?:ArrayBuffer|BigInt64Array|BigUint64Array|ByteString|DOMString|DataView|Float32Array|Float64Array|FrozenArray|Int16Array|Int32Array|Int8Array|ObservableArray|Promise|USVString|Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray)\\b/,\n      keyword: [\n        /\\b(?:async|attribute|callback|const|constructor|deleter|dictionary|enum|getter|implements|includes|inherit|interface|mixin|namespace|null|optional|or|partial|readonly|required|setter|static|stringifier|typedef|unrestricted)\\b/,\n        // type keywords\n        /\\b(?:any|bigint|boolean|byte|double|float|iterable|long|maplike|object|octet|record|sequence|setlike|short|symbol|undefined|unsigned|void)\\b/\n      ],\n      boolean: /\\b(?:false|true)\\b/,\n      number: {\n        pattern:\n          /(^|[^\\w-])-?(?:0x[0-9a-f]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|NaN|Infinity)(?![\\w-])/i,\n        lookbehind: true\n      },\n      operator: /\\.{3}|[=:?<>-]/,\n      punctuation: /[(){}[\\].,;]/\n    }\n    for (var key in Prism.languages['web-idl']) {\n      if (key !== 'class-name') {\n        typeInside[key] = Prism.languages['web-idl'][key]\n      }\n    }\n    Prism.languages['webidl'] = Prism.languages['web-idl']\n  })(Prism)\n}\n","// @ts-nocheck\nwgsl.displayName = 'wgsl'\nwgsl.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function wgsl(Prism) {\n  Prism.languages.wgsl = {\n    comment: {\n      pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n      greedy: true\n    },\n    'builtin-attribute': {\n      pattern: /(@)builtin\\(.*?\\)/,\n      lookbehind: true,\n      inside: {\n        attribute: {\n          pattern: /^builtin/,\n          alias: 'attr-name'\n        },\n        punctuation: /[(),]/,\n        'built-in-values': {\n          pattern:\n            /\\b(?:frag_depth|front_facing|global_invocation_id|instance_index|local_invocation_id|local_invocation_index|num_workgroups|position|sample_index|sample_mask|vertex_index|workgroup_id)\\b/,\n          alias: 'attr-value'\n        }\n      }\n    },\n    attributes: {\n      pattern:\n        /(@)(?:align|binding|compute|const|fragment|group|id|interpolate|invariant|location|size|vertex|workgroup_size)/i,\n      lookbehind: true,\n      alias: 'attr-name'\n    },\n    functions: {\n      pattern: /\\b(fn\\s+)[_a-zA-Z]\\w*(?=[(<])/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    keyword:\n      /\\b(?:bitcast|break|case|const|continue|continuing|default|discard|else|enable|fallthrough|fn|for|function|if|let|loop|private|return|storage|struct|switch|type|uniform|var|while|workgroup)\\b/,\n    builtin:\n      /\\b(?:abs|acos|acosh|all|any|array|asin|asinh|atan|atan2|atanh|atomic|atomicAdd|atomicAnd|atomicCompareExchangeWeak|atomicExchange|atomicLoad|atomicMax|atomicMin|atomicOr|atomicStore|atomicSub|atomicXor|bool|ceil|clamp|cos|cosh|countLeadingZeros|countOneBits|countTrailingZeros|cross|degrees|determinant|distance|dot|dpdx|dpdxCoarse|dpdxFine|dpdy|dpdyCoarse|dpdyFine|exp|exp2|extractBits|f32|f64|faceForward|firstLeadingBit|floor|fma|fract|frexp|fwidth|fwidthCoarse|fwidthFine|i32|i64|insertBits|inverseSqrt|ldexp|length|log|log2|mat[2-4]x[2-4]|max|min|mix|modf|normalize|override|pack2x16float|pack2x16snorm|pack2x16unorm|pack4x8snorm|pack4x8unorm|pow|ptr|quantizeToF16|radians|reflect|refract|reverseBits|round|sampler|sampler_comparison|select|shiftLeft|shiftRight|sign|sin|sinh|smoothstep|sqrt|staticAssert|step|storageBarrier|tan|tanh|textureDimensions|textureGather|textureGatherCompare|textureLoad|textureNumLayers|textureNumLevels|textureNumSamples|textureSample|textureSampleBias|textureSampleCompare|textureSampleCompareLevel|textureSampleGrad|textureSampleLevel|textureStore|texture_1d|texture_2d|texture_2d_array|texture_3d|texture_cube|texture_cube_array|texture_depth_2d|texture_depth_2d_array|texture_depth_cube|texture_depth_cube_array|texture_depth_multisampled_2d|texture_multisampled_2d|texture_storage_1d|texture_storage_2d|texture_storage_2d_array|texture_storage_3d|transpose|trunc|u32|u64|unpack2x16float|unpack2x16snorm|unpack2x16unorm|unpack4x8snorm|unpack4x8unorm|vec[2-4]|workgroupBarrier)\\b/,\n    'function-calls': {\n      pattern: /\\b[_a-z]\\w*(?=\\()/i,\n      alias: 'function'\n    },\n    'class-name': /\\b(?:[A-Z][A-Za-z0-9]*)\\b/,\n    'bool-literal': {\n      pattern: /\\b(?:false|true)\\b/,\n      alias: 'boolean'\n    },\n    'hex-int-literal': {\n      pattern: /\\b0[xX][0-9a-fA-F]+[iu]?\\b(?![.pP])/,\n      alias: 'number'\n    },\n    'hex-float-literal': {\n      pattern: /\\b0[xX][0-9a-fA-F]*(?:\\.[0-9a-fA-F]*)?(?:[pP][+-]?\\d+[fh]?)?/,\n      alias: 'number'\n    },\n    'decimal-float-literal': [\n      {\n        pattern: /\\d*\\.\\d+(?:[eE](?:\\+|-)?\\d+)?[fh]?/,\n        alias: 'number'\n      },\n      {\n        pattern: /\\d+\\.\\d*(?:[eE](?:\\+|-)?\\d+)?[fh]?/,\n        alias: 'number'\n      },\n      {\n        pattern: /\\d+[eE](?:\\+|-)?\\d+[fh]?/,\n        alias: 'number'\n      },\n      {\n        pattern: /\\b\\d+[fh]\\b/,\n        alias: 'number'\n      }\n    ],\n    'int-literal': {\n      pattern: /\\b\\d+[iu]?\\b/,\n      alias: 'number'\n    },\n    operator: [\n      {\n        pattern: /(?:\\^|~|\\|(?!\\|)|\\|\\||&&|<<|>>|!)(?!=)/\n      },\n      {\n        pattern: /&(?![&=])/\n      },\n      {\n        pattern: /(?:\\+=|-=|\\*=|\\/=|%=|\\^=|&=|\\|=|<<=|>>=)/\n      },\n      {\n        pattern: /(^|[^<>=!])=(?![=>])/,\n        lookbehind: true\n      },\n      {\n        pattern: /(?:==|!=|<=|\\+\\+|--|(^|[^=])>=)/,\n        lookbehind: true\n      },\n      {\n        pattern: /(?:(?:[+%]|(?:\\*(?!\\w)))(?!=))|(?:-(?!>))|(?:\\/(?!\\/))/\n      },\n      {\n        pattern: /->/\n      }\n    ],\n    punctuation: /[@(){}[\\],;<>:.]/\n  }\n}\n","// @ts-nocheck\nimport refractorMarkup from './markup.js'\nwiki.displayName = 'wiki'\nwiki.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function wiki(Prism) {\n  Prism.register(refractorMarkup)\n  Prism.languages.wiki = Prism.languages.extend('markup', {\n    'block-comment': {\n      pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?\\*\\//,\n      lookbehind: true,\n      alias: 'comment'\n    },\n    heading: {\n      pattern: /^(=+)[^=\\r\\n].*?\\1/m,\n      inside: {\n        punctuation: /^=+|=+$/,\n        important: /.+/\n      }\n    },\n    emphasis: {\n      // TODO Multi-line\n      pattern: /('{2,5}).+?\\1/,\n      inside: {\n        'bold-italic': {\n          pattern: /(''''').+?(?=\\1)/,\n          lookbehind: true,\n          alias: ['bold', 'italic']\n        },\n        bold: {\n          pattern: /(''')[^'](?:.*?[^'])?(?=\\1)/,\n          lookbehind: true\n        },\n        italic: {\n          pattern: /('')[^'](?:.*?[^'])?(?=\\1)/,\n          lookbehind: true\n        },\n        punctuation: /^''+|''+$/\n      }\n    },\n    hr: {\n      pattern: /^-{4,}/m,\n      alias: 'punctuation'\n    },\n    url: [\n      /ISBN +(?:97[89][ -]?)?(?:\\d[ -]?){9}[\\dx]\\b|(?:PMID|RFC) +\\d+/i,\n      /\\[\\[.+?\\]\\]|\\[.+?\\]/\n    ],\n    variable: [\n      /__[A-Z]+__/,\n      // FIXME Nested structures should be handled\n      // {{formatnum:{{#expr:{{{3}}}}}}}\n      /\\{{3}.+?\\}{3}/,\n      /\\{\\{.+?\\}\\}/\n    ],\n    symbol: [/^#redirect/im, /~{3,5}/],\n    // Handle table attrs:\n    // {|\n    // ! style=\"text-align:left;\"| Item\n    // |}\n    'table-tag': {\n      pattern: /((?:^|[|!])[|!])[^|\\r\\n]+\\|(?!\\|)/m,\n      lookbehind: true,\n      inside: {\n        'table-bar': {\n          pattern: /\\|$/,\n          alias: 'punctuation'\n        },\n        rest: Prism.languages.markup['tag'].inside\n      }\n    },\n    punctuation: /^(?:\\{\\||\\|\\}|\\|-|[*#:;!|])|\\|\\||!!/m\n  })\n  Prism.languages.insertBefore('wiki', 'tag', {\n    // Prevent highlighting inside <nowiki>, <source> and <pre> tags\n    nowiki: {\n      pattern: /<(nowiki|pre|source)\\b[^>]*>[\\s\\S]*?<\\/\\1>/i,\n      inside: {\n        tag: {\n          pattern: /<(?:nowiki|pre|source)\\b[^>]*>|<\\/(?:nowiki|pre|source)>/i,\n          inside: Prism.languages.markup['tag'].inside\n        }\n      }\n    }\n  })\n}\n","// @ts-nocheck\nwolfram.displayName = 'wolfram'\nwolfram.aliases = ['mathematica', 'nb', 'wl']\n\n/** @type {import('../core.js').Syntax} */\nexport default function wolfram(Prism) {\n  Prism.languages.wolfram = {\n    comment:\n      // Allow one level of nesting - note: regex taken from applescipt\n      /\\(\\*(?:\\(\\*(?:[^*]|\\*(?!\\)))*\\*\\)|(?!\\(\\*)[\\s\\S])*?\\*\\)/,\n    string: {\n      pattern: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:Abs|AbsArg|Accuracy|Block|Do|For|Function|If|Manipulate|Module|Nest|NestList|None|Return|Switch|Table|Which|While)\\b/,\n    context: {\n      pattern: /\\b\\w+`+\\w*/,\n      alias: 'class-name'\n    },\n    blank: {\n      pattern: /\\b\\w+_\\b/,\n      alias: 'regex'\n    },\n    'global-variable': {\n      pattern: /\\$\\w+/,\n      alias: 'variable'\n    },\n    boolean: /\\b(?:False|True)\\b/,\n    number:\n      /(?:\\b(?=\\d)|\\B(?=\\.))(?:0[bo])?(?:(?:\\d|0x[\\da-f])[\\da-f]*(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?j?\\b/i,\n    operator:\n      /\\/\\.|;|=\\.|\\^=|\\^:=|:=|<<|>>|<\\||\\|>|:>|\\|->|->|<-|@@@|@@|@|\\/@|=!=|===|==|=|\\+|-|\\[\\/-+%=\\]=?|!=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]/,\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.mathematica = Prism.languages.wolfram\n  Prism.languages.wl = Prism.languages.wolfram\n  Prism.languages.nb = Prism.languages.wolfram\n}\n","// @ts-nocheck\nwren.displayName = 'wren'\nwren.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function wren(Prism) {\n  // https://wren.io/\n\n  Prism.languages.wren = {\n    // Multiline comments in Wren can have nested multiline comments\n    // Comments: // and /* */\n    comment: [\n      {\n        // support 3 levels of nesting\n        // regex: \\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|<self>)*\\*\\/\n        pattern:\n          /\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*))*\\*\\/)*\\*\\/)*\\*\\//,\n        greedy: true\n      },\n      {\n        pattern: /(^|[^\\\\:])\\/\\/.*/,\n        lookbehind: true,\n        greedy: true\n      }\n    ],\n    // Triple quoted strings are multiline but cannot have interpolation (raw strings)\n    // Based on prism-python.js\n    'triple-quoted-string': {\n      pattern: /\"\"\"[\\s\\S]*?\"\"\"/,\n      greedy: true,\n      alias: 'string'\n    },\n    // see below\n    'string-literal': null,\n    // #!/usr/bin/env wren on the first line\n    hashbang: {\n      pattern: /^#!\\/.+/,\n      greedy: true,\n      alias: 'comment'\n    },\n    // Attributes are special keywords to add meta data to classes\n    attribute: {\n      // #! attributes are stored in class properties\n      // #!myvar = true\n      // #attributes are not stored and dismissed at compilation\n      pattern: /#!?[ \\t\\u3000]*\\w+/,\n      alias: 'keyword'\n    },\n    'class-name': [\n      {\n        // class definition\n        // class Meta {}\n        pattern: /(\\bclass\\s+)\\w+/,\n        lookbehind: true\n      },\n      // A class must always start with an uppercase.\n      // File.read\n      /\\b[A-Z][a-z\\d_]*\\b/\n    ],\n    // A constant can be a variable, class, property or method. Just named in all uppercase letters\n    constant: /\\b[A-Z][A-Z\\d_]*\\b/,\n    null: {\n      pattern: /\\bnull\\b/,\n      alias: 'keyword'\n    },\n    keyword:\n      /\\b(?:as|break|class|construct|continue|else|for|foreign|if|import|in|is|return|static|super|this|var|while)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    number: /\\b(?:0x[\\da-f]+|\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?)\\b/i,\n    // Functions can be Class.method()\n    function: /\\b[a-z_]\\w*(?=\\s*[({])/i,\n    operator: /<<|>>|[=!<>]=?|&&|\\|\\||[-+*/%~^&|?:]|\\.{2,3}/,\n    punctuation: /[\\[\\](){}.,;]/\n  }\n  Prism.languages.wren['string-literal'] = {\n    // A single quote string is multiline and can have interpolation (similar to JS backticks ``)\n    pattern:\n      /(^|[^\\\\\"])\"(?:[^\\\\\"%]|\\\\[\\s\\S]|%(?!\\()|%\\((?:[^()]|\\((?:[^()]|\\([^)]*\\))*\\))*\\))*\"/,\n    lookbehind: true,\n    greedy: true,\n    inside: {\n      interpolation: {\n        // \"%(interpolation)\"\n        pattern:\n          /((?:^|[^\\\\])(?:\\\\{2})*)%\\((?:[^()]|\\((?:[^()]|\\([^)]*\\))*\\))*\\)/,\n        lookbehind: true,\n        inside: {\n          expression: {\n            pattern: /^(%\\()[\\s\\S]+(?=\\)$)/,\n            lookbehind: true,\n            inside: Prism.languages.wren\n          },\n          'interpolation-punctuation': {\n            pattern: /^%\\(|\\)$/,\n            alias: 'punctuation'\n          }\n        }\n      },\n      string: /[\\s\\S]+/\n    }\n  }\n}\n","// @ts-nocheck\nimport refractorMarkup from './markup.js'\nxeora.displayName = 'xeora'\nxeora.aliases = ['xeoracube']\n\n/** @type {import('../core.js').Syntax} */\nexport default function xeora(Prism) {\n  Prism.register(refractorMarkup)\n  ;(function (Prism) {\n    Prism.languages.xeora = Prism.languages.extend('markup', {\n      constant: {\n        pattern: /\\$(?:DomainContents|PageRenderDuration)\\$/,\n        inside: {\n          punctuation: {\n            pattern: /\\$/\n          }\n        }\n      },\n      variable: {\n        pattern: /\\$@?(?:#+|[-+*~=^])?[\\w.]+\\$/,\n        inside: {\n          punctuation: {\n            pattern: /[$.]/\n          },\n          operator: {\n            pattern: /#+|[-+*~=^@]/\n          }\n        }\n      },\n      'function-inline': {\n        pattern:\n          /\\$F:[-\\w.]+\\?[-\\w.]+(?:,(?:(?:@[-#]*\\w+\\.[\\w+.]\\.*)*\\|)*(?:(?:[\\w+]|[-#*.~^]+[\\w+]|=\\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\\w+\\.[\\w+.]\\.*)+(?:(?:[\\w+]|[-#*~^][-#*.~^]*[\\w+]|=\\S)(?:[^$=]|=+[^=])*=*)?)?)?\\$/,\n        inside: {\n          variable: {\n            pattern: /(?:[,|])@?(?:#+|[-+*~=^])?[\\w.]+/,\n            inside: {\n              punctuation: {\n                pattern: /[,.|]/\n              },\n              operator: {\n                pattern: /#+|[-+*~=^@]/\n              }\n            }\n          },\n          punctuation: {\n            pattern: /\\$\\w:|[$:?.,|]/\n          }\n        },\n        alias: 'function'\n      },\n      'function-block': {\n        pattern:\n          /\\$XF:\\{[-\\w.]+\\?[-\\w.]+(?:,(?:(?:@[-#]*\\w+\\.[\\w+.]\\.*)*\\|)*(?:(?:[\\w+]|[-#*.~^]+[\\w+]|=\\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\\w+\\.[\\w+.]\\.*)+(?:(?:[\\w+]|[-#*~^][-#*.~^]*[\\w+]|=\\S)(?:[^$=]|=+[^=])*=*)?)?)?\\}:XF\\$/,\n        inside: {\n          punctuation: {\n            pattern: /[$:{}?.,|]/\n          }\n        },\n        alias: 'function'\n      },\n      'directive-inline': {\n        pattern: /\\$\\w(?:#\\d+\\+?)?(?:\\[[-\\w.]+\\])?:[-\\/\\w.]+\\$/,\n        inside: {\n          punctuation: {\n            pattern: /\\$(?:\\w:|C(?:\\[|#\\d))?|[:{[\\]]/,\n            inside: {\n              tag: {\n                pattern: /#\\d/\n              }\n            }\n          }\n        },\n        alias: 'function'\n      },\n      'directive-block-open': {\n        pattern:\n          /\\$\\w+:\\{|\\$\\w(?:#\\d+\\+?)?(?:\\[[-\\w.]+\\])?:[-\\w.]+:\\{(?:![A-Z]+)?/,\n        inside: {\n          punctuation: {\n            pattern: /\\$(?:\\w:|C(?:\\[|#\\d))?|[:{[\\]]/,\n            inside: {\n              tag: {\n                pattern: /#\\d/\n              }\n            }\n          },\n          attribute: {\n            pattern: /![A-Z]+$/,\n            inside: {\n              punctuation: {\n                pattern: /!/\n              }\n            },\n            alias: 'keyword'\n          }\n        },\n        alias: 'function'\n      },\n      'directive-block-separator': {\n        pattern: /\\}:[-\\w.]+:\\{/,\n        inside: {\n          punctuation: {\n            pattern: /[:{}]/\n          }\n        },\n        alias: 'function'\n      },\n      'directive-block-close': {\n        pattern: /\\}:[-\\w.]+\\$/,\n        inside: {\n          punctuation: {\n            pattern: /[:{}$]/\n          }\n        },\n        alias: 'function'\n      }\n    })\n    Prism.languages.insertBefore(\n      'inside',\n      'punctuation',\n      {\n        variable: Prism.languages.xeora['function-inline'].inside['variable']\n      },\n      Prism.languages.xeora['function-block']\n    )\n    Prism.languages.xeoracube = Prism.languages.xeora\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorMarkup from './markup.js'\nxmlDoc.displayName = 'xml-doc'\nxmlDoc.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function xmlDoc(Prism) {\n  Prism.register(refractorMarkup)\n  ;(function (Prism) {\n    /**\n     * If the given language is present, it will insert the given doc comment grammar token into it.\n     *\n     * @param {string} lang\n     * @param {any} docComment\n     */\n    function insertDocComment(lang, docComment) {\n      if (Prism.languages[lang]) {\n        Prism.languages.insertBefore(lang, 'comment', {\n          'doc-comment': docComment\n        })\n      }\n    }\n    var tag = Prism.languages.markup.tag\n    var slashDocComment = {\n      pattern: /\\/\\/\\/.*/,\n      greedy: true,\n      alias: 'comment',\n      inside: {\n        tag: tag\n      }\n    }\n    var tickDocComment = {\n      pattern: /'''.*/,\n      greedy: true,\n      alias: 'comment',\n      inside: {\n        tag: tag\n      }\n    }\n    insertDocComment('csharp', slashDocComment)\n    insertDocComment('fsharp', slashDocComment)\n    insertDocComment('vbnet', tickDocComment)\n  })(Prism)\n}\n","// @ts-nocheck\nxojo.displayName = 'xojo'\nxojo.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function xojo(Prism) {\n  Prism.languages.xojo = {\n    comment: {\n      pattern: /(?:'|\\/\\/|Rem\\b).+/i,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:\"\"|[^\"])*\"/,\n      greedy: true\n    },\n    number: [/(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:E[+-]?\\d+)?/i, /&[bchou][a-z\\d]+/i],\n    directive: {\n      pattern: /#(?:Else|ElseIf|Endif|If|Pragma)\\b/i,\n      alias: 'property'\n    },\n    keyword:\n      /\\b(?:AddHandler|App|Array|As(?:signs)?|Auto|Boolean|Break|By(?:Ref|Val)|Byte|Call|Case|Catch|CFStringRef|CGFloat|Class|Color|Const|Continue|CString|Currency|CurrentMethodName|Declare|Delegate|Dim|Do(?:uble|wnTo)?|Each|Else(?:If)?|End|Enumeration|Event|Exception|Exit|Extends|False|Finally|For|Function|Get|GetTypeInfo|Global|GOTO|If|Implements|In|Inherits|Int(?:8|16|32|64|eger|erface)?|Lib|Loop|Me|Module|Next|Nil|Object|Optional|OSType|ParamArray|Private|Property|Protected|PString|Ptr|Raise(?:Event)?|ReDim|RemoveHandler|Return|Select(?:or)?|Self|Set|Shared|Short|Single|Soft|Static|Step|String|Sub|Super|Text|Then|To|True|Try|Ubound|UInt(?:8|16|32|64|eger)?|Until|Using|Var(?:iant)?|Wend|While|WindowPtr|WString)\\b/i,\n    operator:\n      /<[=>]?|>=?|[+\\-*\\/\\\\^=]|\\b(?:AddressOf|And|Ctype|IsA?|Mod|New|Not|Or|WeakAddressOf|Xor)\\b/i,\n    punctuation: /[.,;:()]/\n  }\n}\n","// @ts-nocheck\nimport refractorMarkup from './markup.js'\nxquery.displayName = 'xquery'\nxquery.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function xquery(Prism) {\n  Prism.register(refractorMarkup)\n  ;(function (Prism) {\n    Prism.languages.xquery = Prism.languages.extend('markup', {\n      'xquery-comment': {\n        pattern: /\\(:[\\s\\S]*?:\\)/,\n        greedy: true,\n        alias: 'comment'\n      },\n      string: {\n        pattern: /([\"'])(?:\\1\\1|(?!\\1)[\\s\\S])*\\1/,\n        greedy: true\n      },\n      extension: {\n        pattern: /\\(#.+?#\\)/,\n        alias: 'symbol'\n      },\n      variable: /\\$[-\\w:]+/,\n      axis: {\n        pattern:\n          /(^|[^-])(?:ancestor(?:-or-self)?|attribute|child|descendant(?:-or-self)?|following(?:-sibling)?|parent|preceding(?:-sibling)?|self)(?=::)/,\n        lookbehind: true,\n        alias: 'operator'\n      },\n      'keyword-operator': {\n        pattern:\n          /(^|[^:-])\\b(?:and|castable as|div|eq|except|ge|gt|idiv|instance of|intersect|is|le|lt|mod|ne|or|union)\\b(?=$|[^:-])/,\n        lookbehind: true,\n        alias: 'operator'\n      },\n      keyword: {\n        pattern:\n          /(^|[^:-])\\b(?:as|ascending|at|base-uri|boundary-space|case|cast as|collation|construction|copy-namespaces|declare|default|descending|else|empty (?:greatest|least)|encoding|every|external|for|function|if|import|in|inherit|lax|let|map|module|namespace|no-inherit|no-preserve|option|order(?: by|ed|ing)?|preserve|return|satisfies|schema|some|stable|strict|strip|then|to|treat as|typeswitch|unordered|validate|variable|version|where|xquery)\\b(?=$|[^:-])/,\n        lookbehind: true\n      },\n      function: /[\\w-]+(?::[\\w-]+)*(?=\\s*\\()/,\n      'xquery-element': {\n        pattern: /(element\\s+)[\\w-]+(?::[\\w-]+)*/,\n        lookbehind: true,\n        alias: 'tag'\n      },\n      'xquery-attribute': {\n        pattern: /(attribute\\s+)[\\w-]+(?::[\\w-]+)*/,\n        lookbehind: true,\n        alias: 'attr-name'\n      },\n      builtin: {\n        pattern:\n          /(^|[^:-])\\b(?:attribute|comment|document|element|processing-instruction|text|xs:(?:ENTITIES|ENTITY|ID|IDREFS?|NCName|NMTOKENS?|NOTATION|Name|QName|anyAtomicType|anyType|anyURI|base64Binary|boolean|byte|date|dateTime|dayTimeDuration|decimal|double|duration|float|gDay|gMonth|gMonthDay|gYear|gYearMonth|hexBinary|int|integer|language|long|negativeInteger|nonNegativeInteger|nonPositiveInteger|normalizedString|positiveInteger|short|string|time|token|unsigned(?:Byte|Int|Long|Short)|untyped(?:Atomic)?|yearMonthDuration))\\b(?=$|[^:-])/,\n        lookbehind: true\n      },\n      number: /\\b\\d+(?:\\.\\d+)?(?:E[+-]?\\d+)?/,\n      operator: [\n        /[+*=?|@]|\\.\\.?|:=|!=|<[=<]?|>[=>]?/,\n        {\n          pattern: /(\\s)-(?=\\s)/,\n          lookbehind: true\n        }\n      ],\n      punctuation: /[[\\](){},;:/]/\n    })\n    Prism.languages.xquery.tag.pattern =\n      /<\\/?(?!\\d)[^\\s>\\/=$<%]+(?:\\s+[^\\s>\\/=]+(?:=(?:(\"|')(?:\\\\[\\s\\S]|\\{(?!\\{)(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])+\\}|(?!\\1)[^\\\\])*\\1|[^\\s'\">=]+))?)*\\s*\\/?>/\n    Prism.languages.xquery['tag'].inside['attr-value'].pattern =\n      /=(?:(\"|')(?:\\\\[\\s\\S]|\\{(?!\\{)(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])+\\}|(?!\\1)[^\\\\])*\\1|[^\\s'\">=]+)/\n    Prism.languages.xquery['tag'].inside['attr-value'].inside['punctuation'] =\n      /^=\"|\"$/\n    Prism.languages.xquery['tag'].inside['attr-value'].inside['expression'] = {\n      // Allow for two levels of nesting\n      pattern: /\\{(?!\\{)(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])+\\}/,\n      inside: Prism.languages.xquery,\n      alias: 'language-xquery'\n    }\n\n    // The following will handle plain text inside tags\n    var stringifyToken = function (token) {\n      if (typeof token === 'string') {\n        return token\n      }\n      if (typeof token.content === 'string') {\n        return token.content\n      }\n      return token.content.map(stringifyToken).join('')\n    }\n    var walkTokens = function (tokens) {\n      var openedTags = []\n      for (var i = 0; i < tokens.length; i++) {\n        var token = tokens[i]\n        var notTagNorBrace = false\n        if (typeof token !== 'string') {\n          if (\n            token.type === 'tag' &&\n            token.content[0] &&\n            token.content[0].type === 'tag'\n          ) {\n            // We found a tag, now find its kind\n\n            if (token.content[0].content[0].content === '</') {\n              // Closing tag\n              if (\n                openedTags.length > 0 &&\n                openedTags[openedTags.length - 1].tagName ===\n                  stringifyToken(token.content[0].content[1])\n              ) {\n                // Pop matching opening tag\n                openedTags.pop()\n              }\n            } else {\n              if (token.content[token.content.length - 1].content === '/>') {\n                // Autoclosed tag, ignore\n              } else {\n                // Opening tag\n                openedTags.push({\n                  tagName: stringifyToken(token.content[0].content[1]),\n                  openedBraces: 0\n                })\n              }\n            }\n          } else if (\n            openedTags.length > 0 &&\n            token.type === 'punctuation' &&\n            token.content === '{' &&\n            // Ignore `{{`\n            (!tokens[i + 1] ||\n              tokens[i + 1].type !== 'punctuation' ||\n              tokens[i + 1].content !== '{') &&\n            (!tokens[i - 1] ||\n              tokens[i - 1].type !== 'plain-text' ||\n              tokens[i - 1].content !== '{')\n          ) {\n            // Here we might have entered an XQuery expression inside a tag\n            openedTags[openedTags.length - 1].openedBraces++\n          } else if (\n            openedTags.length > 0 &&\n            openedTags[openedTags.length - 1].openedBraces > 0 &&\n            token.type === 'punctuation' &&\n            token.content === '}'\n          ) {\n            // Here we might have left an XQuery expression inside a tag\n            openedTags[openedTags.length - 1].openedBraces--\n          } else if (token.type !== 'comment') {\n            notTagNorBrace = true\n          }\n        }\n        if (notTagNorBrace || typeof token === 'string') {\n          if (\n            openedTags.length > 0 &&\n            openedTags[openedTags.length - 1].openedBraces === 0\n          ) {\n            // Here we are inside a tag, and not inside an XQuery expression.\n            // That's plain text: drop any tokens matched.\n            var plainText = stringifyToken(token)\n\n            // And merge text with adjacent text\n            if (\n              i < tokens.length - 1 &&\n              (typeof tokens[i + 1] === 'string' ||\n                tokens[i + 1].type === 'plain-text')\n            ) {\n              plainText += stringifyToken(tokens[i + 1])\n              tokens.splice(i + 1, 1)\n            }\n            if (\n              i > 0 &&\n              (typeof tokens[i - 1] === 'string' ||\n                tokens[i - 1].type === 'plain-text')\n            ) {\n              plainText = stringifyToken(tokens[i - 1]) + plainText\n              tokens.splice(i - 1, 1)\n              i--\n            }\n            if (/^\\s+$/.test(plainText)) {\n              tokens[i] = plainText\n            } else {\n              tokens[i] = new Prism.Token(\n                'plain-text',\n                plainText,\n                null,\n                plainText\n              )\n            }\n          }\n        }\n        if (token.content && typeof token.content !== 'string') {\n          walkTokens(token.content)\n        }\n      }\n    }\n    Prism.hooks.add('after-tokenize', function (env) {\n      if (env.language !== 'xquery') {\n        return\n      }\n      walkTokens(env.tokens)\n    })\n  })(Prism)\n}\n","// @ts-nocheck\nyang.displayName = 'yang'\nyang.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function yang(Prism) {\n  Prism.languages.yang = {\n    // https://tools.ietf.org/html/rfc6020#page-34\n    // http://www.yang-central.org/twiki/bin/view/Main/YangExamples\n    comment: /\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*/,\n    string: {\n      pattern: /\"(?:[^\\\\\"]|\\\\.)*\"|'[^']*'/,\n      greedy: true\n    },\n    keyword: {\n      pattern: /(^|[{};\\r\\n][ \\t]*)[a-z_][\\w.-]*/i,\n      lookbehind: true\n    },\n    namespace: {\n      pattern: /(\\s)[a-z_][\\w.-]*(?=:)/i,\n      lookbehind: true\n    },\n    boolean: /\\b(?:false|true)\\b/,\n    operator: /\\+/,\n    punctuation: /[{};:]/\n  }\n}\n","// @ts-nocheck\nzig.displayName = 'zig'\nzig.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function zig(Prism) {\n  ;(function (Prism) {\n    function literal(str) {\n      return function () {\n        return str\n      }\n    }\n    var keyword =\n      /\\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\\b/\n    var IDENTIFIER = '\\\\b(?!' + keyword.source + ')(?!\\\\d)\\\\w+\\\\b'\n    var ALIGN = /align\\s*\\((?:[^()]|\\([^()]*\\))*\\)/.source\n    var PREFIX_TYPE_OP =\n      /(?:\\?|\\bpromise->|(?:\\[[^[\\]]*\\]|\\*(?!\\*)|\\*\\*)(?:\\s*<ALIGN>|\\s*const\\b|\\s*volatile\\b|\\s*allowzero\\b)*)/.source.replace(\n        /<ALIGN>/g,\n        literal(ALIGN)\n      )\n    var SUFFIX_EXPR =\n      /(?:\\bpromise\\b|(?:\\berror\\.)?<ID>(?:\\.<ID>)*(?!\\s+<ID>))/.source.replace(\n        /<ID>/g,\n        literal(IDENTIFIER)\n      )\n    var TYPE =\n      '(?!\\\\s)(?:!?\\\\s*(?:' + PREFIX_TYPE_OP + '\\\\s*)*' + SUFFIX_EXPR + ')+'\n\n    /*\n     * A simplified grammar for Zig compile time type literals:\n     *\n     * TypeExpr = ( \"!\"? PREFIX_TYPE_OP* SUFFIX_EXPR )+\n     *\n     * SUFFIX_EXPR = ( \\b \"promise\" \\b | ( \\b \"error\" \".\" )? IDENTIFIER ( \".\" IDENTIFIER )* (?! \\s+ IDENTIFIER ) )\n     *\n     * PREFIX_TYPE_OP = \"?\"\n     *                | \\b \"promise\" \"->\"\n     *                | ( \"[\" [^\\[\\]]* \"]\" | \"*\" | \"**\" ) ( ALIGN | \"const\" \\b | \"volatile\" \\b | \"allowzero\" \\b )*\n     *\n     * ALIGN = \"align\" \"(\" ( [^()] | \"(\" [^()]* \")\" )* \")\"\n     *\n     * IDENTIFIER = \\b (?! KEYWORD ) [a-zA-Z_] \\w* \\b\n     *\n     */\n\n    Prism.languages.zig = {\n      comment: [\n        {\n          pattern: /\\/\\/[/!].*/,\n          alias: 'doc-comment'\n        },\n        /\\/{2}.*/\n      ],\n      string: [\n        {\n          // \"string\" and c\"string\"\n          pattern: /(^|[^\\\\@])c?\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"/,\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          // multiline strings and c-strings\n          pattern: /([\\r\\n])([ \\t]+c?\\\\{2}).*(?:(?:\\r\\n?|\\n)\\2.*)*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      char: {\n        // characters 'a', '\\n', '\\xFF', '\\u{10FFFF}'\n        pattern:\n          /(^|[^\\\\])'(?:[^'\\\\\\r\\n]|[\\uD800-\\uDFFF]{2}|\\\\(?:.|x[a-fA-F\\d]{2}|u\\{[a-fA-F\\d]{1,6}\\}))'/,\n        lookbehind: true,\n        greedy: true\n      },\n      builtin: /\\B@(?!\\d)\\w+(?=\\s*\\()/,\n      label: {\n        pattern:\n          /(\\b(?:break|continue)\\s*:\\s*)\\w+\\b|\\b(?!\\d)\\w+\\b(?=\\s*:\\s*(?:\\{|while\\b))/,\n        lookbehind: true\n      },\n      'class-name': [\n        // const Foo = struct {};\n        /\\b(?!\\d)\\w+(?=\\s*=\\s*(?:(?:extern|packed)\\s+)?(?:enum|struct|union)\\s*[({])/,\n        {\n          // const x: i32 = 9;\n          // var x: Bar;\n          // fn foo(x: bool, y: f32) void {}\n          pattern: RegExp(\n            /(:\\s*)<TYPE>(?=\\s*(?:<ALIGN>\\s*)?[=;,)])|<TYPE>(?=\\s*(?:<ALIGN>\\s*)?\\{)/.source\n              .replace(/<TYPE>/g, literal(TYPE))\n              .replace(/<ALIGN>/g, literal(ALIGN))\n          ),\n          lookbehind: true,\n          inside: null // see below\n        },\n        {\n          // extern fn foo(x: f64) f64; (optional alignment)\n          pattern: RegExp(\n            /(\\)\\s*)<TYPE>(?=\\s*(?:<ALIGN>\\s*)?;)/.source\n              .replace(/<TYPE>/g, literal(TYPE))\n              .replace(/<ALIGN>/g, literal(ALIGN))\n          ),\n          lookbehind: true,\n          inside: null // see below\n        }\n      ],\n\n      'builtin-type': {\n        pattern:\n          /\\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\\b/,\n        alias: 'keyword'\n      },\n      keyword: keyword,\n      function: /\\b(?!\\d)\\w+(?=\\s*\\()/,\n      number:\n        /\\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\\d]+(?:\\.[a-fA-F\\d]*)?(?:[pP][+-]?[a-fA-F\\d]+)?|\\d+(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)\\b/,\n      boolean: /\\b(?:false|true)\\b/,\n      operator:\n        /\\.[*?]|\\.{2,3}|[-=]>|\\*\\*|\\+\\+|\\|\\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,\n      punctuation: /[.:,;(){}[\\]]/\n    }\n    Prism.languages.zig['class-name'].forEach(function (obj) {\n      if (obj.inside === null) {\n        obj.inside = Prism.languages.zig\n      }\n    })\n  })(Prism)\n}\n","/**\n * @typedef {import('./core.js').RefractorRoot} RefractorRoot\n * @typedef {import('./core.js').RefractorElement} RefractorElement\n * @typedef {import('./core.js').Text} Text\n * @typedef {import('./core.js').Grammar} Grammar\n * @typedef {import('./core.js').Syntax} Syntax\n */\nimport markup from '../lang/markup.js'\nimport css from '../lang/css.js'\nimport clike from '../lang/clike.js'\nimport regex from '../lang/regex.js'\nimport javascript from '../lang/javascript.js'\nimport abap from '../lang/abap.js'\nimport abnf from '../lang/abnf.js'\nimport actionscript from '../lang/actionscript.js'\nimport ada from '../lang/ada.js'\nimport agda from '../lang/agda.js'\nimport al from '../lang/al.js'\nimport antlr4 from '../lang/antlr4.js'\nimport apacheconf from '../lang/apacheconf.js'\nimport sql from '../lang/sql.js'\nimport apex from '../lang/apex.js'\nimport apl from '../lang/apl.js'\nimport applescript from '../lang/applescript.js'\nimport aql from '../lang/aql.js'\nimport c from '../lang/c.js'\nimport cpp from '../lang/cpp.js'\nimport arduino from '../lang/arduino.js'\nimport arff from '../lang/arff.js'\nimport armasm from '../lang/armasm.js'\nimport bash from '../lang/bash.js'\nimport yaml from '../lang/yaml.js'\nimport markdown from '../lang/markdown.js'\nimport arturo from '../lang/arturo.js'\nimport asciidoc from '../lang/asciidoc.js'\nimport csharp from '../lang/csharp.js'\nimport aspnet from '../lang/aspnet.js'\nimport asm6502 from '../lang/asm6502.js'\nimport asmatmel from '../lang/asmatmel.js'\nimport autohotkey from '../lang/autohotkey.js'\nimport autoit from '../lang/autoit.js'\nimport avisynth from '../lang/avisynth.js'\nimport avroIdl from '../lang/avro-idl.js'\nimport awk from '../lang/awk.js'\nimport basic from '../lang/basic.js'\nimport batch from '../lang/batch.js'\nimport bbcode from '../lang/bbcode.js'\nimport bbj from '../lang/bbj.js'\nimport bicep from '../lang/bicep.js'\nimport birb from '../lang/birb.js'\nimport bison from '../lang/bison.js'\nimport bnf from '../lang/bnf.js'\nimport bqn from '../lang/bqn.js'\nimport brainfuck from '../lang/brainfuck.js'\nimport brightscript from '../lang/brightscript.js'\nimport bro from '../lang/bro.js'\nimport bsl from '../lang/bsl.js'\nimport cfscript from '../lang/cfscript.js'\nimport chaiscript from '../lang/chaiscript.js'\nimport cil from '../lang/cil.js'\nimport cilkc from '../lang/cilkc.js'\nimport cilkcpp from '../lang/cilkcpp.js'\nimport clojure from '../lang/clojure.js'\nimport cmake from '../lang/cmake.js'\nimport cobol from '../lang/cobol.js'\nimport coffeescript from '../lang/coffeescript.js'\nimport concurnas from '../lang/concurnas.js'\nimport csp from '../lang/csp.js'\nimport cooklang from '../lang/cooklang.js'\nimport coq from '../lang/coq.js'\nimport ruby from '../lang/ruby.js'\nimport crystal from '../lang/crystal.js'\nimport cssExtras from '../lang/css-extras.js'\nimport csv from '../lang/csv.js'\nimport cue from '../lang/cue.js'\nimport cypher from '../lang/cypher.js'\nimport d from '../lang/d.js'\nimport dart from '../lang/dart.js'\nimport dataweave from '../lang/dataweave.js'\nimport dax from '../lang/dax.js'\nimport dhall from '../lang/dhall.js'\nimport diff from '../lang/diff.js'\nimport markupTemplating from '../lang/markup-templating.js'\nimport django from '../lang/django.js'\nimport dnsZoneFile from '../lang/dns-zone-file.js'\nimport docker from '../lang/docker.js'\nimport dot from '../lang/dot.js'\nimport ebnf from '../lang/ebnf.js'\nimport editorconfig from '../lang/editorconfig.js'\nimport eiffel from '../lang/eiffel.js'\nimport ejs from '../lang/ejs.js'\nimport elixir from '../lang/elixir.js'\nimport elm from '../lang/elm.js'\nimport lua from '../lang/lua.js'\nimport etlua from '../lang/etlua.js'\nimport erb from '../lang/erb.js'\nimport erlang from '../lang/erlang.js'\nimport excelFormula from '../lang/excel-formula.js'\nimport fsharp from '../lang/fsharp.js'\nimport factor from '../lang/factor.js'\nimport $false from '../lang/false.js'\nimport firestoreSecurityRules from '../lang/firestore-security-rules.js'\nimport flow from '../lang/flow.js'\nimport fortran from '../lang/fortran.js'\nimport ftl from '../lang/ftl.js'\nimport gml from '../lang/gml.js'\nimport gap from '../lang/gap.js'\nimport gcode from '../lang/gcode.js'\nimport gdscript from '../lang/gdscript.js'\nimport gedcom from '../lang/gedcom.js'\nimport gettext from '../lang/gettext.js'\nimport gherkin from '../lang/gherkin.js'\nimport git from '../lang/git.js'\nimport glsl from '../lang/glsl.js'\nimport gn from '../lang/gn.js'\nimport linkerScript from '../lang/linker-script.js'\nimport go from '../lang/go.js'\nimport goModule from '../lang/go-module.js'\nimport gradle from '../lang/gradle.js'\nimport graphql from '../lang/graphql.js'\nimport groovy from '../lang/groovy.js'\nimport less from '../lang/less.js'\nimport scss from '../lang/scss.js'\nimport textile from '../lang/textile.js'\nimport haml from '../lang/haml.js'\nimport handlebars from '../lang/handlebars.js'\nimport haskell from '../lang/haskell.js'\nimport haxe from '../lang/haxe.js'\nimport hcl from '../lang/hcl.js'\nimport hlsl from '../lang/hlsl.js'\nimport hoon from '../lang/hoon.js'\nimport hpkp from '../lang/hpkp.js'\nimport hsts from '../lang/hsts.js'\nimport json from '../lang/json.js'\nimport uri from '../lang/uri.js'\nimport http from '../lang/http.js'\nimport ichigojam from '../lang/ichigojam.js'\nimport icon from '../lang/icon.js'\nimport icuMessageFormat from '../lang/icu-message-format.js'\nimport idris from '../lang/idris.js'\nimport ignore from '../lang/ignore.js'\nimport inform7 from '../lang/inform7.js'\nimport ini from '../lang/ini.js'\nimport io from '../lang/io.js'\nimport j from '../lang/j.js'\nimport java from '../lang/java.js'\nimport php from '../lang/php.js'\nimport javadoclike from '../lang/javadoclike.js'\nimport scala from '../lang/scala.js'\nimport javadoc from '../lang/javadoc.js'\nimport javastacktrace from '../lang/javastacktrace.js'\nimport jexl from '../lang/jexl.js'\nimport jolie from '../lang/jolie.js'\nimport jq from '../lang/jq.js'\nimport jsTemplates from '../lang/js-templates.js'\nimport typescript from '../lang/typescript.js'\nimport jsdoc from '../lang/jsdoc.js'\nimport n4js from '../lang/n4js.js'\nimport jsExtras from '../lang/js-extras.js'\nimport json5 from '../lang/json5.js'\nimport jsonp from '../lang/jsonp.js'\nimport jsstacktrace from '../lang/jsstacktrace.js'\nimport julia from '../lang/julia.js'\nimport keepalived from '../lang/keepalived.js'\nimport keyman from '../lang/keyman.js'\nimport kotlin from '../lang/kotlin.js'\nimport kumir from '../lang/kumir.js'\nimport kusto from '../lang/kusto.js'\nimport latex from '../lang/latex.js'\nimport latte from '../lang/latte.js'\nimport scheme from '../lang/scheme.js'\nimport lilypond from '../lang/lilypond.js'\nimport liquid from '../lang/liquid.js'\nimport lisp from '../lang/lisp.js'\nimport livescript from '../lang/livescript.js'\nimport llvm from '../lang/llvm.js'\nimport log from '../lang/log.js'\nimport lolcode from '../lang/lolcode.js'\nimport magma from '../lang/magma.js'\nimport makefile from '../lang/makefile.js'\nimport mata from '../lang/mata.js'\nimport matlab from '../lang/matlab.js'\nimport maxscript from '../lang/maxscript.js'\nimport mel from '../lang/mel.js'\nimport mermaid from '../lang/mermaid.js'\nimport metafont from '../lang/metafont.js'\nimport mizar from '../lang/mizar.js'\nimport mongodb from '../lang/mongodb.js'\nimport monkey from '../lang/monkey.js'\nimport moonscript from '../lang/moonscript.js'\nimport n1ql from '../lang/n1ql.js'\nimport nand2tetrisHdl from '../lang/nand2tetris-hdl.js'\nimport naniscript from '../lang/naniscript.js'\nimport nasm from '../lang/nasm.js'\nimport neon from '../lang/neon.js'\nimport nevod from '../lang/nevod.js'\nimport nginx from '../lang/nginx.js'\nimport nim from '../lang/nim.js'\nimport nix from '../lang/nix.js'\nimport nsis from '../lang/nsis.js'\nimport objectivec from '../lang/objectivec.js'\nimport ocaml from '../lang/ocaml.js'\nimport odin from '../lang/odin.js'\nimport opencl from '../lang/opencl.js'\nimport openqasm from '../lang/openqasm.js'\nimport oz from '../lang/oz.js'\nimport parigp from '../lang/parigp.js'\nimport parser from '../lang/parser.js'\nimport pascal from '../lang/pascal.js'\nimport pascaligo from '../lang/pascaligo.js'\nimport psl from '../lang/psl.js'\nimport pcaxis from '../lang/pcaxis.js'\nimport peoplecode from '../lang/peoplecode.js'\nimport perl from '../lang/perl.js'\nimport phpdoc from '../lang/phpdoc.js'\nimport phpExtras from '../lang/php-extras.js'\nimport plantUml from '../lang/plant-uml.js'\nimport plsql from '../lang/plsql.js'\nimport powerquery from '../lang/powerquery.js'\nimport powershell from '../lang/powershell.js'\nimport processing from '../lang/processing.js'\nimport prolog from '../lang/prolog.js'\nimport promql from '../lang/promql.js'\nimport properties from '../lang/properties.js'\nimport protobuf from '../lang/protobuf.js'\nimport stylus from '../lang/stylus.js'\nimport twig from '../lang/twig.js'\nimport pug from '../lang/pug.js'\nimport puppet from '../lang/puppet.js'\nimport pure from '../lang/pure.js'\nimport purebasic from '../lang/purebasic.js'\nimport purescript from '../lang/purescript.js'\nimport python from '../lang/python.js'\nimport qsharp from '../lang/qsharp.js'\nimport q from '../lang/q.js'\nimport qml from '../lang/qml.js'\nimport qore from '../lang/qore.js'\nimport r from '../lang/r.js'\nimport racket from '../lang/racket.js'\nimport cshtml from '../lang/cshtml.js'\nimport jsx from '../lang/jsx.js'\nimport tsx from '../lang/tsx.js'\nimport reason from '../lang/reason.js'\nimport rego from '../lang/rego.js'\nimport renpy from '../lang/renpy.js'\nimport rescript from '../lang/rescript.js'\nimport rest from '../lang/rest.js'\nimport rip from '../lang/rip.js'\nimport roboconf from '../lang/roboconf.js'\nimport robotframework from '../lang/robotframework.js'\nimport rust from '../lang/rust.js'\nimport sas from '../lang/sas.js'\nimport sass from '../lang/sass.js'\nimport shellSession from '../lang/shell-session.js'\nimport smali from '../lang/smali.js'\nimport smalltalk from '../lang/smalltalk.js'\nimport smarty from '../lang/smarty.js'\nimport sml from '../lang/sml.js'\nimport solidity from '../lang/solidity.js'\nimport solutionFile from '../lang/solution-file.js'\nimport soy from '../lang/soy.js'\nimport turtle from '../lang/turtle.js'\nimport sparql from '../lang/sparql.js'\nimport splunkSpl from '../lang/splunk-spl.js'\nimport sqf from '../lang/sqf.js'\nimport squirrel from '../lang/squirrel.js'\nimport stan from '../lang/stan.js'\nimport stata from '../lang/stata.js'\nimport iecst from '../lang/iecst.js'\nimport supercollider from '../lang/supercollider.js'\nimport swift from '../lang/swift.js'\nimport systemd from '../lang/systemd.js'\nimport t4Templating from '../lang/t4-templating.js'\nimport t4Cs from '../lang/t4-cs.js'\nimport vbnet from '../lang/vbnet.js'\nimport t4Vb from '../lang/t4-vb.js'\nimport tap from '../lang/tap.js'\nimport tcl from '../lang/tcl.js'\nimport tt2 from '../lang/tt2.js'\nimport toml from '../lang/toml.js'\nimport tremor from '../lang/tremor.js'\nimport typoscript from '../lang/typoscript.js'\nimport unrealscript from '../lang/unrealscript.js'\nimport uorazor from '../lang/uorazor.js'\nimport v from '../lang/v.js'\nimport vala from '../lang/vala.js'\nimport velocity from '../lang/velocity.js'\nimport verilog from '../lang/verilog.js'\nimport vhdl from '../lang/vhdl.js'\nimport vim from '../lang/vim.js'\nimport visualBasic from '../lang/visual-basic.js'\nimport warpscript from '../lang/warpscript.js'\nimport wasm from '../lang/wasm.js'\nimport webIdl from '../lang/web-idl.js'\nimport wgsl from '../lang/wgsl.js'\nimport wiki from '../lang/wiki.js'\nimport wolfram from '../lang/wolfram.js'\nimport wren from '../lang/wren.js'\nimport xeora from '../lang/xeora.js'\nimport xmlDoc from '../lang/xml-doc.js'\nimport xojo from '../lang/xojo.js'\nimport xquery from '../lang/xquery.js'\nimport yang from '../lang/yang.js'\nimport zig from '../lang/zig.js'\nimport {refractor} from './core.js'\n\nrefractor.register(markup)\nrefractor.register(css)\nrefractor.register(clike)\nrefractor.register(regex)\nrefractor.register(javascript)\nrefractor.register(abap)\nrefractor.register(abnf)\nrefractor.register(actionscript)\nrefractor.register(ada)\nrefractor.register(agda)\nrefractor.register(al)\nrefractor.register(antlr4)\nrefractor.register(apacheconf)\nrefractor.register(sql)\nrefractor.register(apex)\nrefractor.register(apl)\nrefractor.register(applescript)\nrefractor.register(aql)\nrefractor.register(c)\nrefractor.register(cpp)\nrefractor.register(arduino)\nrefractor.register(arff)\nrefractor.register(armasm)\nrefractor.register(bash)\nrefractor.register(yaml)\nrefractor.register(markdown)\nrefractor.register(arturo)\nrefractor.register(asciidoc)\nrefractor.register(csharp)\nrefractor.register(aspnet)\nrefractor.register(asm6502)\nrefractor.register(asmatmel)\nrefractor.register(autohotkey)\nrefractor.register(autoit)\nrefractor.register(avisynth)\nrefractor.register(avroIdl)\nrefractor.register(awk)\nrefractor.register(basic)\nrefractor.register(batch)\nrefractor.register(bbcode)\nrefractor.register(bbj)\nrefractor.register(bicep)\nrefractor.register(birb)\nrefractor.register(bison)\nrefractor.register(bnf)\nrefractor.register(bqn)\nrefractor.register(brainfuck)\nrefractor.register(brightscript)\nrefractor.register(bro)\nrefractor.register(bsl)\nrefractor.register(cfscript)\nrefractor.register(chaiscript)\nrefractor.register(cil)\nrefractor.register(cilkc)\nrefractor.register(cilkcpp)\nrefractor.register(clojure)\nrefractor.register(cmake)\nrefractor.register(cobol)\nrefractor.register(coffeescript)\nrefractor.register(concurnas)\nrefractor.register(csp)\nrefractor.register(cooklang)\nrefractor.register(coq)\nrefractor.register(ruby)\nrefractor.register(crystal)\nrefractor.register(cssExtras)\nrefractor.register(csv)\nrefractor.register(cue)\nrefractor.register(cypher)\nrefractor.register(d)\nrefractor.register(dart)\nrefractor.register(dataweave)\nrefractor.register(dax)\nrefractor.register(dhall)\nrefractor.register(diff)\nrefractor.register(markupTemplating)\nrefractor.register(django)\nrefractor.register(dnsZoneFile)\nrefractor.register(docker)\nrefractor.register(dot)\nrefractor.register(ebnf)\nrefractor.register(editorconfig)\nrefractor.register(eiffel)\nrefractor.register(ejs)\nrefractor.register(elixir)\nrefractor.register(elm)\nrefractor.register(lua)\nrefractor.register(etlua)\nrefractor.register(erb)\nrefractor.register(erlang)\nrefractor.register(excelFormula)\nrefractor.register(fsharp)\nrefractor.register(factor)\nrefractor.register($false)\nrefractor.register(firestoreSecurityRules)\nrefractor.register(flow)\nrefractor.register(fortran)\nrefractor.register(ftl)\nrefractor.register(gml)\nrefractor.register(gap)\nrefractor.register(gcode)\nrefractor.register(gdscript)\nrefractor.register(gedcom)\nrefractor.register(gettext)\nrefractor.register(gherkin)\nrefractor.register(git)\nrefractor.register(glsl)\nrefractor.register(gn)\nrefractor.register(linkerScript)\nrefractor.register(go)\nrefractor.register(goModule)\nrefractor.register(gradle)\nrefractor.register(graphql)\nrefractor.register(groovy)\nrefractor.register(less)\nrefractor.register(scss)\nrefractor.register(textile)\nrefractor.register(haml)\nrefractor.register(handlebars)\nrefractor.register(haskell)\nrefractor.register(haxe)\nrefractor.register(hcl)\nrefractor.register(hlsl)\nrefractor.register(hoon)\nrefractor.register(hpkp)\nrefractor.register(hsts)\nrefractor.register(json)\nrefractor.register(uri)\nrefractor.register(http)\nrefractor.register(ichigojam)\nrefractor.register(icon)\nrefractor.register(icuMessageFormat)\nrefractor.register(idris)\nrefractor.register(ignore)\nrefractor.register(inform7)\nrefractor.register(ini)\nrefractor.register(io)\nrefractor.register(j)\nrefractor.register(java)\nrefractor.register(php)\nrefractor.register(javadoclike)\nrefractor.register(scala)\nrefractor.register(javadoc)\nrefractor.register(javastacktrace)\nrefractor.register(jexl)\nrefractor.register(jolie)\nrefractor.register(jq)\nrefractor.register(jsTemplates)\nrefractor.register(typescript)\nrefractor.register(jsdoc)\nrefractor.register(n4js)\nrefractor.register(jsExtras)\nrefractor.register(json5)\nrefractor.register(jsonp)\nrefractor.register(jsstacktrace)\nrefractor.register(julia)\nrefractor.register(keepalived)\nrefractor.register(keyman)\nrefractor.register(kotlin)\nrefractor.register(kumir)\nrefractor.register(kusto)\nrefractor.register(latex)\nrefractor.register(latte)\nrefractor.register(scheme)\nrefractor.register(lilypond)\nrefractor.register(liquid)\nrefractor.register(lisp)\nrefractor.register(livescript)\nrefractor.register(llvm)\nrefractor.register(log)\nrefractor.register(lolcode)\nrefractor.register(magma)\nrefractor.register(makefile)\nrefractor.register(mata)\nrefractor.register(matlab)\nrefractor.register(maxscript)\nrefractor.register(mel)\nrefractor.register(mermaid)\nrefractor.register(metafont)\nrefractor.register(mizar)\nrefractor.register(mongodb)\nrefractor.register(monkey)\nrefractor.register(moonscript)\nrefractor.register(n1ql)\nrefractor.register(nand2tetrisHdl)\nrefractor.register(naniscript)\nrefractor.register(nasm)\nrefractor.register(neon)\nrefractor.register(nevod)\nrefractor.register(nginx)\nrefractor.register(nim)\nrefractor.register(nix)\nrefractor.register(nsis)\nrefractor.register(objectivec)\nrefractor.register(ocaml)\nrefractor.register(odin)\nrefractor.register(opencl)\nrefractor.register(openqasm)\nrefractor.register(oz)\nrefractor.register(parigp)\nrefractor.register(parser)\nrefractor.register(pascal)\nrefractor.register(pascaligo)\nrefractor.register(psl)\nrefractor.register(pcaxis)\nrefractor.register(peoplecode)\nrefractor.register(perl)\nrefractor.register(phpdoc)\nrefractor.register(phpExtras)\nrefractor.register(plantUml)\nrefractor.register(plsql)\nrefractor.register(powerquery)\nrefractor.register(powershell)\nrefractor.register(processing)\nrefractor.register(prolog)\nrefractor.register(promql)\nrefractor.register(properties)\nrefractor.register(protobuf)\nrefractor.register(stylus)\nrefractor.register(twig)\nrefractor.register(pug)\nrefractor.register(puppet)\nrefractor.register(pure)\nrefractor.register(purebasic)\nrefractor.register(purescript)\nrefractor.register(python)\nrefractor.register(qsharp)\nrefractor.register(q)\nrefractor.register(qml)\nrefractor.register(qore)\nrefractor.register(r)\nrefractor.register(racket)\nrefractor.register(cshtml)\nrefractor.register(jsx)\nrefractor.register(tsx)\nrefractor.register(reason)\nrefractor.register(rego)\nrefractor.register(renpy)\nrefractor.register(rescript)\nrefractor.register(rest)\nrefractor.register(rip)\nrefractor.register(roboconf)\nrefractor.register(robotframework)\nrefractor.register(rust)\nrefractor.register(sas)\nrefractor.register(sass)\nrefractor.register(shellSession)\nrefractor.register(smali)\nrefractor.register(smalltalk)\nrefractor.register(smarty)\nrefractor.register(sml)\nrefractor.register(solidity)\nrefractor.register(solutionFile)\nrefractor.register(soy)\nrefractor.register(turtle)\nrefractor.register(sparql)\nrefractor.register(splunkSpl)\nrefractor.register(sqf)\nrefractor.register(squirrel)\nrefractor.register(stan)\nrefractor.register(stata)\nrefractor.register(iecst)\nrefractor.register(supercollider)\nrefractor.register(swift)\nrefractor.register(systemd)\nrefractor.register(t4Templating)\nrefractor.register(t4Cs)\nrefractor.register(vbnet)\nrefractor.register(t4Vb)\nrefractor.register(tap)\nrefractor.register(tcl)\nrefractor.register(tt2)\nrefractor.register(toml)\nrefractor.register(tremor)\nrefractor.register(typoscript)\nrefractor.register(unrealscript)\nrefractor.register(uorazor)\nrefractor.register(v)\nrefractor.register(vala)\nrefractor.register(velocity)\nrefractor.register(verilog)\nrefractor.register(vhdl)\nrefractor.register(vim)\nrefractor.register(visualBasic)\nrefractor.register(warpscript)\nrefractor.register(wasm)\nrefractor.register(webIdl)\nrefractor.register(wgsl)\nrefractor.register(wiki)\nrefractor.register(wolfram)\nrefractor.register(wren)\nrefractor.register(xeora)\nrefractor.register(xmlDoc)\nrefractor.register(xojo)\nrefractor.register(xquery)\nrefractor.register(yang)\nrefractor.register(zig)\n\nexport {refractor} from './core.js'\n","// @ts-nocheck\nimport refractorBasic from './basic.js'\nvbnet.displayName = 'vbnet'\nvbnet.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function vbnet(Prism) {\n  Prism.register(refractorBasic)\n  Prism.languages.vbnet = Prism.languages.extend('basic', {\n    comment: [\n      {\n        pattern: /(?:!|REM\\b).+/i,\n        inside: {\n          keyword: /^REM/i\n        }\n      },\n      {\n        pattern: /(^|[^\\\\:])'.*/,\n        lookbehind: true,\n        greedy: true\n      }\n    ],\n    string: {\n      pattern: /(^|[^\"])\"(?:\"\"|[^\"])*\"(?!\")/,\n      lookbehind: true,\n      greedy: true\n    },\n    keyword:\n      /(?:\\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\\$|\\b)/i,\n    punctuation: /[,;:(){}]/\n  })\n}\n","// @ts-nocheck\nswift.displayName = 'swift'\nswift.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function swift(Prism) {\n  Prism.languages.swift = {\n    comment: {\n      // Nested comments are supported up to 2 levels\n      pattern:\n        /(^|[^\\\\:])(?:\\/\\/.*|\\/\\*(?:[^/*]|\\/(?!\\*)|\\*(?!\\/)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*\\*\\/)/,\n      lookbehind: true,\n      greedy: true\n    },\n    'string-literal': [\n      // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html\n      {\n        pattern: RegExp(\n          /(^|[^\"#])/.source +\n            '(?:' +\n            // single-line string\n            /\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^(])|[^\\\\\\r\\n\"])*\"/\n              .source +\n            '|' +\n            // multi-line string\n            /\"\"\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|[^(])|[^\\\\\"]|\"(?!\"\"))*\"\"\"/\n              .source +\n            ')' +\n            /(?![\"#])/.source\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern: /(\\\\\\()(?:[^()]|\\([^()]*\\))*(?=\\))/,\n            lookbehind: true,\n            inside: null // see below\n          },\n\n          'interpolation-punctuation': {\n            pattern: /^\\)|\\\\\\($/,\n            alias: 'punctuation'\n          },\n          punctuation: /\\\\(?=[\\r\\n])/,\n          string: /[\\s\\S]+/\n        }\n      },\n      {\n        pattern: RegExp(\n          /(^|[^\"#])(#+)/.source +\n            '(?:' +\n            // single-line string\n            /\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^#])|[^\\\\\\r\\n])*?\"/\n              .source +\n            '|' +\n            // multi-line string\n            /\"\"\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|[^#])|[^\\\\])*?\"\"\"/.source +\n            ')' +\n            '\\\\2'\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern: /(\\\\#+\\()(?:[^()]|\\([^()]*\\))*(?=\\))/,\n            lookbehind: true,\n            inside: null // see below\n          },\n\n          'interpolation-punctuation': {\n            pattern: /^\\)|\\\\#+\\($/,\n            alias: 'punctuation'\n          },\n          string: /[\\s\\S]+/\n        }\n      }\n    ],\n    directive: {\n      // directives with conditions\n      pattern: RegExp(\n        /#/.source +\n          '(?:' +\n          (/(?:elseif|if)\\b/.source +\n            '(?:[ \\t]*' +\n            // This regex is a little complex. It's equivalent to this:\n            //   (?:![ \\t]*)?(?:\\b\\w+\\b(?:[ \\t]*<round>)?|<round>)(?:[ \\t]*(?:&&|\\|\\|))?\n            // where <round> is a general parentheses expression.\n            /(?:![ \\t]*)?(?:\\b\\w+\\b(?:[ \\t]*\\((?:[^()]|\\([^()]*\\))*\\))?|\\((?:[^()]|\\([^()]*\\))*\\))(?:[ \\t]*(?:&&|\\|\\|))?/\n              .source +\n            ')+') +\n          '|' +\n          /(?:else|endif)\\b/.source +\n          ')'\n      ),\n      alias: 'property',\n      inside: {\n        'directive-name': /^#\\w+/,\n        boolean: /\\b(?:false|true)\\b/,\n        number: /\\b\\d+(?:\\.\\d+)*\\b/,\n        operator: /!|&&|\\|\\||[<>]=?/,\n        punctuation: /[(),]/\n      }\n    },\n    literal: {\n      pattern:\n        /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\\b/,\n      alias: 'constant'\n    },\n    'other-directive': {\n      pattern: /#\\w+\\b/,\n      alias: 'property'\n    },\n    attribute: {\n      pattern: /@\\w+/,\n      alias: 'atrule'\n    },\n    'function-definition': {\n      pattern: /(\\bfunc\\s+)\\w+/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    label: {\n      // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141\n      pattern:\n        /\\b(break|continue)\\s+\\w+|\\b[a-zA-Z_]\\w*(?=\\s*:\\s*(?:for|repeat|while)\\b)/,\n      lookbehind: true,\n      alias: 'important'\n    },\n    keyword:\n      /\\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    nil: {\n      pattern: /\\bnil\\b/,\n      alias: 'constant'\n    },\n    'short-argument': /\\$\\d+\\b/,\n    omit: {\n      pattern: /\\b_\\b/,\n      alias: 'keyword'\n    },\n    number:\n      /\\b(?:[\\d_]+(?:\\.[\\de_]+)?|0x[a-f0-9_]+(?:\\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\\b/i,\n    // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.\n    'class-name': /\\b[A-Z](?:[A-Z_\\d]*[a-z]\\w*)?\\b/,\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n    constant: /\\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\\b/,\n    // Operators are generic in Swift. Developers can even create new operators (e.g. +++).\n    // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481\n    // This regex only supports ASCII operators.\n    operator: /[-+*/%=!<>&|^~?]+|\\.[.\\-+*/%=!<>&|^~?]+/,\n    punctuation: /[{}[\\]();,.:\\\\]/\n  }\n  Prism.languages.swift['string-literal'].forEach(function (rule) {\n    rule.inside['interpolation'].inside = Prism.languages.swift\n  })\n}\n","// @ts-nocheck\nyaml.displayName = 'yaml'\nyaml.aliases = ['yml']\n\n/** @type {import('../core.js').Syntax} */\nexport default function yaml(Prism) {\n  ;(function (Prism) {\n    // https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property\n    // https://yaml.org/spec/1.2/spec.html#c-ns-alias-node\n    var anchorOrAlias = /[*&][^\\s[\\]{},]+/\n    // https://yaml.org/spec/1.2/spec.html#c-ns-tag-property\n    var tag =\n      /!(?:<[\\w\\-%#;/?:@&=+$,.!~*'()[\\]]+>|(?:[a-zA-Z\\d-]*!)?[\\w\\-%#;/?:@&=+$.~*'()]+)?/\n    // https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)\n    var properties =\n      '(?:' +\n      tag.source +\n      '(?:[ \\t]+' +\n      anchorOrAlias.source +\n      ')?|' +\n      anchorOrAlias.source +\n      '(?:[ \\t]+' +\n      tag.source +\n      ')?)'\n    // https://yaml.org/spec/1.2/spec.html#ns-plain(n,c)\n    // This is a simplified version that doesn't support \"#\" and multiline keys\n    // All these long scarry character classes are simplified versions of YAML's characters\n    var plainKey =\n      /(?:[^\\s\\x00-\\x08\\x0e-\\x1f!\"#%&'*,\\-:>?@[\\]`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ \\t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(\n        /<PLAIN>/g,\n        function () {\n          return /[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]/\n            .source\n        }\n      )\n    var string = /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?:[^'\\\\\\r\\n]|\\\\.)*'/.source\n\n    /**\n     *\n     * @param {string} value\n     * @param {string} [flags]\n     * @returns {RegExp}\n     */\n    function createValuePattern(value, flags) {\n      flags = (flags || '').replace(/m/g, '') + 'm' // add m flag\n      var pattern =\n        /([:\\-,[{]\\s*(?:\\s<<prop>>[ \\t]+)?)(?:<<value>>)(?=[ \\t]*(?:$|,|\\]|\\}|(?:[\\r\\n]\\s*)?#))/.source\n          .replace(/<<prop>>/g, function () {\n            return properties\n          })\n          .replace(/<<value>>/g, function () {\n            return value\n          })\n      return RegExp(pattern, flags)\n    }\n    Prism.languages.yaml = {\n      scalar: {\n        pattern: RegExp(\n          /([\\-:]\\s*(?:\\s<<prop>>[ \\t]+)?[|>])[ \\t]*(?:((?:\\r?\\n|\\r)[ \\t]+)\\S[^\\r\\n]*(?:\\2[^\\r\\n]+)*)/.source.replace(\n            /<<prop>>/g,\n            function () {\n              return properties\n            }\n          )\n        ),\n        lookbehind: true,\n        alias: 'string'\n      },\n      comment: /#.*/,\n      key: {\n        pattern: RegExp(\n          /((?:^|[:\\-,[{\\r\\n?])[ \\t]*(?:<<prop>>[ \\t]+)?)<<key>>(?=\\s*:\\s)/.source\n            .replace(/<<prop>>/g, function () {\n              return properties\n            })\n            .replace(/<<key>>/g, function () {\n              return '(?:' + plainKey + '|' + string + ')'\n            })\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'atrule'\n      },\n      directive: {\n        pattern: /(^[ \\t]*)%.+/m,\n        lookbehind: true,\n        alias: 'important'\n      },\n      datetime: {\n        pattern: createValuePattern(\n          /\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \\t]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?(?:[ \\t]*(?:Z|[-+]\\d\\d?(?::\\d{2})?))?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?/\n            .source\n        ),\n        lookbehind: true,\n        alias: 'number'\n      },\n      boolean: {\n        pattern: createValuePattern(/false|true/.source, 'i'),\n        lookbehind: true,\n        alias: 'important'\n      },\n      null: {\n        pattern: createValuePattern(/null|~/.source, 'i'),\n        lookbehind: true,\n        alias: 'important'\n      },\n      string: {\n        pattern: createValuePattern(string),\n        lookbehind: true,\n        greedy: true\n      },\n      number: {\n        pattern: createValuePattern(\n          /[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)/\n            .source,\n          'i'\n        ),\n        lookbehind: true\n      },\n      tag: tag,\n      important: anchorOrAlias,\n      punctuation: /---|[:[\\]{}\\-,|>?]|\\.\\.\\./\n    }\n    Prism.languages.yml = Prism.languages.yaml\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorJavascript from './javascript.js'\ntypescript.displayName = 'typescript'\ntypescript.aliases = ['ts']\n\n/** @type {import('../core.js').Syntax} */\nexport default function typescript(Prism) {\n  Prism.register(refractorJavascript)\n  ;(function (Prism) {\n    Prism.languages.typescript = Prism.languages.extend('javascript', {\n      'class-name': {\n        pattern:\n          /(\\b(?:class|extends|implements|instanceof|interface|new|type)\\s+)(?!keyof\\b)(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?:\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,\n        lookbehind: true,\n        greedy: true,\n        inside: null // see below\n      },\n\n      builtin:\n        /\\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\\b/\n    })\n\n    // The keywords TypeScript adds to JavaScript\n    Prism.languages.typescript.keyword.push(\n      /\\b(?:abstract|declare|is|keyof|readonly|require)\\b/,\n      // keywords that have to be followed by an identifier\n      /\\b(?:asserts|infer|interface|module|namespace|type)\\b(?=\\s*(?:[{_$a-zA-Z\\xA0-\\uFFFF]|$))/,\n      // This is for `import type *, {}`\n      /\\btype\\b(?=\\s*(?:[\\{*]|$))/\n    )\n\n    // doesn't work with TS because TS is too complex\n    delete Prism.languages.typescript['parameter']\n    delete Prism.languages.typescript['literal-property']\n\n    // a version of typescript specifically for highlighting types\n    var typeInside = Prism.languages.extend('typescript', {})\n    delete typeInside['class-name']\n    Prism.languages.typescript['class-name'].inside = typeInside\n    Prism.languages.insertBefore('typescript', 'function', {\n      decorator: {\n        pattern: /@[$\\w\\xA0-\\uFFFF]+/,\n        inside: {\n          at: {\n            pattern: /^@/,\n            alias: 'operator'\n          },\n          function: /^[\\s\\S]+/\n        }\n      },\n      'generic-function': {\n        // e.g. foo<T extends \"bar\" | \"baz\">( ...\n        pattern:\n          /#?(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\\s*\\()/,\n        greedy: true,\n        inside: {\n          function: /^#?(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*/,\n          generic: {\n            pattern: /<[\\s\\S]+/,\n            // everything after the first <\n            alias: 'class-name',\n            inside: typeInside\n          }\n        }\n      }\n    })\n    Prism.languages.ts = Prism.languages.typescript\n  })(Prism)\n}\n","// @ts-nocheck\nrust.displayName = 'rust'\nrust.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function rust(Prism) {\n  ;(function (Prism) {\n    var multilineComment = /\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|<self>)*\\*\\//.source\n    for (var i = 0; i < 2; i++) {\n      // support 4 levels of nested comments\n      multilineComment = multilineComment.replace(/<self>/g, function () {\n        return multilineComment\n      })\n    }\n    multilineComment = multilineComment.replace(/<self>/g, function () {\n      return /[^\\s\\S]/.source\n    })\n    Prism.languages.rust = {\n      comment: [\n        {\n          pattern: RegExp(/(^|[^\\\\])/.source + multilineComment),\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          pattern: /(^|[^\\\\:])\\/\\/.*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      string: {\n        pattern: /b?\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"|b?r(#*)\"(?:[^\"]|\"(?!\\1))*\"\\1/,\n        greedy: true\n      },\n      char: {\n        pattern:\n          /b?'(?:\\\\(?:x[0-7][\\da-fA-F]|u\\{(?:[\\da-fA-F]_*){1,6}\\}|.)|[^\\\\\\r\\n\\t'])'/,\n        greedy: true\n      },\n      attribute: {\n        pattern: /#!?\\[(?:[^\\[\\]\"]|\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")*\\]/,\n        greedy: true,\n        alias: 'attr-name',\n        inside: {\n          string: null // see below\n        }\n      },\n\n      // Closure params should not be confused with bitwise OR |\n      'closure-params': {\n        pattern: /([=(,:]\\s*|\\bmove\\s*)\\|[^|]*\\||\\|[^|]*\\|(?=\\s*(?:\\{|->))/,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          'closure-punctuation': {\n            pattern: /^\\||\\|$/,\n            alias: 'punctuation'\n          },\n          rest: null // see below\n        }\n      },\n\n      'lifetime-annotation': {\n        pattern: /'\\w+/,\n        alias: 'symbol'\n      },\n      'fragment-specifier': {\n        pattern: /(\\$\\w+:)[a-z]+/,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      variable: /\\$\\w+/,\n      'function-definition': {\n        pattern: /(\\bfn\\s+)\\w+/,\n        lookbehind: true,\n        alias: 'function'\n      },\n      'type-definition': {\n        pattern: /(\\b(?:enum|struct|trait|type|union)\\s+)\\w+/,\n        lookbehind: true,\n        alias: 'class-name'\n      },\n      'module-declaration': [\n        {\n          pattern: /(\\b(?:crate|mod)\\s+)[a-z][a-z_\\d]*/,\n          lookbehind: true,\n          alias: 'namespace'\n        },\n        {\n          pattern:\n            /(\\b(?:crate|self|super)\\s*)::\\s*[a-z][a-z_\\d]*\\b(?:\\s*::(?:\\s*[a-z][a-z_\\d]*\\s*::)*)?/,\n          lookbehind: true,\n          alias: 'namespace',\n          inside: {\n            punctuation: /::/\n          }\n        }\n      ],\n      keyword: [\n        // https://github.com/rust-lang/reference/blob/master/src/keywords.md\n        /\\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\\b/,\n        // primitives and str\n        // https://doc.rust-lang.org/stable/rust-by-example/primitives.html\n        /\\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\\b/\n      ],\n      // functions can technically start with an upper-case letter, but this will introduce a lot of false positives\n      // and Rust's naming conventions recommend snake_case anyway.\n      // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html\n      function: /\\b[a-z_]\\w*(?=\\s*(?:::\\s*<|\\())/,\n      macro: {\n        pattern: /\\b\\w+!/,\n        alias: 'property'\n      },\n      constant: /\\b[A-Z_][A-Z_\\d]+\\b/,\n      'class-name': /\\b[A-Z]\\w*\\b/,\n      namespace: {\n        pattern: /(?:\\b[a-z][a-z_\\d]*\\s*::\\s*)*\\b[a-z][a-z_\\d]*\\s*::(?!\\s*<)/,\n        inside: {\n          punctuation: /::/\n        }\n      },\n      // Hex, oct, bin, dec numbers with visual separators and type suffix\n      number:\n        /\\b(?:0x[\\dA-Fa-f](?:_?[\\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\\d(?:_?\\d)*)?\\.)?\\d(?:_?\\d)*(?:[Ee][+-]?\\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\\b/,\n      boolean: /\\b(?:false|true)\\b/,\n      punctuation: /->|\\.\\.=|\\.{1,3}|::|[{}[\\];(),:]/,\n      operator: /[-+*\\/%!^]=?|=[=>]?|&[&=]?|\\|[|=]?|<<?=?|>>?=?|[@?]/\n    }\n    Prism.languages.rust['closure-params'].inside.rest = Prism.languages.rust\n    Prism.languages.rust['attribute'].inside['string'] =\n      Prism.languages.rust['string']\n  })(Prism)\n}\n","/**\n * @typedef {import('./core.js').RefractorRoot} RefractorRoot\n * @typedef {import('./core.js').RefractorElement} RefractorElement\n * @typedef {import('./core.js').Text} Text\n * @typedef {import('./core.js').Grammar} Grammar\n * @typedef {import('./core.js').Syntax} Syntax\n */\nimport clike from '../lang/clike.js'\nimport c from '../lang/c.js'\nimport cpp from '../lang/cpp.js'\nimport arduino from '../lang/arduino.js'\nimport bash from '../lang/bash.js'\nimport csharp from '../lang/csharp.js'\nimport markup from '../lang/markup.js'\nimport css from '../lang/css.js'\nimport diff from '../lang/diff.js'\nimport go from '../lang/go.js'\nimport ini from '../lang/ini.js'\nimport java from '../lang/java.js'\nimport regex from '../lang/regex.js'\nimport javascript from '../lang/javascript.js'\nimport json from '../lang/json.js'\nimport kotlin from '../lang/kotlin.js'\nimport less from '../lang/less.js'\nimport lua from '../lang/lua.js'\nimport makefile from '../lang/makefile.js'\nimport yaml from '../lang/yaml.js'\nimport markdown from '../lang/markdown.js'\nimport objectivec from '../lang/objectivec.js'\nimport perl from '../lang/perl.js'\nimport markupTemplating from '../lang/markup-templating.js'\nimport php from '../lang/php.js'\nimport python from '../lang/python.js'\nimport r from '../lang/r.js'\nimport ruby from '../lang/ruby.js'\nimport rust from '../lang/rust.js'\nimport sass from '../lang/sass.js'\nimport scss from '../lang/scss.js'\nimport sql from '../lang/sql.js'\nimport swift from '../lang/swift.js'\nimport typescript from '../lang/typescript.js'\nimport basic from '../lang/basic.js'\nimport vbnet from '../lang/vbnet.js'\nimport {refractor} from './core.js'\n\nrefractor.register(clike)\nrefractor.register(c)\nrefractor.register(cpp)\nrefractor.register(arduino)\nrefractor.register(bash)\nrefractor.register(csharp)\nrefractor.register(markup)\nrefractor.register(css)\nrefractor.register(diff)\nrefractor.register(go)\nrefractor.register(ini)\nrefractor.register(java)\nrefractor.register(regex)\nrefractor.register(javascript)\nrefractor.register(json)\nrefractor.register(kotlin)\nrefractor.register(less)\nrefractor.register(lua)\nrefractor.register(makefile)\nrefractor.register(yaml)\nrefractor.register(markdown)\nrefractor.register(objectivec)\nrefractor.register(perl)\nrefractor.register(markupTemplating)\nrefractor.register(php)\nrefractor.register(python)\nrefractor.register(r)\nrefractor.register(ruby)\nrefractor.register(rust)\nrefractor.register(sass)\nrefractor.register(scss)\nrefractor.register(sql)\nrefractor.register(swift)\nrefractor.register(typescript)\nrefractor.register(basic)\nrefractor.register(vbnet)\n\nexport {refractor} from './core.js'\n","// @ts-nocheck\nr.displayName = 'r'\nr.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function r(Prism) {\n  Prism.languages.r = {\n    comment: /#.*/,\n    string: {\n      pattern: /(['\"])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    'percent-operator': {\n      // Includes user-defined operators\n      // and %%, %*%, %/%, %in%, %o%, %x%\n      pattern: /%[^%\\s]*%/,\n      alias: 'operator'\n    },\n    boolean: /\\b(?:FALSE|TRUE)\\b/,\n    ellipsis: /\\.\\.(?:\\.|\\d+)/,\n    number: [\n      /\\b(?:Inf|NaN)\\b/,\n      /(?:\\b0x[\\dA-Fa-f]+(?:\\.\\d*)?|\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[EePp][+-]?\\d+)?[iL]?/\n    ],\n    keyword:\n      /\\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\\b/,\n    operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\\|\\|?|[+*\\/^$@~]/,\n    punctuation: /[(){}\\[\\],;]/\n  }\n}\n","// @ts-nocheck\nregex.displayName = 'regex'\nregex.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function regex(Prism) {\n  ;(function (Prism) {\n    var specialEscape = {\n      pattern: /\\\\[\\\\(){}[\\]^$+*?|.]/,\n      alias: 'escape'\n    }\n    var escape =\n      /\\\\(?:x[\\da-fA-F]{2}|u[\\da-fA-F]{4}|u\\{[\\da-fA-F]+\\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/\n    var charSet = {\n      pattern: /\\.|\\\\[wsd]|\\\\p\\{[^{}]+\\}/i,\n      alias: 'class-name'\n    }\n    var charSetWithoutDot = {\n      pattern: /\\\\[wsd]|\\\\p\\{[^{}]+\\}/i,\n      alias: 'class-name'\n    }\n    var rangeChar = '(?:[^\\\\\\\\-]|' + escape.source + ')'\n    var range = RegExp(rangeChar + '-' + rangeChar)\n\n    // the name of a capturing group\n    var groupName = {\n      pattern: /(<|')[^<>']+(?=[>']$)/,\n      lookbehind: true,\n      alias: 'variable'\n    }\n    Prism.languages.regex = {\n      'char-class': {\n        pattern: /((?:^|[^\\\\])(?:\\\\\\\\)*)\\[(?:[^\\\\\\]]|\\\\[\\s\\S])*\\]/,\n        lookbehind: true,\n        inside: {\n          'char-class-negation': {\n            pattern: /(^\\[)\\^/,\n            lookbehind: true,\n            alias: 'operator'\n          },\n          'char-class-punctuation': {\n            pattern: /^\\[|\\]$/,\n            alias: 'punctuation'\n          },\n          range: {\n            pattern: range,\n            inside: {\n              escape: escape,\n              'range-punctuation': {\n                pattern: /-/,\n                alias: 'operator'\n              }\n            }\n          },\n          'special-escape': specialEscape,\n          'char-set': charSetWithoutDot,\n          escape: escape\n        }\n      },\n      'special-escape': specialEscape,\n      'char-set': charSet,\n      backreference: [\n        {\n          // a backreference which is not an octal escape\n          pattern: /\\\\(?![123][0-7]{2})[1-9]/,\n          alias: 'keyword'\n        },\n        {\n          pattern: /\\\\k<[^<>']+>/,\n          alias: 'keyword',\n          inside: {\n            'group-name': groupName\n          }\n        }\n      ],\n      anchor: {\n        pattern: /[$^]|\\\\[ABbGZz]/,\n        alias: 'function'\n      },\n      escape: escape,\n      group: [\n        {\n          // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html\n          // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs\n\n          // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)\n          pattern:\n            /\\((?:\\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,\n          alias: 'punctuation',\n          inside: {\n            'group-name': groupName\n          }\n        },\n        {\n          pattern: /\\)/,\n          alias: 'punctuation'\n        }\n      ],\n      quantifier: {\n        pattern: /(?:[+*?]|\\{\\d+(?:,\\d*)?\\})[?+]?/,\n        alias: 'number'\n      },\n      alternation: {\n        pattern: /\\|/,\n        alias: 'keyword'\n      }\n    }\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorCss from './css.js'\nsass.displayName = 'sass'\nsass.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function sass(Prism) {\n  Prism.register(refractorCss)\n  ;(function (Prism) {\n    Prism.languages.sass = Prism.languages.extend('css', {\n      // Sass comments don't need to be closed, only indented\n      comment: {\n        pattern: /^([ \\t]*)\\/[\\/*].*(?:(?:\\r?\\n|\\r)\\1[ \\t].+)*/m,\n        lookbehind: true,\n        greedy: true\n      }\n    })\n    Prism.languages.insertBefore('sass', 'atrule', {\n      // We want to consume the whole line\n      'atrule-line': {\n        // Includes support for = and + shortcuts\n        pattern: /^(?:[ \\t]*)[@+=].+/m,\n        greedy: true,\n        inside: {\n          atrule: /(?:@[\\w-]+|[+=])/\n        }\n      }\n    })\n    delete Prism.languages.sass.atrule\n    var variable = /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n    var operator = [\n      /[+*\\/%]|[=!]=|<=?|>=?|\\b(?:and|not|or)\\b/,\n      {\n        pattern: /(\\s)-(?=\\s)/,\n        lookbehind: true\n      }\n    ]\n    Prism.languages.insertBefore('sass', 'property', {\n      // We want to consume the whole line\n      'variable-line': {\n        pattern: /^[ \\t]*\\$.+/m,\n        greedy: true,\n        inside: {\n          punctuation: /:/,\n          variable: variable,\n          operator: operator\n        }\n      },\n      // We want to consume the whole line\n      'property-line': {\n        pattern: /^[ \\t]*(?:[^:\\s]+ *:.*|:[^:\\s].*)/m,\n        greedy: true,\n        inside: {\n          property: [\n            /[^:\\s]+(?=\\s*:)/,\n            {\n              pattern: /(:)[^:\\s]+/,\n              lookbehind: true\n            }\n          ],\n          punctuation: /:/,\n          variable: variable,\n          operator: operator,\n          important: Prism.languages.sass.important\n        }\n      }\n    })\n    delete Prism.languages.sass.property\n    delete Prism.languages.sass.important\n\n    // Now that whole lines for other patterns are consumed,\n    // what's left should be selectors\n    Prism.languages.insertBefore('sass', 'punctuation', {\n      selector: {\n        pattern:\n          /^([ \\t]*)\\S(?:,[^,\\r\\n]+|[^,\\r\\n]*)(?:,[^,\\r\\n]+)*(?:,(?:\\r?\\n|\\r)\\1[ \\t]+\\S(?:,[^,\\r\\n]+|[^,\\r\\n]*)(?:,[^,\\r\\n]+)*)*/m,\n        lookbehind: true,\n        greedy: true\n      }\n    })\n  })(Prism)\n}\n","// @ts-nocheck\nimport refractorClike from './clike.js'\nruby.displayName = 'ruby'\nruby.aliases = ['rb']\n\n/** @type {import('../core.js').Syntax} */\nexport default function ruby(Prism) {\n  Prism.register(refractorClike)\n  /**\n   * Original by Samuel Flores\n   *\n   * Adds the following new token classes:\n   *     constant, builtin, variable, symbol, regex\n   */\n  ;(function (Prism) {\n    Prism.languages.ruby = Prism.languages.extend('clike', {\n      comment: {\n        pattern: /#.*|^=begin\\s[\\s\\S]*?^=end/m,\n        greedy: true\n      },\n      'class-name': {\n        pattern:\n          /(\\b(?:class|module)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+|\\b[A-Z_]\\w*(?=\\s*\\.\\s*new\\b)/,\n        lookbehind: true,\n        inside: {\n          punctuation: /[.\\\\]/\n        }\n      },\n      keyword:\n        /\\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\\b/,\n      operator:\n        /\\.{2,3}|&\\.|===|<?=>|[!=]?~|(?:&&|\\|\\||<<|>>|\\*\\*|[+\\-*/%<>!^&|=])=?|[?:]/,\n      punctuation: /[(){}[\\].,;]/\n    })\n    Prism.languages.insertBefore('ruby', 'operator', {\n      'double-colon': {\n        pattern: /::/,\n        alias: 'punctuation'\n      }\n    })\n    var interpolation = {\n      pattern: /((?:^|[^\\\\])(?:\\\\{2})*)#\\{(?:[^{}]|\\{[^{}]*\\})*\\}/,\n      lookbehind: true,\n      inside: {\n        content: {\n          pattern: /^(#\\{)[\\s\\S]+(?=\\}$)/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        },\n        delimiter: {\n          pattern: /^#\\{|\\}$/,\n          alias: 'punctuation'\n        }\n      }\n    }\n    delete Prism.languages.ruby.function\n    var percentExpression =\n      '(?:' +\n      [\n        /([^a-zA-Z0-9\\s{(\\[<=])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/.source,\n        /\\((?:[^()\\\\]|\\\\[\\s\\S]|\\((?:[^()\\\\]|\\\\[\\s\\S])*\\))*\\)/.source,\n        /\\{(?:[^{}\\\\]|\\\\[\\s\\S]|\\{(?:[^{}\\\\]|\\\\[\\s\\S])*\\})*\\}/.source,\n        /\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S]|\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S])*\\])*\\]/.source,\n        /<(?:[^<>\\\\]|\\\\[\\s\\S]|<(?:[^<>\\\\]|\\\\[\\s\\S])*>)*>/.source\n      ].join('|') +\n      ')'\n    var symbolName =\n      /(?:\"(?:\\\\.|[^\"\\\\\\r\\n])*\"|(?:\\b[a-zA-Z_]\\w*|[^\\s\\0-\\x7F]+)[?!]?|\\$.)/\n        .source\n    Prism.languages.insertBefore('ruby', 'keyword', {\n      'regex-literal': [\n        {\n          pattern: RegExp(\n            /%r/.source + percentExpression + /[egimnosux]{0,6}/.source\n          ),\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            regex: /[\\s\\S]+/\n          }\n        },\n        {\n          pattern:\n            /(^|[^/])\\/(?!\\/)(?:\\[[^\\r\\n\\]]+\\]|\\\\.|[^[/\\\\\\r\\n])+\\/[egimnosux]{0,6}(?=\\s*(?:$|[\\r\\n,.;})#]))/,\n          lookbehind: true,\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            regex: /[\\s\\S]+/\n          }\n        }\n      ],\n      variable: /[@$]+[a-zA-Z_]\\w*(?:[?!]|\\b)/,\n      symbol: [\n        {\n          pattern: RegExp(/(^|[^:]):/.source + symbolName),\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          pattern: RegExp(\n            /([\\r\\n{(,][ \\t]*)/.source + symbolName + /(?=:(?!:))/.source\n          ),\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      'method-definition': {\n        pattern: /(\\bdef\\s+)\\w+(?:\\s*\\.\\s*\\w+)?/,\n        lookbehind: true,\n        inside: {\n          function: /\\b\\w+$/,\n          keyword: /^self\\b/,\n          'class-name': /^\\w+/,\n          punctuation: /\\./\n        }\n      }\n    })\n    Prism.languages.insertBefore('ruby', 'string', {\n      'string-literal': [\n        {\n          pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            string: /[\\s\\S]+/\n          }\n        },\n        {\n          pattern:\n            /(\"|')(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\#\\r\\n])*\\1/,\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            string: /[\\s\\S]+/\n          }\n        },\n        {\n          pattern: /<<[-~]?([a-z_]\\w*)[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,\n          alias: 'heredoc-string',\n          greedy: true,\n          inside: {\n            delimiter: {\n              pattern: /^<<[-~]?[a-z_]\\w*|\\b[a-z_]\\w*$/i,\n              inside: {\n                symbol: /\\b\\w+/,\n                punctuation: /^<<[-~]?/\n              }\n            },\n            interpolation: interpolation,\n            string: /[\\s\\S]+/\n          }\n        },\n        {\n          pattern: /<<[-~]?'([a-z_]\\w*)'[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,\n          alias: 'heredoc-string',\n          greedy: true,\n          inside: {\n            delimiter: {\n              pattern: /^<<[-~]?'[a-z_]\\w*'|\\b[a-z_]\\w*$/i,\n              inside: {\n                symbol: /\\b\\w+/,\n                punctuation: /^<<[-~]?'|'$/\n              }\n            },\n            string: /[\\s\\S]+/\n          }\n        }\n      ],\n      'command-literal': [\n        {\n          pattern: RegExp(/%x/.source + percentExpression),\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            command: {\n              pattern: /[\\s\\S]+/,\n              alias: 'string'\n            }\n          }\n        },\n        {\n          pattern: /`(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|[^\\\\`#\\r\\n])*`/,\n          greedy: true,\n          inside: {\n            interpolation: interpolation,\n            command: {\n              pattern: /[\\s\\S]+/,\n              alias: 'string'\n            }\n          }\n        }\n      ]\n    })\n    delete Prism.languages.ruby.string\n    Prism.languages.insertBefore('ruby', 'number', {\n      builtin:\n        /\\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\\b/,\n      constant: /\\b[A-Z][A-Z0-9_]*(?:[?!]|\\b)/\n    })\n    Prism.languages.rb = Prism.languages.ruby\n  })(Prism)\n}\n","// @ts-nocheck\nsql.displayName = 'sql'\nsql.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function sql(Prism) {\n  Prism.languages.sql = {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:--|\\/\\/|#).*)/,\n      lookbehind: true\n    },\n    variable: [\n      {\n        pattern: /@([\"'`])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])+\\1/,\n        greedy: true\n      },\n      /@[\\w.$]+/\n    ],\n    string: {\n      pattern: /(^|[^@\\\\])(\"|')(?:\\\\[\\s\\S]|(?!\\2)[^\\\\]|\\2\\2)*\\2/,\n      greedy: true,\n      lookbehind: true\n    },\n    identifier: {\n      pattern: /(^|[^@\\\\])`(?:\\\\[\\s\\S]|[^`\\\\]|``)*`/,\n      greedy: true,\n      lookbehind: true,\n      inside: {\n        punctuation: /^`|`$/\n      }\n    },\n    function:\n      /\\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\\s*\\()/i,\n    // Should we highlight user defined functions too?\n    keyword:\n      /\\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\\b/i,\n    boolean: /\\b(?:FALSE|NULL|TRUE)\\b/i,\n    number: /\\b0x[\\da-f]+\\b|\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+\\b/i,\n    operator:\n      /[-+*\\/=%^~]|&&?|\\|\\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\\b/i,\n    punctuation: /[;[\\]()`,.]/\n  }\n}\n","// @ts-nocheck\nimport refractorCss from './css.js'\nscss.displayName = 'scss'\nscss.aliases = []\n\n/** @type {import('../core.js').Syntax} */\nexport default function scss(Prism) {\n  Prism.register(refractorCss)\n  Prism.languages.scss = Prism.languages.extend('css', {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n      lookbehind: true\n    },\n    atrule: {\n      pattern: /@[\\w-](?:\\([^()]+\\)|[^()\\s]|\\s+(?!\\s))*?(?=\\s+[{;])/,\n      inside: {\n        rule: /@[\\w-]+/\n        // See rest below\n      }\n    },\n\n    // url, compassified\n    url: /(?:[-a-z]+-)?url(?=\\()/i,\n    // CSS selector regex is not appropriate for Sass\n    // since there can be lot more things (var, @ directive, nesting..)\n    // a selector must start at the end of a property or after a brace (end of other rules or nesting)\n    // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable\n    // the end of a selector is found when there is no rules in it ( {} or {\\s}) or if there is a property (because an interpolated var\n    // can \"pass\" as a selector- e.g: proper#{$erty})\n    // this one was hard to do, so please be careful if you edit this one :)\n    selector: {\n      // Initial look-ahead is used to prevent matching of blank selectors\n      pattern:\n        /(?=\\S)[^@;{}()]?(?:[^@;{}()\\s]|\\s+(?!\\s)|#\\{\\$[-\\w]+\\})+(?=\\s*\\{(?:\\}|\\s|[^}][^:{}]*[:{][^}]))/,\n      inside: {\n        parent: {\n          pattern: /&/,\n          alias: 'important'\n        },\n        placeholder: /%[-\\w]+/,\n        variable: /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n      }\n    },\n    property: {\n      pattern: /(?:[-\\w]|\\$[-\\w]|#\\{\\$[-\\w]+\\})+(?=\\s*:)/,\n      inside: {\n        variable: /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n      }\n    }\n  })\n  Prism.languages.insertBefore('scss', 'atrule', {\n    keyword: [\n      /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\\b/i,\n      {\n        pattern: /( )(?:from|through)(?= )/,\n        lookbehind: true\n      }\n    ]\n  })\n  Prism.languages.insertBefore('scss', 'important', {\n    // var and interpolated vars\n    variable: /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n  })\n  Prism.languages.insertBefore('scss', 'function', {\n    'module-modifier': {\n      pattern: /\\b(?:as|hide|show|with)\\b/i,\n      alias: 'keyword'\n    },\n    placeholder: {\n      pattern: /%[-\\w]+/,\n      alias: 'selector'\n    },\n    statement: {\n      pattern: /\\B!(?:default|optional)\\b/i,\n      alias: 'keyword'\n    },\n    boolean: /\\b(?:false|true)\\b/,\n    null: {\n      pattern: /\\bnull\\b/,\n      alias: 'keyword'\n    },\n    operator: {\n      pattern: /(\\s)(?:[-+*\\/%]|[=!]=|<=?|>=?|and|not|or)(?=\\s)/,\n      lookbehind: true\n    }\n  })\n  Prism.languages.scss['atrule'].inside.rest = Prism.languages.scss\n}\n"],"names":["uniqueId","plainTextGrammar","_","util","type","o","Object","prototype","toString","call","slice","objId","obj","defineProperty","value","clone","deepClone","visited","id","key","hasOwnProperty","forEach","v","i","languages","plain","plaintext","text","txt","extend","redef","lang","insertBefore","inside","before","insert","root","grammar","ret","token","newToken","old","DFS","this","callback","property","propertyType","plugins","highlight","language","env","code","hooks","run","Error","tokens","tokenize","Token","stringify","encode","rest","tokenList","LinkedList","addAfter","head","matchGrammar","list","array","node","next","tail","push","toArray","all","add","name","callbacks","length","content","alias","matchedStr","matchPattern","pattern","pos","lookbehind","lastIndex","match","exec","lookbehindLength","index","startNode","startPos","rematch","patterns","Array","isArray","j","cause","patternObj","greedy","global","flags","RegExp","source","currentNode","reach","str","removeCount","from","to","p","k","matchStr","after","removeFrom","prev","removeRange","nestedRematch","newNode","count","Prism","own","Refractor","refractor","TypeError","children","register","syntax","displayName","map","registered","aliasOrLanguage","listLanguages","result","undefined","tag","classes","attributes","h","join","attrs","parseEntities","scheme","comment","string","symbol","char","keyword","builtin","operator","number","replace","trim","SortedBNF","boolean","function","identifier","punctuation","aliases","textile","refractorMarkup","modifierRegex","parenthesesRegex","withModifier","modifierTokens","css","phrase","modifier","table","inline","bold","italic","cite","inserted","deleted","span","url","link","image","footnote","acronym","mark","phraseInside","nestedPatterns","phraseInlineInside","phraseTableInside","uri","fragment","query","pair","authority","port","host","path","scala","refractorJava","escape","interpolation","expression","stylus","unit","func","important","hexcode","color","entity","delimiter","atrule","variable","statement","selector","twig","refractorMarkupTemplating","buildPlaceholders","tokenizePlaceholders","qsharp","refractorClike","replacements","m","re","keywords","qualifiedName","typeInside","regularString","range","interpolationExpr","depthLog2","nested","qs","q","datetime","adverb","verb","qml","refractorJavascript","jsString","jsComment","jsExpr","javascript","qore","racket","refractorScheme","rkt","tsx","refractorJsx","refractorTypescript","typescript","reason","constructor","label","rego","namespace","renpy","rpy","rescript","constant","res","substitution","directive","title","hr","field","role","rip","regex","date","time","reference","roboconf","component","optional","wildcard","robotframework","createSection","extendecInside","docTag","testNameLike","testPropertyLike","settings","documentation","variables","tasks","robot","sas","stringPattern","numericConstant","macroVariable","macroKeyword","step","args","arg","format","equals","altformat","globalStatements","submitStatement","actionSets","casActions","action","argument","datalines","sql","groovy","lua","macro","input","shellSession","refractorBash","strings","command","info","user","bash","output","smali","smalltalk","smarty","php","smartyPattern","smartyLiteralMode","sml","word","smlnj","solidity","version","sol","solutionFile","guid","object","soy","numberPattern","parameter","soyLitteralMode","turtle","prefix","trig","sparql","refractorTurtle","rq","splunkSpl","sqf","squirrel","clike","lambda","stan","higherOrderFunctions","constraint","stata","refractorMata","refractorPython","mata","java","python","supercollider","sclang","systemd","quotesSource","section","quoted","t4Templating","createBlock","contentAlias","insideLang","className","block","standard","t4Cs","refractorCsharp","refractorT4Templating","t4","createT4","t4Vb","refractorVbnet","tap","refractorYaml","fail","pass","pragma","bailout","plan","subtest","yamlish","yaml","tcl","scope","tt2","toml","insertKey","tremor","extractor","interpolationPattern","troy","trickle","typoscript","tsconfig","unrealscript","category","metadata","uc","uscript","uorazor","attribute","generic","vala","velocity","unparsed","verilog","vhdl","vim","visualBasic","vb","vba","warpscript","wasm","webIdl","wgsl","functions","wiki","heading","emphasis","markup","nowiki","wolfram","context","blank","mathematica","wl","nb","wren","hashbang","null","xeora","xeoracube","xmlDoc","insertDocComment","docComment","slashDocComment","tickDocComment","xojo","xquery","extension","axis","stringifyToken","walkTokens","openedTags","notTagNorBrace","tagName","pop","openedBraces","plainText","splice","test","yang","zig","literal","IDENTIFIER","ALIGN","TYPE","abap","abnf","actionscript","ada","agda","al","antlr4","apacheconf","apex","apl","applescript","aql","c","cpp","arduino","arff","armasm","markdown","arturo","asciidoc","csharp","aspnet","asm6502","asmatmel","autohotkey","autoit","avisynth","avroIdl","awk","basic","batch","bbcode","bbj","bicep","birb","bison","bnf","bqn","brainfuck","brightscript","bro","bsl","cfscript","chaiscript","cil","cilkc","cilkcpp","clojure","cmake","cobol","coffeescript","concurnas","csp","cooklang","coq","ruby","crystal","cssExtras","csv","cue","cypher","d","dart","dataweave","dax","dhall","diff","markupTemplating","django","dnsZoneFile","docker","dot","ebnf","editorconfig","eiffel","ejs","elixir","elm","etlua","erb","erlang","excelFormula","fsharp","factor","$false","firestoreSecurityRules","flow","fortran","ftl","gml","gap","gcode","gdscript","gedcom","gettext","gherkin","git","glsl","gn","linkerScript","go","goModule","gradle","graphql","less","scss","haml","handlebars","haskell","haxe","hcl","hlsl","hoon","hpkp","hsts","json","http","ichigojam","icon","icuMessageFormat","idris","ignore","inform7","ini","io","javadoclike","javadoc","javastacktrace","jexl","jolie","jq","jsTemplates","jsdoc","n4js","jsExtras","json5","jsonp","jsstacktrace","julia","keepalived","keyman","kotlin","kumir","kusto","latex","latte","lilypond","liquid","lisp","livescript","llvm","log","lolcode","magma","makefile","matlab","maxscript","mel","mermaid","metafont","mizar","mongodb","monkey","moonscript","n1ql","nand2tetrisHdl","naniscript","nasm","neon","nevod","nginx","nim","nix","nsis","objectivec","ocaml","odin","opencl","openqasm","oz","parigp","parser","pascal","pascaligo","psl","pcaxis","peoplecode","perl","phpdoc","phpExtras","plantUml","plsql","powerquery","powershell","processing","prolog","promql","properties","protobuf","pug","puppet","pure","purebasic","purescript","r","cshtml","jsx","rust","sass","iecst","swift","vbnet","refractorBasic","nil","omit","rule","anchorOrAlias","plainKey","createValuePattern","scalar","yml","decorator","at","ts","multilineComment","ellipsis","specialEscape","rangeChar","groupName","backreference","anchor","group","quantifier","alternation","refractorCss","percentExpression","symbolName","rb","parent","placeholder"],"sourceRoot":""}