@instincthub/react-ui 0.0.3 → 0.0.5

package/dist/node_modules/refractor/lang/gn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gn.js","sources":["../../../../node_modules/refractor/lang/gn.js"],"sourcesContent":["'use strict'\n\nmodule.exports = gn\ngn.displayName = 'gn'\ngn.aliases = ['gni']\nfunction gn(Prism) {\n  // https://gn.googlesource.com/gn/+/refs/heads/main/docs/reference.md#grammar\n  Prism.languages.gn = {\n    comment: {\n      pattern: /#.*/,\n      greedy: true\n    },\n    'string-literal': {\n      pattern: /(^|[^\\\\\"])\"(?:[^\\r\\n\"\\\\]|\\\\.)*\"/,\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern:\n            /((?:^|[^\\\\])(?:\\\\{2})*)\\$(?:\\{[\\s\\S]*?\\}|[a-zA-Z_]\\w*|0x[a-fA-F0-9]{2})/,\n          lookbehind: true,\n          inside: {\n            number: /^\\$0x[\\s\\S]{2}$/,\n            variable: /^\\$\\w+$/,\n            'interpolation-punctuation': {\n              pattern: /^\\$\\{|\\}$/,\n              alias: 'punctuation'\n            },\n            expression: {\n              pattern: /[\\s\\S]+/,\n              inside: null // see below\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    },\n    keyword: /\\b(?:else|if)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    'builtin-function': {\n      // a few functions get special highlighting to improve readability\n      pattern:\n        /\\b(?:assert|defined|foreach|import|pool|print|template|tool|toolchain)(?=\\s*\\()/i,\n      alias: 'keyword'\n    },\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n    constant:\n      /\\b(?:current_cpu|current_os|current_toolchain|default_toolchain|host_cpu|host_os|root_build_dir|root_gen_dir|root_out_dir|target_cpu|target_gen_dir|target_os|target_out_dir)\\b/,\n    number: /-?\\b\\d+\\b/,\n    operator: /[-+!=<>]=?|&&|\\|\\|/,\n    punctuation: /[(){}[\\],.]/\n  }\n  Prism.languages.gn['string-literal'].inside['interpolation'].inside[\n    'expression'\n  ].inside = Prism.languages.gn\n  Prism.languages.gni = Prism.languages.gn\n}\n"],"names":["gn","Prism","languages","comment","pattern","greedy","lookbehind","inside","interpolation","number","variable","alias","expression","string","keyword","boolean","function","constant","operator","punctuation","gni","gn_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAGC,GAEVA,EAAMC,UAAUF,GAAK,CACnBG,QAAS,CACPC,QAAS,MACTC,QAAQ,GAEV,iBAAkB,CAChBD,QAAS,kCACTE,YAAY,EACZD,QAAQ,EACRE,OAAQ,CACNC,cAAe,CACbJ,QACE,0EACFE,YAAY,EACZC,OAAQ,CACNE,OAAQ,kBACRC,SAAU,UACV,4BAA6B,CAC3BN,QAAS,YACTO,MAAO,eAETC,WAAY,CACVR,QAAS,UACTG,OAAQ,QAIdM,OAAQ,YAGZC,QAAS,kBACTC,QAAS,qBACT,mBAAoB,CAElBX,QACE,mFACFO,MAAO,WAETK,SAAU,wBACVC,SACE,kLACFR,OAAQ,YACRS,SAAU,qBACVC,YAAa,eAEflB,EAAMC,UAAUF,GAAG,kBAAkBO,OAAsB,cAAEA,OAE/D,WAAIA,OAASN,EAAMC,UAAUF,GAC3BC,EAAMC,UAAUkB,IAAMnB,EAAMC,UAAUF,EACxC,YAtDAqB,EAAiBrB,EACjBA,EAAGsB,YAAc,KACjBtB,EAAGuB,QAAU,CAAC"}

package/dist/node_modules/refractor/lang/go-module.js

@@ -1,2 +0,0 @@
-var e,o;function r(){if(o)return e;function r(e){e.languages["go-mod"]=e.languages["go-module"]={comment:{pattern:/\/\/.*/,greedy:!0},version:{pattern:/(^|[\s()[\],])v\d+\.\d+\.\d+(?:[+-][-+.\w]*)?(?![^\s()[\],])/,lookbehind:!0,alias:"number"},"go-version":{pattern:/((?:^|\s)go\s+)\d+(?:\.\d+){1,2}/,lookbehind:!0,alias:"number"},keyword:{pattern:/^([ \t]*)(?:exclude|go|module|replace|require|retract)\b/m,lookbehind:!0},operator:/=>/,punctuation:/[()[\],]/}}return o=1,e=r,r.displayName="goModule",r.aliases=[],e}export{r as __require};
-//# sourceMappingURL=go-module.js.map

package/dist/node_modules/refractor/lang/go-module.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"go-module.js","sources":["../../../../node_modules/refractor/lang/go-module.js"],"sourcesContent":["'use strict'\n\nmodule.exports = goModule\ngoModule.displayName = 'goModule'\ngoModule.aliases = []\nfunction goModule(Prism) {\n  // https://go.dev/ref/mod#go-mod-file-module\n  Prism.languages['go-mod'] = Prism.languages['go-module'] = {\n    comment: {\n      pattern: /\\/\\/.*/,\n      greedy: true\n    },\n    version: {\n      pattern: /(^|[\\s()[\\],])v\\d+\\.\\d+\\.\\d+(?:[+-][-+.\\w]*)?(?![^\\s()[\\],])/,\n      lookbehind: true,\n      alias: 'number'\n    },\n    'go-version': {\n      pattern: /((?:^|\\s)go\\s+)\\d+(?:\\.\\d+){1,2}/,\n      lookbehind: true,\n      alias: 'number'\n    },\n    keyword: {\n      pattern: /^([ \\t]*)(?:exclude|go|module|replace|require|retract)\\b/m,\n      lookbehind: true\n    },\n    operator: /=>/,\n    punctuation: /[()[\\],]/\n  }\n}\n"],"names":["goModule","Prism","languages","comment","pattern","greedy","version","lookbehind","alias","keyword","operator","punctuation","goModule_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAASC,GAEhBA,EAAMC,UAAU,UAAYD,EAAMC,UAAU,aAAe,CACzDC,QAAS,CACPC,QAAS,SACTC,QAAQ,GAEVC,QAAS,CACPF,QAAS,+DACTG,YAAY,EACZC,MAAO,UAET,aAAc,CACZJ,QAAS,mCACTG,YAAY,EACZC,MAAO,UAETC,QAAS,CACPL,QAAS,4DACTG,YAAY,GAEdG,SAAU,KACVC,YAAa,WAEjB,YA3BAC,EAAiBZ,EACjBA,EAASa,YAAc,WACvBb,EAASc,QAAU"}

package/dist/node_modules/refractor/lang/go.js

@@ -1,2 +0,0 @@
-var e,r;function a(){if(r)return e;function a(e){e.languages.go=e.languages.extend("clike",{string:{pattern:/(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,lookbehind:!0,greedy:!0},keyword:/\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,boolean:/\b(?:_|false|iota|nil|true)\b/,number:[/\b0(?:b[01_]+|o[0-7_]+)i?\b/i,/\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,/(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i],operator:/[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,builtin:/\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/}),e.languages.insertBefore("go","string",{char:{pattern:/'(?:\\.|[^'\\\r\n]){0,10}'/,greedy:!0}}),delete e.languages.go["class-name"]}return r=1,e=a,a.displayName="go",a.aliases=[],e}export{a as __require};
-//# sourceMappingURL=go.js.map

package/dist/node_modules/refractor/lang/go.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"go.js","sources":["../../../../node_modules/refractor/lang/go.js"],"sourcesContent":["'use strict'\n\nmodule.exports = go\ngo.displayName = 'go'\ngo.aliases = []\nfunction go(Prism) {\n  Prism.languages.go = Prism.languages.extend('clike', {\n    string: {\n      pattern: /(^|[^\\\\])\"(?:\\\\.|[^\"\\\\\\r\\n])*\"|`[^`]*`/,\n      lookbehind: true,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\\b/,\n    boolean: /\\b(?:_|false|iota|nil|true)\\b/,\n    number: [\n      // binary and octal integers\n      /\\b0(?:b[01_]+|o[0-7_]+)i?\\b/i, // hexadecimal integers and floats\n      /\\b0x(?:[a-f\\d_]+(?:\\.[a-f\\d_]*)?|\\.[a-f\\d_]+)(?:p[+-]?\\d+(?:_\\d+)*)?i?(?!\\w)/i, // decimal integers and floats\n      /(?:\\b\\d[\\d_]*(?:\\.[\\d_]*)?|\\B\\.\\d[\\d_]*)(?:e[+-]?[\\d_]+)?i?(?!\\w)/i\n    ],\n    operator:\n      /[*\\/%^!=]=?|\\+[=+]?|-[=-]?|\\|[=|]?|&(?:=|&|\\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\\.\\.\\./,\n    builtin:\n      /\\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\\b/\n  })\n  Prism.languages.insertBefore('go', 'string', {\n    char: {\n      pattern: /'(?:\\\\.|[^'\\\\\\r\\n]){0,10}'/,\n      greedy: true\n    }\n  })\n  delete Prism.languages.go['class-name']\n}\n"],"names":["go","Prism","languages","extend","string","pattern","lookbehind","greedy","keyword","boolean","number","operator","builtin","insertBefore","char","go_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAGC,GACVA,EAAMC,UAAUF,GAAKC,EAAMC,UAAUC,OAAO,QAAS,CACnDC,OAAQ,CACNC,QAAS,yCACTC,YAAY,EACZC,QAAQ,GAEVC,QACE,sKACFC,QAAS,gCACTC,OAAQ,CAEN,+BACA,gFACA,sEAEFC,SACE,wFACFC,QACE,6LAEJX,EAAMC,UAAUW,aAAa,KAAM,SAAU,CAC3CC,KAAM,CACJT,QAAS,6BACTE,QAAQ,YAGLN,EAAMC,UAAUF,GAAG,aAC5B,YA/BAe,EAAiBf,EACjBA,EAAGgB,YAAc,KACjBhB,EAAGiB,QAAU"}

package/dist/node_modules/refractor/lang/graphql.js

@@ -1,2 +0,0 @@
-var n,t;function e(){if(t)return n;function e(n){n.languages.graphql={comment:/#.*/,description:{pattern:/(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,greedy:!0,alias:"string",inside:{"language-markdown":{pattern:/(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,lookbehind:!0,inside:n.languages.markdown}}},string:{pattern:/"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,greedy:!0},number:/(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,boolean:/\b(?:false|true)\b/,variable:/\$[a-z_]\w*/i,directive:{pattern:/@[a-z_]\w*/i,alias:"function"},"attr-name":{pattern:/\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,greedy:!0},"atom-input":{pattern:/\b[A-Z]\w*Input\b/,alias:"class-name"},scalar:/\b(?:Boolean|Float|ID|Int|String)\b/,constant:/\b[A-Z][A-Z_\d]*\b/,"class-name":{pattern:/(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,lookbehind:!0},fragment:{pattern:/(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,lookbehind:!0,alias:"function"},"definition-mutation":{pattern:/(\bmutation\s+)[a-zA-Z_]\w*/,lookbehind:!0,alias:"function"},"definition-query":{pattern:/(\bquery\s+)[a-zA-Z_]\w*/,lookbehind:!0,alias:"function"},keyword:/\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,operator:/[!=|&]|\.{3}/,"property-query":/\w+(?=\s*\()/,object:/\w+(?=\s*\{)/,punctuation:/[!(){}\[\]:=,]/,property:/\w+/},n.hooks.add("after-tokenize",(function(n){if("graphql"===n.language)for(var t=n.tokens.filter((function(n){return"string"!=typeof n&&"comment"!==n.type&&"scalar"!==n.type})),e=0;e<t.length;){var a=t[e++];if("keyword"===a.type&&"mutation"===a.content){var r=[];if(f(["definition-mutation","punctuation"])&&"("===l(1).content){e+=2;var i=c(/^\($/,/^\)$/);if(-1===i)continue;for(;e<i;e++){var o=l(0);"variable"===o.type&&(b(o,"variable-input"),r.push(o.content))}e=i+1}if(f(["punctuation","property-query"])&&"{"===l(0).content&&(e++,b(l(0),"property-mutation"),r.length>0)){var u=c(/^\{$/,/^\}$/);if(-1===u)continue;for(var s=e;s<u;s++){var p=t[s];"variable"===p.type&&r.indexOf(p.content)>=0&&b(p,"variable-input")}}}}function l(n){return t[e+n]}function f(n,t){t=t||0;for(var e=0;e<n.length;e++){var a=l(e+t);if(!a||a.type!==n[e])return!1}return!0}function c(n,a){for(var r=1,i=e;i<t.length;i++){var o=t[i],u=o.content;if("punctuation"===o.type&&"string"==typeof u)if(n.test(u))r++;else if(a.test(u)&&0===--r)return i}return-1}function b(n,t){var e=n.alias;e?Array.isArray(e)||(n.alias=e=[e]):n.alias=e=[],e.push(t)}}))}return t=1,n=e,e.displayName="graphql",e.aliases=[],n}export{e as __require};
-//# sourceMappingURL=graphql.js.map

package/dist/node_modules/refractor/lang/graphql.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphql.js","sources":["../../../../node_modules/refractor/lang/graphql.js"],"sourcesContent":["'use strict'\n\nmodule.exports = graphql\ngraphql.displayName = 'graphql'\ngraphql.aliases = []\nfunction graphql(Prism) {\n  Prism.languages.graphql = {\n    comment: /#.*/,\n    description: {\n      pattern:\n        /(?:\"\"\"(?:[^\"]|(?!\"\"\")\")*\"\"\"|\"(?:\\\\.|[^\\\\\"\\r\\n])*\")(?=\\s*[a-z_])/i,\n      greedy: true,\n      alias: 'string',\n      inside: {\n        'language-markdown': {\n          pattern: /(^\"(?:\"\")?)(?!\\1)[\\s\\S]+(?=\\1$)/,\n          lookbehind: true,\n          inside: Prism.languages.markdown\n        }\n      }\n    },\n    string: {\n      pattern: /\"\"\"(?:[^\"]|(?!\"\"\")\")*\"\"\"|\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n      greedy: true\n    },\n    number: /(?:\\B-|\\b)\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?\\b/i,\n    boolean: /\\b(?:false|true)\\b/,\n    variable: /\\$[a-z_]\\w*/i,\n    directive: {\n      pattern: /@[a-z_]\\w*/i,\n      alias: 'function'\n    },\n    'attr-name': {\n      pattern: /\\b[a-z_]\\w*(?=\\s*(?:\\((?:[^()\"]|\"(?:\\\\.|[^\\\\\"\\r\\n])*\")*\\))?:)/i,\n      greedy: true\n    },\n    'atom-input': {\n      pattern: /\\b[A-Z]\\w*Input\\b/,\n      alias: 'class-name'\n    },\n    scalar: /\\b(?:Boolean|Float|ID|Int|String)\\b/,\n    constant: /\\b[A-Z][A-Z_\\d]*\\b/,\n    'class-name': {\n      pattern:\n        /(\\b(?:enum|implements|interface|on|scalar|type|union)\\s+|&\\s*|:\\s*|\\[)[A-Z_]\\w*/,\n      lookbehind: true\n    },\n    fragment: {\n      pattern: /(\\bfragment\\s+|\\.{3}\\s*(?!on\\b))[a-zA-Z_]\\w*/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    'definition-mutation': {\n      pattern: /(\\bmutation\\s+)[a-zA-Z_]\\w*/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    'definition-query': {\n      pattern: /(\\bquery\\s+)[a-zA-Z_]\\w*/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    keyword:\n      /\\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\\b/,\n    operator: /[!=|&]|\\.{3}/,\n    'property-query': /\\w+(?=\\s*\\()/,\n    object: /\\w+(?=\\s*\\{)/,\n    punctuation: /[!(){}\\[\\]:=,]/,\n    property: /\\w+/\n  }\n  Prism.hooks.add('after-tokenize', function afterTokenizeGraphql(env) {\n    if (env.language !== 'graphql') {\n      return\n    }\n    /**\n     * get the graphql token stream that we want to customize\n     *\n     * @typedef {InstanceType<import(\"./prism-core\")[\"Token\"]>} Token\n     * @type {Token[]}\n     */\n    var validTokens = env.tokens.filter(function (token) {\n      return (\n        typeof token !== 'string' &&\n        token.type !== 'comment' &&\n        token.type !== 'scalar'\n      )\n    })\n    var currentIndex = 0\n    /**\n     * Returns whether the token relative to the current index has the given type.\n     *\n     * @param {number} offset\n     * @returns {Token | undefined}\n     */\n    function getToken(offset) {\n      return validTokens[currentIndex + offset]\n    }\n    /**\n     * Returns whether the token relative to the current index has the given type.\n     *\n     * @param {readonly string[]} types\n     * @param {number} [offset=0]\n     * @returns {boolean}\n     */\n    function isTokenType(types, offset) {\n      offset = offset || 0\n      for (var i = 0; i < types.length; i++) {\n        var token = getToken(i + offset)\n        if (!token || token.type !== types[i]) {\n          return false\n        }\n      }\n      return true\n    }\n    /**\n     * Returns the index of the closing bracket to an opening bracket.\n     *\n     * It is assumed that `token[currentIndex - 1]` is an opening bracket.\n     *\n     * If no closing bracket could be found, `-1` will be returned.\n     *\n     * @param {RegExp} open\n     * @param {RegExp} close\n     * @returns {number}\n     */\n    function findClosingBracket(open, close) {\n      var stackHeight = 1\n      for (var i = currentIndex; i < validTokens.length; i++) {\n        var token = validTokens[i]\n        var content = token.content\n        if (token.type === 'punctuation' && typeof content === 'string') {\n          if (open.test(content)) {\n            stackHeight++\n          } else if (close.test(content)) {\n            stackHeight--\n            if (stackHeight === 0) {\n              return i\n            }\n          }\n        }\n      }\n      return -1\n    }\n    /**\n     * Adds an alias to the given token.\n     *\n     * @param {Token} token\n     * @param {string} alias\n     * @returns {void}\n     */\n    function addAlias(token, alias) {\n      var aliases = token.alias\n      if (!aliases) {\n        token.alias = aliases = []\n      } else if (!Array.isArray(aliases)) {\n        token.alias = aliases = [aliases]\n      }\n      aliases.push(alias)\n    }\n    for (; currentIndex < validTokens.length; ) {\n      var startToken = validTokens[currentIndex++] // add special aliases for mutation tokens\n      if (startToken.type === 'keyword' && startToken.content === 'mutation') {\n        // any array of the names of all input variables (if any)\n        var inputVariables = []\n        if (\n          isTokenType(['definition-mutation', 'punctuation']) &&\n          getToken(1).content === '('\n        ) {\n          // definition\n          currentIndex += 2 // skip 'definition-mutation' and 'punctuation'\n          var definitionEnd = findClosingBracket(/^\\($/, /^\\)$/)\n          if (definitionEnd === -1) {\n            continue\n          } // find all input variables\n          for (; currentIndex < definitionEnd; currentIndex++) {\n            var t = getToken(0)\n            if (t.type === 'variable') {\n              addAlias(t, 'variable-input')\n              inputVariables.push(t.content)\n            }\n          }\n          currentIndex = definitionEnd + 1\n        }\n        if (\n          isTokenType(['punctuation', 'property-query']) &&\n          getToken(0).content === '{'\n        ) {\n          currentIndex++ // skip opening bracket\n          addAlias(getToken(0), 'property-mutation')\n          if (inputVariables.length > 0) {\n            var mutationEnd = findClosingBracket(/^\\{$/, /^\\}$/)\n            if (mutationEnd === -1) {\n              continue\n            } // give references to input variables a special alias\n            for (var i = currentIndex; i < mutationEnd; i++) {\n              var varToken = validTokens[i]\n              if (\n                varToken.type === 'variable' &&\n                inputVariables.indexOf(varToken.content) >= 0\n              ) {\n                addAlias(varToken, 'variable-input')\n              }\n            }\n          }\n        }\n      }\n    }\n  })\n}\n"],"names":["graphql","Prism","languages","comment","description","pattern","greedy","alias","inside","lookbehind","markdown","string","number","boolean","variable","directive","scalar","constant","fragment","keyword","operator","object","punctuation","property","hooks","add","env","language","validTokens","tokens","filter","token","type","currentIndex","length","startToken","content","inputVariables","isTokenType","getToken","definitionEnd","findClosingBracket","t","addAlias","push","mutationEnd","i","varToken","indexOf","offset","types","open","close","stackHeight","test","aliases","Array","isArray","graphql_1","displayName"],"mappings":"mCAKA,SAASA,EAAQC,GACfA,EAAMC,UAAUF,QAAU,CACxBG,QAAS,MACTC,YAAa,CACXC,QACE,mEACFC,QAAQ,EACRC,MAAO,SACPC,OAAQ,CACN,oBAAqB,CACnBH,QAAS,kCACTI,YAAY,EACZD,OAAQP,EAAMC,UAAUQ,YAI9BC,OAAQ,CACNN,QAAS,iDACTC,QAAQ,GAEVM,OAAQ,2CACRC,QAAS,qBACTC,SAAU,eACVC,UAAW,CACTV,QAAS,cACTE,MAAO,YAET,YAAa,CACXF,QAAS,iEACTC,QAAQ,GAEV,aAAc,CACZD,QAAS,oBACTE,MAAO,cAETS,OAAQ,sCACRC,SAAU,qBACV,aAAc,CACZZ,QACE,kFACFI,YAAY,GAEdS,SAAU,CACRb,QAAS,+CACTI,YAAY,EACZF,MAAO,YAET,sBAAuB,CACrBF,QAAS,8BACTI,YAAY,EACZF,MAAO,YAET,mBAAoB,CAClBF,QAAS,2BACTI,YAAY,EACZF,MAAO,YAETY,QACE,uIACFC,SAAU,eACV,iBAAkB,eAClBC,OAAQ,eACRC,YAAa,iBACbC,SAAU,OAEZtB,EAAMuB,MAAMC,IAAI,kBAAkB,SAA8BC,GAC9D,GAAqB,YAAjBA,EAAIC,SAwFR,IA/EA,IAAIC,EAAcF,EAAIG,OAAOC,QAAO,SAAUC,GAC5C,MACmB,iBAAVA,GACQ,YAAfA,EAAMC,MACS,WAAfD,EAAMC,IAEd,IACQC,EAAe,EAwEZA,EAAeL,EAAYM,QAAU,CAC1C,IAAIC,EAAaP,EAAYK,KAC7B,GAAwB,YAApBE,EAAWH,MAA6C,aAAvBG,EAAWC,QAAwB,CAEtE,IAAIC,EAAiB,GACrB,GACEC,EAAY,CAAC,sBAAuB,iBACZ,MAAxBC,EAAS,GAAGH,QACZ,CAEAH,GAAgB,EAChB,IAAIO,EAAgBC,EAAmB,OAAQ,QAC/C,IAAuB,IAAnBD,EACF,SAEF,KAAOP,EAAeO,EAAeP,IAAgB,CACnD,IAAIS,EAAIH,EAAS,GACF,aAAXG,EAAEV,OACJW,EAASD,EAAG,kBACZL,EAAeO,KAAKF,EAAEN,SAEzB,CACDH,EAAeO,EAAgB,CAChC,CACD,GACEF,EAAY,CAAC,cAAe,oBACJ,MAAxBC,EAAS,GAAGH,UAEZH,IACAU,EAASJ,EAAS,GAAI,qBAClBF,EAAeH,OAAS,GAAG,CAC7B,IAAIW,EAAcJ,EAAmB,OAAQ,QAC7C,IAAqB,IAAjBI,EACF,SAEF,IAAK,IAAIC,EAAIb,EAAca,EAAID,EAAaC,IAAK,CAC/C,IAAIC,EAAWnB,EAAYkB,GAEP,aAAlBC,EAASf,MACTK,EAAeW,QAAQD,EAASX,UAAY,GAE5CO,EAASI,EAAU,iBAEtB,CACF,CAEJ,CACF,CAhHD,SAASR,EAASU,GAChB,OAAOrB,EAAYK,EAAegB,EACnC,CAQD,SAASX,EAAYY,EAAOD,GAC1BA,EAASA,GAAU,EACnB,IAAK,IAAIH,EAAI,EAAGA,EAAII,EAAMhB,OAAQY,IAAK,CACrC,IAAIf,EAAQQ,EAASO,EAAIG,GACzB,IAAKlB,GAASA,EAAMC,OAASkB,EAAMJ,GACjC,OAAO,CAEV,CACD,OAAO,CACR,CAYD,SAASL,EAAmBU,EAAMC,GAEhC,IADA,IAAIC,EAAc,EACTP,EAAIb,EAAca,EAAIlB,EAAYM,OAAQY,IAAK,CACtD,IAAIf,EAAQH,EAAYkB,GACpBV,EAAUL,EAAMK,QACpB,GAAmB,gBAAfL,EAAMC,MAA6C,iBAAZI,EACzC,GAAIe,EAAKG,KAAKlB,GACZiB,SACK,GAAID,EAAME,KAAKlB,IAEA,MADpBiB,EAEE,OAAOP,CAId,CACD,OAAQ,CACT,CAQD,SAASH,EAASZ,EAAOxB,GACvB,IAAIgD,EAAUxB,EAAMxB,MACfgD,EAEOC,MAAMC,QAAQF,KACxBxB,EAAMxB,MAAQgD,EAAU,CAACA,IAFzBxB,EAAMxB,MAAQgD,EAAU,GAI1BA,EAAQX,KAAKrC,EACd,CAiDL,GACA,YA9MAmD,EAAiB1D,EACjBA,EAAQ2D,YAAc,UACtB3D,EAAQuD,QAAU"}

package/dist/node_modules/refractor/lang/groovy.js

@@ -1,2 +0,0 @@
-var e,t;function n(){if(t)return e;function n(e){e.languages.groovy=e.languages.extend("clike",{string:[{pattern:/("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,greedy:!0},{pattern:/(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,greedy:!0}],keyword:/\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,number:/\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,operator:{pattern:/(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,lookbehind:!0},punctuation:/\.+|[{}[\];(),:$]/}),e.languages.insertBefore("groovy","string",{shebang:{pattern:/#!.+/,alias:"comment"}}),e.languages.insertBefore("groovy","punctuation",{"spock-block":/\b(?:and|cleanup|expect|given|setup|then|when|where):/}),e.languages.insertBefore("groovy","function",{annotation:{pattern:/(^|[^.])@\w+/,lookbehind:!0,alias:"punctuation"}}),e.hooks.add("wrap",(function(t){if("groovy"===t.language&&"string"===t.type){var n=t.content.value[0];if("'"!=n){var a=/([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;"$"===n&&(a=/([^\$])(?:\$(?:\{.*?\}|[\w.]+))/),t.content.value=t.content.value.replace(/&lt;/g,"<").replace(/&amp;/g,"&"),t.content=e.highlight(t.content.value,{expression:{pattern:a,lookbehind:!0,inside:e.languages.groovy}}),t.classes.push("/"===n?"regex":"gstring")}}}))}return t=1,e=n,n.displayName="groovy",n.aliases=[],e}export{n as __require};
-//# sourceMappingURL=groovy.js.map

package/dist/node_modules/refractor/lang/groovy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"groovy.js","sources":["../../../../node_modules/refractor/lang/groovy.js"],"sourcesContent":["'use strict'\n\nmodule.exports = groovy\ngroovy.displayName = 'groovy'\ngroovy.aliases = []\nfunction groovy(Prism) {\n  Prism.languages.groovy = Prism.languages.extend('clike', {\n    string: [\n      {\n        // https://groovy-lang.org/syntax.html#_dollar_slashy_string\n        pattern:\n          /(\"\"\"|''')(?:[^\\\\]|\\\\[\\s\\S])*?\\1|\\$\\/(?:[^/$]|\\$(?:[/$]|(?![/$]))|\\/(?!\\$))*\\/\\$/,\n        greedy: true\n      },\n      {\n        // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with\n        // simple division (see JS regex), so find a fix maybe?\n        pattern: /([\"'/])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n        greedy: true\n      }\n    ],\n    keyword:\n      /\\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\\b/,\n    number:\n      /\\b(?:0b[01_]+|0x[\\da-f_]+(?:\\.[\\da-f_p\\-]+)?|[\\d_]+(?:\\.[\\d_]+)?(?:e[+-]?\\d+)?)[glidf]?\\b/i,\n    operator: {\n      pattern:\n        /(^|[^.])(?:~|==?~?|\\?[.:]?|\\*(?:[.=]|\\*=?)?|\\.[@&]|\\.\\.<|\\.\\.(?!\\.)|-[-=>]?|\\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\\|[|=]?|\\/=?|\\^=?|%=?)/,\n      lookbehind: true\n    },\n    punctuation: /\\.+|[{}[\\];(),:$]/\n  })\n  Prism.languages.insertBefore('groovy', 'string', {\n    shebang: {\n      pattern: /#!.+/,\n      alias: 'comment'\n    }\n  })\n  Prism.languages.insertBefore('groovy', 'punctuation', {\n    'spock-block': /\\b(?:and|cleanup|expect|given|setup|then|when|where):/\n  })\n  Prism.languages.insertBefore('groovy', 'function', {\n    annotation: {\n      pattern: /(^|[^.])@\\w+/,\n      lookbehind: true,\n      alias: 'punctuation'\n    }\n  }) // Handle string interpolation\n  Prism.hooks.add('wrap', function (env) {\n    if (env.language === 'groovy' && env.type === 'string') {\n      var delimiter = env.content.value[0]\n      if (delimiter != \"'\") {\n        var pattern = /([^\\\\])(?:\\$(?:\\{.*?\\}|[\\w.]+))/\n        if (delimiter === '$') {\n          pattern = /([^\\$])(?:\\$(?:\\{.*?\\}|[\\w.]+))/\n        } // To prevent double HTML-encoding we have to decode env.content first\n        env.content.value = env.content.value\n          .replace(/&lt;/g, '<')\n          .replace(/&amp;/g, '&')\n        env.content = Prism.highlight(env.content.value, {\n          expression: {\n            pattern: pattern,\n            lookbehind: true,\n            inside: Prism.languages.groovy\n          }\n        })\n        env.classes.push(delimiter === '/' ? 'regex' : 'gstring')\n      }\n    }\n  })\n}\n"],"names":["groovy","Prism","languages","extend","string","pattern","greedy","keyword","number","operator","lookbehind","punctuation","insertBefore","shebang","alias","annotation","hooks","add","env","language","type","delimiter","content","value","replace","highlight","expression","inside","classes","push","groovy_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAOC,GACdA,EAAMC,UAAUF,OAASC,EAAMC,UAAUC,OAAO,QAAS,CACvDC,OAAQ,CACN,CAEEC,QACE,kFACFC,QAAQ,GAEV,CAGED,QAAS,oCACTC,QAAQ,IAGZC,QACE,6WACFC,OACE,6FACFC,SAAU,CACRJ,QACE,oJACFK,YAAY,GAEdC,YAAa,sBAEfV,EAAMC,UAAUU,aAAa,SAAU,SAAU,CAC/CC,QAAS,CACPR,QAAS,OACTS,MAAO,aAGXb,EAAMC,UAAUU,aAAa,SAAU,cAAe,CACpD,cAAe,0DAEjBX,EAAMC,UAAUU,aAAa,SAAU,WAAY,CACjDG,WAAY,CACVV,QAAS,eACTK,YAAY,EACZI,MAAO,iBAGXb,EAAMe,MAAMC,IAAI,QAAQ,SAAUC,GAChC,GAAqB,WAAjBA,EAAIC,UAAsC,WAAbD,EAAIE,KAAmB,CACtD,IAAIC,EAAYH,EAAII,QAAQC,MAAM,GAClC,GAAiB,KAAbF,EAAkB,CACpB,IAAIhB,EAAU,kCACI,MAAdgB,IACFhB,EAAU,mCAEZa,EAAII,QAAQC,MAAQL,EAAII,QAAQC,MAC7BC,QAAQ,QAAS,KACjBA,QAAQ,SAAU,KACrBN,EAAII,QAAUrB,EAAMwB,UAAUP,EAAII,QAAQC,MAAO,CAC/CG,WAAY,CACVrB,QAASA,EACTK,YAAY,EACZiB,OAAQ1B,EAAMC,UAAUF,UAG5BkB,EAAIU,QAAQC,KAAmB,MAAdR,EAAoB,QAAU,UAChD,CACF,CACL,GACA,YApEAS,EAAiB9B,EACjBA,EAAO+B,YAAc,SACrB/B,EAAOgC,QAAU"}

package/dist/node_modules/refractor/lang/haml.js

@@ -1,2 +0,0 @@
-import{__require as e}from"./ruby.js";var n,t;function r(){if(t)return n;t=1;var r=e();function a(e){e.register(r),function(e){e.languages.haml={"multiline-comment":{pattern:/((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,lookbehind:!0,alias:"comment"},"multiline-code":[{pattern:/((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,lookbehind:!0,inside:e.languages.ruby},{pattern:/((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,lookbehind:!0,inside:e.languages.ruby}],filter:{pattern:/((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,lookbehind:!0,inside:{"filter-name":{pattern:/^:[\w-]+/,alias:"symbol"}}},markup:{pattern:/((?:^|\r?\n|\r)[\t ]*)<.+/,lookbehind:!0,inside:e.languages.markup},doctype:{pattern:/((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,lookbehind:!0},tag:{pattern:/((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,lookbehind:!0,inside:{attributes:[{pattern:/(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,lookbehind:!0,inside:e.languages.ruby},{pattern:/\([^)]+\)/,inside:{"attr-value":{pattern:/(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,lookbehind:!0},"attr-name":/[\w:-]+(?=\s*!?=|\s*[,)])/,punctuation:/[=(),]/}},{pattern:/\[[^\]]+\]/,inside:e.languages.ruby}],punctuation:/[<>]/}},code:{pattern:/((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,lookbehind:!0,inside:e.languages.ruby},interpolation:{pattern:/#\{[^}]+\}/,inside:{delimiter:{pattern:/^#\{|\}$/,alias:"punctuation"},ruby:{pattern:/[\s\S]+/,inside:e.languages.ruby}}},punctuation:{pattern:/((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,lookbehind:!0}};for(var n=["css",{filter:"coffee",language:"coffeescript"},"erb","javascript","less","markdown","ruby","scss","textile"],t={},r=0,a=n.length;r<a;r++){var i=n[r];i="string"==typeof i?{filter:i,language:i}:i,e.languages[i.language]&&(t["filter-"+i.filter]={pattern:RegExp("((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+".replace("{{filter_name}}",(function(){return i.filter}))),lookbehind:!0,inside:{"filter-name":{pattern:/^:[\w-]+/,alias:"symbol"},text:{pattern:/[\s\S]+/,alias:[i.language,"language-"+i.language],inside:e.languages[i.language]}}})}e.languages.insertBefore("haml","filter",t)}(e)}return n=a,a.displayName="haml",a.aliases=[],n}export{r as __require};
-//# sourceMappingURL=haml.js.map

package/dist/node_modules/refractor/lang/haml.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"haml.js","sources":["../../../../node_modules/refractor/lang/haml.js"],"sourcesContent":["'use strict'\nvar refractorRuby = require('./ruby.js')\nmodule.exports = haml\nhaml.displayName = 'haml'\nhaml.aliases = []\nfunction haml(Prism) {\n  Prism.register(refractorRuby)\n  /* TODO\nHandle multiline code after tag\n%foo= some |\nmultiline |\ncode |\n*/\n  ;(function (Prism) {\n    Prism.languages.haml = {\n      // Multiline stuff should appear before the rest\n      'multiline-comment': {\n        pattern:\n          /((?:^|\\r?\\n|\\r)([\\t ]*))(?:\\/|-#).*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)*/,\n        lookbehind: true,\n        alias: 'comment'\n      },\n      'multiline-code': [\n        {\n          pattern:\n            /((?:^|\\r?\\n|\\r)([\\t ]*)(?:[~-]|[&!]?=)).*,[\\t ]*(?:(?:\\r?\\n|\\r)\\2[\\t ].*,[\\t ]*)*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        },\n        {\n          pattern:\n            /((?:^|\\r?\\n|\\r)([\\t ]*)(?:[~-]|[&!]?=)).*\\|[\\t ]*(?:(?:\\r?\\n|\\r)\\2[\\t ].*\\|[\\t ]*)*/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        }\n      ],\n      // See at the end of the file for known filters\n      filter: {\n        pattern:\n          /((?:^|\\r?\\n|\\r)([\\t ]*)):[\\w-]+(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/,\n        lookbehind: true,\n        inside: {\n          'filter-name': {\n            pattern: /^:[\\w-]+/,\n            alias: 'symbol'\n          }\n        }\n      },\n      markup: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)<.+/,\n        lookbehind: true,\n        inside: Prism.languages.markup\n      },\n      doctype: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)!!!(?: .+)?/,\n        lookbehind: true\n      },\n      tag: {\n        // Allows for one nested group of braces\n        pattern:\n          /((?:^|\\r?\\n|\\r)[\\t ]*)[%.#][\\w\\-#.]*[\\w\\-](?:\\([^)]+\\)|\\{(?:\\{[^}]+\\}|[^{}])+\\}|\\[[^\\]]+\\])*[\\/<>]*/,\n        lookbehind: true,\n        inside: {\n          attributes: [\n            {\n              // Lookbehind tries to prevent interpolations from breaking it all\n              // Allows for one nested group of braces\n              pattern: /(^|[^#])\\{(?:\\{[^}]+\\}|[^{}])+\\}/,\n              lookbehind: true,\n              inside: Prism.languages.ruby\n            },\n            {\n              pattern: /\\([^)]+\\)/,\n              inside: {\n                'attr-value': {\n                  pattern: /(=\\s*)(?:\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|[^)\\s]+)/,\n                  lookbehind: true\n                },\n                'attr-name': /[\\w:-]+(?=\\s*!?=|\\s*[,)])/,\n                punctuation: /[=(),]/\n              }\n            },\n            {\n              pattern: /\\[[^\\]]+\\]/,\n              inside: Prism.languages.ruby\n            }\n          ],\n          punctuation: /[<>]/\n        }\n      },\n      code: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*(?:[~-]|[&!]?=)).+/,\n        lookbehind: true,\n        inside: Prism.languages.ruby\n      },\n      // Interpolations in plain text\n      interpolation: {\n        pattern: /#\\{[^}]+\\}/,\n        inside: {\n          delimiter: {\n            pattern: /^#\\{|\\}$/,\n            alias: 'punctuation'\n          },\n          ruby: {\n            pattern: /[\\s\\S]+/,\n            inside: Prism.languages.ruby\n          }\n        }\n      },\n      punctuation: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)[~=\\-&!]+/,\n        lookbehind: true\n      }\n    }\n    var filter_pattern =\n      '((?:^|\\\\r?\\\\n|\\\\r)([\\\\t ]*)):{{filter_name}}(?:(?:\\\\r?\\\\n|\\\\r)(?:\\\\2[\\\\t ].+|\\\\s*?(?=\\\\r?\\\\n|\\\\r)))+' // Non exhaustive list of available filters and associated languages\n    var filters = [\n      'css',\n      {\n        filter: 'coffee',\n        language: 'coffeescript'\n      },\n      'erb',\n      'javascript',\n      'less',\n      'markdown',\n      'ruby',\n      'scss',\n      'textile'\n    ]\n    var all_filters = {}\n    for (var i = 0, l = filters.length; i < l; i++) {\n      var filter = filters[i]\n      filter =\n        typeof filter === 'string'\n          ? {\n              filter: filter,\n              language: filter\n            }\n          : filter\n      if (Prism.languages[filter.language]) {\n        all_filters['filter-' + filter.filter] = {\n          pattern: RegExp(\n            filter_pattern.replace('{{filter_name}}', function () {\n              return filter.filter\n            })\n          ),\n          lookbehind: true,\n          inside: {\n            'filter-name': {\n              pattern: /^:[\\w-]+/,\n              alias: 'symbol'\n            },\n            text: {\n              pattern: /[\\s\\S]+/,\n              alias: [filter.language, 'language-' + filter.language],\n              inside: Prism.languages[filter.language]\n            }\n          }\n        }\n      }\n    }\n    Prism.languages.insertBefore('haml', 'filter', all_filters)\n  })(Prism)\n}\n"],"names":["refractorRuby","require$$0","haml","Prism","register","languages","pattern","lookbehind","alias","inside","ruby","filter","markup","doctype","tag","attributes","punctuation","code","interpolation","delimiter","filters","language","all_filters","i","l","length","RegExp","replace","text","insertBefore","haml_1","displayName","aliases"],"mappings":"6EACA,IAAIA,EAAgBC,IAIpB,SAASC,EAAKC,GACZA,EAAMC,SAASJ,GAOd,SAAWG,GACVA,EAAME,UAAUH,KAAO,CAErB,oBAAqB,CACnBI,QACE,gEACFC,YAAY,EACZC,MAAO,WAET,iBAAkB,CAChB,CACEF,QACE,6GACFC,YAAY,EACZE,OAAQN,EAAME,UAAUK,MAE1B,CACEJ,QACE,sFACFC,YAAY,EACZE,OAAQN,EAAME,UAAUK,OAI5BC,OAAQ,CACNL,QACE,iFACFC,YAAY,EACZE,OAAQ,CACN,cAAe,CACbH,QAAS,WACTE,MAAO,YAIbI,OAAQ,CACNN,QAAS,4BACTC,YAAY,EACZE,OAAQN,EAAME,UAAUO,QAE1BC,QAAS,CACPP,QAAS,oCACTC,YAAY,GAEdO,IAAK,CAEHR,QACE,sGACFC,YAAY,EACZE,OAAQ,CACNM,WAAY,CACV,CAGET,QAAS,mCACTC,YAAY,EACZE,OAAQN,EAAME,UAAUK,MAE1B,CACEJ,QAAS,YACTG,OAAQ,CACN,aAAc,CACZH,QAAS,0CACTC,YAAY,GAEd,YAAa,4BACbS,YAAa,WAGjB,CACEV,QAAS,aACTG,OAAQN,EAAME,UAAUK,OAG5BM,YAAa,SAGjBC,KAAM,CACJX,QAAS,0CACTC,YAAY,EACZE,OAAQN,EAAME,UAAUK,MAG1BQ,cAAe,CACbZ,QAAS,aACTG,OAAQ,CACNU,UAAW,CACTb,QAAS,WACTE,MAAO,eAETE,KAAM,CACJJ,QAAS,UACTG,OAAQN,EAAME,UAAUK,QAI9BM,YAAa,CACXV,QAAS,kCACTC,YAAY,IAoBhB,IAjBA,IAEIa,EAAU,CACZ,MACA,CACET,OAAQ,SACRU,SAAU,gBAEZ,MACA,aACA,OACA,WACA,OACA,OACA,WAEEC,EAAc,CAAE,EACXC,EAAI,EAAGC,EAAIJ,EAAQK,OAAQF,EAAIC,EAAGD,IAAK,CAC9C,IAAIZ,EAASS,EAAQG,GACrBZ,EACoB,iBAAXA,EACH,CACEA,OAAQA,EACRU,SAAUV,GAEZA,EACFR,EAAME,UAAUM,EAAOU,YACzBC,EAAY,UAAYX,EAAOA,QAAU,CACvCL,QAASoB,OA3Bb,uGA4BqBC,QAAQ,mBAAmB,WACxC,OAAOhB,EAAOA,MAC5B,KAEUJ,YAAY,EACZE,OAAQ,CACN,cAAe,CACbH,QAAS,WACTE,MAAO,UAEToB,KAAM,CACJtB,QAAS,UACTE,MAAO,CAACG,EAAOU,SAAU,YAAcV,EAAOU,UAC9CZ,OAAQN,EAAME,UAAUM,EAAOU,aAKxC,CACDlB,EAAME,UAAUwB,aAAa,OAAQ,SAAUP,EAChD,CAtJA,CAsJEnB,EACL,QAlKA2B,EAAiB5B,EACjBA,EAAK6B,YAAc,OACnB7B,EAAK8B,QAAU"}

package/dist/node_modules/refractor/lang/handlebars.js

@@ -1,2 +0,0 @@
-import{__require as a}from"./markup-templating.js";var e,n;function r(){if(n)return e;n=1;var r=a();function s(a){a.register(r),function(a){a.languages.handlebars={comment:/\{\{![\s\S]*?\}\}/,delimiter:{pattern:/^\{\{\{?|\}\}\}?$/,alias:"punctuation"},string:/(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,number:/\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,boolean:/\b(?:false|true)\b/,block:{pattern:/^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,lookbehind:!0,alias:"keyword"},brackets:{pattern:/\[[^\]]+\]/,inside:{punctuation:/\[|\]/,variable:/[\s\S]+/}},punctuation:/[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,variable:/[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/},a.hooks.add("before-tokenize",(function(e){a.languages["markup-templating"].buildPlaceholders(e,"handlebars",/\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g)})),a.hooks.add("after-tokenize",(function(e){a.languages["markup-templating"].tokenizePlaceholders(e,"handlebars")})),a.languages.hbs=a.languages.handlebars}(a)}return e=s,s.displayName="handlebars",s.aliases=["hbs"],e}export{r as __require};
-//# sourceMappingURL=handlebars.js.map

package/dist/node_modules/refractor/lang/handlebars.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlebars.js","sources":["../../../../node_modules/refractor/lang/handlebars.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = handlebars\nhandlebars.displayName = 'handlebars'\nhandlebars.aliases = ['hbs']\nfunction handlebars(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.handlebars = {\n      comment: /\\{\\{![\\s\\S]*?\\}\\}/,\n      delimiter: {\n        pattern: /^\\{\\{\\{?|\\}\\}\\}?$/,\n        alias: 'punctuation'\n      },\n      string: /([\"'])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      number: /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee][+-]?\\d+)?/,\n      boolean: /\\b(?:false|true)\\b/,\n      block: {\n        pattern: /^(\\s*(?:~\\s*)?)[#\\/]\\S+?(?=\\s*(?:~\\s*)?$|\\s)/,\n        lookbehind: true,\n        alias: 'keyword'\n      },\n      brackets: {\n        pattern: /\\[[^\\]]+\\]/,\n        inside: {\n          punctuation: /\\[|\\]/,\n          variable: /[\\s\\S]+/\n        }\n      },\n      punctuation: /[!\"#%&':()*+,.\\/;<=>@\\[\\\\\\]^`{|}~]/,\n      variable: /[^!\"#%&'()*+,\\/;<=>@\\[\\\\\\]^`{|}~\\s]+/\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var handlebarsPattern = /\\{\\{\\{[\\s\\S]+?\\}\\}\\}|\\{\\{[\\s\\S]+?\\}\\}/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'handlebars',\n        handlebarsPattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(\n        env,\n        'handlebars'\n      )\n    })\n    Prism.languages.hbs = Prism.languages.handlebars\n  })(Prism)\n}\n"],"names":["refractorMarkupTemplating","require$$0","handlebars","Prism","register","languages","comment","delimiter","pattern","alias","string","number","boolean","block","lookbehind","brackets","inside","punctuation","variable","hooks","add","env","buildPlaceholders","tokenizePlaceholders","hbs","handlebars_1","displayName","aliases"],"mappings":"0FACA,IAAIA,EAA4BC,IAIhC,SAASC,EAAWC,GAClBA,EAAMC,SAASJ,GACd,SAAWG,GACVA,EAAME,UAAUH,WAAa,CAC3BI,QAAS,oBACTC,UAAW,CACTC,QAAS,oBACTC,MAAO,eAETC,OAAQ,mCACRC,OAAQ,iEACRC,QAAS,qBACTC,MAAO,CACLL,QAAS,+CACTM,YAAY,EACZL,MAAO,WAETM,SAAU,CACRP,QAAS,aACTQ,OAAQ,CACNC,YAAa,QACbC,SAAU,YAGdD,YAAa,qCACbC,SAAU,wCAEZf,EAAMgB,MAAMC,IAAI,mBAAmB,SAAUC,GAE3ClB,EAAME,UAAU,qBAAqBiB,kBACnCD,EACA,aAHsB,yCAM9B,IACIlB,EAAMgB,MAAMC,IAAI,kBAAkB,SAAUC,GAC1ClB,EAAME,UAAU,qBAAqBkB,qBACnCF,EACA,aAER,IACIlB,EAAME,UAAUmB,IAAMrB,EAAME,UAAUH,UACvC,CAxCA,CAwCEC,EACL,QA9CAsB,EAAiBvB,EACjBA,EAAWwB,YAAc,aACzBxB,EAAWyB,QAAU,CAAC"}

package/dist/node_modules/refractor/lang/haskell.js

@@ -1,2 +0,0 @@
-var e,i;function a(){if(i)return e;function a(e){e.languages.haskell={comment:{pattern:/(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,lookbehind:!0},char:{pattern:/'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,alias:"string"},string:{pattern:/"(?:[^\\"]|\\(?:\S|\s+\\))*"/,greedy:!0},keyword:/\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,"import-statement":{pattern:/(^[\t ]*)import\s+(?:qualified\s+)?(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*(?:\s+as\s+(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,lookbehind:!0,inside:{keyword:/\b(?:as|hiding|import|qualified)\b/,punctuation:/\./}},builtin:/\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,number:/\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,operator:[{pattern:/`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,greedy:!0},{pattern:/(\s)\.(?=\s)/,lookbehind:!0},/[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/],hvariable:{pattern:/\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,inside:{punctuation:/\./}},constant:{pattern:/\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,inside:{punctuation:/\./}},punctuation:/[{}[\];(),.:]/},e.languages.hs=e.languages.haskell}return i=1,e=a,a.displayName="haskell",a.aliases=["hs"],e}export{a as __require};
-//# sourceMappingURL=haskell.js.map

package/dist/node_modules/refractor/lang/haskell.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"haskell.js","sources":["../../../../node_modules/refractor/lang/haskell.js"],"sourcesContent":["'use strict'\n\nmodule.exports = haskell\nhaskell.displayName = 'haskell'\nhaskell.aliases = ['hs']\nfunction haskell(Prism) {\n  Prism.languages.haskell = {\n    comment: {\n      pattern:\n        /(^|[^-!#$%*+=?&@|~.:<>^\\\\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\\\\/].*|$)|\\{-[\\s\\S]*?-\\})/m,\n      lookbehind: true\n    },\n    char: {\n      pattern:\n        /'(?:[^\\\\']|\\\\(?:[abfnrtv\\\\\"'&]|\\^[A-Z@[\\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\\d+|o[0-7]+|x[0-9a-fA-F]+))'/,\n      alias: 'string'\n    },\n    string: {\n      pattern: /\"(?:[^\\\\\"]|\\\\(?:\\S|\\s+\\\\))*\"/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\\b/,\n    'import-statement': {\n      // The imported or hidden names are not included in this import\n      // statement. This is because we want to highlight those exactly like\n      // we do for the names in the program.\n      pattern:\n        /(^[\\t ]*)import\\s+(?:qualified\\s+)?(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*(?:\\s+as\\s+(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*)?(?:\\s+hiding\\b)?/m,\n      lookbehind: true,\n      inside: {\n        keyword: /\\b(?:as|hiding|import|qualified)\\b/,\n        punctuation: /\\./\n      }\n    },\n    // These are builtin variables only. Constructors are highlighted later as a constant.\n    builtin:\n      /\\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\\b/,\n    // decimal integers and floating point numbers | octal integers | hexadecimal integers\n    number: /\\b(?:\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?|0o[0-7]+|0x[0-9a-f]+)\\b/i,\n    operator: [\n      {\n        // infix operator\n        pattern: /`(?:[A-Z][\\w']*\\.)*[_a-z][\\w']*`/,\n        greedy: true\n      },\n      {\n        // function composition\n        pattern: /(\\s)\\.(?=\\s)/,\n        lookbehind: true\n      }, // Most of this is needed because of the meaning of a single '.'.\n      // If it stands alone freely, it is the function composition.\n      // It may also be a separator between a module name and an identifier => no\n      // operator. If it comes together with other special characters it is an\n      // operator too.\n      //\n      // This regex means: /[-!#$%*+=?&@|~.:<>^\\\\\\/]+/ without /\\./.\n      /[-!#$%*+=?&@|~:<>^\\\\\\/][-!#$%*+=?&@|~.:<>^\\\\\\/]*|\\.[-!#$%*+=?&@|~.:<>^\\\\\\/]+/\n    ],\n    // In Haskell, nearly everything is a variable, do not highlight these.\n    hvariable: {\n      pattern: /\\b(?:[A-Z][\\w']*\\.)*[_a-z][\\w']*/,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    constant: {\n      pattern: /\\b(?:[A-Z][\\w']*\\.)*[A-Z][\\w']*/,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.hs = Prism.languages.haskell\n}\n"],"names":["haskell","Prism","languages","comment","pattern","lookbehind","char","alias","string","greedy","keyword","inside","punctuation","builtin","number","operator","hvariable","constant","hs","haskell_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAQC,GACfA,EAAMC,UAAUF,QAAU,CACxBG,QAAS,CACPC,QACE,4FACFC,YAAY,GAEdC,KAAM,CACJF,QACE,sMACFG,MAAO,UAETC,OAAQ,CACNJ,QAAS,+BACTK,QAAQ,GAEVC,QACE,wHACF,mBAAoB,CAIlBN,QACE,sIACFC,YAAY,EACZM,OAAQ,CACND,QAAS,qCACTE,YAAa,OAIjBC,QACE,yoDAEFC,OAAQ,4DACRC,SAAU,CACR,CAEEX,QAAS,mCACTK,QAAQ,GAEV,CAEEL,QAAS,eACTC,YAAY,GAQd,gFAGFW,UAAW,CACTZ,QAAS,mCACTO,OAAQ,CACNC,YAAa,OAGjBK,SAAU,CACRb,QAAS,kCACTO,OAAQ,CACNC,YAAa,OAGjBA,YAAa,iBAEfX,EAAMC,UAAUgB,GAAKjB,EAAMC,UAAUF,OACvC,YAzEAmB,EAAiBnB,EACjBA,EAAQoB,YAAc,UACtBpB,EAAQqB,QAAU,CAAC"}

package/dist/node_modules/refractor/lang/haxe.js

@@ -1,2 +0,0 @@
-var e,a;function t(){if(a)return e;function t(e){e.languages.haxe=e.languages.extend("clike",{string:{pattern:/"(?:[^"\\]|\\[\s\S])*"/,greedy:!0},"class-name":[{pattern:/(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,lookbehind:!0},/\b[A-Z]\w*/],keyword:/\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,function:{pattern:/\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,greedy:!0},operator:/\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/}),e.languages.insertBefore("haxe","string",{"string-interpolation":{pattern:/'(?:[^'\\]|\\[\s\S])*'/,greedy:!0,inside:{interpolation:{pattern:/(^|[^\\])\$(?:\w+|\{[^{}]+\})/,lookbehind:!0,inside:{"interpolation-punctuation":{pattern:/^\$\{?|\}$/,alias:"punctuation"},expression:{pattern:/[\s\S]+/,inside:e.languages.haxe}}},string:/[\s\S]+/}}}),e.languages.insertBefore("haxe","class-name",{regex:{pattern:/~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,greedy:!0,inside:{"regex-flags":/\b[a-z]+$/,"regex-source":{pattern:/^(~\/)[\s\S]+(?=\/$)/,lookbehind:!0,alias:"language-regex",inside:e.languages.regex},"regex-delimiter":/^~\/|\/$/}}}),e.languages.insertBefore("haxe","keyword",{preprocessor:{pattern:/#(?:else|elseif|end|if)\b.*/,alias:"property"},metadata:{pattern:/@:?[\w.]+/,alias:"symbol"},reification:{pattern:/\$(?:\w+|(?=\{))/,alias:"important"}})}return a=1,e=t,t.displayName="haxe",t.aliases=[],e}export{t as __require};
-//# sourceMappingURL=haxe.js.map

package/dist/node_modules/refractor/lang/haxe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"haxe.js","sources":["../../../../node_modules/refractor/lang/haxe.js"],"sourcesContent":["'use strict'\n\nmodule.exports = haxe\nhaxe.displayName = 'haxe'\nhaxe.aliases = []\nfunction haxe(Prism) {\n  Prism.languages.haxe = Prism.languages.extend('clike', {\n    string: {\n      // Strings can be multi-line\n      pattern: /\"(?:[^\"\\\\]|\\\\[\\s\\S])*\"/,\n      greedy: true\n    },\n    'class-name': [\n      {\n        pattern:\n          /(\\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\\s+)[A-Z_]\\w*/,\n        lookbehind: true\n      }, // based on naming convention\n      /\\b[A-Z]\\w*/\n    ],\n    // The final look-ahead prevents highlighting of keywords if expressions such as \"haxe.macro.Expr\"\n    keyword:\n      /\\bthis\\b|\\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\\.)\\b/,\n    function: {\n      pattern: /\\b[a-z_]\\w*(?=\\s*(?:<[^<>]*>\\s*)?\\()/i,\n      greedy: true\n    },\n    operator: /\\.{3}|\\+\\+|--|&&|\\|\\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/\n  })\n  Prism.languages.insertBefore('haxe', 'string', {\n    'string-interpolation': {\n      pattern: /'(?:[^'\\\\]|\\\\[\\s\\S])*'/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /(^|[^\\\\])\\$(?:\\w+|\\{[^{}]+\\})/,\n          lookbehind: true,\n          inside: {\n            'interpolation-punctuation': {\n              pattern: /^\\$\\{?|\\}$/,\n              alias: 'punctuation'\n            },\n            expression: {\n              pattern: /[\\s\\S]+/,\n              inside: Prism.languages.haxe\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n  })\n  Prism.languages.insertBefore('haxe', 'class-name', {\n    regex: {\n      pattern: /~\\/(?:[^\\/\\\\\\r\\n]|\\\\.)+\\/[a-z]*/,\n      greedy: true,\n      inside: {\n        'regex-flags': /\\b[a-z]+$/,\n        'regex-source': {\n          pattern: /^(~\\/)[\\s\\S]+(?=\\/$)/,\n          lookbehind: true,\n          alias: 'language-regex',\n          inside: Prism.languages.regex\n        },\n        'regex-delimiter': /^~\\/|\\/$/\n      }\n    }\n  })\n  Prism.languages.insertBefore('haxe', 'keyword', {\n    preprocessor: {\n      pattern: /#(?:else|elseif|end|if)\\b.*/,\n      alias: 'property'\n    },\n    metadata: {\n      pattern: /@:?[\\w.]+/,\n      alias: 'symbol'\n    },\n    reification: {\n      pattern: /\\$(?:\\w+|(?=\\{))/,\n      alias: 'important'\n    }\n  })\n}\n"],"names":["haxe","Prism","languages","extend","string","pattern","greedy","lookbehind","keyword","function","operator","insertBefore","inside","interpolation","alias","expression","regex","preprocessor","metadata","reification","haxe_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAKC,GACZA,EAAMC,UAAUF,KAAOC,EAAMC,UAAUC,OAAO,QAAS,CACrDC,OAAQ,CAENC,QAAS,yBACTC,QAAQ,GAEV,aAAc,CACZ,CACED,QACE,mFACFE,YAAY,GAEd,cAGFC,QACE,gUACFC,SAAU,CACRJ,QAAS,wCACTC,QAAQ,GAEVI,SAAU,oEAEZT,EAAMC,UAAUS,aAAa,OAAQ,SAAU,CAC7C,uBAAwB,CACtBN,QAAS,yBACTC,QAAQ,EACRM,OAAQ,CACNC,cAAe,CACbR,QAAS,gCACTE,YAAY,EACZK,OAAQ,CACN,4BAA6B,CAC3BP,QAAS,aACTS,MAAO,eAETC,WAAY,CACVV,QAAS,UACTO,OAAQX,EAAMC,UAAUF,QAI9BI,OAAQ,cAIdH,EAAMC,UAAUS,aAAa,OAAQ,aAAc,CACjDK,MAAO,CACLX,QAAS,kCACTC,QAAQ,EACRM,OAAQ,CACN,cAAe,YACf,eAAgB,CACdP,QAAS,uBACTE,YAAY,EACZO,MAAO,iBACPF,OAAQX,EAAMC,UAAUc,OAE1B,kBAAmB,eAIzBf,EAAMC,UAAUS,aAAa,OAAQ,UAAW,CAC9CM,aAAc,CACZZ,QAAS,8BACTS,MAAO,YAETI,SAAU,CACRb,QAAS,YACTS,MAAO,UAETK,YAAa,CACXd,QAAS,mBACTS,MAAO,cAGb,YAhFAM,EAAiBpB,EACjBA,EAAKqB,YAAc,OACnBrB,EAAKsB,QAAU"}

package/dist/node_modules/refractor/lang/hcl.js

@@ -1,2 +0,0 @@
-var e,a;function r(){if(a)return e;function r(e){e.languages.hcl={comment:/(?:\/\/|#).*|\/\*[\s\S]*?(?:\*\/|$)/,heredoc:{pattern:/<<-?(\w+\b)[\s\S]*?^[ \t]*\1/m,greedy:!0,alias:"string"},keyword:[{pattern:/(?:data|resource)\s+(?:"(?:\\[\s\S]|[^\\"])*")(?=\s+"[\w-]+"\s+\{)/i,inside:{type:{pattern:/(resource|data|\s+)(?:"(?:\\[\s\S]|[^\\"])*")/i,lookbehind:!0,alias:"variable"}}},{pattern:/(?:backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+(?=\{)/i,inside:{type:{pattern:/(backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+/i,lookbehind:!0,alias:"variable"}}},/[\w-]+(?=\s+\{)/],property:[/[-\w\.]+(?=\s*=(?!=))/,/"(?:\\[\s\S]|[^\\"])+"(?=\s*[:=])/],string:{pattern:/"(?:[^\\$"]|\\[\s\S]|\$(?:(?=")|\$+(?!\$)|[^"${])|\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\})*"/,greedy:!0,inside:{interpolation:{pattern:/(^|[^$])\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\}/,lookbehind:!0,inside:{type:{pattern:/(\b(?:count|data|local|module|path|self|terraform|var)\b\.)[\w\*]+/i,lookbehind:!0,alias:"variable"},keyword:/\b(?:count|data|local|module|path|self|terraform|var)\b/i,function:/\w+(?=\()/,string:{pattern:/"(?:\\[\s\S]|[^\\"])*"/,greedy:!0},number:/\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,punctuation:/[!\$#%&'()*+,.\/;<=>@\[\\\]^`{|}~?:]/}}}},number:/\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,boolean:/\b(?:false|true)\b/i,punctuation:/[=\[\]{}]/}}return a=1,e=r,r.displayName="hcl",r.aliases=[],e}export{r as __require};
-//# sourceMappingURL=hcl.js.map

package/dist/node_modules/refractor/lang/hcl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hcl.js","sources":["../../../../node_modules/refractor/lang/hcl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = hcl\nhcl.displayName = 'hcl'\nhcl.aliases = []\nfunction hcl(Prism) {\n  Prism.languages.hcl = {\n    comment: /(?:\\/\\/|#).*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    heredoc: {\n      pattern: /<<-?(\\w+\\b)[\\s\\S]*?^[ \\t]*\\1/m,\n      greedy: true,\n      alias: 'string'\n    },\n    keyword: [\n      {\n        pattern:\n          /(?:data|resource)\\s+(?:\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")(?=\\s+\"[\\w-]+\"\\s+\\{)/i,\n        inside: {\n          type: {\n            pattern: /(resource|data|\\s+)(?:\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")/i,\n            lookbehind: true,\n            alias: 'variable'\n          }\n        }\n      },\n      {\n        pattern:\n          /(?:backend|module|output|provider|provisioner|variable)\\s+(?:[\\w-]+|\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")\\s+(?=\\{)/i,\n        inside: {\n          type: {\n            pattern:\n              /(backend|module|output|provider|provisioner|variable)\\s+(?:[\\w-]+|\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")\\s+/i,\n            lookbehind: true,\n            alias: 'variable'\n          }\n        }\n      },\n      /[\\w-]+(?=\\s+\\{)/\n    ],\n    property: [/[-\\w\\.]+(?=\\s*=(?!=))/, /\"(?:\\\\[\\s\\S]|[^\\\\\"])+\"(?=\\s*[:=])/],\n    string: {\n      pattern:\n        /\"(?:[^\\\\$\"]|\\\\[\\s\\S]|\\$(?:(?=\")|\\$+(?!\\$)|[^\"${])|\\$\\{(?:[^{}\"]|\"(?:[^\\\\\"]|\\\\[\\s\\S])*\")*\\})*\"/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /(^|[^$])\\$\\{(?:[^{}\"]|\"(?:[^\\\\\"]|\\\\[\\s\\S])*\")*\\}/,\n          lookbehind: true,\n          inside: {\n            type: {\n              pattern:\n                /(\\b(?:count|data|local|module|path|self|terraform|var)\\b\\.)[\\w\\*]+/i,\n              lookbehind: true,\n              alias: 'variable'\n            },\n            keyword: /\\b(?:count|data|local|module|path|self|terraform|var)\\b/i,\n            function: /\\w+(?=\\()/,\n            string: {\n              pattern: /\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"/,\n              greedy: true\n            },\n            number: /\\b0x[\\da-f]+\\b|\\b\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?/i,\n            punctuation: /[!\\$#%&'()*+,.\\/;<=>@\\[\\\\\\]^`{|}~?:]/\n          }\n        }\n      }\n    },\n    number: /\\b0x[\\da-f]+\\b|\\b\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?/i,\n    boolean: /\\b(?:false|true)\\b/i,\n    punctuation: /[=\\[\\]{}]/\n  }\n}\n"],"names":["hcl","Prism","languages","comment","heredoc","pattern","greedy","alias","keyword","inside","type","lookbehind","property","string","interpolation","function","number","punctuation","boolean","hcl_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAIC,GACXA,EAAMC,UAAUF,IAAM,CACpBG,QAAS,sCACTC,QAAS,CACPC,QAAS,gCACTC,QAAQ,EACRC,MAAO,UAETC,QAAS,CACP,CACEH,QACE,sEACFI,OAAQ,CACNC,KAAM,CACJL,QAAS,iDACTM,YAAY,EACZJ,MAAO,cAIb,CACEF,QACE,wGACFI,OAAQ,CACNC,KAAM,CACJL,QACE,gGACFM,YAAY,EACZJ,MAAO,cAIb,mBAEFK,SAAU,CAAC,wBAAyB,qCACpCC,OAAQ,CACNR,QACE,gGACFC,QAAQ,EACRG,OAAQ,CACNK,cAAe,CACbT,QAAS,mDACTM,YAAY,EACZF,OAAQ,CACNC,KAAM,CACJL,QACE,sEACFM,YAAY,EACZJ,MAAO,YAETC,QAAS,2DACTO,SAAU,YACVF,OAAQ,CACNR,QAAS,yBACTC,QAAQ,GAEVU,OAAQ,gDACRC,YAAa,2CAKrBD,OAAQ,gDACRE,QAAS,sBACTD,YAAa,YAEjB,YArEAE,EAAiBnB,EACjBA,EAAIoB,YAAc,MAClBpB,EAAIqB,QAAU"}

package/dist/node_modules/refractor/lang/hlsl.js

@@ -1,2 +0,0 @@
-import{__require as e}from"./c.js";var t,r;function a(){if(r)return t;r=1;var a=e();function n(e){e.register(a),e.languages.hlsl=e.languages.extend("c",{"class-name":[e.languages.c["class-name"],/\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\b/],keyword:[/\b(?:asm|asm_fragment|auto|break|case|catch|cbuffer|centroid|char|class|column_major|compile|compile_fragment|const|const_cast|continue|default|delete|discard|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|fxgroup|goto|groupshared|if|in|inline|inout|interface|line|lineadj|linear|long|matrix|mutable|namespace|new|nointerpolation|noperspective|operator|out|packoffset|pass|pixelfragment|point|precise|private|protected|public|register|reinterpret_cast|return|row_major|sample|sampler|shared|short|signed|sizeof|snorm|stateblock|stateblock_state|static|static_cast|string|struct|switch|tbuffer|technique|technique10|technique11|template|texture|this|throw|triangle|triangleadj|try|typedef|typename|uniform|union|unorm|unsigned|using|vector|vertexfragment|virtual|void|volatile|while)\b/,/\b(?:bool|double|dword|float|half|int|min(?:10float|12int|16(?:float|int|uint))|uint)(?:[1-4](?:x[1-4])?)?\b/],number:/(?:(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?|\b0x[\da-fA-F]+)[fFhHlLuU]?\b/,boolean:/\b(?:false|true)\b/})}return t=n,n.displayName="hlsl",n.aliases=[],t}export{a as __require};
-//# sourceMappingURL=hlsl.js.map

package/dist/node_modules/refractor/lang/hlsl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hlsl.js","sources":["../../../../node_modules/refractor/lang/hlsl.js"],"sourcesContent":["'use strict'\nvar refractorC = require('./c.js')\nmodule.exports = hlsl\nhlsl.displayName = 'hlsl'\nhlsl.aliases = []\nfunction hlsl(Prism) {\n  Prism.register(refractorC)\n  Prism.languages.hlsl = Prism.languages.extend('c', {\n    // Regarding keywords and class names:\n    // The list of all keywords was split into 'keyword' and 'class-name' tokens based on whether they are capitalized.\n    // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-keywords\n    // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-reserved-words\n    'class-name': [\n      Prism.languages.c['class-name'],\n      /\\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\\b/\n    ],\n    keyword: [\n      // HLSL keyword\n      /\\b(?:asm|asm_fragment|auto|break|case|catch|cbuffer|centroid|char|class|column_major|compile|compile_fragment|const|const_cast|continue|default|delete|discard|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|fxgroup|goto|groupshared|if|in|inline|inout|interface|line|lineadj|linear|long|matrix|mutable|namespace|new|nointerpolation|noperspective|operator|out|packoffset|pass|pixelfragment|point|precise|private|protected|public|register|reinterpret_cast|return|row_major|sample|sampler|shared|short|signed|sizeof|snorm|stateblock|stateblock_state|static|static_cast|string|struct|switch|tbuffer|technique|technique10|technique11|template|texture|this|throw|triangle|triangleadj|try|typedef|typename|uniform|union|unorm|unsigned|using|vector|vertexfragment|virtual|void|volatile|while)\\b/, // scalar, vector, and matrix types\n      /\\b(?:bool|double|dword|float|half|int|min(?:10float|12int|16(?:float|int|uint))|uint)(?:[1-4](?:x[1-4])?)?\\b/\n    ],\n    // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-grammar#floating-point-numbers\n    number:\n      /(?:(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?|\\b0x[\\da-fA-F]+)[fFhHlLuU]?\\b/,\n    boolean: /\\b(?:false|true)\\b/\n  })\n}\n"],"names":["refractorC","require$$0","hlsl","Prism","register","languages","extend","c","keyword","number","boolean","hlsl_1","displayName","aliases"],"mappings":"0EACA,IAAIA,EAAaC,IAIjB,SAASC,EAAKC,GACZA,EAAMC,SAASJ,GACfG,EAAME,UAAUH,KAAOC,EAAME,UAAUC,OAAO,IAAK,CAKjD,aAAc,CACZH,EAAME,UAAUE,EAAE,cAClB,wgBAEFC,QAAS,CAEP,gyBACA,gHAGFC,OACE,gFACFC,QAAS,sBAEb,QAxBAC,EAAiBT,EACjBA,EAAKU,YAAc,OACnBV,EAAKW,QAAU"}

package/dist/node_modules/refractor/lang/hoon.js

@@ -1,2 +0,0 @@
-var n,a;function e(){if(a)return n;function e(n){n.languages.hoon={comment:{pattern:/::.*/,greedy:!0},string:{pattern:/"[^"]*"|'[^']*'/,greedy:!0},constant:/%(?:\.[ny]|[\w-]+)/,"class-name":/@(?:[a-z0-9-]*[a-z0-9])?|\*/i,function:/(?:\+[-+] {2})?(?:[a-z](?:[a-z0-9-]*[a-z0-9])?)/,keyword:/\.[\^\+\*=\?]|![><:\.=\?!]|=[>|:,\.\-\^<+;/~\*\?]|\?[>|:\.\-\^<\+&~=@!]|\|[\$_%:\.\-\^~\*=@\?]|\+[|\$\+\*]|:[_\-\^\+~\*]|%[_:\.\-\^\+~\*=]|\^[|:\.\-\+&~\*=\?]|\$[|_%:<>\-\^&~@=\?]|;[:<\+;\/~\*=]|~[>|\$_%<\+\/&=\?!]|--|==/}}return a=1,n=e,e.displayName="hoon",e.aliases=[],n}export{e as __require};
-//# sourceMappingURL=hoon.js.map

package/dist/node_modules/refractor/lang/hoon.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hoon.js","sources":["../../../../node_modules/refractor/lang/hoon.js"],"sourcesContent":["'use strict'\n\nmodule.exports = hoon\nhoon.displayName = 'hoon'\nhoon.aliases = []\nfunction hoon(Prism) {\n  Prism.languages.hoon = {\n    comment: {\n      pattern: /::.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /\"[^\"]*\"|'[^']*'/,\n      greedy: true\n    },\n    constant: /%(?:\\.[ny]|[\\w-]+)/,\n    'class-name': /@(?:[a-z0-9-]*[a-z0-9])?|\\*/i,\n    function: /(?:\\+[-+] {2})?(?:[a-z](?:[a-z0-9-]*[a-z0-9])?)/,\n    keyword:\n      /\\.[\\^\\+\\*=\\?]|![><:\\.=\\?!]|=[>|:,\\.\\-\\^<+;/~\\*\\?]|\\?[>|:\\.\\-\\^<\\+&~=@!]|\\|[\\$_%:\\.\\-\\^~\\*=@\\?]|\\+[|\\$\\+\\*]|:[_\\-\\^\\+~\\*]|%[_:\\.\\-\\^\\+~\\*=]|\\^[|:\\.\\-\\+&~\\*=\\?]|\\$[|_%:<>\\-\\^&~@=\\?]|;[:<\\+;\\/~\\*=]|~[>|\\$_%<\\+\\/&=\\?!]|--|==/\n  }\n}\n"],"names":["hoon","Prism","languages","comment","pattern","greedy","string","constant","function","keyword","hoon_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAKC,GACZA,EAAMC,UAAUF,KAAO,CACrBG,QAAS,CACPC,QAAS,OACTC,QAAQ,GAEVC,OAAQ,CACNF,QAAS,kBACTC,QAAQ,GAEVE,SAAU,qBACV,aAAc,+BACdC,SAAU,kDACVC,QACE,+NAEN,YAnBAC,EAAiBV,EACjBA,EAAKW,YAAc,OACnBX,EAAKY,QAAU"}

package/dist/node_modules/refractor/lang/hpkp.js

@@ -1,2 +0,0 @@
-var r,a;function e(){if(a)return r;function e(r){r.languages.hpkp={directive:{pattern:/\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\s;=]|$)/i,alias:"property"},operator:/=/,punctuation:/;/}}return a=1,r=e,e.displayName="hpkp",e.aliases=[],r}export{e as __require};
-//# sourceMappingURL=hpkp.js.map

package/dist/node_modules/refractor/lang/hpkp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hpkp.js","sources":["../../../../node_modules/refractor/lang/hpkp.js"],"sourcesContent":["'use strict'\n\nmodule.exports = hpkp\nhpkp.displayName = 'hpkp'\nhpkp.aliases = []\nfunction hpkp(Prism) {\n  /**\n   * Original by Scott Helme.\n   *\n   * Reference: https://scotthelme.co.uk/hpkp-cheat-sheet/\n   */\n  Prism.languages.hpkp = {\n    directive: {\n      pattern:\n        /\\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\\s;=]|$)/i,\n      alias: 'property'\n    },\n    operator: /=/,\n    punctuation: /;/\n  }\n}\n"],"names":["hpkp","Prism","languages","directive","pattern","alias","operator","punctuation","hpkp_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAKC,GAMZA,EAAMC,UAAUF,KAAO,CACrBG,UAAW,CACTC,QACE,8FACFC,MAAO,YAETC,SAAU,IACVC,YAAa,IAEjB,YAlBAC,EAAiBR,EACjBA,EAAKS,YAAc,OACnBT,EAAKU,QAAU"}

package/dist/node_modules/refractor/lang/hsts.js

@@ -1,2 +0,0 @@
-var a,e;function r(){if(e)return a;function r(a){a.languages.hsts={directive:{pattern:/\b(?:includeSubDomains|max-age|preload)(?=[\s;=]|$)/i,alias:"property"},operator:/=/,punctuation:/;/}}return e=1,a=r,r.displayName="hsts",r.aliases=[],a}export{r as __require};
-//# sourceMappingURL=hsts.js.map

package/dist/node_modules/refractor/lang/hsts.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hsts.js","sources":["../../../../node_modules/refractor/lang/hsts.js"],"sourcesContent":["'use strict'\n\nmodule.exports = hsts\nhsts.displayName = 'hsts'\nhsts.aliases = []\nfunction hsts(Prism) {\n  /**\n   * Original by Scott Helme.\n   *\n   * Reference: https://scotthelme.co.uk/hsts-cheat-sheet/\n   */\n  Prism.languages.hsts = {\n    directive: {\n      pattern: /\\b(?:includeSubDomains|max-age|preload)(?=[\\s;=]|$)/i,\n      alias: 'property'\n    },\n    operator: /=/,\n    punctuation: /;/\n  }\n}\n"],"names":["hsts","Prism","languages","directive","pattern","alias","operator","punctuation","hsts_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAKC,GAMZA,EAAMC,UAAUF,KAAO,CACrBG,UAAW,CACTC,QAAS,uDACTC,MAAO,YAETC,SAAU,IACVC,YAAa,IAEjB,YAjBAC,EAAiBR,EACjBA,EAAKS,YAAc,OACnBT,EAAKU,QAAU"}

package/dist/node_modules/refractor/lang/http.js

@@ -1,2 +0,0 @@
-var e,t;function a(){if(t)return e;function a(e){!function(e){function t(e){return RegExp("(^(?:"+e+"):[ \t]*(?![ \t]))[^]+","i")}e.languages.http={"request-line":{pattern:/^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\s(?:https?:\/\/|\/)\S*\sHTTP\/[\d.]+/m,inside:{method:{pattern:/^[A-Z]+\b/,alias:"property"},"request-target":{pattern:/^(\s)(?:https?:\/\/|\/)\S*(?=\s)/,lookbehind:!0,alias:"url",inside:e.languages.uri},"http-version":{pattern:/^(\s)HTTP\/[\d.]+/,lookbehind:!0,alias:"property"}}},"response-status":{pattern:/^HTTP\/[\d.]+ \d+ .+/m,inside:{"http-version":{pattern:/^HTTP\/[\d.]+/,alias:"property"},"status-code":{pattern:/^(\s)\d+(?=\s)/,lookbehind:!0,alias:"number"},"reason-phrase":{pattern:/^(\s).+/,lookbehind:!0,alias:"string"}}},header:{pattern:/^[\w-]+:.+(?:(?:\r\n?|\n)[ \t].+)*/m,inside:{"header-value":[{pattern:t(/Content-Security-Policy/.source),lookbehind:!0,alias:["csp","languages-csp"],inside:e.languages.csp},{pattern:t(/Public-Key-Pins(?:-Report-Only)?/.source),lookbehind:!0,alias:["hpkp","languages-hpkp"],inside:e.languages.hpkp},{pattern:t(/Strict-Transport-Security/.source),lookbehind:!0,alias:["hsts","languages-hsts"],inside:e.languages.hsts},{pattern:t(/[^:]+/.source),lookbehind:!0}],"header-name":{pattern:/^[^:]+/,alias:"keyword"},punctuation:/^:/}}};var a,n=e.languages,s={"application/javascript":n.javascript,"application/json":n.json||n.javascript,"application/xml":n.xml,"text/xml":n.xml,"text/html":n.html,"text/css":n.css,"text/plain":n.plain},r={"application/json":!0,"application/xml":!0};function i(e){var t=e.replace(/^[a-z]+\//,"");return"(?:"+e+"|"+("\\w+/(?:[\\w.-]+\\+)+"+t+"(?![+\\w.-])")+")"}for(var p in s)if(s[p]){a=a||{};var o=r[p]?i(p):p;a[p.replace(/\//g,"-")]={pattern:RegExp("("+/content-type:\s*/.source+o+/(?:(?:\r\n?|\n)[\w-].*)*(?:\r(?:\n|(?!\n))|\n)/.source+")"+/[^ \t\w-][\s\S]*/.source,"i"),lookbehind:!0,inside:s[p]}}a&&e.languages.insertBefore("http","header",a)}(e)}return t=1,e=a,a.displayName="http",a.aliases=[],e}export{a as __require};
-//# sourceMappingURL=http.js.map

package/dist/node_modules/refractor/lang/http.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"http.js","sources":["../../../../node_modules/refractor/lang/http.js"],"sourcesContent":["'use strict'\n\nmodule.exports = http\nhttp.displayName = 'http'\nhttp.aliases = []\nfunction http(Prism) {\n  ;(function (Prism) {\n    /**\n     * @param {string} name\n     * @returns {RegExp}\n     */\n    function headerValueOf(name) {\n      return RegExp('(^(?:' + name + '):[ \\t]*(?![ \\t]))[^]+', 'i')\n    }\n    Prism.languages.http = {\n      'request-line': {\n        pattern:\n          /^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\\s(?:https?:\\/\\/|\\/)\\S*\\sHTTP\\/[\\d.]+/m,\n        inside: {\n          // HTTP Method\n          method: {\n            pattern: /^[A-Z]+\\b/,\n            alias: 'property'\n          },\n          // Request Target e.g. http://example.com, /path/to/file\n          'request-target': {\n            pattern: /^(\\s)(?:https?:\\/\\/|\\/)\\S*(?=\\s)/,\n            lookbehind: true,\n            alias: 'url',\n            inside: Prism.languages.uri\n          },\n          // HTTP Version\n          'http-version': {\n            pattern: /^(\\s)HTTP\\/[\\d.]+/,\n            lookbehind: true,\n            alias: 'property'\n          }\n        }\n      },\n      'response-status': {\n        pattern: /^HTTP\\/[\\d.]+ \\d+ .+/m,\n        inside: {\n          // HTTP Version\n          'http-version': {\n            pattern: /^HTTP\\/[\\d.]+/,\n            alias: 'property'\n          },\n          // Status Code\n          'status-code': {\n            pattern: /^(\\s)\\d+(?=\\s)/,\n            lookbehind: true,\n            alias: 'number'\n          },\n          // Reason Phrase\n          'reason-phrase': {\n            pattern: /^(\\s).+/,\n            lookbehind: true,\n            alias: 'string'\n          }\n        }\n      },\n      header: {\n        pattern: /^[\\w-]+:.+(?:(?:\\r\\n?|\\n)[ \\t].+)*/m,\n        inside: {\n          'header-value': [\n            {\n              pattern: headerValueOf(/Content-Security-Policy/.source),\n              lookbehind: true,\n              alias: ['csp', 'languages-csp'],\n              inside: Prism.languages.csp\n            },\n            {\n              pattern: headerValueOf(/Public-Key-Pins(?:-Report-Only)?/.source),\n              lookbehind: true,\n              alias: ['hpkp', 'languages-hpkp'],\n              inside: Prism.languages.hpkp\n            },\n            {\n              pattern: headerValueOf(/Strict-Transport-Security/.source),\n              lookbehind: true,\n              alias: ['hsts', 'languages-hsts'],\n              inside: Prism.languages.hsts\n            },\n            {\n              pattern: headerValueOf(/[^:]+/.source),\n              lookbehind: true\n            }\n          ],\n          'header-name': {\n            pattern: /^[^:]+/,\n            alias: 'keyword'\n          },\n          punctuation: /^:/\n        }\n      }\n    } // Create a mapping of Content-Type headers to language definitions\n    var langs = Prism.languages\n    var httpLanguages = {\n      'application/javascript': langs.javascript,\n      'application/json': langs.json || langs.javascript,\n      'application/xml': langs.xml,\n      'text/xml': langs.xml,\n      'text/html': langs.html,\n      'text/css': langs.css,\n      'text/plain': langs.plain\n    } // Declare which types can also be suffixes\n    var suffixTypes = {\n      'application/json': true,\n      'application/xml': true\n    }\n    /**\n     * Returns a pattern for the given content type which matches it and any type which has it as a suffix.\n     *\n     * @param {string} contentType\n     * @returns {string}\n     */\n    function getSuffixPattern(contentType) {\n      var suffix = contentType.replace(/^[a-z]+\\//, '')\n      var suffixPattern = '\\\\w+/(?:[\\\\w.-]+\\\\+)+' + suffix + '(?![+\\\\w.-])'\n      return '(?:' + contentType + '|' + suffixPattern + ')'\n    } // Insert each content type parser that has its associated language\n    // currently loaded.\n    var options\n    for (var contentType in httpLanguages) {\n      if (httpLanguages[contentType]) {\n        options = options || {}\n        var pattern = suffixTypes[contentType]\n          ? getSuffixPattern(contentType)\n          : contentType\n        options[contentType.replace(/\\//g, '-')] = {\n          pattern: RegExp(\n            '(' +\n              /content-type:\\s*/.source +\n              pattern +\n              /(?:(?:\\r\\n?|\\n)[\\w-].*)*(?:\\r(?:\\n|(?!\\n))|\\n)/.source +\n              ')' + // This is a little interesting:\n              // The HTTP format spec required 1 empty line before the body to make everything unambiguous.\n              // However, when writing code by hand (e.g. to display on a website) people can forget about this,\n              // so we want to be liberal here. We will allow the empty line to be omitted if the first line of\n              // the body does not start with a [\\w-] character (as headers do).\n              /[^ \\t\\w-][\\s\\S]*/.source,\n            'i'\n          ),\n          lookbehind: true,\n          inside: httpLanguages[contentType]\n        }\n      }\n    }\n    if (options) {\n      Prism.languages.insertBefore('http', 'header', options)\n    }\n  })(Prism)\n}\n"],"names":["http","Prism","headerValueOf","name","RegExp","languages","pattern","inside","method","alias","lookbehind","uri","header","source","csp","hpkp","hsts","punctuation","options","langs","httpLanguages","javascript","json","xml","html","css","plain","suffixTypes","getSuffixPattern","contentType","suffix","replace","insertBefore","http_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAKC,IACX,SAAWA,GAKV,SAASC,EAAcC,GACrB,OAAOC,OAAO,QAAUD,EAAO,yBAA0B,IAC1D,CACDF,EAAMI,UAAUL,KAAO,CACrB,eAAgB,CACdM,QACE,6GACFC,OAAQ,CAENC,OAAQ,CACNF,QAAS,YACTG,MAAO,YAGT,iBAAkB,CAChBH,QAAS,mCACTI,YAAY,EACZD,MAAO,MACPF,OAAQN,EAAMI,UAAUM,KAG1B,eAAgB,CACdL,QAAS,oBACTI,YAAY,EACZD,MAAO,cAIb,kBAAmB,CACjBH,QAAS,wBACTC,OAAQ,CAEN,eAAgB,CACdD,QAAS,gBACTG,MAAO,YAGT,cAAe,CACbH,QAAS,iBACTI,YAAY,EACZD,MAAO,UAGT,gBAAiB,CACfH,QAAS,UACTI,YAAY,EACZD,MAAO,YAIbG,OAAQ,CACNN,QAAS,sCACTC,OAAQ,CACN,eAAgB,CACd,CACED,QAASJ,EAAc,0BAA0BW,QACjDH,YAAY,EACZD,MAAO,CAAC,MAAO,iBACfF,OAAQN,EAAMI,UAAUS,KAE1B,CACER,QAASJ,EAAc,mCAAmCW,QAC1DH,YAAY,EACZD,MAAO,CAAC,OAAQ,kBAChBF,OAAQN,EAAMI,UAAUU,MAE1B,CACET,QAASJ,EAAc,4BAA4BW,QACnDH,YAAY,EACZD,MAAO,CAAC,OAAQ,kBAChBF,OAAQN,EAAMI,UAAUW,MAE1B,CACEV,QAASJ,EAAc,QAAQW,QAC/BH,YAAY,IAGhB,cAAe,CACbJ,QAAS,SACTG,MAAO,WAETQ,YAAa,QAInB,IA0BIC,EA1BAC,EAAQlB,EAAMI,UACde,EAAgB,CAClB,yBAA0BD,EAAME,WAChC,mBAAoBF,EAAMG,MAAQH,EAAME,WACxC,kBAAmBF,EAAMI,IACzB,WAAYJ,EAAMI,IAClB,YAAaJ,EAAMK,KACnB,WAAYL,EAAMM,IAClB,aAAcN,EAAMO,OAElBC,EAAc,CAChB,oBAAoB,EACpB,mBAAmB,GAQrB,SAASC,EAAiBC,GACxB,IAAIC,EAASD,EAAYE,QAAQ,YAAa,IAE9C,MAAO,MAAQF,EAAc,KADT,wBAA0BC,EAAS,gBACJ,GACpD,CAGD,IAAK,IAAID,KAAeT,EACtB,GAAIA,EAAcS,GAAc,CAC9BX,EAAUA,GAAW,CAAE,EACvB,IAAIZ,EAAUqB,EAAYE,GACtBD,EAAiBC,GACjBA,EACJX,EAAQW,EAAYE,QAAQ,MAAO,MAAQ,CACzCzB,QAASF,OACP,IACE,mBAAmBS,OACnBP,EACA,iDAAiDO,OACjD,IAKA,mBAAmBA,OACrB,KAEFH,YAAY,EACZH,OAAQa,EAAcS,GAEzB,CAECX,GACFjB,EAAMI,UAAU2B,aAAa,OAAQ,SAAUd,EAElD,CAjJA,CAiJEjB,EACL,YAtJAgC,EAAiBjC,EACjBA,EAAKkC,YAAc,OACnBlC,EAAKmC,QAAU"}

package/dist/node_modules/refractor/lang/ichigojam.js

@@ -1,2 +0,0 @@
-var E,N;function R(){if(N)return E;function R(E){E.languages.ichigojam={comment:/(?:\B'|REM)(?:[^\n\r]*)/i,string:{pattern:/"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,greedy:!0},number:/\B#[0-9A-F]+|\B`[01]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,keyword:/\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\$|\b)/i,function:/\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\$|\b)/i,label:/(?:\B@\S+)/,operator:/<[=>]?|>=?|\|\||&&|[+\-*\/=|&^~!]|\b(?:AND|NOT|OR)\b/i,punctuation:/[\[,;:()\]]/}}return N=1,E=R,R.displayName="ichigojam",R.aliases=[],E}export{R as __require};
-//# sourceMappingURL=ichigojam.js.map

package/dist/node_modules/refractor/lang/ichigojam.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ichigojam.js","sources":["../../../../node_modules/refractor/lang/ichigojam.js"],"sourcesContent":["'use strict'\n\nmodule.exports = ichigojam\nichigojam.displayName = 'ichigojam'\nichigojam.aliases = []\nfunction ichigojam(Prism) {\n  // according to the offical reference (EN)\n  // https://ichigojam.net/IchigoJam-en.html\n  Prism.languages.ichigojam = {\n    comment: /(?:\\B'|REM)(?:[^\\n\\r]*)/i,\n    string: {\n      pattern: /\"(?:\"\"|[!#$%&'()*,\\/:;<=>?^\\w +\\-.])*\"/,\n      greedy: true\n    },\n    number: /\\B#[0-9A-F]+|\\B`[01]+|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:E[+-]?\\d+)?/i,\n    keyword:\n      /\\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\\$|\\b)/i,\n    function:\n      /\\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\\$|\\b)/i,\n    label: /(?:\\B@\\S+)/,\n    operator: /<[=>]?|>=?|\\|\\||&&|[+\\-*\\/=|&^~!]|\\b(?:AND|NOT|OR)\\b/i,\n    punctuation: /[\\[,;:()\\]]/\n  }\n}\n"],"names":["ichigojam","Prism","languages","comment","string","pattern","greedy","number","keyword","function","label","operator","punctuation","ichigojam_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAUC,GAGjBA,EAAMC,UAAUF,UAAY,CAC1BG,QAAS,2BACTC,OAAQ,CACNC,QAAS,yCACTC,QAAQ,GAEVC,OAAQ,mEACRC,QACE,mSACFC,SACE,sIACFC,MAAO,aACPC,SAAU,wDACVC,YAAa,cAEjB,YArBAC,EAAiBb,EACjBA,EAAUc,YAAc,YACxBd,EAAUe,QAAU"}

package/dist/node_modules/refractor/lang/icon.js

@@ -1,2 +0,0 @@
-var e,t;function r(){if(t)return e;function r(e){e.languages.icon={comment:/#.*/,string:{pattern:/(["'])(?:(?!\1)[^\\\r\n_]|\\.|_(?!\1)(?:\r\n|[\s\S]))*\1/,greedy:!0},number:/\b(?:\d+r[a-z\d]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b|\.\d+\b/i,"builtin-keyword":{pattern:/&(?:allocated|ascii|clock|collections|cset|current|date|dateline|digits|dump|e|error(?:number|text|value)?|errout|fail|features|file|host|input|lcase|letters|level|line|main|null|output|phi|pi|pos|progname|random|regions|source|storage|subject|time|trace|ucase|version)\b/,alias:"variable"},directive:{pattern:/\$\w+/,alias:"builtin"},keyword:/\b(?:break|by|case|create|default|do|else|end|every|fail|global|if|initial|invocable|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while)\b/,function:/\b(?!\d)\w+(?=\s*[({]|\s*!\s*\[)/,operator:/[+-]:(?!=)|(?:[\/?@^%&]|\+\+?|--?|==?=?|~==?=?|\*\*?|\|\|\|?|<(?:->?|<?=?)|>>?=?)(?::=)?|:(?:=:?)?|[!.\\|~]/,punctuation:/[\[\](){},;]/}}return t=1,e=r,r.displayName="icon",r.aliases=[],e}export{r as __require};
-//# sourceMappingURL=icon.js.map

package/dist/node_modules/refractor/lang/icon.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"icon.js","sources":["../../../../node_modules/refractor/lang/icon.js"],"sourcesContent":["'use strict'\n\nmodule.exports = icon\nicon.displayName = 'icon'\nicon.aliases = []\nfunction icon(Prism) {\n  Prism.languages.icon = {\n    comment: /#.*/,\n    string: {\n      pattern: /([\"'])(?:(?!\\1)[^\\\\\\r\\n_]|\\\\.|_(?!\\1)(?:\\r\\n|[\\s\\S]))*\\1/,\n      greedy: true\n    },\n    number: /\\b(?:\\d+r[a-z\\d]+|\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?)\\b|\\.\\d+\\b/i,\n    'builtin-keyword': {\n      pattern:\n        /&(?:allocated|ascii|clock|collections|cset|current|date|dateline|digits|dump|e|error(?:number|text|value)?|errout|fail|features|file|host|input|lcase|letters|level|line|main|null|output|phi|pi|pos|progname|random|regions|source|storage|subject|time|trace|ucase|version)\\b/,\n      alias: 'variable'\n    },\n    directive: {\n      pattern: /\\$\\w+/,\n      alias: 'builtin'\n    },\n    keyword:\n      /\\b(?:break|by|case|create|default|do|else|end|every|fail|global|if|initial|invocable|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while)\\b/,\n    function: /\\b(?!\\d)\\w+(?=\\s*[({]|\\s*!\\s*\\[)/,\n    operator:\n      /[+-]:(?!=)|(?:[\\/?@^%&]|\\+\\+?|--?|==?=?|~==?=?|\\*\\*?|\\|\\|\\|?|<(?:->?|<?=?)|>>?=?)(?::=)?|:(?:=:?)?|[!.\\\\|~]/,\n    punctuation: /[\\[\\](){},;]/\n  }\n}\n"],"names":["icon","Prism","languages","comment","string","pattern","greedy","number","alias","directive","keyword","function","operator","punctuation","icon_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAKC,GACZA,EAAMC,UAAUF,KAAO,CACrBG,QAAS,MACTC,OAAQ,CACNC,QAAS,2DACTC,QAAQ,GAEVC,OAAQ,4DACR,kBAAmB,CACjBF,QACE,kRACFG,MAAO,YAETC,UAAW,CACTJ,QAAS,QACTG,MAAO,WAETE,QACE,mLACFC,SAAU,mCACVC,SACE,8GACFC,YAAa,eAEjB,YA3BAC,EAAiBd,EACjBA,EAAKe,YAAc,OACnBf,EAAKgB,QAAU"}

package/dist/node_modules/refractor/lang/icu-message-format.js

@@ -1,2 +0,0 @@
-var e,s;function t(){if(s)return e;function t(e){!function(e){function s(e,t){return t<=0?/[]/.source:e.replace(/<SELF>/g,(function(){return s(e,t-1)}))}var t=/'[{}:=,](?:[^']|'')*'(?!')/,n={pattern:/''/,greedy:!0,alias:"operator"},r={pattern:t,greedy:!0,inside:{escape:n}},a=s(/\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\}/.source.replace(/<STR>/g,(function(){return t.source})),8),i={pattern:RegExp(a),inside:{message:{pattern:/^(\{)[\s\S]+(?=\}$)/,lookbehind:!0,inside:null},"message-delimiter":{pattern:/./,alias:"punctuation"}}};e.languages["icu-message-format"]={argument:{pattern:RegExp(a),greedy:!0,inside:{content:{pattern:/^(\{)[\s\S]+(?=\}$)/,lookbehind:!0,inside:{"argument-name":{pattern:/^(\s*)[^{}:=,\s]+/,lookbehind:!0},"choice-style":{pattern:/^(\s*,\s*choice\s*,\s*)\S(?:[\s\S]*\S)?/,lookbehind:!0,inside:{punctuation:/\|/,range:{pattern:/^(\s*)[+-]?(?:\d+(?:\.\d*)?|\u221e)\s*[<#\u2264]/,lookbehind:!0,inside:{operator:/[<#\u2264]/,number:/\S+/}},rest:null}},"plural-style":{pattern:/^(\s*,\s*(?:plural|selectordinal)\s*,\s*)\S(?:[\s\S]*\S)?/,lookbehind:!0,inside:{offset:/^offset:\s*\d+/,"nested-message":i,selector:{pattern:/=\d+|[^{}:=,\s]+/,inside:{keyword:/^(?:few|many|one|other|two|zero)$/}}}},"select-style":{pattern:/^(\s*,\s*select\s*,\s*)\S(?:[\s\S]*\S)?/,lookbehind:!0,inside:{"nested-message":i,selector:{pattern:/[^{}:=,\s]+/,inside:{keyword:/^other$/}}}},keyword:/\b(?:choice|plural|select|selectordinal)\b/,"arg-type":{pattern:/\b(?:date|duration|number|ordinal|spellout|time)\b/,alias:"keyword"},"arg-skeleton":{pattern:/(,\s*)::[^{}:=,\s]+/,lookbehind:!0},"arg-style":{pattern:/(,\s*)(?:currency|full|integer|long|medium|percent|short)(?=\s*$)/,lookbehind:!0},"arg-style-text":{pattern:RegExp(/(^\s*,\s*(?=\S))/.source+s(/(?:[^{}']|'[^']*'|\{(?:<SELF>)?\})+/.source,8)+"$"),lookbehind:!0,alias:"string"},punctuation:/,/}},"argument-delimiter":{pattern:/./,alias:"operator"}}},escape:n,string:r},i.inside.message.inside=e.languages["icu-message-format"],e.languages["icu-message-format"].argument.inside.content.inside["choice-style"].inside.rest=e.languages["icu-message-format"]}(e)}return s=1,e=t,t.displayName="icuMessageFormat",t.aliases=[],e}export{t as __require};
-//# sourceMappingURL=icu-message-format.js.map

package/dist/node_modules/refractor/lang/icu-message-format.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"icu-message-format.js","sources":["../../../../node_modules/refractor/lang/icu-message-format.js"],"sourcesContent":["'use strict'\n\nmodule.exports = icuMessageFormat\nicuMessageFormat.displayName = 'icuMessageFormat'\nicuMessageFormat.aliases = []\nfunction icuMessageFormat(Prism) {\n  // https://unicode-org.github.io/icu/userguide/format_parse/messages/\n  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/MessageFormat.html\n  ;(function (Prism) {\n    /**\n     * @param {string} source\n     * @param {number} level\n     * @returns {string}\n     */\n    function nested(source, level) {\n      if (level <= 0) {\n        return /[]/.source\n      } else {\n        return source.replace(/<SELF>/g, function () {\n          return nested(source, level - 1)\n        })\n      }\n    }\n    var stringPattern = /'[{}:=,](?:[^']|'')*'(?!')/\n    var escape = {\n      pattern: /''/,\n      greedy: true,\n      alias: 'operator'\n    }\n    var string = {\n      pattern: stringPattern,\n      greedy: true,\n      inside: {\n        escape: escape\n      }\n    }\n    var argumentSource = nested(\n      /\\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\\}/.source.replace(\n        /<STR>/g,\n        function () {\n          return stringPattern.source\n        }\n      ),\n      8\n    )\n    var nestedMessage = {\n      pattern: RegExp(argumentSource),\n      inside: {\n        message: {\n          pattern: /^(\\{)[\\s\\S]+(?=\\}$)/,\n          lookbehind: true,\n          inside: null // see below\n        },\n        'message-delimiter': {\n          pattern: /./,\n          alias: 'punctuation'\n        }\n      }\n    }\n    Prism.languages['icu-message-format'] = {\n      argument: {\n        pattern: RegExp(argumentSource),\n        greedy: true,\n        inside: {\n          content: {\n            pattern: /^(\\{)[\\s\\S]+(?=\\}$)/,\n            lookbehind: true,\n            inside: {\n              'argument-name': {\n                pattern: /^(\\s*)[^{}:=,\\s]+/,\n                lookbehind: true\n              },\n              'choice-style': {\n                // https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1ChoiceFormat.html#details\n                pattern: /^(\\s*,\\s*choice\\s*,\\s*)\\S(?:[\\s\\S]*\\S)?/,\n                lookbehind: true,\n                inside: {\n                  punctuation: /\\|/,\n                  range: {\n                    pattern: /^(\\s*)[+-]?(?:\\d+(?:\\.\\d*)?|\\u221e)\\s*[<#\\u2264]/,\n                    lookbehind: true,\n                    inside: {\n                      operator: /[<#\\u2264]/,\n                      number: /\\S+/\n                    }\n                  },\n                  rest: null // see below\n                }\n              },\n              'plural-style': {\n                // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/PluralFormat.html#:~:text=Patterns%20and%20Their%20Interpretation\n                pattern:\n                  /^(\\s*,\\s*(?:plural|selectordinal)\\s*,\\s*)\\S(?:[\\s\\S]*\\S)?/,\n                lookbehind: true,\n                inside: {\n                  offset: /^offset:\\s*\\d+/,\n                  'nested-message': nestedMessage,\n                  selector: {\n                    pattern: /=\\d+|[^{}:=,\\s]+/,\n                    inside: {\n                      keyword: /^(?:few|many|one|other|two|zero)$/\n                    }\n                  }\n                }\n              },\n              'select-style': {\n                // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/SelectFormat.html#:~:text=Patterns%20and%20Their%20Interpretation\n                pattern: /^(\\s*,\\s*select\\s*,\\s*)\\S(?:[\\s\\S]*\\S)?/,\n                lookbehind: true,\n                inside: {\n                  'nested-message': nestedMessage,\n                  selector: {\n                    pattern: /[^{}:=,\\s]+/,\n                    inside: {\n                      keyword: /^other$/\n                    }\n                  }\n                }\n              },\n              keyword: /\\b(?:choice|plural|select|selectordinal)\\b/,\n              'arg-type': {\n                pattern: /\\b(?:date|duration|number|ordinal|spellout|time)\\b/,\n                alias: 'keyword'\n              },\n              'arg-skeleton': {\n                pattern: /(,\\s*)::[^{}:=,\\s]+/,\n                lookbehind: true\n              },\n              'arg-style': {\n                pattern:\n                  /(,\\s*)(?:currency|full|integer|long|medium|percent|short)(?=\\s*$)/,\n                lookbehind: true\n              },\n              'arg-style-text': {\n                pattern: RegExp(\n                  /(^\\s*,\\s*(?=\\S))/.source +\n                    nested(/(?:[^{}']|'[^']*'|\\{(?:<SELF>)?\\})+/.source, 8) +\n                    '$'\n                ),\n                lookbehind: true,\n                alias: 'string'\n              },\n              punctuation: /,/\n            }\n          },\n          'argument-delimiter': {\n            pattern: /./,\n            alias: 'operator'\n          }\n        }\n      },\n      escape: escape,\n      string: string\n    }\n    nestedMessage.inside.message.inside = Prism.languages['icu-message-format']\n    Prism.languages['icu-message-format'].argument.inside.content.inside[\n      'choice-style'\n    ].inside.rest = Prism.languages['icu-message-format']\n  })(Prism)\n}\n"],"names":["icuMessageFormat","Prism","nested","source","level","replace","stringPattern","escape","pattern","greedy","alias","string","inside","argumentSource","nestedMessage","RegExp","message","lookbehind","languages","argument","content","punctuation","range","operator","number","rest","offset","selector","keyword","icuMessageFormat_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAiBC,IAGvB,SAAWA,GAMV,SAASC,EAAOC,EAAQC,GACtB,OAAIA,GAAS,EACJ,KAAKD,OAELA,EAAOE,QAAQ,WAAW,WAC/B,OAAOH,EAAOC,EAAQC,EAAQ,EACxC,GAEK,CACD,IAAIE,EAAgB,6BAChBC,EAAS,CACXC,QAAS,KACTC,QAAQ,EACRC,MAAO,YAELC,EAAS,CACXH,QAASF,EACTG,QAAQ,EACRG,OAAQ,CACNL,OAAQA,IAGRM,EAAiBX,EACnB,8CAA8CC,OAAOE,QACnD,UACA,WACE,OAAOC,EAAcH,MACtB,IAEH,GAEEW,EAAgB,CAClBN,QAASO,OAAOF,GAChBD,OAAQ,CACNI,QAAS,CACPR,QAAS,sBACTS,YAAY,EACZL,OAAQ,MAEV,oBAAqB,CACnBJ,QAAS,IACTE,MAAO,iBAIbT,EAAMiB,UAAU,sBAAwB,CACtCC,SAAU,CACRX,QAASO,OAAOF,GAChBJ,QAAQ,EACRG,OAAQ,CACNQ,QAAS,CACPZ,QAAS,sBACTS,YAAY,EACZL,OAAQ,CACN,gBAAiB,CACfJ,QAAS,oBACTS,YAAY,GAEd,eAAgB,CAEdT,QAAS,0CACTS,YAAY,EACZL,OAAQ,CACNS,YAAa,KACbC,MAAO,CACLd,QAAS,mDACTS,YAAY,EACZL,OAAQ,CACNW,SAAU,aACVC,OAAQ,QAGZC,KAAM,OAGV,eAAgB,CAEdjB,QACE,4DACFS,YAAY,EACZL,OAAQ,CACNc,OAAQ,iBACR,iBAAkBZ,EAClBa,SAAU,CACRnB,QAAS,mBACTI,OAAQ,CACNgB,QAAS,wCAKjB,eAAgB,CAEdpB,QAAS,0CACTS,YAAY,EACZL,OAAQ,CACN,iBAAkBE,EAClBa,SAAU,CACRnB,QAAS,cACTI,OAAQ,CACNgB,QAAS,cAKjBA,QAAS,6CACT,WAAY,CACVpB,QAAS,qDACTE,MAAO,WAET,eAAgB,CACdF,QAAS,sBACTS,YAAY,GAEd,YAAa,CACXT,QACE,oEACFS,YAAY,GAEd,iBAAkB,CAChBT,QAASO,OACP,mBAAmBZ,OACjBD,EAAO,sCAAsCC,OAAQ,GACrD,KAEJc,YAAY,EACZP,MAAO,UAETW,YAAa,MAGjB,qBAAsB,CACpBb,QAAS,IACTE,MAAO,cAIbH,OAAQA,EACRI,OAAQA,GAEVG,EAAcF,OAAOI,QAAQJ,OAASX,EAAMiB,UAAU,sBACtDjB,EAAMiB,UAAU,sBAAsBC,SAASP,OAAOQ,QAAQR,OAC5D,gBACAA,OAAOa,KAAOxB,EAAMiB,UAAU,qBACjC,CAtJA,CAsJEjB,EACL,YA7JA4B,EAAiB7B,EACjBA,EAAiB8B,YAAc,mBAC/B9B,EAAiB+B,QAAU"}

package/dist/node_modules/refractor/lang/idris.js

@@ -1,2 +0,0 @@
-import{__require as e}from"./haskell.js";var i,r;function t(){if(r)return i;r=1;var t=e();function a(e){e.register(t),e.languages.idris=e.languages.extend("haskell",{comment:{pattern:/(?:(?:--|\|\|\|).*$|\{-[\s\S]*?-\})/m},keyword:/\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\b/,builtin:void 0}),e.languages.insertBefore("idris","keyword",{"import-statement":{pattern:/(^\s*import\s+)(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*/m,lookbehind:!0,inside:{punctuation:/\./}}}),e.languages.idr=e.languages.idris}return i=a,a.displayName="idris",a.aliases=["idr"],i}export{t as __require};
-//# sourceMappingURL=idris.js.map

package/dist/node_modules/refractor/lang/idris.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"idris.js","sources":["../../../../node_modules/refractor/lang/idris.js"],"sourcesContent":["'use strict'\nvar refractorHaskell = require('./haskell.js')\nmodule.exports = idris\nidris.displayName = 'idris'\nidris.aliases = ['idr']\nfunction idris(Prism) {\n  Prism.register(refractorHaskell)\n  Prism.languages.idris = Prism.languages.extend('haskell', {\n    comment: {\n      pattern: /(?:(?:--|\\|\\|\\|).*$|\\{-[\\s\\S]*?-\\})/m\n    },\n    keyword:\n      /\\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\\b/,\n    builtin: undefined\n  })\n  Prism.languages.insertBefore('idris', 'keyword', {\n    'import-statement': {\n      pattern: /(^\\s*import\\s+)(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*/m,\n      lookbehind: true,\n      inside: {\n        punctuation: /\\./\n      }\n    }\n  })\n  Prism.languages.idr = Prism.languages.idris\n}\n"],"names":["refractorHaskell","require$$0","idris","Prism","register","languages","extend","comment","pattern","keyword","builtin","undefined","insertBefore","lookbehind","inside","punctuation","idr","idris_1","displayName","aliases"],"mappings":"gFACA,IAAIA,EAAmBC,IAIvB,SAASC,EAAMC,GACbA,EAAMC,SAASJ,GACfG,EAAME,UAAUH,MAAQC,EAAME,UAAUC,OAAO,UAAW,CACxDC,QAAS,CACPC,QAAS,wCAEXC,QACE,kTACFC,aAASC,IAEXR,EAAME,UAAUO,aAAa,QAAS,UAAW,CAC/C,mBAAoB,CAClBJ,QAAS,oDACTK,YAAY,EACZC,OAAQ,CACNC,YAAa,SAInBZ,EAAME,UAAUW,IAAMb,EAAME,UAAUH,KACxC,QAvBAe,EAAiBf,EACjBA,EAAMgB,YAAc,QACpBhB,EAAMiB,QAAU,CAAC"}

package/dist/node_modules/refractor/lang/iecst.js

@@ -1,2 +0,0 @@
-var T,E;function N(){if(E)return T;function N(T){T.languages.iecst={comment:[{pattern:/(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,lookbehind:!0,greedy:!0},{pattern:/(^|[^\\:])\/\/.*/,lookbehind:!0,greedy:!0}],string:{pattern:/(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,greedy:!0},keyword:[/\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i,/\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/],"class-name":/\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/,address:{pattern:/%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/,alias:"symbol"},number:/\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,boolean:/\b(?:FALSE|NULL|TRUE)\b/,operator:/S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,function:/\b[a-z_]\w*(?=\s*\()/i,punctuation:/[()[\].,;]/}}return E=1,T=N,N.displayName="iecst",N.aliases=[],T}export{N as __require};
-//# sourceMappingURL=iecst.js.map

package/dist/node_modules/refractor/lang/iecst.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"iecst.js","sources":["../../../../node_modules/refractor/lang/iecst.js"],"sourcesContent":["'use strict'\n\nmodule.exports = iecst\niecst.displayName = 'iecst'\niecst.aliases = []\nfunction iecst(Prism) {\n  Prism.languages.iecst = {\n    comment: [\n      {\n        pattern:\n          /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?(?:\\*\\/|$)|\\(\\*[\\s\\S]*?(?:\\*\\)|$)|\\{[\\s\\S]*?(?:\\}|$))/,\n        lookbehind: true,\n        greedy: true\n      },\n      {\n        pattern: /(^|[^\\\\:])\\/\\/.*/,\n        lookbehind: true,\n        greedy: true\n      }\n    ],\n    string: {\n      pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    keyword: [\n      /\\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\\b/i,\n      /\\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\\b/\n    ],\n    'class-name':\n      /\\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\\b/,\n    address: {\n      pattern: /%[IQM][XBWDL][\\d.]*|%[IQ][\\d.]*/,\n      alias: 'symbol'\n    },\n    number:\n      /\\b(?:16#[\\da-f]+|2#[01_]+|0x[\\da-f]+)\\b|\\b(?:D|DT|T|TOD)#[\\d_shmd:]*|\\b[A-Z]*#[\\d.,_]*|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i,\n    boolean: /\\b(?:FALSE|NULL|TRUE)\\b/,\n    operator:\n      /S?R?:?=>?|&&?|\\*\\*?|<[=>]?|>=?|[-:^/+#]|\\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\\b/,\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n    punctuation: /[()[\\].,;]/\n  }\n}\n"],"names":["iecst","Prism","languages","comment","pattern","lookbehind","greedy","string","keyword","address","alias","number","boolean","operator","function","punctuation","iecst_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAMC,GACbA,EAAMC,UAAUF,MAAQ,CACtBG,QAAS,CACP,CACEC,QACE,gFACFC,YAAY,EACZC,QAAQ,GAEV,CACEF,QAAS,mBACTC,YAAY,EACZC,QAAQ,IAGZC,OAAQ,CACNH,QAAS,iDACTE,QAAQ,GAEVE,QAAS,CACP,yPACA,yPAEF,aACE,4HACFC,QAAS,CACPL,QAAS,kCACTM,MAAO,UAETC,OACE,oIACFC,QAAS,0BACTC,SACE,4FACFC,SAAU,wBACVC,YAAa,aAEjB,YAxCAC,EAAiBhB,EACjBA,EAAMiB,YAAc,QACpBjB,EAAMkB,QAAU"}

package/dist/node_modules/refractor/lang/ignore.js

@@ -1,2 +0,0 @@
-var n,e;function g(){if(e)return n;function g(n){!function(n){n.languages.ignore={comment:/^#.*/m,entry:{pattern:/\S(?:.*(?:(?:\\ )|\S))?/,alias:"string",inside:{operator:/^!|\*\*?|\?/,regex:{pattern:/(^|[^\\])\[[^\[\]]*\]/,lookbehind:!0},punctuation:/\//}}},n.languages.gitignore=n.languages.ignore,n.languages.hgignore=n.languages.ignore,n.languages.npmignore=n.languages.ignore}(n)}return e=1,n=g,g.displayName="ignore",g.aliases=["gitignore","hgignore","npmignore"],n}export{g as __require};
-//# sourceMappingURL=ignore.js.map

package/dist/node_modules/refractor/lang/ignore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ignore.js","sources":["../../../../node_modules/refractor/lang/ignore.js"],"sourcesContent":["'use strict'\n\nmodule.exports = ignore\nignore.displayName = 'ignore'\nignore.aliases = ['gitignore', 'hgignore', 'npmignore']\nfunction ignore(Prism) {\n  ;(function (Prism) {\n    Prism.languages.ignore = {\n      // https://git-scm.com/docs/gitignore\n      comment: /^#.*/m,\n      entry: {\n        pattern: /\\S(?:.*(?:(?:\\\\ )|\\S))?/,\n        alias: 'string',\n        inside: {\n          operator: /^!|\\*\\*?|\\?/,\n          regex: {\n            pattern: /(^|[^\\\\])\\[[^\\[\\]]*\\]/,\n            lookbehind: true\n          },\n          punctuation: /\\//\n        }\n      }\n    }\n    Prism.languages.gitignore = Prism.languages.ignore\n    Prism.languages.hgignore = Prism.languages.ignore\n    Prism.languages.npmignore = Prism.languages.ignore\n  })(Prism)\n}\n"],"names":["ignore","Prism","languages","comment","entry","pattern","alias","inside","operator","regex","lookbehind","punctuation","gitignore","hgignore","npmignore","ignore_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAOC,IACb,SAAWA,GACVA,EAAMC,UAAUF,OAAS,CAEvBG,QAAS,QACTC,MAAO,CACLC,QAAS,0BACTC,MAAO,SACPC,OAAQ,CACNC,SAAU,cACVC,MAAO,CACLJ,QAAS,wBACTK,YAAY,GAEdC,YAAa,QAInBV,EAAMC,UAAUU,UAAYX,EAAMC,UAAUF,OAC5CC,EAAMC,UAAUW,SAAWZ,EAAMC,UAAUF,OAC3CC,EAAMC,UAAUY,UAAYb,EAAMC,UAAUF,MAC7C,CApBA,CAoBEC,EACL,YAzBAc,EAAiBf,EACjBA,EAAOgB,YAAc,SACrBhB,EAAOiB,QAAU,CAAC,YAAa,WAAY"}

package/dist/node_modules/refractor/lang/inform7.js

@@ -1,2 +0,0 @@
-var e,n;function i(){if(n)return e;function i(e){e.languages.inform7={string:{pattern:/"[^"]*"/,inside:{substitution:{pattern:/\[[^\[\]]+\]/,inside:{delimiter:{pattern:/\[|\]/,alias:"punctuation"}}}}},comment:{pattern:/\[[^\[\]]+\]/,greedy:!0},title:{pattern:/^[ \t]*(?:book|chapter|part(?! of)|section|table|volume)\b.+/im,alias:"important"},number:{pattern:/(^|[^-])(?:\b\d+(?:\.\d+)?(?:\^\d+)?(?:(?!\d)\w+)?|\b(?:eight|eleven|five|four|nine|one|seven|six|ten|three|twelve|two))\b(?!-)/i,lookbehind:!0},verb:{pattern:/(^|[^-])\b(?:answering|applying to|are|asking|attacking|be(?:ing)?|burning|buying|called|carries|carry(?! out)|carrying|climbing|closing|conceal(?:ing|s)?|consulting|contain(?:ing|s)?|cutting|drinking|dropping|eating|enclos(?:es?|ing)|entering|examining|exiting|getting|giving|going|ha(?:s|ve|ving)|hold(?:ing|s)?|impl(?:ies|y)|incorporat(?:es?|ing)|inserting|is|jumping|kissing|listening|locking|looking|mean(?:ing|s)?|opening|provid(?:es?|ing)|pulling|pushing|putting|relat(?:es?|ing)|removing|searching|see(?:ing|s)?|setting|showing|singing|sleeping|smelling|squeezing|support(?:ing|s)?|swearing|switching|taking|tasting|telling|thinking|throwing|touching|turning|tying|unlock(?:ing|s)?|var(?:ies|y|ying)|waiting|waking|waving|wear(?:ing|s)?)\b(?!-)/i,lookbehind:!0,alias:"operator"},keyword:{pattern:/(^|[^-])\b(?:after|before|carry out|check|continue the action|definition(?= *:)|do nothing|else|end (?:if|the story|unless)|every turn|if|include|instead(?: of)?|let|move|no|now|otherwise|repeat|report|resume the story|rule for|running through|say(?:ing)?|stop the action|test|try(?:ing)?|understand|unless|use|when|while|yes)\b(?!-)/i,lookbehind:!0},property:{pattern:/(^|[^-])\b(?:adjacent(?! to)|carried|closed|concealed|contained|dark|described|edible|empty|enclosed|enterable|even|female|fixed in place|full|handled|held|improper-named|incorporated|inedible|invisible|lighted|lit|lock(?:able|ed)|male|marked for listing|mentioned|negative|neuter|non-(?:empty|full|recurring)|odd|opaque|open(?:able)?|plural-named|portable|positive|privately-named|proper-named|provided|publically-named|pushable between rooms|recurring|related|rubbing|scenery|seen|singular-named|supported|swinging|switch(?:able|ed(?: off| on)?)|touch(?:able|ed)|transparent|unconcealed|undescribed|unlit|unlocked|unmarked for listing|unmentioned|unopenable|untouchable|unvisited|variable|visible|visited|wearable|worn)\b(?!-)/i,lookbehind:!0,alias:"symbol"},position:{pattern:/(^|[^-])\b(?:above|adjacent to|back side of|below|between|down|east|everywhere|front side|here|in|inside(?: from)?|north(?:east|west)?|nowhere|on(?: top of)?|other side|outside(?: from)?|parts? of|regionally in|south(?:east|west)?|through|up|west|within)\b(?!-)/i,lookbehind:!0,alias:"keyword"},type:{pattern:/(^|[^-])\b(?:actions?|activit(?:ies|y)|actors?|animals?|backdrops?|containers?|devices?|directions?|doors?|holders?|kinds?|lists?|m[ae]n|nobody|nothing|nouns?|numbers?|objects?|people|persons?|player(?:'s holdall)?|regions?|relations?|rooms?|rule(?:book)?s?|scenes?|someone|something|supporters?|tables?|texts?|things?|time|vehicles?|wom[ae]n)\b(?!-)/i,lookbehind:!0,alias:"variable"},punctuation:/[.,:;(){}]/},e.languages.inform7.string.inside.substitution.inside.rest=e.languages.inform7,e.languages.inform7.string.inside.substitution.inside.rest.text={pattern:/\S(?:\s*\S)*/,alias:"comment"}}return n=1,e=i,i.displayName="inform7",i.aliases=[],e}export{i as __require};
-//# sourceMappingURL=inform7.js.map

package/dist/node_modules/refractor/lang/inform7.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"inform7.js","sources":["../../../../node_modules/refractor/lang/inform7.js"],"sourcesContent":["'use strict'\n\nmodule.exports = inform7\ninform7.displayName = 'inform7'\ninform7.aliases = []\nfunction inform7(Prism) {\n  Prism.languages.inform7 = {\n    string: {\n      pattern: /\"[^\"]*\"/,\n      inside: {\n        substitution: {\n          pattern: /\\[[^\\[\\]]+\\]/,\n          inside: {\n            delimiter: {\n              pattern: /\\[|\\]/,\n              alias: 'punctuation'\n            } // See rest below\n          }\n        }\n      }\n    },\n    comment: {\n      pattern: /\\[[^\\[\\]]+\\]/,\n      greedy: true\n    },\n    title: {\n      pattern: /^[ \\t]*(?:book|chapter|part(?! of)|section|table|volume)\\b.+/im,\n      alias: 'important'\n    },\n    number: {\n      pattern:\n        /(^|[^-])(?:\\b\\d+(?:\\.\\d+)?(?:\\^\\d+)?(?:(?!\\d)\\w+)?|\\b(?:eight|eleven|five|four|nine|one|seven|six|ten|three|twelve|two))\\b(?!-)/i,\n      lookbehind: true\n    },\n    verb: {\n      pattern:\n        /(^|[^-])\\b(?:answering|applying to|are|asking|attacking|be(?:ing)?|burning|buying|called|carries|carry(?! out)|carrying|climbing|closing|conceal(?:ing|s)?|consulting|contain(?:ing|s)?|cutting|drinking|dropping|eating|enclos(?:es?|ing)|entering|examining|exiting|getting|giving|going|ha(?:s|ve|ving)|hold(?:ing|s)?|impl(?:ies|y)|incorporat(?:es?|ing)|inserting|is|jumping|kissing|listening|locking|looking|mean(?:ing|s)?|opening|provid(?:es?|ing)|pulling|pushing|putting|relat(?:es?|ing)|removing|searching|see(?:ing|s)?|setting|showing|singing|sleeping|smelling|squeezing|support(?:ing|s)?|swearing|switching|taking|tasting|telling|thinking|throwing|touching|turning|tying|unlock(?:ing|s)?|var(?:ies|y|ying)|waiting|waking|waving|wear(?:ing|s)?)\\b(?!-)/i,\n      lookbehind: true,\n      alias: 'operator'\n    },\n    keyword: {\n      pattern:\n        /(^|[^-])\\b(?:after|before|carry out|check|continue the action|definition(?= *:)|do nothing|else|end (?:if|the story|unless)|every turn|if|include|instead(?: of)?|let|move|no|now|otherwise|repeat|report|resume the story|rule for|running through|say(?:ing)?|stop the action|test|try(?:ing)?|understand|unless|use|when|while|yes)\\b(?!-)/i,\n      lookbehind: true\n    },\n    property: {\n      pattern:\n        /(^|[^-])\\b(?:adjacent(?! to)|carried|closed|concealed|contained|dark|described|edible|empty|enclosed|enterable|even|female|fixed in place|full|handled|held|improper-named|incorporated|inedible|invisible|lighted|lit|lock(?:able|ed)|male|marked for listing|mentioned|negative|neuter|non-(?:empty|full|recurring)|odd|opaque|open(?:able)?|plural-named|portable|positive|privately-named|proper-named|provided|publically-named|pushable between rooms|recurring|related|rubbing|scenery|seen|singular-named|supported|swinging|switch(?:able|ed(?: off| on)?)|touch(?:able|ed)|transparent|unconcealed|undescribed|unlit|unlocked|unmarked for listing|unmentioned|unopenable|untouchable|unvisited|variable|visible|visited|wearable|worn)\\b(?!-)/i,\n      lookbehind: true,\n      alias: 'symbol'\n    },\n    position: {\n      pattern:\n        /(^|[^-])\\b(?:above|adjacent to|back side of|below|between|down|east|everywhere|front side|here|in|inside(?: from)?|north(?:east|west)?|nowhere|on(?: top of)?|other side|outside(?: from)?|parts? of|regionally in|south(?:east|west)?|through|up|west|within)\\b(?!-)/i,\n      lookbehind: true,\n      alias: 'keyword'\n    },\n    type: {\n      pattern:\n        /(^|[^-])\\b(?:actions?|activit(?:ies|y)|actors?|animals?|backdrops?|containers?|devices?|directions?|doors?|holders?|kinds?|lists?|m[ae]n|nobody|nothing|nouns?|numbers?|objects?|people|persons?|player(?:'s holdall)?|regions?|relations?|rooms?|rule(?:book)?s?|scenes?|someone|something|supporters?|tables?|texts?|things?|time|vehicles?|wom[ae]n)\\b(?!-)/i,\n      lookbehind: true,\n      alias: 'variable'\n    },\n    punctuation: /[.,:;(){}]/\n  }\n  Prism.languages.inform7['string'].inside['substitution'].inside.rest =\n    Prism.languages.inform7 // We don't want the remaining text in the substitution to be highlighted as the string.\n  Prism.languages.inform7['string'].inside['substitution'].inside.rest.text = {\n    pattern: /\\S(?:\\s*\\S)*/,\n    alias: 'comment'\n  }\n}\n"],"names":["inform7","Prism","languages","string","pattern","inside","substitution","delimiter","alias","comment","greedy","title","number","lookbehind","verb","keyword","property","position","type","punctuation","rest","text","inform7_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAQC,GACfA,EAAMC,UAAUF,QAAU,CACxBG,OAAQ,CACNC,QAAS,UACTC,OAAQ,CACNC,aAAc,CACZF,QAAS,eACTC,OAAQ,CACNE,UAAW,CACTH,QAAS,QACTI,MAAO,mBAMjBC,QAAS,CACPL,QAAS,eACTM,QAAQ,GAEVC,MAAO,CACLP,QAAS,iEACTI,MAAO,aAETI,OAAQ,CACNR,QACE,mIACFS,YAAY,GAEdC,KAAM,CACJV,QACE,ovBACFS,YAAY,EACZL,MAAO,YAETO,QAAS,CACPX,QACE,iVACFS,YAAY,GAEdG,SAAU,CACRZ,QACE,4tBACFS,YAAY,EACZL,MAAO,UAETS,SAAU,CACRb,QACE,yQACFS,YAAY,EACZL,MAAO,WAETU,KAAM,CACJd,QACE,kWACFS,YAAY,EACZL,MAAO,YAETW,YAAa,cAEflB,EAAMC,UAAUF,QAAgB,OAAEK,OAAqB,aAAEA,OAAOe,KAC9DnB,EAAMC,UAAUF,QAClBC,EAAMC,UAAUF,QAAgB,OAAEK,OAAqB,aAAEA,OAAOe,KAAKC,KAAO,CAC1EjB,QAAS,eACTI,MAAO,UAEX,YArEAc,EAAiBtB,EACjBA,EAAQuB,YAAc,UACtBvB,EAAQwB,QAAU"}

package/dist/node_modules/refractor/lang/ini.js

@@ -1,2 +0,0 @@
-var t,n;function e(){if(n)return t;function e(t){t.languages.ini={comment:{pattern:/(^[ \f\t\v]*)[#;][^\n\r]*/m,lookbehind:!0},section:{pattern:/(^[ \f\t\v]*)\[[^\n\r\]]*\]?/m,lookbehind:!0,inside:{"section-name":{pattern:/(^\[[ \f\t\v]*)[^ \f\t\v\]]+(?:[ \f\t\v]+[^ \f\t\v\]]+)*/,lookbehind:!0,alias:"selector"},punctuation:/\[|\]/}},key:{pattern:/(^[ \f\t\v]*)[^ \f\n\r\t\v=]+(?:[ \f\t\v]+[^ \f\n\r\t\v=]+)*(?=[ \f\t\v]*=)/m,lookbehind:!0,alias:"attr-name"},value:{pattern:/(=[ \f\t\v]*)[^ \f\n\r\t\v]+(?:[ \f\t\v]+[^ \f\n\r\t\v]+)*/,lookbehind:!0,alias:"attr-value",inside:{"inner-value":{pattern:/^("|').+(?=\1$)/,lookbehind:!0}}},punctuation:/=/}}return n=1,t=e,e.displayName="ini",e.aliases=[],t}export{e as __require};
-//# sourceMappingURL=ini.js.map

package/dist/node_modules/refractor/lang/ini.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ini.js","sources":["../../../../node_modules/refractor/lang/ini.js"],"sourcesContent":["'use strict'\n\nmodule.exports = ini\nini.displayName = 'ini'\nini.aliases = []\nfunction ini(Prism) {\n  Prism.languages.ini = {\n    /**\n     * The component mimics the behavior of the Win32 API parser.\n     *\n     * @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723}\n     */\n    comment: {\n      pattern: /(^[ \\f\\t\\v]*)[#;][^\\n\\r]*/m,\n      lookbehind: true\n    },\n    section: {\n      pattern: /(^[ \\f\\t\\v]*)\\[[^\\n\\r\\]]*\\]?/m,\n      lookbehind: true,\n      inside: {\n        'section-name': {\n          pattern: /(^\\[[ \\f\\t\\v]*)[^ \\f\\t\\v\\]]+(?:[ \\f\\t\\v]+[^ \\f\\t\\v\\]]+)*/,\n          lookbehind: true,\n          alias: 'selector'\n        },\n        punctuation: /\\[|\\]/\n      }\n    },\n    key: {\n      pattern:\n        /(^[ \\f\\t\\v]*)[^ \\f\\n\\r\\t\\v=]+(?:[ \\f\\t\\v]+[^ \\f\\n\\r\\t\\v=]+)*(?=[ \\f\\t\\v]*=)/m,\n      lookbehind: true,\n      alias: 'attr-name'\n    },\n    value: {\n      pattern: /(=[ \\f\\t\\v]*)[^ \\f\\n\\r\\t\\v]+(?:[ \\f\\t\\v]+[^ \\f\\n\\r\\t\\v]+)*/,\n      lookbehind: true,\n      alias: 'attr-value',\n      inside: {\n        'inner-value': {\n          pattern: /^(\"|').+(?=\\1$)/,\n          lookbehind: true\n        }\n      }\n    },\n    punctuation: /=/\n  }\n}\n"],"names":["ini","Prism","languages","comment","pattern","lookbehind","section","inside","alias","punctuation","key","value","ini_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAIC,GACXA,EAAMC,UAAUF,IAAM,CAMpBG,QAAS,CACPC,QAAS,6BACTC,YAAY,GAEdC,QAAS,CACPF,QAAS,gCACTC,YAAY,EACZE,OAAQ,CACN,eAAgB,CACdH,QAAS,2DACTC,YAAY,EACZG,MAAO,YAETC,YAAa,UAGjBC,IAAK,CACHN,QACE,+EACFC,YAAY,EACZG,MAAO,aAETG,MAAO,CACLP,QAAS,6DACTC,YAAY,EACZG,MAAO,aACPD,OAAQ,CACN,cAAe,CACbH,QAAS,kBACTC,YAAY,KAIlBI,YAAa,IAEjB,YA7CAG,EAAiBZ,EACjBA,EAAIa,YAAc,MAClBb,EAAIc,QAAU"}

package/dist/node_modules/refractor/lang/io.js

@@ -1,2 +0,0 @@
-var e,r;function t(){if(r)return e;function t(e){e.languages.io={comment:{pattern:/(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*|#.*)/,lookbehind:!0,greedy:!0},"triple-quoted-string":{pattern:/"""(?:\\[\s\S]|(?!""")[^\\])*"""/,greedy:!0,alias:"string"},string:{pattern:/"(?:\\.|[^\\\r\n"])*"/,greedy:!0},keyword:/\b(?:activate|activeCoroCount|asString|block|break|call|catch|clone|collectGarbage|compileString|continue|do|doFile|doMessage|doString|else|elseif|exit|for|foreach|forward|getEnvironmentVariable|getSlot|hasSlot|if|ifFalse|ifNil|ifNilEval|ifTrue|isActive|isNil|isResumable|list|message|method|parent|pass|pause|perform|performWithArgList|print|println|proto|raise|raiseResumable|removeSlot|resend|resume|schedulerSleepSeconds|self|sender|setSchedulerSleepSeconds|setSlot|shallowCopy|slotNames|super|system|then|thisBlock|thisContext|try|type|uniqueId|updateSlot|wait|while|write|yield)\b/,builtin:/\b(?:Array|AudioDevice|AudioMixer|BigNum|Block|Box|Buffer|CFunction|CGI|Color|Curses|DBM|DNSResolver|DOConnection|DOProxy|DOServer|Date|Directory|Duration|DynLib|Error|Exception|FFT|File|Fnmatch|Font|Future|GL|GLE|GLScissor|GLU|GLUCylinder|GLUQuadric|GLUSphere|GLUT|Host|Image|Importer|LinkList|List|Lobby|Locals|MD5|MP3Decoder|MP3Encoder|Map|Message|Movie|Notification|Number|Object|OpenGL|Point|Protos|Random|Regex|SGML|SGMLElement|SGMLParser|SQLite|Sequence|Server|ShowMessage|SleepyCat|SleepyCatCursor|Socket|SocketManager|Sound|Soup|Store|String|Tree|UDPSender|UPDReceiver|URL|User|Warning|WeakLink)\b/,boolean:/\b(?:false|nil|true)\b/,number:/\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e-?\d+)?/i,operator:/[=!*/%+\-^&|]=|>>?=?|<<?=?|:?:?=|\+\+?|--?|\*\*?|\/\/?|%|\|\|?|&&?|\b(?:and|not|or|return)\b|@@?|\?\??|\.\./,punctuation:/[{}[\];(),.:]/}}return r=1,e=t,t.displayName="io",t.aliases=[],e}export{t as __require};
-//# sourceMappingURL=io.js.map

package/dist/node_modules/refractor/lang/io.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"io.js","sources":["../../../../node_modules/refractor/lang/io.js"],"sourcesContent":["'use strict'\n\nmodule.exports = io\nio.displayName = 'io'\nio.aliases = []\nfunction io(Prism) {\n  Prism.languages.io = {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?(?:\\*\\/|$)|\\/\\/.*|#.*)/,\n      lookbehind: true,\n      greedy: true\n    },\n    'triple-quoted-string': {\n      pattern: /\"\"\"(?:\\\\[\\s\\S]|(?!\"\"\")[^\\\\])*\"\"\"/,\n      greedy: true,\n      alias: 'string'\n    },\n    string: {\n      pattern: /\"(?:\\\\.|[^\\\\\\r\\n\"])*\"/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:activate|activeCoroCount|asString|block|break|call|catch|clone|collectGarbage|compileString|continue|do|doFile|doMessage|doString|else|elseif|exit|for|foreach|forward|getEnvironmentVariable|getSlot|hasSlot|if|ifFalse|ifNil|ifNilEval|ifTrue|isActive|isNil|isResumable|list|message|method|parent|pass|pause|perform|performWithArgList|print|println|proto|raise|raiseResumable|removeSlot|resend|resume|schedulerSleepSeconds|self|sender|setSchedulerSleepSeconds|setSlot|shallowCopy|slotNames|super|system|then|thisBlock|thisContext|try|type|uniqueId|updateSlot|wait|while|write|yield)\\b/,\n    builtin:\n      /\\b(?:Array|AudioDevice|AudioMixer|BigNum|Block|Box|Buffer|CFunction|CGI|Color|Curses|DBM|DNSResolver|DOConnection|DOProxy|DOServer|Date|Directory|Duration|DynLib|Error|Exception|FFT|File|Fnmatch|Font|Future|GL|GLE|GLScissor|GLU|GLUCylinder|GLUQuadric|GLUSphere|GLUT|Host|Image|Importer|LinkList|List|Lobby|Locals|MD5|MP3Decoder|MP3Encoder|Map|Message|Movie|Notification|Number|Object|OpenGL|Point|Protos|Random|Regex|SGML|SGMLElement|SGMLParser|SQLite|Sequence|Server|ShowMessage|SleepyCat|SleepyCatCursor|Socket|SocketManager|Sound|Soup|Store|String|Tree|UDPSender|UPDReceiver|URL|User|Warning|WeakLink)\\b/,\n    boolean: /\\b(?:false|nil|true)\\b/,\n    number: /\\b0x[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e-?\\d+)?/i,\n    operator:\n      /[=!*/%+\\-^&|]=|>>?=?|<<?=?|:?:?=|\\+\\+?|--?|\\*\\*?|\\/\\/?|%|\\|\\|?|&&?|\\b(?:and|not|or|return)\\b|@@?|\\?\\??|\\.\\./,\n    punctuation: /[{}[\\];(),.:]/\n  }\n}\n"],"names":["io","Prism","languages","comment","pattern","lookbehind","greedy","alias","string","keyword","builtin","boolean","number","operator","punctuation","io_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAGC,GACVA,EAAMC,UAAUF,GAAK,CACnBG,QAAS,CACPC,QAAS,iDACTC,YAAY,EACZC,QAAQ,GAEV,uBAAwB,CACtBF,QAAS,mCACTE,QAAQ,EACRC,MAAO,UAETC,OAAQ,CACNJ,QAAS,wBACTE,QAAQ,GAEVG,QACE,6kBACFC,QACE,imBACFC,QAAS,yBACTC,OAAQ,yDACRC,SACE,8GACFC,YAAa,gBAEjB,YA7BAC,EAAiBf,EACjBA,EAAGgB,YAAc,KACjBhB,EAAGiB,QAAU"}

package/dist/node_modules/refractor/lang/j.js

@@ -1,2 +0,0 @@
-var e,a;function r(){if(a)return e;function r(e){e.languages.j={comment:{pattern:/\bNB\..*/,greedy:!0},string:{pattern:/'(?:''|[^'\r\n])*'/,greedy:!0},keyword:/\b(?:(?:CR|LF|adverb|conjunction|def|define|dyad|monad|noun|verb)\b|(?:assert|break|case|catch[dt]?|continue|do|else|elseif|end|fcase|for|for_\w+|goto_\w+|if|label_\w+|return|select|throw|try|while|whilst)\.)/,verb:{pattern:/(?!\^:|;\.|[=!][.:])(?:\{(?:\.|::?)?|p(?:\.\.?|:)|[=!\]]|[<>+*\-%$|,#][.:]?|[?^]\.?|[;\[]:?|[~}"i][.:]|[ACeEIjLor]\.|(?:[_\/\\qsux]|_?\d):)/,alias:"keyword"},number:/\b_?(?:(?!\d:)\d+(?:\.\d+)?(?:(?:ad|ar|[ejpx])_?\d+(?:\.\d+)?)*(?:b_?[\da-z]+(?:\.[\da-z]+)?)?|_\b(?!\.))/,adverb:{pattern:/[~}]|[\/\\]\.?|[bfM]\.|t[.:]/,alias:"builtin"},operator:/[=a][.:]|_\./,conjunction:{pattern:/&(?:\.:?|:)?|[.:@][.:]?|[!D][.:]|[;dHT]\.|`:?|[\^LS]:|"/,alias:"variable"},punctuation:/[()]/}}return a=1,e=r,r.displayName="j",r.aliases=[],e}export{r as __require};
-//# sourceMappingURL=j.js.map

package/dist/node_modules/refractor/lang/j.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"j.js","sources":["../../../../node_modules/refractor/lang/j.js"],"sourcesContent":["'use strict'\n\nmodule.exports = j\nj.displayName = 'j'\nj.aliases = []\nfunction j(Prism) {\n  Prism.languages.j = {\n    comment: {\n      pattern: /\\bNB\\..*/,\n      greedy: true\n    },\n    string: {\n      pattern: /'(?:''|[^'\\r\\n])*'/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:(?:CR|LF|adverb|conjunction|def|define|dyad|monad|noun|verb)\\b|(?:assert|break|case|catch[dt]?|continue|do|else|elseif|end|fcase|for|for_\\w+|goto_\\w+|if|label_\\w+|return|select|throw|try|while|whilst)\\.)/,\n    verb: {\n      // Negative look-ahead prevents bad highlighting\n      // of ^: ;. =. =: !. !:\n      pattern:\n        /(?!\\^:|;\\.|[=!][.:])(?:\\{(?:\\.|::?)?|p(?:\\.\\.?|:)|[=!\\]]|[<>+*\\-%$|,#][.:]?|[?^]\\.?|[;\\[]:?|[~}\"i][.:]|[ACeEIjLor]\\.|(?:[_\\/\\\\qsux]|_?\\d):)/,\n      alias: 'keyword'\n    },\n    number:\n      /\\b_?(?:(?!\\d:)\\d+(?:\\.\\d+)?(?:(?:ad|ar|[ejpx])_?\\d+(?:\\.\\d+)?)*(?:b_?[\\da-z]+(?:\\.[\\da-z]+)?)?|_\\b(?!\\.))/,\n    adverb: {\n      pattern: /[~}]|[\\/\\\\]\\.?|[bfM]\\.|t[.:]/,\n      alias: 'builtin'\n    },\n    operator: /[=a][.:]|_\\./,\n    conjunction: {\n      pattern: /&(?:\\.:?|:)?|[.:@][.:]?|[!D][.:]|[;dHT]\\.|`:?|[\\^LS]:|\"/,\n      alias: 'variable'\n    },\n    punctuation: /[()]/\n  }\n}\n"],"names":["j","Prism","languages","comment","pattern","greedy","string","keyword","verb","alias","number","adverb","operator","conjunction","punctuation","j_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAEC,GACTA,EAAMC,UAAUF,EAAI,CAClBG,QAAS,CACPC,QAAS,WACTC,QAAQ,GAEVC,OAAQ,CACNF,QAAS,qBACTC,QAAQ,GAEVE,QACE,mNACFC,KAAM,CAGJJ,QACE,8IACFK,MAAO,WAETC,OACE,4GACFC,OAAQ,CACNP,QAAS,+BACTK,MAAO,WAETG,SAAU,eACVC,YAAa,CACXT,QAAS,0DACTK,MAAO,YAETK,YAAa,OAEjB,YAnCAC,EAAiBf,EACjBA,EAAEgB,YAAc,IAChBhB,EAAEiB,QAAU"}

package/dist/node_modules/refractor/lang/java.js

@@ -1,2 +0,0 @@
-var e,n;function t(){if(n)return e;function t(e){!function(e){var n=/\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/,t=/(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source,a={pattern:RegExp(t+/[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),lookbehind:!0,inside:{namespace:{pattern:/^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,inside:{punctuation:/\./}},punctuation:/\./}};e.languages.java=e.languages.extend("clike",{string:{pattern:/(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,lookbehind:!0,greedy:!0},"class-name":[a,{pattern:RegExp(t+/[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source),lookbehind:!0,inside:a.inside}],keyword:n,function:[e.languages.clike.function,{pattern:/(::\s*)[a-z_]\w*/,lookbehind:!0}],number:/\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,operator:{pattern:/(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,lookbehind:!0}}),e.languages.insertBefore("java","string",{"triple-quoted-string":{pattern:/"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,greedy:!0,alias:"string"},char:{pattern:/'(?:\\.|[^'\\\r\n]){1,6}'/,greedy:!0}}),e.languages.insertBefore("java","class-name",{annotation:{pattern:/(^|[^.])@\w+(?:\s*\.\s*\w+)*/,lookbehind:!0,alias:"punctuation"},generics:{pattern:/<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,inside:{"class-name":a,keyword:n,punctuation:/[<>(),.:]/,operator:/[?&|]/}},namespace:{pattern:RegExp(/(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(/<keyword>/g,(function(){return n.source}))),lookbehind:!0,inside:{punctuation:/\./}}})}(e)}return n=1,e=t,t.displayName="java",t.aliases=[],e}export{t as __require};
-//# sourceMappingURL=java.js.map

package/dist/node_modules/refractor/lang/java.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"java.js","sources":["../../../../node_modules/refractor/lang/java.js"],"sourcesContent":["'use strict'\n\nmodule.exports = java\njava.displayName = 'java'\njava.aliases = []\nfunction java(Prism) {\n  ;(function (Prism) {\n    var keywords =\n      /\\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\\b/ // full package (optional) + parent classes (optional)\n    var classNamePrefix = /(^|[^\\w.])(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*/\n      .source // based on the java naming conventions\n    var className = {\n      pattern: RegExp(classNamePrefix + /[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b/.source),\n      lookbehind: true,\n      inside: {\n        namespace: {\n          pattern: /^[a-z]\\w*(?:\\s*\\.\\s*[a-z]\\w*)*(?:\\s*\\.)?/,\n          inside: {\n            punctuation: /\\./\n          }\n        },\n        punctuation: /\\./\n      }\n    }\n    Prism.languages.java = Prism.languages.extend('clike', {\n      string: {\n        pattern: /(^|[^\\\\])\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n        lookbehind: true,\n        greedy: true\n      },\n      'class-name': [\n        className,\n        {\n          // variables and parameters\n          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)\n          pattern: RegExp(\n            classNamePrefix + /[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()])/.source\n          ),\n          lookbehind: true,\n          inside: className.inside\n        }\n      ],\n      keyword: keywords,\n      function: [\n        Prism.languages.clike.function,\n        {\n          pattern: /(::\\s*)[a-z_]\\w*/,\n          lookbehind: true\n        }\n      ],\n      number:\n        /\\b0b[01][01_]*L?\\b|\\b0x(?:\\.[\\da-f_p+-]+|[\\da-f_]+(?:\\.[\\da-f_p+-]+)?)\\b|(?:\\b\\d[\\d_]*(?:\\.[\\d_]*)?|\\B\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[dfl]?/i,\n      operator: {\n        pattern:\n          /(^|[^.])(?:<<=?|>>>?=?|->|--|\\+\\+|&&|\\|\\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,\n        lookbehind: true\n      }\n    })\n    Prism.languages.insertBefore('java', 'string', {\n      'triple-quoted-string': {\n        // http://openjdk.java.net/jeps/355#Description\n        pattern: /\"\"\"[ \\t]*[\\r\\n](?:(?:\"|\"\")?(?:\\\\.|[^\"\\\\]))*\"\"\"/,\n        greedy: true,\n        alias: 'string'\n      },\n      char: {\n        pattern: /'(?:\\\\.|[^'\\\\\\r\\n]){1,6}'/,\n        greedy: true\n      }\n    })\n    Prism.languages.insertBefore('java', 'class-name', {\n      annotation: {\n        pattern: /(^|[^.])@\\w+(?:\\s*\\.\\s*\\w+)*/,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      generics: {\n        pattern:\n          /<(?:[\\w\\s,.?]|&(?!&)|<(?:[\\w\\s,.?]|&(?!&)|<(?:[\\w\\s,.?]|&(?!&)|<(?:[\\w\\s,.?]|&(?!&))*>)*>)*>)*>/,\n        inside: {\n          'class-name': className,\n          keyword: keywords,\n          punctuation: /[<>(),.:]/,\n          operator: /[?&|]/\n        }\n      },\n      namespace: {\n        pattern: RegExp(\n          /(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)(?!<keyword>)[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?/.source.replace(\n            /<keyword>/g,\n            function () {\n              return keywords.source\n            }\n          )\n        ),\n        lookbehind: true,\n        inside: {\n          punctuation: /\\./\n        }\n      }\n    })\n  })(Prism)\n}\n"],"names":["java","Prism","keywords","classNamePrefix","source","className","pattern","RegExp","lookbehind","inside","namespace","punctuation","languages","extend","string","greedy","keyword","function","clike","number","operator","insertBefore","alias","char","annotation","generics","replace","java_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAKC,IACX,SAAWA,GACV,IAAIC,EACF,idACEC,EAAkB,uDACnBC,OACCC,EAAY,CACdC,QAASC,OAAOJ,EAAkB,gCAAgCC,QAClEI,YAAY,EACZC,OAAQ,CACNC,UAAW,CACTJ,QAAS,2CACTG,OAAQ,CACNE,YAAa,OAGjBA,YAAa,OAGjBV,EAAMW,UAAUZ,KAAOC,EAAMW,UAAUC,OAAO,QAAS,CACrDC,OAAQ,CACNR,QAAS,iCACTE,YAAY,EACZO,QAAQ,GAEV,aAAc,CACZV,EACA,CAGEC,QAASC,OACPJ,EAAkB,+BAA+BC,QAEnDI,YAAY,EACZC,OAAQJ,EAAUI,SAGtBO,QAASd,EACTe,SAAU,CACRhB,EAAMW,UAAUM,MAAMD,SACtB,CACEX,QAAS,mBACTE,YAAY,IAGhBW,OACE,8IACFC,SAAU,CACRd,QACE,wEACFE,YAAY,KAGhBP,EAAMW,UAAUS,aAAa,OAAQ,SAAU,CAC7C,uBAAwB,CAEtBf,QAAS,iDACTS,QAAQ,EACRO,MAAO,UAETC,KAAM,CACJjB,QAAS,4BACTS,QAAQ,KAGZd,EAAMW,UAAUS,aAAa,OAAQ,aAAc,CACjDG,WAAY,CACVlB,QAAS,+BACTE,YAAY,EACZc,MAAO,eAETG,SAAU,CACRnB,QACE,kGACFG,OAAQ,CACN,aAAcJ,EACdW,QAASd,EACTS,YAAa,YACbS,SAAU,UAGdV,UAAW,CACTJ,QAASC,OACP,qJAAqJH,OAAOsB,QAC1J,cACA,WACE,OAAOxB,EAASE,MACjB,KAGLI,YAAY,EACZC,OAAQ,CACNE,YAAa,QAIpB,CA/FA,CA+FEV,EACL,YApGA0B,EAAiB3B,EACjBA,EAAK4B,YAAc,OACnB5B,EAAK6B,QAAU"}

package/dist/node_modules/refractor/lang/javadoc.js

@@ -1,2 +0,0 @@
-import{__require as a}from"./java.js";import{__require as e}from"./javadoclike.js";var n,s;function t(){if(s)return n;s=1;var t=a(),i=e();function o(a){a.register(t),a.register(i),function(a){var e=/(^(?:[\t ]*(?:\*\s*)*))[^*\s].*$/m,n=/#\s*\w+(?:\s*\([^()]*\))?/.source,s=/(?:\b[a-zA-Z]\w+\s*\.\s*)*\b[A-Z]\w*(?:\s*<mem>)?|<mem>/.source.replace(/<mem>/g,(function(){return n}));a.languages.javadoc=a.languages.extend("javadoclike",{}),a.languages.insertBefore("javadoc","keyword",{reference:{pattern:RegExp(/(@(?:exception|link|linkplain|see|throws|value)\s+(?:\*\s*)?)/.source+"(?:"+s+")"),lookbehind:!0,inside:{function:{pattern:/(#\s*)\w+(?=\s*\()/,lookbehind:!0},field:{pattern:/(#\s*)\w+/,lookbehind:!0},namespace:{pattern:/\b(?:[a-z]\w*\s*\.\s*)+/,inside:{punctuation:/\./}},"class-name":/\b[A-Z]\w*/,keyword:a.languages.java.keyword,punctuation:/[#()[\],.]/}},"class-name":{pattern:/(@param\s+)<[A-Z]\w*>/,lookbehind:!0,inside:{punctuation:/[.<>]/}},"code-section":[{pattern:/(\{@code\s+(?!\s))(?:[^\s{}]|\s+(?![\s}])|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})+(?=\s*\})/,lookbehind:!0,inside:{code:{pattern:e,lookbehind:!0,inside:a.languages.java,alias:"language-java"}}},{pattern:/(<(code|pre|tt)>(?!<code>)\s*)\S(?:\S|\s+\S)*?(?=\s*<\/\2>)/,lookbehind:!0,inside:{line:{pattern:e,lookbehind:!0,inside:{tag:a.languages.markup.tag,entity:a.languages.markup.entity,code:{pattern:/.+/,inside:a.languages.java,alias:"language-java"}}}}}],tag:a.languages.markup.tag,entity:a.languages.markup.entity}),a.languages.javadoclike.addSupport("java",a.languages.javadoc)}(a)}return n=o,o.displayName="javadoc",o.aliases=[],n}export{t as __require};
-//# sourceMappingURL=javadoc.js.map

package/dist/node_modules/refractor/lang/javadoc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"javadoc.js","sources":["../../../../node_modules/refractor/lang/javadoc.js"],"sourcesContent":["'use strict'\nvar refractorJava = require('./java.js')\nvar refractorJavadoclike = require('./javadoclike.js')\nmodule.exports = javadoc\njavadoc.displayName = 'javadoc'\njavadoc.aliases = []\nfunction javadoc(Prism) {\n  Prism.register(refractorJava)\n  Prism.register(refractorJavadoclike)\n  ;(function (Prism) {\n    var codeLinePattern = /(^(?:[\\t ]*(?:\\*\\s*)*))[^*\\s].*$/m\n    var memberReference = /#\\s*\\w+(?:\\s*\\([^()]*\\))?/.source\n    var reference =\n      /(?:\\b[a-zA-Z]\\w+\\s*\\.\\s*)*\\b[A-Z]\\w*(?:\\s*<mem>)?|<mem>/.source.replace(\n        /<mem>/g,\n        function () {\n          return memberReference\n        }\n      )\n    Prism.languages.javadoc = Prism.languages.extend('javadoclike', {})\n    Prism.languages.insertBefore('javadoc', 'keyword', {\n      reference: {\n        pattern: RegExp(\n          /(@(?:exception|link|linkplain|see|throws|value)\\s+(?:\\*\\s*)?)/\n            .source +\n            '(?:' +\n            reference +\n            ')'\n        ),\n        lookbehind: true,\n        inside: {\n          function: {\n            pattern: /(#\\s*)\\w+(?=\\s*\\()/,\n            lookbehind: true\n          },\n          field: {\n            pattern: /(#\\s*)\\w+/,\n            lookbehind: true\n          },\n          namespace: {\n            pattern: /\\b(?:[a-z]\\w*\\s*\\.\\s*)+/,\n            inside: {\n              punctuation: /\\./\n            }\n          },\n          'class-name': /\\b[A-Z]\\w*/,\n          keyword: Prism.languages.java.keyword,\n          punctuation: /[#()[\\],.]/\n        }\n      },\n      'class-name': {\n        // @param <T> the first generic type parameter\n        pattern: /(@param\\s+)<[A-Z]\\w*>/,\n        lookbehind: true,\n        inside: {\n          punctuation: /[.<>]/\n        }\n      },\n      'code-section': [\n        {\n          pattern:\n            /(\\{@code\\s+(?!\\s))(?:[^\\s{}]|\\s+(?![\\s}])|\\{(?:[^{}]|\\{(?:[^{}]|\\{(?:[^{}]|\\{[^{}]*\\})*\\})*\\})*\\})+(?=\\s*\\})/,\n          lookbehind: true,\n          inside: {\n            code: {\n              // there can't be any HTML inside of {@code} tags\n              pattern: codeLinePattern,\n              lookbehind: true,\n              inside: Prism.languages.java,\n              alias: 'language-java'\n            }\n          }\n        },\n        {\n          pattern:\n            /(<(code|pre|tt)>(?!<code>)\\s*)\\S(?:\\S|\\s+\\S)*?(?=\\s*<\\/\\2>)/,\n          lookbehind: true,\n          inside: {\n            line: {\n              pattern: codeLinePattern,\n              lookbehind: true,\n              inside: {\n                // highlight HTML tags and entities\n                tag: Prism.languages.markup.tag,\n                entity: Prism.languages.markup.entity,\n                code: {\n                  // everything else is Java code\n                  pattern: /.+/,\n                  inside: Prism.languages.java,\n                  alias: 'language-java'\n                }\n              }\n            }\n          }\n        }\n      ],\n      tag: Prism.languages.markup.tag,\n      entity: Prism.languages.markup.entity\n    })\n    Prism.languages.javadoclike.addSupport('java', Prism.languages.javadoc)\n  })(Prism)\n}\n"],"names":["refractorJava","require$$0","refractorJavadoclike","require$$1","javadoc","Prism","register","codeLinePattern","memberReference","source","reference","replace","languages","extend","insertBefore","pattern","RegExp","lookbehind","inside","function","field","namespace","punctuation","keyword","java","code","alias","line","tag","markup","entity","javadoclike","addSupport","javadoc_1","displayName","aliases"],"mappings":"0HACA,IAAIA,EAAgBC,IAChBC,EAAuBC,IAI3B,SAASC,EAAQC,GACfA,EAAMC,SAASN,GACfK,EAAMC,SAASJ,GACd,SAAWG,GACV,IAAIE,EAAkB,oCAClBC,EAAkB,4BAA4BC,OAC9CC,EACF,0DAA0DD,OAAOE,QAC/D,UACA,WACE,OAAOH,CACR,IAELH,EAAMO,UAAUR,QAAUC,EAAMO,UAAUC,OAAO,cAAe,IAChER,EAAMO,UAAUE,aAAa,UAAW,UAAW,CACjDJ,UAAW,CACTK,QAASC,OACP,gEACGP,OACD,MACAC,EACA,KAEJO,YAAY,EACZC,OAAQ,CACNC,SAAU,CACRJ,QAAS,qBACTE,YAAY,GAEdG,MAAO,CACLL,QAAS,YACTE,YAAY,GAEdI,UAAW,CACTN,QAAS,0BACTG,OAAQ,CACNI,YAAa,OAGjB,aAAc,aACdC,QAASlB,EAAMO,UAAUY,KAAKD,QAC9BD,YAAa,eAGjB,aAAc,CAEZP,QAAS,wBACTE,YAAY,EACZC,OAAQ,CACNI,YAAa,UAGjB,eAAgB,CACd,CACEP,QACE,+GACFE,YAAY,EACZC,OAAQ,CACNO,KAAM,CAEJV,QAASR,EACTU,YAAY,EACZC,OAAQb,EAAMO,UAAUY,KACxBE,MAAO,mBAIb,CACEX,QACE,8DACFE,YAAY,EACZC,OAAQ,CACNS,KAAM,CACJZ,QAASR,EACTU,YAAY,EACZC,OAAQ,CAENU,IAAKvB,EAAMO,UAAUiB,OAAOD,IAC5BE,OAAQzB,EAAMO,UAAUiB,OAAOC,OAC/BL,KAAM,CAEJV,QAAS,KACTG,OAAQb,EAAMO,UAAUY,KACxBE,MAAO,sBAOnBE,IAAKvB,EAAMO,UAAUiB,OAAOD,IAC5BE,OAAQzB,EAAMO,UAAUiB,OAAOC,SAEjCzB,EAAMO,UAAUmB,YAAYC,WAAW,OAAQ3B,EAAMO,UAAUR,QAChE,CA3FA,CA2FEC,EACL,QAlGA4B,EAAiB7B,EACjBA,EAAQ8B,YAAc,UACtB9B,EAAQ+B,QAAU"}

package/dist/node_modules/refractor/lang/javadoclike.js

@@ -1,2 +0,0 @@
-var a,e;function n(){if(e)return a;function n(a){!function(a){var e=a.languages.javadoclike={parameter:{pattern:/(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m,lookbehind:!0},keyword:{pattern:/(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m,lookbehind:!0},punctuation:/[{}]/};Object.defineProperty(e,"addSupport",{value:function(e,n){"string"==typeof e&&(e=[e]),e.forEach((function(e){!function(e,n){var t="doc-comment",r=a.languages[e];if(r){var i=r[t];if(!i){var o={};o[t]={pattern:/(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,lookbehind:!0,alias:"comment"},i=(r=a.languages.insertBefore(e,"comment",o))[t]}if(i instanceof RegExp&&(i=r[t]={pattern:i}),Array.isArray(i))for(var s=0,p=i.length;s<p;s++)i[s]instanceof RegExp&&(i[s]={pattern:i[s]}),n(i[s]);else n(i)}}(e,(function(a){a.inside||(a.inside={}),a.inside.rest=n}))}))}}),e.addSupport(["java","javascript","php"],e)}(a)}return e=1,a=n,n.displayName="javadoclike",n.aliases=[],a}export{n as __require};
-//# sourceMappingURL=javadoclike.js.map

package/dist/node_modules/refractor/lang/javadoclike.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"javadoclike.js","sources":["../../../../node_modules/refractor/lang/javadoclike.js"],"sourcesContent":["'use strict'\n\nmodule.exports = javadoclike\njavadoclike.displayName = 'javadoclike'\njavadoclike.aliases = []\nfunction javadoclike(Prism) {\n  ;(function (Prism) {\n    var javaDocLike = (Prism.languages.javadoclike = {\n      parameter: {\n        pattern:\n          /(^[\\t ]*(?:\\/{3}|\\*|\\/\\*\\*)\\s*@(?:arg|arguments|param)\\s+)\\w+/m,\n        lookbehind: true\n      },\n      keyword: {\n        // keywords are the first word in a line preceded be an `@` or surrounded by curly braces.\n        // @word, {@word}\n        pattern: /(^[\\t ]*(?:\\/{3}|\\*|\\/\\*\\*)\\s*|\\{)@[a-z][a-zA-Z-]+\\b/m,\n        lookbehind: true\n      },\n      punctuation: /[{}]/\n    })\n    /**\n     * Adds doc comment support to the given language and calls a given callback on each doc comment pattern.\n     *\n     * @param {string} lang the language add doc comment support to.\n     * @param {(pattern: {inside: {rest: undefined}}) => void} callback the function called with each doc comment pattern as argument.\n     */\n    function docCommentSupport(lang, callback) {\n      var tokenName = 'doc-comment'\n      var grammar = Prism.languages[lang]\n      if (!grammar) {\n        return\n      }\n      var token = grammar[tokenName]\n      if (!token) {\n        // add doc comment: /** */\n        var definition = {}\n        definition[tokenName] = {\n          pattern: /(^|[^\\\\])\\/\\*\\*[^/][\\s\\S]*?(?:\\*\\/|$)/,\n          lookbehind: true,\n          alias: 'comment'\n        }\n        grammar = Prism.languages.insertBefore(lang, 'comment', definition)\n        token = grammar[tokenName]\n      }\n      if (token instanceof RegExp) {\n        // convert regex to object\n        token = grammar[tokenName] = {\n          pattern: token\n        }\n      }\n      if (Array.isArray(token)) {\n        for (var i = 0, l = token.length; i < l; i++) {\n          if (token[i] instanceof RegExp) {\n            token[i] = {\n              pattern: token[i]\n            }\n          }\n          callback(token[i])\n        }\n      } else {\n        callback(token)\n      }\n    }\n    /**\n     * Adds doc-comment support to the given languages for the given documentation language.\n     *\n     * @param {string[]|string} languages\n     * @param {Object} docLanguage\n     */\n    function addSupport(languages, docLanguage) {\n      if (typeof languages === 'string') {\n        languages = [languages]\n      }\n      languages.forEach(function (lang) {\n        docCommentSupport(lang, function (pattern) {\n          if (!pattern.inside) {\n            pattern.inside = {}\n          }\n          pattern.inside.rest = docLanguage\n        })\n      })\n    }\n    Object.defineProperty(javaDocLike, 'addSupport', {\n      value: addSupport\n    })\n    javaDocLike.addSupport(['java', 'javascript', 'php'], javaDocLike)\n  })(Prism)\n}\n"],"names":["javadoclike","Prism","javaDocLike","languages","parameter","pattern","lookbehind","keyword","punctuation","Object","defineProperty","value","docLanguage","forEach","lang","callback","tokenName","grammar","token","definition","alias","insertBefore","RegExp","Array","isArray","i","l","length","docCommentSupport","inside","rest","addSupport","javadoclike_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAYC,IAClB,SAAWA,GACV,IAAIC,EAAeD,EAAME,UAAUH,YAAc,CAC/CI,UAAW,CACTC,QACE,iEACFC,YAAY,GAEdC,QAAS,CAGPF,QAAS,wDACTC,YAAY,GAEdE,YAAa,QAgEfC,OAAOC,eAAeR,EAAa,aAAc,CAC/CS,MAdF,SAAoBR,EAAWS,GACJ,iBAAdT,IACTA,EAAY,CAACA,IAEfA,EAAUU,SAAQ,SAAUC,IA/C9B,SAA2BA,EAAMC,GAC/B,IAAIC,EAAY,cACZC,EAAUhB,EAAME,UAAUW,GAC9B,GAAKG,EAAL,CAGA,IAAIC,EAAQD,EAAQD,GACpB,IAAKE,EAAO,CAEV,IAAIC,EAAa,CAAE,EACnBA,EAAWH,GAAa,CACtBX,QAAS,wCACTC,YAAY,EACZc,MAAO,WAGTF,GADAD,EAAUhB,EAAME,UAAUkB,aAAaP,EAAM,UAAWK,IACxCH,EACjB,CAOD,GANIE,aAAiBI,SAEnBJ,EAAQD,EAAQD,GAAa,CAC3BX,QAASa,IAGTK,MAAMC,QAAQN,GAChB,IAAK,IAAIO,EAAI,EAAGC,EAAIR,EAAMS,OAAQF,EAAIC,EAAGD,IACnCP,EAAMO,aAAcH,SACtBJ,EAAMO,GAAK,CACTpB,QAASa,EAAMO,KAGnBV,EAASG,EAAMO,SAGjBV,EAASG,EA7BV,CA+BF,CAYGU,CAAkBd,GAAM,SAAUT,GAC3BA,EAAQwB,SACXxB,EAAQwB,OAAS,CAAE,GAErBxB,EAAQwB,OAAOC,KAAOlB,CAChC,GACA,GACK,IAIDV,EAAY6B,WAAW,CAAC,OAAQ,aAAc,OAAQ7B,EACvD,CAjFA,CAiFED,EACL,YAtFA+B,EAAiBhC,EACjBA,EAAYiC,YAAc,cAC1BjC,EAAYkC,QAAU"}