@baseplate-dev/plugin-auth 0.6.14 → 0.6.16

package/dist/web/assets/php-JTON0zp9.js

@@ -0,0 +1,298 @@
+import markupTemplating from "./markup-templating-BDIRuVJH.js";
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/php.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+php.displayName = "php";
+php.aliases = [];
+/** @param {Refractor} Prism */
+function php(Prism) {
+	Prism.register(markupTemplating);
+	(function(Prism) {
+		var comment = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/;
+		var constant = [
+			{
+				pattern: /\b(?:false|true)\b/i,
+				alias: "boolean"
+			},
+			{
+				pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
+				greedy: true,
+				lookbehind: true
+			},
+			{
+				pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
+				greedy: true,
+				lookbehind: true
+			},
+			/\b(?:null)\b/i,
+			/\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
+		];
+		var number = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i;
+		var operator = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/;
+		var punctuation = /[{}\[\](),:;]/;
+		Prism.languages.php = {
+			delimiter: {
+				pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+				alias: "important"
+			},
+			comment,
+			variable: /\$+(?:\w+\b|(?=\{))/,
+			package: {
+				pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+				lookbehind: true,
+				inside: { punctuation: /\\/ }
+			},
+			"class-name-definition": {
+				pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+				lookbehind: true,
+				alias: "class-name"
+			},
+			"function-definition": {
+				pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+				lookbehind: true,
+				alias: "function"
+			},
+			keyword: [
+				{
+					pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
+					alias: "type-casting",
+					greedy: true,
+					lookbehind: true
+				},
+				{
+					pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
+					alias: "type-hint",
+					greedy: true,
+					lookbehind: true
+				},
+				{
+					pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
+					alias: "return-type",
+					greedy: true,
+					lookbehind: true
+				},
+				{
+					pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
+					alias: "type-declaration",
+					greedy: true
+				},
+				{
+					pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
+					alias: "type-declaration",
+					greedy: true,
+					lookbehind: true
+				},
+				{
+					pattern: /\b(?:parent|self|static)(?=\s*::)/i,
+					alias: "static-context",
+					greedy: true
+				},
+				{
+					pattern: /(\byield\s+)from\b/i,
+					lookbehind: true
+				},
+				/\bclass\b/i,
+				{
+					pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
+					lookbehind: true
+				}
+			],
+			"argument-name": {
+				pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
+				lookbehind: true
+			},
+			"class-name": [
+				{
+					pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
+					greedy: true,
+					lookbehind: true
+				},
+				{
+					pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
+					greedy: true,
+					lookbehind: true
+				},
+				{
+					pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
+					greedy: true
+				},
+				{
+					pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
+					alias: "class-name-fully-qualified",
+					greedy: true,
+					lookbehind: true,
+					inside: { punctuation: /\\/ }
+				},
+				{
+					pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
+					alias: "class-name-fully-qualified",
+					greedy: true,
+					inside: { punctuation: /\\/ }
+				},
+				{
+					pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+					alias: "class-name-fully-qualified",
+					greedy: true,
+					lookbehind: true,
+					inside: { punctuation: /\\/ }
+				},
+				{
+					pattern: /\b[a-z_]\w*(?=\s*\$)/i,
+					alias: "type-declaration",
+					greedy: true
+				},
+				{
+					pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+					alias: ["class-name-fully-qualified", "type-declaration"],
+					greedy: true,
+					inside: { punctuation: /\\/ }
+				},
+				{
+					pattern: /\b[a-z_]\w*(?=\s*::)/i,
+					alias: "static-context",
+					greedy: true
+				},
+				{
+					pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
+					alias: ["class-name-fully-qualified", "static-context"],
+					greedy: true,
+					inside: { punctuation: /\\/ }
+				},
+				{
+					pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
+					alias: "type-hint",
+					greedy: true,
+					lookbehind: true
+				},
+				{
+					pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+					alias: ["class-name-fully-qualified", "type-hint"],
+					greedy: true,
+					lookbehind: true,
+					inside: { punctuation: /\\/ }
+				},
+				{
+					pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
+					alias: "return-type",
+					greedy: true,
+					lookbehind: true
+				},
+				{
+					pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+					alias: ["class-name-fully-qualified", "return-type"],
+					greedy: true,
+					lookbehind: true,
+					inside: { punctuation: /\\/ }
+				}
+			],
+			constant,
+			function: {
+				pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+				lookbehind: true,
+				inside: { punctuation: /\\/ }
+			},
+			property: {
+				pattern: /(->\s*)\w+/,
+				lookbehind: true
+			},
+			number,
+			operator,
+			punctuation
+		};
+		var string_interpolation = {
+			pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
+			lookbehind: true,
+			inside: Prism.languages.php
+		};
+		var string = [
+			{
+				pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
+				alias: "nowdoc-string",
+				greedy: true,
+				inside: { delimiter: {
+					pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+					alias: "symbol",
+					inside: { punctuation: /^<<<'?|[';]$/ }
+				} }
+			},
+			{
+				pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
+				alias: "heredoc-string",
+				greedy: true,
+				inside: {
+					delimiter: {
+						pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+						alias: "symbol",
+						inside: { punctuation: /^<<<"?|[";]$/ }
+					},
+					interpolation: string_interpolation
+				}
+			},
+			{
+				pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+				alias: "backtick-quoted-string",
+				greedy: true
+			},
+			{
+				pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+				alias: "single-quoted-string",
+				greedy: true
+			},
+			{
+				pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+				alias: "double-quoted-string",
+				greedy: true,
+				inside: { interpolation: string_interpolation }
+			}
+		];
+		Prism.languages.insertBefore("php", "variable", {
+			string,
+			attribute: {
+				pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
+				greedy: true,
+				inside: {
+					"attribute-content": {
+						pattern: /^(#\[)[\s\S]+(?=\]$)/,
+						lookbehind: true,
+						inside: {
+							comment,
+							string,
+							"attribute-class-name": [{
+								pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
+								alias: "class-name",
+								greedy: true,
+								lookbehind: true
+							}, {
+								pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
+								alias: ["class-name", "class-name-fully-qualified"],
+								greedy: true,
+								lookbehind: true,
+								inside: { punctuation: /\\/ }
+							}],
+							constant,
+							number,
+							operator,
+							punctuation
+						}
+					},
+					delimiter: {
+						pattern: /^#\[|\]$/,
+						alias: "punctuation"
+					}
+				}
+			}
+		});
+		Prism.hooks.add("before-tokenize", function(env) {
+			if (!/<\?/.test(env.code)) return;
+			Prism.languages["markup-templating"].buildPlaceholders(env, "php", /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g);
+		});
+		Prism.hooks.add("after-tokenize", function(env) {
+			Prism.languages["markup-templating"].tokenizePlaceholders(env, "php");
+		});
+	})(Prism);
+}
+//#endregion
+export { php as default };
+
+//# sourceMappingURL=php-JTON0zp9.js.map

