@kong-ui-public/document-viewer 0.10.20 → 0.10.22

package/dist/prism-factor.min-0ea41495.js

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

package/dist/prism-false.min-d1e3e399.js

@@ -1,3 +0,0 @@
-(function(a) {
-  a.languages.false = { comment: { pattern: /\{[^}]*\}/ }, string: { pattern: /"[^"]*"/, greedy: !0 }, "character-code": { pattern: /'(?:[^\r]|\r\n?)/, alias: "number" }, "assembler-code": { pattern: /\d+`/, alias: "important" }, number: /\d+/, operator: /[-!#$%&'*+,./:;=>?@\\^_`|~ßø]/, punctuation: /\[|\]/, variable: /[a-z]/, "non-standard": { pattern: /[()<BDO®]/, alias: "bold" } };
-})(Prism);

package/dist/prism-firestore-security-rules.min-2230fbf2.js

@@ -1 +0,0 @@
-Prism.languages["firestore-security-rules"] = Prism.languages.extend("clike", { comment: /\/\/.*/, keyword: /\b(?:allow|function|if|match|null|return|rules_version|service)\b/, operator: /&&|\|\||[<>!=]=?|[-+*/%]|\b(?:in|is)\b/ }), delete Prism.languages["firestore-security-rules"]["class-name"], Prism.languages.insertBefore("firestore-security-rules", "keyword", { path: { pattern: /(^|[\s(),])(?:\/(?:[\w\xA0-\uFFFF]+|\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)))+/, lookbehind: !0, greedy: !0, inside: { variable: { pattern: /\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)/, inside: { operator: /=/, keyword: /\*\*/, punctuation: /[.$(){}]/ } }, punctuation: /\// } }, method: { pattern: /(\ballow\s+)[a-z]+(?:\s*,\s*[a-z]+)*(?=\s*[:;])/, lookbehind: !0, alias: "builtin", inside: { punctuation: /,/ } } });

package/dist/prism-flow.min-4379ef1a.js

@@ -1,3 +0,0 @@
-(function(e) {
-  e.languages.flow = e.languages.extend("javascript", {}), e.languages.insertBefore("flow", "keyword", { type: [{ pattern: /\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|[Ss]ymbol|any|mixed|null|void)\b/, alias: "class-name" }] }), e.languages.flow["function-variable"].pattern = /(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i, delete e.languages.flow.parameter, e.languages.insertBefore("flow", "operator", { "flow-punctuation": { pattern: /\{\||\|\}/, alias: "punctuation" } }), Array.isArray(e.languages.flow.keyword) || (e.languages.flow.keyword = [e.languages.flow.keyword]), e.languages.flow.keyword.unshift({ pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/, lookbehind: !0 }, { pattern: /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/, lookbehind: !0 });
-})(Prism);

package/dist/prism-fortran.min-32dee11f.js

@@ -1 +0,0 @@
-Prism.languages.fortran = { "quoted-number": { pattern: /[BOZ](['"])[A-F0-9]+\1/i, alias: "number" }, string: { pattern: /(?:\b\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:[ \t]*!.*(?:\r\n?|\n)|(?![ \t]*!))|(?!\1).)*(?:\1|&)/, inside: { comment: { pattern: /(&(?:\r\n?|\n)\s*)!.*/, lookbehind: !0 } } }, comment: { pattern: /!.*/, greedy: !0 }, boolean: /\.(?:FALSE|TRUE)\.(?:_\w+)?/i, number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?/i, keyword: [/\b(?:CHARACTER|COMPLEX|DOUBLE ?PRECISION|INTEGER|LOGICAL|REAL)\b/i, /\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE)\b/i, /\b(?:ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE)\b/i, /\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEIF|ELSEWHERE|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i], operator: [/\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.[A-Z]+\./i, { pattern: /(^|(?!\().)\/(?!\))/, lookbehind: !0 }], punctuation: /\(\/|\/\)|[(),;:&]/ };

package/dist/prism-fsharp.min-e4eccb74.js

@@ -1 +0,0 @@
-Prism.languages.fsharp = Prism.languages.extend("clike", { comment: [{ pattern: /(^|[^\\])\(\*(?!\))[\s\S]*?\*\)/, lookbehind: !0, greedy: !0 }, { pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0 }], string: { pattern: /(?:"""[\s\S]*?"""|@"(?:""|[^"])*"|"(?:\\[\s\S]|[^\\"])*")B?/, greedy: !0 }, "class-name": { pattern: /(\b(?:exception|inherit|interface|new|of|type)\s+|\w\s*:\s*|\s:\??>\s*)[.\w]+\b(?:\s*(?:->|\*)\s*[.\w]+\b)*(?!\s*[:.])/, lookbehind: !0, inside: { operator: /->|\*/, punctuation: /\./ } }, keyword: /\b(?:let|return|use|yield)(?:!\B|\b)|\b(?:abstract|and|as|asr|assert|atomic|base|begin|break|checked|class|component|const|constraint|constructor|continue|default|delegate|do|done|downcast|downto|eager|elif|else|end|event|exception|extern|external|false|finally|fixed|for|fun|function|functor|global|if|in|include|inherit|inline|interface|internal|land|lazy|lor|lsl|lsr|lxor|match|member|method|mixin|mod|module|mutable|namespace|new|not|null|object|of|open|or|override|parallel|private|process|protected|public|pure|rec|sealed|select|sig|static|struct|tailcall|then|to|trait|true|try|type|upcast|val|virtual|void|volatile|when|while|with)\b/, number: [/\b0x[\da-fA-F]+(?:LF|lf|un)?\b/, /\b0b[01]+(?:uy|y)?\b/, /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[fm]|e[+-]?\d+)?\b/i, /\b\d+(?:[IlLsy]|UL|u[lsy]?)?\b/], operator: /([<>~&^])\1\1|([*.:<>&])\2|<-|->|[!=:]=|<?\|{1,3}>?|\??(?:<=|>=|<>|[-+*/%=<>])\??|[!?^&]|~[+~-]|:>|:\?>?/ }), Prism.languages.insertBefore("fsharp", "keyword", { preprocessor: { pattern: /(^[\t ]*)#.*/m, lookbehind: !0, alias: "property", inside: { directive: { pattern: /(^#)\b(?:else|endif|if|light|line|nowarn)\b/, lookbehind: !0, alias: "keyword" } } } }), Prism.languages.insertBefore("fsharp", "punctuation", { "computation-expression": { pattern: /\b[_a-z]\w*(?=\s*\{)/i, alias: "keyword" } }), Prism.languages.insertBefore("fsharp", "string", { annotation: { pattern: /\[<.+?>\]/, greedy: !0, inside: { punctuation: /^\[<|>\]$/, "class-name": { pattern: /^\w+$|(^|;\s*)[A-Z]\w*(?=\()/, lookbehind: !0 }, "annotation-content": { pattern: /[\s\S]+/, inside: Prism.languages.fsharp } } }, char: { pattern: /'(?:[^\\']|\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8}))'B?/, greedy: !0 } });

package/dist/prism-ftl.min-cf603b01.js

@@ -1,20 +0,0 @@
-(function(n) {
-  for (var e = `[^<()"']|\\((?:<expr>)*\\)|<(?!#--)|<#--(?:[^-]|-(?!->))*-->|"(?:[^\\\\"]|\\\\.)*"|'(?:[^\\\\']|\\\\.)*'`, r = 0; r < 2; r++)
-    e = e.replace(/<expr>/g, function() {
-      return e;
-    });
-  e = e.replace(/<expr>/g, "[^\\s\\S]");
-  var t = { comment: /<#--[\s\S]*?-->/, string: [{ pattern: /\br("|')(?:(?!\1)[^\\]|\\.)*\1/, greedy: !0 }, { pattern: RegExp(`("|')(?:(?!\\1|\\$\\{)[^\\\\]|\\\\.|\\$\\{(?:(?!\\})(?:<expr>))*\\})*\\1`.replace(/<expr>/g, function() {
-    return e;
-  })), greedy: !0, inside: { interpolation: { pattern: RegExp("((?:^|[^\\\\])(?:\\\\\\\\)*)\\$\\{(?:(?!\\})(?:<expr>))*\\}".replace(/<expr>/g, function() {
-    return e;
-  })), lookbehind: !0, inside: { "interpolation-punctuation": { pattern: /^\$\{|\}$/, alias: "punctuation" }, rest: null } } } }], keyword: /\b(?:as)\b/, boolean: /\b(?:false|true)\b/, "builtin-function": { pattern: /((?:^|[^?])\?\s*)\w+/, lookbehind: !0, alias: "function" }, function: /\b\w+(?=\s*\()/, number: /\b\d+(?:\.\d+)?\b/, operator: /\.\.[<*!]?|->|--|\+\+|&&|\|\||\?{1,2}|[-+*/%!=<>]=?|\b(?:gt|gte|lt|lte)\b/, punctuation: /[,;.:()[\]{}]/ };
-  t.string[1].inside.interpolation.inside.rest = t, n.languages.ftl = { "ftl-comment": { pattern: /^<#--[\s\S]*/, alias: "comment" }, "ftl-directive": { pattern: /^<[\s\S]+>$/, inside: { directive: { pattern: /(^<\/?)[#@][a-z]\w*/i, lookbehind: !0, alias: "keyword" }, punctuation: /^<\/?|\/?>$/, content: { pattern: /\s*\S[\s\S]*/, alias: "ftl", inside: t } } }, "ftl-interpolation": { pattern: /^\$\{[\s\S]*\}$/, inside: { punctuation: /^\$\{|\}$/, content: { pattern: /\s*\S[\s\S]*/, alias: "ftl", inside: t } } } }, n.hooks.add("before-tokenize", function(i) {
-    var a = RegExp("<#--[^]*?-->|</?[#@][a-zA-Z](?:<expr>)*?>|\\$\\{(?:<expr>)*?\\}".replace(/<expr>/g, function() {
-      return e;
-    }), "gi");
-    n.languages["markup-templating"].buildPlaceholders(i, "ftl", a);
-  }), n.hooks.add("after-tokenize", function(i) {
-    n.languages["markup-templating"].tokenizePlaceholders(i, "ftl");
-  });
-})(Prism);

package/dist/prism-gap.min-3eca85c2.js

@@ -1 +0,0 @@
-Prism.languages.gap = { shell: { pattern: /^gap>[\s\S]*?(?=^gap>|$(?![\s\S]))/m, greedy: !0, inside: { gap: { pattern: /^(gap>).+(?:(?:\r(?:\n|(?!\n))|\n)>.*)*/, lookbehind: !0, inside: null }, punctuation: /^gap>/ } }, comment: { pattern: /#.*/, greedy: !0 }, string: { pattern: /(^|[^\\'"])(?:'(?:[^\r\n\\']|\\.){1,10}'|"(?:[^\r\n\\"]|\\.)*"(?!")|"""[\s\S]*?""")/, lookbehind: !0, greedy: !0, inside: { continuation: { pattern: /([\r\n])>/, lookbehind: !0, alias: "punctuation" } } }, keyword: /\b(?:Assert|Info|IsBound|QUIT|TryNextMethod|Unbind|and|atomic|break|continue|do|elif|else|end|fi|for|function|if|in|local|mod|not|od|or|quit|readonly|readwrite|rec|repeat|return|then|until|while)\b/, boolean: /\b(?:false|true)\b/, function: /\b[a-z_]\w*(?=\s*\()/i, number: { pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/, lookbehind: !0 }, continuation: { pattern: /([\r\n])>/, lookbehind: !0, alias: "punctuation" }, operator: /->|[-+*/^~=!]|<>|[<>]=?|:=|\.\./, punctuation: /[()[\]{},;.:]/ }, Prism.languages.gap.shell.inside.gap.inside = Prism.languages.gap;

package/dist/prism-gcode.min-7be81032.js

@@ -1 +0,0 @@
-Prism.languages.gcode = { comment: /;.*|\B\(.*?\)\B/, string: { pattern: /"(?:""|[^"])*"/, greedy: !0 }, keyword: /\b[GM]\d+(?:\.\d+)?\b/, property: /\b[A-Z]/, checksum: { pattern: /(\*)\d+/, lookbehind: !0, alias: "number" }, punctuation: /[:*]/ };

package/dist/prism-gdscript.min-a7d78975.js

@@ -1 +0,0 @@
-Prism.languages.gdscript = { comment: /#.*/, string: { pattern: /@?(?:("|')(?:(?!\1)[^\n\\]|\\[\s\S])*\1(?!"|')|"""(?:[^\\]|\\[\s\S])*?""")/, greedy: !0 }, "class-name": { pattern: /(^(?:class|class_name|extends)[ \t]+|^export\([ \t]*|\bas[ \t]+|(?:\b(?:const|var)[ \t]|[,(])[ \t]*\w+[ \t]*:[ \t]*|->[ \t]*)[a-zA-Z_]\w*/m, lookbehind: !0 }, keyword: /\b(?:and|as|assert|break|breakpoint|class|class_name|const|continue|elif|else|enum|export|extends|for|func|if|in|is|master|mastersync|match|not|null|onready|or|pass|preload|puppet|puppetsync|remote|remotesync|return|self|setget|signal|static|tool|var|while|yield)\b/, function: /\b[a-z_]\w*(?=[ \t]*\()/i, variable: /\$\w+/, number: [/\b0b[01_]+\b|\b0x[\da-fA-F_]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.[\d_]+)(?:e[+-]?[\d_]+)?\b/, /\b(?:INF|NAN|PI|TAU)\b/], constant: /\b[A-Z][A-Z_\d]*\b/, boolean: /\b(?:false|true)\b/, operator: /->|:=|&&|\|\||<<|>>|[-+*/%&|!<>=]=?|[~^]/, punctuation: /[.:,;()[\]{}]/ };

package/dist/prism-gedcom.min-364aaac3.js

@@ -1 +0,0 @@
-Prism.languages.gedcom = { "line-value": { pattern: /(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?\w+ ).+/m, lookbehind: !0, inside: { pointer: { pattern: /^@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@$/, alias: "variable" } } }, record: { pattern: /(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?)\w+/m, lookbehind: !0, alias: "tag" }, level: { pattern: /(^[\t ]*)\d+/m, lookbehind: !0, alias: "number" }, pointer: { pattern: /@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@/, alias: "variable" } };

package/dist/prism-gettext.min-d6e41f3f.js

@@ -1 +0,0 @@
-Prism.languages.gettext = { comment: [{ pattern: /# .*/, greedy: !0, alias: "translator-comment" }, { pattern: /#\..*/, greedy: !0, alias: "extracted-comment" }, { pattern: /#:.*/, greedy: !0, alias: "reference-comment" }, { pattern: /#,.*/, greedy: !0, alias: "flag-comment" }, { pattern: /#\|.*/, greedy: !0, alias: "previously-untranslated-comment" }, { pattern: /#.*/, greedy: !0 }], string: { pattern: /(^|[^\\])"(?:[^"\\]|\\.)*"/, lookbehind: !0, greedy: !0 }, keyword: /^msg(?:ctxt|id|id_plural|str)\b/m, number: /\b\d+\b/, punctuation: /[\[\]]/ }, Prism.languages.po = Prism.languages.gettext;

package/dist/prism-gherkin.min-b8bce925.js

@@ -1,5 +0,0 @@
-(function(n) {
-  var a = `(?:\r?
-|\r)[ 	]*\\|.+\\|(?:(?!\\|).)*`;
-  n.languages.gherkin = { pystring: { pattern: /("""|''')[\s\S]+?\1/, alias: "string" }, comment: { pattern: /(^[ \t]*)#.*/m, lookbehind: !0 }, tag: { pattern: /(^[ \t]*)@\S*/m, lookbehind: !0 }, feature: { pattern: /((?:^|\r?\n|\r)[ \t]*)(?:Ability|Ahoy matey!|Arwedd|Aspekt|Besigheid Behoefte|Business Need|Caracteristica|Característica|Egenskab|Egenskap|Eiginleiki|Feature|Fīča|Fitur|Fonctionnalité|Fonksyonalite|Funcionalidade|Funcionalitat|Functionalitate|Funcţionalitate|Funcționalitate|Functionaliteit|Fungsi|Funkcia|Funkcija|Funkcionalitāte|Funkcionalnost|Funkcja|Funksie|Funktionalität|Funktionalitéit|Funzionalità|Hwaet|Hwæt|Jellemző|Karakteristik|Lastnost|Mak|Mogucnost|laH|Mogućnost|Moznosti|Možnosti|OH HAI|Omadus|Ominaisuus|Osobina|Özellik|Potrzeba biznesowa|perbogh|poQbogh malja'|Požadavek|Požiadavka|Pretty much|Qap|Qu'meH 'ut|Savybė|Tính năng|Trajto|Vermoë|Vlastnosť|Właściwość|Značilnost|Δυνατότητα|Λειτουργία|Могућност|Мөмкинлек|Особина|Свойство|Үзенчәлеклелек|Функционал|Функционалност|Функция|Функціонал|תכונה|خاصية|خصوصیت|صلاحیت|کاروبار کی ضرورت|وِیژگی|रूप लेख|ਖਾਸੀਅਤ|ਨਕਸ਼ ਨੁਹਾਰ|ਮੁਹਾਂਦਰਾ|గుణము|ಹೆಚ್ಚಳ|ความต้องการทางธุรกิจ|ความสามารถ|โครงหลัก|기능|フィーチャ|功能|機能):(?:[^:\r\n]+(?:\r?\n|\r|$))*/, lookbehind: !0, inside: { important: { pattern: /(:)[^\r\n]+/, lookbehind: !0 }, keyword: /[^:\r\n]+:/ } }, scenario: { pattern: /(^[ \t]*)(?:Abstract Scenario|Abstrakt Scenario|Achtergrond|Aer|Ær|Agtergrond|All y'all|Antecedentes|Antecedents|Atburðarás|Atburðarásir|Awww, look mate|B4|Background|Baggrund|Bakgrund|Bakgrunn|Bakgrunnur|Beispiele|Beispiller|Bối cảnh|Cefndir|Cenario|Cenário|Cenario de Fundo|Cenário de Fundo|Cenarios|Cenários|Contesto|Context|Contexte|Contexto|Conto|Contoh|Contone|Dæmi|Dasar|Dead men tell no tales|Delineacao do Cenario|Delineação do Cenário|Dis is what went down|Dữ liệu|Dyagram Senaryo|Dyagram senaryo|Egzanp|Ejemplos|Eksempler|Ekzemploj|Enghreifftiau|Esbozo do escenario|Escenari|Escenario|Esempi|Esquema de l'escenari|Esquema del escenario|Esquema do Cenario|Esquema do Cenário|EXAMPLZ|Examples|Exempel|Exemple|Exemples|Exemplos|First off|Fono|Forgatókönyv|Forgatókönyv vázlat|Fundo|Geçmiş|Grundlage|Hannergrond|ghantoH|Háttér|Heave to|Istorik|Juhtumid|Keadaan|Khung kịch bản|Khung tình huống|Kịch bản|Koncept|Konsep skenario|Kontèks|Kontekst|Kontekstas|Konteksts|Kontext|Konturo de la scenaro|Latar Belakang|lut chovnatlh|lut|lutmey|Lýsing Atburðarásar|Lýsing Dæma|MISHUN SRSLY|MISHUN|Menggariskan Senario|mo'|Náčrt Scenára|Náčrt Scénáře|Náčrt Scenáru|Oris scenarija|Örnekler|Osnova|Osnova Scenára|Osnova scénáře|Osnutek|Ozadje|Paraugs|Pavyzdžiai|Példák|Piemēri|Plan du scénario|Plan du Scénario|Plan Senaryo|Plan senaryo|Plang vum Szenario|Pozadí|Pozadie|Pozadina|Príklady|Příklady|Primer|Primeri|Primjeri|Przykłady|Raamstsenaarium|Reckon it's like|Rerefons|Scenár|Scénář|Scenarie|Scenarij|Scenarijai|Scenarijaus šablonas|Scenariji|Scenārijs|Scenārijs pēc parauga|Scenarijus|Scenario|Scénario|Scenario Amlinellol|Scenario Outline|Scenario Template|Scenariomal|Scenariomall|Scenarios|Scenariu|Scenariusz|Scenaro|Schema dello scenario|Se ðe|Se the|Se þe|Senario|Senaryo Deskripsyon|Senaryo deskripsyon|Senaryo|Senaryo taslağı|Shiver me timbers|Situācija|Situai|Situasie Uiteensetting|Situasie|Skenario konsep|Skenario|Skica|Structura scenariu|Structură scenariu|Struktura scenarija|Stsenaarium|Swa hwaer swa|Swa|Swa hwær swa|Szablon scenariusza|Szenario|Szenariogrundriss|Tapaukset|Tapaus|Tapausaihio|Taust|Tausta|Template Keadaan|Template Senario|Template Situai|The thing of it is|Tình huống|Variantai|Voorbeelde|Voorbeelden|Wharrimean is|Yo-ho-ho|You'll wanna|Założenia|Παραδείγματα|Περιγραφή Σεναρίου|Σενάρια|Σενάριο|Υπόβαθρο|Кереш|Контекст|Концепт|Мисаллар|Мисоллар|Основа|Передумова|Позадина|Предистория|Предыстория|Приклади|Пример|Примери|Примеры|Рамка на сценарий|Скица|Структура сценарија|Структура сценария|Структура сценарію|Сценарий|Сценарий структураси|Сценарийның төзелеше|Сценарији|Сценарио|Сценарій|Тарих|Үрнәкләр|דוגמאות|רקע|תבנית תרחיש|תרחיש|الخلفية|الگوی سناریو|امثلة|پس منظر|زمینه|سناریو|سيناريو|سيناريو مخطط|مثالیں|منظر نامے کا خاکہ|منظرنامہ|نمونه ها|उदाहरण|परिदृश्य|परिदृश्य रूपरेखा|पृष्ठभूमि|ਉਦਾਹਰਨਾਂ|ਪਟਕਥਾ|ਪਟਕਥਾ ਢਾਂਚਾ|ਪਟਕਥਾ ਰੂਪ ਰੇਖਾ|ਪਿਛੋਕੜ|ఉదాహరణలు|కథనం|నేపథ్యం|సన్నివేశం|ಉದಾಹರಣೆಗಳು|ಕಥಾಸಾರಾಂಶ|ವಿವರಣೆ|ಹಿನ್ನೆಲೆ|โครงสร้างของเหตุการณ์|ชุดของตัวอย่าง|ชุดของเหตุการณ์|แนวคิด|สรุปเหตุการณ์|เหตุการณ์|배경|시나리오|시나리오 개요|예|サンプル|シナリオ|シナリオアウトライン|シナリオテンプレ|シナリオテンプレート|テンプレ|例|例子|剧本|剧本大纲|劇本|劇本大綱|场景|场景大纲|場景|場景大綱|背景):[^:\r\n]*/m, lookbehind: !0, inside: { important: { pattern: /(:)[^\r\n]*/, lookbehind: !0 }, keyword: /[^:\r\n]+:/ } }, "table-body": { pattern: RegExp("(" + a + ")(?:" + a + ")+"), lookbehind: !0, inside: { outline: { pattern: /<[^>]+>/, alias: "variable" }, td: { pattern: /\s*[^\s|][^|]*/, alias: "string" }, punctuation: /\|/ } }, "table-head": { pattern: RegExp(a), inside: { th: { pattern: /\s*[^\s|][^|]*/, alias: "variable" }, punctuation: /\|/ } }, atrule: { pattern: /(^[ \t]+)(?:'a|'ach|'ej|7|a|A také|A taktiež|A tiež|A zároveň|Aber|Ac|Adott|Akkor|Ak|Aleshores|Ale|Ali|Allora|Alors|Als|Ama|Amennyiben|Amikor|Ampak|an|AN|Ananging|And y'all|And|Angenommen|Anrhegedig a|An|Apabila|Atès|Atesa|Atunci|Avast!|Aye|A|awer|Bagi|Banjur|Bet|Biết|Blimey!|Buh|But at the end of the day I reckon|But y'all|But|BUT|Cal|Când|Cand|Cando|Ce|Cuando|Če|Ða ðe|Ða|Dadas|Dada|Dados|Dado|DaH ghu' bejlu'|dann|Dann|Dano|Dan|Dar|Dat fiind|Data|Date fiind|Date|Dati fiind|Dati|Daţi fiind|Dați fiind|DEN|Dato|De|Den youse gotta|Dengan|Diberi|Diyelim ki|Donada|Donat|Donitaĵo|Do|Dun|Duota|Ðurh|Eeldades|Ef|Eğer ki|Entao|Então|Entón|E|En|Entonces|Epi|És|Etant donnée|Etant donné|Et|Étant données|Étant donnée|Étant donné|Etant données|Etant donnés|Étant donnés|Fakat|Gangway!|Gdy|Gegeben seien|Gegeben sei|Gegeven|Gegewe|ghu' noblu'|Gitt|Given y'all|Given|Givet|Givun|Ha|Cho|I CAN HAZ|In|Ir|It's just unbelievable|I|Ja|Jeśli|Jeżeli|Kad|Kada|Kadar|Kai|Kaj|Když|Keď|Kemudian|Ketika|Khi|Kiedy|Ko|Kuid|Kui|Kun|Lan|latlh|Le sa a|Let go and haul|Le|Lè sa a|Lè|Logo|Lorsqu'<|Lorsque|mä|Maar|Mais|Mając|Ma|Majd|Maka|Manawa|Mas|Men|Menawa|Mutta|Nalika|Nalikaning|Nanging|Når|När|Nato|Nhưng|Niin|Njuk|O zaman|Och|Og|Oletetaan|Ond|Onda|Oraz|Pak|Pero|Però|Podano|Pokiaľ|Pokud|Potem|Potom|Privzeto|Pryd|Quan|Quand|Quando|qaSDI'|Så|Sed|Se|Siis|Sipoze ke|Sipoze Ke|Sipoze|Si|Şi|Și|Soit|Stel|Tada|Tad|Takrat|Tak|Tapi|Ter|Tetapi|Tha the|Tha|Then y'all|Then|Thì|Thurh|Toda|Too right|Un|Und|ugeholl|Và|vaj|Vendar|Ve|wann|Wanneer|WEN|Wenn|When y'all|When|Wtedy|Wun|Y'know|Yeah nah|Yna|Youse know like when|Youse know when youse got|Y|Za predpokladu|Za předpokladu|Zadan|Zadani|Zadano|Zadate|Zadato|Zakładając|Zaradi|Zatati|Þa þe|Þa|Þá|Þegar|Þurh|Αλλά|Δεδομένου|Και|Όταν|Τότε|А також|Агар|Але|Али|Аммо|А|Әгәр|Әйтик|Әмма|Бирок|Ва|Вә|Дадено|Дано|Допустим|Если|Задате|Задати|Задато|И|І|К тому же|Када|Кад|Когато|Когда|Коли|Ләкин|Лекин|Нәтиҗәдә|Нехай|Но|Онда|Припустимо, що|Припустимо|Пусть|Также|Та|Тогда|Тоді|То|Унда|Һәм|Якщо|אבל|אזי|אז|בהינתן|וגם|כאשר|آنگاه|اذاً|اگر|اما|اور|با فرض|بالفرض|بفرض|پھر|تب|ثم|جب|عندما|فرض کیا|لكن|لیکن|متى|هنگامی|و|अगर|और|कदा|किन्तु|चूंकि|जब|तथा|तदा|तब|परन्तु|पर|यदि|ਅਤੇ|ਜਦੋਂ|ਜਿਵੇਂ ਕਿ|ਜੇਕਰ|ਤਦ|ਪਰ|అప్పుడు|ఈ పరిస్థితిలో|కాని|చెప్పబడినది|మరియు|ಆದರೆ|ನಂತರ|ನೀಡಿದ|ಮತ್ತು|ಸ್ಥಿತಿಯನ್ನು|กำหนดให้|ดังนั้น|แต่|เมื่อ|และ|그러면<|그리고<|단<|만약<|만일<|먼저<|조건<|하지만<|かつ<|しかし<|ただし<|ならば<|もし<|並且<|但し<|但是<|假如<|假定<|假設<|假设<|前提<|同时<|同時<|并且<|当<|當<|而且<|那么<|那麼<)(?=[ \t])/m, lookbehind: !0 }, string: { pattern: /"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'/, inside: { outline: { pattern: /<[^>]+>/, alias: "variable" } } }, outline: { pattern: /<[^>]+>/, alias: "variable" } };
-})(Prism);

package/dist/prism-git.min-d984e2ae.js

@@ -1 +0,0 @@
-Prism.languages.git = { comment: /^#.*/m, deleted: /^[-–].*/m, inserted: /^\+.*/m, string: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/, command: { pattern: /^.*\$ git .*$/m, inside: { parameter: /\s--?\w+/ } }, coord: /^@@.*@@$/m, "commit-sha1": /^commit \w{40}$/m };

package/dist/prism-glsl.min-5a4d82d4.js

@@ -1 +0,0 @@
-Prism.languages.glsl = Prism.languages.extend("c", { keyword: /\b(?:active|asm|atomic_uint|attribute|[ibdu]?vec[234]|bool|break|buffer|case|cast|centroid|class|coherent|common|const|continue|d?mat[234](?:x[234])?|default|discard|do|double|else|enum|extern|external|false|filter|fixed|flat|float|for|fvec[234]|goto|half|highp|hvec[234]|[iu]?sampler2DMS(?:Array)?|[iu]?sampler2DRect|[iu]?samplerBuffer|[iu]?samplerCube|[iu]?samplerCubeArray|[iu]?sampler[123]D|[iu]?sampler[12]DArray|[iu]?image2DMS(?:Array)?|[iu]?image2DRect|[iu]?imageBuffer|[iu]?imageCube|[iu]?imageCubeArray|[iu]?image[123]D|[iu]?image[12]DArray|if|in|inline|inout|input|int|interface|invariant|layout|long|lowp|mediump|namespace|noinline|noperspective|out|output|partition|patch|precise|precision|public|readonly|resource|restrict|return|sample|sampler[12]DArrayShadow|sampler[12]DShadow|sampler2DRectShadow|sampler3DRect|samplerCubeArrayShadow|samplerCubeShadow|shared|short|sizeof|smooth|static|struct|subroutine|superp|switch|template|this|true|typedef|uint|uniform|union|unsigned|using|varying|void|volatile|while|writeonly)\b/ });

package/dist/prism-gml.min-b91c603d.js

@@ -1 +0,0 @@
-Prism.languages.gamemakerlanguage = Prism.languages.gml = Prism.languages.extend("clike", { keyword: /\b(?:break|case|continue|default|do|else|enum|exit|for|globalvar|if|repeat|return|switch|until|var|while)\b/, number: /(?:\b0x[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ulf]{0,4}/i, operator: /--|\+\+|[-+%/=]=?|!=|\*\*?=?|<[<=>]?|>[=>]?|&&?|\^\^?|\|\|?|~|\b(?:and|at|not|or|with|xor)\b/, constant: /\b(?:GM_build_date|GM_version|action_(?:continue|restart|reverse|stop)|all|gamespeed_(?:fps|microseconds)|global|local|noone|other|pi|pointer_(?:invalid|null)|self|timezone_(?:local|utc)|undefined|ev_(?:create|destroy|step|alarm|keyboard|mouse|collision|other|draw|draw_(?:begin|end|post|pre)|keypress|keyrelease|trigger|(?:left|middle|no|right)_button|(?:left|middle|right)_press|(?:left|middle|right)_release|mouse_(?:enter|leave|wheel_down|wheel_up)|global_(?:left|middle|right)_button|global_(?:left|middle|right)_press|global_(?:left|middle|right)_release|joystick(?:1|2)_(?:button1|button2|button3|button4|button5|button6|button7|button8|down|left|right|up)|outside|boundary|game_start|game_end|room_start|room_end|no_more_lives|animation_end|end_of_path|no_more_health|user\d|gui|gui_begin|gui_end|step_(?:begin|end|normal))|vk_(?:alt|anykey|backspace|control|delete|down|end|enter|escape|home|insert|left|nokey|pagedown|pageup|pause|printscreen|return|right|shift|space|tab|up|f\d|numpad\d|add|decimal|divide|lalt|lcontrol|lshift|multiply|ralt|rcontrol|rshift|subtract)|achievement_(?:filter_(?:all_players|favorites_only|friends_only)|friends_info|info|leaderboard_info|our_info|pic_loaded|show_(?:achievement|bank|friend_picker|leaderboard|profile|purchase_prompt|ui)|type_challenge|type_score_challenge)|asset_(?:font|object|path|room|script|shader|sound|sprite|tiles|timeline|unknown)|audio_(?:3d|falloff_(?:exponent_distance|exponent_distance_clamped|inverse_distance|inverse_distance_clamped|linear_distance|linear_distance_clamped|none)|mono|new_system|old_system|stereo)|bm_(?:add|complex|dest_alpha|dest_color|dest_colour|inv_dest_alpha|inv_dest_color|inv_dest_colour|inv_src_alpha|inv_src_color|inv_src_colour|max|normal|one|src_alpha|src_alpha_sat|src_color|src_colour|subtract|zero)|browser_(?:chrome|firefox|ie|ie_mobile|not_a_browser|opera|safari|safari_mobile|tizen|unknown|windows_store)|buffer_(?:bool|f16|f32|f64|fast|fixed|generalerror|grow|invalidtype|network|outofbounds|outofspace|s16|s32|s8|seek_end|seek_relative|seek_start|string|text|u16|u32|u64|u8|vbuffer|wrap)|c_(?:aqua|black|blue|dkgray|fuchsia|gray|green|lime|ltgray|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)|cmpfunc_(?:always|equal|greater|greaterequal|less|lessequal|never|notequal)|cr_(?:appstart|arrow|beam|cross|default|drag|handpoint|hourglass|none|size_all|size_nesw|size_ns|size_nwse|size_we|uparrow)|cull_(?:clockwise|counterclockwise|noculling)|device_(?:emulator|tablet)|device_ios_(?:ipad|ipad_retina|iphone|iphone5|iphone6|iphone6plus|iphone_retina|unknown)|display_(?:landscape|landscape_flipped|portrait|portrait_flipped)|dll_(?:cdecl|cdel|stdcall)|ds_type_(?:grid|list|map|priority|queue|stack)|ef_(?:cloud|ellipse|explosion|firework|flare|rain|ring|smoke|smokeup|snow|spark|star)|fa_(?:archive|bottom|center|directory|hidden|left|middle|readonly|right|sysfile|top|volumeid)|fb_login_(?:default|fallback_to_webview|forcing_safari|forcing_webview|no_fallback_to_webview|use_system_account)|iap_(?:available|canceled|ev_consume|ev_product|ev_purchase|ev_restore|ev_storeload|failed|purchased|refunded|status_available|status_loading|status_processing|status_restoring|status_unavailable|status_uninitialised|storeload_failed|storeload_ok|unavailable)|leaderboard_type_(?:number|time_mins_secs)|lighttype_(?:dir|point)|matrix_(?:projection|view|world)|mb_(?:any|left|middle|none|right)|network_(?:config_(?:connect_timeout|disable_reliable_udp|enable_reliable_udp|use_non_blocking_socket)|socket_(?:bluetooth|tcp|udp)|type_(?:connect|data|disconnect|non_blocking_connect))|of_challenge_(?:lose|tie|win)|os_(?:android|ios|linux|macosx|ps3|ps4|psvita|unknown|uwp|win32|win8native|windows|winphone|xboxone)|phy_debug_render_(?:aabb|collision_pairs|coms|core_shapes|joints|obb|shapes)|phy_joint_(?:anchor_1_x|anchor_1_y|anchor_2_x|anchor_2_y|angle|angle_limits|damping_ratio|frequency|length_1|length_2|lower_angle_limit|max_force|max_length|max_motor_force|max_motor_torque|max_torque|motor_force|motor_speed|motor_torque|reaction_force_x|reaction_force_y|reaction_torque|speed|translation|upper_angle_limit)|phy_particle_data_flag_(?:category|color|colour|position|typeflags|velocity)|phy_particle_flag_(?:colormixing|colourmixing|elastic|powder|spring|tensile|viscous|wall|water|zombie)|phy_particle_group_flag_(?:rigid|solid)|pr_(?:linelist|linestrip|pointlist|trianglefan|trianglelist|trianglestrip)|ps_(?:distr|shape)_(?:diamond|ellipse|gaussian|invgaussian|line|linear|rectangle)|pt_shape_(?:circle|cloud|disk|explosion|flare|line|pixel|ring|smoke|snow|spark|sphere|square|star)|ty_(?:real|string)|gp_(?:face\d|axislh|axislv|axisrh|axisrv|padd|padl|padr|padu|select|shoulderl|shoulderlb|shoulderr|shoulderrb|start|stickl|stickr)|lb_disp_(?:none|numeric|time_ms|time_sec)|lb_sort_(?:ascending|descending|none)|ov_(?:achievements|community|friends|gamegroup|players|settings)|ugc_(?:filetype_(?:community|microtrans)|list_(?:Favorited|Followed|Published|Subscribed|UsedOrPlayed|VotedDown|VotedOn|VotedUp|WillVoteLater)|match_(?:AllGuides|Artwork|Collections|ControllerBindings|IntegratedGuides|Items|Items_Mtx|Items_ReadyToUse|Screenshots|UsableInGame|Videos|WebGuides)|query_(?:AcceptedForGameRankedByAcceptanceDate|CreatedByFriendsRankedByPublicationDate|FavoritedByFriendsRankedByPublicationDate|NotYetRated)|query_RankedBy(?:NumTimesReported|PublicationDate|TextSearch|TotalVotesAsc|Trend|Vote|VotesUp)|result_success|sortorder_CreationOrder(?:Asc|Desc)|sortorder_(?:ForModeration|LastUpdatedDesc|SubscriptionDateDesc|TitleAsc|VoteScoreDesc)|visibility_(?:friends_only|private|public))|vertex_usage_(?:binormal|blendindices|blendweight|color|colour|depth|fog|normal|position|psize|sample|tangent|texcoord|textcoord)|vertex_type_(?:float\d|color|colour|ubyte4)|input_type|layerelementtype_(?:background|instance|oldtilemap|particlesystem|sprite|tile|tilemap|undefined)|se_(?:chorus|compressor|echo|equalizer|flanger|gargle|none|reverb)|text_type|tile_(?:flip|index_mask|mirror|rotate)|(?:obj|rm|scr|spr)\w+)\b/, variable: /\b(?:alarm|application_surface|async_load|background_(?:alpha|blend|color|colour|foreground|height|hspeed|htiled|index|showcolor|showcolour|visible|vspeed|vtiled|width|x|xscale|y|yscale)|bbox_(?:bottom|left|right|top)|browser_(?:height|width)|caption_(?:health|lives|score)|current_(?:day|hour|minute|month|second|time|weekday|year)|cursor_sprite|debug_mode|delta_time|direction|display_aa|error_(?:last|occurred)|event_(?:action|number|object|type)|fps|fps_real|friction|game_(?:display|project|save)_(?:id|name)|gamemaker_(?:pro|registered|version)|gravity|gravity_direction|(?:h|v)speed|health|iap_data|id|image_(?:alpha|angle|blend|depth|index|number|speed|xscale|yscale)|instance_(?:count|id)|keyboard_(?:key|lastchar|lastkey|string)|layer|lives|mask_index|mouse_(?:button|lastbutton|x|y)|object_index|os_(?:browser|device|type|version)|path_(?:endaction|index|orientation|position|positionprevious|scale|speed)|persistent|phy_(?:rotation|(?:col_normal|collision|com|linear_velocity|position|speed)_(?:x|y)|angular_(?:damping|velocity)|position_(?:x|y)previous|speed|linear_damping|bullet|fixed_rotation|active|mass|inertia|dynamic|kinematic|sleeping|collision_points)|pointer_(?:invalid|null)|room|room_(?:caption|first|height|last|persistent|speed|width)|score|secure_mode|show_(?:health|lives|score)|solid|speed|sprite_(?:height|index|width|xoffset|yoffset)|temp_directory|timeline_(?:index|loop|position|running|speed)|transition_(?:color|kind|steps)|undefined|view_(?:angle|current|enabled|(?:h|v)(?:border|speed)|(?:h|w|x|y)port|(?:h|w|x|y)view|object|surface_id|visible)|visible|webgl_enabled|working_directory|(?:x|y)(?:previous|start)|x|y|argument(?:_relitive|_count|\d)|argument|global|local|other|self)\b/ });

package/dist/prism-gn.min-b37dd2cf.js

@@ -1 +0,0 @@
-Prism.languages.gn = { comment: { pattern: /#.*/, greedy: !0 }, "string-literal": { pattern: /(^|[^\\"])"(?:[^\r\n"\\]|\\.)*"/, lookbehind: !0, greedy: !0, inside: { interpolation: { pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[\s\S]*?\}|[a-zA-Z_]\w*|0x[a-fA-F0-9]{2})/, lookbehind: !0, inside: { number: /^\$0x[\s\S]{2}$/, variable: /^\$\w+$/, "interpolation-punctuation": { pattern: /^\$\{|\}$/, alias: "punctuation" }, expression: { pattern: /[\s\S]+/, inside: null } } }, string: /[\s\S]+/ } }, keyword: /\b(?:else|if)\b/, boolean: /\b(?:false|true)\b/, "builtin-function": { pattern: /\b(?:assert|defined|foreach|import|pool|print|template|tool|toolchain)(?=\s*\()/i, alias: "keyword" }, function: /\b[a-z_]\w*(?=\s*\()/i, constant: /\b(?:current_cpu|current_os|current_toolchain|default_toolchain|host_cpu|host_os|root_build_dir|root_gen_dir|root_out_dir|target_cpu|target_gen_dir|target_os|target_out_dir)\b/, number: /-?\b\d+\b/, operator: /[-+!=<>]=?|&&|\|\|/, punctuation: /[(){}[\],.]/ }, Prism.languages.gn["string-literal"].inside.interpolation.inside.expression.inside = Prism.languages.gn, Prism.languages.gni = Prism.languages.gn;

package/dist/prism-go-module.min-e9a704bf.js

@@ -1 +0,0 @@
-Prism.languages["go-mod"] = Prism.languages["go-module"] = { comment: { pattern: /\/\/.*/, greedy: !0 }, version: { pattern: /(^|[\s()[\],])v\d+\.\d+\.\d+(?:[+-][-+.\w]*)?(?![^\s()[\],])/, lookbehind: !0, alias: "number" }, "go-version": { pattern: /((?:^|\s)go\s+)\d+(?:\.\d+){1,2}/, lookbehind: !0, alias: "number" }, keyword: { pattern: /^([ \t]*)(?:exclude|go|module|replace|require|retract)\b/m, lookbehind: !0 }, operator: /=>/, punctuation: /[()[\],]/ };

package/dist/prism-go.min-c7322c64.js

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

package/dist/prism-gradle.min-1a828d06.js

@@ -1,4 +0,0 @@
-(function(e) {
-  var n = { pattern: /((?:^|[^\\$])(?:\\{2})*)\$(?:\w+|\{[^{}]*\})/, lookbehind: !0, inside: { "interpolation-punctuation": { pattern: /^\$\{?|\}$/, alias: "punctuation" }, expression: { pattern: /[\s\S]+/, inside: null } } };
-  e.languages.gradle = e.languages.extend("clike", { string: { pattern: /'''(?:[^\\]|\\[\s\S])*?'''|'(?:\\.|[^\\'\r\n])*'/, greedy: !0 }, keyword: /\b(?:apply|def|dependencies|else|if|implementation|import|plugin|plugins|project|repositories|repository|sourceSets|tasks|val)\b/, number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i, operator: { pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/, lookbehind: !0 }, punctuation: /\.+|[{}[\];(),:$]/ }), e.languages.insertBefore("gradle", "string", { shebang: { pattern: /#!.+/, alias: "comment", greedy: !0 }, "interpolation-string": { pattern: /"""(?:[^\\]|\\[\s\S])*?"""|(["/])(?:\\.|(?!\1)[^\\\r\n])*\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/, greedy: !0, inside: { interpolation: n, string: /[\s\S]+/ } } }), e.languages.insertBefore("gradle", "punctuation", { "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/ }), e.languages.insertBefore("gradle", "function", { annotation: { pattern: /(^|[^.])@\w+/, lookbehind: !0, alias: "punctuation" } }), n.inside.expression.inside = e.languages.gradle;
-})(Prism);

package/dist/prism-graphql.min-e5fddf96.js

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

package/dist/prism-groovy.min-6999a453.js

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

package/dist/prism-haml.min-06d636e1.js

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

package/dist/prism-handlebars.min-d59c233b.js

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

package/dist/prism-haskell.min-2d474195.js

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

package/dist/prism-haxe.min-0b47bda7.js

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

package/dist/prism-hcl.min-dd93c4fa.js

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

package/dist/prism-hlsl.min-90bc1513.js

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

package/dist/prism-hoon.min-5ac6535d.js

@@ -1 +0,0 @@
-Prism.languages.hoon = { comment: { pattern: /::.*/, greedy: !0 }, string: { pattern: /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/, greedy: !0 }, constant: /%(?:\.[ny]|[\w-]+)/, "class-name": /@(?:[a-z0-9-]*[a-z0-9])?|\*/i, function: /(?:\+[-+] {2})?(?:[a-z](?:[a-z0-9-]*[a-z0-9])?)/, keyword: /\.[\^\+\*=\?]|![><:\.=\?!]|=[>|:,\.\-\^<+;/~\*\?]|\?[>|:\.\-\^<\+&~=@!]|\|[\$_%:\.\-\^~\*=@\?]|\+[|\$\+\*]|:[_\-\^\+~\*]|%[_:\.\-\^\+~\*=]|\^[|:\.\-\+&~\*=\?]|\$[|_%:<>\-\^&~@=\?]|;[:<\+;\/~\*=]|~[>|\$_%<\+\/&=\?!]|--|==/ };

package/dist/prism-hpkp.min-ccf08017.js

@@ -1 +0,0 @@
-Prism.languages.hpkp = { directive: { pattern: /\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\s;=]|$)/i, alias: "property" }, operator: /=/, punctuation: /;/ };

package/dist/prism-hsts.min-0dd9146f.js

@@ -1 +0,0 @@
-Prism.languages.hsts = { directive: { pattern: /\b(?:includeSubDomains|max-age|preload)(?=[\s;=]|$)/i, alias: "property" }, operator: /=/, punctuation: /;/ };

package/dist/prism-http.min-10b32777.js

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

package/dist/prism-ichigojam.min-144f1b4b.js

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

package/dist/prism-icon.min-22bb1195.js

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

package/dist/prism-icu-message-format.min-b2ecdff3.js

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

package/dist/prism-idris.min-920ad8df.js

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

package/dist/prism-iecst.min-d5ab1f6c.js

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

package/dist/prism-ignore.min-272b6ccf.js

@@ -1,3 +0,0 @@
-(function(g) {
-  g.languages.ignore = { comment: /^#.*/m, entry: { pattern: /\S(?:.*(?:(?:\\ )|\S))?/, alias: "string", inside: { operator: /^!|\*\*?|\?/, regex: { pattern: /(^|[^\\])\[[^\[\]]*\]/, lookbehind: !0 }, punctuation: /\// } } }, g.languages.gitignore = g.languages.ignore, g.languages.hgignore = g.languages.ignore, g.languages.npmignore = g.languages.ignore;
-})(Prism);

package/dist/prism-inform7.min-22b438d7.js

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

package/dist/prism-ini.min-b9585cc2.js

@@ -1 +0,0 @@
-Prism.languages.ini = { comment: { pattern: /(^[ \f\t\v]*)[#;][^\n\r]*/m, lookbehind: !0 }, section: { pattern: /(^[ \f\t\v]*)\[[^\n\r\]]*\]?/m, lookbehind: !0, inside: { "section-name": { pattern: /(^\[[ \f\t\v]*)[^ \f\t\v\]]+(?:[ \f\t\v]+[^ \f\t\v\]]+)*/, lookbehind: !0, alias: "selector" }, punctuation: /\[|\]/ } }, key: { pattern: /(^[ \f\t\v]*)[^ \f\n\r\t\v=]+(?:[ \f\t\v]+[^ \f\n\r\t\v=]+)*(?=[ \f\t\v]*=)/m, lookbehind: !0, alias: "attr-name" }, value: { pattern: /(=[ \f\t\v]*)[^ \f\n\r\t\v]+(?:[ \f\t\v]+[^ \f\n\r\t\v]+)*/, lookbehind: !0, alias: "attr-value", inside: { "inner-value": { pattern: /^("|').+(?=\1$)/, lookbehind: !0 } } }, punctuation: /=/ };

package/dist/prism-io.min-bc03d63b.js

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

package/dist/prism-j.min-2dc34683.js

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

package/dist/prism-java.min-2cfc90de.js

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

package/dist/prism-javadoc.min-12ef12d8.js

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

package/dist/prism-javadoclike.min-e07933fc.js

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

package/dist/prism-javascript.min-03c8bcee.js

@@ -1,8 +0,0 @@
-Prism.languages.javascript = Prism.languages.extend("clike", { "class-name": [Prism.languages.clike["class-name"], { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/, lookbehind: !0 }], keyword: [{ pattern: /((?:^|\})\s*)catch\b/, lookbehind: !0 }, { pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/, lookbehind: !0 }], function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/, number: { pattern: RegExp("(^|[^\\w$])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][\\dA-Fa-f]+(?:_[\\dA-Fa-f]+)*n?|\\d+(?:_\\d+)*n|(?:\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\.\\d+(?:_\\d+)*)(?:[Ee][+-]?\\d+(?:_\\d+)*)?)(?![\\w$])"), lookbehind: !0 }, operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/ }), Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, Prism.languages.insertBefore("javascript", "keyword", { regex: { pattern: RegExp(`((?:^|[^$\\w\\xA0-\\uFFFF."'\\])\\s]|\\b(?:return|yield))\\s*)/(?:(?:\\[(?:[^\\]\\\\\r
-]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\r
-])+/[dgimyus]{0,7}|(?:\\[(?:[^[\\]\\\\\r
-]|\\\\.|\\[(?:[^[\\]\\\\\r
-]|\\\\.|\\[(?:[^[\\]\\\\\r
-]|\\\\.)*\\])*\\])*\\]|\\\\.|[^/\\\\\\[\r
-])+/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\\s|/\\*(?:[^*]|\\*(?!/))*\\*/)*(?:$|[\r
-,.;:})\\]]|//))`), lookbehind: !0, greedy: !0, inside: { "regex-source": { pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/, lookbehind: !0, alias: "language-regex", inside: Prism.languages.regex }, "regex-delimiter": /^\/|\/$/, "regex-flags": /^[a-z]+$/ } }, "function-variable": { pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/, alias: "function" }, parameter: [{ pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/, lookbehind: !0, inside: Prism.languages.javascript }, { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i, lookbehind: !0, inside: Prism.languages.javascript }, { pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/, lookbehind: !0, inside: Prism.languages.javascript }, { pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/, lookbehind: !0, inside: Prism.languages.javascript }], constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/ }), Prism.languages.insertBefore("javascript", "string", { hashbang: { pattern: /^#!.*/, greedy: !0, alias: "comment" }, "template-string": { pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/, greedy: !0, inside: { "template-punctuation": { pattern: /^`|`$/, alias: "string" }, interpolation: { pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/, lookbehind: !0, inside: { "interpolation-punctuation": { pattern: /^\$\{|\}$/, alias: "punctuation" }, rest: Prism.languages.javascript } }, string: /[\s\S]+/ } }, "string-property": { pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m, lookbehind: !0, greedy: !0, alias: "property" } }), Prism.languages.insertBefore("javascript", "operator", { "literal-property": { pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m, lookbehind: !0, alias: "property" } }), Prism.languages.markup && (Prism.languages.markup.tag.addInlined("script", "javascript"), Prism.languages.markup.tag.addAttribute("on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)", "javascript")), Prism.languages.js = Prism.languages.javascript;

package/dist/prism-javastacktrace.min-d3186b3e.js

@@ -1 +0,0 @@
-Prism.languages.javastacktrace = { summary: { pattern: /^([\t ]*)(?:(?:Caused by:|Suppressed:|Exception in thread "[^"]*")[\t ]+)?[\w$.]+(?::.*)?$/m, lookbehind: !0, inside: { keyword: { pattern: /^([\t ]*)(?:(?:Caused by|Suppressed)(?=:)|Exception in thread)/m, lookbehind: !0 }, string: { pattern: /^(\s*)"[^"]*"/, lookbehind: !0 }, exceptions: { pattern: /^(:?\s*)[\w$.]+(?=:|$)/, lookbehind: !0, inside: { "class-name": /[\w$]+$/, namespace: /\b[a-z]\w*\b/, punctuation: /\./ } }, message: { pattern: /(:\s*)\S.*/, lookbehind: !0, alias: "string" }, punctuation: /:/ } }, "stack-frame": { pattern: /^([\t ]*)at (?:[\w$./]|@[\w$.+-]*\/)+(?:<init>)?\([^()]*\)/m, lookbehind: !0, inside: { keyword: { pattern: /^(\s*)at(?= )/, lookbehind: !0 }, source: [{ pattern: /(\()\w+\.\w+:\d+(?=\))/, lookbehind: !0, inside: { file: /^\w+\.\w+/, punctuation: /:/, "line-number": { pattern: /\b\d+\b/, alias: "number" } } }, { pattern: /(\()[^()]*(?=\))/, lookbehind: !0, inside: { keyword: /^(?:Native Method|Unknown Source)$/ } }], "class-name": /[\w$]+(?=\.(?:<init>|[\w$]+)\()/, function: /(?:<init>|[\w$]+)(?=\()/, "class-loader": { pattern: /(\s)[a-z]\w*(?:\.[a-z]\w*)*(?=\/[\w@$.]*\/)/, lookbehind: !0, alias: "namespace", inside: { punctuation: /\./ } }, module: { pattern: /([\s/])[a-z]\w*(?:\.[a-z]\w*)*(?:@[\w$.+-]*)?(?=\/)/, lookbehind: !0, inside: { version: { pattern: /(@)[\s\S]+/, lookbehind: !0, alias: "number" }, punctuation: /[@.]/ } }, namespace: { pattern: /(?:\b[a-z]\w*\.)+/, inside: { punctuation: /\./ } }, punctuation: /[()/.]/ } }, more: { pattern: /^([\t ]*)\.{3} \d+ [a-z]+(?: [a-z]+)*/m, lookbehind: !0, inside: { punctuation: /\.{3}/, number: /\d+/, keyword: /\b[a-z]+(?: [a-z]+)*\b/ } } };

package/dist/prism-jexl.min-084d69d8.js

@@ -1 +0,0 @@
-Prism.languages.jexl = { string: /(["'])(?:\\[\s\S]|(?!\1)[^\\])*\1/, transform: { pattern: /(\|\s*)[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wа-яА-Я\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*/, alias: "function", lookbehind: !0 }, function: /[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wа-яА-Я\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*\s*(?=\()/, number: /\b\d+(?:\.\d+)?\b|\B\.\d+\b/, operator: /[<>!]=?|-|\+|&&|==|\|\|?|\/\/?|[?:*^%]/, boolean: /\b(?:false|true)\b/, keyword: /\bin\b/, punctuation: /[{}[\](),.]/ };

package/dist/prism-jolie.min-466d4cf7.js

@@ -1 +0,0 @@
-Prism.languages.jolie = Prism.languages.extend("clike", { string: { pattern: /(^|[^\\])"(?:\\[\s\S]|[^"\\])*"/, lookbehind: !0, greedy: !0 }, "class-name": { pattern: /((?:\b(?:as|courier|embed|in|inputPort|outputPort|service)\b|@)[ \t]*)\w+/, lookbehind: !0 }, keyword: /\b(?:as|cH|comp|concurrent|constants|courier|cset|csets|default|define|else|embed|embedded|execution|exit|extender|for|foreach|forward|from|global|if|import|in|include|init|inputPort|install|instanceof|interface|is_defined|linkIn|linkOut|main|new|nullProcess|outputPort|over|private|provide|public|scope|sequential|service|single|spawn|synchronized|this|throw|throws|type|undef|until|while|with)\b/, function: /\b[a-z_]\w*(?=[ \t]*[@(])/i, number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?l?/i, operator: /-[-=>]?|\+[+=]?|<[<=]?|[>=*!]=?|&&|\|\||[?\/%^@|]/, punctuation: /[()[\]{},;.:]/, builtin: /\b(?:Byte|any|bool|char|double|enum|float|int|length|long|ranges|regex|string|undefined|void)\b/ }), Prism.languages.insertBefore("jolie", "keyword", { aggregates: { pattern: /(\bAggregates\s*:\s*)(?:\w+(?:\s+with\s+\w+)?\s*,\s*)*\w+(?:\s+with\s+\w+)?/, lookbehind: !0, inside: { keyword: /\bwith\b/, "class-name": /\w+/, punctuation: /,/ } }, redirects: { pattern: /(\bRedirects\s*:\s*)(?:\w+\s*=>\s*\w+\s*,\s*)*(?:\w+\s*=>\s*\w+)/, lookbehind: !0, inside: { punctuation: /,/, "class-name": /\w+/, operator: /=>/ } }, property: { pattern: /\b(?:Aggregates|[Ii]nterfaces|Java|Javascript|Jolie|[Ll]ocation|OneWay|[Pp]rotocol|Redirects|RequestResponse)\b(?=[ \t]*:)/ } });

package/dist/prism-jq.min-3daf478a.js

@@ -1,8 +0,0 @@
-(function(i) {
-  var n = "\\\\\\((?:[^()]|\\([^()]*\\))*\\)", t = RegExp(`(^|[^\\\\])"(?:[^"\r
-\\\\]|\\\\[^\r
-(]|__)*"`.replace(/__/g, function() {
-    return n;
-  })), e = { interpolation: { pattern: RegExp("((?:^|[^\\\\])(?:\\\\{2})*)" + n), lookbehind: !0, inside: { content: { pattern: /^(\\\()[\s\S]+(?=\)$)/, lookbehind: !0, inside: null }, punctuation: /^\\\(|\)$/ } } }, a = i.languages.jq = { comment: /#.*/, property: { pattern: RegExp(t.source + "(?=\\s*:(?!:))"), lookbehind: !0, greedy: !0, inside: e }, string: { pattern: t, lookbehind: !0, greedy: !0, inside: e }, function: { pattern: /(\bdef\s+)[a-z_]\w+/i, lookbehind: !0 }, variable: /\B\$\w+/, "property-literal": { pattern: /\b[a-z_]\w*(?=\s*:(?!:))/i, alias: "property" }, keyword: /\b(?:as|break|catch|def|elif|else|end|foreach|if|import|include|label|module|modulemeta|null|reduce|then|try|while)\b/, boolean: /\b(?:false|true)\b/, number: /(?:\b\d+\.|\B\.)?\b\d+(?:[eE][+-]?\d+)?\b/, operator: [{ pattern: /\|=?/, alias: "pipe" }, /\.\.|[!=<>]?=|\?\/\/|\/\/=?|[-+*/%]=?|[<>?]|\b(?:and|not|or)\b/], "c-style-function": { pattern: /\b[a-z_]\w*(?=\s*\()/i, alias: "function" }, punctuation: /::|[()\[\]{},:;]|\.(?=\s*[\[\w$])/, dot: { pattern: /\./, alias: "important" } };
-  e.interpolation.inside.content.inside = a;
-})(Prism);

package/dist/prism-js-extras.min-a225cee9.js

@@ -1,14 +0,0 @@
-(function(a) {
-  function t(i, l) {
-    return RegExp(i.replace(/<ID>/g, function() {
-      return "(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*";
-    }), l);
-  }
-  a.languages.insertBefore("javascript", "function-variable", { "method-variable": { pattern: RegExp("(\\.\\s*)" + a.languages.javascript["function-variable"].pattern.source), lookbehind: !0, alias: ["function-variable", "method", "function", "property-access"] } }), a.languages.insertBefore("javascript", "function", { method: { pattern: RegExp("(\\.\\s*)" + a.languages.javascript.function.source), lookbehind: !0, alias: ["function", "property-access"] } }), a.languages.insertBefore("javascript", "constant", { "known-class-name": [{ pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/, alias: "class-name" }, { pattern: /\b(?:[A-Z]\w*)Error\b/, alias: "class-name" }] }), a.languages.insertBefore("javascript", "keyword", { imports: { pattern: t("(\\bimport\\b\\s*)(?:<ID>(?:\\s*,\\s*(?:\\*\\s*as\\s+<ID>|\\{[^{}]*\\}))?|\\*\\s*as\\s+<ID>|\\{[^{}]*\\})(?=\\s*\\bfrom\\b)"), lookbehind: !0, inside: a.languages.javascript }, exports: { pattern: t("(\\bexport\\b\\s*)(?:\\*(?:\\s*as\\s+<ID>)?(?=\\s*\\bfrom\\b)|\\{[^{}]*\\})"), lookbehind: !0, inside: a.languages.javascript } }), a.languages.javascript.keyword.unshift({ pattern: /\b(?:as|default|export|from|import)\b/, alias: "module" }, { pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/, alias: "control-flow" }, { pattern: /\bnull\b/, alias: ["null", "nil"] }, { pattern: /\bundefined\b/, alias: "nil" }), a.languages.insertBefore("javascript", "operator", { spread: { pattern: /\.{3}/, alias: "operator" }, arrow: { pattern: /=>/, alias: "operator" } }), a.languages.insertBefore("javascript", "punctuation", { "property-access": { pattern: t("(\\.\\s*)#?<ID>"), lookbehind: !0 }, "maybe-class-name": { pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/, lookbehind: !0 }, dom: { pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/, alias: "variable" }, console: { pattern: /\bconsole(?=\s*\.)/, alias: "class-name" } });
-  for (var r = ["function", "function-variable", "method", "method-variable", "property-access"], n = 0; n < r.length; n++) {
-    var s = r[n], e = a.languages.javascript[s];
-    a.util.type(e) === "RegExp" && (e = a.languages.javascript[s] = { pattern: e });
-    var o = e.inside || {};
-    e.inside = o, o["maybe-class-name"] = /^[A-Z][\s\S]*/;
-  }
-})(Prism);