@flyfish-group/file-viewer3 1.0.26 → 2.0.1

package/dist/components/typescript.js

@@ -1,521 +0,0 @@
-//#region node_modules/.pnpm/highlight.js@11.11.1/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",
-	"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);
-			if (i = a.match(/^\s*=/)) {
-				t.ignoreMatch();
-				return;
-			}
-			if ((i = a.match(/^\s+extends\s+/)) && i.index === 0) {
-				t.ignoreMatch();
-				return;
-			}
-		}
-	}, 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: "[A-Za-z$_][0-9A-Za-z$_]*(?=\\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"
-		].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-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: "\\$[A-Za-z$_][0-9A-Za-z$_]*",
-				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: "@[A-Za-z$_][0-9A-Za-z$_]*"
-	}, 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 };

package/dist/components/typst.js

@@ -1,25 +0,0 @@
-import { n as e, t } from "./asyncToGenerator.js";
-import { r as n } from "./util.js";
-import { createApp as r, createVNode as i, defineAsyncComponent as a } from "vue";
-//#region src/package/vendors/typst/index.tsx
-e();
-var o = a(() => import("./TypstViewer.js"));
-function s(e, t, n, r) {
-	return c.apply(this, arguments);
-}
-function c() {
-	return c = t(function* (e, t, a, s) {
-		let c = yield n(e), l = r({ render: () => {
-			var e;
-			return i(o, {
-				source: c,
-				filename: s == null ? void 0 : s.filename,
-				compilerWasmUrl: s == null || (e = s.options) == null || (e = e.typst) == null ? void 0 : e.compilerWasmUrl,
-				exportAdapter: s == null ? void 0 : s.registerExportAdapter
-			}, null);
-		} });
-		return l.mount(t), l;
-	}), c.apply(this, arguments);
-}
-//#endregion
-export { s as default };