@cyfung1031/prism-code-editor 5.2.0-cdn-esm.0

package/dist/prism/languages/yaml.js

@@ -0,0 +1,61 @@
+import { a as languages } from "../../core-DpDyJ-7r.js";
+import { n as re, r as replace } from "../../shared-oTKIFAwH.js";
+//#region src/prism/languages/yaml.js
+var anchorOrAlias = /[*&][^\s[\]{},]+/;
+var tag = /!(?:<[\w%#;/?:@&=$,.!~*'()[\]+-]+>|(?:[a-zA-Z\d-]*!)?[\w%#;/?:@&=$.~*'()+-]+)?/;
+var properties = `(?:${tag.source}(?:[ 	]+${anchorOrAlias.source})?|${anchorOrAlias.source}(?:[ 	]+${tag.source})?)`;
+var plainKey = replace("(?:[^\\s\0-\\x08\\x0e-\\x1f!\"#%&'*,:>?@[\\]{}`|\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff-]|[?:-]<0>)(?:[ 	]*(?:(?![#:])<0>|:<0>))*", ["[^\\s\0-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]"]);
+var string = "\"(?:\\\\.|[^\\\\\n\"])*\"|'(?:\\\\.|[^\\\\\n'])*'";
+/**
+* @param {string} value
+* @param {string} [flags]
+*/
+var createValuePattern = (value, flags) => re("([:,[{-]\\s*(?:\\s<0>[ 	]+)?)<1>(?=[ 	]*(?:$|,|\\]|\\}|(?:\n\\s*)?#))", [properties, value], flags);
+languages.yml = languages.yaml = {
+	"scalar": {
+		pattern: re("([:-]\\s*(?:\\s<0>[ 	]+)?[|>])[ 	]*(?:(\n[ 	]+)\\S.*(?:\\2.+)*)", [properties]),
+		lookbehind: true,
+		alias: "string"
+	},
+	"comment": /#.*/,
+	"key": {
+		pattern: re("((?:^|[:,[{\n?-])[ 	]*(?:<0>[ 	]+)?)<1>(?=\\s*:\\s)", [properties, "(?:" + plainKey + "|" + string + ")"], "g"),
+		lookbehind: true,
+		alias: "atrule"
+	},
+	"directive": {
+		pattern: /(^[ 	]*)%.+/m,
+		lookbehind: true,
+		alias: "important"
+	},
+	"datetime": {
+		pattern: createValuePattern("\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ 	]+)\\d\\d?:\\d\\d:\\d\\d(?:\\.\\d*)?(?:[ 	]*(?:Z|[+-]\\d\\d?(?::\\d\\d)?))?|\\d{4}-\\d\\d-\\d\\d|\\d\\d?:\\d\\d(?::\\d\\d(?:\\.\\d*)?)?", "m"),
+		lookbehind: true,
+		alias: "number"
+	},
+	"boolean": {
+		pattern: createValuePattern("false|true", "im"),
+		lookbehind: true,
+		alias: "important"
+	},
+	"null": {
+		pattern: createValuePattern("null|~", "im"),
+		lookbehind: true,
+		alias: "important"
+	},
+	"string": {
+		pattern: createValuePattern(string, "mg"),
+		lookbehind: true
+	},
+	"number": {
+		pattern: createValuePattern("[+-]?(?:0x[a-f\\d]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)", "im"),
+		lookbehind: true
+	},
+	"tag": tag,
+	"important": anchorOrAlias,
+	"punctuation": /---|[:[\]{},|>?-]|\.{3}/
+};
+//#endregion
+export { languages };
+
+//# sourceMappingURL=yaml.js.map

package/dist/prism/languages/yaml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml.js","names":[],"sources":["../../../src/prism/languages/yaml.js"],"sourcesContent":["import { languages } from '../core.js';\nimport { re, replace } from '../utils/shared.js';\n\n// https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property\n// https://yaml.org/spec/1.2/spec.html#c-ns-alias-node\nvar anchorOrAlias = /[*&][^\\s[\\]{},]+/;\n// https://yaml.org/spec/1.2/spec.html#c-ns-tag-property\nvar tag = /!(?:<[\\w%#;/?:@&=$,.!~*'()[\\]+-]+>|(?:[a-zA-Z\\d-]*!)?[\\w%#;/?:@&=$.~*'()+-]+)?/;\n// https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)\nvar properties = `(?:${tag.source}(?:[ \\t]+${anchorOrAlias.source})?|${anchorOrAlias.source}(?:[ \\t]+${tag.source})?)`;\n// https://yaml.org/spec/1.2/spec.html#ns-plain(n,c)\n// This is a simplified version that doesn't support \"#\" and multiline keys\n// All these long scarry character classes are simplified versions of YAML's characters\nvar plainKey = replace(\n\t/(?:[^\\s\\0-\\x08\\x0e-\\x1f!\"#%&'*,:>?@[\\]{}`|\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff-]|[?:-]<0>)(?:[ \\t]*(?:(?![#:])<0>|:<0>))*/.source,\n\t[/[^\\s\\0-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]/.source]\n);\nvar string = /\"(?:\\\\.|[^\\\\\\n\"])*\"|'(?:\\\\.|[^\\\\\\n'])*'/.source;\n\n/**\n * @param {string} value\n * @param {string} [flags]\n */\nvar createValuePattern = (value, flags) => re(\n\t/([:,[{-]\\s*(?:\\s<0>[ \\t]+)?)<1>(?=[ \\t]*(?:$|,|\\]|\\}|(?:\\n\\s*)?#))/.source,\n\t[properties, value], flags\n);\n\nlanguages.yml = languages.yaml = {\n\t'scalar': {\n\t\tpattern: re(/([:-]\\s*(?:\\s<0>[ \\t]+)?[|>])[ \\t]*(?:(\\n[ \\t]+)\\S.*(?:\\2.+)*)/.source, [properties]),\n\t\tlookbehind: true,\n\t\talias: 'string'\n\t},\n\t'comment': /#.*/,\n\t'key': {\n\t\tpattern: re(\n\t\t\t/((?:^|[:,[{\\n?-])[ \\t]*(?:<0>[ \\t]+)?)<1>(?=\\s*:\\s)/.source,\n\t\t\t[properties, '(?:' + plainKey + '|' + string + ')'], 'g'\n\t\t),\n\t\tlookbehind: true,\n\t\talias: 'atrule'\n\t},\n\t'directive': {\n\t\tpattern: /(^[ \\t]*)%.+/m,\n\t\tlookbehind: true,\n\t\talias: 'important'\n\t},\n\t'datetime': {\n\t\tpattern: createValuePattern(/\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \\t]+)\\d\\d?:\\d\\d:\\d\\d(?:\\.\\d*)?(?:[ \\t]*(?:Z|[+-]\\d\\d?(?::\\d\\d)?))?|\\d{4}-\\d\\d-\\d\\d|\\d\\d?:\\d\\d(?::\\d\\d(?:\\.\\d*)?)?/.source, 'm'),\n\t\tlookbehind: true,\n\t\talias: 'number'\n\t},\n\t'boolean': {\n\t\tpattern: createValuePattern(/false|true/.source, 'im'),\n\t\tlookbehind: true,\n\t\talias: 'important'\n\t},\n\t'null': {\n\t\tpattern: createValuePattern(/null|~/.source, 'im'),\n\t\tlookbehind: true,\n\t\talias: 'important'\n\t},\n\t'string': {\n\t\tpattern: createValuePattern(string, 'mg'),\n\t\tlookbehind: true\n\t},\n\t'number': {\n\t\tpattern: createValuePattern(/[+-]?(?:0x[a-f\\d]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)/.source, 'im'),\n\t\tlookbehind: true\n\t},\n\t'tag': tag,\n\t'important': anchorOrAlias,\n\t'punctuation': /---|[:[\\]{},|>?-]|\\.{3}/\n};\n\nexport { languages } from \"../core.js\";\n"],"mappings":";;;AAKA,IAAI,gBAAgB;AAEpB,IAAI,MAAM;AAEV,IAAI,aAAa,MAAM,IAAI,OAAO,UAAW,cAAc,OAAO,KAAK,cAAc,OAAO,UAAW,IAAI,OAAO;AAIlH,IAAI,WAAW,QACd,iJACA,CAAC,qFAA+E,CACjF;AACA,IAAI,SAAS;;;;;AAMb,IAAI,sBAAsB,OAAO,UAAU,GAC1C,yEACA,CAAC,YAAY,KAAK,GAAG,KACtB;AAEA,UAAU,MAAM,UAAU,OAAO;CAChC,UAAU;EACT,SAAS,GAAG,mEAAyE,CAAC,UAAU,CAAC;EACjG,YAAY;EACZ,OAAO;CACR;CACA,WAAW;CACX,OAAO;EACN,SAAS,GACR,uDACA,CAAC,YAAY,QAAQ,WAAW,MAAM,SAAS,GAAG,GAAG,GACtD;EACA,YAAY;EACZ,OAAO;CACR;CACA,aAAa;EACZ,SAAS;EACT,YAAY;EACZ,OAAO;CACR;CACA,YAAY;EACX,SAAS,mBAAmB,4KAAuJ,GAAG;EACtL,YAAY;EACZ,OAAO;CACR;CACA,WAAW;EACV,SAAS,mBAAmB,cAAqB,IAAI;EACrD,YAAY;EACZ,OAAO;CACR;CACA,QAAQ;EACP,SAAS,mBAAmB,UAAiB,IAAI;EACjD,YAAY;EACZ,OAAO;CACR;CACA,UAAU;EACT,SAAS,mBAAmB,QAAQ,IAAI;EACxC,YAAY;CACb;CACA,UAAU;EACT,SAAS,mBAAmB,2FAAyF,IAAI;EACzH,YAAY;CACb;CACA,OAAO;CACP,aAAa;CACb,eAAe;AAChB"}

package/dist/prism/languages/yang.d.ts

@@ -0,0 +1,3 @@
+/** Used for autocompletion. This module doesn't have a default export. */
+declare const _: never;
+export default _;

package/dist/prism/languages/yang.js

@@ -0,0 +1,22 @@
+import { a as languages } from "../../core-DpDyJ-7r.js";
+import { n as clikeComment, t as boolean } from "../../patterns-DSInPV_c.js";
+//#region src/prism/languages/yang.js
+languages.yang = {
+	"comment": clikeComment,
+	"string": /"(?:\\.|[^\\"])*"|'[^']*'/g,
+	"keyword": {
+		pattern: /(^|[{};\n][ 	]*)[a-z_][\w.-]*/i,
+		lookbehind: true
+	},
+	"namespace": {
+		pattern: /(\s)[a-z_][\w.-]*(?=:)/i,
+		lookbehind: true
+	},
+	"boolean": boolean,
+	"operator": /\+/,
+	"punctuation": /[{}:;]/
+};
+//#endregion
+export { languages };
+
+//# sourceMappingURL=yang.js.map

