@threadlabs/looma 0.18.6 → 0.19.1

package/vue/chunks/elixir.js

@@ -0,0 +1,241 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/elixir.js
+/** @type LanguageFn */
+function elixir(hljs) {
+	const regex = hljs.regex;
+	const ELIXIR_IDENT_RE = "[a-zA-Z_][a-zA-Z0-9_.]*(!|\\?)?";
+	const ELIXIR_METHOD_RE = "[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?";
+	const KWS = {
+		$pattern: ELIXIR_IDENT_RE,
+		keyword: [
+			"after",
+			"alias",
+			"and",
+			"case",
+			"catch",
+			"cond",
+			"defstruct",
+			"defguard",
+			"defguardp",
+			"do",
+			"else",
+			"end",
+			"fn",
+			"for",
+			"if",
+			"import",
+			"in",
+			"not",
+			"or",
+			"quote",
+			"raise",
+			"receive",
+			"require",
+			"reraise",
+			"rescue",
+			"try",
+			"unless",
+			"unquote",
+			"unquote_splicing",
+			"use",
+			"when",
+			"with|0"
+		],
+		literal: [
+			"false",
+			"nil",
+			"true"
+		]
+	};
+	const SUBST = {
+		className: "subst",
+		begin: /#\{/,
+		end: /\}/,
+		keywords: KWS
+	};
+	const NUMBER = {
+		className: "number",
+		begin: "(\\b0o[0-7_]+)|(\\b0b[01_]+)|(\\b0x[0-9a-fA-F_]+)|(-?\\b[0-9][0-9_]*(\\.[0-9_]+([eE][-+]?[0-9]+)?)?)",
+		relevance: 0
+	};
+	const BACKSLASH_ESCAPE = {
+		match: /\\[\s\S]/,
+		scope: "char.escape",
+		relevance: 0
+	};
+	const SIGIL_DELIMITER_MODES = [
+		{
+			begin: /"/,
+			end: /"/
+		},
+		{
+			begin: /'/,
+			end: /'/
+		},
+		{
+			begin: /\//,
+			end: /\//
+		},
+		{
+			begin: /\|/,
+			end: /\|/
+		},
+		{
+			begin: /\(/,
+			end: /\)/
+		},
+		{
+			begin: /\[/,
+			end: /\]/
+		},
+		{
+			begin: /\{/,
+			end: /\}/
+		},
+		{
+			begin: /</,
+			end: />/
+		}
+	];
+	const escapeSigilEnd = (end) => {
+		return {
+			scope: "char.escape",
+			begin: regex.concat(/\\/, end),
+			relevance: 0
+		};
+	};
+	const LOWERCASE_SIGIL = {
+		className: "string",
+		begin: "~[a-z](?=[/|([{<\"'])",
+		contains: SIGIL_DELIMITER_MODES.map((x) => hljs.inherit(x, { contains: [
+			escapeSigilEnd(x.end),
+			BACKSLASH_ESCAPE,
+			SUBST
+		] }))
+	};
+	const UPCASE_SIGIL = {
+		className: "string",
+		begin: "~[A-Z](?=[/|([{<\"'])",
+		contains: SIGIL_DELIMITER_MODES.map((x) => hljs.inherit(x, { contains: [escapeSigilEnd(x.end)] }))
+	};
+	const REGEX_SIGIL = {
+		className: "regex",
+		variants: [{
+			begin: "~r(?=[/|([{<\"'])",
+			contains: SIGIL_DELIMITER_MODES.map((x) => hljs.inherit(x, {
+				end: regex.concat(x.end, /[uismxfU]{0,7}/),
+				contains: [
+					escapeSigilEnd(x.end),
+					BACKSLASH_ESCAPE,
+					SUBST
+				]
+			}))
+		}, {
+			begin: "~R(?=[/|([{<\"'])",
+			contains: SIGIL_DELIMITER_MODES.map((x) => hljs.inherit(x, {
+				end: regex.concat(x.end, /[uismxfU]{0,7}/),
+				contains: [escapeSigilEnd(x.end)]
+			}))
+		}]
+	};
+	const STRING = {
+		className: "string",
+		contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+		variants: [
+			{
+				begin: /"""/,
+				end: /"""/
+			},
+			{
+				begin: /'''/,
+				end: /'''/
+			},
+			{
+				begin: /~S"""/,
+				end: /"""/,
+				contains: []
+			},
+			{
+				begin: /~S"/,
+				end: /"/,
+				contains: []
+			},
+			{
+				begin: /~S'''/,
+				end: /'''/,
+				contains: []
+			},
+			{
+				begin: /~S'/,
+				end: /'/,
+				contains: []
+			},
+			{
+				begin: /'/,
+				end: /'/
+			},
+			{
+				begin: /"/,
+				end: /"/
+			}
+		]
+	};
+	const FUNCTION = {
+		className: "function",
+		beginKeywords: "def defp defmacro defmacrop",
+		end: /\B\b/,
+		contains: [hljs.inherit(hljs.TITLE_MODE, {
+			begin: ELIXIR_IDENT_RE,
+			endsParent: true
+		})]
+	};
+	const CLASS = hljs.inherit(FUNCTION, {
+		className: "class",
+		beginKeywords: "defimpl defmodule defprotocol defrecord",
+		end: /\bdo\b|$|;/
+	});
+	const ELIXIR_DEFAULT_CONTAINS = [
+		{
+			scope: "string",
+			match: /\?'/,
+			relevance: 0
+		},
+		STRING,
+		REGEX_SIGIL,
+		UPCASE_SIGIL,
+		LOWERCASE_SIGIL,
+		hljs.HASH_COMMENT_MODE,
+		CLASS,
+		FUNCTION,
+		{ begin: "::" },
+		{
+			className: "symbol",
+			begin: ":(?![\\s:])",
+			contains: [STRING, { begin: ELIXIR_METHOD_RE }],
+			relevance: 0
+		},
+		{
+			className: "symbol",
+			begin: ELIXIR_IDENT_RE + ":(?!:)",
+			relevance: 0
+		},
+		{
+			className: "title.class",
+			begin: /(\b[A-Z][a-zA-Z0-9_]+)/,
+			relevance: 0
+		},
+		NUMBER,
+		{
+			className: "variable",
+			begin: "(\\$\\W)|((\\$|@@?)(\\w+))"
+		}
+	];
+	SUBST.contains = ELIXIR_DEFAULT_CONTAINS;
+	return {
+		name: "Elixir",
+		aliases: ["ex", "exs"],
+		keywords: KWS,
+		contains: ELIXIR_DEFAULT_CONTAINS
+	};
+}
+//#endregion
+export { elixir as default };

