@webskill/chatbot 0.0.1

package/dist/csharp-iSWtQEXl.js

@@ -0,0 +1,301 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/csharp.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+csharp.displayName = "csharp";
+csharp.aliases = ["cs", "dotnet"];
+/** @param {Refractor} Prism */
+function csharp(Prism) {
+	Prism.register(clike);
+	(function(Prism) {
+		/**
+		* Replaces all placeholders "<<n>>" of given pattern with the n-th replacement (zero based).
+		*
+		* Note: This is a simple text based replacement. Be careful when using backreferences!
+		*
+		* @param {string} pattern the given pattern.
+		* @param {string[]} replacements a list of replacement which can be inserted into the given pattern.
+		* @returns {string} the pattern with all placeholders replaced with their corresponding replacements.
+		* @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source
+		*/
+		function replace(pattern, replacements) {
+			return pattern.replace(/<<(\d+)>>/g, function(m, index) {
+				return "(?:" + replacements[+index] + ")";
+			});
+		}
+		/**
+		* @param {string} pattern
+		* @param {string[]} replacements
+		* @param {string} [flags]
+		* @returns {RegExp}
+		*/
+		function re(pattern, replacements, flags) {
+			return RegExp(replace(pattern, replacements), flags || "");
+		}
+		/**
+		* Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
+		*
+		* @param {string} pattern
+		* @param {number} depthLog2
+		* @returns {string}
+		*/
+		function nested(pattern, depthLog2) {
+			for (var i = 0; i < depthLog2; i++) pattern = pattern.replace(/<<self>>/g, function() {
+				return "(?:" + pattern + ")";
+			});
+			return pattern.replace(/<<self>>/g, "[^\\s\\S]");
+		}
+		var keywordKinds = {
+			type: "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
+			typeDeclaration: "class enum interface record struct",
+			contextual: "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)",
+			other: "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield"
+		};
+		function keywordsToPattern(words) {
+			return "\\b(?:" + words.trim().replace(/ /g, "|") + ")\\b";
+		}
+		var typeDeclarationKeywords = keywordsToPattern(keywordKinds.typeDeclaration);
+		var keywords = RegExp(keywordsToPattern(keywordKinds.type + " " + keywordKinds.typeDeclaration + " " + keywordKinds.contextual + " " + keywordKinds.other));
+		var nonTypeKeywords = keywordsToPattern(keywordKinds.typeDeclaration + " " + keywordKinds.contextual + " " + keywordKinds.other);
+		var nonContextualKeywords = keywordsToPattern(keywordKinds.type + " " + keywordKinds.typeDeclaration + " " + keywordKinds.other);
+		var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2);
+		var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.source, 2);
+		var name = /@?\b[A-Za-z_]\w*\b/.source;
+		var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [name, generic]);
+		var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [nonTypeKeywords, genericName]);
+		var array = /\[\s*(?:,\s*)*\]/.source;
+		var typeExpressionWithoutTuple = replace(/<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source, [identifier, array]);
+		var tupleElement = replace(/[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [
+			generic,
+			nestedRound,
+			array
+		]);
+		var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]);
+		var typeExpression = replace(/(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source, [
+			tuple,
+			identifier,
+			array
+		]);
+		var typeInside = {
+			keyword: keywords,
+			punctuation: /[<>()?,.:[\]]/
+		};
+		var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source;
+		var regularString = /"(?:\\.|[^\\"\r\n])*"/.source;
+		var verbatimString = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
+		Prism.languages.csharp = Prism.languages.extend("clike", {
+			string: [{
+				pattern: re(/(^|[^$\\])<<0>>/.source, [verbatimString]),
+				lookbehind: true,
+				greedy: true
+			}, {
+				pattern: re(/(^|[^@$\\])<<0>>/.source, [regularString]),
+				lookbehind: true,
+				greedy: true
+			}],
+			"class-name": [
+				{
+					pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [identifier]),
+					lookbehind: true,
+					inside: typeInside
+				},
+				{
+					pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [name, typeExpression]),
+					lookbehind: true,
+					inside: typeInside
+				},
+				{
+					pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
+					lookbehind: true
+				},
+				{
+					pattern: re(/(\b<<0>>\s+)<<1>>/.source, [typeDeclarationKeywords, genericName]),
+					lookbehind: true,
+					inside: typeInside
+				},
+				{
+					pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
+					lookbehind: true,
+					inside: typeInside
+				},
+				{
+					pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
+					lookbehind: true
+				},
+				{
+					pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [typeExpressionWithoutTuple]),
+					lookbehind: true,
+					inside: typeInside
+				},
+				{
+					pattern: re(/\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source, [
+						typeExpression,
+						nonContextualKeywords,
+						name
+					]),
+					inside: typeInside
+				}
+			],
+			keyword: keywords,
+			number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+			operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
+			punctuation: /\?\.?|::|[{}[\];(),.:]/
+		});
+		Prism.languages.insertBefore("csharp", "number", { range: {
+			pattern: /\.\./,
+			alias: "operator"
+		} });
+		Prism.languages.insertBefore("csharp", "punctuation", { "named-parameter": {
+			pattern: re(/([(,]\s*)<<0>>(?=\s*:)/.source, [name]),
+			lookbehind: true,
+			alias: "punctuation"
+		} });
+		Prism.languages.insertBefore("csharp", "class-name", {
+			namespace: {
+				pattern: re(/(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source, [name]),
+				lookbehind: true,
+				inside: { punctuation: /\./ }
+			},
+			"type-expression": {
+				pattern: re(/(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source, [nestedRound]),
+				lookbehind: true,
+				alias: "class-name",
+				inside: typeInside
+			},
+			"return-type": {
+				pattern: re(/<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source, [typeExpression, identifier]),
+				inside: typeInside,
+				alias: "class-name"
+			},
+			"constructor-invocation": {
+				pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
+				lookbehind: true,
+				inside: typeInside,
+				alias: "class-name"
+			},
+			"generic-method": {
+				pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [name, generic]),
+				inside: {
+					function: re(/^<<0>>/.source, [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|[{;]|=>|$))/.source, [
+					typeDeclarationKeywords,
+					genericName,
+					name,
+					typeExpression,
+					keywords.source,
+					nestedRound,
+					/\bnew\s*\(\s*\)/.source
+				]),
+				lookbehind: true,
+				inside: {
+					"record-arguments": {
+						pattern: re(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [genericName, nestedRound]),
+						lookbehind: true,
+						greedy: true,
+						inside: Prism.languages.csharp
+					},
+					keyword: keywords,
+					"class-name": {
+						pattern: RegExp(typeExpression),
+						greedy: true,
+						inside: typeInside
+					},
+					punctuation: /[,()]/
+				}
+			},
+			preprocessor: {
+				pattern: /(^[\t ]*)#.*/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"
+				} }
+			}
+		});
+		var regularStringOrCharacter = regularString + "|" + character;
+		var regularStringCharacterOrComment = replace(/\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source, [regularStringOrCharacter]);
+		var roundExpression = nested(replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [regularStringCharacterOrComment]), 2);
+		var attrTarget = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source;
+		var attr = replace(/<<0>>(?:\s*\(<<1>>*\))?/.source, [identifier, roundExpression]);
+		Prism.languages.insertBefore("csharp", "class-name", { attribute: {
+			pattern: re(/((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source, [attrTarget, attr]),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				target: {
+					pattern: re(/^<<0>>(?=\s*:)/.source, [attrTarget]),
+					alias: "keyword"
+				},
+				"attribute-arguments": {
+					pattern: re(/\(<<0>>*\)/.source, [roundExpression]),
+					inside: Prism.languages.csharp
+				},
+				"class-name": {
+					pattern: RegExp(identifier),
+					inside: { punctuation: /\./ }
+				},
+				punctuation: /[:,]/
+			}
+		} });
+		var formatString = /:[^}\r\n]+/.source;
+		var mInterpolationRound = nested(replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [regularStringCharacterOrComment]), 2);
+		var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [mInterpolationRound, formatString]);
+		var sInterpolationRound = nested(replace(/[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source, [regularStringOrCharacter]), 2);
+		var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [sInterpolationRound, formatString]);
+		function createInterpolationInside(interpolation, interpolationRound) {
+			return {
+				interpolation: {
+					pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]),
+					lookbehind: true,
+					inside: {
+						"format-string": {
+							pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [interpolationRound, formatString]),
+							lookbehind: true,
+							inside: { punctuation: /^:/ }
+						},
+						punctuation: /^\{|\}$/,
+						expression: {
+							pattern: /[\s\S]+/,
+							alias: "language-csharp",
+							inside: Prism.languages.csharp
+						}
+					}
+				},
+				string: /[\s\S]+/
+			};
+		}
+		Prism.languages.insertBefore("csharp", "string", {
+			"interpolation-string": [{
+				pattern: re(/(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source, [mInterpolation]),
+				lookbehind: true,
+				greedy: true,
+				inside: createInterpolationInside(mInterpolation, mInterpolationRound)
+			}, {
+				pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [sInterpolation]),
+				lookbehind: true,
+				greedy: true,
+				inside: createInterpolationInside(sInterpolation, sInterpolationRound)
+			}],
+			char: {
+				pattern: RegExp(character),
+				greedy: true
+			}
+		});
+		Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp;
+	})(Prism);
+}
+
+//#endregion
+export { csharp as default };