package/dist/prism/languages/yang.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yang.js","names":[],"sources":["../../../src/prism/languages/yang.js"],"sourcesContent":["import { languages } from '../core.js';\nimport { boolean, clikeComment } from '../utils/patterns.js';\n\nlanguages.yang = {\n\t// https://tools.ietf.org/html/rfc6020#page-34\n\t// http://www.yang-central.org/twiki/bin/view/Main/YangExamples\n\t'comment': clikeComment,\n\t'string': /\"(?:\\\\.|[^\\\\\"])*\"|'[^']*'/g,\n\t'keyword': {\n\t\tpattern: /(^|[{};\\n][ \\t]*)[a-z_][\\w.-]*/i,\n\t\tlookbehind: true\n\t},\n\t'namespace': {\n\t\tpattern: /(\\s)[a-z_][\\w.-]*(?=:)/i,\n\t\tlookbehind: true\n\t},\n\t'boolean': boolean,\n\t'operator': /\\+/,\n\t'punctuation': /[{}:;]/\n};\n\nexport { languages } from \"../core.js\";\n"],"mappings":";;;AAGA,UAAU,OAAO;CAGhB,WAAW;CACX,UAAU;CACV,WAAW;EACV,SAAS;EACT,YAAY;CACb;CACA,aAAa;EACZ,SAAS;EACT,YAAY;CACb;CACA,WAAW;CACX,YAAY;CACZ,eAAe;AAChB"}

package/dist/prism/languages/zig.d.ts

@@ -0,0 +1,3 @@
+/** Used for autocompletion. This module doesn't have a default export. */
+declare const _: never;
+export default _;

package/dist/prism/languages/zig.js

@@ -0,0 +1,59 @@
+import { a as languages } from "../../core-DpDyJ-7r.js";
+import { i as clikePunctuation, t as boolean } from "../../patterns-DSInPV_c.js";
+import { n as re, r as replace } from "../../shared-oTKIFAwH.js";
+//#region src/prism/languages/zig.js
+var keyword = /\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|f?or|if|inline|linksection|nakedcc|noalias|nosuspend|null|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/;
+var IDENTIFIER = "\\b(?!" + keyword.source + ")(?!\\d)\\w+\\b";
+var ALIGN = "align\\s*\\((?:[^()]|\\([^)]*\\))*\\)";
+var PREFIX_TYPE_OP = replace("(?:\\?|\\bpromise->|(?:\\[[^[\\]]*\\]|\\*(?!\\*)|\\*\\*)(?:\\s*<0>|\\s*const\\b|\\s*volatile\\b|\\s*allowzero\\b)*)", [ALIGN]);
+var SUFFIX_EXPR = replace("(?:\\bpromise\\b|(?:\\berror\\.)?<0>(?:\\.<0>)*(?!\\s+<0>))", [IDENTIFIER]);
+var TYPE = "(?!\\s)(?:!?\\s*(?:" + PREFIX_TYPE_OP + "\\s*)*" + SUFFIX_EXPR + ")+";
+languages.zig = {
+	"comment": [{
+		pattern: /\/\/[/!].*/,
+		alias: "doc-comment"
+	}, /\/\/.*/],
+	"string": [{
+		pattern: /(^|[^\\@])c?"(?:\\.|[^\\\n"])*"/g,
+		lookbehind: true
+	}, {
+		pattern: /(\n)([ 	]+c?\\\\).*(?:\n\2.*)*/g,
+		lookbehind: true
+	}],
+	"char": {
+		pattern: /(^|[^\\])'(?:[^\\\n']|[\ud800-\udfff]{2}|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/g,
+		lookbehind: true
+	},
+	"builtin": /\B@(?!\d)\w+(?=\s*\()/,
+	"label": {
+		pattern: /(\b(?:break|continue)\s*:\s*)\w+|\b(?!\d)\w+\b(?=\s*:\s*(?:\{|while\b))/,
+		lookbehind: true
+	},
+	"class-name": [
+		/\b(?!\d)\w+(?=\s*=\s*(?:(?:extern|packed)\s+)?(?:enum|struct|union)\s*[({])/,
+		{
+			pattern: re("(:\\s*)<0>(?=\\s*(?:<1>\\s*)?[=;,)])|<0>(?=\\s*(?:<1>\\s*)?\\{)", [TYPE, ALIGN]),
+			lookbehind: true,
+			inside: "zig"
+		},
+		{
+			pattern: re("(\\)\\s*)<0>(?=\\s*(?:<1>\\s*)?;)", [TYPE, ALIGN]),
+			lookbehind: true,
+			inside: "zig"
+		}
+	],
+	"builtin-type": {
+		pattern: /\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/,
+		alias: "keyword"
+	},
+	"keyword": keyword,
+	"function": /\b(?!\d)\w+(?=\s*\()/,
+	"number": /\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/,
+	"boolean": boolean,
+	"operator": /[=-]>|\*\*|\+\+|\|\||(?:<<|>>|[*+-]%|[%&|^!=<>/*+-])=?|[?~]|\.{3}|\.[.*?]/,
+	"punctuation": clikePunctuation
+};
+//#endregion
+export { languages };
+
+//# sourceMappingURL=zig.js.map

package/dist/prism/languages/zig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zig.js","names":[],"sources":["../../../src/prism/languages/zig.js"],"sourcesContent":["import { languages } from '../core.js';\nimport { boolean, clikePunctuation } from '../utils/patterns.js';\nimport { re, replace } from '../utils/shared.js';\n\nvar keyword = /\\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|f?or|if|inline|linksection|nakedcc|noalias|nosuspend|null|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\\b/;\n\nvar IDENTIFIER = '\\\\b(?!' + keyword.source + ')(?!\\\\d)\\\\w+\\\\b';\nvar ALIGN = /align\\s*\\((?:[^()]|\\([^)]*\\))*\\)/.source;\nvar PREFIX_TYPE_OP = replace(/(?:\\?|\\bpromise->|(?:\\[[^[\\]]*\\]|\\*(?!\\*)|\\*\\*)(?:\\s*<0>|\\s*const\\b|\\s*volatile\\b|\\s*allowzero\\b)*)/.source, [ALIGN]);\nvar SUFFIX_EXPR = replace(/(?:\\bpromise\\b|(?:\\berror\\.)?<0>(?:\\.<0>)*(?!\\s+<0>))/.source, [IDENTIFIER]);\nvar TYPE = '(?!\\\\s)(?:!?\\\\s*(?:' + PREFIX_TYPE_OP + '\\\\s*)*' + SUFFIX_EXPR + ')+';\n\n/*\n * A simplified grammar for Zig compile time type literals:\n *\n * TypeExpr = ( \"!\"? PREFIX_TYPE_OP* SUFFIX_EXPR )+\n *\n * SUFFIX_EXPR = ( \\b \"promise\" \\b | ( \\b \"error\" \".\" )? IDENTIFIER ( \".\" IDENTIFIER )* (?! \\s+ IDENTIFIER ) )\n *\n * PREFIX_TYPE_OP = \"?\"\n *                | \\b \"promise\" \"->\"\n *                | ( \"[\" [^\\[\\]]* \"]\" | \"*\" | \"**\" ) ( ALIGN | \"const\" \\b | \"volatile\" \\b | \"allowzero\" \\b )*\n *\n * ALIGN = \"align\" \"(\" ( [^()] | \"(\" [^()]* \")\" )* \")\"\n *\n * IDENTIFIER = \\b (?! KEYWORD ) [a-zA-Z_] \\w* \\b\n *\n*/\n\nlanguages.zig = {\n\t'comment': [\n\t\t{\n\t\t\tpattern: /\\/\\/[/!].*/,\n\t\t\talias: 'doc-comment'\n\t\t},\n\t\t/\\/\\/.*/\n\t],\n\t'string': [\n\t\t{\n\t\t\t// \"string\" and c\"string\"\n\t\t\tpattern: /(^|[^\\\\@])c?\"(?:\\\\.|[^\\\\\\n\"])*\"/g,\n\t\t\tlookbehind: true\n\t\t},\n\t\t{\n\t\t\t// multiline strings and c-strings\n\t\t\tpattern: /(\\n)([ \\t]+c?\\\\\\\\).*(?:\\n\\2.*)*/g,\n\t\t\tlookbehind: true\n\t\t}\n\t],\n\t'char': {\n\t\t// characters 'a', '\\n', '\\xFF', '\\u{10FFFF}'\n\t\tpattern: /(^|[^\\\\])'(?:[^\\\\\\n']|[\\ud800-\\udfff]{2}|\\\\(?:.|x[a-fA-F\\d]{2}|u\\{[a-fA-F\\d]{1,6}\\}))'/g,\n\t\tlookbehind: true\n\t},\n\t'builtin': /\\B@(?!\\d)\\w+(?=\\s*\\()/,\n\t'label': {\n\t\tpattern: /(\\b(?:break|continue)\\s*:\\s*)\\w+|\\b(?!\\d)\\w+\\b(?=\\s*:\\s*(?:\\{|while\\b))/,\n\t\tlookbehind: true\n\t},\n\t'class-name': [\n\t\t// const Foo = struct {};\n\t\t/\\b(?!\\d)\\w+(?=\\s*=\\s*(?:(?:extern|packed)\\s+)?(?:enum|struct|union)\\s*[({])/,\n\t\t{\n\t\t\t// const x: i32 = 9;\n\t\t\t// var x: Bar;\n\t\t\t// fn foo(x: bool, y: f32) void {}\n\t\t\tpattern: re(/(:\\s*)<0>(?=\\s*(?:<1>\\s*)?[=;,)])|<0>(?=\\s*(?:<1>\\s*)?\\{)/.source, [TYPE, ALIGN]),\n\t\t\tlookbehind: true,\n\t\t\tinside: 'zig'\n\t\t},\n\t\t{\n\t\t\t// extern fn foo(x: f64) f64; (optional alignment)\n\t\t\tpattern: re(/(\\)\\s*)<0>(?=\\s*(?:<1>\\s*)?;)/.source, [TYPE, ALIGN]),\n\t\t\tlookbehind: true,\n\t\t\tinside: 'zig'\n\t\t}\n\t],\n\t'builtin-type': {\n\t\tpattern: /\\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\\b/,\n\t\talias: 'keyword'\n\t},\n\t'keyword': keyword,\n\t'function': /\\b(?!\\d)\\w+(?=\\s*\\()/,\n\t'number': /\\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\\d]+(?:\\.[a-fA-F\\d]*)?(?:[pP][+-]?[a-fA-F\\d]+)?|\\d+(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)\\b/,\n\t'boolean': boolean,\n\t'operator': /[=-]>|\\*\\*|\\+\\+|\\|\\||(?:<<|>>|[*+-]%|[%&|^!=<>/*+-])=?|[?~]|\\.{3}|\\.[.*?]/,\n\t'punctuation': clikePunctuation\n};\n\nexport { languages } from \"../core.js\";\n"],"mappings":";;;;AAIA,IAAI,UAAU;AAEd,IAAI,aAAa,WAAW,QAAQ,SAAS;AAC7C,IAAI,QAAQ;AACZ,IAAI,iBAAiB,QAAQ,uHAA8G,CAAC,KAAK,CAAC;AAClJ,IAAI,cAAc,QAAQ,+DAAgE,CAAC,UAAU,CAAC;AACtG,IAAI,OAAO,wBAAwB,iBAAiB,WAAW,cAAc;AAmB7E,UAAU,MAAM;CACf,WAAW,CACV;EACC,SAAS;EACT,OAAO;CACR,GACA,QACD;CACA,UAAU,CACT;EAEC,SAAS;EACT,YAAY;CACb,GACA;EAEC,SAAS;EACT,YAAY;CACb,CACD;CACA,QAAQ;EAEP,SAAS;EACT,YAAY;CACb;CACA,WAAW;CACX,SAAS;EACR,SAAS;EACT,YAAY;CACb;CACA,cAAc;EAEb;EACA;GAIC,SAAS,GAAG,mEAAoE,CAAC,MAAM,KAAK,CAAC;GAC7F,YAAY;GACZ,QAAQ;EACT;EACA;GAEC,SAAS,GAAG,qCAAwC,CAAC,MAAM,KAAK,CAAC;GACjE,YAAY;GACZ,QAAQ;EACT;CACD;CACA,gBAAgB;EACf,SAAS;EACT,OAAO;CACR;CACA,WAAW;CACX,YAAY;CACZ,UAAU;CACV,WAAW;CACX,YAAY;CACZ,eAAe;AAChB"}

package/dist/prism/tests/core-tests.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/prism/tests/coverage.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/prism/tests/helper/args.d.ts

@@ -0,0 +1,3 @@
+/** @type {string | string[]} */
+export const language: string | string[];
+export const update: boolean;

package/dist/prism/tests/helper/lang-info.d.ts

@@ -0,0 +1,4 @@
+/** @type {Record<string, string[]>} */
+export const dependencyGraph: Record<string, string[]>;
+/** @type {Record<string, string[]>} */
+export const optionals: Record<string, string[]>;

package/dist/prism/tests/helper/prism-loader.d.ts

@@ -0,0 +1,2 @@
+/** @param {string[]} langs */
+export function loadLanguages(langs: string[]): Promise<void>;

package/dist/prism/tests/helper/test-case.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Runs the given test case file and asserts the result
+ *
+ * The passed language identifier can either be a language like "css" or a composed language
+ * identifier like "css+markup". Composed identifiers can be used for testing language inclusion.
+ *
+ * When testing language inclusion, the first given language is the main language which will be passed
+ * to Prism for highlighting ("css+markup" will result in a call to Prism to highlight with the "css" grammar).
+ * But it will be ensured, that the additional passed languages will be loaded too.
+ *
+ * The languages will be loaded in the order they were provided.
+ * @param {string} filePath
+ * @param {string} languageIdentifier
+ * @param {"none" | "insert" | "update"} updateMode
+ * @param {() => void | undefined} beforeRun
+ */
+export function runTestCase(languageIdentifier: string, filePath: string, updateMode: "none" | "insert" | "update", beforeRun: () => void | undefined): Promise<void>;
+/**
+ * @param {string} languageIdentifier
+ * @param {string} filePath
+ * @param {"none" | "insert" | "update"} updateMode
+ * @param {Runner<T>} runner
+ * @param {() => void | undefined} beforeRun
+ * @template T
+ */
+export function runTestCaseWithRunner<T>(languageIdentifier: string, filePath: string, updateMode: "none" | "insert" | "update", runner: Runner<T>, beforeRun: () => void | undefined): Promise<void>;
+/**
+ * Parses the language names and finds the main language.
+ *
+ * It is either the last language or the language followed by a exclamation mark “!”.
+ * There should only be one language with an exclamation mark.
+ *
+ * @param {string} languageIdentifier
+ * @returns {{languages: string[], mainLanguage: string}}
+ */
+export function parseLanguageNames(languageIdentifier: string): {
+    languages: string[];
+    mainLanguage: string;
+};
+/**
+ * * @typedef {import("./token-stream-transformer").TokenStream} TokenStream
+ */
+/**
+ * Handles parsing and printing of a test case file.
+ *
+ * A test case file consists of at most three parts, separated by a line of at least 10 dashes.
+ * This separation line must start at the beginning of the line and consist of at least three dashes.
+ *
+ *     {code: the source code of the test case}
+ *     ----------
+ *     {expected: the expected value of the test case}
+ *     ----------
+ *     {description: explaining the test case}
+ *
+ * All parts are optional.
+ *
+ * If the file contains more than three parts, the remaining parts are part of the description.
+ */
+export class TestCaseFile {
+    /**
+     * Parses the given file contents into a test file.
+     *
+     * The line ends of the code, expected value, and description are all normalized to LF.
+     * @param {string} content
+     */
+    static parse(content: string): TestCaseFile;
+    /**
+     * Reads the given test case file from disk.
+     * @param {string} filePath
+     */
+    static readFromFile(filePath: string): TestCaseFile;
+    /**
+     * @param {string} code
+     * @param {string} [expected = '']
+     * @param {string} [description = '']
+     */
+    constructor(code: string, expected?: string, description?: string);
+    code: string;
+    expected: string;
+    description: string;
+    /**
+     * The end of line sequence used when printed.
+     *
+     * @type {"\n" | "\r\n"}
+     */
+    eol: "\n" | "\r\n";
+    /**
+     * The number of the first line of `code`.
+     *
+     * @type {number}
+     */
+    codeLineStart: number;
+    /**
+     * The number of the first line of `expected`.
+     *
+     * @type {number}
+     */
+    expectedLineStart: number;
+    /**
+     * The number of the first line of `description`.
+     *
+     * @type {number}
+     */
+    descriptionLineStart: number;
+    /**
+     * Returns the file content of the given test file.
+     */
+    print(): string;
+    /**
+     * Writes the given test case file to disk.
+     * @param {string} filePath
+     */
+    writeToFile(filePath: string): void;
+}
+/**
+ * *
+ */
+export type TokenStream = import('./token-stream-transformer').TokenStream;
+export type Runner<T> = {
+    run: (code: string, language: string) => T;
+    print: (actual: T) => string;
+    isEqual: (actual: T, expected: string) => boolean;
+    assertEqual: (actual: T, expected: string, message: (firstDifference: number) => string) => void;
+};

package/dist/prism/tests/helper/test-discovery.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Loads the list of all available tests
+ * @returns {Map<string, string[]>}
+ */
+export function loadAllTests(rootDir?: any): Map<string, string[]>;
+/**
+ * Loads the list of available tests that match the given languages
+ * @param {string | string[]} languages
+ * @param {string} [rootDir=LANGUAGES_DIR]
+ * @returns {Map<string, string[]>}
+ */
+export function loadSomeTests(languages: string | string[], rootDir?: string): Map<string, string[]>;
+/**
+ * Returns a list of all (sub)directories (just the directory names, not full paths)
+ * in the given src directory
+ * @param {string} src
+ * @returns {string[]}
+ */
+export function getAllDirectories(src: string): string[];
+/**
+ * Returns a list of all (sub)directories (just the directory names, not full paths)
+ * in the given src directory, matching the given languages
+ * @param {string | string[]} languages
+ * @param {string} src
+ */
+export function getSomeDirectories(src: string, languages: string | string[]): any;
+/**
+ * Returns whether a directory matches one of the given languages.
+ * @param {string} directory
+ * @param {string | string[]} language
+ */
+export function directoryMatches(directory: string, languages: any): boolean;

package/dist/prism/tests/helper/token-stream-transformer.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @typedef TokenStreamItem
+ * @property {string} type
+ * @property {string | Array<string|TokenStreamItem>} content
+ *
+ * @typedef {Array<string|TokenStreamItem>} TokenStream
+ *
+ * @typedef {string | [string, string | SimplifiedTokenStream]} SimplifiedToken
+ * @typedef {Array<string | [string, string | Array]>} SimplifiedTokenStream
+ *
+ * @typedef {Array<PrettyTokenStreamItem>} PrettyTokenStream
+ * @typedef {string | LineBreakItem | GlueItem | [string, string | Array]} PrettyTokenStreamItem
+ */
+/**
+ * Simplifies the token stream to ease the matching with the expected token stream.
+ *
+ * * Strings are kept as-is
+ * * In arrays each value is transformed individually
+ * * Values that are empty (empty arrays or strings only containing whitespace)
+ * @param {TokenStream} tokenStream
+ * @returns {SimplifiedTokenStream}
+ */
+export function simplify(tokenStream: TokenStream): SimplifiedTokenStream;
+/**
+ * @param {TokenStream} tokenStream
+ * @param {string} [indentation]
+ * @returns {string}
+ */
+export function prettyprint(tokenStream: TokenStream, indentation?: string): string;
+export type TokenStreamItem = {
+    type: string;
+    content: string | Array<string | TokenStreamItem>;
+};
+export type TokenStream = Array<string | TokenStreamItem>;
+export type SimplifiedToken = string | [string, string | SimplifiedTokenStream];
+export type SimplifiedTokenStream = Array<string | [string, string | any[]]>;
+export type PrettyTokenStream = Array<PrettyTokenStreamItem>;
+export type PrettyTokenStreamItem = string | LineBreakItem | GlueItem | [string, string | any[]];
+/**
+ * This item indicates that one or multiple line breaks are present between the preceding and following items in the
+ * source token stream.
+ *
+ * Only if an item is enabled will it appear in the pretty-printed token stream.
+ */
+declare class LineBreakItem {
+    /** @param {number} sourceCount */
+    constructor(sourceCount: number);
+    sourceCount: number;
+    enabled: boolean;
+}
+/**
+ * This item indicates the the preceding and following items are to be printed on the same line in the pretty-printed
+ * token stream.
+ */
+declare class GlueItem {
+}
+export {};

package/dist/prism/tests/helper/util.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Performs a breadth-first search on the given start element.
+ * @param {any} start
+ * @param {(path: { key: string, value: any }[], obj: Record<string, any>) => void} callback
+ */
+export function BFS(start: any, callback: (path: {
+    key: string;
+    value: any;
+}[], obj: Record<string, any>) => void): void;
+/**
+ * Given the `BFS` path given to `BFS` callbacks, this will return the Prism language token path of the current
+ * value (e.g. `Prism.languages.xml.tag.pattern`).
+ *
+ * @param {readonly{ key: string, value: any }[]} path
+ * @param {string} [root]
+ * @returns {string}
+ */
+export function BFSPathToPrismTokenPath(path: readonly {
+    key: string;
+    value: any;
+}[], root?: string): string;
+/**
+ * Returns the AST of a given pattern.
+ *
+ * @param {RegExp} regex
+ * @returns {LiteralAST}
+ */
+export function parseRegex(regex: RegExp): LiteralAST;
+/** @param {string} string */
+export function getLeadingSpaces(string: string): string;
+/** @param {string} string */
+export function getTrailingSpaces(string: string): string;
+/**
+ * @param {string} html
+ * @returns {string}
+ */
+export function formatHtml(html: string): string;
+/**
+ * @param {unknown} value
+ * @returns {value is RegExp}
+ */
+export function isRegExp(value: unknown): value is RegExp;
+export type Pattern = import('regexpp/ast').Pattern;
+export type Flags = import('regexpp/ast').Flags;
+export type LiteralAST = {
+    pattern: Pattern;
+    flags: Flags;
+};

package/dist/prism/tests/identifier-test.d.ts

@@ -0,0 +1,9 @@
+export type Token = {
+    type: string;
+    content: string | Token | (string | Token)[];
+};
+export type IdentifierTestOptions = {
+    word?: boolean | undefined;
+    number?: boolean | undefined;
+    template?: boolean | undefined;
+};

package/dist/prism/tests/pattern-tests.d.ts

@@ -0,0 +1,11 @@
+export type LiteralAST = import('./helper/util').LiteralAST;
+export type CapturingGroup = import('regexpp/ast').CapturingGroup;
+export type Element = import('regexpp/ast').Element;
+export type Group = import('regexpp/ast').Group;
+export type LookaroundAssertion = import('regexpp/ast').LookaroundAssertion;
+export type Pattern = import('regexpp/ast').Pattern;
+export type Highlight = {
+    start: number;
+    end: number;
+    label?: string | undefined;
+};

package/dist/prism/tests/run.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/prism/types.d.ts

@@ -0,0 +1,65 @@
+import { tokenize, rest, Token } from './core.js';
+/**
+ * A token stream is an array of strings and {@link Token} objects.
+ *
+ * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process
+ * them.
+ *
+ * 1. No adjacent strings.
+ * 2. No empty strings.
+ *
+ * The only exception here is the token stream that only contains the empty string and nothing else.
+ */
+export type TokenStream = (string | Token)[];
+export type StandardTokenName = 'atrule' | 'attr-name' | 'attr-value' | 'bold' | 'boolean' | 'builtin' | 'cdata' | 'char' | 'class-name' | 'comment' | 'constant' | 'deleted' | 'doctype' | 'entity' | 'function' | 'important' | 'inserted' | 'italic' | 'keyword' | 'namespace' | 'number' | 'operator' | 'prolog' | 'property' | 'punctuation' | 'regex' | 'selector' | 'string' | 'symbol' | 'tag' | 'url';
+export type TokenName = string & {} | StandardTokenName;
+/**
+ * The expansion of a simple `RegExp` literal to support additional properties.
+ */
+export interface GrammarToken {
+    /**
+     * The regular expression of the token.
+     */
+    pattern: RegExp;
+    /**
+     * If `true`, then the first capturing group of `pattern` will (effectively) behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token.
+     *
+     * @default false
+     */
+    lookbehind?: boolean;
+    /**
+     * No longer specifies whether the token is greedy. Set the global regex flag on the pattern instead.
+     */
+    greedy?: never;
+    /**
+     * An optional alias. Multiple aliases are separated by spaces.
+     */
+    alias?: TokenName;
+    /**
+     * The nested grammar of this token.
+     *
+     * The `inside` grammar will be used to tokenize the text value of each token of this kind.
+     *
+     * This can be used to make nested and even recursive language definitions.
+     *
+     * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into
+     * each another.
+     */
+    inside?: Grammar | string | null;
+}
+/**
+ * A custom tokenizer for a grammar.
+ *
+ * @see {@link tokenize} symbol for more info.
+ *
+ * @param code A string with the code this grammar needs to tokenize.
+ * @param grammar The grammar with the custom tokenizer
+ * @returns A token stream representing the matched code.
+ */
+export type CustomTokenizer = (code: string, grammar: Grammar) => TokenStream;
+export type GrammarTokens = Partial<Record<TokenName, RegExp | GrammarToken | (RegExp | GrammarToken)[]>>;
+export type GrammarSymbols = {
+    [rest]?: Grammar | string | null;
+    [tokenize]?: CustomTokenizer | null;
+};
+export type Grammar = GrammarTokens & GrammarSymbols;

package/dist/prism/utils/clike-class.d.ts

@@ -0,0 +1,7 @@
+export function clikeClass(): {
+    pattern: RegExp;
+    lookbehind: boolean;
+    inside: {
+        punctuation: RegExp;
+    };
+};

package/dist/prism/utils/data-uri.d.ts

@@ -0,0 +1,46 @@
+import { TokenStream } from '../types.js';
+/**
+ * Function that will highlight the body of data URIs. If you have
+ * `'data:image/svg+xml,<svg></svg>'`, then this will highlight `<svg></svg>` as XML for
+ * example.
+ *
+ * ## Usage
+ *
+ * Note that this function should be the first tokenization function that's called. If
+ * {@link matchBrackets} or {@link matchTags} are called before this function is added
+ * as a `tokenize` listener, then tags and brackets created by this won't be matched
+ * together.
+ *
+ * ### With editors
+ *
+ * To use this function with editors, add it as a `tokenize` listener.
+ *
+ * ```js
+ * createEditor(
+ *   "#editor",
+ *   { ... },
+ *   editor => editor.on("tokenize", tokenizeDataUris),
+ *   // Other tokenizers after
+ *   matchBrackets()
+ * )
+ * ```
+ *
+ * ### With code blocks
+ *
+ * To use this function with code blocks, call it inside `tokenizeCallback`.
+ *
+ * ```js
+ * renderCodeBlock({
+ *   language: "js",
+ *   code: "const foo = 'bar'",
+ *   tokenizeCallback(tokens) {
+ *     tokenizeDataUris(tokens)
+ *
+ *     // Other tokenizers after
+ *   }
+ * })
+ * ```
+ *
+ * @param {TokenStream} tokens Tokens to mutate.
+ */
+export function tokenizeDataUris(tokens: TokenStream): void;

package/dist/prism/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { clone, insertBefore, extend } from './language.js';
+export { embeddedIn } from './templating.js';
+export { tokenizeDataUris } from './data-uri.js';
+export { tokenizeInvisibles } from './invisibles.js';
+export { tokenizeStrings } from './tokenize-strings.js';