@baseplate-dev/plugin-auth 0.6.14 → 0.6.16

package/dist/web/assets/{get-auth-plugin-definition-D3ocnNxw.js → get-auth-plugin-definition-x8oAsN1R.js}

@@ -1,4 +1,4 @@
-import { f as __mf_26 } from "./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare___mf_0_baseplate_mf_2_dev_mf_1_project_mf_2_builder_mf_2_lib__loadShare__.js-0m3QgjSy.js";
+import { f as __mf_26 } from "./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare___mf_0_baseplate_mf_2_dev_mf_1_project_mf_2_builder_mf_2_lib__loadShare__.js-BfSk5vRC.js";
 //#region src/auth/utils/get-auth-plugin-definition.ts
 /**
 * Get the auth plugin definition from the project definition.
@@ -11,4 +11,4 @@ function getAuthPluginDefinition(definition) {
 //#endregion
 export { getAuthPluginDefinition as t };
 
-//# sourceMappingURL=get-auth-plugin-definition-D3ocnNxw.js.map
+//# sourceMappingURL=get-auth-plugin-definition-x8oAsN1R.js.map

package/dist/web/assets/go-CzER04EZ.js

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

package/dist/web/assets/{hostInit-D3RxwboF.js → hostInit-Bay0Y9UX.js}

@@ -45,7 +45,7 @@ async function initHost() {
 		};
 		const runtime = await (await __vitePreload(() => import("../remoteEntry.js"), [], import.meta.url)).init();
 		const { usedShared } = await __vitePreload(async () => {
-			const { usedShared } = await import("./_virtual_mf-localSharedImportMap___mfe_internal__plugin_mf_2_auth-3sV-KVGF.js");
+			const { usedShared } = await import("./_virtual_mf-localSharedImportMap___mfe_internal__plugin_mf_2_auth-04_7KkB1.js");
 			return { usedShared };
 		}, [], import.meta.url);
 		const __mfNormalizeRuntimeShare = (mod) => {

package/dist/web/assets/{index-CozZxQl1.js → index-qso1IsKy.js}

@@ -1,2 +1,2 @@
-import "./virtual_mf-exposes___mfe_internal__plugin-auth__remoteEntry_js-BQ0UMKSv.js";
-import "./virtual_mf-REMOTE_ENTRY_ID___mfe_internal__plugin-auth__remoteEntry_js-aH8n-Nbe.js";
+import "./virtual_mf-exposes___mfe_internal__plugin-auth__remoteEntry_js-DM6Ir1_S.js";
+import "./virtual_mf-REMOTE_ENTRY_ID___mfe_internal__plugin-auth__remoteEntry_js-BBt5f0I7.js";

package/dist/web/assets/ini-CU-wHLTy.js

@@ -0,0 +1,51 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ini.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+ini.displayName = "ini";
+ini.aliases = [];
+/** @param {Refractor} Prism */
+function ini(Prism) {
+	Prism.languages.ini = {
+		/**
+		* The component mimics the behavior of the Win32 API parser.
+		*
+		* @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723}
+		*/
+		comment: {
+			pattern: /(^[ \f\t\v]*)[#;][^\n\r]*/m,
+			lookbehind: true
+		},
+		section: {
+			pattern: /(^[ \f\t\v]*)\[[^\n\r\]]*\]?/m,
+			lookbehind: true,
+			inside: {
+				"section-name": {
+					pattern: /(^\[[ \f\t\v]*)[^ \f\t\v\]]+(?:[ \f\t\v]+[^ \f\t\v\]]+)*/,
+					lookbehind: true,
+					alias: "selector"
+				},
+				punctuation: /\[|\]/
+			}
+		},
+		key: {
+			pattern: /(^[ \f\t\v]*)[^ \f\n\r\t\v=]+(?:[ \f\t\v]+[^ \f\n\r\t\v=]+)*(?=[ \f\t\v]*=)/m,
+			lookbehind: true,
+			alias: "attr-name"
+		},
+		value: {
+			pattern: /(=[ \f\t\v]*)[^ \f\n\r\t\v]+(?:[ \f\t\v]+[^ \f\n\r\t\v]+)*/,
+			lookbehind: true,
+			alias: "attr-value",
+			inside: { "inner-value": {
+				pattern: /^("|').+(?=\1$)/,
+				lookbehind: true
+			} }
+		},
+		punctuation: /=/
+	};
+}
+//#endregion
+export { ini as default };
+
+//# sourceMappingURL=ini-CU-wHLTy.js.map

package/dist/web/assets/java-HAvRESj1.js

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

package/dist/web/assets/javascript-BVAr0eZH.js

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

package/dist/web/assets/json-DN8T4yFI.js

@@ -0,0 +1,38 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/json.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+json.displayName = "json";
+json.aliases = ["webmanifest"];
+/** @param {Refractor} Prism */
+function json(Prism) {
+	Prism.languages.json = {
+		property: {
+			pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+			lookbehind: true,
+			greedy: true
+		},
+		string: {
+			pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+			lookbehind: true,
+			greedy: true
+		},
+		comment: {
+			pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+			greedy: true
+		},
+		number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+		punctuation: /[{}[\],]/,
+		operator: /:/,
+		boolean: /\b(?:false|true)\b/,
+		null: {
+			pattern: /\bnull\b/,
+			alias: "keyword"
+		}
+	};
+	Prism.languages.webmanifest = Prism.languages.json;
+}
+//#endregion
+export { json as default };
+
+//# sourceMappingURL=json-DN8T4yFI.js.map

