@factorialco/f0-react 12.10.0 → 12.11.0

package/dist/typescript-Bv8uKU6V.js

@@ -0,0 +1,516 @@
+//#region ../../node_modules/.pnpm/highlight.js@11.12.0/node_modules/highlight.js/es/languages/typescript.js
+var e = "[A-Za-z$_][0-9A-Za-z$_]*", t = /* @__PURE__ */ "as.in.of.if.for.while.finally.var.new.function.do.return.void.else.break.catch.instanceof.with.throw.case.default.try.switch.continue.typeof.delete.let.yield.const.class.debugger.async.await.static.import.from.export.extends.using".split("."), n = [
+	"true",
+	"false",
+	"null",
+	"undefined",
+	"NaN",
+	"Infinity"
+], r = /* @__PURE__ */ "Object.Function.Boolean.Symbol.Math.Date.Number.BigInt.String.RegExp.Array.Float32Array.Float64Array.Int8Array.Uint8Array.Uint8ClampedArray.Int16Array.Int32Array.Uint16Array.Uint32Array.BigInt64Array.BigUint64Array.Set.Map.WeakSet.WeakMap.ArrayBuffer.SharedArrayBuffer.Atomics.DataView.JSON.Promise.Generator.GeneratorFunction.AsyncFunction.Reflect.Proxy.Intl.WebAssembly".split("."), i = [
+	"Error",
+	"EvalError",
+	"InternalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError"
+], a = [
+	"setInterval",
+	"setTimeout",
+	"clearInterval",
+	"clearTimeout",
+	"require",
+	"exports",
+	"eval",
+	"isFinite",
+	"isNaN",
+	"parseFloat",
+	"parseInt",
+	"decodeURI",
+	"decodeURIComponent",
+	"encodeURI",
+	"encodeURIComponent",
+	"escape",
+	"unescape"
+], o = [
+	"arguments",
+	"this",
+	"super",
+	"console",
+	"window",
+	"document",
+	"localStorage",
+	"sessionStorage",
+	"module",
+	"self",
+	"global"
+], s = [].concat(a, r, i);
+function c(c) {
+	let l = c.regex, u = (e, { after: t }) => {
+		let n = "</" + e[0].slice(1);
+		return e.input.indexOf(n, t) !== -1;
+	}, d = e, f = {
+		begin: "<>",
+		end: "</>"
+	}, p = /<[A-Za-z0-9\\._:-]+\s*\/>/, m = {
+		begin: /<[A-Za-z0-9\\._:-]+/,
+		end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+		isTrulyOpeningTag: (e, t) => {
+			let n = e[0].length + e.index, r = e.input[n];
+			if (r === "<" || r === ",") {
+				t.ignoreMatch();
+				return;
+			}
+			r === ">" && (u(e, { after: n }) || t.ignoreMatch());
+			let i, a = e.input.substring(n);
+			((i = a.match(/^\s*=/)) || (i = a.match(/^\s+extends\s+/)) && i.index === 0) && t.ignoreMatch();
+		}
+	}, h = {
+		$pattern: e,
+		keyword: t,
+		literal: n,
+		built_in: s,
+		"variable.language": o
+	}, g = "[0-9](_?[0-9])*", _ = `\\.(${g})`, v = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", y = {
+		className: "number",
+		variants: [
+			{ begin: `(\\b(${v})((${_})|\\.)?|(${_}))[eE][+-]?(${g})\\b` },
+			{ begin: `\\b(${v})\\b((${_})\\b|\\.)?|(${_})\\b` },
+			{ begin: "\\b(0|[1-9](_?[0-9])*)n\\b" },
+			{ begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+			{ begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+			{ begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+			{ begin: "\\b0[0-7]+n?\\b" }
+		],
+		relevance: 0
+	}, b = {
+		className: "subst",
+		begin: "\\$\\{",
+		end: "\\}",
+		keywords: h,
+		contains: []
+	}, x = {
+		begin: ".?html`",
+		end: "",
+		starts: {
+			end: "`",
+			returnEnd: !1,
+			contains: [c.BACKSLASH_ESCAPE, b],
+			subLanguage: "xml"
+		}
+	}, S = {
+		begin: ".?css`",
+		end: "",
+		starts: {
+			end: "`",
+			returnEnd: !1,
+			contains: [c.BACKSLASH_ESCAPE, b],
+			subLanguage: "css"
+		}
+	}, C = {
+		begin: ".?gql`",
+		end: "",
+		starts: {
+			end: "`",
+			returnEnd: !1,
+			contains: [c.BACKSLASH_ESCAPE, b],
+			subLanguage: "graphql"
+		}
+	}, w = {
+		className: "string",
+		begin: "`",
+		end: "`",
+		contains: [c.BACKSLASH_ESCAPE, b]
+	}, T = {
+		className: "comment",
+		variants: [
+			c.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
+				relevance: 0,
+				contains: [{
+					begin: "(?=@[A-Za-z]+)",
+					relevance: 0,
+					contains: [
+						{
+							className: "doctag",
+							begin: "@[A-Za-z]+"
+						},
+						{
+							className: "type",
+							begin: "\\{",
+							end: "\\}",
+							excludeEnd: !0,
+							excludeBegin: !0,
+							relevance: 0
+						},
+						{
+							className: "variable",
+							begin: d + "(?=\\s*(-)|$)",
+							endsParent: !0,
+							relevance: 0
+						},
+						{
+							begin: /(?=[^\n])\s/,
+							relevance: 0
+						}
+					]
+				}]
+			}),
+			c.C_BLOCK_COMMENT_MODE,
+			c.C_LINE_COMMENT_MODE
+		]
+	}, E = [
+		c.APOS_STRING_MODE,
+		c.QUOTE_STRING_MODE,
+		x,
+		S,
+		C,
+		w,
+		{ match: /\$\d+/ },
+		y
+	];
+	b.contains = E.concat({
+		begin: /\{/,
+		end: /\}/,
+		keywords: h,
+		contains: ["self"].concat(E)
+	});
+	let D = [].concat(T, b.contains), O = D.concat([{
+		begin: /(\s*)\(/,
+		end: /\)/,
+		keywords: h,
+		contains: ["self"].concat(D)
+	}]), k = {
+		className: "params",
+		begin: /(\s*)\(/,
+		end: /\)/,
+		excludeBegin: !0,
+		excludeEnd: !0,
+		keywords: h,
+		contains: O
+	}, A = { variants: [{
+		match: [
+			/class/,
+			/\s+/,
+			d,
+			/\s+/,
+			/extends/,
+			/\s+/,
+			l.concat(d, "(", l.concat(/\./, d), ")*")
+		],
+		scope: {
+			1: "keyword",
+			3: "title.class",
+			5: "keyword",
+			7: "title.class.inherited"
+		}
+	}, {
+		match: [
+			/class/,
+			/\s+/,
+			d
+		],
+		scope: {
+			1: "keyword",
+			3: "title.class"
+		}
+	}] }, j = {
+		relevance: 0,
+		match: l.either(/\bJSON/, /\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/, /\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/, /\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/),
+		className: "title.class",
+		keywords: { _: [...r, ...i] }
+	}, M = {
+		label: "use_strict",
+		className: "meta",
+		relevance: 10,
+		begin: /^\s*['"]use (strict|asm)['"]/
+	}, N = {
+		variants: [{ match: [
+			/function/,
+			/\s+/,
+			d,
+			/(?=\s*\()/
+		] }, { match: [/function/, /\s*(?=\()/] }],
+		className: {
+			1: "keyword",
+			3: "title.function"
+		},
+		label: "func.def",
+		contains: [k],
+		illegal: /%/
+	}, P = {
+		relevance: 0,
+		match: /\b[A-Z][A-Z_0-9]+\b/,
+		className: "variable.constant"
+	};
+	function F(e) {
+		return l.concat("(?!", e.join("|"), ")");
+	}
+	let I = {
+		match: l.concat(/\b/, F([
+			...a,
+			"super",
+			"import",
+			"await"
+		].map((e) => `${e}\\s*\\(`)), d, l.lookahead(/\s*\(/)),
+		className: "title.function",
+		relevance: 0
+	}, L = {
+		begin: l.concat(/\./, l.lookahead(l.concat(d, /(?![0-9A-Za-z$_(])/))),
+		end: d,
+		excludeBegin: !0,
+		keywords: "prototype",
+		className: "property",
+		relevance: 0
+	}, R = {
+		match: [
+			/get|set/,
+			/\s+/,
+			d,
+			/(?=\()/
+		],
+		className: {
+			1: "keyword",
+			3: "title.function"
+		},
+		contains: [{ begin: /\(\)/ }, k]
+	}, z = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + c.UNDERSCORE_IDENT_RE + ")\\s*=>", B = {
+		match: [
+			/const|var|let/,
+			/\s+/,
+			d,
+			/\s*/,
+			/=\s*/,
+			/(async\s*)?/,
+			l.lookahead(z)
+		],
+		keywords: "async",
+		className: {
+			1: "keyword",
+			3: "title.function"
+		},
+		contains: [k]
+	};
+	return {
+		name: "JavaScript",
+		aliases: [
+			"js",
+			"jsx",
+			"mjs",
+			"cjs"
+		],
+		keywords: h,
+		exports: {
+			PARAMS_CONTAINS: O,
+			CLASS_REFERENCE: j
+		},
+		illegal: /#(?![$_A-Za-z])/,
+		contains: [
+			c.SHEBANG({
+				label: "shebang",
+				binary: "node",
+				relevance: 5
+			}),
+			M,
+			c.APOS_STRING_MODE,
+			c.QUOTE_STRING_MODE,
+			x,
+			S,
+			C,
+			w,
+			T,
+			{ match: /\$\d+/ },
+			y,
+			j,
+			{
+				scope: "attr",
+				match: d + l.lookahead(":"),
+				relevance: 0
+			},
+			B,
+			{
+				begin: "(" + c.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+				keywords: "return throw case",
+				relevance: 0,
+				contains: [
+					T,
+					c.REGEXP_MODE,
+					{
+						className: "function",
+						begin: z,
+						returnBegin: !0,
+						end: "\\s*=>",
+						contains: [{
+							className: "params",
+							variants: [
+								{
+									begin: c.UNDERSCORE_IDENT_RE,
+									relevance: 0
+								},
+								{
+									className: null,
+									begin: /\(\s*\)/,
+									skip: !0
+								},
+								{
+									begin: /(\s*)\(/,
+									end: /\)/,
+									excludeBegin: !0,
+									excludeEnd: !0,
+									keywords: h,
+									contains: O
+								}
+							]
+						}]
+					},
+					{
+						begin: /,/,
+						relevance: 0
+					},
+					{
+						match: /\s+/,
+						relevance: 0
+					},
+					{
+						variants: [
+							{
+								begin: f.begin,
+								end: f.end
+							},
+							{ match: p },
+							{
+								begin: m.begin,
+								"on:begin": m.isTrulyOpeningTag,
+								end: m.end
+							}
+						],
+						subLanguage: "xml",
+						contains: [{
+							begin: m.begin,
+							end: m.end,
+							skip: !0,
+							contains: ["self"]
+						}]
+					}
+				]
+			},
+			N,
+			{ beginKeywords: "while if switch catch for" },
+			{
+				begin: "\\b(?!function)" + c.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+				returnBegin: !0,
+				label: "func.def",
+				contains: [k, c.inherit(c.TITLE_MODE, {
+					begin: d,
+					className: "title.function"
+				})]
+			},
+			{
+				match: /\.\.\./,
+				relevance: 0
+			},
+			L,
+			{
+				match: "\\$" + d,
+				relevance: 0
+			},
+			{
+				match: [/\bconstructor(?=\s*\()/],
+				className: { 1: "title.function" },
+				contains: [k]
+			},
+			I,
+			P,
+			A,
+			R,
+			{ match: /\$[(.]/ }
+		]
+	};
+}
+function l(r) {
+	let i = r.regex, a = c(r), l = e, u = [
+		"any",
+		"void",
+		"number",
+		"boolean",
+		"string",
+		"object",
+		"never",
+		"symbol",
+		"bigint",
+		"unknown"
+	], d = {
+		begin: [
+			/namespace/,
+			/\s+/,
+			r.IDENT_RE
+		],
+		beginScope: {
+			1: "keyword",
+			3: "title.class"
+		}
+	}, f = {
+		beginKeywords: "interface",
+		end: /\{/,
+		excludeEnd: !0,
+		keywords: {
+			keyword: "interface extends",
+			built_in: u
+		},
+		contains: [a.exports.CLASS_REFERENCE]
+	}, p = {
+		className: "meta",
+		relevance: 10,
+		begin: /^\s*['"]use strict['"]/
+	}, m = {
+		$pattern: e,
+		keyword: t.concat([
+			"type",
+			"interface",
+			"public",
+			"private",
+			"protected",
+			"implements",
+			"declare",
+			"abstract",
+			"readonly",
+			"enum",
+			"override",
+			"satisfies"
+		]),
+		literal: n,
+		built_in: s.concat(u),
+		"variable.language": o
+	}, h = {
+		className: "meta",
+		begin: "@" + l
+	}, g = (e, t, n) => {
+		let r = e.contains.findIndex((e) => e.label === t);
+		if (r === -1) throw Error("can not find mode to replace");
+		e.contains.splice(r, 1, n);
+	};
+	Object.assign(a.keywords, m), a.exports.PARAMS_CONTAINS.push(h);
+	let _ = a.contains.find((e) => e.scope === "attr"), v = Object.assign({}, _, { match: i.concat(l, i.lookahead(/\s*\?:/)) });
+	a.exports.PARAMS_CONTAINS.push([
+		a.exports.CLASS_REFERENCE,
+		_,
+		v
+	]), a.contains = a.contains.concat([
+		h,
+		d,
+		f,
+		v
+	]), g(a, "shebang", r.SHEBANG()), g(a, "use_strict", p);
+	let y = a.contains.find((e) => e.label === "func.def");
+	return y.relevance = 0, Object.assign(a, {
+		name: "TypeScript",
+		aliases: [
+			"ts",
+			"tsx",
+			"mts",
+			"cts"
+		]
+	}), a;
+}
+//#endregion
+export { l as default };