@baseplate-dev/plugin-auth 0.6.15 → 0.6.16

package/dist/web/assets/markdown-_2_uVr2L.js

@@ -0,0 +1,278 @@
+import { t as markup } from "./markup-BVZ8HhdW.js";
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/markdown.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+markdown.displayName = "markdown";
+markdown.aliases = ["md"];
+/** @param {Refractor} Prism */
+function markdown(Prism) {
+	Prism.register(markup);
+	(function(Prism) {
+		var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+		/**
+		* This function is intended for the creation of the bold or italic pattern.
+		*
+		* This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped.
+		*
+		* _Note:_ Keep in mind that this adds a capturing group.
+		*
+		* @param {string} pattern
+		* @returns {RegExp}
+		*/
+		function createInline(pattern) {
+			pattern = pattern.replace(/<inner>/g, function() {
+				return inner;
+			});
+			return RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + pattern + ")");
+		}
+		var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source;
+		var tableRow = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
+			return tableCell;
+		});
+		var tableLine = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
+		Prism.languages.markdown = Prism.languages.extend("markup", {});
+		Prism.languages.insertBefore("markdown", "prolog", {
+			"front-matter-block": {
+				pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					punctuation: /^---|---$/,
+					"front-matter": {
+						pattern: /\S+(?:\s+\S+)*/,
+						alias: ["yaml", "language-yaml"],
+						inside: Prism.languages.yaml
+					}
+				}
+			},
+			blockquote: {
+				pattern: /^>(?:[\t ]*>)*/m,
+				alias: "punctuation"
+			},
+			table: {
+				pattern: RegExp("^" + tableRow + tableLine + "(?:" + tableRow + ")*", "m"),
+				inside: {
+					"table-data-rows": {
+						pattern: RegExp("^(" + tableRow + tableLine + ")(?:" + tableRow + ")*$"),
+						lookbehind: true,
+						inside: {
+							"table-data": {
+								pattern: RegExp(tableCell),
+								inside: Prism.languages.markdown
+							},
+							punctuation: /\|/
+						}
+					},
+					"table-line": {
+						pattern: RegExp("^(" + tableRow + ")" + tableLine + "$"),
+						lookbehind: true,
+						inside: { punctuation: /\||:?-{3,}:?/ }
+					},
+					"table-header-row": {
+						pattern: RegExp("^" + tableRow + "$"),
+						inside: {
+							"table-header": {
+								pattern: RegExp(tableCell),
+								alias: "important",
+								inside: Prism.languages.markdown
+							},
+							punctuation: /\|/
+						}
+					}
+				}
+			},
+			code: [{
+				pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+				lookbehind: true,
+				alias: "keyword"
+			}, {
+				pattern: /^```[\s\S]*?^```$/m,
+				greedy: true,
+				inside: {
+					"code-block": {
+						pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+						lookbehind: true
+					},
+					"code-language": {
+						pattern: /^(```).+/,
+						lookbehind: true
+					},
+					punctuation: /```/
+				}
+			}],
+			title: [{
+				pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+				alias: "important",
+				inside: { punctuation: /==+$|--+$/ }
+			}, {
+				pattern: /(^\s*)#.+/m,
+				lookbehind: true,
+				alias: "important",
+				inside: { punctuation: /^#+|#+$/ }
+			}],
+			hr: {
+				pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+				lookbehind: true,
+				alias: "punctuation"
+			},
+			list: {
+				pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+				lookbehind: true,
+				alias: "punctuation"
+			},
+			"url-reference": {
+				pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+				inside: {
+					variable: {
+						pattern: /^(!?\[)[^\]]+/,
+						lookbehind: true
+					},
+					string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+					punctuation: /^[\[\]!:]|[<>]/
+				},
+				alias: "url"
+			},
+			bold: {
+				pattern: createInline(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					content: {
+						pattern: /(^..)[\s\S]+(?=..$)/,
+						lookbehind: true,
+						inside: {}
+					},
+					punctuation: /\*\*|__/
+				}
+			},
+			italic: {
+				pattern: createInline(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					content: {
+						pattern: /(^.)[\s\S]+(?=.$)/,
+						lookbehind: true,
+						inside: {}
+					},
+					punctuation: /[*_]/
+				}
+			},
+			strike: {
+				pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					content: {
+						pattern: /(^~~?)[\s\S]+(?=\1$)/,
+						lookbehind: true,
+						inside: {}
+					},
+					punctuation: /~~?/
+				}
+			},
+			"code-snippet": {
+				pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+				lookbehind: true,
+				greedy: true,
+				alias: ["code", "keyword"]
+			},
+			url: {
+				pattern: createInline(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					operator: /^!/,
+					content: {
+						pattern: /(^\[)[^\]]+(?=\])/,
+						lookbehind: true,
+						inside: {}
+					},
+					variable: {
+						pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+						lookbehind: true
+					},
+					url: {
+						pattern: /(^\]\()[^\s)]+/,
+						lookbehind: true
+					},
+					string: {
+						pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+						lookbehind: true
+					}
+				}
+			}
+		});
+		[
+			"url",
+			"bold",
+			"italic",
+			"strike"
+		].forEach(function(token) {
+			[
+				"url",
+				"bold",
+				"italic",
+				"strike",
+				"code-snippet"
+			].forEach(function(inside) {
+				if (token !== inside) Prism.languages.markdown[token].inside.content.inside[inside] = Prism.languages.markdown[inside];
+			});
+		});
+		Prism.hooks.add("after-tokenize", function(env) {
+			if (env.language !== "markdown" && env.language !== "md") return;
+			function walkTokens(tokens) {
+				if (!tokens || typeof tokens === "string") return;
+				for (var i = 0, l = tokens.length; i < l; i++) {
+					var token = tokens[i];
+					if (token.type !== "code") {
+						walkTokens(token.content);
+						continue;
+					}
+					var codeLang = token.content[1];
+					var codeBlock = token.content[3];
+					if (codeLang && codeBlock && codeLang.type === "code-language" && codeBlock.type === "code-block" && typeof codeLang.content === "string") {
+						var lang = codeLang.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+						lang = (/[a-z][\w-]*/i.exec(lang) || [""])[0].toLowerCase();
+						var alias = "language-" + lang;
+						if (!codeBlock.alias) codeBlock.alias = [alias];
+						else if (typeof codeBlock.alias === "string") codeBlock.alias = [codeBlock.alias, alias];
+						else codeBlock.alias.push(alias);
+					}
+				}
+			}
+			walkTokens(env.tokens);
+		});
+		Prism.hooks.add("wrap", function(env) {
+			if (env.type !== "code-block") return;
+			var codeLang = "";
+			for (var i = 0, l = env.classes.length; i < l; i++) {
+				var cls = env.classes[i];
+				var match = /language-(.+)/.exec(cls);
+				if (match) {
+					codeLang = match[1];
+					break;
+				}
+			}
+			var grammar = Prism.languages[codeLang];
+			if (!grammar) {
+				if (codeLang && codeLang !== "none" && Prism.plugins.autoloader) {
+					var id = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 0x2386f26fc10000);
+					env.attributes["id"] = id;
+					Prism.plugins.autoloader.loadLanguages(codeLang, function() {
+						var ele = document.getElementById(id);
+						if (ele) ele.innerHTML = Prism.highlight(ele.textContent, Prism.languages[codeLang], codeLang);
+					});
+				}
+			} else env.content = Prism.highlight(env.content.value, grammar, codeLang);
+		});
+		RegExp(Prism.languages.markup.tag.pattern.source, "gi");
+		String.fromCodePoint || String.fromCharCode;
+		Prism.languages.md = Prism.languages.markdown;
+	})(Prism);
+}
+//#endregion
+export { markdown as default };
+
+//# sourceMappingURL=markdown-_2_uVr2L.js.map