package/dist/cshtml-DC91Qnfw.js

@@ -0,0 +1,107 @@
+import { t as markup } from "./markup-D2NSmoAx.js";
+import csharp from "./csharp-iSWtQEXl.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cshtml.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+cshtml.displayName = "cshtml";
+cshtml.aliases = ["razor"];
+/** @param {Refractor} Prism */
+function cshtml(Prism) {
+	Prism.register(csharp);
+	Prism.register(markup);
+	(function(Prism) {
+		var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//.source;
+		var stringLike = /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source + "|" + /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
+		/**
+		* Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
+		*
+		* @param {string} pattern
+		* @param {number} depthLog2
+		* @returns {string}
+		*/
+		function nested(pattern, depthLog2) {
+			for (var i = 0; i < depthLog2; i++) pattern = pattern.replace(/<self>/g, function() {
+				return "(?:" + pattern + ")";
+			});
+			return pattern.replace(/<self>/g, "[^\\s\\S]").replace(/<str>/g, "(?:" + stringLike + ")").replace(/<comment>/g, "(?:" + commentLike + ")");
+		}
+		var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2);
+		var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 1);
+		var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2);
+		var angle = nested(/<(?:[^<>'"@/]|<comment>|<self>)*>/.source, 1);
+		var inlineCs = /@/.source + /(?:await\b\s*)?/.source + "(?:" + /(?!await\b)\w+\b/.source + "|" + round + ")(?:" + /[?!]?\.\w+\b/.source + "|(?:" + angle + ")?" + round + "|" + square + ")*" + /(?![?!\.(\[]|<(?!\/))/.source;
+		var tagAttrInlineCs = /@(?![\w()])/.source + "|" + inlineCs;
+		var tagAttrValue = "(?:" + /"[^"@]*"|'[^'@]*'|[^\s'"@>=]+(?=[\s>])/.source + "|[\"'][^\"'@]*(?:(?:" + tagAttrInlineCs + ")[^\"'@]*)+[\"'])";
+		var tagAttrs = /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*<tagAttrValue>|(?=[\s/>])))+)?/.source.replace(/<tagAttrValue>/, tagAttrValue);
+		var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source;
+		var tagRegion = /\B@?/.source + "(?:" + /<([a-zA-Z][\w:]*)/.source + tagAttrs + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + /<\/?(?!\1\b)/.source + tagContent + "|" + nested(/<\1/.source + tagAttrs + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + /<\/?(?!\1\b)/.source + tagContent + "|<self>") + ")*" + /<\/\1\s*>/.source, 2)) + ")*" + /<\/\1\s*>/.source + "|" + /</.source + tagContent + ")";
+		Prism.languages.cshtml = Prism.languages.extend("markup", {});
+		var cs = {
+			pattern: /\S[\s\S]*/,
+			alias: "language-csharp",
+			inside: Prism.languages.insertBefore("csharp", "string", { html: {
+				pattern: RegExp(tagRegion),
+				greedy: true,
+				inside: Prism.languages.cshtml
+			} }, { csharp: Prism.languages.extend("csharp", {}) })
+		};
+		var inlineValue = {
+			pattern: RegExp(/(^|[^@])/.source + inlineCs),
+			lookbehind: true,
+			greedy: true,
+			alias: "variable",
+			inside: {
+				keyword: /^@/,
+				csharp: cs
+			}
+		};
+		Prism.languages.cshtml.tag.pattern = RegExp(/<\/?/.source + tagContent);
+		Prism.languages.cshtml.tag.inside["attr-value"].pattern = RegExp(/=\s*/.source + tagAttrValue);
+		Prism.languages.insertBefore("inside", "punctuation", { value: inlineValue }, Prism.languages.cshtml.tag.inside["attr-value"]);
+		Prism.languages.insertBefore("cshtml", "prolog", {
+			"razor-comment": {
+				pattern: /@\*[\s\S]*?\*@/,
+				greedy: true,
+				alias: "comment"
+			},
+			block: {
+				pattern: RegExp(/(^|[^@])@/.source + "(?:" + [
+					curly,
+					/(?:code|functions)\s*/.source + curly,
+					/(?:for|foreach|lock|switch|using|while)\s*/.source + round + /\s*/.source + curly,
+					/do\s*/.source + curly + /\s*while\s*/.source + round + /(?:\s*;)?/.source,
+					/try\s*/.source + curly + /\s*catch\s*/.source + round + /\s*/.source + curly + /\s*finally\s*/.source + curly,
+					/if\s*/.source + round + /\s*/.source + curly + "(?:" + /\s*else/.source + "(?:" + /\s+if\s*/.source + round + ")?" + /\s*/.source + curly + ")*",
+					/helper\s+\w+\s*/.source + round + /\s*/.source + curly
+				].join("|") + ")"),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					keyword: /^@\w*/,
+					csharp: cs
+				}
+			},
+			directive: {
+				pattern: /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					keyword: /^@\w+/,
+					csharp: cs
+				}
+			},
+			value: inlineValue,
+			"delegate-operator": {
+				pattern: /(^|[^@])@(?=<)/,
+				lookbehind: true,
+				alias: "operator"
+			}
+		});
+		Prism.languages.razor = Prism.languages.cshtml;
+	})(Prism);
+}
+
+//#endregion
+export { cshtml as default };