package/vue/chunks/elm.js

@@ -0,0 +1,103 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/elm.js
+/** @type LanguageFn */
+function elm(hljs) {
+	const COMMENT = { variants: [hljs.COMMENT("--", "$"), hljs.COMMENT(/\{-/, /-\}/, { contains: ["self"] })] };
+	const CONSTRUCTOR = {
+		className: "type",
+		begin: "\\b[A-Z][\\w']*",
+		relevance: 0
+	};
+	const LIST = {
+		begin: "\\(",
+		end: "\\)",
+		illegal: "\"",
+		contains: [{
+			className: "type",
+			begin: "\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"
+		}, COMMENT]
+	};
+	const RECORD = {
+		begin: /\{/,
+		end: /\}/,
+		contains: LIST.contains
+	};
+	return {
+		name: "Elm",
+		keywords: [
+			"let",
+			"in",
+			"if",
+			"then",
+			"else",
+			"case",
+			"of",
+			"where",
+			"module",
+			"import",
+			"exposing",
+			"type",
+			"alias",
+			"as",
+			"infix",
+			"infixl",
+			"infixr",
+			"port",
+			"effect",
+			"command",
+			"subscription"
+		],
+		contains: [
+			{
+				beginKeywords: "port effect module",
+				end: "exposing",
+				keywords: "port effect module where command subscription exposing",
+				contains: [LIST, COMMENT],
+				illegal: "\\W\\.|;"
+			},
+			{
+				begin: "import",
+				end: "$",
+				keywords: "import as exposing",
+				contains: [LIST, COMMENT],
+				illegal: "\\W\\.|;"
+			},
+			{
+				begin: "type",
+				end: "$",
+				keywords: "type alias",
+				contains: [
+					CONSTRUCTOR,
+					LIST,
+					RECORD,
+					COMMENT
+				]
+			},
+			{
+				beginKeywords: "infix infixl infixr",
+				end: "$",
+				contains: [hljs.C_NUMBER_MODE, COMMENT]
+			},
+			{
+				begin: "port",
+				end: "$",
+				keywords: "port",
+				contains: [COMMENT]
+			},
+			{
+				className: "string",
+				begin: "'\\\\?.",
+				end: "'",
+				illegal: "."
+			},
+			hljs.QUOTE_STRING_MODE,
+			hljs.C_NUMBER_MODE,
+			CONSTRUCTOR,
+			hljs.inherit(hljs.TITLE_MODE, { begin: "^[_a-z][\\w']*" }),
+			COMMENT,
+			{ begin: "->|<-" }
+		],
+		illegal: /;/
+	};
+}
+//#endregion
+export { elm as default };

