@baseplate-dev/plugin-auth 1.0.7 → 1.0.8

package/dist/web/assets/ruby-BoFHz67P.js

@@ -0,0 +1,175 @@
+import { t as clike } from "./clike-D9YNFwtw.js";
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ruby.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+ruby.displayName = "ruby";
+ruby.aliases = ["rb"];
+/** @param {Refractor} Prism */
+function ruby(Prism) {
+	Prism.register(clike);
+	(function(Prism) {
+		Prism.languages.ruby = Prism.languages.extend("clike", {
+			comment: {
+				pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
+				greedy: true
+			},
+			"class-name": {
+				pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+				lookbehind: true,
+				inside: { punctuation: /[.\\]/ }
+			},
+			keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
+			operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
+			punctuation: /[(){}[\].,;]/
+		});
+		Prism.languages.insertBefore("ruby", "operator", { "double-colon": {
+			pattern: /::/,
+			alias: "punctuation"
+		} });
+		var interpolation = {
+			pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
+			lookbehind: true,
+			inside: {
+				content: {
+					pattern: /^(#\{)[\s\S]+(?=\}$)/,
+					lookbehind: true,
+					inside: Prism.languages.ruby
+				},
+				delimiter: {
+					pattern: /^#\{|\}$/,
+					alias: "punctuation"
+				}
+			}
+		};
+		delete Prism.languages.ruby.function;
+		var percentExpression = "(?:" + [
+			/([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+			/\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
+			/\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
+			/\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
+			/<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
+		].join("|") + ")";
+		var symbolName = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
+		Prism.languages.insertBefore("ruby", "keyword", {
+			"regex-literal": [{
+				pattern: RegExp(/%r/.source + percentExpression + /[egimnosux]{0,6}/.source),
+				greedy: true,
+				inside: {
+					interpolation,
+					regex: /[\s\S]+/
+				}
+			}, {
+				pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					interpolation,
+					regex: /[\s\S]+/
+				}
+			}],
+			variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+			symbol: [{
+				pattern: RegExp(/(^|[^:]):/.source + symbolName),
+				lookbehind: true,
+				greedy: true
+			}, {
+				pattern: RegExp(/([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source),
+				lookbehind: true,
+				greedy: true
+			}],
+			"method-definition": {
+				pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+				lookbehind: true,
+				inside: {
+					function: /\b\w+$/,
+					keyword: /^self\b/,
+					"class-name": /^\w+/,
+					punctuation: /\./
+				}
+			}
+		});
+		Prism.languages.insertBefore("ruby", "string", {
+			"string-literal": [
+				{
+					pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),
+					greedy: true,
+					inside: {
+						interpolation,
+						string: /[\s\S]+/
+					}
+				},
+				{
+					pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
+					greedy: true,
+					inside: {
+						interpolation,
+						string: /[\s\S]+/
+					}
+				},
+				{
+					pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+					alias: "heredoc-string",
+					greedy: true,
+					inside: {
+						delimiter: {
+							pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+							inside: {
+								symbol: /\b\w+/,
+								punctuation: /^<<[-~]?/
+							}
+						},
+						interpolation,
+						string: /[\s\S]+/
+					}
+				},
+				{
+					pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+					alias: "heredoc-string",
+					greedy: true,
+					inside: {
+						delimiter: {
+							pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+							inside: {
+								symbol: /\b\w+/,
+								punctuation: /^<<[-~]?'|'$/
+							}
+						},
+						string: /[\s\S]+/
+					}
+				}
+			],
+			"command-literal": [{
+				pattern: RegExp(/%x/.source + percentExpression),
+				greedy: true,
+				inside: {
+					interpolation,
+					command: {
+						pattern: /[\s\S]+/,
+						alias: "string"
+					}
+				}
+			}, {
+				pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
+				greedy: true,
+				inside: {
+					interpolation,
+					command: {
+						pattern: /[\s\S]+/,
+						alias: "string"
+					}
+				}
+			}]
+		});
+		delete Prism.languages.ruby.string;
+		Prism.languages.insertBefore("ruby", "number", {
+			builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+			constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
+		});
+		Prism.languages.rb = Prism.languages.ruby;
+	})(Prism);
+}
+//#endregion
+export { ruby as default };
+
+//# sourceMappingURL=ruby-BoFHz67P.js.map

package/dist/web/assets/rust-CpZXpaj0.js

@@ -0,0 +1,107 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/rust.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+rust.displayName = "rust";
+rust.aliases = [];
+/** @param {Refractor} Prism */
+function rust(Prism) {
+	(function(Prism) {
+		var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
+		for (var i = 0; i < 2; i++) multilineComment = multilineComment.replace(/<self>/g, function() {
+			return multilineComment;
+		});
+		multilineComment = multilineComment.replace(/<self>/g, function() {
+			return /[^\s\S]/.source;
+		});
+		Prism.languages.rust = {
+			comment: [{
+				pattern: RegExp(/(^|[^\\])/.source + multilineComment),
+				lookbehind: true,
+				greedy: true
+			}, {
+				pattern: /(^|[^\\:])\/\/.*/,
+				lookbehind: true,
+				greedy: true
+			}],
+			string: {
+				pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
+				greedy: true
+			},
+			char: {
+				pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
+				greedy: true
+			},
+			attribute: {
+				pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
+				greedy: true,
+				alias: "attr-name",
+				inside: { string: null }
+			},
+			"closure-params": {
+				pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					"closure-punctuation": {
+						pattern: /^\||\|$/,
+						alias: "punctuation"
+					},
+					rest: null
+				}
+			},
+			"lifetime-annotation": {
+				pattern: /'\w+/,
+				alias: "symbol"
+			},
+			"fragment-specifier": {
+				pattern: /(\$\w+:)[a-z]+/,
+				lookbehind: true,
+				alias: "punctuation"
+			},
+			variable: /\$\w+/,
+			"function-definition": {
+				pattern: /(\bfn\s+)\w+/,
+				lookbehind: true,
+				alias: "function"
+			},
+			"type-definition": {
+				pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+				lookbehind: true,
+				alias: "class-name"
+			},
+			"module-declaration": [{
+				pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+				lookbehind: true,
+				alias: "namespace"
+			}, {
+				pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+				lookbehind: true,
+				alias: "namespace",
+				inside: { punctuation: /::/ }
+			}],
+			keyword: [/\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/, /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/],
+			function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+			macro: {
+				pattern: /\b\w+!/,
+				alias: "property"
+			},
+			constant: /\b[A-Z_][A-Z_\d]+\b/,
+			"class-name": /\b[A-Z]\w*\b/,
+			namespace: {
+				pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+				inside: { punctuation: /::/ }
+			},
+			number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+			boolean: /\b(?:false|true)\b/,
+			punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+			operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
+		};
+		Prism.languages.rust["closure-params"].inside.rest = Prism.languages.rust;
+		Prism.languages.rust["attribute"].inside["string"] = Prism.languages.rust["string"];
+	})(Prism);
+}
+//#endregion
+export { rust as default };
+
+//# sourceMappingURL=rust-CpZXpaj0.js.map

package/dist/web/assets/sass-DG0YAnL7.js

@@ -0,0 +1,65 @@
+import css from "./css-D7TbgetL.js";
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/sass.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+sass.displayName = "sass";
+sass.aliases = [];
+/** @param {Refractor} Prism */
+function sass(Prism) {
+	Prism.register(css);
+	(function(Prism) {
+		Prism.languages.sass = Prism.languages.extend("css", { comment: {
+			pattern: /^([ \t]*)\/[\/*].*(?:(?:\r?\n|\r)\1[ \t].+)*/m,
+			lookbehind: true,
+			greedy: true
+		} });
+		Prism.languages.insertBefore("sass", "atrule", { "atrule-line": {
+			pattern: /^(?:[ \t]*)[@+=].+/m,
+			greedy: true,
+			inside: { atrule: /(?:@[\w-]+|[+=])/ }
+		} });
+		delete Prism.languages.sass.atrule;
+		var variable = /\$[-\w]+|#\{\$[-\w]+\}/;
+		var operator = [/[+*\/%]|[=!]=|<=?|>=?|\b(?:and|not|or)\b/, {
+			pattern: /(\s)-(?=\s)/,
+			lookbehind: true
+		}];
+		Prism.languages.insertBefore("sass", "property", {
+			"variable-line": {
+				pattern: /^[ \t]*\$.+/m,
+				greedy: true,
+				inside: {
+					punctuation: /:/,
+					variable,
+					operator
+				}
+			},
+			"property-line": {
+				pattern: /^[ \t]*(?:[^:\s]+ *:.*|:[^:\s].*)/m,
+				greedy: true,
+				inside: {
+					property: [/[^:\s]+(?=\s*:)/, {
+						pattern: /(:)[^:\s]+/,
+						lookbehind: true
+					}],
+					punctuation: /:/,
+					variable,
+					operator,
+					important: Prism.languages.sass.important
+				}
+			}
+		});
+		delete Prism.languages.sass.property;
+		delete Prism.languages.sass.important;
+		Prism.languages.insertBefore("sass", "punctuation", { selector: {
+			pattern: /^([ \t]*)\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*(?:,(?:\r?\n|\r)\1[ \t]+\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*)*/m,
+			lookbehind: true,
+			greedy: true
+		} });
+	})(Prism);
+}
+//#endregion
+export { sass as default };
+
+//# sourceMappingURL=sass-DG0YAnL7.js.map

package/dist/web/assets/scss-BDRIqhak.js

@@ -0,0 +1,70 @@
+import css from "./css-D7TbgetL.js";
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/scss.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+scss.displayName = "scss";
+scss.aliases = [];
+/** @param {Refractor} Prism */
+function scss(Prism) {
+	Prism.register(css);
+	Prism.languages.scss = Prism.languages.extend("css", {
+		comment: {
+			pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+			lookbehind: true
+		},
+		atrule: {
+			pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
+			inside: { rule: /@[\w-]+/ }
+		},
+		url: /(?:[-a-z]+-)?url(?=\()/i,
+		selector: {
+			pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
+			inside: {
+				parent: {
+					pattern: /&/,
+					alias: "important"
+				},
+				placeholder: /%[-\w]+/,
+				variable: /\$[-\w]+|#\{\$[-\w]+\}/
+			}
+		},
+		property: {
+			pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
+			inside: { variable: /\$[-\w]+|#\{\$[-\w]+\}/ }
+		}
+	});
+	Prism.languages.insertBefore("scss", "atrule", { keyword: [/@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i, {
+		pattern: /( )(?:from|through)(?= )/,
+		lookbehind: true
+	}] });
+	Prism.languages.insertBefore("scss", "important", { variable: /\$[-\w]+|#\{\$[-\w]+\}/ });
+	Prism.languages.insertBefore("scss", "function", {
+		"module-modifier": {
+			pattern: /\b(?:as|hide|show|with)\b/i,
+			alias: "keyword"
+		},
+		placeholder: {
+			pattern: /%[-\w]+/,
+			alias: "selector"
+		},
+		statement: {
+			pattern: /\B!(?:default|optional)\b/i,
+			alias: "keyword"
+		},
+		boolean: /\b(?:false|true)\b/,
+		null: {
+			pattern: /\bnull\b/,
+			alias: "keyword"
+		},
+		operator: {
+			pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
+			lookbehind: true
+		}
+	});
+	Prism.languages.scss["atrule"].inside.rest = Prism.languages.scss;
+}
+//#endregion
+export { scss as default };
+
+//# sourceMappingURL=scss-BDRIqhak.js.map

package/dist/web/assets/sql-C-bL8_gT.js

@@ -0,0 +1,40 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/sql.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+sql.displayName = "sql";
+sql.aliases = [];
+/** @param {Refractor} Prism */
+function sql(Prism) {
+	Prism.languages.sql = {
+		comment: {
+			pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+			lookbehind: true
+		},
+		variable: [{
+			pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
+			greedy: true
+		}, /@[\w.$]+/],
+		string: {
+			pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
+			greedy: true,
+			lookbehind: true
+		},
+		identifier: {
+			pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
+			greedy: true,
+			lookbehind: true,
+			inside: { punctuation: /^`|`$/ }
+		},
+		function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
+		keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
+		boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
+		number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+		operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
+		punctuation: /[;[\]()`,.]/
+	};
+}
+//#endregion
+export { sql as default };
+
+//# sourceMappingURL=sql-C-bL8_gT.js.map

package/dist/web/assets/{style-DiK_rD1L.css → styles-Cc26Bbxc.css}

@@ -1,4 +1,4 @@
-/*! tailwindcss v4.1.18 | MIT License | https://tailwindcss.com */
+/*! tailwindcss v4.3.1 | MIT License | https://tailwindcss.com */
 @layer properties {
   @supports (((-webkit-hyphens: none)) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color: rgb(from red r g b)))) {
     *, :before, :after, ::backdrop {

package/dist/web/assets/styles-Cuq4wgvD.js

@@ -0,0 +1,176 @@
+import { $ as __mf_2, B as appendErrors, H as set, Q as __mf_1, V as get, c as __mf_157, s as __mf_156 } from "./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare___mf_0_baseplate_mf_2_dev_mf_1_ui_mf_2_components__loadShare__.js-CXGct_48.js";
+import { t as __mf_13 } from "./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare___mf_0_tanstack_mf_1_react_mf_2_router__loadShare__.js-Ci5_qYaj.js";
+import { a as parseAsync, i as parse, o as $ZodError } from "./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare__zod__loadShare__.js-Do-7VDVw.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";
+import { i as __mf_25 } 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_mf_1_web__loadShare__.js-DZIcwf2B.js";
+//#region ../../node_modules/.pnpm/@hookform+resolvers@5.2.2_react-hook-form@7.71.1/node_modules/@hookform/resolvers/dist/resolvers.mjs
+var r = (t, r, o) => {
+	if (t && "reportValidity" in t) {
+		const s = get(o, r);
+		t.setCustomValidity(s && s.message || ""), t.reportValidity();
+	}
+};
+var o = (e, t) => {
+	for (const o in t.fields) {
+		const s = t.fields[o];
+		s && s.ref && "reportValidity" in s.ref ? r(s.ref, o, e) : s && s.refs && s.refs.forEach((t) => r(t, o, e));
+	}
+};
+var s$1 = (r, s) => {
+	s.shouldUseNativeValidation && o(r, s);
+	const n = {};
+	for (const o in r) {
+		const f = get(s.fields, o), c = Object.assign(r[o] || {}, { ref: f && f.ref });
+		if (i$1(s.names || Object.keys(r), o)) {
+			const r = Object.assign({}, get(n, o));
+			set(r, "root", c), set(n, o, r);
+		} else set(n, o, c);
+	}
+	return n;
+};
+var i$1 = (e, t) => {
+	const r = n(t);
+	return e.some((e) => n(e).match(`^${r}\\.\\d+`));
+};
+function n(e) {
+	return e.replace(/\]|\[/g, "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@hookform+resolvers@5.2.2_react-hook-form@7.71.1/node_modules/@hookform/resolvers/zod/dist/zod.mjs
+function t(r, e) {
+	try {
+		var o = r();
+	} catch (r) {
+		return e(r);
+	}
+	return o && o.then ? o.then(void 0, e) : o;
+}
+function s(r, e) {
+	for (var n = {}; r.length;) {
+		var t = r[0], s = t.code, i = t.message, a = t.path.join(".");
+		if (!n[a]) if ("unionErrors" in t) {
+			var u = t.unionErrors[0].errors[0];
+			n[a] = {
+				message: u.message,
+				type: u.code
+			};
+		} else n[a] = {
+			message: i,
+			type: s
+		};
+		if ("unionErrors" in t && t.unionErrors.forEach(function(e) {
+			return e.errors.forEach(function(e) {
+				return r.push(e);
+			});
+		}), e) {
+			var c = n[a].types, f = c && c[t.code];
+			n[a] = appendErrors(a, e, n, s, f ? [].concat(f, t.message) : t.message);
+		}
+		r.shift();
+	}
+	return n;
+}
+function i(r, e) {
+	for (var n = {}; r.length;) {
+		var t = r[0], s = t.code, i = t.message, a = t.path.join(".");
+		if (!n[a]) if ("invalid_union" === t.code && t.errors.length > 0) {
+			var u = t.errors[0][0];
+			n[a] = {
+				message: u.message,
+				type: u.code
+			};
+		} else n[a] = {
+			message: i,
+			type: s
+		};
+		if ("invalid_union" === t.code && t.errors.forEach(function(e) {
+			return e.forEach(function(e) {
+				return r.push(e);
+			});
+		}), e) {
+			var c = n[a].types, f = c && c[t.code];
+			n[a] = appendErrors(a, e, n, s, f ? [].concat(f, t.message) : t.message);
+		}
+		r.shift();
+	}
+	return n;
+}
+function a(o$1, a, u) {
+	if (void 0 === u && (u = {}), function(r) {
+		return "_def" in r && "object" == typeof r._def && "typeName" in r._def;
+	}(o$1)) return function(n, i, c) {
+		try {
+			return Promise.resolve(t(function() {
+				return Promise.resolve(o$1["sync" === u.mode ? "parse" : "parseAsync"](n, a)).then(function(e) {
+					return c.shouldUseNativeValidation && o({}, c), {
+						errors: {},
+						values: u.raw ? Object.assign({}, n) : e
+					};
+				});
+			}, function(r) {
+				if (function(r) {
+					return Array.isArray(null == r ? void 0 : r.issues);
+				}(r)) return {
+					values: {},
+					errors: s$1(s(r.errors, !c.shouldUseNativeValidation && "all" === c.criteriaMode), c)
+				};
+				throw r;
+			}));
+		} catch (r) {
+			return Promise.reject(r);
+		}
+	};
+	if (function(r) {
+		return "_zod" in r && "object" == typeof r._zod;
+	}(o$1)) return function(s, c, f) {
+		try {
+			return Promise.resolve(t(function() {
+				return Promise.resolve(("sync" === u.mode ? parse : parseAsync)(o$1, s, a)).then(function(e) {
+					return f.shouldUseNativeValidation && o({}, f), {
+						errors: {},
+						values: u.raw ? Object.assign({}, s) : e
+					};
+				});
+			}, function(r) {
+				if (function(r) {
+					return r instanceof $ZodError;
+				}(r)) return {
+					values: {},
+					errors: s$1(i(r.issues, !f.shouldUseNativeValidation && "all" === f.criteriaMode), f)
+				};
+				throw r;
+			}));
+		} catch (r) {
+			return Promise.reject(r);
+		}
+	};
+	throw new Error("Invalid input: not a Zod schema");
+}
+//#endregion
+//#region src/common/components/auth-config-tabs.tsx
+function AuthConfigTabs() {
+	const { definition, schemaParserContext } = __mf_25();
+	const authPlugin = schemaParserContext.pluginStore.availablePlugins.find((p) => p.metadata.packageName === "@baseplate-dev/plugin-auth" && p.metadata.name === "auth");
+	if (!authPlugin) return null;
+	const implementationPluginKey = __mf_26.configByKey(definition, authPlugin.metadata.key)?.implementationPluginKey;
+	const authImplementationPlugin = schemaParserContext.pluginStore.availablePlugins.find((p) => p.metadata.key === implementationPluginKey);
+	if (!authImplementationPlugin) return null;
+	return /* @__PURE__ */ __mf_2(__mf_156, { children: [/* @__PURE__ */ __mf_1(__mf_157, {
+		render: /* @__PURE__ */ __mf_1(__mf_13, {
+			to: "/plugins/edit/$key",
+			params: { key: authPlugin.metadata.key },
+			activeOptions: { exact: true }
+		}),
+		children: "Auth"
+	}), /* @__PURE__ */ __mf_1(__mf_157, {
+		render: /* @__PURE__ */ __mf_1(__mf_13, {
+			to: `/plugins/edit/${authImplementationPlugin.metadata.key}`,
+			activeOptions: { exact: true }
+		}),
+		children: authImplementationPlugin.metadata.displayName
+	})] });
+}
+//#endregion
+export { a as n, AuthConfigTabs as t };
+
+//# sourceMappingURL=styles-Cuq4wgvD.js.map