@baseplate-dev/plugin-auth 1.0.7 → 1.0.8

package/dist/web/assets/get-auth-plugin-definition-x8oAsN1R.js

@@ -0,0 +1,14 @@
+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.
+* @param definition - The project definition.
+* @returns The auth plugin definition.
+*/
+function getAuthPluginDefinition(definition) {
+	return __mf_26.configByKeyOrThrow(definition, "baseplate-dev_plugin-auth_auth");
+}
+//#endregion
+export { getAuthPluginDefinition as t };
+
+//# 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-oh7k6PLP.js

@@ -0,0 +1,99 @@
+import { t as __vitePreload } from "./vite-preload-helper-iIio8xkS.js";
+//#region \0virtual:mf:__mfe_internal__plugin_mf_2_auth__H_A_I__hostAutoInit__H_A_I__.js
+var __mfCacheGlobalKey = "__mf_module_cache__";
+globalThis[__mfCacheGlobalKey] ||= {
+	share: {},
+	remote: {}
+};
+globalThis[__mfCacheGlobalKey].share ||= {};
+globalThis[__mfCacheGlobalKey].remote ||= {};
+var __mfModuleCache = globalThis[__mfCacheGlobalKey];
+for (const __mfShareKey of Object.keys(__mfModuleCache.share)) if (__mfShareKey.startsWith("default:")) {
+	const __mfLegacyShareKey = __mfShareKey.slice(8);
+	if (__mfModuleCache.share[__mfLegacyShareKey] === void 0) __mfModuleCache.share[__mfLegacyShareKey] = __mfModuleCache.share[__mfShareKey];
+} else if (!__mfShareKey.includes(":")) {
+	const __mfDefaultShareKey = "default:" + __mfShareKey;
+	if (__mfModuleCache.share[__mfDefaultShareKey] === void 0) __mfModuleCache.share[__mfDefaultShareKey] = __mfModuleCache.share[__mfShareKey];
+}
+var hostInitPromise;
+async function initHost() {
+	if (!hostInitPromise) hostInitPromise = (async () => {
+		const __mfGetSharedCacheDescriptor = (pkg, singleton, version, scope) => {
+			const scopeName = (Array.isArray(scope) ? scope[0] : scope) || "default";
+			const id = singleton || !version ? pkg : pkg + "@" + version;
+			const descriptor = { canonical: scopeName + ":" + id };
+			if (scopeName === "default") descriptor.aliases = [id];
+			return descriptor;
+		};
+		const __mfReadSharedCache = (cache, descriptor) => {
+			const value = cache[descriptor.canonical];
+			if (value !== void 0) return value;
+			const aliases = descriptor.aliases || [];
+			for (const alias of aliases) {
+				const aliasValue = cache[alias];
+				if (aliasValue !== void 0) {
+					cache[descriptor.canonical] = aliasValue;
+					return aliasValue;
+				}
+			}
+		};
+		const __mfWriteSharedCache = (cache, descriptor, value) => {
+			cache[descriptor.canonical] = value;
+			const aliases = descriptor.aliases || [];
+			for (const alias of aliases) if (cache[alias] === void 0) cache[alias] = value;
+			return value;
+		};
+		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-DdyPR8Y-.js");
+			return { usedShared };
+		}, [], import.meta.url);
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const __mfHostInitShareOrder = [
+			"react",
+			"react-dom",
+			"zod",
+			"@baseplate-dev/ui-components",
+			"@baseplate-dev/project-builder-lib/web",
+			"@baseplate-dev/project-builder-lib",
+			"@tanstack/react-router"
+		].concat(Object.keys(usedShared).filter((pkg) => ![
+			"react",
+			"react-dom",
+			"zod",
+			"@baseplate-dev/ui-components",
+			"@baseplate-dev/project-builder-lib/web",
+			"@baseplate-dev/project-builder-lib",
+			"@tanstack/react-router"
+		].includes(pkg)));
+		for (const pkg of __mfHostInitShareOrder) {
+			const share = usedShared[pkg];
+			if (!share) continue;
+			if (share.treeShaking) continue;
+			const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+			if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== void 0) continue;
+			await runtime.loadShare(pkg, { customShareInfo: { shareConfig: share.shareConfig } }).then((factory) => {
+				const mod = typeof factory === "function" ? factory() : factory;
+				return Promise.resolve(mod).then((resolved) => {
+					__mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, __mfNormalizeRuntimeShare(resolved));
+				});
+			});
+		}
+		await Promise.all([]);
+		return runtime;
+	})();
+	return hostInitPromise;
+}
+hostInitPromise = initHost();
+//#endregion
+export { hostInitPromise, initHost };

package/dist/web/assets/index-D-gGyBWJ.js

@@ -0,0 +1,2 @@
+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-RJNeuwba.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