package/vue/chunks/erb.js

@@ -0,0 +1,17 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/erb.js
+/** @type LanguageFn */
+function erb(hljs) {
+	return {
+		name: "ERB",
+		subLanguage: "xml",
+		contains: [hljs.COMMENT("<%#", "%>"), {
+			begin: "<%[%=-]?",
+			end: "[%-]?%>",
+			subLanguage: "ruby",
+			excludeBegin: true,
+			excludeEnd: true
+		}]
+	};
+}
+//#endregion
+export { erb as default };

package/vue/chunks/erlang-repl.js

@@ -0,0 +1,41 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/erlang-repl.js
+/** @type LanguageFn */
+function erlangRepl(hljs) {
+	const regex = hljs.regex;
+	return {
+		name: "Erlang REPL",
+		keywords: {
+			built_in: "spawn spawn_link self",
+			keyword: "after and andalso|10 band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse|10 query receive rem try when xor"
+		},
+		contains: [
+			{
+				className: "meta.prompt",
+				begin: "^[0-9]+> ",
+				relevance: 10
+			},
+			hljs.COMMENT("%", "$"),
+			{
+				className: "number",
+				begin: "\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",
+				relevance: 0
+			},
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE,
+			{ begin: regex.concat(/\?(::)?/, /([A-Z]\w*)/, /((::)[A-Z]\w*)*/) },
+			{ begin: "->" },
+			{ begin: "ok" },
+			{ begin: "!" },
+			{
+				begin: "(\\b[a-z'][a-zA-Z0-9_']*:[a-z'][a-zA-Z0-9_']*)|(\\b[a-z'][a-zA-Z0-9_']*)",
+				relevance: 0
+			},
+			{
+				begin: "[A-Z][a-zA-Z0-9_']*",
+				relevance: 0
+			}
+		]
+	};
+}
+//#endregion
+export { erlangRepl as default };

package/vue/chunks/erlang.js

