@effect-app/vue-components 4.0.0-beta.22 → 4.0.0-beta.221

package/dist/vue-components58.es.js

@@ -0,0 +1,4 @@
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/Struct.js
+var e = (e) => e;
+//#endregion
+export { e as lambda };

package/dist/vue-components59.es.js

@@ -0,0 +1,109 @@
+import { memoize as e } from "./vue-components13.es.js";
+import { isFunction as t } from "./vue-components15.es.js";
+import { isSome as n, some as r } from "./vue-components28.es.js";
+import { isArrayNonEmpty as i } from "./vue-components30.es.js";
+import { getSuccess as a, isSuccess as o } from "./vue-components40.es.js";
+import { catchEager as s, fail as c, flatMapEager as l, mapErrorEager as u, runSync as d, runSyncExit as f, succeed as p } from "./vue-components46.es.js";
+import { resolve as m } from "./vue-components49.es.js";
+import { Composite as h, Encoding as g, InvalidValue as _ } from "./vue-components54.es.js";
+import { ClassTypeId as v, Link as y, STRUCTURAL_ANNOTATION_KEY as b, collectIssues as x, defaultParseOptions as S, isArrays as C, isDeclaration as w, isObjects as T, replaceEncoding as E, toType as D } from "./vue-components57.es.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/SchemaParser.js
+var O = /* @__PURE__ */ e((e) => {
+	switch (e._tag) {
+		case "Declaration": {
+			let n = e.annotations?.[v];
+			if (t(n)) {
+				let t = n(e.typeParameters), r = O(t.to);
+				return E(e, r === t.to ? [t] : [new y(r, t.transformation)]);
+			}
+			return e;
+		}
+		case "Objects":
+		case "Arrays": return e.recur((e) => {
+			let t = e.context?.defaultValue;
+			return t ? E(O(e), t) : O(e);
+		});
+		case "Suspend": return e.recur(O);
+		default: return e;
+	}
+});
+function k(e) {
+	let t = I(O(D(e.ast)));
+	return (e, n) => t(e, n?.disableChecks ? n?.parseOptions ? {
+		...n.parseOptions,
+		disableChecks: !0
+	} : { disableChecks: !0 } : n?.parseOptions);
+}
+function A(e) {
+	let t = k(e);
+	return (e, n) => a(f(t(e, n)));
+}
+function j(e) {
+	let t = k(e);
+	return (e, n) => d(u(t(e, n), (e) => Error(e.toString(), { cause: e })));
+}
+function M(e) {
+	let t = L(I(D(e)));
+	return (e) => o(t(e, S));
+}
+function N(e) {
+	return I(e.ast);
+}
+function P(e) {
+	return R(N(e));
+}
+var F = P;
+function I(e) {
+	let t = z(e);
+	return (e, n) => l(t(r(e), n ?? S), (e) => e._tag === "None" ? c(new _(e)) : p(e.value));
+}
+function L(e) {
+	return (t, n) => f(e(t, n));
+}
+function R(e) {
+	return (t, n) => d(u(e(t, n), (e) => Error(e.toString(), { cause: e })));
+}
+var z = /* @__PURE__ */ e((e) => {
+	let t, r = m(e)?.parseOptions;
+	if (!e.context && !e.encoding && !e.checks) return (n, i) => (t ??= e.getParser(z), r && (i = {
+		...i,
+		...r
+	}), t(n, i));
+	let a = C(e) || T(e) || w(e) && e.typeParameters.length > 0;
+	return (o, d) => {
+		r && (d = {
+			...d,
+			...r
+		});
+		let f = e.encoding, m;
+		if (f) {
+			let t = f, n = t.length;
+			for (let e = n - 1; e >= 0; e--) {
+				let n = t[e], r = n.to, i = z(r);
+				if (m = m ? l(m, (e) => i(e, d)) : i(o, d), n.transformation._tag === "Transformation") {
+					let e = n.transformation.decode;
+					m = l(m, (t) => e.run(t, d));
+				} else m = n.transformation.decode(m, d);
+			}
+			m = u(m, (t) => new g(e, o, t));
+		}
+		t ??= e.getParser(z);
+		let _ = m ? l(m, (e) => t(e, d)) : t(o, d);
+		if (e.checks && !d?.disableChecks) {
+			let t = e.checks;
+			d?.errors === "all" && a && n(o) && (_ = s(_, (n) => {
+				let r = [];
+				return x(t.filter((e) => e.annotations?.[b]), o.value, r, e, d), c(i(r) ? n._tag === "Composite" && n.ast === e ? new h(e, n.actual, [...n.issues, ...r]) : new h(e, o, [n, ...r]) : n);
+			})), _ = l(_, (r) => {
+				if (n(r)) {
+					let n = r.value, a = [];
+					if (x(t, n, a, e, d), i(a)) return c(new h(e, r, a));
+				}
+				return p(r);
+			});
+		}
+		return _;
+	};
+});
+//#endregion
+export { M as _is, F as decodeSync, N as decodeUnknownEffect, k as makeEffect, A as makeOption, j as makeUnsafe };