package/dist/csp-BFJkxLlp.js

@@ -0,0 +1,63 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/csp.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+csp.displayName = "csp";
+csp.aliases = [];
+/** @param {Refractor} Prism */
+function csp(Prism) {
+	(function(Prism) {
+		/**
+		* @param {string} source
+		* @returns {RegExp}
+		*/
+		function value(source) {
+			return RegExp(/([ \t])/.source + "(?:" + source + ")" + /(?=[\s;]|$)/.source, "i");
+		}
+		Prism.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-z0-9.+-]*:/.source),
+				lookbehind: true
+			},
+			none: {
+				pattern: value(/'none'/.source),
+				lookbehind: true,
+				alias: "keyword"
+			},
+			nonce: {
+				pattern: value(/'nonce-[-+/\w=]+'/.source),
+				lookbehind: true,
+				alias: "number"
+			},
+			hash: {
+				pattern: value(/'sha(?:256|384|512)-[-+/\w=]+'/.source),
+				lookbehind: true,
+				alias: "number"
+			},
+			host: {
+				pattern: value(/[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source + "|" + /\*[^\s;,']*/.source + "|" + /[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source),
+				lookbehind: true,
+				alias: "url",
+				inside: { important: /\*/ }
+			},
+			keyword: [{
+				pattern: value(/'unsafe-[a-z-]+'/.source),
+				lookbehind: true,
+				alias: "unsafe"
+			}, {
+				pattern: value(/'[a-z-]+'/.source),
+				lookbehind: true,
+				alias: "safe"
+			}],
+			punctuation: /;/
+		};
+	})(Prism);
+}
+
+//#endregion
+export { csp as default };