@@ -0,0 +1,236 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/erlang.js
+/** @type LanguageFn */
+function erlang(hljs) {
+	const BASIC_ATOM_RE = "[a-z'][a-zA-Z0-9_']*";
+	const FUNCTION_NAME_RE = "(" + BASIC_ATOM_RE + ":" + BASIC_ATOM_RE + "|" + BASIC_ATOM_RE + ")";
+	const ERLANG_RESERVED = {
+		keyword: "after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun if let not of orelse|10 query receive rem try when xor maybe else",
+		literal: "false true"
+	};
+	const COMMENT = hljs.COMMENT("%", "$");
+	const NUMBER = {
+		className: "number",
+		begin: "\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",
+		relevance: 0
+	};
+	const NAMED_FUN = { begin: "fun\\s+" + BASIC_ATOM_RE + "/\\d+" };
+	const FUNCTION_CALL = {
+		begin: FUNCTION_NAME_RE + "\\(",
+		end: "\\)",
+		returnBegin: true,
+		relevance: 0,
+		contains: [{
+			begin: FUNCTION_NAME_RE,
+			relevance: 0
+		}, {
+			begin: "\\(",
+			end: "\\)",
+			endsWithParent: true,
+			returnEnd: true,
+			relevance: 0
+		}]
+	};
+	const TUPLE = {
+		begin: /\{/,
+		end: /\}/,
+		relevance: 0
+	};
+	const VAR1 = {
+		begin: "\\b_([A-Z][A-Za-z0-9_]*)?",
+		relevance: 0
+	};
+	const VAR2 = {
+		begin: "[A-Z][a-zA-Z0-9_]*",
+		relevance: 0
+	};
+	const RECORD_ACCESS = {
+		begin: "#" + hljs.UNDERSCORE_IDENT_RE,
+		relevance: 0,
+		returnBegin: true,
+		contains: [{
+			begin: "#" + hljs.UNDERSCORE_IDENT_RE,
+			relevance: 0
+		}, {
+			begin: /\{/,
+			end: /\}/,
+			relevance: 0
+		}]
+	};
+	const CHAR_LITERAL = {
+		scope: "string",
+		match: /\$(\\([^0-9]|[0-9]{1,3}|)|.)/
+	};
+	const TRIPLE_QUOTE = {
+		scope: "string",
+		match: /"""("*)(?!")[\s\S]*?"""\1/
+	};
+	const SIGIL = {
+		scope: "string",
+		contains: [hljs.BACKSLASH_ESCAPE],
+		variants: [
+			{ match: /~\w?"""("*)(?!")[\s\S]*?"""\1/ },
+			{
+				begin: /~\w?\(/,
+				end: /\)/
+			},
+			{
+				begin: /~\w?\[/,
+				end: /\]/
+			},
+			{
+				begin: /~\w?{/,
+				end: /}/
+			},
+			{
+				begin: /~\w?</,
+				end: />/
+			},
+			{
+				begin: /~\w?\//,
+				end: /\//
+			},
+			{
+				begin: /~\w?\|/,
+				end: /\|/
+			},
+			{
+				begin: /~\w?'/,
+				end: /'/
+			},
+			{
+				begin: /~\w?"/,
+				end: /"/
+			},
+			{
+				begin: /~\w?`/,
+				end: /`/
+			},
+			{
+				begin: /~\w?#/,
+				end: /#/
+			}
+		]
+	};
+	const BLOCK_STATEMENTS = {
+		beginKeywords: "fun receive if try case maybe",
+		end: "end",
+		keywords: ERLANG_RESERVED
+	};
+	BLOCK_STATEMENTS.contains = [
+		COMMENT,
+		NAMED_FUN,
+		hljs.inherit(hljs.APOS_STRING_MODE, { className: "" }),
+		BLOCK_STATEMENTS,
+		FUNCTION_CALL,
+		SIGIL,
+		TRIPLE_QUOTE,
+		hljs.QUOTE_STRING_MODE,
+		NUMBER,
+		TUPLE,
+		VAR1,
+		VAR2,
+		RECORD_ACCESS,
+		CHAR_LITERAL
+	];
+	const BASIC_MODES = [
+		COMMENT,
+		NAMED_FUN,
+		BLOCK_STATEMENTS,
+		FUNCTION_CALL,
+		SIGIL,
+		TRIPLE_QUOTE,
+		hljs.QUOTE_STRING_MODE,
+		NUMBER,
+		TUPLE,
+		VAR1,
+		VAR2,
+		RECORD_ACCESS,
+		CHAR_LITERAL
+	];
+	FUNCTION_CALL.contains[1].contains = BASIC_MODES;
+	TUPLE.contains = BASIC_MODES;
+	RECORD_ACCESS.contains[1].contains = BASIC_MODES;
+	const DIRECTIVES = [
+		"-module",
+		"-record",
+		"-undef",
+		"-export",
+		"-ifdef",
+		"-ifndef",
+		"-author",
+		"-copyright",
+		"-doc",
+		"-moduledoc",
+		"-vsn",
+		"-import",
+		"-include",
+		"-include_lib",
+		"-compile",
+		"-define",
+		"-else",
+		"-endif",
+		"-file",
+		"-behaviour",
+		"-behavior",
+		"-spec",
+		"-on_load",
+		"-nifs"
+	];
+	const PARAMS = {
+		className: "params",
+		begin: "\\(",
+		end: "\\)",
+		contains: BASIC_MODES
+	};
+	return {
+		name: "Erlang",
+		aliases: ["erl"],
+		keywords: ERLANG_RESERVED,
+		illegal: "(</|\\*=|\\+=|-=|/\\*|\\*/|\\(\\*|\\*\\))",
+		contains: [
+			{
+				className: "function",
+				begin: "^" + BASIC_ATOM_RE + "\\s*\\(",
+				end: "->",
+				returnBegin: true,
+				illegal: "\\(|#|//|/\\*|\\\\|:|;",
+				contains: [PARAMS, hljs.inherit(hljs.TITLE_MODE, { begin: BASIC_ATOM_RE })],
+				starts: {
+					end: ";|\\.",
+					keywords: ERLANG_RESERVED,
+					contains: BASIC_MODES
+				}
+			},
+			COMMENT,
+			{
+				begin: "^-",
+				end: "\\.",
+				relevance: 0,
+				excludeEnd: true,
+				returnBegin: true,
+				keywords: {
+					$pattern: "-" + hljs.IDENT_RE,
+					keyword: DIRECTIVES.map((x) => `${x}|1.5`).join(" ")
+				},
+				contains: [
+					PARAMS,
+					SIGIL,
+					TRIPLE_QUOTE,
+					hljs.QUOTE_STRING_MODE
+				]
+			},
+			NUMBER,
+			SIGIL,
+			TRIPLE_QUOTE,
+			hljs.QUOTE_STRING_MODE,
+			RECORD_ACCESS,
+			VAR1,
+			VAR2,
+			TUPLE,
+			CHAR_LITERAL,
+			{ begin: /\.$/ }
+		]
+	};
+}
+//#endregion
+export { erlang as default };