@instincthub/react-ui 0.0.3 → 0.0.5

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

@@ -1,2 +0,0 @@
-var e,t;function i(){if(t)return e;function i(e){!function(e){for(var t=/\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source,i=0;i<2;i++)t=t.replace(/<self>/g,(function(){return t}));t=t.replace(/<self>/g,"[]"),e.languages.coq={comment:RegExp(t),string:{pattern:/"(?:[^"]|"")*"(?!")/,greedy:!0},attribute:[{pattern:RegExp(/#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(/<comment>/g,(function(){return t}))),greedy:!0,alias:"attr-name",inside:{comment:RegExp(t),string:{pattern:/"(?:[^"]|"")*"(?!")/,greedy:!0},operator:/=/,punctuation:/^#\[|\]$|[,()]/}},{pattern:/\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,alias:"attr-name"}],keyword:/\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,number:/\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,punct:{pattern:/@\{|\{\||\[=|:>/,alias:"punctuation"},operator:/\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,punctuation:/\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/}}(e)}return t=1,e=i,i.displayName="coq",i.aliases=[],e}export{i as __require};
-//# sourceMappingURL=coq.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"coq.js","sources":["../../../../node_modules/refractor/lang/coq.js"],"sourcesContent":["'use strict'\n\nmodule.exports = coq\ncoq.displayName = 'coq'\ncoq.aliases = []\nfunction coq(Prism) {\n  ;(function (Prism) {\n    // https://github.com/coq/coq\n    var commentSource = /\\(\\*(?:[^(*]|\\((?!\\*)|\\*(?!\\))|<self>)*\\*\\)/.source\n    for (var i = 0; i < 2; i++) {\n      commentSource = commentSource.replace(/<self>/g, function () {\n        return commentSource\n      })\n    }\n    commentSource = commentSource.replace(/<self>/g, '[]')\n    Prism.languages.coq = {\n      comment: RegExp(commentSource),\n      string: {\n        pattern: /\"(?:[^\"]|\"\")*\"(?!\")/,\n        greedy: true\n      },\n      attribute: [\n        {\n          pattern: RegExp(\n            /#\\[(?:[^\\[\\](\"]|\"(?:[^\"]|\"\")*\"(?!\")|\\((?!\\*)|<comment>)*\\]/.source.replace(\n              /<comment>/g,\n              function () {\n                return commentSource\n              }\n            )\n          ),\n          greedy: true,\n          alias: 'attr-name',\n          inside: {\n            comment: RegExp(commentSource),\n            string: {\n              pattern: /\"(?:[^\"]|\"\")*\"(?!\")/,\n              greedy: true\n            },\n            operator: /=/,\n            punctuation: /^#\\[|\\]$|[,()]/\n          }\n        },\n        {\n          pattern:\n            /\\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\\b/,\n          alias: 'attr-name'\n        }\n      ],\n      keyword:\n        /\\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\\b/,\n      number:\n        /\\b(?:0x[a-f0-9][a-f0-9_]*(?:\\.[a-f0-9_]+)?(?:p[+-]?\\d[\\d_]*)?|\\d[\\d_]*(?:\\.[\\d_]+)?(?:e[+-]?\\d[\\d_]*)?)\\b/i,\n      punct: {\n        pattern: /@\\{|\\{\\||\\[=|:>/,\n        alias: 'punctuation'\n      },\n      operator:\n        /\\/\\\\|\\\\\\/|\\.{2,3}|:{1,2}=|\\*\\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\\|[-|]?|[-!%&*+/<=>?@^~']/,\n      punctuation: /\\.\\(|`\\(|@\\{|`\\{|\\{\\||\\[=|:>|[:.,;(){}\\[\\]]/\n    }\n  })(Prism)\n}\n"],"names":["coq","Prism","commentSource","source","i","replace","languages","comment","RegExp","string","pattern","greedy","attribute","alias","inside","operator","punctuation","keyword","number","punct","coq_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAIC,IACV,SAAWA,GAGV,IADA,IAAIC,EAAgB,8CAA8CC,OACzDC,EAAI,EAAGA,EAAI,EAAGA,IACrBF,EAAgBA,EAAcG,QAAQ,WAAW,WAC/C,OAAOH,CACf,IAEIA,EAAgBA,EAAcG,QAAQ,UAAW,MACjDJ,EAAMK,UAAUN,IAAM,CACpBO,QAASC,OAAON,GAChBO,OAAQ,CACNC,QAAS,sBACTC,QAAQ,GAEVC,UAAW,CACT,CACEF,QAASF,OACP,6DAA6DL,OAAOE,QAClE,cACA,WACE,OAAOH,CACR,KAGLS,QAAQ,EACRE,MAAO,YACPC,OAAQ,CACNP,QAASC,OAAON,GAChBO,OAAQ,CACNC,QAAS,sBACTC,QAAQ,GAEVI,SAAU,IACVC,YAAa,mBAGjB,CACEN,QACE,wFACFG,MAAO,cAGXI,QACE,0/DACFC,OACE,6GACFC,MAAO,CACLT,QAAS,kBACTG,MAAO,eAETE,SACE,8FACFC,YAAa,8CAEhB,CAvDA,CAuDEf,EACL,YA5DAmB,EAAiBpB,EACjBA,EAAIqB,YAAc,MAClBrB,EAAIsB,QAAU"}

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

@@ -1,2 +0,0 @@
-import{__require as e}from"./c.js";var t,n;function r(){if(n)return t;n=1;var r=e();function a(e){e.register(r),function(e){var t=/\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/,n=/\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g,(function(){return t.source}));e.languages.cpp=e.languages.extend("c",{"class-name":[{pattern:RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(/<keyword>/g,(function(){return t.source}))),lookbehind:!0},/\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,/\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,/\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/],keyword:t,number:{pattern:/(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,greedy:!0},operator:/>>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,boolean:/\b(?:false|true)\b/}),e.languages.insertBefore("cpp","string",{module:{pattern:RegExp(/(\b(?:import|module)\s+)/.source+"(?:"+/"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source+"|"+/<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g,(function(){return n}))+")"),lookbehind:!0,greedy:!0,inside:{string:/^[<"][\s\S]+/,operator:/:/,punctuation:/\./}},"raw-string":{pattern:/R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,alias:"string",greedy:!0}}),e.languages.insertBefore("cpp","keyword",{"generic-function":{pattern:/\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,inside:{function:/^\w+/,generic:{pattern:/<[\s\S]+/,alias:"class-name",inside:e.languages.cpp}}}}),e.languages.insertBefore("cpp","operator",{"double-colon":{pattern:/::/,alias:"punctuation"}}),e.languages.insertBefore("cpp","class-name",{"base-clause":{pattern:/(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,lookbehind:!0,greedy:!0,inside:e.languages.extend("cpp",{})}}),e.languages.insertBefore("inside","double-colon",{"class-name":/\b[a-z_]\w*\b(?!\s*::)/i},e.languages.cpp["base-clause"])}(e)}return t=a,a.displayName="cpp",a.aliases=[],t}export{r as __require};
-//# sourceMappingURL=cpp.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"cpp.js","sources":["../../../../node_modules/refractor/lang/cpp.js"],"sourcesContent":["'use strict'\nvar refractorC = require('./c.js')\nmodule.exports = cpp\ncpp.displayName = 'cpp'\ncpp.aliases = []\nfunction cpp(Prism) {\n  Prism.register(refractorC)\n  ;(function (Prism) {\n    var keyword =\n      /\\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\\b/\n    var modName = /\\b(?!<keyword>)\\w+(?:\\s*\\.\\s*\\w+)*\\b/.source.replace(\n      /<keyword>/g,\n      function () {\n        return keyword.source\n      }\n    )\n    Prism.languages.cpp = Prism.languages.extend('c', {\n      'class-name': [\n        {\n          pattern: RegExp(\n            /(\\b(?:class|concept|enum|struct|typename)\\s+)(?!<keyword>)\\w+/.source.replace(\n              /<keyword>/g,\n              function () {\n                return keyword.source\n              }\n            )\n          ),\n          lookbehind: true\n        }, // This is intended to capture the class name of method implementations like:\n        //   void foo::bar() const {}\n        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if\n        // it starts with an uppercase letter. This approximation should give decent results.\n        /\\b[A-Z]\\w*(?=\\s*::\\s*\\w+\\s*\\()/, // This will capture the class name before destructors like:\n        //   Foo::~Foo() {}\n        /\\b[A-Z_]\\w*(?=\\s*::\\s*~\\w+\\s*\\()/i, // This also intends to capture the class name of method implementations but here the class has template\n        // parameters, so it can't be a namespace (until C++ adds generic namespaces).\n        /\\b\\w+(?=\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\\s*::\\s*\\w+\\s*\\()/\n      ],\n      keyword: keyword,\n      number: {\n        pattern:\n          /(?:\\b0b[01']+|\\b0x(?:[\\da-f']+(?:\\.[\\da-f']*)?|\\.[\\da-f']+)(?:p[+-]?[\\d']+)?|(?:\\b[\\d']+(?:\\.[\\d']*)?|\\B\\.[\\d']+)(?:e[+-]?[\\d']+)?)[ful]{0,4}/i,\n        greedy: true\n      },\n      operator:\n        />>=?|<<=?|->|--|\\+\\+|&&|\\|\\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\\b/,\n      boolean: /\\b(?:false|true)\\b/\n    })\n    Prism.languages.insertBefore('cpp', 'string', {\n      module: {\n        // https://en.cppreference.com/w/cpp/language/modules\n        pattern: RegExp(\n          /(\\b(?:import|module)\\s+)/.source +\n            '(?:' + // header-name\n            /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"|<[^<>\\r\\n]*>/.source +\n            '|' + // module name or partition or both\n            /<mod-name>(?:\\s*:\\s*<mod-name>)?|:\\s*<mod-name>/.source.replace(\n              /<mod-name>/g,\n              function () {\n                return modName\n              }\n            ) +\n            ')'\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          string: /^[<\"][\\s\\S]+/,\n          operator: /:/,\n          punctuation: /\\./\n        }\n      },\n      'raw-string': {\n        pattern: /R\"([^()\\\\ ]{0,16})\\([\\s\\S]*?\\)\\1\"/,\n        alias: 'string',\n        greedy: true\n      }\n    })\n    Prism.languages.insertBefore('cpp', 'keyword', {\n      'generic-function': {\n        pattern: /\\b(?!operator\\b)[a-z_]\\w*\\s*<(?:[^<>]|<[^<>]*>)*>(?=\\s*\\()/i,\n        inside: {\n          function: /^\\w+/,\n          generic: {\n            pattern: /<[\\s\\S]+/,\n            alias: 'class-name',\n            inside: Prism.languages.cpp\n          }\n        }\n      }\n    })\n    Prism.languages.insertBefore('cpp', 'operator', {\n      'double-colon': {\n        pattern: /::/,\n        alias: 'punctuation'\n      }\n    })\n    Prism.languages.insertBefore('cpp', 'class-name', {\n      // the base clause is an optional list of parent classes\n      // https://en.cppreference.com/w/cpp/language/class\n      'base-clause': {\n        pattern:\n          /(\\b(?:class|struct)\\s+\\w+\\s*:\\s*)[^;{}\"'\\s]+(?:\\s+[^;{}\"'\\s]+)*(?=\\s*[;{])/,\n        lookbehind: true,\n        greedy: true,\n        inside: Prism.languages.extend('cpp', {})\n      }\n    })\n    Prism.languages.insertBefore(\n      'inside',\n      'double-colon',\n      {\n        // All untokenized words that are not namespaces should be class names\n        'class-name': /\\b[a-z_]\\w*\\b(?!\\s*::)/i\n      },\n      Prism.languages.cpp['base-clause']\n    )\n  })(Prism)\n}\n"],"names":["refractorC","require$$0","cpp","Prism","register","keyword","modName","source","replace","languages","extend","pattern","RegExp","lookbehind","number","greedy","operator","boolean","insertBefore","module","inside","string","punctuation","alias","function","generic","cpp_1","displayName","aliases"],"mappings":"0EACA,IAAIA,EAAaC,IAIjB,SAASC,EAAIC,GACXA,EAAMC,SAASJ,GACd,SAAWG,GACV,IAAIE,EACF,osBACEC,EAAU,uCAAuCC,OAAOC,QAC1D,cACA,WACE,OAAOH,EAAQE,MAChB,IAEHJ,EAAMM,UAAUP,IAAMC,EAAMM,UAAUC,OAAO,IAAK,CAChD,aAAc,CACZ,CACEC,QAASC,OACP,gEAAgEL,OAAOC,QACrE,cACA,WACE,OAAOH,EAAQE,MAChB,KAGLM,YAAY,GAKd,iCAEA,oCAEA,kEAEFR,QAASA,EACTS,OAAQ,CACNH,QACE,iJACFI,QAAQ,GAEVC,SACE,yHACFC,QAAS,uBAEXd,EAAMM,UAAUS,aAAa,MAAO,SAAU,CAC5CC,OAAQ,CAENR,QAASC,OACP,2BAA2BL,OACzB,MACA,mDAAmDA,OACnD,IACA,kDAAkDA,OAAOC,QACvD,eACA,WACE,OAAOF,CACR,IAEH,KAEJO,YAAY,EACZE,QAAQ,EACRK,OAAQ,CACNC,OAAQ,eACRL,SAAU,IACVM,YAAa,OAGjB,aAAc,CACZX,QAAS,oCACTY,MAAO,SACPR,QAAQ,KAGZZ,EAAMM,UAAUS,aAAa,MAAO,UAAW,CAC7C,mBAAoB,CAClBP,QAAS,8DACTS,OAAQ,CACNI,SAAU,OACVC,QAAS,CACPd,QAAS,WACTY,MAAO,aACPH,OAAQjB,EAAMM,UAAUP,SAKhCC,EAAMM,UAAUS,aAAa,MAAO,WAAY,CAC9C,eAAgB,CACdP,QAAS,KACTY,MAAO,iBAGXpB,EAAMM,UAAUS,aAAa,MAAO,aAAc,CAGhD,cAAe,CACbP,QACE,6EACFE,YAAY,EACZE,QAAQ,EACRK,OAAQjB,EAAMM,UAAUC,OAAO,MAAO,CAAA,MAG1CP,EAAMM,UAAUS,aACd,SACA,eACA,CAEE,aAAc,2BAEhBf,EAAMM,UAAUP,IAAI,eAEvB,CA9GA,CA8GEC,EACL,QApHAuB,EAAiBxB,EACjBA,EAAIyB,YAAc,MAClBzB,EAAI0B,QAAU"}

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

@@ -1,2 +0,0 @@
-import{__require as e}from"./ruby.js";var t,a;function n(){if(a)return t;a=1;var n=e();function r(e){e.register(n),function(e){e.languages.crystal=e.languages.extend("ruby",{keyword:[/\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/,{pattern:/(\.\s*)(?:is_a|responds_to)\?/,lookbehind:!0}],number:/\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/,operator:[/->/,e.languages.ruby.operator],punctuation:/[(){}[\].,;\\]/}),e.languages.insertBefore("crystal","string-literal",{attribute:{pattern:/@\[.*?\]/,inside:{delimiter:{pattern:/^@\[|\]$/,alias:"punctuation"},attribute:{pattern:/^(\s*)\w+/,lookbehind:!0,alias:"class-name"},args:{pattern:/\S(?:[\s\S]*\S)?/,inside:e.languages.crystal}}},expansion:{pattern:/\{(?:\{.*?\}|%.*?%)\}/,inside:{content:{pattern:/^(\{.)[\s\S]+(?=.\}$)/,lookbehind:!0,inside:e.languages.crystal},delimiter:{pattern:/^\{[\{%]|[\}%]\}$/,alias:"operator"}}},char:{pattern:/'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/,greedy:!0}})}(e)}return t=r,r.displayName="crystal",r.aliases=[],t}export{n as __require};
-//# sourceMappingURL=crystal.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"crystal.js","sources":["../../../../node_modules/refractor/lang/crystal.js"],"sourcesContent":["'use strict'\nvar refractorRuby = require('./ruby.js')\nmodule.exports = crystal\ncrystal.displayName = 'crystal'\ncrystal.aliases = []\nfunction crystal(Prism) {\n  Prism.register(refractorRuby)\n  ;(function (Prism) {\n    Prism.languages.crystal = Prism.languages.extend('ruby', {\n      keyword: [\n        /\\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\\b/,\n        {\n          pattern: /(\\.\\s*)(?:is_a|responds_to)\\?/,\n          lookbehind: true\n        }\n      ],\n      number:\n        /\\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\\da-fA-F_]*[\\da-fA-F]|(?:\\d(?:[\\d_]*\\d)?)(?:\\.[\\d_]*\\d)?(?:[eE][+-]?[\\d_]*\\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\\b/,\n      operator: [/->/, Prism.languages.ruby.operator],\n      punctuation: /[(){}[\\].,;\\\\]/\n    })\n    Prism.languages.insertBefore('crystal', 'string-literal', {\n      attribute: {\n        pattern: /@\\[.*?\\]/,\n        inside: {\n          delimiter: {\n            pattern: /^@\\[|\\]$/,\n            alias: 'punctuation'\n          },\n          attribute: {\n            pattern: /^(\\s*)\\w+/,\n            lookbehind: true,\n            alias: 'class-name'\n          },\n          args: {\n            pattern: /\\S(?:[\\s\\S]*\\S)?/,\n            inside: Prism.languages.crystal\n          }\n        }\n      },\n      expansion: {\n        pattern: /\\{(?:\\{.*?\\}|%.*?%)\\}/,\n        inside: {\n          content: {\n            pattern: /^(\\{.)[\\s\\S]+(?=.\\}$)/,\n            lookbehind: true,\n            inside: Prism.languages.crystal\n          },\n          delimiter: {\n            pattern: /^\\{[\\{%]|[\\}%]\\}$/,\n            alias: 'operator'\n          }\n        }\n      },\n      char: {\n        pattern:\n          /'(?:[^\\\\\\r\\n]{1,2}|\\\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\\{[A-Fa-f0-9]{1,6}\\})))'/,\n        greedy: true\n      }\n    })\n  })(Prism)\n}\n"],"names":["refractorRuby","require$$0","crystal","Prism","register","languages","extend","keyword","pattern","lookbehind","number","operator","ruby","punctuation","insertBefore","attribute","inside","delimiter","alias","args","expansion","content","char","greedy","crystal_1","displayName","aliases"],"mappings":"6EACA,IAAIA,EAAgBC,IAIpB,SAASC,EAAQC,GACfA,EAAMC,SAASJ,GACd,SAAWG,GACVA,EAAME,UAAUH,QAAUC,EAAME,UAAUC,OAAO,OAAQ,CACvDC,QAAS,CACP,4XACA,CACEC,QAAS,gCACTC,YAAY,IAGhBC,OACE,sJACFC,SAAU,CAAC,KAAMR,EAAME,UAAUO,KAAKD,UACtCE,YAAa,mBAEfV,EAAME,UAAUS,aAAa,UAAW,iBAAkB,CACxDC,UAAW,CACTP,QAAS,WACTQ,OAAQ,CACNC,UAAW,CACTT,QAAS,WACTU,MAAO,eAETH,UAAW,CACTP,QAAS,YACTC,YAAY,EACZS,MAAO,cAETC,KAAM,CACJX,QAAS,mBACTQ,OAAQb,EAAME,UAAUH,WAI9BkB,UAAW,CACTZ,QAAS,wBACTQ,OAAQ,CACNK,QAAS,CACPb,QAAS,wBACTC,YAAY,EACZO,OAAQb,EAAME,UAAUH,SAE1Be,UAAW,CACTT,QAAS,oBACTU,MAAO,cAIbI,KAAM,CACJd,QACE,0EACFe,QAAQ,IAGb,CArDA,CAqDEpB,EACL,QA3DAqB,EAAiBtB,EACjBA,EAAQuB,YAAc,UACtBvB,EAAQwB,QAAU"}

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

@@ -1,2 +0,0 @@
-var e,s;function n(){if(s)return e;function n(e){!function(e){function s(e,s){return e.replace(/<<(\d+)>>/g,(function(e,n){return"(?:"+s[+n]+")"}))}function n(e,n,r){return RegExp(s(e,n),r||"")}function r(e,s){for(var n=0;n<s;n++)e=e.replace(/<<self>>/g,(function(){return"(?:"+e+")"}));return e.replace(/<<self>>/g,"[^\\s\\S]")}var a="bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",t="class enum interface record struct",o="add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)",i="abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield";function c(e){return"\\b(?:"+e.trim().replace(/ /g,"|")+")\\b"}var u=c(t),l=RegExp(c(a+" "+t+" "+o+" "+i)),d=c(t+" "+o+" "+i),p=c(a+" "+t+" "+i),g=r(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source,2),b=r(/\((?:[^()]|<<self>>)*\)/.source,2),h=/@?\b[A-Za-z_]\w*\b/.source,f=s(/<<0>>(?:\s*<<1>>)?/.source,[h,g]),m=s(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source,[d,f]),k=/\[\s*(?:,\s*)*\]/.source,y=s(/<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source,[m,k]),w=s(/[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source,[g,b,k]),v=s(/\(<<0>>+(?:,<<0>>+)+\)/.source,[w]),x=s(/(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source,[v,m,k]),$={keyword:l,punctuation:/[<>()?,.:[\]]/},_=/'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source,B=/"(?:\\.|[^\\"\r\n])*"/.source,E=/@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;e.languages.csharp=e.languages.extend("clike",{string:[{pattern:n(/(^|[^$\\])<<0>>/.source,[E]),lookbehind:!0,greedy:!0},{pattern:n(/(^|[^@$\\])<<0>>/.source,[B]),lookbehind:!0,greedy:!0}],"class-name":[{pattern:n(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source,[m]),lookbehind:!0,inside:$},{pattern:n(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source,[h,x]),lookbehind:!0,inside:$},{pattern:n(/(\busing\s+)<<0>>(?=\s*=)/.source,[h]),lookbehind:!0},{pattern:n(/(\b<<0>>\s+)<<1>>/.source,[u,f]),lookbehind:!0,inside:$},{pattern:n(/(\bcatch\s*\(\s*)<<0>>/.source,[m]),lookbehind:!0,inside:$},{pattern:n(/(\bwhere\s+)<<0>>/.source,[h]),lookbehind:!0},{pattern:n(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source,[y]),lookbehind:!0,inside:$},{pattern:n(/\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source,[x,p,h]),inside:$}],keyword:l,number:/(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,operator:/>>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,punctuation:/\?\.?|::|[{}[\];(),.:]/}),e.languages.insertBefore("csharp","number",{range:{pattern:/\.\./,alias:"operator"}}),e.languages.insertBefore("csharp","punctuation",{"named-parameter":{pattern:n(/([(,]\s*)<<0>>(?=\s*:)/.source,[h]),lookbehind:!0,alias:"punctuation"}}),e.languages.insertBefore("csharp","class-name",{namespace:{pattern:n(/(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source,[h]),lookbehind:!0,inside:{punctuation:/\./}},"type-expression":{pattern:n(/(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source,[b]),lookbehind:!0,alias:"class-name",inside:$},"return-type":{pattern:n(/<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source,[x,m]),inside:$,alias:"class-name"},"constructor-invocation":{pattern:n(/(\bnew\s+)<<0>>(?=\s*[[({])/.source,[x]),lookbehind:!0,inside:$,alias:"class-name"},"generic-method":{pattern:n(/<<0>>\s*<<1>>(?=\s*\()/.source,[h,g]),inside:{function:n(/^<<0>>/.source,[h]),generic:{pattern:RegExp(g),alias:"class-name",inside:$}}},"type-list":{pattern:n(/\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/.source,[u,f,h,x,l.source,b,/\bnew\s*\(\s*\)/.source]),lookbehind:!0,inside:{"record-arguments":{pattern:n(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source,[f,b]),lookbehind:!0,greedy:!0,inside:e.languages.csharp},keyword:l,"class-name":{pattern:RegExp(x),greedy:!0,inside:$},punctuation:/[,()]/}},preprocessor:{pattern:/(^[\t ]*)#.*/m,lookbehind:!0,alias:"property",inside:{directive:{pattern:/(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,lookbehind:!0,alias:"keyword"}}}});var R=B+"|"+_,S=s(/\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source,[R]),z=r(s(/[^"'/()]|<<0>>|\(<<self>>*\)/.source,[S]),2),j=/\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source,A=s(/<<0>>(?:\s*\(<<1>>*\))?/.source,[m,z]);e.languages.insertBefore("csharp","class-name",{attribute:{pattern:n(/((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source,[j,A]),lookbehind:!0,greedy:!0,inside:{target:{pattern:n(/^<<0>>(?=\s*:)/.source,[j]),alias:"keyword"},"attribute-arguments":{pattern:n(/\(<<0>>*\)/.source,[z]),inside:e.languages.csharp},"class-name":{pattern:RegExp(m),inside:{punctuation:/\./}},punctuation:/[:,]/}}});var q=/:[^}\r\n]+/.source,F=r(s(/[^"'/()]|<<0>>|\(<<self>>*\)/.source,[S]),2),N=s(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source,[F,q]),U=r(s(/[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source,[R]),2),Z=s(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source,[U,q]);function C(s,r){return{interpolation:{pattern:n(/((?:^|[^{])(?:\{\{)*)<<0>>/.source,[s]),lookbehind:!0,inside:{"format-string":{pattern:n(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source,[r,q]),lookbehind:!0,inside:{punctuation:/^:/}},punctuation:/^\{|\}$/,expression:{pattern:/[\s\S]+/,alias:"language-csharp",inside:e.languages.csharp}}},string:/[\s\S]+/}}e.languages.insertBefore("csharp","string",{"interpolation-string":[{pattern:n(/(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source,[N]),lookbehind:!0,greedy:!0,inside:C(N,F)},{pattern:n(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source,[Z]),lookbehind:!0,greedy:!0,inside:C(Z,U)}],char:{pattern:RegExp(_),greedy:!0}}),e.languages.dotnet=e.languages.cs=e.languages.csharp}(e)}return s=1,e=n,n.displayName="csharp",n.aliases=["dotnet","cs"],e}export{n as __require};
-//# sourceMappingURL=csharp.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"csharp.js","sources":["../../../../node_modules/refractor/lang/csharp.js"],"sourcesContent":["'use strict'\n\nmodule.exports = csharp\ncsharp.displayName = 'csharp'\ncsharp.aliases = ['dotnet', 'cs']\nfunction csharp(Prism) {\n  ;(function (Prism) {\n    /**\n     * Replaces all placeholders \"<<n>>\" of given pattern with the n-th replacement (zero based).\n     *\n     * Note: This is a simple text based replacement. Be careful when using backreferences!\n     *\n     * @param {string} pattern the given pattern.\n     * @param {string[]} replacements a list of replacement which can be inserted into the given pattern.\n     * @returns {string} the pattern with all placeholders replaced with their corresponding replacements.\n     * @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source\n     */\n    function replace(pattern, replacements) {\n      return pattern.replace(/<<(\\d+)>>/g, function (m, index) {\n        return '(?:' + replacements[+index] + ')'\n      })\n    }\n    /**\n     * @param {string} pattern\n     * @param {string[]} replacements\n     * @param {string} [flags]\n     * @returns {RegExp}\n     */\n    function re(pattern, replacements, flags) {\n      return RegExp(replace(pattern, replacements), flags || '')\n    }\n    /**\n     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.\n     *\n     * @param {string} pattern\n     * @param {number} depthLog2\n     * @returns {string}\n     */\n    function nested(pattern, depthLog2) {\n      for (var i = 0; i < depthLog2; i++) {\n        pattern = pattern.replace(/<<self>>/g, function () {\n          return '(?:' + pattern + ')'\n        })\n      }\n      return pattern.replace(/<<self>>/g, '[^\\\\s\\\\S]')\n    } // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/\n    var keywordKinds = {\n      // keywords which represent a return or variable type\n      type: 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void',\n      // keywords which are used to declare a type\n      typeDeclaration: 'class enum interface record struct',\n      // contextual keywords\n      // (\"var\" and \"dynamic\" are missing because they are used like types)\n      contextual:\n        'add alias and ascending async await by descending from(?=\\\\s*(?:\\\\w|$)) get global group into init(?=\\\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\\\s*{)',\n      // all other keywords\n      other:\n        'abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield'\n    } // keywords\n    function keywordsToPattern(words) {\n      return '\\\\b(?:' + words.trim().replace(/ /g, '|') + ')\\\\b'\n    }\n    var typeDeclarationKeywords = keywordsToPattern(\n      keywordKinds.typeDeclaration\n    )\n    var keywords = RegExp(\n      keywordsToPattern(\n        keywordKinds.type +\n          ' ' +\n          keywordKinds.typeDeclaration +\n          ' ' +\n          keywordKinds.contextual +\n          ' ' +\n          keywordKinds.other\n      )\n    )\n    var nonTypeKeywords = keywordsToPattern(\n      keywordKinds.typeDeclaration +\n        ' ' +\n        keywordKinds.contextual +\n        ' ' +\n        keywordKinds.other\n    )\n    var nonContextualKeywords = keywordsToPattern(\n      keywordKinds.type +\n        ' ' +\n        keywordKinds.typeDeclaration +\n        ' ' +\n        keywordKinds.other\n    ) // types\n    var generic = nested(/<(?:[^<>;=+\\-*/%&|^]|<<self>>)*>/.source, 2) // the idea behind the other forbidden characters is to prevent false positives. Same for tupleElement.\n    var nestedRound = nested(/\\((?:[^()]|<<self>>)*\\)/.source, 2)\n    var name = /@?\\b[A-Za-z_]\\w*\\b/.source\n    var genericName = replace(/<<0>>(?:\\s*<<1>>)?/.source, [name, generic])\n    var identifier = replace(/(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*/.source, [\n      nonTypeKeywords,\n      genericName\n    ])\n    var array = /\\[\\s*(?:,\\s*)*\\]/.source\n    var typeExpressionWithoutTuple = replace(\n      /<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?/.source,\n      [identifier, array]\n    )\n    var tupleElement = replace(\n      /[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source,\n      [generic, nestedRound, array]\n    )\n    var tuple = replace(/\\(<<0>>+(?:,<<0>>+)+\\)/.source, [tupleElement])\n    var typeExpression = replace(\n      /(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?/.source,\n      [tuple, identifier, array]\n    )\n    var typeInside = {\n      keyword: keywords,\n      punctuation: /[<>()?,.:[\\]]/\n    } // strings & characters\n    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#character-literals\n    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#string-literals\n    var character = /'(?:[^\\r\\n'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'/.source // simplified pattern\n    var regularString = /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/.source\n    var verbatimString = /@\"(?:\"\"|\\\\[\\s\\S]|[^\\\\\"])*\"(?!\")/.source\n    Prism.languages.csharp = Prism.languages.extend('clike', {\n      string: [\n        {\n          pattern: re(/(^|[^$\\\\])<<0>>/.source, [verbatimString]),\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          pattern: re(/(^|[^@$\\\\])<<0>>/.source, [regularString]),\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      'class-name': [\n        {\n          // Using static\n          // using static System.Math;\n          pattern: re(/(\\busing\\s+static\\s+)<<0>>(?=\\s*;)/.source, [\n            identifier\n          ]),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // Using alias (type)\n          // using Project = PC.MyCompany.Project;\n          pattern: re(/(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)/.source, [\n            name,\n            typeExpression\n          ]),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // Using alias (alias)\n          // using Project = PC.MyCompany.Project;\n          pattern: re(/(\\busing\\s+)<<0>>(?=\\s*=)/.source, [name]),\n          lookbehind: true\n        },\n        {\n          // Type declarations\n          // class Foo<A, B>\n          // interface Foo<out A, B>\n          pattern: re(/(\\b<<0>>\\s+)<<1>>/.source, [\n            typeDeclarationKeywords,\n            genericName\n          ]),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // Single catch exception declaration\n          // catch(Foo)\n          // (things like catch(Foo e) is covered by variable declaration)\n          pattern: re(/(\\bcatch\\s*\\(\\s*)<<0>>/.source, [identifier]),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // Name of the type parameter of generic constraints\n          // where Foo : class\n          pattern: re(/(\\bwhere\\s+)<<0>>/.source, [name]),\n          lookbehind: true\n        },\n        {\n          // Casts and checks via as and is.\n          // as Foo<A>, is Bar<B>\n          // (things like if(a is Foo b) is covered by variable declaration)\n          pattern: re(/(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>/.source, [\n            typeExpressionWithoutTuple\n          ]),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // Variable, field and parameter declaration\n          // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)\n          pattern: re(\n            /\\b<<0>>(?=\\s+(?!<<1>>|with\\s*\\{)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))/\n              .source,\n            [typeExpression, nonContextualKeywords, name]\n          ),\n          inside: typeInside\n        }\n      ],\n      keyword: keywords,\n      // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals\n      number:\n        /(?:\\b0(?:x[\\da-f_]*[\\da-f]|b[01_]*[01])|(?:\\B\\.\\d+(?:_+\\d+)*|\\b\\d+(?:_+\\d+)*(?:\\.\\d+(?:_+\\d+)*)?)(?:e[-+]?\\d+(?:_+\\d+)*)?)(?:[dflmu]|lu|ul)?\\b/i,\n      operator: />>=?|<<=?|[-=]>|([-+&|])\\1|~|\\?\\?=?|[-+*/%&|^!=<>]=?/,\n      punctuation: /\\?\\.?|::|[{}[\\];(),.:]/\n    })\n    Prism.languages.insertBefore('csharp', 'number', {\n      range: {\n        pattern: /\\.\\./,\n        alias: 'operator'\n      }\n    })\n    Prism.languages.insertBefore('csharp', 'punctuation', {\n      'named-parameter': {\n        pattern: re(/([(,]\\s*)<<0>>(?=\\s*:)/.source, [name]),\n        lookbehind: true,\n        alias: 'punctuation'\n      }\n    })\n    Prism.languages.insertBefore('csharp', 'class-name', {\n      namespace: {\n        // namespace Foo.Bar {}\n        // using Foo.Bar;\n        pattern: re(\n          /(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])/.source,\n          [name]\n        ),\n        lookbehind: true,\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      'type-expression': {\n        // default(Foo), typeof(Foo<Bar>), sizeof(int)\n        pattern: re(\n          /(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))/\n            .source,\n          [nestedRound]\n        ),\n        lookbehind: true,\n        alias: 'class-name',\n        inside: typeInside\n      },\n      'return-type': {\n        // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0\n        // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];\n        // int Foo => 0; int Foo { get; set } = 0;\n        pattern: re(\n          /<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))/.source,\n          [typeExpression, identifier]\n        ),\n        inside: typeInside,\n        alias: 'class-name'\n      },\n      'constructor-invocation': {\n        // new List<Foo<Bar[]>> { }\n        pattern: re(/(\\bnew\\s+)<<0>>(?=\\s*[[({])/.source, [typeExpression]),\n        lookbehind: true,\n        inside: typeInside,\n        alias: 'class-name'\n      },\n      /*'explicit-implementation': {\n// int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();\npattern: replace(/\\b<<0>>(?=\\.<<1>>)/, className, methodOrPropertyDeclaration),\ninside: classNameInside,\nalias: 'class-name'\n},*/\n      'generic-method': {\n        // foo<Bar>()\n        pattern: re(/<<0>>\\s*<<1>>(?=\\s*\\()/.source, [name, generic]),\n        inside: {\n          function: re(/^<<0>>/.source, [name]),\n          generic: {\n            pattern: RegExp(generic),\n            alias: 'class-name',\n            inside: typeInside\n          }\n        }\n      },\n      'type-list': {\n        // The list of types inherited or of generic constraints\n        // class Foo<F> : Bar, IList<FooBar>\n        // where F : Bar, IList<int>\n        pattern: re(\n          /\\b((?:<<0>>\\s+<<1>>|record\\s+<<1>>\\s*<<5>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>|<<1>>\\s*<<5>>|<<6>>)(?:\\s*,\\s*(?:<<3>>|<<4>>|<<6>>))*(?=\\s*(?:where|[{;]|=>|$))/\n            .source,\n          [\n            typeDeclarationKeywords,\n            genericName,\n            name,\n            typeExpression,\n            keywords.source,\n            nestedRound,\n            /\\bnew\\s*\\(\\s*\\)/.source\n          ]\n        ),\n        lookbehind: true,\n        inside: {\n          'record-arguments': {\n            pattern: re(/(^(?!new\\s*\\()<<0>>\\s*)<<1>>/.source, [\n              genericName,\n              nestedRound\n            ]),\n            lookbehind: true,\n            greedy: true,\n            inside: Prism.languages.csharp\n          },\n          keyword: keywords,\n          'class-name': {\n            pattern: RegExp(typeExpression),\n            greedy: true,\n            inside: typeInside\n          },\n          punctuation: /[,()]/\n        }\n      },\n      preprocessor: {\n        pattern: /(^[\\t ]*)#.*/m,\n        lookbehind: true,\n        alias: 'property',\n        inside: {\n          // highlight preprocessor directives as keywords\n          directive: {\n            pattern:\n              /(#)\\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\\b/,\n            lookbehind: true,\n            alias: 'keyword'\n          }\n        }\n      }\n    }) // attributes\n    var regularStringOrCharacter = regularString + '|' + character\n    var regularStringCharacterOrComment = replace(\n      /\\/(?![*/])|\\/\\/[^\\r\\n]*[\\r\\n]|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<<0>>/.source,\n      [regularStringOrCharacter]\n    )\n    var roundExpression = nested(\n      replace(/[^\"'/()]|<<0>>|\\(<<self>>*\\)/.source, [\n        regularStringCharacterOrComment\n      ]),\n      2\n    ) // https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/#attribute-targets\n    var attrTarget =\n      /\\b(?:assembly|event|field|method|module|param|property|return|type)\\b/\n        .source\n    var attr = replace(/<<0>>(?:\\s*\\(<<1>>*\\))?/.source, [\n      identifier,\n      roundExpression\n    ])\n    Prism.languages.insertBefore('csharp', 'class-name', {\n      attribute: {\n        // Attributes\n        // [Foo], [Foo(1), Bar(2, Prop = \"foo\")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]\n        pattern: re(\n          /((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])/\n            .source,\n          [attrTarget, attr]\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          target: {\n            pattern: re(/^<<0>>(?=\\s*:)/.source, [attrTarget]),\n            alias: 'keyword'\n          },\n          'attribute-arguments': {\n            pattern: re(/\\(<<0>>*\\)/.source, [roundExpression]),\n            inside: Prism.languages.csharp\n          },\n          'class-name': {\n            pattern: RegExp(identifier),\n            inside: {\n              punctuation: /\\./\n            }\n          },\n          punctuation: /[:,]/\n        }\n      }\n    }) // string interpolation\n    var formatString = /:[^}\\r\\n]+/.source // multi line\n    var mInterpolationRound = nested(\n      replace(/[^\"'/()]|<<0>>|\\(<<self>>*\\)/.source, [\n        regularStringCharacterOrComment\n      ]),\n      2\n    )\n    var mInterpolation = replace(/\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}/.source, [\n      mInterpolationRound,\n      formatString\n    ]) // single line\n    var sInterpolationRound = nested(\n      replace(\n        /[^\"'/()]|\\/(?!\\*)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<<0>>|\\(<<self>>*\\)/\n          .source,\n        [regularStringOrCharacter]\n      ),\n      2\n    )\n    var sInterpolation = replace(/\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}/.source, [\n      sInterpolationRound,\n      formatString\n    ])\n    function createInterpolationInside(interpolation, interpolationRound) {\n      return {\n        interpolation: {\n          pattern: re(/((?:^|[^{])(?:\\{\\{)*)<<0>>/.source, [interpolation]),\n          lookbehind: true,\n          inside: {\n            'format-string': {\n              pattern: re(/(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)/.source, [\n                interpolationRound,\n                formatString\n              ]),\n              lookbehind: true,\n              inside: {\n                punctuation: /^:/\n              }\n            },\n            punctuation: /^\\{|\\}$/,\n            expression: {\n              pattern: /[\\s\\S]+/,\n              alias: 'language-csharp',\n              inside: Prism.languages.csharp\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n    Prism.languages.insertBefore('csharp', 'string', {\n      'interpolation-string': [\n        {\n          pattern: re(\n            /(^|[^\\\\])(?:\\$@|@\\$)\"(?:\"\"|\\\\[\\s\\S]|\\{\\{|<<0>>|[^\\\\{\"])*\"/.source,\n            [mInterpolation]\n          ),\n          lookbehind: true,\n          greedy: true,\n          inside: createInterpolationInside(mInterpolation, mInterpolationRound)\n        },\n        {\n          pattern: re(/(^|[^@\\\\])\\$\"(?:\\\\.|\\{\\{|<<0>>|[^\\\\\"{])*\"/.source, [\n            sInterpolation\n          ]),\n          lookbehind: true,\n          greedy: true,\n          inside: createInterpolationInside(sInterpolation, sInterpolationRound)\n        }\n      ],\n      char: {\n        pattern: RegExp(character),\n        greedy: true\n      }\n    })\n    Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp\n  })(Prism)\n}\n"],"names":["csharp","Prism","replace","pattern","replacements","m","index","re","flags","RegExp","nested","depthLog2","i","keywordKinds","keywordsToPattern","words","trim","typeDeclarationKeywords","keywords","nonTypeKeywords","nonContextualKeywords","generic","source","nestedRound","name","genericName","identifier","array","typeExpressionWithoutTuple","tupleElement","tuple","typeExpression","typeInside","keyword","punctuation","character","regularString","verbatimString","languages","extend","string","lookbehind","greedy","inside","number","operator","insertBefore","range","alias","namespace","function","preprocessor","directive","regularStringOrCharacter","regularStringCharacterOrComment","roundExpression","attrTarget","attr","attribute","target","formatString","mInterpolationRound","mInterpolation","sInterpolationRound","sInterpolation","createInterpolationInside","interpolation","interpolationRound","expression","char","dotnet","cs","csharp_1","displayName","aliases"],"mappings":"mCAKA,SAASA,EAAOC,IACb,SAAWA,GAWV,SAASC,EAAQC,EAASC,GACxB,OAAOD,EAAQD,QAAQ,cAAc,SAAUG,EAAGC,GAChD,MAAO,MAAQF,GAAcE,GAAS,GAC9C,GACK,CAOD,SAASC,EAAGJ,EAASC,EAAcI,GACjC,OAAOC,OAAOP,EAAQC,EAASC,GAAeI,GAAS,GACxD,CAQD,SAASE,EAAOP,EAASQ,GACvB,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAWC,IAC7BT,EAAUA,EAAQD,QAAQ,aAAa,WACrC,MAAO,MAAQC,EAAU,GACnC,IAEM,OAAOA,EAAQD,QAAQ,YAAa,YACrC,CACD,IAAIW,EAEI,4GAFJA,EAIe,qCAJfA,EAQA,2NARAA,EAWA,uXAEJ,SAASC,EAAkBC,GACzB,MAAO,SAAWA,EAAMC,OAAOd,QAAQ,KAAM,KAAO,MACrD,CACD,IAAIe,EAA0BH,EAC5BD,GAEEK,EAAWT,OACbK,EACED,EACE,IACAA,EACA,IACAA,EACA,IACAA,IAGFM,EAAkBL,EACpBD,EACE,IACAA,EACA,IACAA,GAEAO,EAAwBN,EAC1BD,EACE,IACAA,EACA,IACAA,GAEAQ,EAAUX,EAAO,mCAAmCY,OAAQ,GAC5DC,EAAcb,EAAO,0BAA0BY,OAAQ,GACvDE,EAAO,qBAAqBF,OAC5BG,EAAcvB,EAAQ,qBAAqBoB,OAAQ,CAACE,EAAMH,IAC1DK,EAAaxB,EAAQ,mCAAmCoB,OAAQ,CAClEH,EACAM,IAEEE,EAAQ,mBAAmBL,OAC3BM,EAA6B1B,EAC/B,yCAAyCoB,OACzC,CAACI,EAAYC,IAEXE,EAAe3B,EACjB,2CAA2CoB,OAC3C,CAACD,EAASE,EAAaI,IAErBG,EAAQ5B,EAAQ,yBAAyBoB,OAAQ,CAACO,IAClDE,EAAiB7B,EACnB,mDAAmDoB,OACnD,CAACQ,EAAOJ,EAAYC,IAElBK,EAAa,CACfC,QAASf,EACTgB,YAAa,iBAIXC,EAAY,8CAA8Cb,OAC1Dc,EAAgB,wBAAwBd,OACxCe,EAAiB,kCAAkCf,OACvDrB,EAAMqC,UAAUtC,OAASC,EAAMqC,UAAUC,OAAO,QAAS,CACvDC,OAAQ,CACN,CACErC,QAASI,EAAG,kBAAkBe,OAAQ,CAACe,IACvCI,YAAY,EACZC,QAAQ,GAEV,CACEvC,QAASI,EAAG,mBAAmBe,OAAQ,CAACc,IACxCK,YAAY,EACZC,QAAQ,IAGZ,aAAc,CACZ,CAGEvC,QAASI,EAAG,qCAAqCe,OAAQ,CACvDI,IAEFe,YAAY,EACZE,OAAQX,GAEV,CAGE7B,QAASI,EAAG,wCAAwCe,OAAQ,CAC1DE,EACAO,IAEFU,YAAY,EACZE,OAAQX,GAEV,CAGE7B,QAASI,EAAG,4BAA4Be,OAAQ,CAACE,IACjDiB,YAAY,GAEd,CAIEtC,QAASI,EAAG,oBAAoBe,OAAQ,CACtCL,EACAQ,IAEFgB,YAAY,EACZE,OAAQX,GAEV,CAIE7B,QAASI,EAAG,yBAAyBe,OAAQ,CAACI,IAC9Ce,YAAY,EACZE,OAAQX,GAEV,CAGE7B,QAASI,EAAG,oBAAoBe,OAAQ,CAACE,IACzCiB,YAAY,GAEd,CAIEtC,QAASI,EAAG,mCAAmCe,OAAQ,CACrDM,IAEFa,YAAY,EACZE,OAAQX,GAEV,CAGE7B,QAASI,EACP,2EACGe,OACH,CAACS,EAAgBX,EAAuBI,IAE1CmB,OAAQX,IAGZC,QAASf,EAET0B,OACE,kJACFC,SAAU,uDACVX,YAAa,2BAEfjC,EAAMqC,UAAUQ,aAAa,SAAU,SAAU,CAC/CC,MAAO,CACL5C,QAAS,OACT6C,MAAO,cAGX/C,EAAMqC,UAAUQ,aAAa,SAAU,cAAe,CACpD,kBAAmB,CACjB3C,QAASI,EAAG,yBAAyBe,OAAQ,CAACE,IAC9CiB,YAAY,EACZO,MAAO,iBAGX/C,EAAMqC,UAAUQ,aAAa,SAAU,aAAc,CACnDG,UAAW,CAGT9C,QAASI,EACP,+DAA+De,OAC/D,CAACE,IAEHiB,YAAY,EACZE,OAAQ,CACNT,YAAa,OAGjB,kBAAmB,CAEjB/B,QAASI,EACP,kFACGe,OACH,CAACC,IAEHkB,YAAY,EACZO,MAAO,aACPL,OAAQX,GAEV,cAAe,CAIb7B,QAASI,EACP,+DAA+De,OAC/D,CAACS,EAAgBL,IAEnBiB,OAAQX,EACRgB,MAAO,cAET,yBAA0B,CAExB7C,QAASI,EAAG,8BAA8Be,OAAQ,CAACS,IACnDU,YAAY,EACZE,OAAQX,EACRgB,MAAO,cAQT,iBAAkB,CAEhB7C,QAASI,EAAG,yBAAyBe,OAAQ,CAACE,EAAMH,IACpDsB,OAAQ,CACNO,SAAU3C,EAAG,SAASe,OAAQ,CAACE,IAC/BH,QAAS,CACPlB,QAASM,OAAOY,GAChB2B,MAAO,aACPL,OAAQX,KAId,YAAa,CAIX7B,QAASI,EACP,kKACGe,OACH,CACEL,EACAQ,EACAD,EACAO,EACAb,EAASI,OACTC,EACA,kBAAkBD,SAGtBmB,YAAY,EACZE,OAAQ,CACN,mBAAoB,CAClBxC,QAASI,EAAG,+BAA+Be,OAAQ,CACjDG,EACAF,IAEFkB,YAAY,EACZC,QAAQ,EACRC,OAAQ1C,EAAMqC,UAAUtC,QAE1BiC,QAASf,EACT,aAAc,CACZf,QAASM,OAAOsB,GAChBW,QAAQ,EACRC,OAAQX,GAEVE,YAAa,UAGjBiB,aAAc,CACZhD,QAAS,gBACTsC,YAAY,EACZO,MAAO,WACPL,OAAQ,CAENS,UAAW,CACTjD,QACE,iGACFsC,YAAY,EACZO,MAAO,eAKf,IAAIK,EAA2BjB,EAAgB,IAAMD,EACjDmB,EAAkCpD,EACpC,iEAAiEoB,OACjE,CAAC+B,IAECE,EAAkB7C,EACpBR,EAAQ,+BAA+BoB,OAAQ,CAC7CgC,IAEF,GAEEE,EACF,wEACGlC,OACDmC,EAAOvD,EAAQ,0BAA0BoB,OAAQ,CACnDI,EACA6B,IAEFtD,EAAMqC,UAAUQ,aAAa,SAAU,aAAc,CACnDY,UAAW,CAGTvD,QAASI,EACP,6EACGe,OACH,CAACkC,EAAYC,IAEfhB,YAAY,EACZC,QAAQ,EACRC,OAAQ,CACNgB,OAAQ,CACNxD,QAASI,EAAG,iBAAiBe,OAAQ,CAACkC,IACtCR,MAAO,WAET,sBAAuB,CACrB7C,QAASI,EAAG,aAAae,OAAQ,CAACiC,IAClCZ,OAAQ1C,EAAMqC,UAAUtC,QAE1B,aAAc,CACZG,QAASM,OAAOiB,GAChBiB,OAAQ,CACNT,YAAa,OAGjBA,YAAa,WAInB,IAAI0B,EAAe,aAAatC,OAC5BuC,EAAsBnD,EACxBR,EAAQ,+BAA+BoB,OAAQ,CAC7CgC,IAEF,GAEEQ,EAAiB5D,EAAQ,qCAAqCoB,OAAQ,CACxEuC,EACAD,IAEEG,EAAsBrD,EACxBR,EACE,mEACGoB,OACH,CAAC+B,IAEH,GAEEW,EAAiB9D,EAAQ,qCAAqCoB,OAAQ,CACxEyC,EACAH,IAEF,SAASK,EAA0BC,EAAeC,GAChD,MAAO,CACLD,cAAe,CACb/D,QAASI,EAAG,6BAA6Be,OAAQ,CAAC4C,IAClDzB,YAAY,EACZE,OAAQ,CACN,gBAAiB,CACfxC,QAASI,EAAG,sCAAsCe,OAAQ,CACxD6C,EACAP,IAEFnB,YAAY,EACZE,OAAQ,CACNT,YAAa,OAGjBA,YAAa,UACbkC,WAAY,CACVjE,QAAS,UACT6C,MAAO,kBACPL,OAAQ1C,EAAMqC,UAAUtC,UAI9BwC,OAAQ,UAEX,CACDvC,EAAMqC,UAAUQ,aAAa,SAAU,SAAU,CAC/C,uBAAwB,CACtB,CACE3C,QAASI,EACP,4DAA4De,OAC5D,CAACwC,IAEHrB,YAAY,EACZC,QAAQ,EACRC,OAAQsB,EAA0BH,EAAgBD,IAEpD,CACE1D,QAASI,EAAG,4CAA4Ce,OAAQ,CAC9D0C,IAEFvB,YAAY,EACZC,QAAQ,EACRC,OAAQsB,EAA0BD,EAAgBD,KAGtDM,KAAM,CACJlE,QAASM,OAAO0B,GAChBO,QAAQ,KAGZzC,EAAMqC,UAAUgC,OAASrE,EAAMqC,UAAUiC,GAAKtE,EAAMqC,UAAUtC,MAC/D,CAxcA,CAwcEC,EACL,YA7cAuE,EAAiBxE,EACjBA,EAAOyE,YAAc,SACrBzE,EAAO0E,QAAU,CAAC,SAAU"}

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

@@ -1,2 +0,0 @@
-import{__require as e}from"./csharp.js";var s,r;function o(){if(r)return s;r=1;var o=e();function a(e){e.register(o),function(e){var s=/\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//.source,r=/@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source+"|"+/'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;function o(e,o){for(var a=0;a<o;a++)e=e.replace(/<self>/g,(function(){return"(?:"+e+")"}));return e.replace(/<self>/g,"[^\\s\\S]").replace(/<str>/g,"(?:"+r+")").replace(/<comment>/g,"(?:"+s+")")}var a=o(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source,2),c=o(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source,2),u=o(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source,2),t=o(/<(?:[^<>'"@/]|<str>|<comment>|<self>)*>/.source,2),n=/(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?/.source,i=/(?!\d)[^\s>\/=$<%]+/.source+n+/\s*\/?>/.source,l=/\B@?/.source+"(?:"+/<([a-zA-Z][\w:]*)/.source+n+/\s*>/.source+"(?:"+/[^<]/.source+"|"+/<\/?(?!\1\b)/.source+i+"|"+o(/<\1/.source+n+/\s*>/.source+"(?:"+/[^<]/.source+"|"+/<\/?(?!\1\b)/.source+i+"|<self>)*"+/<\/\1\s*>/.source,2)+")*"+/<\/\1\s*>/.source+"|"+/</.source+i+")";e.languages.cshtml=e.languages.extend("markup",{});var g={pattern:/\S[\s\S]*/,alias:"language-csharp",inside:e.languages.insertBefore("csharp","string",{html:{pattern:RegExp(l),greedy:!0,inside:e.languages.cshtml}},{csharp:e.languages.extend("csharp",{})})};e.languages.insertBefore("cshtml","prolog",{"razor-comment":{pattern:/@\*[\s\S]*?\*@/,greedy:!0,alias:"comment"},block:{pattern:RegExp(/(^|[^@])@/.source+"(?:"+[u,/(?:code|functions)\s*/.source+u,/(?:for|foreach|lock|switch|using|while)\s*/.source+a+/\s*/.source+u,/do\s*/.source+u+/\s*while\s*/.source+a+/(?:\s*;)?/.source,/try\s*/.source+u+/\s*catch\s*/.source+a+/\s*/.source+u+/\s*finally\s*/.source+u,/if\s*/.source+a+/\s*/.source+u+"(?:"+/\s*else/.source+"(?:"+/\s+if\s*/.source+a+")?"+/\s*/.source+u+")*"].join("|")+")"),lookbehind:!0,greedy:!0,inside:{keyword:/^@\w*/,csharp:g}},directive:{pattern:/^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,lookbehind:!0,greedy:!0,inside:{keyword:/^@\w+/,csharp:g}},value:{pattern:RegExp(/(^|[^@])@/.source+/(?:await\b\s*)?/.source+"(?:"+/\w+\b/.source+"|"+a+")(?:"+/[?!]?\.\w+\b/.source+"|"+a+"|"+c+"|"+t+a+")*"),lookbehind:!0,greedy:!0,alias:"variable",inside:{keyword:/^@/,csharp:g}},"delegate-operator":{pattern:/(^|[^@])@(?=<)/,lookbehind:!0,alias:"operator"}}),e.languages.razor=e.languages.cshtml}(e)}return s=a,a.displayName="cshtml",a.aliases=["razor"],s}export{o as __require};
-//# sourceMappingURL=cshtml.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"cshtml.js","sources":["../../../../node_modules/refractor/lang/cshtml.js"],"sourcesContent":["'use strict'\nvar refractorCsharp = require('./csharp.js')\nmodule.exports = cshtml\ncshtml.displayName = 'cshtml'\ncshtml.aliases = ['razor']\nfunction cshtml(Prism) {\n  Prism.register(refractorCsharp)\n  // Docs:\n  // https://docs.microsoft.com/en-us/aspnet/core/razor-pages/?view=aspnetcore-5.0&tabs=visual-studio\n  // https://docs.microsoft.com/en-us/aspnet/core/mvc/views/razor?view=aspnetcore-5.0\n  ;(function (Prism) {\n    var commentLike = /\\/(?![/*])|\\/\\/.*[\\r\\n]|\\/\\*[^*]*(?:\\*(?!\\/)[^*]*)*\\*\\//\n      .source\n    var stringLike =\n      /@(?!\")|\"(?:[^\\r\\n\\\\\"]|\\\\.)*\"|@\"(?:[^\\\\\"]|\"\"|\\\\[\\s\\S])*\"(?!\")/.source +\n      '|' +\n      /'(?:(?:[^\\r\\n'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'|(?=[^\\\\](?!')))/.source\n    /**\n     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.\n     *\n     * @param {string} pattern\n     * @param {number} depthLog2\n     * @returns {string}\n     */\n    function nested(pattern, depthLog2) {\n      for (var i = 0; i < depthLog2; i++) {\n        pattern = pattern.replace(/<self>/g, function () {\n          return '(?:' + pattern + ')'\n        })\n      }\n      return pattern\n        .replace(/<self>/g, '[^\\\\s\\\\S]')\n        .replace(/<str>/g, '(?:' + stringLike + ')')\n        .replace(/<comment>/g, '(?:' + commentLike + ')')\n    }\n    var round = nested(/\\((?:[^()'\"@/]|<str>|<comment>|<self>)*\\)/.source, 2)\n    var square = nested(/\\[(?:[^\\[\\]'\"@/]|<str>|<comment>|<self>)*\\]/.source, 2)\n    var curly = nested(/\\{(?:[^{}'\"@/]|<str>|<comment>|<self>)*\\}/.source, 2)\n    var angle = nested(/<(?:[^<>'\"@/]|<str>|<comment>|<self>)*>/.source, 2) // Note about the above bracket patterns:\n    // They all ignore HTML expressions that might be in the C# code. This is a problem because HTML (like strings and\n    // comments) is parsed differently. This is a huge problem because HTML might contain brackets and quotes which\n    // messes up the bracket and string counting implemented by the above patterns.\n    //\n    // This problem is not fixable because 1) HTML expression are highly context sensitive and very difficult to detect\n    // and 2) they require one capturing group at every nested level. See the `tagRegion` pattern to admire the\n    // complexity of an HTML expression.\n    //\n    // To somewhat alleviate the problem a bit, the patterns for characters (e.g. 'a') is very permissive, it also\n    // allows invalid characters to support HTML expressions like this: <p>That's it!</p>.\n    var tagAttrs =\n      /(?:\\s(?:\\s*[^\\s>\\/=]+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))|(?=[\\s/>])))+)?/\n        .source\n    var tagContent = /(?!\\d)[^\\s>\\/=$<%]+/.source + tagAttrs + /\\s*\\/?>/.source\n    var tagRegion =\n      /\\B@?/.source +\n      '(?:' +\n      /<([a-zA-Z][\\w:]*)/.source +\n      tagAttrs +\n      /\\s*>/.source +\n      '(?:' +\n      (/[^<]/.source +\n        '|' + // all tags that are not the start tag\n        // eslint-disable-next-line regexp/strict\n        /<\\/?(?!\\1\\b)/.source +\n        tagContent +\n        '|' + // nested start tag\n        nested(\n          // eslint-disable-next-line regexp/strict\n          /<\\1/.source +\n            tagAttrs +\n            /\\s*>/.source +\n            '(?:' +\n            (/[^<]/.source +\n              '|' + // all tags that are not the start tag\n              // eslint-disable-next-line regexp/strict\n              /<\\/?(?!\\1\\b)/.source +\n              tagContent +\n              '|' +\n              '<self>') +\n            ')*' + // eslint-disable-next-line regexp/strict\n            /<\\/\\1\\s*>/.source,\n          2\n        )) +\n      ')*' + // eslint-disable-next-line regexp/strict\n      /<\\/\\1\\s*>/.source +\n      '|' +\n      /</.source +\n      tagContent +\n      ')' // Now for the actual language definition(s):\n    //\n    // Razor as a language has 2 parts:\n    //  1) CSHTML: A markup-like language that has been extended with inline C# code expressions and blocks.\n    //  2) C#+HTML: A variant of C# that can contain CSHTML tags as expressions.\n    //\n    // In the below code, both CSHTML and C#+HTML will be create as separate language definitions that reference each\n    // other. However, only CSHTML will be exported via `Prism.languages`.\n    Prism.languages.cshtml = Prism.languages.extend('markup', {})\n    var csharpWithHtml = Prism.languages.insertBefore(\n      'csharp',\n      'string',\n      {\n        html: {\n          pattern: RegExp(tagRegion),\n          greedy: true,\n          inside: Prism.languages.cshtml\n        }\n      },\n      {\n        csharp: Prism.languages.extend('csharp', {})\n      }\n    )\n    var cs = {\n      pattern: /\\S[\\s\\S]*/,\n      alias: 'language-csharp',\n      inside: csharpWithHtml\n    }\n    Prism.languages.insertBefore('cshtml', 'prolog', {\n      'razor-comment': {\n        pattern: /@\\*[\\s\\S]*?\\*@/,\n        greedy: true,\n        alias: 'comment'\n      },\n      block: {\n        pattern: RegExp(\n          /(^|[^@])@/.source +\n            '(?:' +\n            [\n              // @{ ... }\n              curly, // @code{ ... }\n              /(?:code|functions)\\s*/.source + curly, // @for (...) { ... }\n              /(?:for|foreach|lock|switch|using|while)\\s*/.source +\n                round +\n                /\\s*/.source +\n                curly, // @do { ... } while (...);\n              /do\\s*/.source +\n                curly +\n                /\\s*while\\s*/.source +\n                round +\n                /(?:\\s*;)?/.source, // @try { ... } catch (...) { ... } finally { ... }\n              /try\\s*/.source +\n                curly +\n                /\\s*catch\\s*/.source +\n                round +\n                /\\s*/.source +\n                curly +\n                /\\s*finally\\s*/.source +\n                curly, // @if (...) {...} else if (...) {...} else {...}\n              /if\\s*/.source +\n                round +\n                /\\s*/.source +\n                curly +\n                '(?:' +\n                /\\s*else/.source +\n                '(?:' +\n                /\\s+if\\s*/.source +\n                round +\n                ')?' +\n                /\\s*/.source +\n                curly +\n                ')*'\n            ].join('|') +\n            ')'\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          keyword: /^@\\w*/,\n          csharp: cs\n        }\n      },\n      directive: {\n        pattern:\n          /^([ \\t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\\s).*/m,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          keyword: /^@\\w+/,\n          csharp: cs\n        }\n      },\n      value: {\n        pattern: RegExp(\n          /(^|[^@])@/.source +\n            /(?:await\\b\\s*)?/.source +\n            '(?:' +\n            /\\w+\\b/.source +\n            '|' +\n            round +\n            ')' +\n            '(?:' +\n            /[?!]?\\.\\w+\\b/.source +\n            '|' +\n            round +\n            '|' +\n            square +\n            '|' +\n            angle +\n            round +\n            ')*'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'variable',\n        inside: {\n          keyword: /^@/,\n          csharp: cs\n        }\n      },\n      'delegate-operator': {\n        pattern: /(^|[^@])@(?=<)/,\n        lookbehind: true,\n        alias: 'operator'\n      }\n    })\n    Prism.languages.razor = Prism.languages.cshtml\n  })(Prism)\n}\n"],"names":["refractorCsharp","require$$0","cshtml","Prism","register","commentLike","source","stringLike","nested","pattern","depthLog2","i","replace","round","square","curly","angle","tagAttrs","tagContent","tagRegion","languages","extend","cs","alias","inside","insertBefore","html","RegExp","greedy","csharp","block","join","lookbehind","keyword","directive","value","razor","cshtml_1","displayName","aliases"],"mappings":"+EACA,IAAIA,EAAkBC,IAItB,SAASC,EAAOC,GACdA,EAAMC,SAASJ,GAId,SAAWG,GACV,IAAIE,EAAc,0DACfC,OACCC,EACF,+DAA+DD,OAC/D,IACA,iEAAiEA,OAQnE,SAASE,EAAOC,EAASC,GACvB,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAWC,IAC7BF,EAAUA,EAAQG,QAAQ,WAAW,WACnC,MAAO,MAAQH,EAAU,GACnC,IAEM,OAAOA,EACJG,QAAQ,UAAW,aACnBA,QAAQ,SAAU,MAAQL,EAAa,KACvCK,QAAQ,aAAc,MAAQP,EAAc,IAChD,CACD,IAAIQ,EAAQL,EAAO,4CAA4CF,OAAQ,GACnEQ,EAASN,EAAO,8CAA8CF,OAAQ,GACtES,EAAQP,EAAO,4CAA4CF,OAAQ,GACnEU,EAAQR,EAAO,0CAA0CF,OAAQ,GAWjEW,EACF,yFACGX,OACDY,EAAa,sBAAsBZ,OAASW,EAAW,UAAUX,OACjEa,EACF,OAAOb,OACP,MACA,oBAAoBA,OACpBW,EACA,OAAOX,OACP,MACC,OAAOA,OACN,IAEA,eAAeA,OACfY,EACA,IACAV,EAEE,MAAMF,OACJW,EACA,OAAOX,OACP,MACC,OAAOA,OACN,IAEA,eAAeA,OACfY,EARJ,YAYE,YAAYZ,OACd,GAEJ,KACA,YAAYA,OACZ,IACA,IAAIA,OACJY,EACA,IAQFf,EAAMiB,UAAUlB,OAASC,EAAMiB,UAAUC,OAAO,SAAU,IAC1D,IAcIC,EAAK,CACPb,QAAS,YACTc,MAAO,kBACPC,OAjBmBrB,EAAMiB,UAAUK,aACnC,SACA,SACA,CACEC,KAAM,CACJjB,QAASkB,OAAOR,GAChBS,QAAQ,EACRJ,OAAQrB,EAAMiB,UAAUlB,SAG5B,CACE2B,OAAQ1B,EAAMiB,UAAUC,OAAO,SAAU,CAAA,MAQ7ClB,EAAMiB,UAAUK,aAAa,SAAU,SAAU,CAC/C,gBAAiB,CACfhB,QAAS,iBACTmB,QAAQ,EACRL,MAAO,WAETO,MAAO,CACLrB,QAASkB,OACP,YAAYrB,OACV,MACA,CAEES,EACA,wBAAwBT,OAASS,EACjC,6CAA6CT,OAC3CO,EACA,MAAMP,OACNS,EACF,QAAQT,OACNS,EACA,cAAcT,OACdO,EACA,YAAYP,OACd,SAASA,OACPS,EACA,cAAcT,OACdO,EACA,MAAMP,OACNS,EACA,gBAAgBT,OAChBS,EACF,QAAQT,OACNO,EACA,MAAMP,OACNS,EACA,MACA,UAAUT,OACV,MACA,WAAWA,OACXO,EACA,KACA,MAAMP,OACNS,EACA,MACFgB,KAAK,KACP,KAEJC,YAAY,EACZJ,QAAQ,EACRJ,OAAQ,CACNS,QAAS,QACTJ,OAAQP,IAGZY,UAAW,CACTzB,QACE,wKACFuB,YAAY,EACZJ,QAAQ,EACRJ,OAAQ,CACNS,QAAS,QACTJ,OAAQP,IAGZa,MAAO,CACL1B,QAASkB,OACP,YAAYrB,OACV,kBAAkBA,OAClB,MACA,QAAQA,OACR,IACAO,EALF,OAQE,eAAeP,OACf,IACAO,EACA,IACAC,EACA,IACAE,EACAH,EACA,MAEJmB,YAAY,EACZJ,QAAQ,EACRL,MAAO,WACPC,OAAQ,CACNS,QAAS,KACTJ,OAAQP,IAGZ,oBAAqB,CACnBb,QAAS,iBACTuB,YAAY,EACZT,MAAO,cAGXpB,EAAMiB,UAAUgB,MAAQjC,EAAMiB,UAAUlB,MACzC,CA7MA,CA6MEC,EACL,QAtNAkC,EAAiBnC,EACjBA,EAAOoC,YAAc,SACrBpC,EAAOqC,QAAU,CAAC"}

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

@@ -1,2 +0,0 @@
-var e,r;function o(){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}export{o as __require};
-//# 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":"mCAKA,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 @@
-var e,a;function n(){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}export{n as __require};
-//# 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":"mCAKA,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 @@
-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=[];export{s as default};
-//# 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":"AAEA,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 @@
-var a,n;function e(){if(n)return a;function e(a){a.languages.csv={value:/[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,punctuation:/,/}}return n=1,a=e,e.displayName="csv",e.aliases=[],a}export{e as __require};
-//# 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":"mCAKA,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 @@
-var e,E;function r(){if(E)return e;function r(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 E=1,e=r,r.displayName="cypher",r.aliases=[],e}export{r as __require};
-//# 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":"mCAKA,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 @@
-var e,r;function t(){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}export{t as __require};
-//# 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":"mCAKA,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 @@
-var e,a;function n(){if(a)return e;function n(e){!function(e){var a=[/\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/],n=/(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source,s={pattern:RegExp(n+/[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(n+/[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source),lookbehind:!0,inside:s.inside}],keyword:a,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:a,punctuation:/[<>(),.:]/,operator:/[?&|]/}}})}(e)}return a=1,e=n,n.displayName="dart",n.aliases=[],e}export{n as __require};
-//# 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":"mCAKA,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 @@
-var e,t;function a(){if(t)return e;function a(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=a,a.displayName="dataweave",a.aliases=[],e}export{a as __require};
-//# 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":"mCAKA,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 @@
-var E,T;function A(){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}export{A as __require};
-//# 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":"mCAKA,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 @@
-var e,n;function a(){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}export{a as __require};
-//# 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":"mCAKA,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 @@
-var e,n;function a(){if(n)return e;function a(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(a){var i=n[a],r=[];/^\w+$/.test(a)||r.push(/\w+/.exec(a)[0]),"diff"===a&&r.push("bold"),e.languages.diff[a]={pattern:RegExp("^(?:["+i+"].*(?:\r\n?|\n|(?![\\s\\S])))+","m"),alias:r,inside:{line:{pattern:/(.)(?=[\s\S]).*(?:\r\n?|\n)?/,lookbehind:!0},prefix:{pattern:/[\s\S]/,alias:/\w+/.exec(a)[0]}}}})),Object.defineProperty(e.languages.diff,"PREFIXES",{value:n})}(e)}return n=1,e=a,a.displayName="diff",a.aliases=[],e}export{a as __require};
-//# 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":"mCAKA,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 @@
-import{__require as e}from"./markup-templating.js";var n,a;function o(){if(a)return n;a=1;var o=e();function t(e){e.register(o),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,a=e.languages["markup-templating"];e.hooks.add("before-tokenize",(function(e){a.buildPlaceholders(e,"django",n)})),e.hooks.add("after-tokenize",(function(e){a.tokenizePlaceholders(e,"django")})),e.languages.jinja2=e.languages.django,e.hooks.add("before-tokenize",(function(e){a.buildPlaceholders(e,"jinja2",n)})),e.hooks.add("after-tokenize",(function(e){a.tokenizePlaceholders(e,"jinja2")}))}(e)}return n=t,t.displayName="django",t.aliases=["jinja2"],n}export{o as __require};
-//# 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":"0FACA,IAAIA,EAA4BC,IAIhC,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 @@
-var e,n;function S(){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}export{S as __require};
-//# 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":"mCAKA,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 @@
-var e,r;function n(){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},a={pattern:/(^[ \t]*)#.*/m,lookbehind:!0,greedy:!0};function s(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:s(/(^(?: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:s(/(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\b/.source,"i"),lookbehind:!0,greedy:!0},{pattern:s(/(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\]+<SP>)AS/.source,"i"),lookbehind:!0,greedy:!0},{pattern:s(/(^ONBUILD<SP>)\w+/.source,"i"),lookbehind:!0,greedy:!0},{pattern:/^\w+/,greedy:!0}],comment:a,string:i,variable:/\$(?:\w+|\{[^{}"'\\]*\})/,operator:/\\$/m}},comment:a},e.languages.dockerfile=e.languages.docker}(e)}return r=1,e=n,n.displayName="docker",n.aliases=["dockerfile"],e}export{n as __require};
-//# 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":"mCAKA,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 @@
-var e,a;function n(){if(a)return e;function n(e){!function(e){var a="(?:"+[/[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 r(e,n){return RegExp(e.replace(/<ID>/g,(function(){return a})),n)}e.languages.dot={comment:{pattern:/\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,greedy:!0},"graph-name":{pattern:r(/(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,"i"),lookbehind:!0,greedy:!0,alias:"class-name",inside:n},"attr-value":{pattern:r(/(=[ \t\r\n]*)<ID>/.source),lookbehind:!0,greedy:!0,inside:n},"attr-name":{pattern:r(/([\[;, \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:r(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),lookbehind:!0,greedy:!0,inside:n},operator:/[=:]|-[->]/,punctuation:/[\[\]{};,]/},e.languages.gv=e.languages.dot}(e)}return a=1,e=n,n.displayName="dot",n.aliases=["gv"],e}export{n as __require};
-//# 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":"mCAKA,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 @@
-var e,a;function n(){if(a)return e;function n(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 a=1,e=n,n.displayName="ebnf",n.aliases=[],e}export{n as __require};
-//# 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":"mCAKA,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 @@
-var e,t;function a(){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}export{a as __require};
-//# 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":"mCAKA,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 @@
-var e,r;function a(){if(r)return e;function a(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=a,a.displayName="eiffel",a.aliases=[],e}export{a as __require};
-//# 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":"mCAKA,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"}