package/dist/web/assets/markup-BVZ8HhdW.js

@@ -0,0 +1,176 @@
+import { r as __exportAll } from "./rolldown-runtime-FZ4Itg2g.js";
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/markup.js
+var markup_exports = /* @__PURE__ */ __exportAll({ default: () => markup });
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+markup.displayName = "markup";
+markup.aliases = [
+	"atom",
+	"html",
+	"mathml",
+	"rss",
+	"ssml",
+	"svg",
+	"xml"
+];
+/** @param {Refractor} Prism */
+function markup(Prism) {
+	Prism.languages.markup = {
+		comment: {
+			pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+			greedy: true
+		},
+		prolog: {
+			pattern: /<\?[\s\S]+?\?>/,
+			greedy: true
+		},
+		doctype: {
+			pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+			greedy: true,
+			inside: {
+				"internal-subset": {
+					pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+					lookbehind: true,
+					greedy: true,
+					inside: null
+				},
+				string: {
+					pattern: /"[^"]*"|'[^']*'/,
+					greedy: true
+				},
+				punctuation: /^<!|>$|[[\]]/,
+				"doctype-tag": /^DOCTYPE/i,
+				name: /[^\s<>'"]+/
+			}
+		},
+		cdata: {
+			pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+			greedy: true
+		},
+		tag: {
+			pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+			greedy: true,
+			inside: {
+				tag: {
+					pattern: /^<\/?[^\s>\/]+/,
+					inside: {
+						punctuation: /^<\/?/,
+						namespace: /^[^\s>\/:]+:/
+					}
+				},
+				"special-attr": [],
+				"attr-value": {
+					pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+					inside: { punctuation: [{
+						pattern: /^=/,
+						alias: "attr-equals"
+					}, {
+						pattern: /^(\s*)["']|["']$/,
+						lookbehind: true
+					}] }
+				},
+				punctuation: /\/?>/,
+				"attr-name": {
+					pattern: /[^\s>\/]+/,
+					inside: { namespace: /^[^\s>\/:]+:/ }
+				}
+			}
+		},
+		entity: [{
+			pattern: /&[\da-z]{1,8};/i,
+			alias: "named-entity"
+		}, /&#x?[\da-f]{1,8};/i]
+	};
+	Prism.languages.markup["tag"].inside["attr-value"].inside["entity"] = Prism.languages.markup["entity"];
+	Prism.languages.markup["doctype"].inside["internal-subset"].inside = Prism.languages.markup;
+	Prism.hooks.add("wrap", function(env) {
+		if (env.type === "entity") env.attributes["title"] = env.content.value.replace(/&amp;/, "&");
+	});
+	Object.defineProperty(Prism.languages.markup.tag, "addInlined", { 
+	/**
+	* Adds an inlined language to markup.
+	*
+	* An example of an inlined language is CSS with `<style>` tags.
+	*
+	* @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+	* case insensitive.
+	* @param {string} lang The language key.
+	* @example
+	* addInlined('style', 'css');
+	*/
+value: function addInlined(tagName, lang) {
+		var includedCdataInside = {};
+		includedCdataInside["language-" + lang] = {
+			pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+			lookbehind: true,
+			inside: Prism.languages[lang]
+		};
+		includedCdataInside["cdata"] = /^<!\[CDATA\[|\]\]>$/i;
+		var inside = { "included-cdata": {
+			pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+			inside: includedCdataInside
+		} };
+		inside["language-" + lang] = {
+			pattern: /[\s\S]+/,
+			inside: Prism.languages[lang]
+		};
+		var def = {};
+		def[tagName] = {
+			pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
+				return tagName;
+			}), "i"),
+			lookbehind: true,
+			greedy: true,
+			inside
+		};
+		Prism.languages.insertBefore("markup", "cdata", def);
+	} });
+	Object.defineProperty(Prism.languages.markup.tag, "addAttribute", { 
+	/**
+	* Adds an pattern to highlight languages embedded in HTML attributes.
+	*
+	* An example of an inlined language is CSS with `style` attributes.
+	*
+	* @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+	* case insensitive.
+	* @param {string} lang The language key.
+	* @example
+	* addAttribute('style', 'css');
+	*/
+value: function(attrName, lang) {
+		Prism.languages.markup.tag.inside["special-attr"].push({
+			pattern: RegExp(/(^|["'\s])/.source + "(?:" + attrName + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source, "i"),
+			lookbehind: true,
+			inside: {
+				"attr-name": /^[^\s=]+/,
+				"attr-value": {
+					pattern: /=[\s\S]+/,
+					inside: {
+						value: {
+							pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+							lookbehind: true,
+							alias: [lang, "language-" + lang],
+							inside: Prism.languages[lang]
+						},
+						punctuation: [{
+							pattern: /^=/,
+							alias: "attr-equals"
+						}, /"|'/]
+					}
+				}
+			}
+		});
+	} });
+	Prism.languages.html = Prism.languages.markup;
+	Prism.languages.mathml = Prism.languages.markup;
+	Prism.languages.svg = Prism.languages.markup;
+	Prism.languages.xml = Prism.languages.extend("markup", {});
+	Prism.languages.ssml = Prism.languages.xml;
+	Prism.languages.atom = Prism.languages.xml;
+	Prism.languages.rss = Prism.languages.xml;
+}
+//#endregion
+export { markup_exports as n, markup as t };
+
+//# sourceMappingURL=markup-BVZ8HhdW.js.map

package/dist/web/assets/markup-templating-BDIRuVJH.js

@@ -0,0 +1,94 @@
+import { t as markup } from "./markup-BVZ8HhdW.js";
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/markup-templating.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+markupTemplating.displayName = "markup-templating";
+markupTemplating.aliases = [];
+/** @param {Refractor} Prism */
+function markupTemplating(Prism) {
+	Prism.register(markup);
+	(function(Prism) {
+		/**
+		* Returns the placeholder for the given language id and index.
+		*
+		* @param {string} language
+		* @param {string|number} index
+		* @returns {string}
+		*/
+		function getPlaceholder(language, index) {
+			return "___" + language.toUpperCase() + index + "___";
+		}
+		Object.defineProperties(Prism.languages["markup-templating"] = {}, {
+			buildPlaceholders: { 
+			/**
+			* Tokenize all inline templating expressions matching `placeholderPattern`.
+			*
+			* If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
+			* `true` will be replaced.
+			*
+			* @param {object} env The environment of the `before-tokenize` hook.
+			* @param {string} language The language id.
+			* @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
+			* @param {(match: string) => boolean} [replaceFilter]
+			*/
+value: function(env, language, placeholderPattern, replaceFilter) {
+				if (env.language !== language) return;
+				var tokenStack = env.tokenStack = [];
+				env.code = env.code.replace(placeholderPattern, function(match) {
+					if (typeof replaceFilter === "function" && !replaceFilter(match)) return match;
+					var i = tokenStack.length;
+					var placeholder;
+					while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) ++i;
+					tokenStack[i] = match;
+					return placeholder;
+				});
+				env.grammar = Prism.languages.markup;
+			} },
+			tokenizePlaceholders: { 
+			/**
+			* Replace placeholders with proper tokens after tokenizing.
+			*
+			* @param {object} env The environment of the `after-tokenize` hook.
+			* @param {string} language The language id.
+			*/
+value: function(env, language) {
+				if (env.language !== language || !env.tokenStack) return;
+				env.grammar = Prism.languages[language];
+				var j = 0;
+				var keys = Object.keys(env.tokenStack);
+				function walkTokens(tokens) {
+					for (var i = 0; i < tokens.length; i++) {
+						if (j >= keys.length) break;
+						var token = tokens[i];
+						if (typeof token === "string" || token.content && typeof token.content === "string") {
+							var k = keys[j];
+							var t = env.tokenStack[k];
+							var s = typeof token === "string" ? token : token.content;
+							var placeholder = getPlaceholder(language, k);
+							var index = s.indexOf(placeholder);
+							if (index > -1) {
+								++j;
+								var before = s.substring(0, index);
+								var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), "language-" + language, t);
+								var after = s.substring(index + placeholder.length);
+								var replacement = [];
+								if (before) replacement.push.apply(replacement, walkTokens([before]));
+								replacement.push(middle);
+								if (after) replacement.push.apply(replacement, walkTokens([after]));
+								if (typeof token === "string") tokens.splice.apply(tokens, [i, 1].concat(replacement));
+								else token.content = replacement;
+							}
+						} else if (token.content) walkTokens(token.content);
+					}
+					return tokens;
+				}
+				walkTokens(env.tokens);
+			} }
+		});
+	})(Prism);
+}
+//#endregion
+export { markupTemplating as default };
+
+//# sourceMappingURL=markup-templating-BDIRuVJH.js.map

package/dist/web/assets/{mf-entry-bootstrap-0-b337c957.js → mf-entry-bootstrap-0-659c976f.js}

@@ -25,11 +25,11 @@ const __mfImport = (src) =>
 
 
 (async () => {
-  const __mfHostInit = await __mfImport("./hostInit-BPDI3Q4j.js");
+  const __mfHostInit = await __mfImport("./hostInit-Bay0Y9UX.js");
   await __mfHostInit.__tla;
   const { initHost } = __mfHostInit;
   await initHost();
   if (__mfModuleCache.pendingShareLoads) {
     await Promise.all(__mfModuleCache.pendingShareLoads);
   }
-})().then(() => __mfImport("./index-BocHdii2.js"));
+})().then(() => __mfImport("./index-qso1IsKy.js"));