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

package/dist/prism/languages/cpp.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"cpp.js","names":[],"sources":["../../../src/prism/languages/cpp.js"],"sourcesContent":["import { languages } from '../core.js';\nimport { extend, insertBefore } from '../utils/language.js';\nimport { boolean } from '../utils/patterns.js';\nimport { re } from '../utils/shared.js';\nimport './c.js';\n\nvar keyword = /\\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\\b/;\n\nvar cpp = languages.cpp = extend('c', {\n\t'class-name': [\n\t\t{\n\t\t\tpattern: RegExp(`(\\\\b(?:class|concept|enum|struct|typename)\\\\s+)(?!${keyword.source})\\\\w+`),\n\t\t\tlookbehind: true\n\t\t},\n\t\t// This is intended to capture the class name of method implementations like:\n\t\t//   void foo::bar() const {}\n\t\t// However! The `foo` in the above example could also be a namespace, so we only capture the class name if\n\t\t// it starts with an uppercase letter. This approximation should give decent results.\n\t\t/\\b[A-Z]\\w*(?=\\s*::\\s*\\w+\\s*\\()/,\n\t\t// This will capture the class name before destructors like:\n\t\t//   Foo::~Foo() {}\n\t\t/\\b[a-z_]\\w*(?=\\s*::\\s*~\\w+\\s*\\()/i,\n\t\t// This also intends to capture the class name of method implementations but here the class has template\n\t\t// parameters, so it can't be a namespace (until C++ adds generic namespaces).\n\t\t/\\b\\w+(?=\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\\s*::\\s*\\w+\\s*\\()/\n\t],\n\t'keyword': keyword,\n\t'number': /(?:\\b0b[01']+|\\b0x(?:[a-f\\d']+(?:\\.[a-f\\d']*)?|\\.[a-f\\d']+)(?:p[+-]?[\\d']+)?|(?:\\b[\\d']+(?:\\.[\\d']*)?|\\B\\.[\\d']+)(?:e[+-]?[\\d']+)?)[ful]{0,4}/gi,\n\t'operator': /->|--|\\+\\+|&&|\\|\\||[?:~]|<=>|>>=?|<<=?|[%&|^!=<>/*+-]=?|\\b(?:and|and_eq|bitand|bitor|not|not_eq|x?or|x?or_eq)\\b/,\n\t'boolean': boolean\n});\n\ninsertBefore(cpp, 'string', {\n\t'module': {\n\t\t// https://en.cppreference.com/w/cpp/language/modules\n\t\tpattern: re(\n\t\t\t/(\\b(?:import|module)\\s+)(?:\"(?:\\\\[\\s\\S]|[^\\\\\\n\"])*\"|<[^<>\\n]*>|<0>(?:\\s*:\\s*<0>)?|:\\s*<0>)/.source, [`\\\\b(?!${keyword.source})\\\\w+(?:\\\\s*\\\\.\\\\s*\\\\w+)*\\\\b`], 'g'\n\t\t),\n\t\tlookbehind: true,\n\t\tinside: {\n\t\t\t'string': /^[<\"][\\s\\S]+/,\n\t\t\t'operator': /:/,\n\t\t\t'punctuation': /\\./\n\t\t}\n\t},\n\t'raw-string': {\n\t\tpattern: /R\"([^\\\\() ]{0,16})\\([\\s\\S]*?\\)\\1\"/g,\n\t\talias: 'string'\n\t}\n});\n\ninsertBefore(cpp, 'keyword', {\n\t'generic-function': {\n\t\tpattern: /\\b(?!operator\\b)[a-z_]\\w*\\s*<(?:[^<>]|<[^<>]*>)*>(?=\\s*\\()/i,\n\t\tinside: {\n\t\t\t'function': /^\\w+/,\n\t\t\t'generic': {\n\t\t\t\tpattern: /<[\\s\\S]+/,\n\t\t\t\talias: 'class-name',\n\t\t\t\tinside: cpp\n\t\t\t}\n\t\t}\n\t}\n});\n\ninsertBefore(cpp, 'operator', {\n\t'double-colon': {\n\t\tpattern: /::/,\n\t\talias: 'punctuation'\n\t}\n});\n\nvar baseClauseInside = Object.assign({}, cpp);\n\ninsertBefore(cpp, 'class-name', {\n\t// the base clause is an optional list of parent classes\n\t// https://en.cppreference.com/w/cpp/language/class\n\t'base-clause': {\n\t\tpattern: /(\\b(?:class|struct)\\s+\\w+\\s*:\\s*)[^;{}\"'\\s]+(?:\\s+[^;{}\"'\\s]+)*(?=\\s*[;{])/g,\n\t\tlookbehind: true,\n\t\tinside: baseClauseInside\n\t}\n});\n\ninsertBefore(baseClauseInside, 'double-colon', {\n\t// All untokenized words that are not namespaces should be class names\n\t'class-name': /\\b[a-z_]\\w*\\b(?!\\s*::)/i\n});\n\nexport { languages } from \"../core.js\";\n"],"mappings":";;;;;;AAMA,IAAI,UAAU;AAEd,IAAI,MAAM,UAAU,MAAM,OAAO,KAAK;CACrC,cAAc;EACb;GACC,SAAS,OAAO,qDAAqD,QAAQ,OAAO,MAAM;GAC1F,YAAY;EACb;EAKA;EAGA;EAGA;CACD;CACA,WAAW;CACX,UAAU;CACV,YAAY;CACZ,WAAW;AACZ,CAAC;AAED,aAAa,KAAK,UAAU;CAC3B,UAAU;EAET,SAAS,GACR,4GAAqG,CAAC,SAAS,QAAQ,OAAO,6BAA6B,GAAG,GAC/J;EACA,YAAY;EACZ,QAAQ;GACP,UAAU;GACV,YAAY;GACZ,eAAe;EAChB;CACD;CACA,cAAc;EACb,SAAS;EACT,OAAO;CACR;AACD,CAAC;AAED,aAAa,KAAK,WAAW,EAC5B,oBAAoB;CACnB,SAAS;CACT,QAAQ;EACP,YAAY;EACZ,WAAW;GACV,SAAS;GACT,OAAO;GACP,QAAQ;EACT;CACD;AACD,EACD,CAAC;AAED,aAAa,KAAK,YAAY,EAC7B,gBAAgB;CACf,SAAS;CACT,OAAO;AACR,EACD,CAAC;AAED,IAAI,mBAAmB,OAAO,OAAO,CAAC,GAAG,GAAG;AAE5C,aAAa,KAAK,cAAc,EAG/B,eAAe;CACd,SAAS;CACT,YAAY;CACZ,QAAQ;AACT,EACD,CAAC;AAED,aAAa,kBAAkB,gBAAgB,EAE9C,cAAc,0BACf,CAAC"}