package/dist/vue-components6.es.js

@@ -0,0 +1,13 @@
+import { inject as e, provide as t } from "vue";
+//#region src/utils/index.ts
+var n = Symbol(), r = () => {
+	let t = e(n);
+	if (!t) throw Error("useIntl must be used within a IntlProvider");
+	return t();
+}, i = (e) => t(n, e);
+function a(e) {
+	for (; e.encoding;) e = e.encoding[0].to;
+	return e;
+}
+//#endregion
+export { a as getTransformationFrom, i as provideIntl, r as useIntl, n as useIntlKey };

package/dist/vue-components60.es.js

@@ -0,0 +1,54 @@
+import { pipeArguments as e } from "./vue-components12.es.js";
+import { flow as t } from "./vue-components13.es.js";
+import { mapErrorEager as n } from "./vue-components46.es.js";
+import { annotate as r, annotateKey as i, appendChecks as a, toEncoded as o } from "./vue-components57.es.js";
+import { makeEffect as s, makeOption as c, makeUnsafe as l } from "./vue-components59.es.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/internal/schema/schema.js
+var u = "~effect/Schema/Schema", d = {
+	[u]: u,
+	pipe() {
+		return e(this, arguments);
+	},
+	annotate(e) {
+		return this.rebuild(r(this.ast, e));
+	},
+	annotateKey(e) {
+		return this.rebuild(i(this.ast, e));
+	},
+	check(...e) {
+		return this.rebuild(a(this.ast, e));
+	}
+};
+function f(e, r) {
+	let i = Object.create(d);
+	return r && Object.assign(i, r), i.ast = e, i.rebuild = (e) => f(e, r), i.makeEffect = t(s(i), n((e) => new m(e))), i.make = l(i), i.makeOption = c(i), i;
+}
+var p = "~effect/Schema/SchemaError", m = class {
+	[p] = p;
+	_tag = "SchemaError";
+	name = "SchemaError";
+	issue;
+	constructor(e) {
+		this.issue = e;
+	}
+	get message() {
+		return this.issue.toString();
+	}
+	toString() {
+		return `SchemaError(${this.message})`;
+	}
+};
+function h(e) {
+	return (t) => {
+		let n = /* @__PURE__ */ new Map();
+		for (let e = 0; e < t.length; e++) n.set(o(t[e]), e);
+		let r = [...t].sort((t, r) => {
+			t = o(t), r = o(r);
+			let i = e(t), a = e(r);
+			return i === a ? n.get(t) - n.get(r) : i - a;
+		});
+		return r.some((e, n) => e !== t[n]) ? r : t;
+	};
+}
+//#endregion
+export { m as SchemaError, p as SchemaErrorTypeId, f as make, h as makeReorder };

package/dist/vue-components61.es.js