package/dist/web/assets/kotlin-DkCMjTKK.js

@@ -0,0 +1,83 @@
+import { t as clike } from "./clike-D9YNFwtw.js";
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/kotlin.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+kotlin.displayName = "kotlin";
+kotlin.aliases = ["kt", "kts"];
+/** @param {Refractor} Prism */
+function kotlin(Prism) {
+	Prism.register(clike);
+	(function(Prism) {
+		Prism.languages.kotlin = Prism.languages.extend("clike", {
+			keyword: {
+				pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+				lookbehind: true
+			},
+			function: [{
+				pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
+				greedy: true
+			}, {
+				pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
+				lookbehind: true,
+				greedy: true
+			}],
+			number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
+			operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
+		});
+		delete Prism.languages.kotlin["class-name"];
+		var interpolationInside = {
+			"interpolation-punctuation": {
+				pattern: /^\$\{?|\}$/,
+				alias: "punctuation"
+			},
+			expression: {
+				pattern: /[\s\S]+/,
+				inside: Prism.languages.kotlin
+			}
+		};
+		Prism.languages.insertBefore("kotlin", "string", {
+			"string-literal": [{
+				pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+				alias: "multiline",
+				inside: {
+					interpolation: {
+						pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+						inside: interpolationInside
+					},
+					string: /[\s\S]+/
+				}
+			}, {
+				pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+				alias: "singleline",
+				inside: {
+					interpolation: {
+						pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+						lookbehind: true,
+						inside: interpolationInside
+					},
+					string: /[\s\S]+/
+				}
+			}],
+			char: {
+				pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
+				greedy: true
+			}
+		});
+		delete Prism.languages.kotlin["string"];
+		Prism.languages.insertBefore("kotlin", "keyword", { annotation: {
+			pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+			alias: "builtin"
+		} });
+		Prism.languages.insertBefore("kotlin", "function", { label: {
+			pattern: /\b\w+@|@\w+\b/,
+			alias: "symbol"
+		} });
+		Prism.languages.kt = Prism.languages.kotlin;
+		Prism.languages.kts = Prism.languages.kotlin;
+	})(Prism);
+}
+//#endregion
+export { kotlin as default };
+
+//# sourceMappingURL=kotlin-DkCMjTKK.js.map

package/dist/web/assets/less-ZXX1tgaG.js

@@ -0,0 +1,42 @@
+import css from "./css-D7TbgetL.js";
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/less.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+less.displayName = "less";
+less.aliases = [];
+/** @param {Refractor} Prism */
+function less(Prism) {
+	Prism.register(css);
+	Prism.languages.less = Prism.languages.extend("css", {
+		comment: [/\/\*[\s\S]*?\*\//, {
+			pattern: /(^|[^\\])\/\/.*/,
+			lookbehind: true
+		}],
+		atrule: {
+			pattern: /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/,
+			inside: { punctuation: /[:()]/ }
+		},
+		selector: {
+			pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
+			inside: { variable: /@+[\w-]+/ }
+		},
+		property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
+		operator: /[+\-*\/]/
+	});
+	Prism.languages.insertBefore("less", "property", {
+		variable: [{
+			pattern: /@[\w-]+\s*:/,
+			inside: { punctuation: /:/ }
+		}, /@@?[\w-]+/],
+		"mixin-usage": {
+			pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/,
+			lookbehind: true,
+			alias: "function"
+		}
+	});
+}
+//#endregion
+export { less as default };
+
+//# sourceMappingURL=less-ZXX1tgaG.js.map

package/dist/web/assets/lua-D9bD4wrb.js

@@ -0,0 +1,28 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/lua.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+lua.displayName = "lua";
+lua.aliases = [];
+/** @param {Refractor} Prism */
+function lua(Prism) {
+	Prism.languages.lua = {
+		comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
+		string: {
+			pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
+			greedy: true
+		},
+		number: /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
+		keyword: /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
+		function: /(?!\d)\w+(?=\s*(?:[({]))/,
+		operator: [/[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/, {
+			pattern: /(^|[^.])\.\.(?!\.)/,
+			lookbehind: true
+		}],
+		punctuation: /[\[\](){},;]|\.+|:+/
+	};
+}
+//#endregion
+export { lua as default };
+
+//# sourceMappingURL=lua-D9bD4wrb.js.map

package/dist/web/assets/makefile-CKoRpler.js

@@ -0,0 +1,40 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/makefile.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+makefile.displayName = "makefile";
+makefile.aliases = [];
+/** @param {Refractor} Prism */
+function makefile(Prism) {
+	Prism.languages.makefile = {
+		comment: {
+			pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
+			lookbehind: true
+		},
+		string: {
+			pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+			greedy: true
+		},
+		"builtin-target": {
+			pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+			alias: "builtin"
+		},
+		target: {
+			pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m,
+			alias: "symbol",
+			inside: { variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/ }
+		},
+		variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+		keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
+		function: {
+			pattern: /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/,
+			lookbehind: true
+		},
+		operator: /(?:::|[?:+!])?=|[|@]/,
+		punctuation: /[:;(){}]/
+	};
+}
+//#endregion
+export { makefile as default };
+
+//# sourceMappingURL=makefile-CKoRpler.js.map