package/dist/prism/languages/crystal.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/crystal.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"crystal.js","names":[],"sources":["../../../src/prism/languages/crystal.js"],"sourcesContent":["import { languages } from '../core.js';\nimport { extend, insertBefore } from '../utils/language.js';\nimport './ruby.js';\n\nvar crystal = languages.crystal = extend('ruby', {\n\t'keyword': {\n\t\tpattern: /\\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|asm?|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|[tw]hen|type|typeof|undef|uninitialized|union|unless|until|while|with|yield)\\b|(\\.\\s*)(?:is_a|responds_to)\\?/,\n\t\tlookbehind: true\n\t},\n\t'number': /\\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[a-fA-F\\d_]*[a-fA-F\\d]|(?:\\d(?:[\\d_]*\\d)?)(?:\\.[\\d_]*\\d)?(?:[eE][+-]?[\\d_]*\\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\\b/,\n\t'operator': [\n\t\t/->/,\n\t\tlanguages.ruby.operator,\n\t],\n\t'punctuation': /[()[\\]{}.,;\\\\]/,\n});\n\ninsertBefore(crystal, 'string-literal', {\n\t'attribute': {\n\t\tpattern: /@\\[.*?\\]/,\n\t\tinside: {\n\t\t\t'delimiter': {\n\t\t\t\tpattern: /^..|\\]$/g,\n\t\t\t\talias: 'punctuation'\n\t\t\t},\n\t\t\t'attribute': {\n\t\t\t\tpattern: /^(\\s*)\\w+/,\n\t\t\t\tlookbehind: true,\n\t\t\t\talias: 'class-name'\n\t\t\t},\n\t\t\t'args': {\n\t\t\t\tpattern: /\\S(?:.*\\S)?/,\n\t\t\t\tinside: crystal\n\t\t\t},\n\t\t}\n\t},\n\t'expansion': {\n\t\tpattern: /\\{(?:\\{.*?\\}|%.*?%)\\}/,\n\t\tinside: {\n\t\t\t'delimiter': {\n\t\t\t\tpattern: /^..|..$/g,\n\t\t\t\talias: 'operator'\n\t\t\t},\n\t\t\t'content': {\n\t\t\t\tpattern: /.+/,\n\t\t\t\tinside: crystal\n\t\t\t},\n\t\t}\n\t},\n\t'char': /'(?:[^\\\\\\n]{1,2}|\\\\(?:.|u(?:[a-fA-F\\d]{1,4}|\\{[a-fA-F\\d]{1,6}\\})))'/g\n});\n\nexport { languages } from \"../core.js\";\n"],"mappings":";;;;AAIA,IAAI,UAAU,UAAU,UAAU,OAAO,QAAQ;CAChD,WAAW;EACV,SAAS;EACT,YAAY;CACb;CACA,UAAU;CACV,YAAY,CACX,MACA,UAAU,KAAK,QAChB;CACA,eAAe;AAChB,CAAC;AAED,aAAa,SAAS,kBAAkB;CACvC,aAAa;EACZ,SAAS;EACT,QAAQ;GACP,aAAa;IACZ,SAAS;IACT,OAAO;GACR;GACA,aAAa;IACZ,SAAS;IACT,YAAY;IACZ,OAAO;GACR;GACA,QAAQ;IACP,SAAS;IACT,QAAQ;GACT;EACD;CACD;CACA,aAAa;EACZ,SAAS;EACT,QAAQ;GACP,aAAa;IACZ,SAAS;IACT,OAAO;GACR;GACA,WAAW;IACV,SAAS;IACT,QAAQ;GACT;EACD;CACD;CACA,QAAQ;AACT,CAAC"}

package/dist/prism/languages/csharp.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/csharp.js