@@ -0,0 +1,520 @@
+var e = new class {
+	[Symbol.iterator]() {
+		return this;
+	}
+	next(e) {
+		return {
+			value: e,
+			done: !0
+		};
+	}
+}();
+function t() {
+	return e;
+}
+function* n(e, t) {
+	for (let n of e) yield t(n);
+}
+function* r(e, t) {
+	for (let n of e) yield* t(n);
+}
+function* i(e, t) {
+	for (let n of e) t(n) && (yield n);
+}
+function* a(e, t) {
+	for (let n = 0; n < t; ++n) {
+		let t = e.next();
+		if (t.done) break;
+		yield t.value;
+	}
+}
+function* o(e, t) {
+	let n = e.next();
+	for (; !n.done && t(n.value);) yield n.value, n = e.next();
+}
+function* s(e, t) {
+	for (let t = e.next(); !t.done; t = e.next()) yield t.value;
+	for (let e of t) for (let t = e.next(); !t.done; t = e.next()) yield t.value;
+}
+var c = Symbol.iterator, l = class e {
+	static nil() {
+		return new e(t());
+	}
+	static of(...t) {
+		return new e(t[c]());
+	}
+	constructor(e) {
+		this.g = e;
+	}
+	next() {
+		return this.g.next();
+	}
+	[Symbol.iterator]() {
+		return this.g;
+	}
+	map(t) {
+		return new e(n(this.g, t));
+	}
+	flatMap(t) {
+		return new e(r(this.g, t));
+	}
+	dropWhile(e) {
+		let t = !1;
+		function* n(n) {
+			(t || !e(n)) && (t = !0, yield n);
+		}
+		return this.flatMap(n);
+	}
+	drop(e) {
+		if (e <= 0) return this;
+		let t = 0;
+		function n() {
+			return t++ < e;
+		}
+		return this.dropWhile(n);
+	}
+	takeWhile(t) {
+		return new e(o(this.g, t));
+	}
+	take(t) {
+		return new e(a(this.g, t));
+	}
+	filter(t) {
+		return new e(i(this.g, t));
+	}
+	every(e) {
+		for (let t of this.g) if (!e(t)) return !1;
+		return !0;
+	}
+	has(e) {
+		for (let t of this.g) if (e(t)) return [!0, t];
+		return [!1, null];
+	}
+	join(...t) {
+		return new e(s(this.g, t));
+	}
+	getNthOrLast(e) {
+		let t = e, n = null;
+		for (let e of this.g) {
+			if (t-- === 0) return e;
+			n = e;
+		}
+		return n;
+	}
+}, u = Symbol.for("fast-check/cloneMethod");
+function d(e) {
+	return e !== null && (typeof e == "object" || typeof e == "function") && u in e && typeof e[u] == "function";
+}
+var f = Object.defineProperty, p = class {
+	constructor(e, t, n = void 0) {
+		this.value_ = e, this.context = t, this.hasToBeCloned = n !== void 0 || d(e), this.readOnce = !1, this.hasToBeCloned ? f(this, "value", { get: n === void 0 ? this.getValue : n }) : this.value = e;
+	}
+	getValue() {
+		return this.hasToBeCloned ? this.readOnce ? this.value_[u]() : (this.readOnce = !0, this.value_) : this.value_;
+	}
+}, m = class {
+	filter(e) {
+		return new _(this, e);
+	}
+	map(e, t) {
+		return new g(this, e, t);
+	}
+	chain(e) {
+		return new h(this, e);
+	}
+}, h = class extends m {
+	constructor(e, t) {
+		super(), this.arb = e, this.chainer = t;
+	}
+	generate(e, t) {
+		let n = e.clone(), r = this.arb.generate(e, t);
+		return this.valueChainer(r, e, n, t);
+	}
+	canShrinkWithoutContext(e) {
+		return !1;
+	}
+	shrink(e, t) {
+		return this.isSafeContext(t) ? (t.stoppedForOriginal ? l.nil() : this.arb.shrink(t.originalValue, t.originalContext).map((e) => this.valueChainer(e, t.clonedMrng.clone(), t.clonedMrng, t.originalBias))).join(t.chainedArbitrary.shrink(e, t.chainedContext).map((e) => {
+			let n = {
+				...t,
+				chainedContext: e.context,
+				stoppedForOriginal: !0
+			};
+			return new p(e.value_, n);
+		})) : l.nil();
+	}
+	valueChainer(e, t, n, r) {
+		let i = this.chainer(e.value_), a = i.generate(t, r), o = {
+			originalBias: r,
+			originalValue: e.value_,
+			originalContext: e.context,
+			stoppedForOriginal: !1,
+			chainedArbitrary: i,
+			chainedContext: a.context,
+			clonedMrng: n
+		};
+		return new p(a.value_, o);
+	}
+	isSafeContext(e) {
+		return typeof e == "object" && !!e && "originalBias" in e && "originalValue" in e && "originalContext" in e && "stoppedForOriginal" in e && "chainedArbitrary" in e && "chainedContext" in e && "clonedMrng" in e;
+	}
+}, g = class extends m {
+	constructor(e, t, n) {
+		super(), this.arb = e, this.mapper = t, this.unmapper = n, this.bindValueMapper = (e) => this.valueMapper(e);
+	}
+	generate(e, t) {
+		let n = this.arb.generate(e, t);
+		return this.valueMapper(n);
+	}
+	canShrinkWithoutContext(e) {
+		if (this.unmapper !== void 0) try {
+			let t = this.unmapper(e);
+			return this.arb.canShrinkWithoutContext(t);
+		} catch {
+			return !1;
+		}
+		return !1;
+	}
+	shrink(e, t) {
+		if (this.isSafeContext(t)) return this.arb.shrink(t.originalValue, t.originalContext).map(this.bindValueMapper);
+		if (this.unmapper !== void 0) {
+			let t = this.unmapper(e);
+			return this.arb.shrink(t, void 0).map(this.bindValueMapper);
+		}
+		return l.nil();
+	}
+	mapperWithCloneIfNeeded(e) {
+		let t = e.value, n = this.mapper(t);
+		return e.hasToBeCloned && (typeof n == "object" && n || typeof n == "function") && Object.isExtensible(n) && !d(n) && Object.defineProperty(n, u, { get: () => () => this.mapperWithCloneIfNeeded(e)[0] }), [n, t];
+	}
+	valueMapper(e) {
+		let [t, n] = this.mapperWithCloneIfNeeded(e);
+		return new p(t, {
+			originalValue: n,
+			originalContext: e.context
+		});
+	}
+	isSafeContext(e) {
+		return typeof e == "object" && !!e && "originalValue" in e && "originalContext" in e;
+	}
+}, _ = class extends m {
+	constructor(e, t) {
+		super(), this.arb = e, this.refinement = t, this.bindRefinementOnValue = (e) => this.refinementOnValue(e);
+	}
+	generate(e, t) {
+		for (;;) {
+			let n = this.arb.generate(e, t);
+			if (this.refinementOnValue(n)) return n;
+		}
+	}
+	canShrinkWithoutContext(e) {
+		return this.arb.canShrinkWithoutContext(e) && this.refinement(e);
+	}
+	shrink(e, t) {
+		return this.arb.shrink(e, t).filter(this.bindRefinementOnValue);
+	}
+	refinementOnValue(e) {
+		return this.refinement(e.value);
+	}
+};
+Function.prototype.apply;
+var v = Array, y = BigInt;
+BigInt64Array, BigUint64Array;
+var b = Number;
+Array.prototype.forEach, Array.prototype.indexOf, Array.prototype.join, Array.prototype.map, Array.prototype.flat, Array.prototype.filter, Array.prototype.push, Array.prototype.pop, Array.prototype.splice, Array.prototype.slice, Array.prototype.sort, Array.prototype.every, Date.prototype.getTime, Date.prototype.toISOString, Set.prototype.add, Set.prototype.has, WeakMap.prototype.set, WeakMap.prototype.get, Map.prototype.set, Map.prototype.get, Map.prototype.has, String.prototype.split, String.prototype.startsWith, String.prototype.endsWith, String.prototype.substring, String.prototype.toLowerCase, String.prototype.toUpperCase, String.prototype.padStart, String.prototype.charCodeAt, String.prototype.normalize, String.prototype.replace, Number.prototype.toString, Error.prototype.toString, Array.isArray, Date.now, Array.from, typeof Buffer < "u" && Buffer.isBuffer, Number.isNaN, Date.now, Array.isArray, Number.isInteger, Number.isInteger, Array.isArray;
+var x = Object.getPrototypeOf, S = class extends m {
+	constructor(e) {
+		super(), this.arb = e;
+	}
+	generate(e, t) {
+		return this.arb.generate(e, void 0);
+	}
+	canShrinkWithoutContext(e) {
+		return this.arb.canShrinkWithoutContext(e);
+	}
+	shrink(e, t) {
+		return this.arb.shrink(e, t);
+	}
+};
+function C(e) {
+	return x(e) === S.prototype && e.generate === S.prototype.generate && e.canShrinkWithoutContext === S.prototype.canShrinkWithoutContext && e.shrink === S.prototype.shrink ? e : new S(e);
+}
+Number.isNaN, Number.isNaN, Array.isArray, Number.isNaN, Number.isInteger, Number.isInteger, String.fromCodePoint, String.fromCharCode, b.NEGATIVE_INFINITY, b.POSITIVE_INFINITY, b.EPSILON, -(y(2146435072) * y(4294967296)) - y(1), y(0xfffffffffffff), y("9007199254740992");
+var w = new Float64Array(1);
+new Uint32Array(w.buffer, w.byteOffset), Number.isInteger, Number.MAX_VALUE, Number.isInteger, Number.isNaN, Number.MAX_VALUE;
+var T = new Float32Array(1);
+new Uint32Array(T.buffer, T.byteOffset), Number.isInteger, Number.isNaN;
+var E = Object.getPrototypeOf, D = class extends m {
+	constructor(e) {
+		super(), this.arb = e;
+	}
+	generate(e, t) {
+		return this.arb.generate(e, t);
+	}
+	canShrinkWithoutContext(e) {
+		return this.arb.canShrinkWithoutContext(e);
+	}
+	shrink(e, t) {
+		return l.nil();
+	}
+};
+function O(e) {
+	return E(e) === D.prototype && e.generate === D.prototype.generate && e.canShrinkWithoutContext === D.prototype.canShrinkWithoutContext && e.shrink === D.prototype.shrink ? e : new D(e);
+}
+Number.parseInt, v.isArray, String.fromCharCode, Array.isArray, k({
+	ASCII: "ASCII",
+	ASCII_Hex_Digit: "AHex",
+	Alphabetic: "Alpha",
+	Any: "Any",
+	Assigned: "Assigned",
+	Bidi_Control: "Bidi_C",
+	Bidi_Mirrored: "Bidi_M",
+	Case_Ignorable: "CI",
+	Cased: "Cased",
+	Changes_When_Casefolded: "CWCF",
+	Changes_When_Casemapped: "CWCM",
+	Changes_When_Lowercased: "CWL",
+	Changes_When_NFKC_Casefolded: "CWKCF",
+	Changes_When_Titlecased: "CWT",
+	Changes_When_Uppercased: "CWU",
+	Dash: "Dash",
+	Default_Ignorable_Code_Point: "DI",
+	Deprecated: "Dep",
+	Diacritic: "Dia",
+	Emoji: "Emoji",
+	Emoji_Component: "Emoji_Component",
+	Emoji_Modifier: "Emoji_Modifier",
+	Emoji_Modifier_Base: "Emoji_Modifier_Base",
+	Emoji_Presentation: "Emoji_Presentation",
+	Extended_Pictographic: "Extended_Pictographic",
+	Extender: "Ext",
+	Grapheme_Base: "Gr_Base",
+	Grapheme_Extend: "Gr_Ext",
+	Hex_Digit: "Hex",
+	IDS_Binary_Operator: "IDSB",
+	IDS_Trinary_Operator: "IDST",
+	ID_Continue: "IDC",
+	ID_Start: "IDS",
+	Ideographic: "Ideo",
+	Join_Control: "Join_C",
+	Logical_Order_Exception: "LOE",
+	Lowercase: "Lower",
+	Math: "Math",
+	Noncharacter_Code_Point: "NChar",
+	Pattern_Syntax: "Pat_Syn",
+	Pattern_White_Space: "Pat_WS",
+	Quotation_Mark: "QMark",
+	Radical: "Radical",
+	Regional_Indicator: "RI",
+	Sentence_Terminal: "STerm",
+	Soft_Dotted: "SD",
+	Terminal_Punctuation: "Term",
+	Unified_Ideograph: "UIdeo",
+	Uppercase: "Upper",
+	Variation_Selector: "VS",
+	White_Space: "space",
+	XID_Continue: "XIDC",
+	XID_Start: "XIDS"
+}), k({
+	Cased_Letter: "LC",
+	Close_Punctuation: "Pe",
+	Connector_Punctuation: "Pc",
+	Control: ["Cc", "cntrl"],
+	Currency_Symbol: "Sc",
+	Dash_Punctuation: "Pd",
+	Decimal_Number: ["Nd", "digit"],
+	Enclosing_Mark: "Me",
+	Final_Punctuation: "Pf",
+	Format: "Cf",
+	Initial_Punctuation: "Pi",
+	Letter: "L",
+	Letter_Number: "Nl",
+	Line_Separator: "Zl",
+	Lowercase_Letter: "Ll",
+	Mark: ["M", "Combining_Mark"],
+	Math_Symbol: "Sm",
+	Modifier_Letter: "Lm",
+	Modifier_Symbol: "Sk",
+	Nonspacing_Mark: "Mn",
+	Number: "N",
+	Open_Punctuation: "Ps",
+	Other: "C",
+	Other_Letter: "Lo",
+	Other_Number: "No",
+	Other_Punctuation: "Po",
+	Other_Symbol: "So",
+	Paragraph_Separator: "Zp",
+	Private_Use: "Co",
+	Punctuation: ["P", "punct"],
+	Separator: "Z",
+	Space_Separator: "Zs",
+	Spacing_Mark: "Mc",
+	Surrogate: "Cs",
+	Symbol: "S",
+	Titlecase_Letter: "Lt",
+	Unassigned: "Cn",
+	Uppercase_Letter: "Lu"
+}), k({
+	Adlam: "Adlm",
+	Ahom: "Ahom",
+	Anatolian_Hieroglyphs: "Hluw",
+	Arabic: "Arab",
+	Armenian: "Armn",
+	Avestan: "Avst",
+	Balinese: "Bali",
+	Bamum: "Bamu",
+	Bassa_Vah: "Bass",
+	Batak: "Batk",
+	Bengali: "Beng",
+	Bhaiksuki: "Bhks",
+	Bopomofo: "Bopo",
+	Brahmi: "Brah",
+	Braille: "Brai",
+	Buginese: "Bugi",
+	Buhid: "Buhd",
+	Canadian_Aboriginal: "Cans",
+	Carian: "Cari",
+	Caucasian_Albanian: "Aghb",
+	Chakma: "Cakm",
+	Cham: "Cham",
+	Cherokee: "Cher",
+	Common: "Zyyy",
+	Coptic: ["Copt", "Qaac"],
+	Cuneiform: "Xsux",
+	Cypriot: "Cprt",
+	Cyrillic: "Cyrl",
+	Deseret: "Dsrt",
+	Devanagari: "Deva",
+	Dogra: "Dogr",
+	Duployan: "Dupl",
+	Egyptian_Hieroglyphs: "Egyp",
+	Elbasan: "Elba",
+	Ethiopic: "Ethi",
+	Georgian: "Geor",
+	Glagolitic: "Glag",
+	Gothic: "Goth",
+	Grantha: "Gran",
+	Greek: "Grek",
+	Gujarati: "Gujr",
+	Gunjala_Gondi: "Gong",
+	Gurmukhi: "Guru",
+	Han: "Hani",
+	Hangul: "Hang",
+	Hanifi_Rohingya: "Rohg",
+	Hanunoo: "Hano",
+	Hatran: "Hatr",
+	Hebrew: "Hebr",
+	Hiragana: "Hira",
+	Imperial_Aramaic: "Armi",
+	Inherited: ["Zinh", "Qaai"],
+	Inscriptional_Pahlavi: "Phli",
+	Inscriptional_Parthian: "Prti",
+	Javanese: "Java",
+	Kaithi: "Kthi",
+	Kannada: "Knda",
+	Katakana: "Kana",
+	Kayah_Li: "Kali",
+	Kharoshthi: "Khar",
+	Khmer: "Khmr",
+	Khojki: "Khoj",
+	Khudawadi: "Sind",
+	Lao: "Laoo",
+	Latin: "Latn",
+	Lepcha: "Lepc",
+	Limbu: "Limb",
+	Linear_A: "Lina",
+	Linear_B: "Linb",
+	Lisu: "Lisu",
+	Lycian: "Lyci",
+	Lydian: "Lydi",
+	Mahajani: "Mahj",
+	Makasar: "Maka",
+	Malayalam: "Mlym",
+	Mandaic: "Mand",
+	Manichaean: "Mani",
+	Marchen: "Marc",
+	Medefaidrin: "Medf",
+	Masaram_Gondi: "Gonm",
+	Meetei_Mayek: "Mtei",
+	Mende_Kikakui: "Mend",
+	Meroitic_Cursive: "Merc",
+	Meroitic_Hieroglyphs: "Mero",
+	Miao: "Plrd",
+	Modi: "Modi",
+	Mongolian: "Mong",
+	Mro: "Mroo",
+	Multani: "Mult",
+	Myanmar: "Mymr",
+	Nabataean: "Nbat",
+	New_Tai_Lue: "Talu",
+	Newa: "Newa",
+	Nko: "Nkoo",
+	Nushu: "Nshu",
+	Ogham: "Ogam",
+	Ol_Chiki: "Olck",
+	Old_Hungarian: "Hung",
+	Old_Italic: "Ital",
+	Old_North_Arabian: "Narb",
+	Old_Permic: "Perm",
+	Old_Persian: "Xpeo",
+	Old_Sogdian: "Sogo",
+	Old_South_Arabian: "Sarb",
+	Old_Turkic: "Orkh",
+	Oriya: "Orya",
+	Osage: "Osge",
+	Osmanya: "Osma",
+	Pahawh_Hmong: "Hmng",
+	Palmyrene: "Palm",
+	Pau_Cin_Hau: "Pauc",
+	Phags_Pa: "Phag",
+	Phoenician: "Phnx",
+	Psalter_Pahlavi: "Phlp",
+	Rejang: "Rjng",
+	Runic: "Runr",
+	Samaritan: "Samr",
+	Saurashtra: "Saur",
+	Sharada: "Shrd",
+	Shavian: "Shaw",
+	Siddham: "Sidd",
+	SignWriting: "Sgnw",
+	Sinhala: "Sinh",
+	Sogdian: "Sogd",
+	Sora_Sompeng: "Sora",
+	Soyombo: "Soyo",
+	Sundanese: "Sund",
+	Syloti_Nagri: "Sylo",
+	Syriac: "Syrc",
+	Tagalog: "Tglg",
+	Tagbanwa: "Tagb",
+	Tai_Le: "Tale",
+	Tai_Tham: "Lana",
+	Tai_Viet: "Tavt",
+	Takri: "Takr",
+	Tamil: "Taml",
+	Tangut: "Tang",
+	Telugu: "Telu",
+	Thaana: "Thaa",
+	Thai: "Thai",
+	Tibetan: "Tibt",
+	Tifinagh: "Tfng",
+	Tirhuta: "Tirh",
+	Ugaritic: "Ugar",
+	Vai: "Vaii",
+	Warang_Citi: "Wara",
+	Yi: "Yiii",
+	Zanabazar_Square: "Zanb"
+});
+function k(e) {
+	let t = {};
+	for (let n of Object.keys(e)) {
+		let r = e[n];
+		if (Array.isArray(r)) for (let e = 0; e !== r.length; ++e) t[r[e]] = n;
+		else t[r] = n;
+	}
+	return t;
+}
+String.fromCodePoint, String.fromCodePoint, String.fromCodePoint;
+var A = [..."\r\n"], j = [...""];
+[...A, ...j];
+//#endregion
+export { C as noBias, O as noShrink };