@instincthub/react-ui 0.0.4 → 0.0.6

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

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(r)return e;function o(e){!function(e){function r(e){return RegExp(/([ \t])/.source+"(?:"+e+")"+/(?=[\s;]|$)/.source,"i")}e.languages.csp={directive:{pattern:/(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,lookbehind:!0,alias:"property"},scheme:{pattern:r(/[a-z][a-z0-9.+-]*:/.source),lookbehind:!0},none:{pattern:r(/'none'/.source),lookbehind:!0,alias:"keyword"},nonce:{pattern:r(/'nonce-[-+/\w=]+'/.source),lookbehind:!0,alias:"number"},hash:{pattern:r(/'sha(?:256|384|512)-[-+/\w=]+'/.source),lookbehind:!0,alias:"number"},host:{pattern:r(/[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source+"|"+/\*[^\s;,']*/.source+"|"+/[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source),lookbehind:!0,alias:"url",inside:{important:/\*/}},keyword:[{pattern:r(/'unsafe-[a-z-]+'/.source),lookbehind:!0,alias:"unsafe"},{pattern:r(/'[a-z-]+'/.source),lookbehind:!0,alias:"safe"}],punctuation:/;/}}(e)}return r=1,e=o,o.displayName="csp",o.aliases=[],e};
-//# sourceMappingURL=csp.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"csp.js","sources":["../../../../node_modules/refractor/lang/csp.js"],"sourcesContent":["'use strict'\n\nmodule.exports = csp\ncsp.displayName = 'csp'\ncsp.aliases = []\nfunction csp(Prism) {\n  /**\n   * Original by Scott Helme.\n   *\n   * Reference: https://scotthelme.co.uk/csp-cheat-sheet/\n   *\n   * Supports the following:\n   *  - https://www.w3.org/TR/CSP1/\n   *  - https://www.w3.org/TR/CSP2/\n   *  - https://www.w3.org/TR/CSP3/\n   */\n  ;(function (Prism) {\n    /**\n     * @param {string} source\n     * @returns {RegExp}\n     */\n    function value(source) {\n      return RegExp(\n        /([ \\t])/.source + '(?:' + source + ')' + /(?=[\\s;]|$)/.source,\n        'i'\n      )\n    }\n    Prism.languages.csp = {\n      directive: {\n        pattern:\n          /(^|[\\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\\s;]|$)/i,\n        lookbehind: true,\n        alias: 'property'\n      },\n      scheme: {\n        pattern: value(/[a-z][a-z0-9.+-]*:/.source),\n        lookbehind: true\n      },\n      none: {\n        pattern: value(/'none'/.source),\n        lookbehind: true,\n        alias: 'keyword'\n      },\n      nonce: {\n        pattern: value(/'nonce-[-+/\\w=]+'/.source),\n        lookbehind: true,\n        alias: 'number'\n      },\n      hash: {\n        pattern: value(/'sha(?:256|384|512)-[-+/\\w=]+'/.source),\n        lookbehind: true,\n        alias: 'number'\n      },\n      host: {\n        pattern: value(\n          /[a-z][a-z0-9.+-]*:\\/\\/[^\\s;,']*/.source +\n            '|' +\n            /\\*[^\\s;,']*/.source +\n            '|' +\n            /[a-z0-9-]+(?:\\.[a-z0-9-]+)+(?::[\\d*]+)?(?:\\/[^\\s;,']*)?/.source\n        ),\n        lookbehind: true,\n        alias: 'url',\n        inside: {\n          important: /\\*/\n        }\n      },\n      keyword: [\n        {\n          pattern: value(/'unsafe-[a-z-]+'/.source),\n          lookbehind: true,\n          alias: 'unsafe'\n        },\n        {\n          pattern: value(/'[a-z-]+'/.source),\n          lookbehind: true,\n          alias: 'safe'\n        }\n      ],\n      punctuation: /;/\n    }\n  })(Prism)\n}\n"],"names":["csp","Prism","value","source","RegExp","languages","directive","pattern","lookbehind","alias","scheme","none","nonce","hash","host","inside","important","keyword","punctuation","csp_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAIC,IAWV,SAAWA,GAKV,SAASC,EAAMC,GACb,OAAOC,OACL,UAAUD,OAAS,MAAQA,EAAS,IAAM,cAAcA,OACxD,IAEH,CACDF,EAAMI,UAAUL,IAAM,CACpBM,UAAW,CACTC,QACE,6ZACFC,YAAY,EACZC,MAAO,YAETC,OAAQ,CACNH,QAASL,EAAM,qBAAqBC,QACpCK,YAAY,GAEdG,KAAM,CACJJ,QAASL,EAAM,SAASC,QACxBK,YAAY,EACZC,MAAO,WAETG,MAAO,CACLL,QAASL,EAAM,oBAAoBC,QACnCK,YAAY,EACZC,MAAO,UAETI,KAAM,CACJN,QAASL,EAAM,iCAAiCC,QAChDK,YAAY,EACZC,MAAO,UAETK,KAAM,CACJP,QAASL,EACP,kCAAkCC,OAChC,IACA,cAAcA,OACd,IACA,0DAA0DA,QAE9DK,YAAY,EACZC,MAAO,MACPM,OAAQ,CACNC,UAAW,OAGfC,QAAS,CACP,CACEV,QAASL,EAAM,mBAAmBC,QAClCK,YAAY,EACZC,MAAO,UAET,CACEF,QAASL,EAAM,YAAYC,QAC3BK,YAAY,EACZC,MAAO,SAGXS,YAAa,IAEhB,CAjEA,CAiEEjB,EACL,YAhFAkB,EAAiBnB,EACjBA,EAAIoB,YAAc,MAClBpB,EAAIqB,QAAU"}

package/dist/node_modules/refractor/lang/css-extras.js

@@ -1,2 +0,0 @@
-"use strict";var e,a;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(a)return e;function n(e){!function(e){var a,n=/("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;e.languages.css.selector={pattern:e.languages.css.selector.pattern,lookbehind:!0,inside:a={"pseudo-element":/:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,"pseudo-class":/:[-\w]+/,class:/\.[-\w]+/,id:/#[-\w]+/,attribute:{pattern:RegExp("\\[(?:[^[\\]\"']|"+n.source+")*\\]"),greedy:!0,inside:{punctuation:/^\[|\]$/,"case-sensitivity":{pattern:/(\s)[si]$/i,lookbehind:!0,alias:"keyword"},namespace:{pattern:/^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,lookbehind:!0,inside:{punctuation:/\|$/}},"attr-name":{pattern:/^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,lookbehind:!0},"attr-value":[n,{pattern:/(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,lookbehind:!0}],operator:/[|~*^$]?=/}},"n-th":[{pattern:/(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,lookbehind:!0,inside:{number:/[\dn]+/,operator:/[+-]/}},{pattern:/(\(\s*)(?:even|odd)(?=\s*\))/i,lookbehind:!0}],combinator:/>|\+|~|\|\|/,punctuation:/[(),]/}},e.languages.css.atrule.inside["selector-function-argument"].inside=a,e.languages.insertBefore("css","property",{variable:{pattern:/(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,lookbehind:!0}});var r={pattern:/(\b\d+)(?:%|[a-z]+(?![\w-]))/,lookbehind:!0},i={pattern:/(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,lookbehind:!0};e.languages.insertBefore("css","function",{operator:{pattern:/(\s)[+\-*\/](?=\s)/,lookbehind:!0},hexcode:{pattern:/\B#[\da-f]{3,8}\b/i,alias:"color"},color:[{pattern:/(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i,lookbehind:!0},{pattern:/\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,inside:{unit:r,number:i,function:/[\w-]+(?=\()/,punctuation:/[(),]/}}],entity:/\\[\da-f]{1,8}/i,unit:r,number:i})}(e)}return a=1,e=n,n.displayName="cssExtras",n.aliases=[],e};
-//# sourceMappingURL=css-extras.js.map

package/dist/node_modules/refractor/lang/css-extras.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"css-extras.js","sources":["../../../../node_modules/refractor/lang/css-extras.js"],"sourcesContent":["'use strict'\n\nmodule.exports = cssExtras\ncssExtras.displayName = 'cssExtras'\ncssExtras.aliases = []\nfunction cssExtras(Prism) {\n  ;(function (Prism) {\n    var string = /(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/\n    var selectorInside\n    Prism.languages.css.selector = {\n      pattern: Prism.languages.css.selector.pattern,\n      lookbehind: true,\n      inside: (selectorInside = {\n        'pseudo-element':\n          /:(?:after|before|first-letter|first-line|selection)|::[-\\w]+/,\n        'pseudo-class': /:[-\\w]+/,\n        class: /\\.[-\\w]+/,\n        id: /#[-\\w]+/,\n        attribute: {\n          pattern: RegExp('\\\\[(?:[^[\\\\]\"\\']|' + string.source + ')*\\\\]'),\n          greedy: true,\n          inside: {\n            punctuation: /^\\[|\\]$/,\n            'case-sensitivity': {\n              pattern: /(\\s)[si]$/i,\n              lookbehind: true,\n              alias: 'keyword'\n            },\n            namespace: {\n              pattern: /^(\\s*)(?:(?!\\s)[-*\\w\\xA0-\\uFFFF])*\\|(?!=)/,\n              lookbehind: true,\n              inside: {\n                punctuation: /\\|$/\n              }\n            },\n            'attr-name': {\n              pattern: /^(\\s*)(?:(?!\\s)[-\\w\\xA0-\\uFFFF])+/,\n              lookbehind: true\n            },\n            'attr-value': [\n              string,\n              {\n                pattern: /(=\\s*)(?:(?!\\s)[-\\w\\xA0-\\uFFFF])+(?=\\s*$)/,\n                lookbehind: true\n              }\n            ],\n            operator: /[|~*^$]?=/\n          }\n        },\n        'n-th': [\n          {\n            pattern: /(\\(\\s*)[+-]?\\d*[\\dn](?:\\s*[+-]\\s*\\d+)?(?=\\s*\\))/,\n            lookbehind: true,\n            inside: {\n              number: /[\\dn]+/,\n              operator: /[+-]/\n            }\n          },\n          {\n            pattern: /(\\(\\s*)(?:even|odd)(?=\\s*\\))/i,\n            lookbehind: true\n          }\n        ],\n        combinator: />|\\+|~|\\|\\|/,\n        // the `tag` token has been existed and removed.\n        // because we can't find a perfect tokenize to match it.\n        // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.\n        punctuation: /[(),]/\n      })\n    }\n    Prism.languages.css['atrule'].inside['selector-function-argument'].inside =\n      selectorInside\n    Prism.languages.insertBefore('css', 'property', {\n      variable: {\n        pattern:\n          /(^|[^-\\w\\xA0-\\uFFFF])--(?!\\s)[-_a-z\\xA0-\\uFFFF](?:(?!\\s)[-\\w\\xA0-\\uFFFF])*/i,\n        lookbehind: true\n      }\n    })\n    var unit = {\n      pattern: /(\\b\\d+)(?:%|[a-z]+(?![\\w-]))/,\n      lookbehind: true\n    } // 123 -123 .123 -.123 12.3 -12.3\n    var number = {\n      pattern: /(^|[^\\w.-])-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/,\n      lookbehind: true\n    }\n    Prism.languages.insertBefore('css', 'function', {\n      operator: {\n        pattern: /(\\s)[+\\-*\\/](?=\\s)/,\n        lookbehind: true\n      },\n      // CAREFUL!\n      // Previewers and Inline color use hexcode and color.\n      hexcode: {\n        pattern: /\\B#[\\da-f]{3,8}\\b/i,\n        alias: 'color'\n      },\n      color: [\n        {\n          pattern:\n            /(^|[^\\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\\w-])/i,\n          lookbehind: true\n        },\n        {\n          pattern:\n            /\\b(?:hsl|rgb)\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}%?\\s*,\\s*\\d{1,3}%?\\s*\\)\\B|\\b(?:hsl|rgb)a\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}%?\\s*,\\s*\\d{1,3}%?\\s*,\\s*(?:0|0?\\.\\d+|1)\\s*\\)\\B/i,\n          inside: {\n            unit: unit,\n            number: number,\n            function: /[\\w-]+(?=\\()/,\n            punctuation: /[(),]/\n          }\n        }\n      ],\n      // it's important that there is no boundary assertion after the hex digits\n      entity: /\\\\[\\da-f]{1,8}/i,\n      unit: unit,\n      number: number\n    })\n  })(Prism)\n}\n"],"names":["cssExtras","Prism","selectorInside","string","languages","css","selector","pattern","lookbehind","inside","class","id","attribute","RegExp","source","greedy","punctuation","alias","namespace","operator","number","combinator","insertBefore","variable","unit","hexcode","color","function","entity","cssExtras_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAUC,IAChB,SAAWA,GACV,IACIC,EADAC,EAAS,gDAEbF,EAAMG,UAAUC,IAAIC,SAAW,CAC7BC,QAASN,EAAMG,UAAUC,IAAIC,SAASC,QACtCC,YAAY,EACZC,OAASP,EAAiB,CACxB,iBACE,+DACF,eAAgB,UAChBQ,MAAO,WACPC,GAAI,UACJC,UAAW,CACTL,QAASM,OAAO,oBAAsBV,EAAOW,OAAS,SACtDC,QAAQ,EACRN,OAAQ,CACNO,YAAa,UACb,mBAAoB,CAClBT,QAAS,aACTC,YAAY,EACZS,MAAO,WAETC,UAAW,CACTX,QAAS,4CACTC,YAAY,EACZC,OAAQ,CACNO,YAAa,QAGjB,YAAa,CACXT,QAAS,oCACTC,YAAY,GAEd,aAAc,CACZL,EACA,CACEI,QAAS,4CACTC,YAAY,IAGhBW,SAAU,cAGd,OAAQ,CACN,CACEZ,QAAS,kDACTC,YAAY,EACZC,OAAQ,CACNW,OAAQ,SACRD,SAAU,SAGd,CACEZ,QAAS,gCACTC,YAAY,IAGhBa,WAAY,cAIZL,YAAa,UAGjBf,EAAMG,UAAUC,IAAY,OAAEI,OAAO,8BAA8BA,OACjEP,EACFD,EAAMG,UAAUkB,aAAa,MAAO,WAAY,CAC9CC,SAAU,CACRhB,QACE,8EACFC,YAAY,KAGhB,IAAIgB,EAAO,CACTjB,QAAS,+BACTC,YAAY,GAEVY,EAAS,CACXb,QAAS,uCACTC,YAAY,GAEdP,EAAMG,UAAUkB,aAAa,MAAO,WAAY,CAC9CH,SAAU,CACRZ,QAAS,qBACTC,YAAY,GAIdiB,QAAS,CACPlB,QAAS,qBACTU,MAAO,SAETS,MAAO,CACL,CACEnB,QACE,o6CACFC,YAAY,GAEd,CACED,QACE,4JACFE,OAAQ,CACNe,KAAMA,EACNJ,OAAQA,EACRO,SAAU,eACVX,YAAa,WAKnBY,OAAQ,kBACRJ,KAAMA,EACNJ,OAAQA,GAEX,CAlHA,CAkHEnB,EACL,YAvHA4B,EAAiB7B,EACjBA,EAAU8B,YAAc,YACxB9B,EAAU+B,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var s=e;function e(s){!function(s){var e=/(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;s.languages.css={comment:/\/\*[\s\S]*?\*\//,atrule:{pattern:/@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,inside:{rule:/^@[\w-]+/,"selector-function-argument":{pattern:/(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,lookbehind:!0,alias:"selector"},keyword:{pattern:/(^|[^\w-])(?:and|not|only|or)(?![\w-])/,lookbehind:!0}}},url:{pattern:RegExp("\\burl\\((?:"+e.source+"|"+/(?:[^\\\r\n()"']|\\[\s\S])*/.source+")\\)","i"),greedy:!0,inside:{function:/^url/i,punctuation:/^\(|\)$/,string:{pattern:RegExp("^"+e.source+"$"),alias:"url"}}},selector:{pattern:RegExp("(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|"+e.source+")*(?=\\s*\\{)"),lookbehind:!0},string:{pattern:e,greedy:!0},property:{pattern:/(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,lookbehind:!0},important:/!important\b/i,function:{pattern:/(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,lookbehind:!0},punctuation:/[(){};:,]/},s.languages.css.atrule.inside.rest=s.languages.css;var t=s.languages.markup;t&&(t.tag.addInlined("style","css"),t.tag.addAttribute("style","css"))}(s)}e.displayName="css",e.aliases=[],exports.default=s;
-//# sourceMappingURL=css.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"css.js","sources":["../../../../node_modules/refractor/lang/css.js"],"sourcesContent":["'use strict'\n\nmodule.exports = css\ncss.displayName = 'css'\ncss.aliases = []\nfunction css(Prism) {\n  ;(function (Prism) {\n    var string =\n      /(?:\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"|'(?:\\\\(?:\\r\\n|[\\s\\S])|[^'\\\\\\r\\n])*')/\n    Prism.languages.css = {\n      comment: /\\/\\*[\\s\\S]*?\\*\\//,\n      atrule: {\n        pattern: /@[\\w-](?:[^;{\\s]|\\s+(?![\\s{]))*(?:;|(?=\\s*\\{))/,\n        inside: {\n          rule: /^@[\\w-]+/,\n          'selector-function-argument': {\n            pattern:\n              /(\\bselector\\s*\\(\\s*(?![\\s)]))(?:[^()\\s]|\\s+(?![\\s)])|\\((?:[^()]|\\([^()]*\\))*\\))+(?=\\s*\\))/,\n            lookbehind: true,\n            alias: 'selector'\n          },\n          keyword: {\n            pattern: /(^|[^\\w-])(?:and|not|only|or)(?![\\w-])/,\n            lookbehind: true\n          } // See rest below\n        }\n      },\n      url: {\n        // https://drafts.csswg.org/css-values-3/#urls\n        pattern: RegExp(\n          '\\\\burl\\\\((?:' +\n            string.source +\n            '|' +\n            /(?:[^\\\\\\r\\n()\"']|\\\\[\\s\\S])*/.source +\n            ')\\\\)',\n          'i'\n        ),\n        greedy: true,\n        inside: {\n          function: /^url/i,\n          punctuation: /^\\(|\\)$/,\n          string: {\n            pattern: RegExp('^' + string.source + '$'),\n            alias: 'url'\n          }\n        }\n      },\n      selector: {\n        pattern: RegExp(\n          '(^|[{}\\\\s])[^{}\\\\s](?:[^{};\"\\'\\\\s]|\\\\s+(?![\\\\s{])|' +\n            string.source +\n            ')*(?=\\\\s*\\\\{)'\n        ),\n        lookbehind: true\n      },\n      string: {\n        pattern: string,\n        greedy: true\n      },\n      property: {\n        pattern:\n          /(^|[^-\\w\\xA0-\\uFFFF])(?!\\s)[-_a-z\\xA0-\\uFFFF](?:(?!\\s)[-\\w\\xA0-\\uFFFF])*(?=\\s*:)/i,\n        lookbehind: true\n      },\n      important: /!important\\b/i,\n      function: {\n        pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\\()/i,\n        lookbehind: true\n      },\n      punctuation: /[(){};:,]/\n    }\n    Prism.languages.css['atrule'].inside.rest = Prism.languages.css\n    var markup = Prism.languages.markup\n    if (markup) {\n      markup.tag.addInlined('style', 'css')\n      markup.tag.addAttribute('style', 'css')\n    }\n  })(Prism)\n}\n"],"names":["css_1","css","Prism","string","languages","comment","atrule","pattern","inside","rule","lookbehind","alias","keyword","url","RegExp","source","greedy","function","punctuation","selector","property","important","rest","markup","tag","addInlined","addAttribute","displayName","aliases"],"mappings":"oEAEA,IAAAA,EAAiBC,EAGjB,SAASA,EAAIC,IACV,SAAWA,GACV,IAAIC,EACF,8EACFD,EAAME,UAAUH,IAAM,CACpBI,QAAS,mBACTC,OAAQ,CACNC,QAAS,iDACTC,OAAQ,CACNC,KAAM,WACN,6BAA8B,CAC5BF,QACE,4FACFG,YAAY,EACZC,MAAO,YAETC,QAAS,CACPL,QAAS,yCACTG,YAAY,KAIlBG,IAAK,CAEHN,QAASO,OACP,eACEX,EAAOY,OACP,IACA,8BAA8BA,OAC9B,OACF,KAEFC,QAAQ,EACRR,OAAQ,CACNS,SAAU,QACVC,YAAa,UACbf,OAAQ,CACNI,QAASO,OAAO,IAAMX,EAAOY,OAAS,KACtCJ,MAAO,SAIbQ,SAAU,CACRZ,QAASO,OACP,qDACEX,EAAOY,OACP,iBAEJL,YAAY,GAEdP,OAAQ,CACNI,QAASJ,EACTa,QAAQ,GAEVI,SAAU,CACRb,QACE,oFACFG,YAAY,GAEdW,UAAW,gBACXJ,SAAU,CACRV,QAAS,kCACTG,YAAY,GAEdQ,YAAa,aAEfhB,EAAME,UAAUH,IAAY,OAAEO,OAAOc,KAAOpB,EAAME,UAAUH,IAC5D,IAAIsB,EAASrB,EAAME,UAAUmB,OACzBA,IACFA,EAAOC,IAAIC,WAAW,QAAS,OAC/BF,EAAOC,IAAIE,aAAa,QAAS,OAEpC,CAvEA,CAuEExB,EACL,CA3EAD,EAAI0B,YAAc,MAClB1B,EAAI2B,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(r)return e;function t(e){e.languages.csv={value:/[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,punctuation:/,/}}return r=1,e=t,t.displayName="csv",t.aliases=[],e};
-//# sourceMappingURL=csv.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"csv.js","sources":["../../../../node_modules/refractor/lang/csv.js"],"sourcesContent":["'use strict'\n\nmodule.exports = csv\ncsv.displayName = 'csv'\ncsv.aliases = []\nfunction csv(Prism) {\n  // https://tools.ietf.org/html/rfc4180\n  Prism.languages.csv = {\n    value: /[^\\r\\n,\"]+|\"(?:[^\"]|\"\")*\"(?!\")/,\n    punctuation: /,/\n  }\n}\n"],"names":["csv","Prism","languages","value","punctuation","csv_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAIC,GAEXA,EAAMC,UAAUF,IAAM,CACpBG,MAAO,iCACPC,YAAa,IAEjB,YATAC,EAAiBL,EACjBA,EAAIM,YAAc,MAClBN,EAAIO,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(r)return e;function E(e){e.languages.cypher={comment:/\/\/.*/,string:{pattern:/"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,greedy:!0},"class-name":{pattern:/(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,lookbehind:!0,greedy:!0},relationship:{pattern:/(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,lookbehind:!0,greedy:!0,alias:"property"},identifier:{pattern:/`(?:[^`\\\r\n])*`/,greedy:!0},variable:/\$\w+/,keyword:/\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,function:/\b\w+\b(?=\s*\()/,boolean:/\b(?:false|null|true)\b/i,number:/\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,operator:/:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,punctuation:/[()[\]{},;.]/}}return r=1,e=E,E.displayName="cypher",E.aliases=[],e};
-//# sourceMappingURL=cypher.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"cypher.js","sources":["../../../../node_modules/refractor/lang/cypher.js"],"sourcesContent":["'use strict'\n\nmodule.exports = cypher\ncypher.displayName = 'cypher'\ncypher.aliases = []\nfunction cypher(Prism) {\n  Prism.languages.cypher = {\n    // https://neo4j.com/docs/cypher-manual/current/syntax/comments/\n    comment: /\\/\\/.*/,\n    string: {\n      pattern: /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?:[^'\\\\\\r\\n]|\\\\.)*'/,\n      greedy: true\n    },\n    'class-name': {\n      pattern: /(:\\s*)(?:\\w+|`(?:[^`\\\\\\r\\n])*`)(?=\\s*[{):])/,\n      lookbehind: true,\n      greedy: true\n    },\n    relationship: {\n      pattern:\n        /(-\\[\\s*(?:\\w+\\s*|`(?:[^`\\\\\\r\\n])*`\\s*)?:\\s*|\\|\\s*:\\s*)(?:\\w+|`(?:[^`\\\\\\r\\n])*`)/,\n      lookbehind: true,\n      greedy: true,\n      alias: 'property'\n    },\n    identifier: {\n      pattern: /`(?:[^`\\\\\\r\\n])*`/,\n      greedy: true\n    },\n    variable: /\\$\\w+/,\n    // https://neo4j.com/docs/cypher-manual/current/syntax/reserved/\n    keyword:\n      /\\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\\b/i,\n    function: /\\b\\w+\\b(?=\\s*\\()/,\n    boolean: /\\b(?:false|null|true)\\b/i,\n    number: /\\b(?:0x[\\da-fA-F]+|\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)\\b/,\n    // https://neo4j.com/docs/cypher-manual/current/syntax/operators/\n    operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\\.\\.\\.?/,\n    punctuation: /[()[\\]{},;.]/\n  }\n}\n"],"names":["cypher","Prism","languages","comment","string","pattern","greedy","lookbehind","relationship","alias","identifier","variable","keyword","function","boolean","number","operator","punctuation","cypher_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAOC,GACdA,EAAMC,UAAUF,OAAS,CAEvBG,QAAS,SACTC,OAAQ,CACNC,QAAS,8CACTC,QAAQ,GAEV,aAAc,CACZD,QAAS,8CACTE,YAAY,EACZD,QAAQ,GAEVE,aAAc,CACZH,QACE,kFACFE,YAAY,EACZD,QAAQ,EACRG,MAAO,YAETC,WAAY,CACVL,QAAS,oBACTC,QAAQ,GAEVK,SAAU,QAEVC,QACE,4YACFC,SAAU,mBACVC,QAAS,2BACTC,OAAQ,uDAERC,SAAU,8CACVC,YAAa,eAEjB,YAtCAC,EAAiBlB,EACjBA,EAAOmB,YAAc,SACrBnB,EAAOoB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(r)return e;function t(e){e.languages.d=e.languages.extend("clike",{comment:[{pattern:/^\s*#!.+/,greedy:!0},{pattern:RegExp(/(^|[^\\])/.source+"(?:"+[/\/\+(?:\/\+(?:[^+]|\+(?!\/))*\+\/|(?!\/\+)[\s\S])*?\+\//.source,/\/\/.*/.source,/\/\*[\s\S]*?\*\//.source].join("|")+")"),lookbehind:!0,greedy:!0}],string:[{pattern:RegExp([/\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/.source,/\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/.source,/\bq"((?!\d)\w+)$[\s\S]*?^\1"/.source,/\bq"(.)[\s\S]*?\2"/.source,/(["`])(?:\\[\s\S]|(?!\3)[^\\])*\3[cwd]?/.source].join("|"),"m"),greedy:!0},{pattern:/\bq\{(?:\{[^{}]*\}|[^{}])*\}/,greedy:!0,alias:"token-string"}],keyword:/\$|\b(?:__(?:(?:DATE|EOF|FILE|FUNCTION|LINE|MODULE|PRETTY_FUNCTION|TIMESTAMP|TIME|VENDOR|VERSION)__|gshared|parameters|traits|vector)|abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|dstring|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|ptrdiff_t|public|pure|real|ref|return|scope|shared|short|size_t|static|string|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|wstring)\b/,number:[/\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]{0,4}/i,{pattern:/((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]{0,4}/i,lookbehind:!0}],operator:/\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/}),e.languages.insertBefore("d","string",{char:/'(?:\\(?:\W|\w+)|[^\\])'/}),e.languages.insertBefore("d","keyword",{property:/\B@\w*/}),e.languages.insertBefore("d","function",{register:{pattern:/\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,alias:"variable"}})}return r=1,e=t,t.displayName="d",t.aliases=[],e};
-//# sourceMappingURL=d.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"d.js","sources":["../../../../node_modules/refractor/lang/d.js"],"sourcesContent":["'use strict'\n\nmodule.exports = d\nd.displayName = 'd'\nd.aliases = []\nfunction d(Prism) {\n  Prism.languages.d = Prism.languages.extend('clike', {\n    comment: [\n      {\n        // Shebang\n        pattern: /^\\s*#!.+/,\n        greedy: true\n      },\n      {\n        pattern: RegExp(\n          /(^|[^\\\\])/.source +\n            '(?:' +\n            [\n              // /+ comment +/\n              // Allow one level of nesting\n              /\\/\\+(?:\\/\\+(?:[^+]|\\+(?!\\/))*\\+\\/|(?!\\/\\+)[\\s\\S])*?\\+\\//.source, // // comment\n              /\\/\\/.*/.source, // /* comment */\n              /\\/\\*[\\s\\S]*?\\*\\//.source\n            ].join('|') +\n            ')'\n        ),\n        lookbehind: true,\n        greedy: true\n      }\n    ],\n    string: [\n      {\n        pattern: RegExp(\n          [\n            // r\"\", x\"\"\n            /\\b[rx]\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"[cwd]?/.source, // q\"[]\", q\"()\", q\"<>\", q\"{}\"\n            /\\bq\"(?:\\[[\\s\\S]*?\\]|\\([\\s\\S]*?\\)|<[\\s\\S]*?>|\\{[\\s\\S]*?\\})\"/.source, // q\"IDENT\n            // ...\n            // IDENT\"\n            /\\bq\"((?!\\d)\\w+)$[\\s\\S]*?^\\1\"/.source, // q\"//\", q\"||\", etc.\n            // eslint-disable-next-line regexp/strict\n            /\\bq\"(.)[\\s\\S]*?\\2\"/.source, // eslint-disable-next-line regexp/strict\n            /([\"`])(?:\\\\[\\s\\S]|(?!\\3)[^\\\\])*\\3[cwd]?/.source\n          ].join('|'),\n          'm'\n        ),\n        greedy: true\n      },\n      {\n        pattern: /\\bq\\{(?:\\{[^{}]*\\}|[^{}])*\\}/,\n        greedy: true,\n        alias: 'token-string'\n      }\n    ],\n    // In order: $, keywords and special tokens, globally defined symbols\n    keyword:\n      /\\$|\\b(?:__(?:(?:DATE|EOF|FILE|FUNCTION|LINE|MODULE|PRETTY_FUNCTION|TIMESTAMP|TIME|VENDOR|VERSION)__|gshared|parameters|traits|vector)|abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|dstring|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|ptrdiff_t|public|pure|real|ref|return|scope|shared|short|size_t|static|string|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|wstring)\\b/,\n    number: [\n      // The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator\n      // Hexadecimal numbers must be handled separately to avoid problems with exponent \"e\"\n      /\\b0x\\.?[a-f\\d_]+(?:(?!\\.\\.)\\.[a-f\\d_]*)?(?:p[+-]?[a-f\\d_]+)?[ulfi]{0,4}/i,\n      {\n        pattern:\n          /((?:\\.\\.)?)(?:\\b0b\\.?|\\b|\\.)\\d[\\d_]*(?:(?!\\.\\.)\\.[\\d_]*)?(?:e[+-]?\\d[\\d_]*)?[ulfi]{0,4}/i,\n        lookbehind: true\n      }\n    ],\n    operator:\n      /\\|[|=]?|&[&=]?|\\+[+=]?|-[-=]?|\\.?\\.\\.|=[>=]?|!(?:i[ns]\\b|<>?=?|>=?|=)?|\\bi[ns]\\b|(?:<[<>]?|>>?>?|\\^\\^|[*\\/%^~])=?/\n  })\n  Prism.languages.insertBefore('d', 'string', {\n    // Characters\n    // 'a', '\\\\', '\\n', '\\xFF', '\\377', '\\uFFFF', '\\U0010FFFF', '\\quot'\n    char: /'(?:\\\\(?:\\W|\\w+)|[^\\\\])'/\n  })\n  Prism.languages.insertBefore('d', 'keyword', {\n    property: /\\B@\\w*/\n  })\n  Prism.languages.insertBefore('d', 'function', {\n    register: {\n      // Iasm registers\n      pattern:\n        /\\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\\d))\\b|\\bST(?:\\([0-7]\\)|\\b)/,\n      alias: 'variable'\n    }\n  })\n}\n"],"names":["d","Prism","languages","extend","comment","pattern","greedy","RegExp","source","join","lookbehind","string","alias","keyword","number","operator","insertBefore","char","property","register","d_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAEC,GACTA,EAAMC,UAAUF,EAAIC,EAAMC,UAAUC,OAAO,QAAS,CAClDC,QAAS,CACP,CAEEC,QAAS,WACTC,QAAQ,GAEV,CACED,QAASE,OACP,YAAYC,OACV,MACA,CAGE,0DAA0DA,OAC1D,SAASA,OACT,mBAAmBA,QACnBC,KAAK,KACP,KAEJC,YAAY,EACZJ,QAAQ,IAGZK,OAAQ,CACN,CACEN,QAASE,OACP,CAEE,qCAAqCC,OACrC,6DAA6DA,OAG7D,+BAA+BA,OAE/B,qBAAqBA,OACrB,0CAA0CA,QAC1CC,KAAK,KACP,KAEFH,QAAQ,GAEV,CACED,QAAS,+BACTC,QAAQ,EACRM,MAAO,iBAIXC,QACE,u0BACFC,OAAQ,CAGN,2EACA,CACET,QACE,2FACFK,YAAY,IAGhBK,SACE,sHAEJd,EAAMC,UAAUc,aAAa,IAAK,SAAU,CAG1CC,KAAM,6BAERhB,EAAMC,UAAUc,aAAa,IAAK,UAAW,CAC3CE,SAAU,WAEZjB,EAAMC,UAAUc,aAAa,IAAK,WAAY,CAC5CG,SAAU,CAERd,QACE,sNACFO,MAAO,aAGb,YApFAQ,EAAiBpB,EACjBA,EAAEqB,YAAc,IAChBrB,EAAEsB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,t;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(t)return e;function a(e){!function(e){var t=[/\b(?:async|sync|yield)\*/,/\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/],a=/(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source,s={pattern:RegExp(a+/[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:/\./}}}};e.languages.dart=e.languages.extend("clike",{"class-name":[s,{pattern:RegExp(a+/[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source),lookbehind:!0,inside:s.inside}],keyword:t,operator:/\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/}),e.languages.insertBefore("dart","string",{"string-literal":{pattern:/r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,greedy:!0,inside:{interpolation:{pattern:/((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,lookbehind:!0,inside:{punctuation:/^\$\{?|\}$/,expression:{pattern:/[\s\S]+/,inside:e.languages.dart}}},string:/[\s\S]+/}},string:void 0}),e.languages.insertBefore("dart","class-name",{metadata:{pattern:/@\w+/,alias:"function"}}),e.languages.insertBefore("dart","class-name",{generics:{pattern:/<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,inside:{"class-name":s,keyword:t,punctuation:/[<>(),.:]/,operator:/[?&|]/}}})}(e)}return t=1,e=a,a.displayName="dart",a.aliases=[],e};
-//# sourceMappingURL=dart.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dart.js","sources":["../../../../node_modules/refractor/lang/dart.js"],"sourcesContent":["'use strict'\n\nmodule.exports = dart\ndart.displayName = 'dart'\ndart.aliases = []\nfunction dart(Prism) {\n  ;(function (Prism) {\n    var keywords = [\n      /\\b(?:async|sync|yield)\\*/,\n      /\\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\\b/\n    ] // Handles named imports, such as http.Client\n    var packagePrefix = /(^|[^\\w.])(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*/\n      .source // based on the dart naming conventions\n    var className = {\n      pattern: RegExp(packagePrefix + /[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      }\n    }\n    Prism.languages.dart = Prism.languages.extend('clike', {\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            packagePrefix + /[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()])/.source\n          ),\n          lookbehind: true,\n          inside: className.inside\n        }\n      ],\n      keyword: keywords,\n      operator:\n        /\\bis!|\\b(?:as|is)\\b|\\+\\+|--|&&|\\|\\||<<=?|>>=?|~(?:\\/=?)?|[+\\-*\\/%&^|=!<>]=?|\\?/\n    })\n    Prism.languages.insertBefore('dart', 'string', {\n      'string-literal': {\n        pattern:\n          /r?(?:(\"\"\"|''')[\\s\\S]*?\\1|([\"'])(?:\\\\.|(?!\\2)[^\\\\\\r\\n])*\\2(?!\\2))/,\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern:\n              /((?:^|[^\\\\])(?:\\\\{2})*)\\$(?:\\w+|\\{(?:[^{}]|\\{[^{}]*\\})*\\})/,\n            lookbehind: true,\n            inside: {\n              punctuation: /^\\$\\{?|\\}$/,\n              expression: {\n                pattern: /[\\s\\S]+/,\n                inside: Prism.languages.dart\n              }\n            }\n          },\n          string: /[\\s\\S]+/\n        }\n      },\n      string: undefined\n    })\n    Prism.languages.insertBefore('dart', 'class-name', {\n      metadata: {\n        pattern: /@\\w+/,\n        alias: 'function'\n      }\n    })\n    Prism.languages.insertBefore('dart', 'class-name', {\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    })\n  })(Prism)\n}\n"],"names":["dart","Prism","keywords","packagePrefix","source","className","pattern","RegExp","lookbehind","inside","namespace","punctuation","languages","extend","keyword","operator","insertBefore","greedy","interpolation","expression","string","undefined","metadata","alias","generics","dart_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAKC,IACX,SAAWA,GACV,IAAIC,EAAW,CACb,2BACA,8WAEEC,EAAgB,uDACjBC,OACCC,EAAY,CACdC,QAASC,OAAOJ,EAAgB,gCAAgCC,QAChEI,YAAY,EACZC,OAAQ,CACNC,UAAW,CACTJ,QAAS,2CACTG,OAAQ,CACNE,YAAa,SAKrBV,EAAMW,UAAUZ,KAAOC,EAAMW,UAAUC,OAAO,QAAS,CACrD,aAAc,CACZR,EACA,CAGEC,QAASC,OACPJ,EAAgB,+BAA+BC,QAEjDI,YAAY,EACZC,OAAQJ,EAAUI,SAGtBK,QAASZ,EACTa,SACE,mFAEJd,EAAMW,UAAUI,aAAa,OAAQ,SAAU,CAC7C,iBAAkB,CAChBV,QACE,mEACFW,QAAQ,EACRR,OAAQ,CACNS,cAAe,CACbZ,QACE,6DACFE,YAAY,EACZC,OAAQ,CACNE,YAAa,aACbQ,WAAY,CACVb,QAAS,UACTG,OAAQR,EAAMW,UAAUZ,QAI9BoB,OAAQ,YAGZA,YAAQC,IAEVpB,EAAMW,UAAUI,aAAa,OAAQ,aAAc,CACjDM,SAAU,CACRhB,QAAS,OACTiB,MAAO,cAGXtB,EAAMW,UAAUI,aAAa,OAAQ,aAAc,CACjDQ,SAAU,CACRlB,QACE,sEACFG,OAAQ,CACN,aAAcJ,EACdS,QAASZ,EACTS,YAAa,YACbI,SAAU,WAIjB,CA7EA,CA6EEd,EACL,YAlFAwB,EAAiBzB,EACjBA,EAAK0B,YAAc,OACnB1B,EAAK2B,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,t;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(t)return e;function r(e){!function(e){e.languages.dataweave={url:/\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,property:{pattern:/(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,greedy:!0},string:{pattern:/(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,greedy:!0},"mime-type":/\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,date:{pattern:/\|[\w:+-]+\|/,greedy:!0},comment:[{pattern:/(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,lookbehind:!0,greedy:!0},{pattern:/(^|[^\\:])\/\/.*/,lookbehind:!0,greedy:!0}],regex:{pattern:/\/(?:[^\\\/\r\n]|\\[^\r\n])+\//,greedy:!0},keyword:/\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,function:/\b[A-Z_]\w*(?=\s*\()/i,number:/-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,punctuation:/[{}[\];(),.:@]/,operator:/<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,boolean:/\b(?:false|true)\b/}}(e)}return t=1,e=r,r.displayName="dataweave",r.aliases=[],e};
-//# sourceMappingURL=dataweave.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dataweave.js","sources":["../../../../node_modules/refractor/lang/dataweave.js"],"sourcesContent":["'use strict'\n\nmodule.exports = dataweave\ndataweave.displayName = 'dataweave'\ndataweave.aliases = []\nfunction dataweave(Prism) {\n  ;(function (Prism) {\n    Prism.languages.dataweave = {\n      url: /\\b[A-Za-z]+:\\/\\/[\\w/:.?=&-]+|\\burn:[\\w:.?=&-]+/,\n      property: {\n        pattern: /(?:\\b\\w+#)?(?:\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|\\b\\w+)(?=\\s*[:@])/,\n        greedy: true\n      },\n      string: {\n        pattern: /([\"'`])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/,\n        greedy: true\n      },\n      'mime-type':\n        /\\b(?:application|audio|image|multipart|text|video)\\/[\\w+-]+/,\n      date: {\n        pattern: /\\|[\\w:+-]+\\|/,\n        greedy: true\n      },\n      comment: [\n        {\n          pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          pattern: /(^|[^\\\\:])\\/\\/.*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      regex: {\n        pattern: /\\/(?:[^\\\\\\/\\r\\n]|\\\\[^\\r\\n])+\\//,\n        greedy: true\n      },\n      keyword:\n        /\\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\\b/,\n      function: /\\b[A-Z_]\\w*(?=\\s*\\()/i,\n      number: /-?\\b\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?\\b/i,\n      punctuation: /[{}[\\];(),.:@]/,\n      operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\\+\\+?|!|\\?/,\n      boolean: /\\b(?:false|true)\\b/\n    }\n  })(Prism)\n}\n"],"names":["dataweave","Prism","languages","url","property","pattern","greedy","string","date","comment","lookbehind","regex","keyword","function","number","punctuation","operator","boolean","dataweave_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAUC,IAChB,SAAWA,GACVA,EAAMC,UAAUF,UAAY,CAC1BG,IAAK,iDACLC,SAAU,CACRC,QAAS,wDACTC,QAAQ,GAEVC,OAAQ,CACNF,QAAS,qCACTC,QAAQ,GAEV,YACE,8DACFE,KAAM,CACJH,QAAS,eACTC,QAAQ,GAEVG,QAAS,CACP,CACEJ,QAAS,kCACTK,YAAY,EACZJ,QAAQ,GAEV,CACED,QAAS,mBACTK,YAAY,EACZJ,QAAQ,IAGZK,MAAO,CACLN,QAAS,iCACTC,QAAQ,GAEVM,QACE,0GACFC,SAAU,wBACVC,OAAQ,qCACRC,YAAa,iBACbC,SAAU,wCACVC,QAAS,qBAEZ,CAzCA,CAyCEhB,EACL,YA9CAiB,EAAiBlB,EACjBA,EAAUmB,YAAc,YACxBnB,EAAUoB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var E,T;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(T)return E;function A(E){E.languages.dax={comment:{pattern:/(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/).*)/,lookbehind:!0},"data-field":{pattern:/'(?:[^']|'')*'(?!')(?:\[[ \w\xA0-\uFFFF]+\])?|\w+\[[ \w\xA0-\uFFFF]+\]/,alias:"symbol"},measure:{pattern:/\[[ \w\xA0-\uFFFF]+\]/,alias:"constant"},string:{pattern:/"(?:[^"]|"")*"(?!")/,greedy:!0},function:/\b(?:ABS|ACOS|ACOSH|ACOT|ACOTH|ADDCOLUMNS|ADDMISSINGITEMS|ALL|ALLCROSSFILTERED|ALLEXCEPT|ALLNOBLANKROW|ALLSELECTED|AND|APPROXIMATEDISTINCTCOUNT|ASIN|ASINH|ATAN|ATANH|AVERAGE|AVERAGEA|AVERAGEX|BETA\.DIST|BETA\.INV|BLANK|CALCULATE|CALCULATETABLE|CALENDAR|CALENDARAUTO|CEILING|CHISQ\.DIST|CHISQ\.DIST\.RT|CHISQ\.INV|CHISQ\.INV\.RT|CLOSINGBALANCEMONTH|CLOSINGBALANCEQUARTER|CLOSINGBALANCEYEAR|COALESCE|COMBIN|COMBINA|COMBINEVALUES|CONCATENATE|CONCATENATEX|CONFIDENCE\.NORM|CONFIDENCE\.T|CONTAINS|CONTAINSROW|CONTAINSSTRING|CONTAINSSTRINGEXACT|CONVERT|COS|COSH|COT|COTH|COUNT|COUNTA|COUNTAX|COUNTBLANK|COUNTROWS|COUNTX|CROSSFILTER|CROSSJOIN|CURRENCY|CURRENTGROUP|CUSTOMDATA|DATATABLE|DATE|DATEADD|DATEDIFF|DATESBETWEEN|DATESINPERIOD|DATESMTD|DATESQTD|DATESYTD|DATEVALUE|DAY|DEGREES|DETAILROWS|DISTINCT|DISTINCTCOUNT|DISTINCTCOUNTNOBLANK|DIVIDE|EARLIER|EARLIEST|EDATE|ENDOFMONTH|ENDOFQUARTER|ENDOFYEAR|EOMONTH|ERROR|EVEN|EXACT|EXCEPT|EXP|EXPON\.DIST|FACT|FALSE|FILTER|FILTERS|FIND|FIRSTDATE|FIRSTNONBLANK|FIRSTNONBLANKVALUE|FIXED|FLOOR|FORMAT|GCD|GENERATE|GENERATEALL|GENERATESERIES|GEOMEAN|GEOMEANX|GROUPBY|HASONEFILTER|HASONEVALUE|HOUR|IF|IF\.EAGER|IFERROR|IGNORE|INT|INTERSECT|ISBLANK|ISCROSSFILTERED|ISEMPTY|ISERROR|ISEVEN|ISFILTERED|ISINSCOPE|ISLOGICAL|ISNONTEXT|ISNUMBER|ISO\.CEILING|ISODD|ISONORAFTER|ISSELECTEDMEASURE|ISSUBTOTAL|ISTEXT|KEEPFILTERS|KEYWORDMATCH|LASTDATE|LASTNONBLANK|LASTNONBLANKVALUE|LCM|LEFT|LEN|LN|LOG|LOG10|LOOKUPVALUE|LOWER|MAX|MAXA|MAXX|MEDIAN|MEDIANX|MID|MIN|MINA|MINUTE|MINX|MOD|MONTH|MROUND|NATURALINNERJOIN|NATURALLEFTOUTERJOIN|NEXTDAY|NEXTMONTH|NEXTQUARTER|NEXTYEAR|NONVISUAL|NORM\.DIST|NORM\.INV|NORM\.S\.DIST|NORM\.S\.INV|NOT|NOW|ODD|OPENINGBALANCEMONTH|OPENINGBALANCEQUARTER|OPENINGBALANCEYEAR|OR|PARALLELPERIOD|PATH|PATHCONTAINS|PATHITEM|PATHITEMREVERSE|PATHLENGTH|PERCENTILE\.EXC|PERCENTILE\.INC|PERCENTILEX\.EXC|PERCENTILEX\.INC|PERMUT|PI|POISSON\.DIST|POWER|PREVIOUSDAY|PREVIOUSMONTH|PREVIOUSQUARTER|PREVIOUSYEAR|PRODUCT|PRODUCTX|QUARTER|QUOTIENT|RADIANS|RAND|RANDBETWEEN|RANK\.EQ|RANKX|RELATED|RELATEDTABLE|REMOVEFILTERS|REPLACE|REPT|RIGHT|ROLLUP|ROLLUPADDISSUBTOTAL|ROLLUPGROUP|ROLLUPISSUBTOTAL|ROUND|ROUNDDOWN|ROUNDUP|ROW|SAMEPERIODLASTYEAR|SAMPLE|SEARCH|SECOND|SELECTCOLUMNS|SELECTEDMEASURE|SELECTEDMEASUREFORMATSTRING|SELECTEDMEASURENAME|SELECTEDVALUE|SIGN|SIN|SINH|SQRT|SQRTPI|STARTOFMONTH|STARTOFQUARTER|STARTOFYEAR|STDEV\.P|STDEV\.S|STDEVX\.P|STDEVX\.S|SUBSTITUTE|SUBSTITUTEWITHINDEX|SUM|SUMMARIZE|SUMMARIZECOLUMNS|SUMX|SWITCH|T\.DIST|T\.DIST\.2T|T\.DIST\.RT|T\.INV|T\.INV\.2T|TAN|TANH|TIME|TIMEVALUE|TODAY|TOPN|TOPNPERLEVEL|TOPNSKIP|TOTALMTD|TOTALQTD|TOTALYTD|TREATAS|TRIM|TRUE|TRUNC|UNICHAR|UNICODE|UNION|UPPER|USERELATIONSHIP|USERNAME|USEROBJECTID|USERPRINCIPALNAME|UTCNOW|UTCTODAY|VALUE|VALUES|VAR\.P|VAR\.S|VARX\.P|VARX\.S|WEEKDAY|WEEKNUM|XIRR|XNPV|YEAR|YEARFRAC)(?=\s*\()/i,keyword:/\b(?:DEFINE|EVALUATE|MEASURE|ORDER\s+BY|RETURN|VAR|START\s+AT|ASC|DESC)\b/i,boolean:{pattern:/\b(?:FALSE|NULL|TRUE)\b/i,alias:"constant"},number:/\b\d+(?:\.\d*)?|\B\.\d+\b/,operator:/:=|[-+*\/=^]|&&?|\|\||<(?:=>?|<|>)?|>[>=]?|\b(?:IN|NOT)\b/i,punctuation:/[;\[\](){}`,.]/}}return T=1,E=A,A.displayName="dax",A.aliases=[],E};
-//# sourceMappingURL=dax.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dax.js","sources":["../../../../node_modules/refractor/lang/dax.js"],"sourcesContent":["'use strict'\n\nmodule.exports = dax\ndax.displayName = 'dax'\ndax.aliases = []\nfunction dax(Prism) {\n  Prism.languages.dax = {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:--|\\/\\/).*)/,\n      lookbehind: true\n    },\n    'data-field': {\n      pattern:\n        /'(?:[^']|'')*'(?!')(?:\\[[ \\w\\xA0-\\uFFFF]+\\])?|\\w+\\[[ \\w\\xA0-\\uFFFF]+\\]/,\n      alias: 'symbol'\n    },\n    measure: {\n      pattern: /\\[[ \\w\\xA0-\\uFFFF]+\\]/,\n      alias: 'constant'\n    },\n    string: {\n      pattern: /\"(?:[^\"]|\"\")*\"(?!\")/,\n      greedy: true\n    },\n    function:\n      /\\b(?:ABS|ACOS|ACOSH|ACOT|ACOTH|ADDCOLUMNS|ADDMISSINGITEMS|ALL|ALLCROSSFILTERED|ALLEXCEPT|ALLNOBLANKROW|ALLSELECTED|AND|APPROXIMATEDISTINCTCOUNT|ASIN|ASINH|ATAN|ATANH|AVERAGE|AVERAGEA|AVERAGEX|BETA\\.DIST|BETA\\.INV|BLANK|CALCULATE|CALCULATETABLE|CALENDAR|CALENDARAUTO|CEILING|CHISQ\\.DIST|CHISQ\\.DIST\\.RT|CHISQ\\.INV|CHISQ\\.INV\\.RT|CLOSINGBALANCEMONTH|CLOSINGBALANCEQUARTER|CLOSINGBALANCEYEAR|COALESCE|COMBIN|COMBINA|COMBINEVALUES|CONCATENATE|CONCATENATEX|CONFIDENCE\\.NORM|CONFIDENCE\\.T|CONTAINS|CONTAINSROW|CONTAINSSTRING|CONTAINSSTRINGEXACT|CONVERT|COS|COSH|COT|COTH|COUNT|COUNTA|COUNTAX|COUNTBLANK|COUNTROWS|COUNTX|CROSSFILTER|CROSSJOIN|CURRENCY|CURRENTGROUP|CUSTOMDATA|DATATABLE|DATE|DATEADD|DATEDIFF|DATESBETWEEN|DATESINPERIOD|DATESMTD|DATESQTD|DATESYTD|DATEVALUE|DAY|DEGREES|DETAILROWS|DISTINCT|DISTINCTCOUNT|DISTINCTCOUNTNOBLANK|DIVIDE|EARLIER|EARLIEST|EDATE|ENDOFMONTH|ENDOFQUARTER|ENDOFYEAR|EOMONTH|ERROR|EVEN|EXACT|EXCEPT|EXP|EXPON\\.DIST|FACT|FALSE|FILTER|FILTERS|FIND|FIRSTDATE|FIRSTNONBLANK|FIRSTNONBLANKVALUE|FIXED|FLOOR|FORMAT|GCD|GENERATE|GENERATEALL|GENERATESERIES|GEOMEAN|GEOMEANX|GROUPBY|HASONEFILTER|HASONEVALUE|HOUR|IF|IF\\.EAGER|IFERROR|IGNORE|INT|INTERSECT|ISBLANK|ISCROSSFILTERED|ISEMPTY|ISERROR|ISEVEN|ISFILTERED|ISINSCOPE|ISLOGICAL|ISNONTEXT|ISNUMBER|ISO\\.CEILING|ISODD|ISONORAFTER|ISSELECTEDMEASURE|ISSUBTOTAL|ISTEXT|KEEPFILTERS|KEYWORDMATCH|LASTDATE|LASTNONBLANK|LASTNONBLANKVALUE|LCM|LEFT|LEN|LN|LOG|LOG10|LOOKUPVALUE|LOWER|MAX|MAXA|MAXX|MEDIAN|MEDIANX|MID|MIN|MINA|MINUTE|MINX|MOD|MONTH|MROUND|NATURALINNERJOIN|NATURALLEFTOUTERJOIN|NEXTDAY|NEXTMONTH|NEXTQUARTER|NEXTYEAR|NONVISUAL|NORM\\.DIST|NORM\\.INV|NORM\\.S\\.DIST|NORM\\.S\\.INV|NOT|NOW|ODD|OPENINGBALANCEMONTH|OPENINGBALANCEQUARTER|OPENINGBALANCEYEAR|OR|PARALLELPERIOD|PATH|PATHCONTAINS|PATHITEM|PATHITEMREVERSE|PATHLENGTH|PERCENTILE\\.EXC|PERCENTILE\\.INC|PERCENTILEX\\.EXC|PERCENTILEX\\.INC|PERMUT|PI|POISSON\\.DIST|POWER|PREVIOUSDAY|PREVIOUSMONTH|PREVIOUSQUARTER|PREVIOUSYEAR|PRODUCT|PRODUCTX|QUARTER|QUOTIENT|RADIANS|RAND|RANDBETWEEN|RANK\\.EQ|RANKX|RELATED|RELATEDTABLE|REMOVEFILTERS|REPLACE|REPT|RIGHT|ROLLUP|ROLLUPADDISSUBTOTAL|ROLLUPGROUP|ROLLUPISSUBTOTAL|ROUND|ROUNDDOWN|ROUNDUP|ROW|SAMEPERIODLASTYEAR|SAMPLE|SEARCH|SECOND|SELECTCOLUMNS|SELECTEDMEASURE|SELECTEDMEASUREFORMATSTRING|SELECTEDMEASURENAME|SELECTEDVALUE|SIGN|SIN|SINH|SQRT|SQRTPI|STARTOFMONTH|STARTOFQUARTER|STARTOFYEAR|STDEV\\.P|STDEV\\.S|STDEVX\\.P|STDEVX\\.S|SUBSTITUTE|SUBSTITUTEWITHINDEX|SUM|SUMMARIZE|SUMMARIZECOLUMNS|SUMX|SWITCH|T\\.DIST|T\\.DIST\\.2T|T\\.DIST\\.RT|T\\.INV|T\\.INV\\.2T|TAN|TANH|TIME|TIMEVALUE|TODAY|TOPN|TOPNPERLEVEL|TOPNSKIP|TOTALMTD|TOTALQTD|TOTALYTD|TREATAS|TRIM|TRUE|TRUNC|UNICHAR|UNICODE|UNION|UPPER|USERELATIONSHIP|USERNAME|USEROBJECTID|USERPRINCIPALNAME|UTCNOW|UTCTODAY|VALUE|VALUES|VAR\\.P|VAR\\.S|VARX\\.P|VARX\\.S|WEEKDAY|WEEKNUM|XIRR|XNPV|YEAR|YEARFRAC)(?=\\s*\\()/i,\n    keyword:\n      /\\b(?:DEFINE|EVALUATE|MEASURE|ORDER\\s+BY|RETURN|VAR|START\\s+AT|ASC|DESC)\\b/i,\n    boolean: {\n      pattern: /\\b(?:FALSE|NULL|TRUE)\\b/i,\n      alias: 'constant'\n    },\n    number: /\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+\\b/,\n    operator: /:=|[-+*\\/=^]|&&?|\\|\\||<(?:=>?|<|>)?|>[>=]?|\\b(?:IN|NOT)\\b/i,\n    punctuation: /[;\\[\\](){}`,.]/\n  }\n}\n"],"names":["dax","Prism","languages","comment","pattern","lookbehind","alias","measure","string","greedy","function","keyword","boolean","number","operator","punctuation","dax_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAIC,GACXA,EAAMC,UAAUF,IAAM,CACpBG,QAAS,CACPC,QAAS,8CACTC,YAAY,GAEd,aAAc,CACZD,QACE,yEACFE,MAAO,UAETC,QAAS,CACPH,QAAS,wBACTE,MAAO,YAETE,OAAQ,CACNJ,QAAS,sBACTK,QAAQ,GAEVC,SACE,ywFACFC,QACE,6EACFC,QAAS,CACPR,QAAS,2BACTE,MAAO,YAETO,OAAQ,4BACRC,SAAU,6DACVC,YAAa,iBAEjB,YAlCAC,EAAiBhB,EACjBA,EAAIiB,YAAc,MAClBjB,EAAIkB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,n;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(n)return e;function a(e){e.languages.dhall={comment:/--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,string:{pattern:/"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,greedy:!0,inside:{interpolation:{pattern:/\$\{[^{}]*\}/,inside:{expression:{pattern:/(^\$\{)[\s\S]+(?=\}$)/,lookbehind:!0,alias:"language-dhall",inside:null},punctuation:/\$\{|\}/}}}},label:{pattern:/`[^`]*`/,greedy:!0},url:{pattern:/\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,greedy:!0},env:{pattern:/\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,greedy:!0,inside:{function:/^env/,operator:/^:/,variable:/[\s\S]+/}},hash:{pattern:/\bsha256:[\da-fA-F]{64}\b/,inside:{function:/sha256/,operator:/:/,number:/[\da-fA-F]{64}/}},keyword:/\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,builtin:/\b(?:None|Some)\b/,boolean:/\b(?:False|True)\b/,number:/\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,operator:/\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,punctuation:/\.\.|[{}\[\](),./]/,"class-name":/\b[A-Z]\w*\b/},e.languages.dhall.string.inside.interpolation.inside.expression.inside=e.languages.dhall}return n=1,e=a,a.displayName="dhall",a.aliases=[],e};
-//# sourceMappingURL=dhall.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dhall.js","sources":["../../../../node_modules/refractor/lang/dhall.js"],"sourcesContent":["'use strict'\n\nmodule.exports = dhall\ndhall.displayName = 'dhall'\ndhall.aliases = []\nfunction dhall(Prism) {\n  // ABNF grammar:\n  // https://github.com/dhall-lang/dhall-lang/blob/master/standard/dhall.abnf\n  Prism.languages.dhall = {\n    // Multi-line comments can be nested. E.g. {- foo {- bar -} -}\n    // The multi-line pattern is essentially this:\n    //   \\{-(?:[^-{]|-(?!\\})|\\{(?!-)|<SELF>)*-\\}\n    comment:\n      /--.*|\\{-(?:[^-{]|-(?!\\})|\\{(?!-)|\\{-(?:[^-{]|-(?!\\})|\\{(?!-))*-\\})*-\\}/,\n    string: {\n      pattern: /\"(?:[^\"\\\\]|\\\\.)*\"|''(?:[^']|'(?!')|'''|''\\$\\{)*''(?!'|\\$)/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /\\$\\{[^{}]*\\}/,\n          inside: {\n            expression: {\n              pattern: /(^\\$\\{)[\\s\\S]+(?=\\}$)/,\n              lookbehind: true,\n              alias: 'language-dhall',\n              inside: null // see blow\n            },\n            punctuation: /\\$\\{|\\}/\n          }\n        }\n      }\n    },\n    label: {\n      pattern: /`[^`]*`/,\n      greedy: true\n    },\n    url: {\n      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596\n      pattern:\n        /\\bhttps?:\\/\\/[\\w.:%!$&'*+;=@~-]+(?:\\/[\\w.:%!$&'*+;=@~-]*)*(?:\\?[/?\\w.:%!$&'*+;=@~-]*)?/,\n      greedy: true\n    },\n    env: {\n      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661\n      pattern: /\\benv:(?:(?!\\d)\\w+|\"(?:[^\"\\\\=]|\\\\.)*\")/,\n      greedy: true,\n      inside: {\n        function: /^env/,\n        operator: /^:/,\n        variable: /[\\s\\S]+/\n      }\n    },\n    hash: {\n      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725\n      pattern: /\\bsha256:[\\da-fA-F]{64}\\b/,\n      inside: {\n        function: /sha256/,\n        operator: /:/,\n        number: /[\\da-fA-F]{64}/\n      }\n    },\n    // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359\n    keyword:\n      /\\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\\b|\\u2200/,\n    builtin: /\\b(?:None|Some)\\b/,\n    boolean: /\\b(?:False|True)\\b/,\n    number:\n      /\\bNaN\\b|-?\\bInfinity\\b|[+-]?\\b(?:0x[\\da-fA-F]+|\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?)\\b/,\n    operator:\n      /\\/\\\\|\\/\\/\\\\\\\\|&&|\\|\\||===|[!=]=|\\/\\/|->|\\+\\+|::|[+*#@=:?<>|\\\\\\u2227\\u2a53\\u2261\\u2afd\\u03bb\\u2192]/,\n    punctuation: /\\.\\.|[{}\\[\\](),./]/,\n    // we'll just assume that every capital word left is a type name\n    'class-name': /\\b[A-Z]\\w*\\b/\n  }\n  Prism.languages.dhall.string.inside.interpolation.inside.expression.inside =\n    Prism.languages.dhall\n}\n"],"names":["dhall","Prism","languages","comment","string","pattern","greedy","inside","interpolation","expression","lookbehind","alias","punctuation","label","url","env","function","operator","variable","hash","number","keyword","builtin","boolean","dhall_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAMC,GAGbA,EAAMC,UAAUF,MAAQ,CAItBG,QACE,yEACFC,OAAQ,CACNC,QAAS,4DACTC,QAAQ,EACRC,OAAQ,CACNC,cAAe,CACbH,QAAS,eACTE,OAAQ,CACNE,WAAY,CACVJ,QAAS,wBACTK,YAAY,EACZC,MAAO,iBACPJ,OAAQ,MAEVK,YAAa,cAKrBC,MAAO,CACLR,QAAS,UACTC,QAAQ,GAEVQ,IAAK,CAEHT,QACE,yFACFC,QAAQ,GAEVS,IAAK,CAEHV,QAAS,yCACTC,QAAQ,EACRC,OAAQ,CACNS,SAAU,OACVC,SAAU,KACVC,SAAU,YAGdC,KAAM,CAEJd,QAAS,4BACTE,OAAQ,CACNS,SAAU,SACVC,SAAU,IACVG,OAAQ,mBAIZC,QACE,qFACFC,QAAS,oBACTC,QAAS,qBACTH,OACE,gFACFH,SACE,qGACFL,YAAa,qBAEb,aAAc,gBAEhBX,EAAMC,UAAUF,MAAMI,OAAOG,OAAOC,cAAcD,OAAOE,WAAWF,OAClEN,EAAMC,UAAUF,KACpB,YA1EAwB,EAAiBxB,EACjBA,EAAMyB,YAAc,QACpBzB,EAAM0B,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,n;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(n)return e;function r(e){!function(e){e.languages.diff={coord:[/^(?:\*{3}|-{3}|\+{3}).*$/m,/^@@.*@@$/m,/^\d.*$/m]};var n={"deleted-sign":"-","deleted-arrow":"<","inserted-sign":"+","inserted-arrow":">",unchanged:" ",diff:"!"};Object.keys(n).forEach((function(r){var i=n[r],t=[];/^\w+$/.test(r)||t.push(/\w+/.exec(r)[0]),"diff"===r&&t.push("bold"),e.languages.diff[r]={pattern:RegExp("^(?:["+i+"].*(?:\r\n?|\n|(?![\\s\\S])))+","m"),alias:t,inside:{line:{pattern:/(.)(?=[\s\S]).*(?:\r\n?|\n)?/,lookbehind:!0},prefix:{pattern:/[\s\S]/,alias:/\w+/.exec(r)[0]}}}})),Object.defineProperty(e.languages.diff,"PREFIXES",{value:n})}(e)}return n=1,e=r,r.displayName="diff",r.aliases=[],e};
-//# sourceMappingURL=diff.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"diff.js","sources":["../../../../node_modules/refractor/lang/diff.js"],"sourcesContent":["'use strict'\n\nmodule.exports = diff\ndiff.displayName = 'diff'\ndiff.aliases = []\nfunction diff(Prism) {\n  ;(function (Prism) {\n    Prism.languages.diff = {\n      coord: [\n        // Match all kinds of coord lines (prefixed by \"+++\", \"---\" or \"***\").\n        /^(?:\\*{3}|-{3}|\\+{3}).*$/m, // Match \"@@ ... @@\" coord lines in unified diff.\n        /^@@.*@@$/m, // Match coord lines in normal diff (starts with a number).\n        /^\\d.*$/m\n      ] // deleted, inserted, unchanged, diff\n    }\n    /**\n     * A map from the name of a block to its line prefix.\n     *\n     * @type {Object<string, string>}\n     */\n    var PREFIXES = {\n      'deleted-sign': '-',\n      'deleted-arrow': '<',\n      'inserted-sign': '+',\n      'inserted-arrow': '>',\n      unchanged: ' ',\n      diff: '!'\n    } // add a token for each prefix\n    Object.keys(PREFIXES).forEach(function (name) {\n      var prefix = PREFIXES[name]\n      var alias = []\n      if (!/^\\w+$/.test(name)) {\n        // \"deleted-sign\" -> \"deleted\"\n        alias.push(/\\w+/.exec(name)[0])\n      }\n      if (name === 'diff') {\n        alias.push('bold')\n      }\n      Prism.languages.diff[name] = {\n        pattern: RegExp(\n          '^(?:[' + prefix + '].*(?:\\r\\n?|\\n|(?![\\\\s\\\\S])))+',\n          'm'\n        ),\n        alias: alias,\n        inside: {\n          line: {\n            pattern: /(.)(?=[\\s\\S]).*(?:\\r\\n?|\\n)?/,\n            lookbehind: true\n          },\n          prefix: {\n            pattern: /[\\s\\S]/,\n            alias: /\\w+/.exec(name)[0]\n          }\n        }\n      }\n    }) // make prefixes available to Diff plugin\n    Object.defineProperty(Prism.languages.diff, 'PREFIXES', {\n      value: PREFIXES\n    })\n  })(Prism)\n}\n"],"names":["diff","Prism","languages","coord","PREFIXES","unchanged","Object","keys","forEach","name","prefix","alias","test","push","exec","pattern","RegExp","inside","line","lookbehind","defineProperty","value","diff_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAKC,IACX,SAAWA,GACVA,EAAMC,UAAUF,KAAO,CACrBG,MAAO,CAEL,4BACA,YACA,YAQJ,IAAIC,EAAW,CACb,eAAgB,IAChB,gBAAiB,IACjB,gBAAiB,IACjB,iBAAkB,IAClBC,UAAW,IACXL,KAAM,KAERM,OAAOC,KAAKH,GAAUI,SAAQ,SAAUC,GACtC,IAAIC,EAASN,EAASK,GAClBE,EAAQ,GACP,QAAQC,KAAKH,IAEhBE,EAAME,KAAK,MAAMC,KAAKL,GAAM,IAEjB,SAATA,GACFE,EAAME,KAAK,QAEbZ,EAAMC,UAAUF,KAAKS,GAAQ,CAC3BM,QAASC,OACP,QAAUN,EAAS,iCACnB,KAEFC,MAAOA,EACPM,OAAQ,CACNC,KAAM,CACJH,QAAS,+BACTI,YAAY,GAEdT,OAAQ,CACNK,QAAS,SACTJ,MAAO,MAAMG,KAAKL,GAAM,KAIpC,IACIH,OAAOc,eAAenB,EAAMC,UAAUF,KAAM,WAAY,CACtDqB,MAAOjB,GAEV,CArDA,CAqDEH,EACL,YA1DAqB,EAAiBtB,EACjBA,EAAKuB,YAAc,OACnBvB,EAAKwB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,n,o=require("./markup-templating.js");exports.__require=function(){if(n)return e;n=1;var a=o.__require();function t(e){e.register(a),function(e){e.languages.django={comment:/^\{#[\s\S]*?#\}$/,tag:{pattern:/(^\{%[+-]?\s*)\w+/,lookbehind:!0,alias:"keyword"},delimiter:{pattern:/^\{[{%][+-]?|[+-]?[}%]\}$/,alias:"punctuation"},string:{pattern:/("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,greedy:!0},filter:{pattern:/(\|)\w+/,lookbehind:!0,alias:"function"},test:{pattern:/(\bis\s+(?:not\s+)?)(?!not\b)\w+/,lookbehind:!0,alias:"function"},function:/\b[a-z_]\w+(?=\s*\()/i,keyword:/\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,operator:/[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,number:/\b\d+(?:\.\d+)?\b/,boolean:/[Ff]alse|[Nn]one|[Tt]rue/,variable:/\b\w+\b/,punctuation:/[{}[\](),.:;]/};var n=/\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g,o=e.languages["markup-templating"];e.hooks.add("before-tokenize",(function(e){o.buildPlaceholders(e,"django",n)})),e.hooks.add("after-tokenize",(function(e){o.tokenizePlaceholders(e,"django")})),e.languages.jinja2=e.languages.django,e.hooks.add("before-tokenize",(function(e){o.buildPlaceholders(e,"jinja2",n)})),e.hooks.add("after-tokenize",(function(e){o.tokenizePlaceholders(e,"jinja2")}))}(e)}return e=t,t.displayName="django",t.aliases=["jinja2"],e};
-//# sourceMappingURL=django.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"django.js","sources":["../../../../node_modules/refractor/lang/django.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = django\ndjango.displayName = 'django'\ndjango.aliases = ['jinja2']\nfunction django(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  // Django/Jinja2 syntax definition for Prism.js <http://prismjs.com> syntax highlighter.\n  // Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.\n  ;(function (Prism) {\n    Prism.languages.django = {\n      comment: /^\\{#[\\s\\S]*?#\\}$/,\n      tag: {\n        pattern: /(^\\{%[+-]?\\s*)\\w+/,\n        lookbehind: true,\n        alias: 'keyword'\n      },\n      delimiter: {\n        pattern: /^\\{[{%][+-]?|[+-]?[}%]\\}$/,\n        alias: 'punctuation'\n      },\n      string: {\n        pattern: /(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n        greedy: true\n      },\n      filter: {\n        pattern: /(\\|)\\w+/,\n        lookbehind: true,\n        alias: 'function'\n      },\n      test: {\n        pattern: /(\\bis\\s+(?:not\\s+)?)(?!not\\b)\\w+/,\n        lookbehind: true,\n        alias: 'function'\n      },\n      function: /\\b[a-z_]\\w+(?=\\s*\\()/i,\n      keyword:\n        /\\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\\b/,\n      operator: /[-+%=]=?|!=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]/,\n      number: /\\b\\d+(?:\\.\\d+)?\\b/,\n      boolean: /[Ff]alse|[Nn]one|[Tt]rue/,\n      variable: /\\b\\w+\\b/,\n      punctuation: /[{}[\\](),.:;]/\n    }\n    var pattern = /\\{\\{[\\s\\S]*?\\}\\}|\\{%[\\s\\S]*?%\\}|\\{#[\\s\\S]*?#\\}/g\n    var markupTemplating = Prism.languages['markup-templating']\n    Prism.hooks.add('before-tokenize', function (env) {\n      markupTemplating.buildPlaceholders(env, 'django', pattern)\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      markupTemplating.tokenizePlaceholders(env, 'django')\n    }) // Add an Jinja2 alias\n    Prism.languages.jinja2 = Prism.languages.django\n    Prism.hooks.add('before-tokenize', function (env) {\n      markupTemplating.buildPlaceholders(env, 'jinja2', pattern)\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      markupTemplating.tokenizePlaceholders(env, 'jinja2')\n    })\n  })(Prism)\n}\n"],"names":["refractorMarkupTemplating","require$$0","django","Prism","register","languages","comment","tag","pattern","lookbehind","alias","delimiter","string","greedy","filter","test","function","keyword","operator","number","boolean","variable","punctuation","markupTemplating","hooks","add","env","buildPlaceholders","tokenizePlaceholders","jinja2","django_1","displayName","aliases"],"mappings":"+JACA,IAAIA,EAA4BC,EAAAA,YAIhC,SAASC,EAAOC,GACdA,EAAMC,SAASJ,GAGd,SAAWG,GACVA,EAAME,UAAUH,OAAS,CACvBI,QAAS,mBACTC,IAAK,CACHC,QAAS,oBACTC,YAAY,EACZC,MAAO,WAETC,UAAW,CACTH,QAAS,4BACTE,MAAO,eAETE,OAAQ,CACNJ,QAAS,kCACTK,QAAQ,GAEVC,OAAQ,CACNN,QAAS,UACTC,YAAY,EACZC,MAAO,YAETK,KAAM,CACJP,QAAS,mCACTC,YAAY,EACZC,MAAO,YAETM,SAAU,wBACVC,QACE,gFACFC,SAAU,oDACVC,OAAQ,oBACRC,QAAS,2BACTC,SAAU,UACVC,YAAa,iBAEf,IAAId,EAAU,kDACVe,EAAmBpB,EAAME,UAAU,qBACvCF,EAAMqB,MAAMC,IAAI,mBAAmB,SAAUC,GAC3CH,EAAiBI,kBAAkBD,EAAK,SAAUlB,EACxD,IACIL,EAAMqB,MAAMC,IAAI,kBAAkB,SAAUC,GAC1CH,EAAiBK,qBAAqBF,EAAK,SACjD,IACIvB,EAAME,UAAUwB,OAAS1B,EAAME,UAAUH,OACzCC,EAAMqB,MAAMC,IAAI,mBAAmB,SAAUC,GAC3CH,EAAiBI,kBAAkBD,EAAK,SAAUlB,EACxD,IACIL,EAAMqB,MAAMC,IAAI,kBAAkB,SAAUC,GAC1CH,EAAiBK,qBAAqBF,EAAK,SACjD,GACG,CAlDA,CAkDEvB,EACL,QA1DA2B,EAAiB5B,EACjBA,EAAO6B,YAAc,SACrB7B,EAAO8B,QAAU,CAAC"}

package/dist/node_modules/refractor/lang/dns-zone-file.js

@@ -1,2 +0,0 @@
-"use strict";var e,n;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(n)return e;function S(e){e.languages["dns-zone-file"]={comment:/;.*/,string:{pattern:/"(?:\\.|[^"\\\r\n])*"/,greedy:!0},variable:[{pattern:/(^\$ORIGIN[ \t]+)\S+/m,lookbehind:!0},{pattern:/(^|\s)@(?=\s|$)/,lookbehind:!0}],keyword:/^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m,class:{pattern:/(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/,lookbehind:!0,alias:"keyword"},type:{pattern:/(^|\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\s|$)/,lookbehind:!0,alias:"keyword"},punctuation:/[()]/},e.languages["dns-zone"]=e.languages["dns-zone-file"]}return n=1,e=S,S.displayName="dnsZoneFile",S.aliases=[],e};
-//# sourceMappingURL=dns-zone-file.js.map

package/dist/node_modules/refractor/lang/dns-zone-file.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dns-zone-file.js","sources":["../../../../node_modules/refractor/lang/dns-zone-file.js"],"sourcesContent":["'use strict'\n\nmodule.exports = dnsZoneFile\ndnsZoneFile.displayName = 'dnsZoneFile'\ndnsZoneFile.aliases = []\nfunction dnsZoneFile(Prism) {\n  Prism.languages['dns-zone-file'] = {\n    comment: /;.*/,\n    string: {\n      pattern: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n      greedy: true\n    },\n    variable: [\n      {\n        pattern: /(^\\$ORIGIN[ \\t]+)\\S+/m,\n        lookbehind: true\n      },\n      {\n        pattern: /(^|\\s)@(?=\\s|$)/,\n        lookbehind: true\n      }\n    ],\n    keyword: /^\\$(?:INCLUDE|ORIGIN|TTL)(?=\\s|$)/m,\n    class: {\n      // https://tools.ietf.org/html/rfc1035#page-13\n      pattern: /(^|\\s)(?:CH|CS|HS|IN)(?=\\s|$)/,\n      lookbehind: true,\n      alias: 'keyword'\n    },\n    type: {\n      // https://en.wikipedia.org/wiki/List_of_DNS_record_types\n      pattern:\n        /(^|\\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\\s|$)/,\n      lookbehind: true,\n      alias: 'keyword'\n    },\n    punctuation: /[()]/\n  }\n  Prism.languages['dns-zone'] = Prism.languages['dns-zone-file']\n}\n"],"names":["dnsZoneFile","Prism","languages","comment","string","pattern","greedy","variable","lookbehind","keyword","class","alias","type","punctuation","dnsZoneFile_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAYC,GACnBA,EAAMC,UAAU,iBAAmB,CACjCC,QAAS,MACTC,OAAQ,CACNC,QAAS,wBACTC,QAAQ,GAEVC,SAAU,CACR,CACEF,QAAS,wBACTG,YAAY,GAEd,CACEH,QAAS,kBACTG,YAAY,IAGhBC,QAAS,qCACTC,MAAO,CAELL,QAAS,gCACTG,YAAY,EACZG,MAAO,WAETC,KAAM,CAEJP,QACE,2XACFG,YAAY,EACZG,MAAO,WAETE,YAAa,QAEfZ,EAAMC,UAAU,YAAcD,EAAMC,UAAU,gBAChD,YArCAY,EAAiBd,EACjBA,EAAYe,YAAc,cAC1Bf,EAAYgB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(r)return e;function n(e){!function(e){var r=/\\[\r\n](?:\s|\\[\r\n]|#.*(?!.))*(?![\s#]|\\[\r\n])/.source,n=/(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(/<SP_BS>/g,(function(){return r})),t=/"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"|'(?:[^'\\\r\n]|\\(?:\r\n|[\s\S]))*'/.source,o=/--[\w-]+=(?:<STR>|(?!["'])(?:[^\s\\]|\\.)+)/.source.replace(/<STR>/g,(function(){return t})),i={pattern:RegExp(t),greedy:!0},s={pattern:/(^[ \t]*)#.*/m,lookbehind:!0,greedy:!0};function u(e,r){return e=e.replace(/<OPT>/g,(function(){return o})).replace(/<SP>/g,(function(){return n})),RegExp(e,r)}e.languages.docker={instruction:{pattern:/(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im,lookbehind:!0,greedy:!0,inside:{options:{pattern:u(/(^(?:ONBUILD<SP>)?\w+<SP>)<OPT>(?:<SP><OPT>)*/.source,"i"),lookbehind:!0,greedy:!0,inside:{property:{pattern:/(^|\s)--[\w-]+/,lookbehind:!0},string:[i,{pattern:/(=)(?!["'])(?:[^\s\\]|\\.)+/,lookbehind:!0}],operator:/\\$/m,punctuation:/=/}},keyword:[{pattern:u(/(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\b/.source,"i"),lookbehind:!0,greedy:!0},{pattern:u(/(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\]+<SP>)AS/.source,"i"),lookbehind:!0,greedy:!0},{pattern:u(/(^ONBUILD<SP>)\w+/.source,"i"),lookbehind:!0,greedy:!0},{pattern:/^\w+/,greedy:!0}],comment:s,string:i,variable:/\$(?:\w+|\{[^{}"'\\]*\})/,operator:/\\$/m}},comment:s},e.languages.dockerfile=e.languages.docker}(e)}return r=1,e=n,n.displayName="docker",n.aliases=["dockerfile"],e};
-//# sourceMappingURL=docker.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"docker.js","sources":["../../../../node_modules/refractor/lang/docker.js"],"sourcesContent":["'use strict'\n\nmodule.exports = docker\ndocker.displayName = 'docker'\ndocker.aliases = ['dockerfile']\nfunction docker(Prism) {\n  ;(function (Prism) {\n    // Many of the following regexes will contain negated lookaheads like `[ \\t]+(?![ \\t])`. This is a trick to ensure\n    // that quantifiers behave *atomically*. Atomic quantifiers are necessary to prevent exponential backtracking.\n    var spaceAfterBackSlash =\n      /\\\\[\\r\\n](?:\\s|\\\\[\\r\\n]|#.*(?!.))*(?![\\s#]|\\\\[\\r\\n])/.source // At least one space, comment, or line break\n    var space = /(?:[ \\t]+(?![ \\t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(\n      /<SP_BS>/g,\n      function () {\n        return spaceAfterBackSlash\n      }\n    )\n    var string =\n      /\"(?:[^\"\\\\\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*\"|'(?:[^'\\\\\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*'/\n        .source\n    var option = /--[\\w-]+=(?:<STR>|(?![\"'])(?:[^\\s\\\\]|\\\\.)+)/.source.replace(\n      /<STR>/g,\n      function () {\n        return string\n      }\n    )\n    var stringRule = {\n      pattern: RegExp(string),\n      greedy: true\n    }\n    var commentRule = {\n      pattern: /(^[ \\t]*)#.*/m,\n      lookbehind: true,\n      greedy: true\n    }\n    /**\n     * @param {string} source\n     * @param {string} flags\n     * @returns {RegExp}\n     */\n    function re(source, flags) {\n      source = source\n        .replace(/<OPT>/g, function () {\n          return option\n        })\n        .replace(/<SP>/g, function () {\n          return space\n        })\n      return RegExp(source, flags)\n    }\n    Prism.languages.docker = {\n      instruction: {\n        pattern:\n          /(^[ \\t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\\s)(?:\\\\.|[^\\r\\n\\\\])*(?:\\\\$(?:\\s|#.*$)*(?![\\s#])(?:\\\\.|[^\\r\\n\\\\])*)*/im,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          options: {\n            pattern: re(\n              /(^(?:ONBUILD<SP>)?\\w+<SP>)<OPT>(?:<SP><OPT>)*/.source,\n              'i'\n            ),\n            lookbehind: true,\n            greedy: true,\n            inside: {\n              property: {\n                pattern: /(^|\\s)--[\\w-]+/,\n                lookbehind: true\n              },\n              string: [\n                stringRule,\n                {\n                  pattern: /(=)(?![\"'])(?:[^\\s\\\\]|\\\\.)+/,\n                  lookbehind: true\n                }\n              ],\n              operator: /\\\\$/m,\n              punctuation: /=/\n            }\n          },\n          keyword: [\n            {\n              // https://docs.docker.com/engine/reference/builder/#healthcheck\n              pattern: re(\n                /(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\\b/\n                  .source,\n                'i'\n              ),\n              lookbehind: true,\n              greedy: true\n            },\n            {\n              // https://docs.docker.com/engine/reference/builder/#from\n              pattern: re(\n                /(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \\t\\\\]+<SP>)AS/\n                  .source,\n                'i'\n              ),\n              lookbehind: true,\n              greedy: true\n            },\n            {\n              // https://docs.docker.com/engine/reference/builder/#onbuild\n              pattern: re(/(^ONBUILD<SP>)\\w+/.source, 'i'),\n              lookbehind: true,\n              greedy: true\n            },\n            {\n              pattern: /^\\w+/,\n              greedy: true\n            }\n          ],\n          comment: commentRule,\n          string: stringRule,\n          variable: /\\$(?:\\w+|\\{[^{}\"'\\\\]*\\})/,\n          operator: /\\\\$/m\n        }\n      },\n      comment: commentRule\n    }\n    Prism.languages.dockerfile = Prism.languages.docker\n  })(Prism)\n}\n"],"names":["docker","Prism","spaceAfterBackSlash","source","space","replace","string","option","stringRule","pattern","RegExp","greedy","commentRule","lookbehind","re","flags","languages","instruction","inside","options","property","operator","punctuation","keyword","comment","variable","dockerfile","docker_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAOC,IACb,SAAWA,GAGV,IAAIC,EACF,sDAAsDC,OACpDC,EAAQ,0CAA0CD,OAAOE,QAC3D,YACA,WACE,OAAOH,CACR,IAECI,EACF,0EACGH,OACDI,EAAS,8CAA8CJ,OAAOE,QAChE,UACA,WACE,OAAOC,CACR,IAECE,EAAa,CACfC,QAASC,OAAOJ,GAChBK,QAAQ,GAENC,EAAc,CAChBH,QAAS,gBACTI,YAAY,EACZF,QAAQ,GAOV,SAASG,EAAGX,EAAQY,GAQlB,OAPAZ,EAASA,EACNE,QAAQ,UAAU,WACjB,OAAOE,CACjB,IACSF,QAAQ,SAAS,WAChB,OAAOD,CACjB,IACaM,OAAOP,EAAQY,EACvB,CACDd,EAAMe,UAAUhB,OAAS,CACvBiB,YAAa,CACXR,QACE,kNACFI,YAAY,EACZF,QAAQ,EACRO,OAAQ,CACNC,QAAS,CACPV,QAASK,EACP,gDAAgDX,OAChD,KAEFU,YAAY,EACZF,QAAQ,EACRO,OAAQ,CACNE,SAAU,CACRX,QAAS,iBACTI,YAAY,GAEdP,OAAQ,CACNE,EACA,CACEC,QAAS,8BACTI,YAAY,IAGhBQ,SAAU,OACVC,YAAa,MAGjBC,QAAS,CACP,CAEEd,QAASK,EACP,iEACGX,OACH,KAEFU,YAAY,EACZF,QAAQ,GAEV,CAEEF,QAASK,EACP,iEACGX,OACH,KAEFU,YAAY,EACZF,QAAQ,GAEV,CAEEF,QAASK,EAAG,oBAAoBX,OAAQ,KACxCU,YAAY,EACZF,QAAQ,GAEV,CACEF,QAAS,OACTE,QAAQ,IAGZa,QAASZ,EACTN,OAAQE,EACRiB,SAAU,2BACVJ,SAAU,SAGdG,QAASZ,GAEXX,EAAMe,UAAUU,WAAazB,EAAMe,UAAUhB,MAC9C,CAnHA,CAmHEC,EACL,YAxHA0B,EAAiB3B,EACjBA,EAAO4B,YAAc,SACrB5B,EAAO6B,QAAU,CAAC"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(r)return e;function n(e){!function(e){var r="(?:"+[/[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source,/-?(?:\.\d+|\d+(?:\.\d*)?)/.source,/"[^"\\]*(?:\\[\s\S][^"\\]*)*"/.source,/<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/.source].join("|")+")",n={markup:{pattern:/(^<)[\s\S]+(?=>$)/,lookbehind:!0,alias:["language-markup","language-html","language-xml"],inside:e.languages.markup}};function a(e,n){return RegExp(e.replace(/<ID>/g,(function(){return r})),n)}e.languages.dot={comment:{pattern:/\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,greedy:!0},"graph-name":{pattern:a(/(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,"i"),lookbehind:!0,greedy:!0,alias:"class-name",inside:n},"attr-value":{pattern:a(/(=[ \t\r\n]*)<ID>/.source),lookbehind:!0,greedy:!0,inside:n},"attr-name":{pattern:a(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),lookbehind:!0,greedy:!0,inside:n},keyword:/\b(?:digraph|edge|graph|node|strict|subgraph)\b/i,"compass-point":{pattern:/(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/,lookbehind:!0,alias:"builtin"},node:{pattern:a(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),lookbehind:!0,greedy:!0,inside:n},operator:/[=:]|-[->]/,punctuation:/[\[\]{};,]/},e.languages.gv=e.languages.dot}(e)}return r=1,e=n,n.displayName="dot",n.aliases=["gv"],e};
-//# sourceMappingURL=dot.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dot.js","sources":["../../../../node_modules/refractor/lang/dot.js"],"sourcesContent":["'use strict'\n\nmodule.exports = dot\ndot.displayName = 'dot'\ndot.aliases = ['gv']\nfunction dot(Prism) {\n  // https://www.graphviz.org/doc/info/lang.html\n  ;(function (Prism) {\n    var ID =\n      '(?:' +\n      [\n        // an identifier\n        /[a-zA-Z_\\x80-\\uFFFF][\\w\\x80-\\uFFFF]*/.source, // a number\n        /-?(?:\\.\\d+|\\d+(?:\\.\\d*)?)/.source, // a double-quoted string\n        /\"[^\"\\\\]*(?:\\\\[\\s\\S][^\"\\\\]*)*\"/.source, // HTML-like string\n        /<(?:[^<>]|(?!<!--)<(?:[^<>\"']|\"[^\"]*\"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/\n          .source\n      ].join('|') +\n      ')'\n    var IDInside = {\n      markup: {\n        pattern: /(^<)[\\s\\S]+(?=>$)/,\n        lookbehind: true,\n        alias: ['language-markup', 'language-html', 'language-xml'],\n        inside: Prism.languages.markup\n      }\n    }\n    /**\n     * @param {string} source\n     * @param {string} flags\n     * @returns {RegExp}\n     */\n    function withID(source, flags) {\n      return RegExp(\n        source.replace(/<ID>/g, function () {\n          return ID\n        }),\n        flags\n      )\n    }\n    Prism.languages.dot = {\n      comment: {\n        pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\/|^#.*/m,\n        greedy: true\n      },\n      'graph-name': {\n        pattern: withID(\n          /(\\b(?:digraph|graph|subgraph)[ \\t\\r\\n]+)<ID>/.source,\n          'i'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'class-name',\n        inside: IDInside\n      },\n      'attr-value': {\n        pattern: withID(/(=[ \\t\\r\\n]*)<ID>/.source),\n        lookbehind: true,\n        greedy: true,\n        inside: IDInside\n      },\n      'attr-name': {\n        pattern: withID(/([\\[;, \\t\\r\\n])<ID>(?=[ \\t\\r\\n]*=)/.source),\n        lookbehind: true,\n        greedy: true,\n        inside: IDInside\n      },\n      keyword: /\\b(?:digraph|edge|graph|node|strict|subgraph)\\b/i,\n      'compass-point': {\n        pattern: /(:[ \\t\\r\\n]*)(?:[ewc_]|[ns][ew]?)(?![\\w\\x80-\\uFFFF])/,\n        lookbehind: true,\n        alias: 'builtin'\n      },\n      node: {\n        pattern: withID(/(^|[^-.\\w\\x80-\\uFFFF\\\\])<ID>/.source),\n        lookbehind: true,\n        greedy: true,\n        inside: IDInside\n      },\n      operator: /[=:]|-[->]/,\n      punctuation: /[\\[\\]{};,]/\n    }\n    Prism.languages.gv = Prism.languages.dot\n  })(Prism)\n}\n"],"names":["dot","Prism","ID","source","join","IDInside","markup","pattern","lookbehind","alias","inside","languages","withID","flags","RegExp","replace","comment","greedy","keyword","node","operator","punctuation","gv","dot_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAIC,IAEV,SAAWA,GACV,IAAIC,EACF,MACA,CAEE,uCAAuCC,OACvC,4BAA4BA,OAC5B,gCAAgCA,OAChC,+EACGA,QACHC,KAAK,KACP,IACEC,EAAW,CACbC,OAAQ,CACNC,QAAS,oBACTC,YAAY,EACZC,MAAO,CAAC,kBAAmB,gBAAiB,gBAC5CC,OAAQT,EAAMU,UAAUL,SAQ5B,SAASM,EAAOT,EAAQU,GACtB,OAAOC,OACLX,EAAOY,QAAQ,SAAS,WACtB,OAAOb,CACjB,IACQW,EAEH,CACDZ,EAAMU,UAAUX,IAAM,CACpBgB,QAAS,CACPT,QAAS,gCACTU,QAAQ,GAEV,aAAc,CACZV,QAASK,EACP,+CAA+CT,OAC/C,KAEFK,YAAY,EACZS,QAAQ,EACRR,MAAO,aACPC,OAAQL,GAEV,aAAc,CACZE,QAASK,EAAO,oBAAoBT,QACpCK,YAAY,EACZS,QAAQ,EACRP,OAAQL,GAEV,YAAa,CACXE,QAASK,EAAO,qCAAqCT,QACrDK,YAAY,EACZS,QAAQ,EACRP,OAAQL,GAEVa,QAAS,mDACT,gBAAiB,CACfX,QAAS,uDACTC,YAAY,EACZC,MAAO,WAETU,KAAM,CACJZ,QAASK,EAAO,+BAA+BT,QAC/CK,YAAY,EACZS,QAAQ,EACRP,OAAQL,GAEVe,SAAU,aACVC,YAAa,cAEfpB,EAAMU,UAAUW,GAAKrB,EAAMU,UAAUX,GACtC,CA5EA,CA4EEC,EACL,YAlFAsB,EAAiBvB,EACjBA,EAAIwB,YAAc,MAClBxB,EAAIyB,QAAU,CAAC"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(r)return e;function t(e){e.languages.ebnf={comment:/\(\*[\s\S]*?\*\)/,string:{pattern:/"[^"\r\n]*"|'[^'\r\n]*'/,greedy:!0},special:{pattern:/\?[^?\r\n]*\?/,greedy:!0,alias:"class-name"},definition:{pattern:/^([\t ]*)[a-z]\w*(?:[ \t]+[a-z]\w*)*(?=\s*=)/im,lookbehind:!0,alias:["rule","keyword"]},rule:/\b[a-z]\w*(?:[ \t]+[a-z]\w*)*\b/i,punctuation:/\([:/]|[:/]\)|[.,;()[\]{}]/,operator:/[-=|*/!]/}}return r=1,e=t,t.displayName="ebnf",t.aliases=[],e};
-//# sourceMappingURL=ebnf.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ebnf.js","sources":["../../../../node_modules/refractor/lang/ebnf.js"],"sourcesContent":["'use strict'\n\nmodule.exports = ebnf\nebnf.displayName = 'ebnf'\nebnf.aliases = []\nfunction ebnf(Prism) {\n  Prism.languages.ebnf = {\n    comment: /\\(\\*[\\s\\S]*?\\*\\)/,\n    string: {\n      pattern: /\"[^\"\\r\\n]*\"|'[^'\\r\\n]*'/,\n      greedy: true\n    },\n    special: {\n      pattern: /\\?[^?\\r\\n]*\\?/,\n      greedy: true,\n      alias: 'class-name'\n    },\n    definition: {\n      pattern: /^([\\t ]*)[a-z]\\w*(?:[ \\t]+[a-z]\\w*)*(?=\\s*=)/im,\n      lookbehind: true,\n      alias: ['rule', 'keyword']\n    },\n    rule: /\\b[a-z]\\w*(?:[ \\t]+[a-z]\\w*)*\\b/i,\n    punctuation: /\\([:/]|[:/]\\)|[.,;()[\\]{}]/,\n    operator: /[-=|*/!]/\n  }\n}\n"],"names":["ebnf","Prism","languages","comment","string","pattern","greedy","special","alias","definition","lookbehind","rule","punctuation","operator","ebnf_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAKC,GACZA,EAAMC,UAAUF,KAAO,CACrBG,QAAS,mBACTC,OAAQ,CACNC,QAAS,0BACTC,QAAQ,GAEVC,QAAS,CACPF,QAAS,gBACTC,QAAQ,EACRE,MAAO,cAETC,WAAY,CACVJ,QAAS,iDACTK,YAAY,EACZF,MAAO,CAAC,OAAQ,YAElBG,KAAM,mCACNC,YAAa,6BACbC,SAAU,WAEd,YAxBAC,EAAiBd,EACjBA,EAAKe,YAAc,OACnBf,EAAKgB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,t;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(t)return e;function a(e){e.languages.editorconfig={comment:/[;#].*/,section:{pattern:/(^[ \t]*)\[.+\]/m,lookbehind:!0,alias:"selector",inside:{regex:/\\\\[\[\]{},!?.*]/,operator:/[!?]|\.\.|\*{1,2}/,punctuation:/[\[\]{},]/}},key:{pattern:/(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,lookbehind:!0,alias:"attr-name"},value:{pattern:/=.*/,alias:"attr-value",inside:{punctuation:/^=/}}}}return t=1,e=a,a.displayName="editorconfig",a.aliases=[],e};
-//# sourceMappingURL=editorconfig.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"editorconfig.js","sources":["../../../../node_modules/refractor/lang/editorconfig.js"],"sourcesContent":["'use strict'\n\nmodule.exports = editorconfig\neditorconfig.displayName = 'editorconfig'\neditorconfig.aliases = []\nfunction editorconfig(Prism) {\n  Prism.languages.editorconfig = {\n    // https://editorconfig-specification.readthedocs.io\n    comment: /[;#].*/,\n    section: {\n      pattern: /(^[ \\t]*)\\[.+\\]/m,\n      lookbehind: true,\n      alias: 'selector',\n      inside: {\n        regex: /\\\\\\\\[\\[\\]{},!?.*]/,\n        // Escape special characters with '\\\\'\n        operator: /[!?]|\\.\\.|\\*{1,2}/,\n        punctuation: /[\\[\\]{},]/\n      }\n    },\n    key: {\n      pattern: /(^[ \\t]*)[^\\s=]+(?=[ \\t]*=)/m,\n      lookbehind: true,\n      alias: 'attr-name'\n    },\n    value: {\n      pattern: /=.*/,\n      alias: 'attr-value',\n      inside: {\n        punctuation: /^=/\n      }\n    }\n  }\n}\n"],"names":["editorconfig","Prism","languages","comment","section","pattern","lookbehind","alias","inside","regex","operator","punctuation","key","value","editorconfig_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAaC,GACpBA,EAAMC,UAAUF,aAAe,CAE7BG,QAAS,SACTC,QAAS,CACPC,QAAS,mBACTC,YAAY,EACZC,MAAO,WACPC,OAAQ,CACNC,MAAO,oBAEPC,SAAU,oBACVC,YAAa,cAGjBC,IAAK,CACHP,QAAS,+BACTC,YAAY,EACZC,MAAO,aAETM,MAAO,CACLR,QAAS,MACTE,MAAO,aACPC,OAAQ,CACNG,YAAa,OAIrB,YA/BAG,EAAiBd,EACjBA,EAAae,YAAc,eAC3Bf,EAAagB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(r)return e;function n(e){e.languages.eiffel={comment:/--.*/,string:[{pattern:/"([^[]*)\[[\s\S]*?\]\1"/,greedy:!0},{pattern:/"([^{]*)\{[\s\S]*?\}\1"/,greedy:!0},{pattern:/"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/,greedy:!0}],char:/'(?:%.|[^%'\r\n])+'/,keyword:/\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,boolean:/\b(?:False|True)\b/i,"class-name":/\b[A-Z][\dA-Z_]*\b/,number:[/\b0[xcb][\da-f](?:_*[\da-f])*\b/i,/(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i],punctuation:/:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/,operator:/\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/}}return r=1,e=n,n.displayName="eiffel",n.aliases=[],e};
-//# sourceMappingURL=eiffel.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"eiffel.js","sources":["../../../../node_modules/refractor/lang/eiffel.js"],"sourcesContent":["'use strict'\n\nmodule.exports = eiffel\neiffel.displayName = 'eiffel'\neiffel.aliases = []\nfunction eiffel(Prism) {\n  Prism.languages.eiffel = {\n    comment: /--.*/,\n    string: [\n      // Aligned-verbatim-strings\n      {\n        pattern: /\"([^[]*)\\[[\\s\\S]*?\\]\\1\"/,\n        greedy: true\n      }, // Non-aligned-verbatim-strings\n      {\n        pattern: /\"([^{]*)\\{[\\s\\S]*?\\}\\1\"/,\n        greedy: true\n      }, // Single-line string\n      {\n        pattern: /\"(?:%(?:(?!\\n)\\s)*\\n\\s*%|%\\S|[^%\"\\r\\n])*\"/,\n        greedy: true\n      }\n    ],\n    // normal char | special char | char code\n    char: /'(?:%.|[^%'\\r\\n])+'/,\n    keyword:\n      /\\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\\b/i,\n    boolean: /\\b(?:False|True)\\b/i,\n    // Convention: class-names are always all upper-case characters\n    'class-name': /\\b[A-Z][\\dA-Z_]*\\b/,\n    number: [\n      // hexa | octal | bin\n      /\\b0[xcb][\\da-f](?:_*[\\da-f])*\\b/i, // Decimal\n      /(?:\\b\\d(?:_*\\d)*)?\\.(?:(?:\\d(?:_*\\d)*)?e[+-]?)?\\d(?:_*\\d)*\\b|\\b\\d(?:_*\\d)*\\b\\.?/i\n    ],\n    punctuation: /:=|<<|>>|\\(\\||\\|\\)|->|\\.(?=\\w)|[{}[\\];(),:?]/,\n    operator: /\\\\\\\\|\\|\\.\\.\\||\\.\\.|\\/[~\\/=]?|[><]=?|[-+*^=~]/\n  }\n}\n"],"names":["eiffel","Prism","languages","comment","string","pattern","greedy","char","keyword","boolean","number","punctuation","operator","eiffel_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAOC,GACdA,EAAMC,UAAUF,OAAS,CACvBG,QAAS,OACTC,OAAQ,CAEN,CACEC,QAAS,0BACTC,QAAQ,GAEV,CACED,QAAS,0BACTC,QAAQ,GAEV,CACED,QAAS,4CACTC,QAAQ,IAIZC,KAAM,sBACNC,QACE,+YACFC,QAAS,sBAET,aAAc,qBACdC,OAAQ,CAEN,mCACA,oFAEFC,YAAa,+CACbC,SAAU,+CAEd,YApCAC,EAAiBb,EACjBA,EAAOc,YAAc,SACrBd,EAAOe,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,a,t=require("./markup-templating.js");exports.__require=function(){if(a)return e;a=1;var n=t.__require();function s(e){e.register(n),function(e){e.languages.ejs={delimiter:{pattern:/^<%[-_=]?|[-_]?%>$/,alias:"punctuation"},comment:/^#[\s\S]*/,"language-javascript":{pattern:/[\s\S]+/,inside:e.languages.javascript}},e.hooks.add("before-tokenize",(function(a){e.languages["markup-templating"].buildPlaceholders(a,"ejs",/<%(?!%)[\s\S]+?%>/g)})),e.hooks.add("after-tokenize",(function(a){e.languages["markup-templating"].tokenizePlaceholders(a,"ejs")})),e.languages.eta=e.languages.ejs}(e)}return e=s,s.displayName="ejs",s.aliases=["eta"],e};
-//# sourceMappingURL=ejs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ejs.js","sources":["../../../../node_modules/refractor/lang/ejs.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = ejs\nejs.displayName = 'ejs'\nejs.aliases = ['eta']\nfunction ejs(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.ejs = {\n      delimiter: {\n        pattern: /^<%[-_=]?|[-_]?%>$/,\n        alias: 'punctuation'\n      },\n      comment: /^#[\\s\\S]*/,\n      'language-javascript': {\n        pattern: /[\\s\\S]+/,\n        inside: Prism.languages.javascript\n      }\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var ejsPattern = /<%(?!%)[\\s\\S]+?%>/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'ejs',\n        ejsPattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'ejs')\n    })\n    Prism.languages.eta = Prism.languages.ejs\n  })(Prism)\n}\n"],"names":["refractorMarkupTemplating","require$$0","ejs","Prism","register","languages","delimiter","pattern","alias","comment","inside","javascript","hooks","add","env","buildPlaceholders","tokenizePlaceholders","eta","ejs_1","displayName","aliases"],"mappings":"+JACA,IAAIA,EAA4BC,EAAAA,YAIhC,SAASC,EAAIC,GACXA,EAAMC,SAASJ,GACd,SAAWG,GACVA,EAAME,UAAUH,IAAM,CACpBI,UAAW,CACTC,QAAS,qBACTC,MAAO,eAETC,QAAS,YACT,sBAAuB,CACrBF,QAAS,UACTG,OAAQP,EAAME,UAAUM,aAG5BR,EAAMS,MAAMC,IAAI,mBAAmB,SAAUC,GAE3CX,EAAME,UAAU,qBAAqBU,kBACnCD,EACA,MAHe,qBAMvB,IACIX,EAAMS,MAAMC,IAAI,kBAAkB,SAAUC,GAC1CX,EAAME,UAAU,qBAAqBW,qBAAqBF,EAAK,MACrE,IACIX,EAAME,UAAUY,IAAMd,EAAME,UAAUH,GACvC,CAxBA,CAwBEC,EACL,QA9BAe,EAAiBhB,EACjBA,EAAIiB,YAAc,MAClBjB,EAAIkB,QAAU,CAAC"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(r)return e;function n(e){e.languages.elixir={doc:{pattern:/@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,inside:{attribute:/^@\w+/,string:/['"][\s\S]+/}},comment:{pattern:/#.*/,greedy:!0},regex:{pattern:/~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,greedy:!0},string:[{pattern:/~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,greedy:!0,inside:{}},{pattern:/("""|''')[\s\S]*?\1/,greedy:!0,inside:{}},{pattern:/("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,greedy:!0,inside:{}}],atom:{pattern:/(^|[^:]):\w+/,lookbehind:!0,alias:"symbol"},module:{pattern:/\b[A-Z]\w*\b/,alias:"class-name"},"attr-name":/\b\w+\??:(?!:)/,argument:{pattern:/(^|[^&])&\d+/,lookbehind:!0,alias:"variable"},attribute:{pattern:/@\w+/,alias:"variable"},function:/\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,number:/\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,keyword:/\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,boolean:/\b(?:false|nil|true)\b/,operator:[/\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,{pattern:/([^<])<(?!<)/,lookbehind:!0},{pattern:/([^>])>(?!>)/,lookbehind:!0}],punctuation:/<<|>>|[.,%\[\]{}()]/},e.languages.elixir.string.forEach((function(r){r.inside={interpolation:{pattern:/#\{[^}]+\}/,inside:{delimiter:{pattern:/^#\{|\}$/,alias:"punctuation"},rest:e.languages.elixir}}}}))}return r=1,e=n,n.displayName="elixir",n.aliases=[],e};
-//# sourceMappingURL=elixir.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"elixir.js","sources":["../../../../node_modules/refractor/lang/elixir.js"],"sourcesContent":["'use strict'\n\nmodule.exports = elixir\nelixir.displayName = 'elixir'\nelixir.aliases = []\nfunction elixir(Prism) {\n  Prism.languages.elixir = {\n    doc: {\n      pattern:\n        /@(?:doc|moduledoc)\\s+(?:(\"\"\"|''')[\\s\\S]*?\\1|(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\2)[^\\\\\\r\\n])*\\2)/,\n      inside: {\n        attribute: /^@\\w+/,\n        string: /['\"][\\s\\S]+/\n      }\n    },\n    comment: {\n      pattern: /#.*/,\n      greedy: true\n    },\n    // ~r\"\"\"foo\"\"\" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r\"foo\", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>\n    regex: {\n      pattern:\n        /~[rR](?:(\"\"\"|''')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])+\\1|([\\/|\"'])(?:\\\\.|(?!\\2)[^\\\\\\r\\n])+\\2|\\((?:\\\\.|[^\\\\)\\r\\n])+\\)|\\[(?:\\\\.|[^\\\\\\]\\r\\n])+\\]|\\{(?:\\\\.|[^\\\\}\\r\\n])+\\}|<(?:\\\\.|[^\\\\>\\r\\n])+>)[uismxfr]*/,\n      greedy: true\n    },\n    string: [\n      {\n        // ~s\"\"\"foo\"\"\" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s\"foo\", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>\n        pattern:\n          /~[cCsSwW](?:(\"\"\"|''')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])+\\1|([\\/|\"'])(?:\\\\.|(?!\\2)[^\\\\\\r\\n])+\\2|\\((?:\\\\.|[^\\\\)\\r\\n])+\\)|\\[(?:\\\\.|[^\\\\\\]\\r\\n])+\\]|\\{(?:\\\\.|#\\{[^}]+\\}|#(?!\\{)|[^#\\\\}\\r\\n])+\\}|<(?:\\\\.|[^\\\\>\\r\\n])+>)[csa]?/,\n        greedy: true,\n        inside: {\n          // See interpolation below\n        }\n      },\n      {\n        pattern: /(\"\"\"|''')[\\s\\S]*?\\1/,\n        greedy: true,\n        inside: {\n          // See interpolation below\n        }\n      },\n      {\n        // Multi-line strings are allowed\n        pattern: /(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n        greedy: true,\n        inside: {\n          // See interpolation below\n        }\n      }\n    ],\n    atom: {\n      // Look-behind prevents bad highlighting of the :: operator\n      pattern: /(^|[^:]):\\w+/,\n      lookbehind: true,\n      alias: 'symbol'\n    },\n    module: {\n      pattern: /\\b[A-Z]\\w*\\b/,\n      alias: 'class-name'\n    },\n    // Look-ahead prevents bad highlighting of the :: operator\n    'attr-name': /\\b\\w+\\??:(?!:)/,\n    argument: {\n      // Look-behind prevents bad highlighting of the && operator\n      pattern: /(^|[^&])&\\d+/,\n      lookbehind: true,\n      alias: 'variable'\n    },\n    attribute: {\n      pattern: /@\\w+/,\n      alias: 'variable'\n    },\n    function: /\\b[_a-zA-Z]\\w*[?!]?(?:(?=\\s*(?:\\.\\s*)?\\()|(?=\\/\\d))/,\n    number: /\\b(?:0[box][a-f\\d_]+|\\d[\\d_]*)(?:\\.[\\d_]+)?(?:e[+-]?[\\d_]+)?\\b/i,\n    keyword:\n      /\\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\\b/,\n    boolean: /\\b(?:false|nil|true)\\b/,\n    operator: [\n      /\\bin\\b|&&?|\\|[|>]?|\\\\\\\\|::|\\.\\.\\.?|\\+\\+?|-[->]?|<[-=>]|>=|!==?|\\B!|=(?:==?|[>~])?|[*\\/^]/,\n      {\n        // We don't want to match <<\n        pattern: /([^<])<(?!<)/,\n        lookbehind: true\n      },\n      {\n        // We don't want to match >>\n        pattern: /([^>])>(?!>)/,\n        lookbehind: true\n      }\n    ],\n    punctuation: /<<|>>|[.,%\\[\\]{}()]/\n  }\n  Prism.languages.elixir.string.forEach(function (o) {\n    o.inside = {\n      interpolation: {\n        pattern: /#\\{[^}]+\\}/,\n        inside: {\n          delimiter: {\n            pattern: /^#\\{|\\}$/,\n            alias: 'punctuation'\n          },\n          rest: Prism.languages.elixir\n        }\n      }\n    }\n  })\n}\n"],"names":["elixir","Prism","languages","doc","pattern","inside","attribute","string","comment","greedy","regex","atom","lookbehind","alias","module","argument","function","number","keyword","boolean","operator","punctuation","forEach","o","interpolation","delimiter","rest","elixir_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAOC,GACdA,EAAMC,UAAUF,OAAS,CACvBG,IAAK,CACHC,QACE,6FACFC,OAAQ,CACNC,UAAW,QACXC,OAAQ,gBAGZC,QAAS,CACPJ,QAAS,MACTK,QAAQ,GAGVC,MAAO,CACLN,QACE,6LACFK,QAAQ,GAEVF,OAAQ,CACN,CAEEH,QACE,iNACFK,QAAQ,EACRJ,OAAQ,CAEP,GAEH,CACED,QAAS,sBACTK,QAAQ,EACRJ,OAAQ,CAEP,GAEH,CAEED,QAAS,gDACTK,QAAQ,EACRJ,OAAQ,CAEP,IAGLM,KAAM,CAEJP,QAAS,eACTQ,YAAY,EACZC,MAAO,UAETC,OAAQ,CACNV,QAAS,eACTS,MAAO,cAGT,YAAa,iBACbE,SAAU,CAERX,QAAS,eACTQ,YAAY,EACZC,MAAO,YAETP,UAAW,CACTF,QAAS,OACTS,MAAO,YAETG,SAAU,sDACVC,OAAQ,kEACRC,QACE,kNACFC,QAAS,yBACTC,SAAU,CACR,2FACA,CAEEhB,QAAS,eACTQ,YAAY,GAEd,CAEER,QAAS,eACTQ,YAAY,IAGhBS,YAAa,uBAEfpB,EAAMC,UAAUF,OAAOO,OAAOe,SAAQ,SAAUC,GAC9CA,EAAElB,OAAS,CACTmB,cAAe,CACbpB,QAAS,aACTC,OAAQ,CACNoB,UAAW,CACTrB,QAAS,WACTS,MAAO,eAETa,KAAMzB,EAAMC,UAAUF,SAIhC,GACA,YAzGA2B,EAAiB3B,EACjBA,EAAO4B,YAAc,SACrB5B,EAAO6B,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,t;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(t)return e;function r(e){e.languages.elm={comment:/--.*|\{-[\s\S]*?-\}/,char:{pattern:/'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,greedy:!0},string:[{pattern:/"""[\s\S]*?"""/,greedy:!0},{pattern:/"(?:[^\\"\r\n]|\\.)*"/,greedy:!0}],"import-statement":{pattern:/(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,lookbehind:!0,inside:{keyword:/\b(?:as|exposing|import)\b/}},keyword:/\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,builtin:/\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,number:/\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,operator:/\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,hvariable:/\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,constant:/\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,punctuation:/[{}[\]|(),.:]/}}return t=1,e=r,r.displayName="elm",r.aliases=[],e};
-//# sourceMappingURL=elm.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"elm.js","sources":["../../../../node_modules/refractor/lang/elm.js"],"sourcesContent":["'use strict'\n\nmodule.exports = elm\nelm.displayName = 'elm'\nelm.aliases = []\nfunction elm(Prism) {\n  Prism.languages.elm = {\n    comment: /--.*|\\{-[\\s\\S]*?-\\}/,\n    char: {\n      pattern:\n        /'(?:[^\\\\'\\r\\n]|\\\\(?:[abfnrtv\\\\']|\\d+|x[0-9a-fA-F]+|u\\{[0-9a-fA-F]+\\}))'/,\n      greedy: true\n    },\n    string: [\n      {\n        // Multiline strings are wrapped in triple \". Quotes may appear unescaped.\n        pattern: /\"\"\"[\\s\\S]*?\"\"\"/,\n        greedy: true\n      },\n      {\n        pattern: /\"(?:[^\\\\\"\\r\\n]|\\\\.)*\"/,\n        greedy: true\n      }\n    ],\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+[A-Z]\\w*(?:\\.[A-Z]\\w*)*(?:\\s+as\\s+(?:[A-Z]\\w*)(?:\\.[A-Z]\\w*)*)?(?:\\s+exposing\\s+)?/m,\n      lookbehind: true,\n      inside: {\n        keyword: /\\b(?:as|exposing|import)\\b/\n      }\n    },\n    keyword:\n      /\\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\\b/,\n    // These are builtin variables only. Constructors are highlighted later as a constant.\n    builtin:\n      /\\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\\b/,\n    // decimal integers and floating point numbers | hexadecimal integers\n    number: /\\b(?:\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?|0x[0-9a-f]+)\\b/i,\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    // Valid operator characters in 0.18: +-/*=.$<>:&|^?%#@~!\n    // Ref: https://groups.google.com/forum/#!msg/elm-dev/0AHSnDdkSkQ/E0SVU70JEQAJ\n    operator: /\\s\\.\\s|[+\\-/*=.$<>:&|^?%#@~!]{2,}|[+\\-/*=$<>:&|^?%#@~!]/,\n    // In Elm, nearly everything is a variable, do not highlight these.\n    hvariable: /\\b(?:[A-Z]\\w*\\.)*[a-z]\\w*\\b/,\n    constant: /\\b(?:[A-Z]\\w*\\.)*[A-Z]\\w*\\b/,\n    punctuation: /[{}[\\]|(),.:]/\n  }\n}\n"],"names":["elm","Prism","languages","comment","char","pattern","greedy","string","lookbehind","inside","keyword","builtin","number","operator","hvariable","constant","punctuation","elm_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAIC,GACXA,EAAMC,UAAUF,IAAM,CACpBG,QAAS,sBACTC,KAAM,CACJC,QACE,0EACFC,QAAQ,GAEVC,OAAQ,CACN,CAEEF,QAAS,iBACTC,QAAQ,GAEV,CACED,QAAS,wBACTC,QAAQ,IAGZ,mBAAoB,CAIlBD,QACE,wGACFG,YAAY,EACZC,OAAQ,CACNC,QAAS,+BAGbA,QACE,kFAEFC,QACE,0PAEFC,OAAQ,mDAQRC,SAAU,0DAEVC,UAAW,8BACXC,SAAU,8BACVC,YAAa,gBAEjB,YArDAC,EAAiBjB,EACjBA,EAAIkB,YAAc,MAClBlB,EAAImB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,r,n=require("./ruby.js"),a=require("./markup-templating.js");exports.__require=function(){if(r)return e;r=1;var i=n.__require(),t=a.__require();function u(e){e.register(i),e.register(t),function(e){e.languages.erb={delimiter:{pattern:/^(\s*)<%=?|%>(?=\s*$)/,lookbehind:!0,alias:"punctuation"},ruby:{pattern:/\s*\S[\s\S]*/,alias:"language-ruby",inside:e.languages.ruby}},e.hooks.add("before-tokenize",(function(r){e.languages["markup-templating"].buildPlaceholders(r,"erb",/<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g)})),e.hooks.add("after-tokenize",(function(r){e.languages["markup-templating"].tokenizePlaceholders(r,"erb")}))}(e)}return e=u,u.displayName="erb",u.aliases=[],e};
-//# sourceMappingURL=erb.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"erb.js","sources":["../../../../node_modules/refractor/lang/erb.js"],"sourcesContent":["'use strict'\nvar refractorRuby = require('./ruby.js')\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = erb\nerb.displayName = 'erb'\nerb.aliases = []\nfunction erb(Prism) {\n  Prism.register(refractorRuby)\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.erb = {\n      delimiter: {\n        pattern: /^(\\s*)<%=?|%>(?=\\s*$)/,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      ruby: {\n        pattern: /\\s*\\S[\\s\\S]*/,\n        alias: 'language-ruby',\n        inside: Prism.languages.ruby\n      }\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var erbPattern =\n        /<%=?(?:[^\\r\\n]|[\\r\\n](?!=begin)|[\\r\\n]=begin\\s(?:[^\\r\\n]|[\\r\\n](?!=end))*[\\r\\n]=end)+?%>/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'erb',\n        erbPattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'erb')\n    })\n  })(Prism)\n}\n"],"names":["refractorRuby","require$$0","refractorMarkupTemplating","require$$1","erb","Prism","register","languages","delimiter","pattern","lookbehind","alias","ruby","inside","hooks","add","env","buildPlaceholders","tokenizePlaceholders","erb_1","displayName","aliases"],"mappings":"sLACA,IAAIA,EAAgBC,EAAAA,YAChBC,EAA4BC,EAAAA,YAIhC,SAASC,EAAIC,GACXA,EAAMC,SAASN,GACfK,EAAMC,SAASJ,GACd,SAAWG,GACVA,EAAME,UAAUH,IAAM,CACpBI,UAAW,CACTC,QAAS,wBACTC,YAAY,EACZC,MAAO,eAETC,KAAM,CACJH,QAAS,eACTE,MAAO,gBACPE,OAAQR,EAAME,UAAUK,OAG5BP,EAAMS,MAAMC,IAAI,mBAAmB,SAAUC,GAG3CX,EAAME,UAAU,qBAAqBU,kBACnCD,EACA,MAHA,4FAMR,IACIX,EAAMS,MAAMC,IAAI,kBAAkB,SAAUC,GAC1CX,EAAME,UAAU,qBAAqBW,qBAAqBF,EAAK,MACrE,GACG,CAzBA,CAyBEX,EACL,QAhCAc,EAAiBf,EACjBA,EAAIgB,YAAc,MAClBhB,EAAIiB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,n;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(n)return e;function r(e){e.languages.erlang={comment:/%.+/,string:{pattern:/"(?:\\.|[^\\"\r\n])*"/,greedy:!0},"quoted-function":{pattern:/'(?:\\.|[^\\'\r\n])+'(?=\()/,alias:"function"},"quoted-atom":{pattern:/'(?:\\.|[^\\'\r\n])+'/,alias:"atom"},boolean:/\b(?:false|true)\b/,keyword:/\b(?:after|case|catch|end|fun|if|of|receive|try|when)\b/,number:[/\$\\?./,/\b\d+#[a-z0-9]+/i,/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i],function:/\b[a-z][\w@]*(?=\()/,variable:{pattern:/(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,lookbehind:!0},operator:[/[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,{pattern:/(^|[^<])<(?!<)/,lookbehind:!0},{pattern:/(^|[^>])>(?!>)/,lookbehind:!0}],atom:/\b[a-z][\w@]*/,punctuation:/[()[\]{}:;,.#|]|<<|>>/}}return n=1,e=r,r.displayName="erlang",r.aliases=[],e};
-//# sourceMappingURL=erlang.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"erlang.js","sources":["../../../../node_modules/refractor/lang/erlang.js"],"sourcesContent":["'use strict'\n\nmodule.exports = erlang\nerlang.displayName = 'erlang'\nerlang.aliases = []\nfunction erlang(Prism) {\n  Prism.languages.erlang = {\n    comment: /%.+/,\n    string: {\n      pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n      greedy: true\n    },\n    'quoted-function': {\n      pattern: /'(?:\\\\.|[^\\\\'\\r\\n])+'(?=\\()/,\n      alias: 'function'\n    },\n    'quoted-atom': {\n      pattern: /'(?:\\\\.|[^\\\\'\\r\\n])+'/,\n      alias: 'atom'\n    },\n    boolean: /\\b(?:false|true)\\b/,\n    keyword: /\\b(?:after|case|catch|end|fun|if|of|receive|try|when)\\b/,\n    number: [\n      /\\$\\\\?./,\n      /\\b\\d+#[a-z0-9]+/i,\n      /(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i\n    ],\n    function: /\\b[a-z][\\w@]*(?=\\()/,\n    variable: {\n      // Look-behind is used to prevent wrong highlighting of atoms containing \"@\"\n      pattern: /(^|[^@])(?:\\b|\\?)[A-Z_][\\w@]*/,\n      lookbehind: true\n    },\n    operator: [\n      /[=\\/<>:]=|=[:\\/]=|\\+\\+?|--?|[=*\\/!]|\\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\\b/,\n      {\n        // We don't want to match <<\n        pattern: /(^|[^<])<(?!<)/,\n        lookbehind: true\n      },\n      {\n        // We don't want to match >>\n        pattern: /(^|[^>])>(?!>)/,\n        lookbehind: true\n      }\n    ],\n    atom: /\\b[a-z][\\w@]*/,\n    punctuation: /[()[\\]{}:;,.#|]|<<|>>/\n  }\n}\n"],"names":["erlang","Prism","languages","comment","string","pattern","greedy","alias","boolean","keyword","number","function","variable","lookbehind","operator","atom","punctuation","erlang_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAOC,GACdA,EAAMC,UAAUF,OAAS,CACvBG,QAAS,MACTC,OAAQ,CACNC,QAAS,wBACTC,QAAQ,GAEV,kBAAmB,CACjBD,QAAS,8BACTE,MAAO,YAET,cAAe,CACbF,QAAS,wBACTE,MAAO,QAETC,QAAS,qBACTC,QAAS,0DACTC,OAAQ,CACN,SACA,mBACA,8CAEFC,SAAU,sBACVC,SAAU,CAERP,QAAS,gCACTQ,YAAY,GAEdC,SAAU,CACR,+GACA,CAEET,QAAS,iBACTQ,YAAY,GAEd,CAEER,QAAS,iBACTQ,YAAY,IAGhBE,KAAM,gBACNC,YAAa,wBAEjB,YA/CAC,EAAiBjB,EACjBA,EAAOkB,YAAc,SACrBlB,EAAOmB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,a,t=require("./lua.js"),r=require("./markup-templating.js");exports.__require=function(){if(a)return e;a=1;var u=t.__require(),i=r.__require();function n(e){e.register(u),e.register(i),function(e){e.languages.etlua={delimiter:{pattern:/^<%[-=]?|-?%>$/,alias:"punctuation"},"language-lua":{pattern:/[\s\S]+/,inside:e.languages.lua}},e.hooks.add("before-tokenize",(function(a){e.languages["markup-templating"].buildPlaceholders(a,"etlua",/<%[\s\S]+?%>/g)})),e.hooks.add("after-tokenize",(function(a){e.languages["markup-templating"].tokenizePlaceholders(a,"etlua")}))}(e)}return e=n,n.displayName="etlua",n.aliases=[],e};
-//# sourceMappingURL=etlua.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"etlua.js","sources":["../../../../node_modules/refractor/lang/etlua.js"],"sourcesContent":["'use strict'\nvar refractorLua = require('./lua.js')\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = etlua\netlua.displayName = 'etlua'\netlua.aliases = []\nfunction etlua(Prism) {\n  Prism.register(refractorLua)\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.etlua = {\n      delimiter: {\n        pattern: /^<%[-=]?|-?%>$/,\n        alias: 'punctuation'\n      },\n      'language-lua': {\n        pattern: /[\\s\\S]+/,\n        inside: Prism.languages.lua\n      }\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var pattern = /<%[\\s\\S]+?%>/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'etlua',\n        pattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'etlua')\n    })\n  })(Prism)\n}\n"],"names":["refractorLua","require$$0","refractorMarkupTemplating","require$$1","etlua","Prism","register","languages","delimiter","pattern","alias","inside","lua","hooks","add","env","buildPlaceholders","tokenizePlaceholders","etlua_1","displayName","aliases"],"mappings":"qLACA,IAAIA,EAAeC,EAAAA,YACfC,EAA4BC,EAAAA,YAIhC,SAASC,EAAMC,GACbA,EAAMC,SAASN,GACfK,EAAMC,SAASJ,GACd,SAAWG,GACVA,EAAME,UAAUH,MAAQ,CACtBI,UAAW,CACTC,QAAS,iBACTC,MAAO,eAET,eAAgB,CACdD,QAAS,UACTE,OAAQN,EAAME,UAAUK,MAG5BP,EAAMQ,MAAMC,IAAI,mBAAmB,SAAUC,GAE3CV,EAAME,UAAU,qBAAqBS,kBACnCD,EACA,QAHY,gBAMpB,IACIV,EAAMQ,MAAMC,IAAI,kBAAkB,SAAUC,GAC1CV,EAAME,UAAU,qBAAqBU,qBAAqBF,EAAK,QACrE,GACG,CAtBA,CAsBEV,EACL,QA7BAa,EAAiBd,EACjBA,EAAMe,YAAc,QACpBf,EAAMgB,QAAU"}

package/dist/node_modules/refractor/lang/excel-formula.js

@@ -1,2 +0,0 @@
-"use strict";var e,a;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(a)return e;function r(e){e.languages["excel-formula"]={comment:{pattern:/(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i,lookbehind:!0,greedy:!0},string:{pattern:/"(?:[^"]|"")*"(?!")/,greedy:!0},reference:{pattern:/(?:'[^']*'|(?:[^\s()[\]{}<>*?"';,$&]*\[[^^\s()[\]{}<>*?"']+\])?\w+)!/,greedy:!0,alias:"string",inside:{operator:/!$/,punctuation:/'/,sheet:{pattern:/[^[\]]+$/,alias:"function"},file:{pattern:/\[[^[\]]+\]$/,inside:{punctuation:/[[\]]/}},path:/[\s\S]+/}},"function-name":{pattern:/\b[A-Z]\w*(?=\()/i,alias:"keyword"},range:{pattern:/\$?\b(?:[A-Z]+\$?\d+:\$?[A-Z]+\$?\d+|[A-Z]+:\$?[A-Z]+|\d+:\$?\d+)\b/i,alias:"property",inside:{operator:/:/,cell:/\$?[A-Z]+\$?\d+/i,column:/\$?[A-Z]+/i,row:/\$?\d+/}},cell:{pattern:/\b[A-Z]+\d+\b|\$[A-Za-z]+\$?\d+\b|\b[A-Za-z]+\$\d+\b/,alias:"property"},number:/(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?\b/i,boolean:/\b(?:FALSE|TRUE)\b/i,operator:/[-+*/^%=&,]|<[=>]?|>=?/,punctuation:/[[\]();{}|]/},e.languages.xlsx=e.languages.xls=e.languages["excel-formula"]}return a=1,e=r,r.displayName="excelFormula",r.aliases=[],e};
-//# sourceMappingURL=excel-formula.js.map

package/dist/node_modules/refractor/lang/excel-formula.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"excel-formula.js","sources":["../../../../node_modules/refractor/lang/excel-formula.js"],"sourcesContent":["'use strict'\n\nmodule.exports = excelFormula\nexcelFormula.displayName = 'excelFormula'\nexcelFormula.aliases = []\nfunction excelFormula(Prism) {\n  Prism.languages['excel-formula'] = {\n    comment: {\n      pattern: /(\\bN\\(\\s*)\"(?:[^\"]|\"\")*\"(?=\\s*\\))/i,\n      lookbehind: true,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:[^\"]|\"\")*\"(?!\")/,\n      greedy: true\n    },\n    reference: {\n      // https://www.ablebits.com/office-addins-blog/2015/12/08/excel-reference-another-sheet-workbook/\n      // Sales!B2\n      // 'Winter sales'!B2\n      // [Sales.xlsx]Jan!B2:B5\n      // D:\\Reports\\[Sales.xlsx]Jan!B2:B5\n      // '[Sales.xlsx]Jan sales'!B2:B5\n      // 'D:\\Reports\\[Sales.xlsx]Jan sales'!B2:B5\n      pattern:\n        /(?:'[^']*'|(?:[^\\s()[\\]{}<>*?\"';,$&]*\\[[^^\\s()[\\]{}<>*?\"']+\\])?\\w+)!/,\n      greedy: true,\n      alias: 'string',\n      inside: {\n        operator: /!$/,\n        punctuation: /'/,\n        sheet: {\n          pattern: /[^[\\]]+$/,\n          alias: 'function'\n        },\n        file: {\n          pattern: /\\[[^[\\]]+\\]$/,\n          inside: {\n            punctuation: /[[\\]]/\n          }\n        },\n        path: /[\\s\\S]+/\n      }\n    },\n    'function-name': {\n      pattern: /\\b[A-Z]\\w*(?=\\()/i,\n      alias: 'keyword'\n    },\n    range: {\n      pattern:\n        /\\$?\\b(?:[A-Z]+\\$?\\d+:\\$?[A-Z]+\\$?\\d+|[A-Z]+:\\$?[A-Z]+|\\d+:\\$?\\d+)\\b/i,\n      alias: 'property',\n      inside: {\n        operator: /:/,\n        cell: /\\$?[A-Z]+\\$?\\d+/i,\n        column: /\\$?[A-Z]+/i,\n        row: /\\$?\\d+/\n      }\n    },\n    cell: {\n      // Excel is case insensitive, so the string \"foo1\" could be either a variable or a cell.\n      // To combat this, we match cells case insensitive, if the contain at least one \"$\", and case sensitive otherwise.\n      pattern: /\\b[A-Z]+\\d+\\b|\\$[A-Za-z]+\\$?\\d+\\b|\\b[A-Za-z]+\\$\\d+\\b/,\n      alias: 'property'\n    },\n    number: /(?:\\b\\d+(?:\\.\\d+)?|\\B\\.\\d+)(?:e[+-]?\\d+)?\\b/i,\n    boolean: /\\b(?:FALSE|TRUE)\\b/i,\n    operator: /[-+*/^%=&,]|<[=>]?|>=?/,\n    punctuation: /[[\\]();{}|]/\n  }\n  Prism.languages['xlsx'] = Prism.languages['xls'] =\n    Prism.languages['excel-formula']\n}\n"],"names":["excelFormula","Prism","languages","comment","pattern","lookbehind","greedy","string","reference","alias","inside","operator","punctuation","sheet","file","path","range","cell","column","row","number","boolean","excelFormula_1","displayName","aliases"],"mappings":"uHAKA,SAASA,EAAaC,GACpBA,EAAMC,UAAU,iBAAmB,CACjCC,QAAS,CACPC,QAAS,qCACTC,YAAY,EACZC,QAAQ,GAEVC,OAAQ,CACNH,QAAS,sBACTE,QAAQ,GAEVE,UAAW,CAQTJ,QACE,uEACFE,QAAQ,EACRG,MAAO,SACPC,OAAQ,CACNC,SAAU,KACVC,YAAa,IACbC,MAAO,CACLT,QAAS,WACTK,MAAO,YAETK,KAAM,CACJV,QAAS,eACTM,OAAQ,CACNE,YAAa,UAGjBG,KAAM,YAGV,gBAAiB,CACfX,QAAS,oBACTK,MAAO,WAETO,MAAO,CACLZ,QACE,uEACFK,MAAO,WACPC,OAAQ,CACNC,SAAU,IACVM,KAAM,mBACNC,OAAQ,aACRC,IAAK,WAGTF,KAAM,CAGJb,QAAS,uDACTK,MAAO,YAETW,OAAQ,+CACRC,QAAS,sBACTV,SAAU,yBACVC,YAAa,eAEfX,EAAMC,UAAgB,KAAID,EAAMC,UAAe,IAC7CD,EAAMC,UAAU,gBACpB,YAtEAoB,EAAiBtB,EACjBA,EAAauB,YAAc,eAC3BvB,EAAawB,QAAU"}

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

@@ -1,2 +0,0 @@
-"use strict";var e,t;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(t)return e;function s(e){!function(e){var t={function:/\b(?:BUGS?|FIX(?:MES?)?|NOTES?|TODOS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/},s={number:/\\[^\s']|%\w/},i={comment:[{pattern:/(^|\s)(?:! .*|!$)/,lookbehind:!0,inside:t},{pattern:/(^|\s)\/\*\s[\s\S]*?\*\/(?=\s|$)/,lookbehind:!0,greedy:!0,inside:t},{pattern:/(^|\s)!\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,lookbehind:!0,greedy:!0,inside:t}],number:[{pattern:/(^|\s)[+-]?\d+(?=\s|$)/,lookbehind:!0},{pattern:/(^|\s)[+-]?0(?:b[01]+|o[0-7]+|d\d+|x[\dA-F]+)(?=\s|$)/i,lookbehind:!0},{pattern:/(^|\s)[+-]?\d+\/\d+\.?(?=\s|$)/,lookbehind:!0},{pattern:/(^|\s)\+?\d+\+\d+\/\d+(?=\s|$)/,lookbehind:!0},{pattern:/(^|\s)-\d+-\d+\/\d+(?=\s|$)/,lookbehind:!0},{pattern:/(^|\s)[+-]?(?:\d*\.\d+|\d+\.\d*|\d+)(?:e[+-]?\d+)?(?=\s|$)/i,lookbehind:!0},{pattern:/(^|\s)NAN:\s+[\da-fA-F]+(?=\s|$)/,lookbehind:!0},{pattern:/(^|\s)[+-]?0(?:b1\.[01]*|o1\.[0-7]*|d1\.\d*|x1\.[\dA-F]*)p\d+(?=\s|$)/i,lookbehind:!0}],regexp:{pattern:/(^|\s)R\/\s(?:\\\S|[^\\/])*\/(?:[idmsr]*|[idmsr]+-[idmsr]+)(?=\s|$)/,lookbehind:!0,alias:"number",inside:{variable:/\\\S/,keyword:/[+?*\[\]^$(){}.|]/,operator:{pattern:/(\/)[idmsr]+(?:-[idmsr]+)?/,lookbehind:!0}}},boolean:{pattern:/(^|\s)[tf](?=\s|$)/,lookbehind:!0},"custom-string":{pattern:/(^|\s)[A-Z0-9\-]+"\s(?:\\\S|[^"\\])*"/,lookbehind:!0,greedy:!0,alias:"string",inside:{number:/\\\S|%\w|\//}},"multiline-string":[{pattern:/(^|\s)STRING:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*;(?=\s|$)/,lookbehind:!0,greedy:!0,alias:"string",inside:{number:s.number,"semicolon-or-setlocal":{pattern:/([\r\n][ \t]*);(?=\s|$)/,lookbehind:!0,alias:"function"}}},{pattern:/(^|\s)HEREDOC:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*\S+(?=\s|$)/,lookbehind:!0,greedy:!0,alias:"string",inside:s},{pattern:/(^|\s)\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,lookbehind:!0,greedy:!0,alias:"string",inside:s}],"special-using":{pattern:/(^|\s)USING:(?:\s\S+)*(?=\s+;(?:\s|$))/,lookbehind:!0,alias:"function",inside:{string:{pattern:/(\s)[^:\s]+/,lookbehind:!0}}},"stack-effect-delimiter":[{pattern:/(^|\s)(?:call|eval|execute)?\((?=\s)/,lookbehind:!0,alias:"operator"},{pattern:/(\s)--(?=\s)/,lookbehind:!0,alias:"operator"},{pattern:/(\s)\)(?=\s|$)/,lookbehind:!0,alias:"operator"}],combinators:{pattern:null,lookbehind:!0,alias:"keyword"},"kernel-builtin":{pattern:null,lookbehind:!0,alias:"variable"},"sequences-builtin":{pattern:null,lookbehind:!0,alias:"variable"},"math-builtin":{pattern:null,lookbehind:!0,alias:"variable"},"constructor-word":{pattern:/(^|\s)<(?!=+>|-+>)\S+>(?=\s|$)/,lookbehind:!0,alias:"keyword"},"other-builtin-syntax":{pattern:null,lookbehind:!0,alias:"operator"},"conventionally-named-word":{pattern:/(^|\s)(?!")(?:(?:change|new|set|with)-\S+|\$\S+|>[^>\s]+|[^:>\s]+>|[^>\s]+>[^>\s]+|\+[^+\s]+\+|[^?\s]+\?|\?[^?\s]+|[^>\s]+>>|>>[^>\s]+|[^<\s]+<<|\([^()\s]+\)|[^!\s]+!|[^*\s]\S*\*|[^.\s]\S*\.)(?=\s|$)/,lookbehind:!0,alias:"keyword"},"colon-syntax":{pattern:/(^|\s)(?:[A-Z0-9\-]+#?)?:{1,2}\s+(?:;\S+|(?!;)\S+)(?=\s|$)/,lookbehind:!0,greedy:!0,alias:"function"},"semicolon-or-setlocal":{pattern:/(\s)(?:;|:>)(?=\s|$)/,lookbehind:!0,alias:"function"},"curly-brace-literal-delimiter":[{pattern:/(^|\s)[a-z]*\{(?=\s)/i,lookbehind:!0,alias:"operator"},{pattern:/(\s)\}(?=\s|$)/,lookbehind:!0,alias:"operator"}],"quotation-delimiter":[{pattern:/(^|\s)\[(?=\s)/,lookbehind:!0,alias:"operator"},{pattern:/(\s)\](?=\s|$)/,lookbehind:!0,alias:"operator"}],"normal-word":{pattern:/(^|\s)[^"\s]\S*(?=\s|$)/,lookbehind:!0},string:{pattern:/"(?:\\\S|[^"\\])*"/,greedy:!0,inside:s}},n=function(e){return(e+"").replace(/([.?*+\^$\[\]\\(){}|\-])/g,"\\$1")},r=function(e){return new RegExp("(^|\\s)(?:"+e.map(n).join("|")+")(?=\\s|$)")},a={"kernel-builtin":["or","2nipd","4drop","tuck","wrapper","nip","wrapper?","callstack>array","die","dupd","callstack","callstack?","3dup","hashcode","pick","4nip","build",">boolean","nipd","clone","5nip","eq?","?","=","swapd","2over","clear","2dup","get-retainstack","not","tuple?","dup","3nipd","call","-rotd","object","drop","assert=","assert?","-rot","execute","boa","get-callstack","curried?","3drop","pickd","overd","over","roll","3nip","swap","and","2nip","rotd","throw","(clone)","hashcode*","spin","reach","4dup","equal?","get-datastack","assert","2drop","<wrapper>","boolean?","identity-hashcode","identity-tuple?","null","composed?","new","5drop","rot","-roll","xor","identity-tuple","boolean"],"other-builtin-syntax":["=======","recursive","flushable",">>","<<<<<<","M\\","B","PRIVATE>","\\","======","final","inline","delimiter","deprecated","<PRIVATE",">>>>>>","<<<<<<<","parse-complex","malformed-complex","read-only",">>>>>>>","call-next-method","<<","foldable","$","$[","${"],"sequences-builtin":["member-eq?","mismatch","append","assert-sequence=","longer","repetition","clone-like","3sequence","assert-sequence?","last-index-from","reversed","index-from","cut*","pad-tail","join-as","remove-eq!","concat-as","but-last","snip","nths","nth","sequence","longest","slice?","<slice>","remove-nth","tail-slice","empty?","tail*","member?","virtual-sequence?","set-length","drop-prefix","iota","unclip","bounds-error?","unclip-last-slice","non-negative-integer-expected","non-negative-integer-expected?","midpoint@","longer?","?set-nth","?first","rest-slice","prepend-as","prepend","fourth","sift","subseq-start","new-sequence","?last","like","first4","1sequence","reverse","slice","virtual@","repetition?","set-last","index","4sequence","max-length","set-second","immutable-sequence","first2","first3","supremum","unclip-slice","suffix!","insert-nth","tail","3append","short","suffix","concat","flip","immutable?","reverse!","2sequence","sum","delete-all","indices","snip-slice","<iota>","check-slice","sequence?","head","append-as","halves","sequence=","collapse-slice","?second","slice-error?","product","bounds-check?","bounds-check","immutable","virtual-exemplar","harvest","remove","pad-head","last","set-fourth","cartesian-product","remove-eq","shorten","shorter","reversed?","shorter?","shortest","head-slice","pop*","tail-slice*","but-last-slice","iota?","append!","cut-slice","new-resizable","head-slice*","sequence-hashcode","pop","set-nth","?nth","second","join","immutable-sequence?","<reversed>","3append-as","virtual-sequence","subseq?","remove-nth!","length","last-index","lengthen","assert-sequence","copy","move","third","first","tail?","set-first","prefix","bounds-error","<repetition>","exchange","surround","cut","min-length","set-third","push-all","head?","subseq-start-from","delete-slice","rest","sum-lengths","head*","infimum","remove!","glue","slice-error","subseq","push","replace-slice","subseq-as","unclip-last"],"math-builtin":["number=","next-power-of-2","?1+","fp-special?","imaginary-part","float>bits","number?","fp-infinity?","bignum?","fp-snan?","denominator","gcd","*","+","fp-bitwise=","-","u>=","/",">=","bitand","power-of-2?","log2-expects-positive","neg?","<","log2",">","integer?","number","bits>double","2/","zero?","bits>float","float?","shift","ratio?","rect>","even?","ratio","fp-sign","bitnot",">fixnum","complex?","/i","integer>fixnum","/f","sgn",">bignum","next-float","u<","u>","mod","recip","rational",">float","2^","integer","fixnum?","neg","fixnum","sq","bignum",">rect","bit?","fp-qnan?","simple-gcd","complex","<fp-nan>","real",">fraction","double>bits","bitor","rem","fp-nan-payload","real-part","log2-expects-positive?","prev-float","align","unordered?","float","fp-nan?","abs","bitxor","integer>fixnum-strict","u<=","odd?","<=","/mod",">integer","real?","rational?","numerator"]};Object.keys(a).forEach((function(e){i[e].pattern=r(a[e])}));i.combinators.pattern=r(["2bi","while","2tri","bi*","4dip","both?","same?","tri@","curry","prepose","3bi","?if","tri*","2keep","3keep","curried","2keepd","when","2bi*","2tri*","4keep","bi@","keepdd","do","unless*","tri-curry","if*","loop","bi-curry*","when*","2bi@","2tri@","with","2with","either?","bi","until","3dip","3curry","tri-curry*","tri-curry@","bi-curry","keepd","compose","2dip","if","3tri","unless","tuple","keep","2curry","tri","most","while*","dip","composed","bi-curry@","find-last-from","trim-head-slice","map-as","each-from","none?","trim-tail","partition","if-empty","accumulate*","reject!","find-from","accumulate-as","collector-for-as","reject","map","map-sum","accumulate!","2each-from","follow","supremum-by","map!","unless-empty","collector","padding","reduce-index","replicate-as","infimum-by","trim-tail-slice","count","find-index","filter","accumulate*!","reject-as","map-integers","map-find","reduce","selector","interleave","2map","filter-as","binary-reduce","map-index-as","find","produce","filter!","replicate","cartesian-map","cartesian-each","find-index-from","map-find-last","3map-as","3map","find-last","selector-as","2map-as","2map-reduce","accumulate","each","each-index","accumulate*-as","when-empty","all?","collector-as","push-either","new-like","collector-for","2selector","push-if","2all?","map-reduce","3each","any?","trim-slice","2reduce","change-nth","produce-as","2each","trim","trim-head","cartesian-find","map-index","if-zero","each-integer","unless-zero","(find-integer)","when-zero","find-last-integer","(all-integers?)","times","(each-integer)","find-integer","all-integers?","unless-negative","if-positive","when-positive","when-negative","unless-positive","if-negative","case","2cleave","cond>quot","case>quot","3cleave","wrong-values","to-fixed-point","alist>quot","cond","cleave","call-effect","recursive-hashcode","spread","deep-spread>quot","2||","0||","n||","0&&","2&&","3||","1||","1&&","n&&","3&&","smart-unless*","keep-inputs","reduce-outputs","smart-when*","cleave>array","smart-with","smart-apply","smart-if","inputs/outputs","output>sequence-n","map-outputs","map-reduce-outputs","dropping","output>array","smart-map-reduce","smart-2map-reduce","output>array-n","nullary","input<sequence","append-outputs","drop-inputs","inputs","smart-2reduce","drop-outputs","smart-reduce","preserving","smart-when","outputs","append-outputs-as","smart-unless","smart-if*","sum-outputs","input<sequence-unsafe","output>sequence"]),e.languages.factor=i}(e)}return t=1,e=s,s.displayName="factor",s.aliases=[],e};
-//# sourceMappingURL=factor.js.map