package/dist/csp-dqz05oql.js

@@ -0,0 +1,30 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/csp.js
+var require_csp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function csp(hljs) {
+		return {
+			name: "CSP",
+			case_insensitive: false,
+			keywords: {
+				$pattern: "[a-zA-Z][a-zA-Z0-9_-]*",
+				keyword: "base-uri child-src connect-src default-src font-src form-action frame-ancestors frame-src img-src media-src object-src plugin-types report-uri sandbox script-src style-src"
+			},
+			contains: [{
+				className: "string",
+				begin: "'",
+				end: "'"
+			}, {
+				className: "attribute",
+				begin: "^Content",
+				end: ":",
+				excludeEnd: true
+			}]
+		};
+	}
+	module.exports = csp;
+}));
+
+//#endregion
+export default require_csp();

package/dist/css-Q6-w6BPM.js

@@ -0,0 +1,69 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/css.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+css.displayName = "css";
+css.aliases = [];
+/** @param {Refractor} Prism */
+function css(Prism) {
+	(function(Prism) {
+		var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+		Prism.languages.css = {
+			comment: /\/\*[\s\S]*?\*\//,
+			atrule: {
+				pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + string.source + ")*?" + /(?:;|(?=\s*\{))/.source),
+				inside: {
+					rule: /^@[\w-]+/,
+					"selector-function-argument": {
+						pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+						lookbehind: true,
+						alias: "selector"
+					},
+					keyword: {
+						pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+						lookbehind: true
+					}
+				}
+			},
+			url: {
+				pattern: RegExp("\\burl\\((?:" + string.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
+				greedy: true,
+				inside: {
+					function: /^url/i,
+					punctuation: /^\(|\)$/,
+					string: {
+						pattern: RegExp("^" + string.source + "$"),
+						alias: "url"
+					}
+				}
+			},
+			selector: {
+				pattern: RegExp("(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" + string.source + ")*(?=\\s*\\{)"),
+				lookbehind: true
+			},
+			string: {
+				pattern: string,
+				greedy: true
+			},
+			property: {
+				pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+				lookbehind: true
+			},
+			important: /!important\b/i,
+			function: {
+				pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+				lookbehind: true
+			},
+			punctuation: /[(){};:,]/
+		};
+		Prism.languages.css["atrule"].inside.rest = Prism.languages.css;
+		var markup = Prism.languages.markup;
+		if (markup) {
+			markup.tag.addInlined("style", "css");
+			markup.tag.addAttribute("style", "css");
+		}
+	})(Prism);
+}
+
+//#endregion
+export { css as default };