@@ -0,0 +1,235 @@
+import { a as languages } from "../../core-DpDyJ-7r.js";
+import { n as clikeComment, o as dotPunctuation, t as boolean } from "../../patterns-DSInPV_c.js";
+import { n as re, r as replace, t as nested } from "../../shared-oTKIFAwH.js";
+//#region src/prism/languages/csharp.js
+var keywordsToPattern = (words) => `\\b(?:${words})\\b`;
+var typeKeyword = "bool|char|decimal|double|dynamic|float|object|s?byte|string|u?int|u?long|u?short|var|void";
+var typeDeclarationKeyword = "class|enum|interface|record|struct";
+var contextualKeyword = "add|alias|and|ascending|async|await|by|descending|from(?!\\s*[^\\s\\w])|[gls]et|global|group|into|init(?=\\s*;)|join|nameof|not|notnull|on|or|orderby|partial|remove|select|unmanaged|value|when|where|with(?=\\s*{)";
+var otherKeyword = "abstract|as|[bc]ase|break|catch|checked|const|continue|default|delegate|do|else|event|explicit|extern|finally|fixed|for|foreach|goto|i[fns]|implicit|internal|lock|namespace|new|null|operator|out|override|params|private|protected|public|readonly|ref|return|sealed|sizeof|stackalloc|static|switch|this|throw|try|typeof|unchecked|unsafe|using|virtual|volatile|while|yield";
+var typeDeclarationKeywords = keywordsToPattern(typeDeclarationKeyword);
+var keywords = RegExp(keywordsToPattern(typeKeyword + "|" + typeDeclarationKeyword + "|" + contextualKeyword + "|" + otherKeyword));
+var nonTypeKeywords = keywordsToPattern(typeDeclarationKeyword + "|" + contextualKeyword + "|" + otherKeyword);
+var nonContextualKeywords = keywordsToPattern(typeKeyword + "|" + typeDeclarationKeyword + "|" + otherKeyword);
+var generic = nested("<(?:[^<>;=*/%&|^+-]|<self>)*>", 2);
+var nestedRound = nested("\\((?:[^()]|<self>)*\\)", 2);
+var name = "@?\\b(?!\\d)\\w+\\b";
+var genericName = replace("<0>(?:\\s*<1>)?", [name, generic]);
+var identifier = replace("(?!<0>)<1>(?:\\s*\\.\\s*<1>)*", [nonTypeKeywords, genericName]);
+var array = "\\[\\s*(?:,\\s*)*\\]";
+var typeExpressionWithoutTuple = replace("<0>(?:\\s*(?:\\?\\s*)?<1>)*(?:\\s*\\?)?", [identifier, array]);
+var typeExpression = replace("(?:<0>|<1>)(?:\\s*(?:\\?\\s*)?<2>)*(?:\\s*\\?)?", [
+	replace("\\(<0>+(?:,<0>+)+\\)", [replace("[^()[\\],;%&|^=<>/*+-]|<0>|<1>|<2>", [
+		generic,
+		nestedRound,
+		array
+	])]),
+	identifier,
+	array
+]);
+var typeInside = {
+	"keyword": keywords,
+	"punctuation": /[()[\].,:<>?]/
+};
+var character = "'(?:\\\\.|[^\n'\\\\]|\\\\[Uux][a-fA-F\\d]{1,8})'";
+var regularString = "\"(?:\\\\.|[^\\\\\n\"])*\"";
+var verbatimString = "@\"(?:\"\"|\\\\[\\s\\S]|[^\\\\\"])*\"(?!\")";
+var regularStringOrCharacter = regularString + "|" + character;
+var regularStringCharacterOrComment = replace("/(?![*/])|//[^\n]*\n|/\\*(?:[^*]|\\*(?!/))*\\*/|<0>", [regularStringOrCharacter]);
+var roundExpression = nested(replace("[^()\"'/]|<0>|\\(<self>*\\)", [regularStringCharacterOrComment]), 2);
+var attrTarget = "\\b(?:assembly|event|field|method|module|param|property|return|type)\\b";
+var attr = replace("<0>(?:\\s*\\(<1>*\\))?", [identifier, roundExpression]);
+var formatString = ":[^\n}]+";
+var mInterpolationRound = nested(replace("[^()\"'/]|<0>|\\(<self>*\\)", [regularStringCharacterOrComment]), 2);
+var mInterpolation = replace("\\{(?!\\{)(?:(?![}:])<0>)*<1>?\\}", [mInterpolationRound, formatString]);
+var sInterpolationRound = nested(replace("[^()\"'/]|/(?!\\*)|/\\*(?:[^*]|\\*(?!/))*\\*/|<0>|\\(<self>*\\)", [regularStringOrCharacter]), 2);
+var sInterpolation = replace("\\{(?!\\{)(?:(?![}:])<0>)*<1>?\\}", [sInterpolationRound, formatString]);
+var createInterpolationInside = (interpolation, interpolationRound) => ({
+	"interpolation": {
+		pattern: re("((?:^|[^{])(?:\\{\\{)*)<0>", [interpolation]),
+		lookbehind: true,
+		inside: {
+			"format-string": {
+				pattern: re("(^\\{(?:(?![}:])<0>)*)<1>(?=\\}$)", [interpolationRound, formatString]),
+				lookbehind: true,
+				inside: { "punctuation": /^:/ }
+			},
+			"punctuation": /^\{|\}$/,
+			"expression": {
+				pattern: /[^]+/,
+				alias: "language-csharp",
+				inside: "cs"
+			}
+		}
+	},
+	"string": /[^]+/
+});
+languages.dotnet = languages.cs = languages.csharp = {
+	"comment": clikeComment,
+	"interpolation-string": [{
+		pattern: re("(^|[^\\\\])(?:\\$@|@\\$)\"(?:\"\"|\\\\[\\s\\S]|\\{\\{|<0>|[^\\\\{\"])*\"", [mInterpolation], "g"),
+		lookbehind: true,
+		inside: createInterpolationInside(mInterpolation, mInterpolationRound)
+	}, {
+		pattern: re("(^|[^\\\\@])\\$\"(?:\\\\.|\\{\\{|<0>|[^\\\\\"{])*\"", [sInterpolation], "g"),
+		lookbehind: true,
+		inside: createInterpolationInside(sInterpolation, sInterpolationRound)
+	}],
+	"char": RegExp(character, "g"),
+	"string": [{
+		pattern: re("(^|[^\\\\$])<0>", [verbatimString], "g"),
+		lookbehind: true
+	}, {
+		pattern: re("(^|[^\\\\@$])<0>", [regularString], "g"),
+		lookbehind: true
+	}],
+	"namespace": {
+		pattern: re("(\\b(?:namespace|using)\\s+)<0>(?:\\s*\\.\\s*<0>)*(?=\\s*[;{])", [name]),
+		lookbehind: true,
+		inside: dotPunctuation
+	},
+	"type-expression": {
+		pattern: re("(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<0>)+(?=\\s*\\))", [nestedRound]),
+		lookbehind: true,
+		alias: "class-name",
+		inside: typeInside
+	},
+	"return-type": {
+		pattern: re("<0>(?=\\s+(?:<1>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))", [typeExpression, identifier]),
+		alias: "class-name",
+		inside: typeInside
+	},
+	"constructor-invocation": {
+		pattern: re("(\\bnew\\s+)<0>(?=\\s*[[({])", [typeExpression]),
+		lookbehind: true,
+		alias: "class-name",
+		inside: typeInside
+	},
+	"generic-method": {
+		pattern: re("<0>\\s*<1>(?=\\s*\\()", [name, generic]),
+		inside: {
+			"function": re("^<0>", [name]),
+			"generic": {
+				pattern: RegExp(generic),
+				alias: "class-name",
+				inside: typeInside
+			}
+		}
+	},
+	"type-list": {
+		pattern: re("\\b((?:<0>\\s+<1>|record\\s+<1>\\s*<5>|where\\s+<2>)\\s*:\\s*)(?:<3>|<4>|<1>\\s*<5>|<6>)(?:\\s*,\\s*(?:<3>|<4>|<6>))*(?=\\s*(?:where|[{;]|=>|$))", [
+			typeDeclarationKeywords,
+			genericName,
+			name,
+			typeExpression,
+			keywords.source,
+			nestedRound,
+			"\\bnew\\s*\\(\\s*\\)"
+		]),
+		lookbehind: true,
+		inside: {
+			"record-arguments": {
+				pattern: re("(^(?!new\\s*\\()<0>\\s*)<1>", [genericName, nestedRound], "g"),
+				lookbehind: true,
+				inside: "cs"
+			},
+			"keyword": keywords,
+			"class-name": {
+				pattern: RegExp(typeExpression, "g"),
+				inside: typeInside
+			},
+			"punctuation": /[(),]/
+		}
+	},
+	"preprocessor": {
+		pattern: /(^[ 	]*)#.*/m,
+		lookbehind: true,
+		alias: "property",
+		inside: { "directive": {
+			pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+			lookbehind: true,
+			alias: "keyword"
+		} }
+	},
+	"attribute": {
+		pattern: re("((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<0>\\s*:\\s*)?<1>(?:\\s*,\\s*<1>)*(?=\\s*\\])", [attrTarget, attr], "g"),
+		lookbehind: true,
+		inside: {
+			"target": {
+				pattern: re("^<0>(?=\\s*:)", [attrTarget]),
+				alias: "keyword"
+			},
+			"attribute-arguments": {
+				pattern: re("\\(<0>*\\)", [roundExpression]),
+				inside: "cs"
+			},
+			"class-name": {
+				pattern: RegExp(identifier),
+				inside: dotPunctuation
+			},
+			"punctuation": /[,:]/
+		}
+	},
+	"class-name": [
+		{
+			pattern: re("(\\busing\\s+static\\s+)<0>(?=\\s*;)", [identifier]),
+			lookbehind: true,
+			inside: typeInside
+		},
+		{
+			pattern: re("(\\busing\\s+<0>\\s*=\\s*)<1>(?=\\s*;)", [name, typeExpression]),
+			lookbehind: true,
+			inside: typeInside
+		},
+		{
+			pattern: re("(\\busing\\s+)<0>(?=\\s*=)", [name]),
+			lookbehind: true
+		},
+		{
+			pattern: re("(\\b<0>\\s+)<1>", [typeDeclarationKeywords, genericName]),
+			lookbehind: true,
+			inside: typeInside
+		},
+		{
+			pattern: re("(\\bcatch\\s*\\(\\s*)<0>", [identifier]),
+			lookbehind: true,
+			inside: typeInside
+		},
+		{
+			pattern: re("(\\bwhere\\s+)<0>", [name]),
+			lookbehind: true
+		},
+		{
+			pattern: re("(\\b(?:is(?:\\s+not)?|as)\\s+)<0>", [typeExpressionWithoutTuple]),
+			lookbehind: true,
+			inside: typeInside
+		},
+		{
+			pattern: re("\\b<0>(?=\\s+(?!<1>|with\\s*\\{)<2>(?:\\s*[=,:;{)\\]]|\\s+(?:in|when)\\b))", [
+				typeExpression,
+				nonContextualKeywords,
+				name
+			]),
+			inside: typeInside
+		}
+	],
+	"keyword": keywords,
+	"boolean": boolean,
+	"function": /\b\w+(?=\()/,
+	"range": {
+		pattern: /\.\./,
+		alias: "operator"
+	},
+	"number": /(?:\b0(?:x[a-f\d_]*[a-f\d]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[+-]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+	"operator": /[=-]>|([&|+-])\1|~|\?\?=?|>>=?|<<=?|[%&|^!=<>/*+-]=?/,
+	"named-parameter": {
+		pattern: re("([(,]\\s*)<0>(?=\\s*:)", [name]),
+		lookbehind: true,
+		alias: "punctuation"
+	},
+	"punctuation": /\?\.?|::|[()[\]{}.,:;]/
+};
+//#endregion
+export { languages };
+
+//# sourceMappingURL=csharp.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"csharp.js","names":[],"sources":["../../../src/prism/languages/csharp.js"],"sourcesContent":["import { languages } from '../core.js';\nimport { boolean, clikeComment, dotPunctuation } from '../utils/patterns.js';\nimport { nested, re, replace } from '../utils/shared.js';\n\nvar keywordsToPattern = words => `\\\\b(?:${words})\\\\b`;\n\n// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/\nvar typeKeyword = 'bool|char|decimal|double|dynamic|float|object|s?byte|string|u?int|u?long|u?short|var|void'\nvar typeDeclarationKeyword = 'class|enum|interface|record|struct'\nvar contextualKeyword = 'add|alias|and|ascending|async|await|by|descending|from(?!\\\\s*[^\\\\s\\\\w])|[gls]et|global|group|into|init(?=\\\\s*;)|join|nameof|not|notnull|on|or|orderby|partial|remove|select|unmanaged|value|when|where|with(?=\\\\s*{)'\nvar otherKeyword = 'abstract|as|[bc]ase|break|catch|checked|const|continue|default|delegate|do|else|event|explicit|extern|finally|fixed|for|foreach|goto|i[fns]|implicit|internal|lock|namespace|new|null|operator|out|override|params|private|protected|public|readonly|ref|return|sealed|sizeof|stackalloc|static|switch|this|throw|try|typeof|unchecked|unsafe|using|virtual|volatile|while|yield'\n\n// keywords\nvar typeDeclarationKeywords = keywordsToPattern(typeDeclarationKeyword);\nvar keywords = RegExp(keywordsToPattern(typeKeyword + '|' + typeDeclarationKeyword + '|' + contextualKeyword + '|' + otherKeyword));\nvar nonTypeKeywords = keywordsToPattern(typeDeclarationKeyword + '|' + contextualKeyword + '|' + otherKeyword);\nvar nonContextualKeywords = keywordsToPattern(typeKeyword + '|' + typeDeclarationKeyword + '|' + otherKeyword);\n\n// types\nvar generic = nested(/<(?:[^<>;=*/%&|^+-]|<self>)*>/.source, 2); // the idea behind the other forbidden characters is to prevent false positives. Same for tupleElement.\nvar nestedRound = nested(/\\((?:[^()]|<self>)*\\)/.source, 2);\nvar name = /@?\\b(?!\\d)\\w+\\b/.source;\nvar genericName = replace(/<0>(?:\\s*<1>)?/.source, [name, generic]);\nvar identifier = replace(/(?!<0>)<1>(?:\\s*\\.\\s*<1>)*/.source, [nonTypeKeywords, genericName]);\nvar array = /\\[\\s*(?:,\\s*)*\\]/.source;\nvar typeExpressionWithoutTuple = replace(/<0>(?:\\s*(?:\\?\\s*)?<1>)*(?:\\s*\\?)?/.source, [identifier, array]);\nvar tupleElement = replace(/[^()[\\],;%&|^=<>/*+-]|<0>|<1>|<2>/.source, [generic, nestedRound, array]);\nvar tuple = replace(/\\(<0>+(?:,<0>+)+\\)/.source, [tupleElement]);\nvar typeExpression = replace(/(?:<0>|<1>)(?:\\s*(?:\\?\\s*)?<2>)*(?:\\s*\\?)?/.source, [tuple, identifier, array]);\n\nvar typeInside = {\n\t'keyword': keywords,\n\t'punctuation': /[()[\\].,:<>?]/\n};\n\n// strings & characters\n// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#character-literals\n// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#string-literals\nvar character = /'(?:\\\\.|[^\\n'\\\\]|\\\\[Uux][a-fA-F\\d]{1,8})'/.source; // simplified pattern\nvar regularString = /\"(?:\\\\.|[^\\\\\\n\"])*\"/.source;\nvar verbatimString = /@\"(?:\"\"|\\\\[\\s\\S]|[^\\\\\"])*\"(?!\")/.source;\n\n// attributes\nvar regularStringOrCharacter = regularString + '|' + character;\nvar regularStringCharacterOrComment = replace(/\\/(?![*/])|\\/\\/[^\\n]*\\n|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<0>/.source, [regularStringOrCharacter]);\nvar roundExpression = nested(replace(/[^()\"'/]|<0>|\\(<self>*\\)/.source, [regularStringCharacterOrComment]), 2);\n\n// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/#attribute-targets\nvar attrTarget = /\\b(?:assembly|event|field|method|module|param|property|return|type)\\b/.source;\nvar attr = replace(/<0>(?:\\s*\\(<1>*\\))?/.source, [identifier, roundExpression]);\n\n// string interpolation\nvar formatString = /:[^\\n}]+/.source;\n// multi line\nvar mInterpolationRound = nested(replace(/[^()\"'/]|<0>|\\(<self>*\\)/.source, [regularStringCharacterOrComment]), 2);\nvar mInterpolation = replace(/\\{(?!\\{)(?:(?![}:])<0>)*<1>?\\}/.source, [mInterpolationRound, formatString]);\n// single line\nvar sInterpolationRound = nested(replace(/[^()\"'/]|\\/(?!\\*)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<0>|\\(<self>*\\)/.source, [regularStringOrCharacter]), 2);\nvar sInterpolation = replace(/\\{(?!\\{)(?:(?![}:])<0>)*<1>?\\}/.source, [sInterpolationRound, formatString]);\n\nvar createInterpolationInside = (interpolation, interpolationRound) => ({\n\t'interpolation': {\n\t\tpattern: re(/((?:^|[^{])(?:\\{\\{)*)<0>/.source, [interpolation]),\n\t\tlookbehind: true,\n\t\tinside: {\n\t\t\t'format-string': {\n\t\t\t\tpattern: re(/(^\\{(?:(?![}:])<0>)*)<1>(?=\\}$)/.source, [interpolationRound, formatString]),\n\t\t\t\tlookbehind: true,\n\t\t\t\tinside: {\n\t\t\t\t\t'punctuation': /^:/\n\t\t\t\t}\n\t\t\t},\n\t\t\t'punctuation': /^\\{|\\}$/,\n\t\t\t'expression': {\n\t\t\t\tpattern: /[\\s\\S]+/,\n\t\t\t\talias: 'language-csharp',\n\t\t\t\tinside: 'cs'\n\t\t\t}\n\t\t}\n\t},\n\t'string': /[\\s\\S]+/\n});\n\nlanguages.dotnet = languages.cs = languages.csharp = {\n\t'comment': clikeComment,\n\t'interpolation-string': [\n\t\t{\n\t\t\tpattern: re(/(^|[^\\\\])(?:\\$@|@\\$)\"(?:\"\"|\\\\[\\s\\S]|\\{\\{|<0>|[^\\\\{\"])*\"/.source, [mInterpolation], 'g'),\n\t\t\tlookbehind: true,\n\t\t\tinside: createInterpolationInside(mInterpolation, mInterpolationRound),\n\t\t},\n\t\t{\n\t\t\tpattern: re(/(^|[^\\\\@])\\$\"(?:\\\\.|\\{\\{|<0>|[^\\\\\"{])*\"/.source, [sInterpolation], 'g'),\n\t\t\tlookbehind: true,\n\t\t\tinside: createInterpolationInside(sInterpolation, sInterpolationRound),\n\t\t}\n\t],\n\t'char': RegExp(character, 'g'),\n\t'string': [\n\t\t{\n\t\t\tpattern: re(/(^|[^\\\\$])<0>/.source, [verbatimString], 'g'),\n\t\t\tlookbehind: true\n\t\t},\n\t\t{\n\t\t\tpattern: re(/(^|[^\\\\@$])<0>/.source, [regularString], 'g'),\n\t\t\tlookbehind: true\n\t\t}\n\t],\n\t'namespace': {\n\t\t// namespace Foo.Bar {}\n\t\t// using Foo.Bar;\n\t\tpattern: re(/(\\b(?:namespace|using)\\s+)<0>(?:\\s*\\.\\s*<0>)*(?=\\s*[;{])/.source, [name]),\n\t\tlookbehind: true,\n\t\tinside: dotPunctuation\n\t},\n\t'type-expression': {\n\t\t// default(Foo), typeof(Foo<Bar>), sizeof(int)\n\t\tpattern: re(/(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<0>)+(?=\\s*\\))/.source, [nestedRound]),\n\t\tlookbehind: true,\n\t\talias: 'class-name',\n\t\tinside: typeInside\n\t},\n\t'return-type': {\n\t\t// Foo<Bar> ForBar(); Foo IFoo.Bar() => 0\n\t\t// int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];\n\t\t// int Foo => 0; int Foo { get; set } = 0;\n\t\tpattern: re(/<0>(?=\\s+(?:<1>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))/.source, [typeExpression, identifier]),\n\t\talias: 'class-name',\n\t\tinside: typeInside\n\t},\n\t'constructor-invocation': {\n\t\t// new List<Foo<Bar[]>> { }\n\t\tpattern: re(/(\\bnew\\s+)<0>(?=\\s*[[({])/.source, [typeExpression]),\n\t\tlookbehind: true,\n\t\talias: 'class-name',\n\t\tinside: typeInside\n\t},\n\t/*'explicit-implementation': {\n\t\t// int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();\n\t\tpattern: replace(/\\b<0>(?=\\.<1>)/, className, methodOrPropertyDeclaration),\n\t\tinside: classNameInside,\n\t\talias: 'class-name'\n\t},*/\n\t'generic-method': {\n\t\t// foo<Bar>()\n\t\tpattern: re(/<0>\\s*<1>(?=\\s*\\()/.source, [name, generic]),\n\t\tinside: {\n\t\t\t'function': re(/^<0>/.source, [name]),\n\t\t\t'generic': {\n\t\t\t\tpattern: RegExp(generic),\n\t\t\t\talias: 'class-name',\n\t\t\t\tinside: typeInside\n\t\t\t}\n\t\t}\n\t},\n\t'type-list': {\n\t\t// The list of types inherited or of generic constraints\n\t\t// class Foo<F> : Bar, IList<FooBar>\n\t\t// where F : Bar, IList<int>\n\t\tpattern: re(\n\t\t\t/\\b((?:<0>\\s+<1>|record\\s+<1>\\s*<5>|where\\s+<2>)\\s*:\\s*)(?:<3>|<4>|<1>\\s*<5>|<6>)(?:\\s*,\\s*(?:<3>|<4>|<6>))*(?=\\s*(?:where|[{;]|=>|$))/.source,\n\t\t\t[typeDeclarationKeywords, genericName, name, typeExpression, keywords.source, nestedRound, /\\bnew\\s*\\(\\s*\\)/.source]\n\t\t),\n\t\tlookbehind: true,\n\t\tinside: {\n\t\t\t'record-arguments': {\n\t\t\t\tpattern: re(/(^(?!new\\s*\\()<0>\\s*)<1>/.source, [genericName, nestedRound], 'g'),\n\t\t\t\tlookbehind: true,\n\t\t\t\tinside: 'cs'\n\t\t\t},\n\t\t\t'keyword': keywords,\n\t\t\t'class-name': {\n\t\t\t\tpattern: RegExp(typeExpression, 'g'),\n\t\t\t\tinside: typeInside\n\t\t\t},\n\t\t\t'punctuation': /[(),]/\n\t\t}\n\t},\n\t'preprocessor': {\n\t\tpattern: /(^[ \\t]*)#.*/m,\n\t\tlookbehind: true,\n\t\talias: 'property',\n\t\tinside: {\n\t\t\t// highlight preprocessor directives as keywords\n\t\t\t'directive': {\n\t\t\t\tpattern: /(#)\\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\\b/,\n\t\t\t\tlookbehind: true,\n\t\t\t\talias: 'keyword'\n\t\t\t}\n\t\t}\n\t},\n\t'attribute': {\n\t\t// Attributes\n\t\t// [Foo], [Foo(1), Bar(2, Prop = \"foo\")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]\n\t\tpattern: re(/((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<0>\\s*:\\s*)?<1>(?:\\s*,\\s*<1>)*(?=\\s*\\])/.source, [attrTarget, attr], 'g'),\n\t\tlookbehind: true,\n\t\tinside: {\n\t\t\t'target': {\n\t\t\t\tpattern: re(/^<0>(?=\\s*:)/.source, [attrTarget]),\n\t\t\t\talias: 'keyword'\n\t\t\t},\n\t\t\t'attribute-arguments': {\n\t\t\t\tpattern: re(/\\(<0>*\\)/.source, [roundExpression]),\n\t\t\t\tinside: 'cs'\n\t\t\t},\n\t\t\t'class-name': {\n\t\t\t\tpattern: RegExp(identifier),\n\t\t\t\tinside: dotPunctuation\n\t\t\t},\n\t\t\t'punctuation': /[,:]/\n\t\t}\n\t},\n\t'class-name': [\n\t\t{\n\t\t\t// Using static\n\t\t\t// using static System.Math;\n\t\t\tpattern: re(/(\\busing\\s+static\\s+)<0>(?=\\s*;)/.source, [identifier]),\n\t\t\tlookbehind: true,\n\t\t\tinside: typeInside\n\t\t},\n\t\t{\n\t\t\t// Using alias (type)\n\t\t\t// using Project = PC.MyCompany.Project;\n\t\t\tpattern: re(/(\\busing\\s+<0>\\s*=\\s*)<1>(?=\\s*;)/.source, [name, typeExpression]),\n\t\t\tlookbehind: true,\n\t\t\tinside: typeInside\n\t\t},\n\t\t{\n\t\t\t// Using alias (alias)\n\t\t\t// using Project = PC.MyCompany.Project;\n\t\t\tpattern: re(/(\\busing\\s+)<0>(?=\\s*=)/.source, [name]),\n\t\t\tlookbehind: true\n\t\t},\n\t\t{\n\t\t\t// Type declarations\n\t\t\t// class Foo<A, B>\n\t\t\t// interface Foo<out A, B>\n\t\t\tpattern: re(/(\\b<0>\\s+)<1>/.source, [typeDeclarationKeywords, genericName]),\n\t\t\tlookbehind: true,\n\t\t\tinside: typeInside\n\t\t},\n\t\t{\n\t\t\t// Single catch exception declaration\n\t\t\t// catch(Foo)\n\t\t\t// (things like catch(Foo e) is covered by variable declaration)\n\t\t\tpattern: re(/(\\bcatch\\s*\\(\\s*)<0>/.source, [identifier]),\n\t\t\tlookbehind: true,\n\t\t\tinside: typeInside\n\t\t},\n\t\t{\n\t\t\t// Name of the type parameter of generic constraints\n\t\t\t// where Foo : class\n\t\t\tpattern: re(/(\\bwhere\\s+)<0>/.source, [name]),\n\t\t\tlookbehind: true\n\t\t},\n\t\t{\n\t\t\t// Casts and checks via as and is.\n\t\t\t// as Foo<A>, is Bar<B>\n\t\t\t// (things like if(a is Foo b) is covered by variable declaration)\n\t\t\tpattern: re(/(\\b(?:is(?:\\s+not)?|as)\\s+)<0>/.source, [typeExpressionWithoutTuple]),\n\t\t\tlookbehind: true,\n\t\t\tinside: typeInside\n\t\t},\n\t\t{\n\t\t\t// Variable, field and parameter declaration\n\t\t\t// (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)\n\t\t\tpattern: re(/\\b<0>(?=\\s+(?!<1>|with\\s*\\{)<2>(?:\\s*[=,:;{)\\]]|\\s+(?:in|when)\\b))/.source, [typeExpression, nonContextualKeywords, name]),\n\t\t\tinside: typeInside\n\t\t}\n\t],\n\t'keyword': keywords,\n\t'boolean': boolean,\n\t'function': /\\b\\w+(?=\\()/,\n\t'range': {\n\t\tpattern: /\\.\\./,\n\t\talias: 'operator'\n\t},\n\t// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals\n\t'number': /(?:\\b0(?:x[a-f\\d_]*[a-f\\d]|b[01_]*[01])|(?:\\B\\.\\d+(?:_+\\d+)*|\\b\\d+(?:_+\\d+)*(?:\\.\\d+(?:_+\\d+)*)?)(?:e[+-]?\\d+(?:_+\\d+)*)?)(?:[dflmu]|lu|ul)?\\b/i,\n\t'operator': /[=-]>|([&|+-])\\1|~|\\?\\?=?|>>=?|<<=?|[%&|^!=<>/*+-]=?/,\n\t'named-parameter': {\n\t\tpattern: re(/([(,]\\s*)<0>(?=\\s*:)/.source, [name]),\n\t\tlookbehind: true,\n\t\talias: 'punctuation'\n\t},\n\t'punctuation': /\\?\\.?|::|[()[\\]{}.,:;]/\n};\n\nexport { languages } from \"../core.js\";\n"],"mappings":"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"}

package/dist/prism/languages/cshtml.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/cshtml.js

@@ -0,0 +1,72 @@
+import { a as languages } from "../../core-DpDyJ-7r.js";
+import { r as insertBefore, t as clone } from "../../language-CPVUjid6.js";
+import { r as replace, t as nested } from "../../shared-oTKIFAwH.js";
+import "./markup.js";
+import "./csharp.js";
+//#region src/prism/languages/cshtml.js
+var commentLike = "/(?![/*])|//.*\n|/\\*[^*]*(?:\\*(?!/)[^*]*)*\\*/";
+var stringLike = `@(?!")|"(?:[^\\\\\n"]|\\\\.)*"|@"(?:\\\\[^]|[^\\\\"]|"")*"(?!")|'(?:(?:[^\\\\\n']|\\\\.|\\\\[Uux][\a-fA-F\d]{1,8})'|(?=[^\\\\](?!')))`;
+var round = nested(replace("\\((?:[^()\"'@/]|<0>|<1>|<self>)*\\)", [stringLike, commentLike]), 2);
+var square = nested(replace("\\[(?:[^[\\]\"'@/]|<0>|<1>|<self>)*\\]", [stringLike, commentLike]), 1);
+var curly = nested(replace("\\{(?:[^{}\"'@/]|<0>|<1>|<self>)*\\}", [stringLike, commentLike]), 2);
+var inlineCs = `@(?:await\\b\\s*)?(?:(?!await\\b)\\w+\\b|${round})(?:[?!]?\\.\\w+\\b|(?:${nested(replace("<(?:[^<>\"'@/]|<0>|<self>)*>", [commentLike]), 1)})?${round}|${square})*(?![?!\\.(\\[]|<(?!\\/))`;
+var tagAttrValue = `(?:"[^"@]*"|'[^'@]*'|[^\\s"'@=>]+(?=[\\s>])|["'][^"'@]*(?:(?:${"@(?![()\\w])|" + inlineCs})[^"\'@]*)+["\'])`;
+var tagAttrs = `(?:\\s(?:\\s*[^\\s/=>]+(?:\\s*=\\s*${tagAttrValue}|(?=[\\s/>])))+)?`;
+var tagContent = `(?!\\d)[^\\s/=>$<%]+${tagAttrs}\\s*\\/?>`;
+var tagRegion = `\\B@?(?:<([a-zA-Z][\\w:]*)${tagAttrs}\\s*>(?:[^<]|<\\/?(?!\\1\\b)${tagContent}|${nested(`<\\1${tagAttrs}\\s*>(?:[^<]|<\\/?(?!\\1\\b)${tagContent}|<self>)*<\\/\\1\\s*>`, 2)})*<\\/\\1\\s*>|<${tagContent})`;
+var cshtml = languages.razor = languages.cshtml = clone(languages.html);
+var csharpWithHtml = clone(languages.cs);
+var cs = {
+	pattern: /\S[^]*/,
+	alias: "language-csharp",
+	inside: csharpWithHtml
+};
+var inlineValue = {
+	pattern: RegExp("(^|[^@])" + inlineCs, "g"),
+	lookbehind: true,
+	alias: "variable",
+	inside: {
+		"keyword": /^@/,
+		"csharp": cs
+	}
+};
+var attrValue = cshtml.tag.inside["attr-value"][2];
+cshtml.tag.pattern = RegExp("</?" + tagContent, "g");
+attrValue.pattern = RegExp("(=\\s*)" + tagAttrValue, "g");
+insertBefore(csharpWithHtml, "string", { "html": {
+	pattern: RegExp(tagRegion, "g"),
+	inside: cshtml
+} });
+insertBefore(attrValue.inside, "punctuation", { "value": inlineValue });
+insertBefore(cshtml, "prolog", {
+	"razor-comment": {
+		pattern: /@\*[^]*?\*@/g,
+		alias: "comment"
+	},
+	"block": {
+		pattern: RegExp(`(^|[^@])@(?:${curly}|(?:code|functions)\\s*${curly}|(?:for|foreach|lock|switch|using|while)\\s*${round}\\s*${curly}|do\\s*${curly}\\s*while\\s*${round}(?:\\s*;)?|try\\s*${curly}\\s*catch\\s*${round}\\s*${curly}\\s*finally\\s*${curly}|if\\s*${round}\\s*${curly}(?:\\s*else(?:\\s+if\\s*${round})?\\s*${curly})*|helper\\s+\\w+\\s*${round}\\s*${curly})`, "g"),
+		lookbehind: true,
+		inside: {
+			"keyword": /^@\w*/,
+			"csharp": cs
+		}
+	},
+	"directive": {
+		pattern: /^([ 	]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/gm,
+		lookbehind: true,
+		inside: {
+			"keyword": /^@\w+/,
+			"csharp": cs
+		}
+	},
+	"value": inlineValue,
+	"delegate-operator": {
+		pattern: /(^|[^@])@(?=<)/,
+		lookbehind: true,
+		alias: "operator"
+	}
+});
+//#endregion
+export { languages };
+
+//# sourceMappingURL=cshtml.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cshtml.js","names":[],"sources":["../../../src/prism/languages/cshtml.js"],"sourcesContent":["import { languages } from '../core.js';\nimport { clone, insertBefore } from '../utils/language.js';\nimport { nested, replace } from '../utils/shared.js';\nimport './markup.js';\nimport './csharp.js';\n\nvar commentLike = /\\/(?![/*])|\\/\\/.*\\n|\\/\\*[^*]*(?:\\*(?!\\/)[^*]*)*\\*\\//.source;\nvar stringLike = `@(?!\")|\"(?:[^\\\\\\\\\\n\"]|\\\\\\\\.)*\"|@\"(?:\\\\\\\\[\\\\s\\\\S]|[^\\\\\\\\\"]|\"\")*\"(?!\")|'(?:(?:[^\\\\\\\\\\n']|\\\\\\\\.|\\\\\\\\[Uux][\\a-fA-F\\d]{1,8})'|(?=[^\\\\\\\\](?!')))`;\n\nvar round = nested(replace(/\\((?:[^()\"'@/]|<0>|<1>|<self>)*\\)/.source, [stringLike, commentLike]), 2);\nvar square = nested(replace(/\\[(?:[^[\\]\"'@/]|<0>|<1>|<self>)*\\]/.source, [stringLike, commentLike]), 1);\nvar curly = nested(replace(/\\{(?:[^{}\"'@/]|<0>|<1>|<self>)*\\}/.source, [stringLike, commentLike]), 2);\nvar angle = nested(replace(/<(?:[^<>\"'@/]|<0>|<self>)*>/.source, [commentLike]), 1);\n\nvar inlineCs = `@(?:await\\\\b\\\\s*)?(?:(?!await\\\\b)\\\\w+\\\\b|${round})(?:[?!]?\\\\.\\\\w+\\\\b|(?:${angle})?${round}|${square})*(?![?!\\\\.(\\\\[]|<(?!\\\\/))`;\n\n// Note about the above bracket patterns:\n// They all ignore HTML expressions that might be in the C# code. This is a problem because HTML (like strings and\n// comments) is parsed differently. This is a huge problem because HTML might contain brackets and quotes which\n// messes up the bracket and string counting implemented by the above patterns.\n//\n// This problem is not fixable because 1) HTML expression are highly context sensitive and very difficult to detect\n// and 2) they require one capturing group at every nested level. See the `tagRegion` pattern to admire the\n// complexity of an HTML expression.\n//\n// To somewhat alleviate the problem a bit, the patterns for characters (e.g. 'a') is very permissive, it also\n// allows invalid characters to support HTML expressions like this: <p>That's it!</p>.\n\nvar tagAttrInlineCs = \"@(?![()\\\\w])|\" + inlineCs;\nvar tagAttrValue = `(?:\"[^\"@]*\"|'[^'@]*'|[^\\\\s\"'@=>]+(?=[\\\\s>])|[\"'][^\"'@]*(?:(?:${tagAttrInlineCs})[^\"\\'@]*)+[\"\\'])`;\n\nvar tagAttrs = `(?:\\\\s(?:\\\\s*[^\\\\s/=>]+(?:\\\\s*=\\\\s*${tagAttrValue}|(?=[\\\\s/>])))+)?`;\nvar tagContent = `(?!\\\\d)[^\\\\s/=>$<%]+${tagAttrs}\\\\s*\\\\/?>`;\nvar tagRegion = `\\\\B@?(?:<([a-zA-Z][\\\\w:]*)${tagAttrs}\\\\s*>(?:[^<]|<\\\\/?(?!\\\\1\\\\b)${tagContent}|${nested(\n\t`<\\\\1${tagAttrs}\\\\s*>(?:[^<]|<\\\\/?(?!\\\\1\\\\b)${tagContent}|<self>)*<\\\\/\\\\1\\\\s*>`, 2\n)})*<\\\\/\\\\1\\\\s*>|<${tagContent})`\n\n// Now for the actual language definition(s):\n//\n// Razor as a language has 2 parts:\n//  1) CSHTML: A markup-like language that has been extended with inline C# code expressions and blocks.\n//  2) C#+HTML: A variant of C# that can contain CSHTML tags as expressions.\n//\n// In the below code, both CSHTML and C#+HTML will be create as separate language definitions that reference each\n// other. However, only CSHTML will be exported via `languages`.\n\nvar cshtml = languages.razor = languages.cshtml = clone(languages.html);\n\nvar csharpWithHtml = clone(languages.cs);\n\nvar cs = {\n\tpattern: /\\S[\\s\\S]*/,\n\talias: 'language-csharp',\n\tinside: csharpWithHtml\n};\n\nvar inlineValue = {\n\tpattern: RegExp(/(^|[^@])/.source + inlineCs, 'g'),\n\tlookbehind: true,\n\talias: 'variable',\n\tinside: {\n\t\t'keyword': /^@/,\n\t\t'csharp': cs\n\t}\n};\n\nvar attrValue = cshtml.tag.inside['attr-value'][2];\n\ncshtml.tag.pattern = RegExp(/<\\/?/.source + tagContent, 'g');\nattrValue.pattern = RegExp(/(=\\s*)/.source + tagAttrValue, 'g');\n\ninsertBefore(csharpWithHtml, 'string', {\n\t'html': {\n\t\tpattern: RegExp(tagRegion, 'g'),\n\t\tinside: cshtml\n\t}\n});\n\ninsertBefore(attrValue.inside, 'punctuation', { 'value': inlineValue });\n\ninsertBefore(cshtml, 'prolog', {\n\t'razor-comment': {\n\t\tpattern: /@\\*[\\s\\S]*?\\*@/g,\n\t\talias: 'comment'\n\t},\n\n\t'block': {\n\t\tpattern: RegExp(\n\t\t\t`(^|[^@])@(?:${curly}|(?:code|functions)\\\\s*${curly}|(?:for|foreach|lock|switch|using|while)\\\\s*${\n\t\t\t\tround\n\t\t\t}\\\\s*${curly}|do\\\\s*${curly}\\\\s*while\\\\s*${round}(?:\\\\s*;)?|try\\\\s*${curly}\\\\s*catch\\\\s*${round}\\\\s*${curly}\\\\s*finally\\\\s*${\n\t\t\t\tcurly\n\t\t\t}|if\\\\s*${round}\\\\s*${curly}(?:\\\\s*else(?:\\\\s+if\\\\s*${round})?\\\\s*${curly})*|helper\\\\s+\\\\w+\\\\s*${round}\\\\s*${curly})`, 'g'\n\t\t),\n\t\tlookbehind: true,\n\t\tinside: {\n\t\t\t'keyword': /^@\\w*/,\n\t\t\t'csharp': cs\n\t\t}\n\t},\n\n\t'directive': {\n\t\tpattern: /^([ \\t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\\s).*/mg,\n\t\tlookbehind: true,\n\t\tinside: {\n\t\t\t'keyword': /^@\\w+/,\n\t\t\t'csharp': cs\n\t\t}\n\t},\n\n\t'value': inlineValue,\n\n\t'delegate-operator': {\n\t\tpattern: /(^|[^@])@(?=<)/,\n\t\tlookbehind: true,\n\t\talias: 'operator'\n\t}\n});\n\nexport { languages } from \"../core.js\";\n"],"mappings":";;;;;;AAMA,IAAI,cAAc;AAClB,IAAI,aAAa;AAEjB,IAAI,QAAQ,OAAO,QAAQ,wCAA4C,CAAC,YAAY,WAAW,CAAC,GAAG,CAAC;AACpG,IAAI,SAAS,OAAO,QAAQ,0CAA6C,CAAC,YAAY,WAAW,CAAC,GAAG,CAAC;AACtG,IAAI,QAAQ,OAAO,QAAQ,wCAA4C,CAAC,YAAY,WAAW,CAAC,GAAG,CAAC;AAGpG,IAAI,WAAW,4CAA4C,MAAM,yBAFrD,OAAO,QAAQ,gCAAsC,CAAC,WAAW,CAAC,GAAG,CAEa,EAAE,IAAI,MAAM,GAAG,OAAO;AAepH,IAAI,eAAe,gEADG,kBAAkB,SAC2D;AAEnG,IAAI,WAAW,sCAAsC,aAAa;AAClE,IAAI,aAAa,uBAAuB,SAAS;AACjD,IAAI,YAAY,6BAA6B,SAAS,8BAA8B,WAAW,GAAG,OACjG,OAAO,SAAS,8BAA8B,WAAW,wBAAwB,CAClF,EAAE,kBAAkB,WAAW;AAW/B,IAAI,SAAS,UAAU,QAAQ,UAAU,SAAS,MAAM,UAAU,IAAI;AAEtE,IAAI,iBAAiB,MAAM,UAAU,EAAE;AAEvC,IAAI,KAAK;CACR,SAAS;CACT,OAAO;CACP,QAAQ;AACT;AAEA,IAAI,cAAc;CACjB,SAAS,OAAO,aAAoB,UAAU,GAAG;CACjD,YAAY;CACZ,OAAO;CACP,QAAQ;EACP,WAAW;EACX,UAAU;CACX;AACD;AAEA,IAAI,YAAY,OAAO,IAAI,OAAO,cAAc;AAEhD,OAAO,IAAI,UAAU,OAAO,QAAgB,YAAY,GAAG;AAC3D,UAAU,UAAU,OAAO,YAAkB,cAAc,GAAG;AAE9D,aAAa,gBAAgB,UAAU,EACtC,QAAQ;CACP,SAAS,OAAO,WAAW,GAAG;CAC9B,QAAQ;AACT,EACD,CAAC;AAED,aAAa,UAAU,QAAQ,eAAe,EAAE,SAAS,YAAY,CAAC;AAEtE,aAAa,QAAQ,UAAU;CAC9B,iBAAiB;EAChB,SAAS;EACT,OAAO;CACR;CAEA,SAAS;EACR,SAAS,OACR,eAAe,MAAM,yBAAyB,MAAM,8CACnD,MACA,MAAM,MAAM,SAAS,MAAM,eAAe,MAAM,oBAAoB,MAAM,eAAe,MAAM,MAAM,MAAM,iBAC3G,MACA,SAAS,MAAM,MAAM,MAAM,0BAA0B,MAAM,QAAQ,MAAM,uBAAuB,MAAM,MAAM,MAAM,IAAI,GACxH;EACA,YAAY;EACZ,QAAQ;GACP,WAAW;GACX,UAAU;EACX;CACD;CAEA,aAAa;EACZ,SAAS;EACT,YAAY;EACZ,QAAQ;GACP,WAAW;GACX,UAAU;EACX;CACD;CAEA,SAAS;CAET,qBAAqB;EACpB,SAAS;EACT,YAAY;EACZ,OAAO;CACR;AACD,CAAC"}

package/dist/prism/languages/csp.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/csp.js

@@ -0,0 +1,50 @@
+import { a as languages } from "../../core-DpDyJ-7r.js";
+//#region src/prism/languages/csp.js
+/** @param {string} pattern */
+var value = (pattern) => RegExp("([ 	])(?:" + pattern + ")(?![^\\s;])", "i");
+languages.csp = {
+	"directive": {
+		pattern: /(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?![^\s;])/i,
+		lookbehind: true,
+		alias: "property"
+	},
+	"scheme": {
+		pattern: value("[a-z][a-z\\d.+-]*:"),
+		lookbehind: true
+	},
+	"none": {
+		pattern: value("'none'"),
+		lookbehind: true,
+		alias: "keyword"
+	},
+	"nonce": {
+		pattern: value("'nonce-[\\w=/+-]+'"),
+		lookbehind: true,
+		alias: "number"
+	},
+	"hash": {
+		pattern: value("'sha(?:256|384|512)-[\\w=/+-]+'"),
+		lookbehind: true,
+		alias: "number"
+	},
+	"host": {
+		pattern: value("[a-z][a-z\\d.+-]*://[^\\s;,']*|\\*[^\\s;,']*|[a-z\\d-]+(?:\\.[a-z\\d-]+)+(?::[\\d*]+)?(?:/[^\\s;,']*)?"),
+		lookbehind: true,
+		alias: "url",
+		inside: { "important": /\*/ }
+	},
+	"keyword": [{
+		pattern: value("'unsafe-[a-z-]+'"),
+		lookbehind: true,
+		alias: "unsafe"
+	}, {
+		pattern: value("'[a-z-]+'"),
+		lookbehind: true,
+		alias: "safe"
+	}],
+	"punctuation": /;/
+};
+//#endregion
+export { languages };
+
+//# sourceMappingURL=csp.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"csp.js","names":[],"sources":["../../../src/prism/languages/csp.js"],"sourcesContent":["import { languages } from '../core.js';\n\n/** @param {string} pattern */\nvar value = pattern => RegExp('([ \\t])(?:' + pattern + ')(?![^\\\\s;])', 'i');\n\nlanguages.csp = {\n\t'directive': {\n\t\tpattern: /(^|[\\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?![^\\s;])/i,\n\t\tlookbehind: true,\n\t\talias: 'property'\n\t},\n\t'scheme': {\n\t\tpattern: value(/[a-z][a-z\\d.+-]*:/.source),\n\t\tlookbehind: true\n\t},\n\t'none': {\n\t\tpattern: value(/'none'/.source),\n\t\tlookbehind: true,\n\t\talias: 'keyword'\n\t},\n\t'nonce': {\n\t\tpattern: value(/'nonce-[\\w=/+-]+'/.source),\n\t\tlookbehind: true,\n\t\talias: 'number'\n\t},\n\t'hash': {\n\t\tpattern: value(/'sha(?:256|384|512)-[\\w=/+-]+'/.source),\n\t\tlookbehind: true,\n\t\talias: 'number'\n\t},\n\t'host': {\n\t\tpattern: value(\n\t\t\t/[a-z][a-z\\d.+-]*:\\/\\/[^\\s;,']*|\\*[^\\s;,']*|[a-z\\d-]+(?:\\.[a-z\\d-]+)+(?::[\\d*]+)?(?:\\/[^\\s;,']*)?/.source\n\t\t),\n\t\tlookbehind: true,\n\t\talias: 'url',\n\t\tinside: {\n\t\t\t'important': /\\*/\n\t\t}\n\t},\n\t'keyword': [\n\t\t{\n\t\t\tpattern: value(/'unsafe-[a-z-]+'/.source),\n\t\t\tlookbehind: true,\n\t\t\talias: 'unsafe'\n\t\t},\n\t\t{\n\t\t\tpattern: value(/'[a-z-]+'/.source),\n\t\t\tlookbehind: true,\n\t\t\talias: 'safe'\n\t\t},\n\t],\n\t'punctuation': /;/\n};\n\nexport { languages } from \"../core.js\";\n"],"mappings":";;;AAGA,IAAI,SAAQ,YAAW,OAAO,cAAe,UAAU,gBAAgB,GAAG;AAE1E,UAAU,MAAM;CACf,aAAa;EACZ,SAAS;EACT,YAAY;EACZ,OAAO;CACR;CACA,UAAU;EACT,SAAS,MAAM,oBAA0B;EACzC,YAAY;CACb;CACA,QAAQ;EACP,SAAS,MAAM,QAAe;EAC9B,YAAY;EACZ,OAAO;CACR;CACA,SAAS;EACR,SAAS,MAAM,oBAA0B;EACzC,YAAY;EACZ,OAAO;CACR;CACA,QAAQ;EACP,SAAS,MAAM,iCAAuC;EACtD,YAAY;EACZ,OAAO;CACR;CACA,QAAQ;EACP,SAAS,MACR,wGACD;EACA,YAAY;EACZ,OAAO;EACP,QAAQ,EACP,aAAa,KACd;CACD;CACA,WAAW,CACV;EACC,SAAS,MAAM,kBAAyB;EACxC,YAAY;EACZ,OAAO;CACR,GACA;EACC,SAAS,MAAM,WAAkB;EACjC,YAAY;EACZ,OAAO;CACR,CACD;CACA,eAAe;AAChB"}

package/dist/prism/languages/css-extras.d.ts

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