@threadlabs/looma 0.18.6 → 0.19.0

package/vue/chunks/php-template.js

@@ -0,0 +1,43 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/php-template.js
+function phpTemplate(hljs) {
+	return {
+		name: "PHP template",
+		subLanguage: "xml",
+		contains: [{
+			begin: /<\?(php|=)?/,
+			end: /\?>/,
+			subLanguage: "php",
+			contains: [
+				{
+					begin: "/\\*",
+					end: "\\*/",
+					skip: true
+				},
+				{
+					begin: "b\"",
+					end: "\"",
+					skip: true
+				},
+				{
+					begin: "b'",
+					end: "'",
+					skip: true
+				},
+				hljs.inherit(hljs.APOS_STRING_MODE, {
+					illegal: null,
+					className: null,
+					contains: null,
+					skip: true
+				}),
+				hljs.inherit(hljs.QUOTE_STRING_MODE, {
+					illegal: null,
+					className: null,
+					contains: null,
+					skip: true
+				})
+			]
+		}]
+	};
+}
+//#endregion
+export { phpTemplate as default };

package/vue/chunks/php.js

@@ -0,0 +1,527 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/php.js
+/**
+* @param {HLJSApi} hljs
+* @returns {LanguageDetail}
+* */
+function php(hljs) {
+	const regex = hljs.regex;
+	const NOT_PERL_ETC = /(?![A-Za-z0-9])(?![$])/;
+	const IDENT_RE = regex.concat(/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/, NOT_PERL_ETC);
+	const PASCAL_CASE_CLASS_NAME_RE = regex.concat(/(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/, NOT_PERL_ETC);
+	const UPCASE_NAME_RE = regex.concat(/[A-Z]+/, NOT_PERL_ETC);
+	const VARIABLE = {
+		scope: "variable",
+		match: "\\$+" + IDENT_RE
+	};
+	const PREPROCESSOR = {
+		scope: "meta",
+		variants: [
+			{
+				begin: /<\?php/,
+				relevance: 10
+			},
+			{ begin: /<\?=/ },
+			{
+				begin: /<\?/,
+				relevance: .1
+			},
+			{ begin: /\?>/ }
+		]
+	};
+	const SUBST = {
+		scope: "subst",
+		variants: [{ begin: /\$\w+/ }, {
+			begin: /\{\$/,
+			end: /\}/
+		}]
+	};
+	const SINGLE_QUOTED = hljs.inherit(hljs.APOS_STRING_MODE, { illegal: null });
+	const DOUBLE_QUOTED = hljs.inherit(hljs.QUOTE_STRING_MODE, {
+		illegal: null,
+		contains: hljs.QUOTE_STRING_MODE.contains.concat(SUBST)
+	});
+	const HEREDOC = {
+		begin: /<<<[ \t]*(?:(\w+)|"(\w+)")\n/,
+		end: /[ \t]*(\w+)\b/,
+		contains: hljs.QUOTE_STRING_MODE.contains.concat(SUBST),
+		"on:begin": (m, resp) => {
+			resp.data._beginMatch = m[1] || m[2];
+		},
+		"on:end": (m, resp) => {
+			if (resp.data._beginMatch !== m[1]) resp.ignoreMatch();
+		}
+	};
+	const NOWDOC = hljs.END_SAME_AS_BEGIN({
+		begin: /<<<[ \t]*'(\w+)'\n/,
+		end: /[ \t]*(\w+)\b/
+	});
+	const WHITESPACE = "[ 	\n]";
+	const STRING = {
+		scope: "string",
+		variants: [
+			DOUBLE_QUOTED,
+			SINGLE_QUOTED,
+			HEREDOC,
+			NOWDOC
+		]
+	};
+	const NUMBER = {
+		scope: "number",
+		variants: [
+			{ begin: `\\b0[bB][01]+(?:_[01]+)*\\b` },
+			{ begin: `\\b0[oO][0-7]+(?:_[0-7]+)*\\b` },
+			{ begin: `\\b0[xX][\\da-fA-F]+(?:_[\\da-fA-F]+)*\\b` },
+			{ begin: `(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?` }
+		],
+		relevance: 0
+	};
+	const LITERALS = [
+		"false",
+		"null",
+		"true"
+	];
+	const KWS = [
+		"__CLASS__",
+		"__DIR__",
+		"__FILE__",
+		"__FUNCTION__",
+		"__COMPILER_HALT_OFFSET__",
+		"__LINE__",
+		"__METHOD__",
+		"__NAMESPACE__",
+		"__TRAIT__",
+		"die",
+		"echo",
+		"exit",
+		"include",
+		"include_once",
+		"print",
+		"require",
+		"require_once",
+		"array",
+		"abstract",
+		"and",
+		"as",
+		"binary",
+		"bool",
+		"boolean",
+		"break",
+		"callable",
+		"case",
+		"catch",
+		"class",
+		"clone",
+		"const",
+		"continue",
+		"declare",
+		"default",
+		"do",
+		"double",
+		"else",
+		"elseif",
+		"empty",
+		"enddeclare",
+		"endfor",
+		"endforeach",
+		"endif",
+		"endswitch",
+		"endwhile",
+		"enum",
+		"eval",
+		"extends",
+		"final",
+		"finally",
+		"float",
+		"for",
+		"foreach",
+		"from",
+		"global",
+		"goto",
+		"if",
+		"implements",
+		"instanceof",
+		"insteadof",
+		"int",
+		"integer",
+		"interface",
+		"isset",
+		"iterable",
+		"list",
+		"match|0",
+		"mixed",
+		"new",
+		"never",
+		"object",
+		"or",
+		"private",
+		"protected",
+		"public",
+		"readonly",
+		"real",
+		"return",
+		"string",
+		"switch",
+		"throw",
+		"trait",
+		"try",
+		"unset",
+		"use",
+		"var",
+		"void",
+		"while",
+		"xor",
+		"yield"
+	];
+	const BUILT_INS = [
+		"Error|0",
+		"AppendIterator",
+		"ArgumentCountError",
+		"ArithmeticError",
+		"ArrayIterator",
+		"ArrayObject",
+		"AssertionError",
+		"BadFunctionCallException",
+		"BadMethodCallException",
+		"CachingIterator",
+		"CallbackFilterIterator",
+		"CompileError",
+		"Countable",
+		"DirectoryIterator",
+		"DivisionByZeroError",
+		"DomainException",
+		"EmptyIterator",
+		"ErrorException",
+		"Exception",
+		"FilesystemIterator",
+		"FilterIterator",
+		"GlobIterator",
+		"InfiniteIterator",
+		"InvalidArgumentException",
+		"IteratorIterator",
+		"LengthException",
+		"LimitIterator",
+		"LogicException",
+		"MultipleIterator",
+		"NoRewindIterator",
+		"OutOfBoundsException",
+		"OutOfRangeException",
+		"OuterIterator",
+		"OverflowException",
+		"ParentIterator",
+		"ParseError",
+		"RangeException",
+		"RecursiveArrayIterator",
+		"RecursiveCachingIterator",
+		"RecursiveCallbackFilterIterator",
+		"RecursiveDirectoryIterator",
+		"RecursiveFilterIterator",
+		"RecursiveIterator",
+		"RecursiveIteratorIterator",
+		"RecursiveRegexIterator",
+		"RecursiveTreeIterator",
+		"RegexIterator",
+		"RuntimeException",
+		"SeekableIterator",
+		"SplDoublyLinkedList",
+		"SplFileInfo",
+		"SplFileObject",
+		"SplFixedArray",
+		"SplHeap",
+		"SplMaxHeap",
+		"SplMinHeap",
+		"SplObjectStorage",
+		"SplObserver",
+		"SplPriorityQueue",
+		"SplQueue",
+		"SplStack",
+		"SplSubject",
+		"SplTempFileObject",
+		"TypeError",
+		"UnderflowException",
+		"UnexpectedValueException",
+		"UnhandledMatchError",
+		"ArrayAccess",
+		"BackedEnum",
+		"Closure",
+		"Fiber",
+		"Generator",
+		"Iterator",
+		"IteratorAggregate",
+		"Serializable",
+		"Stringable",
+		"Throwable",
+		"Traversable",
+		"UnitEnum",
+		"WeakReference",
+		"WeakMap",
+		"Directory",
+		"__PHP_Incomplete_Class",
+		"parent",
+		"php_user_filter",
+		"self",
+		"static",
+		"stdClass"
+	];
+	/** Dual-case keywords
+	*
+	* ["then","FILE"] =>
+	*     ["then", "THEN", "FILE", "file"]
+	*
+	* @param {string[]} items */
+	const dualCase = (items) => {
+		/** @type string[] */
+		const result = [];
+		items.forEach((item) => {
+			result.push(item);
+			if (item.toLowerCase() === item) result.push(item.toUpperCase());
+			else result.push(item.toLowerCase());
+		});
+		return result;
+	};
+	const KEYWORDS = {
+		keyword: KWS,
+		literal: dualCase(LITERALS),
+		built_in: BUILT_INS
+	};
+	/**
+	* @param {string[]} items */
+	const normalizeKeywords = (items) => {
+		return items.map((item) => {
+			return item.replace(/\|\d+$/, "");
+		});
+	};
+	const CONSTRUCTOR_CALL = { variants: [{
+		match: [
+			/new/,
+			regex.concat(WHITESPACE, "+"),
+			regex.concat("(?!", normalizeKeywords(BUILT_INS).join("\\b|"), "\\b)"),
+			PASCAL_CASE_CLASS_NAME_RE
+		],
+		scope: {
+			1: "keyword",
+			4: "title.class"
+		}
+	}] };
+	const CONSTANT_REFERENCE = regex.concat(IDENT_RE, "\\b(?!\\()");
+	const LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON = { variants: [
+		{
+			match: [regex.concat(/::/, regex.lookahead(/(?!class\b)/)), CONSTANT_REFERENCE],
+			scope: { 2: "variable.constant" }
+		},
+		{
+			match: [/::/, /class/],
+			scope: { 2: "variable.language" }
+		},
+		{
+			match: [
+				PASCAL_CASE_CLASS_NAME_RE,
+				regex.concat(/::/, regex.lookahead(/(?!class\b)/)),
+				CONSTANT_REFERENCE
+			],
+			scope: {
+				1: "title.class",
+				3: "variable.constant"
+			}
+		},
+		{
+			match: [PASCAL_CASE_CLASS_NAME_RE, regex.concat("::", regex.lookahead(/(?!class\b)/))],
+			scope: { 1: "title.class" }
+		},
+		{
+			match: [
+				PASCAL_CASE_CLASS_NAME_RE,
+				/::/,
+				/class/
+			],
+			scope: {
+				1: "title.class",
+				3: "variable.language"
+			}
+		}
+	] };
+	const NAMED_ARGUMENT = {
+		scope: "attr",
+		match: regex.concat(IDENT_RE, regex.lookahead(":"), regex.lookahead(/(?!::)/))
+	};
+	const PARAMS_MODE = {
+		relevance: 0,
+		begin: /\(/,
+		end: /\)/,
+		keywords: KEYWORDS,
+		contains: [
+			NAMED_ARGUMENT,
+			VARIABLE,
+			LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+			hljs.C_BLOCK_COMMENT_MODE,
+			hljs.C_LINE_COMMENT_MODE,
+			hljs.HASH_COMMENT_MODE,
+			STRING,
+			NUMBER,
+			CONSTRUCTOR_CALL
+		]
+	};
+	const FUNCTION_INVOKE = {
+		relevance: 0,
+		match: [
+			/\b/,
+			regex.concat("(?!fn\\b|function\\b|", normalizeKeywords(KWS).join("\\b|"), "|", normalizeKeywords(BUILT_INS).join("\\b|"), "\\b)"),
+			IDENT_RE,
+			regex.concat(WHITESPACE, "*"),
+			regex.lookahead(/(?=\()/)
+		],
+		scope: { 3: "title.function.invoke" },
+		contains: [PARAMS_MODE]
+	};
+	PARAMS_MODE.contains.push(FUNCTION_INVOKE);
+	const ATTRIBUTE_CONTAINS = [
+		NAMED_ARGUMENT,
+		LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+		hljs.C_BLOCK_COMMENT_MODE,
+		hljs.C_LINE_COMMENT_MODE,
+		hljs.HASH_COMMENT_MODE,
+		STRING,
+		NUMBER,
+		CONSTRUCTOR_CALL
+	];
+	const ATTRIBUTES = {
+		begin: regex.concat(/#\[\s*\\?/, regex.either(PASCAL_CASE_CLASS_NAME_RE, UPCASE_NAME_RE)),
+		beginScope: "meta",
+		end: /]/,
+		endScope: "meta",
+		keywords: {
+			literal: LITERALS,
+			keyword: ["new", "array"]
+		},
+		contains: [
+			{
+				begin: /\[/,
+				end: /]/,
+				keywords: {
+					literal: LITERALS,
+					keyword: ["new", "array"]
+				},
+				contains: ["self", ...ATTRIBUTE_CONTAINS]
+			},
+			...ATTRIBUTE_CONTAINS,
+			{
+				scope: "meta",
+				variants: [{ match: PASCAL_CASE_CLASS_NAME_RE }, { match: UPCASE_NAME_RE }]
+			}
+		]
+	};
+	return {
+		case_insensitive: false,
+		keywords: KEYWORDS,
+		contains: [
+			ATTRIBUTES,
+			hljs.HASH_COMMENT_MODE,
+			hljs.COMMENT("//", "$"),
+			hljs.COMMENT("/\\*", "\\*/", { contains: [{
+				scope: "doctag",
+				match: "@[A-Za-z]+"
+			}] }),
+			{
+				match: /__halt_compiler\(\);/,
+				keywords: "__halt_compiler",
+				starts: {
+					scope: "comment",
+					end: hljs.MATCH_NOTHING_RE,
+					contains: [{
+						match: /\?>/,
+						scope: "meta",
+						endsParent: true
+					}]
+				}
+			},
+			PREPROCESSOR,
+			{
+				scope: "variable.language",
+				match: /\$this\b/
+			},
+			VARIABLE,
+			FUNCTION_INVOKE,
+			LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+			{
+				match: [
+					/const/,
+					/\s/,
+					IDENT_RE
+				],
+				scope: {
+					1: "keyword",
+					3: "variable.constant"
+				}
+			},
+			CONSTRUCTOR_CALL,
+			{
+				scope: "function",
+				relevance: 0,
+				beginKeywords: "fn function",
+				end: /[;{]/,
+				excludeEnd: true,
+				illegal: "[$%\\[]",
+				contains: [
+					{ beginKeywords: "use" },
+					hljs.UNDERSCORE_TITLE_MODE,
+					{
+						begin: "=>",
+						endsParent: true
+					},
+					{
+						scope: "params",
+						begin: "\\(",
+						end: "\\)",
+						excludeBegin: true,
+						excludeEnd: true,
+						keywords: KEYWORDS,
+						contains: [
+							"self",
+							ATTRIBUTES,
+							VARIABLE,
+							LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+							hljs.C_BLOCK_COMMENT_MODE,
+							hljs.C_LINE_COMMENT_MODE,
+							hljs.HASH_COMMENT_MODE,
+							STRING,
+							NUMBER
+						]
+					}
+				]
+			},
+			{
+				scope: "class",
+				variants: [{
+					beginKeywords: "enum",
+					illegal: /[($"]/
+				}, {
+					beginKeywords: "class interface trait",
+					illegal: /[:($"]/
+				}],
+				relevance: 0,
+				end: /\{/,
+				excludeEnd: true,
+				contains: [{ beginKeywords: "extends implements" }, hljs.UNDERSCORE_TITLE_MODE]
+			},
+			{
+				beginKeywords: "namespace",
+				relevance: 0,
+				end: ";",
+				illegal: /[.']/,
+				contains: [hljs.inherit(hljs.UNDERSCORE_TITLE_MODE, { scope: "title.class" })]
+			},
+			{
+				beginKeywords: "use",
+				relevance: 0,
+				end: ";",
+				contains: [{
+					match: /\b(as|const|function)\b/,
+					scope: "keyword"
+				}, hljs.UNDERSCORE_TITLE_MODE]
+			},
+			STRING,
+			NUMBER
+		]
+	};
+}
+//#endregion
+export { php as default };

package/vue/chunks/plaintext.js

@@ -0,0 +1,10 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/plaintext.js
+function plaintext(hljs) {
+	return {
+		name: "Plain text",
+		aliases: ["text", "txt"],
+		disableAutodetect: true
+	};
+}
+//#endregion
+export { plaintext as default };

package/vue/chunks/pony.js

@@ -0,0 +1,60 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/pony.js
+function pony(hljs) {
+	/**
+	* The `FUNCTION` and `CLASS` modes were intentionally removed to simplify
+	* highlighting and fix cases like
+	* ```
+	* interface Iterator[A: A]
+	*   fun has_next(): Bool
+	*   fun next(): A?
+	* ```
+	* where it is valid to have a function head without a body
+	*/
+	return {
+		name: "Pony",
+		keywords: {
+			keyword: "actor addressof and as be break class compile_error compile_intrinsic consume continue delegate digestof do else elseif embed end error for fun if ifdef in interface is isnt lambda let match new not object or primitive recover repeat return struct then trait try type until use var where while with xor",
+			meta: "iso val tag trn box ref",
+			literal: "this false true"
+		},
+		contains: [
+			{
+				className: "type",
+				begin: "\\b_?[A-Z][\\w]*",
+				relevance: 0
+			},
+			{
+				className: "string",
+				begin: "\"\"\"",
+				end: "\"\"\"",
+				relevance: 10
+			},
+			{
+				className: "string",
+				begin: "\"",
+				end: "\"",
+				contains: [hljs.BACKSLASH_ESCAPE]
+			},
+			{
+				className: "string",
+				begin: "'",
+				end: "'",
+				contains: [hljs.BACKSLASH_ESCAPE],
+				relevance: 0
+			},
+			{
+				begin: hljs.IDENT_RE + "'",
+				relevance: 0
+			},
+			{
+				className: "number",
+				begin: "(-?)(\\b0[xX][a-fA-F0-9]+|\\b0[bB][01]+|(\\b\\d+(_\\d+)?(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",
+				relevance: 0
+			},
+			hljs.C_LINE_COMMENT_MODE,
+			hljs.C_BLOCK_COMMENT_MODE
+		]
+	};
+}
+//#endregion
+export { pony as default };