package/dist/web/assets/{plugin-definition-CI1aEVGv.js → plugin-definition-8Exesd6T.js}

@@ -1,5 +1,5 @@
 import { n as __mf_0 } from "./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare__zod__loadShare__.js-Do-7VDVw.js";
-import { i as __mf_163, s as __mf_172, y as __mf_59 } 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 { i as __mf_163, s as __mf_172, y as __mf_59 } 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/core/schema/roles/constants.ts
 var AUTH_DEFAULT_ROLES = [
 	{
@@ -75,4 +75,4 @@ var createAuthPluginDefinitionSchema = __mf_163((ctx) => __mf_0.object({
 //#endregion
 export { createAuthRoleSchema as n, createDefaultAuthRoles as r, createAuthPluginDefinitionSchema as t };
 
-//# sourceMappingURL=plugin-definition-CI1aEVGv.js.map
+//# sourceMappingURL=plugin-definition-8Exesd6T.js.map

package/dist/web/assets/{plugin-definition-BI565qFo.js → plugin-definition-ChBrbazJ.js}

@@ -1,5 +1,5 @@
 import { n as __mf_0 } from "./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare__zod__loadShare__.js-Do-7VDVw.js";
-import { i as __mf_163 } 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 { i as __mf_163 } 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/placeholder-auth/constants/model-names.ts
 var PLACEHOLDER_AUTH_MODELS = { user: "User" };
 //#endregion
@@ -8,4 +8,4 @@ var createPlaceholderAuthPluginDefinitionSchema = __mf_163(() => __mf_0.object({
 //#endregion
 export { PLACEHOLDER_AUTH_MODELS as n, createPlaceholderAuthPluginDefinitionSchema as t };
 
-//# sourceMappingURL=plugin-definition-BI565qFo.js.map
+//# sourceMappingURL=plugin-definition-ChBrbazJ.js.map

package/dist/web/assets/python-CURlmZ7M.js

@@ -0,0 +1,73 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/python.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+python.displayName = "python";
+python.aliases = ["py"];
+/** @param {Refractor} Prism */
+function python(Prism) {
+	Prism.languages.python = {
+		comment: {
+			pattern: /(^|[^\\])#.*/,
+			lookbehind: true,
+			greedy: true
+		},
+		"string-interpolation": {
+			pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+			greedy: true,
+			inside: {
+				interpolation: {
+					pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+					lookbehind: true,
+					inside: {
+						"format-spec": {
+							pattern: /(:)[^:(){}]+(?=\}$)/,
+							lookbehind: true
+						},
+						"conversion-option": {
+							pattern: /![sra](?=[:}]$)/,
+							alias: "punctuation"
+						},
+						rest: null
+					}
+				},
+				string: /[\s\S]+/
+			}
+		},
+		"triple-quoted-string": {
+			pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+			greedy: true,
+			alias: "string"
+		},
+		string: {
+			pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+			greedy: true
+		},
+		function: {
+			pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+			lookbehind: true
+		},
+		"class-name": {
+			pattern: /(\bclass\s+)\w+/i,
+			lookbehind: true
+		},
+		decorator: {
+			pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+			lookbehind: true,
+			alias: ["annotation", "punctuation"],
+			inside: { punctuation: /\./ }
+		},
+		keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+		builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+		boolean: /\b(?:False|None|True)\b/,
+		number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+		operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+		punctuation: /[{}[\];(),.:]/
+	};
+	Prism.languages.python["string-interpolation"].inside["interpolation"].inside.rest = Prism.languages.python;
+	Prism.languages.py = Prism.languages.python;
+}
+//#endregion
+export { python as default };
+
+//# sourceMappingURL=python-CURlmZ7M.js.map

package/dist/web/assets/r-8lr7pbGm.js

@@ -0,0 +1,30 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/r.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+r.displayName = "r";
+r.aliases = [];
+/** @param {Refractor} Prism */
+function r(Prism) {
+	Prism.languages.r = {
+		comment: /#.*/,
+		string: {
+			pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+			greedy: true
+		},
+		"percent-operator": {
+			pattern: /%[^%\s]*%/,
+			alias: "operator"
+		},
+		boolean: /\b(?:FALSE|TRUE)\b/,
+		ellipsis: /\.\.(?:\.|\d+)/,
+		number: [/\b(?:Inf|NaN)\b/, /(?:\b0x[\dA-Fa-f]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/],
+		keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
+		operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
+		punctuation: /[(){}\[\],;]/
+	};
+}
+//#endregion
+export { r as default };
+
+//# sourceMappingURL=r-8lr7pbGm.js.map

package/dist/web/assets/regex-CxQ7DXCx.js

@@ -0,0 +1,96 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/regex.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+regex.displayName = "regex";
+regex.aliases = [];
+/** @param {Refractor} Prism */
+function regex(Prism) {
+	(function(Prism) {
+		var specialEscape = {
+			pattern: /\\[\\(){}[\]^$+*?|.]/,
+			alias: "escape"
+		};
+		var escape = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/;
+		var charSet = {
+			pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i,
+			alias: "class-name"
+		};
+		var charSetWithoutDot = {
+			pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+			alias: "class-name"
+		};
+		var rangeChar = "(?:[^\\\\-]|" + escape.source + ")";
+		var range = RegExp(rangeChar + "-" + rangeChar);
+		var groupName = {
+			pattern: /(<|')[^<>']+(?=[>']$)/,
+			lookbehind: true,
+			alias: "variable"
+		};
+		Prism.languages.regex = {
+			"char-class": {
+				pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/,
+				lookbehind: true,
+				inside: {
+					"char-class-negation": {
+						pattern: /(^\[)\^/,
+						lookbehind: true,
+						alias: "operator"
+					},
+					"char-class-punctuation": {
+						pattern: /^\[|\]$/,
+						alias: "punctuation"
+					},
+					range: {
+						pattern: range,
+						inside: {
+							escape,
+							"range-punctuation": {
+								pattern: /-/,
+								alias: "operator"
+							}
+						}
+					},
+					"special-escape": specialEscape,
+					"char-set": charSetWithoutDot,
+					escape
+				}
+			},
+			"special-escape": specialEscape,
+			"char-set": charSet,
+			backreference: [{
+				pattern: /\\(?![123][0-7]{2})[1-9]/,
+				alias: "keyword"
+			}, {
+				pattern: /\\k<[^<>']+>/,
+				alias: "keyword",
+				inside: { "group-name": groupName }
+			}],
+			anchor: {
+				pattern: /[$^]|\\[ABbGZz]/,
+				alias: "function"
+			},
+			escape,
+			group: [{
+				pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
+				alias: "punctuation",
+				inside: { "group-name": groupName }
+			}, {
+				pattern: /\)/,
+				alias: "punctuation"
+			}],
+			quantifier: {
+				pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+				alias: "number"
+			},
+			alternation: {
+				pattern: /\|/,
+				alias: "keyword"
+			}
+		};
+	})(Prism);
+}
+//#endregion
+export { regex as default };
+
+//# sourceMappingURL=regex-CxQ7DXCx.js.map

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