@synnaxlabs/pluto 0.53.2 → 0.54.0

package/dist/aether-Bl3vMZO3.js

@@ -0,0 +1,716 @@
+import { n as e } from "./chunk-DeC0fbbY.js";
+import { d as t, o as n, t as r } from "./types-BGbd8pRh.js";
+import { NotFoundError as i, UnexpectedError as a, ValidationError as o } from "@synnaxlabs/client";
+import { color as s, deep as c, shallow as l, status as u } from "@synnaxlabs/x";
+import { z as d } from "zod";
+import { alamos as f } from "@synnaxlabs/alamos";
+//#region src/util/zod.ts
+var p = (e, t, n = "") => {
+	try {
+		return e.parse(t);
+	} catch (e) {
+		if (e instanceof d.ZodError) {
+			let t = e.issues.map((e) => e.path.length === 0 ? e.message : `${e.path.join(".")}: ${e.message}`);
+			throw Error(`${n} - ${t.join("\n")}`, { cause: e });
+		} else throw e;
+	}
+}, ee = /* @__PURE__ */ e({
+	Composite: () => _,
+	Leaf: () => g,
+	Root: () => v,
+	isFireAndForget: () => h,
+	render: () => y
+}), m = (e, t) => e instanceof Error ? (e.message = `[${t}] - ${e.message}`, e) : Error(t ?? "unknown error", { cause: e }), h = (e) => {
+	let t = e._zod.def.output;
+	return t instanceof d.ZodVoid || t instanceof d.ZodNever || t instanceof d.ZodUnknown;
+}, g = class {
+	type;
+	key;
+	sender;
+	_internalState;
+	_state;
+	_prevState;
+	_deleted = !1;
+	parentCtxValues;
+	childCtxValues;
+	childCtxChangedKeys;
+	instrumentation;
+	schema = void 0;
+	methods = void 0;
+	_methodImplementations = null;
+	constructor({ key: e, type: t, sender: n, instrumentation: r, parentCtxValues: i }) {
+		this.type = t, this.key = e, this.sender = n, this._internalState = {}, this.instrumentation = r.child(this.toString()), this.parentCtxValues = /* @__PURE__ */ new Map(), i?.forEach((e, t) => this.parentCtxValues.set(t, e)), this.childCtxValues = /* @__PURE__ */ new Map(), this.childCtxChangedKeys = /* @__PURE__ */ new Set();
+	}
+	initializeMethods() {
+		if (!(this.methods == null || this._methodImplementations != null)) {
+			this._methodImplementations = {};
+			for (let [e, t] of Object.entries(this.methods)) {
+				let n = this[e];
+				if (typeof n != "function") throw Error(`Method ${e} is not a function`);
+				this._methodImplementations[e] = h(t) ? t.implement(n.bind(this)) : t.implementAsync(n.bind(this));
+			}
+		}
+	}
+	get _schema() {
+		if (this.schema == null) throw new o("[AetherLeaf] - expected subclass to define component schema, but none was found.\n        Make sure to define a property 'schema' on the class.");
+		return this.schema;
+	}
+	setState(e) {
+		let n = t(e, this.state);
+		this._prevState = l.copy(this._state), this._state = p(this._schema, n, `${this.toString()}`), this.sender.send({
+			variant: "update",
+			key: this.key,
+			state: this._state
+		});
+	}
+	get state() {
+		if (this._state == null) throw new a(`[AetherLeaf] - state not defined in ${this.toString()}`);
+		return this._state;
+	}
+	get internal() {
+		return this._internalState;
+	}
+	get prevState() {
+		if (this._prevState === void 0) throw Error("prevState not defined");
+		return this._prevState;
+	}
+	get deleted() {
+		return this._deleted;
+	}
+	get ctx() {
+		return {
+			get: (e) => {
+				let t = this.parentCtxValues.get(e);
+				if (t === void 0) throw new i(`Context value for ${e} not found on ${this.toString()}`);
+				return t;
+			},
+			getOptional: (e) => this.parentCtxValues.get(e),
+			has: (e) => this.parentCtxValues.has(e),
+			wasSetPreviously: (e) => this.childCtxValues.has(e),
+			set: (e, t, n = !0) => {
+				this.childCtxValues.set(e, t), n && this.childCtxChangedKeys.add(e);
+			}
+		};
+	}
+	toString() {
+		return `${this.type}(${this.key})`;
+	}
+	_updateState({ path: e, state: t }) {
+		if (!this.deleted) try {
+			this.initializeMethods();
+			let n = this.instrumentation.T.debug(`${this.toString()}:updateState`);
+			this.validatePath(e);
+			let r = p(this._schema, t, `${this.toString()}`);
+			this._state == null ? this.instrumentation.L.debug("setting initial state", {
+				state: t,
+				path: e
+			}) : this.instrumentation.L.debug("updating state", () => ({ diff: c.difference(this.state, r) })), this._prevState = this._state ?? r, this._state = r, this.afterUpdate(this.ctx), n();
+		} catch (e) {
+			throw m(e, `${this.toString()}.updateState`);
+		}
+	}
+	_updateContext(e) {
+		try {
+			let t = this.instrumentation.T.debug(`${this.toString()}:updateContext`);
+			e.forEach((e, t) => this.parentCtxValues.set(t, e)), this.afterUpdate(this.ctx), t();
+		} catch (e) {
+			throw m(e, `${this.type}.${this.key}.updateContext`);
+		}
+	}
+	_delete(e) {
+		try {
+			let t = this.instrumentation.T.debug(`${this.toString()}:delete`);
+			this.validatePath(e), this._deleted = !0, this.afterDelete(this.ctx), t();
+		} catch (e) {
+			throw m(e, `[${this.toString()}:delete]`);
+		}
+	}
+	afterUpdate(e) {}
+	afterDelete(e) {}
+	validatePath(e) {
+		if (e.length === 0) throw new a(`[Leaf.setState] - ${this.toString()} received an empty path`);
+		let t = e[e.length - 1];
+		if (e.length > 1) throw new a(`[Leaf.setState] - ${this.toString()} received a subPath ${e.join(".")} but is a leaf`);
+		if (t !== this.key) throw new a(`[Leaf.setState] - ${this.toString()} received a key ${t} but expected ${this.key}`);
+	}
+	handleInvokeError({ method: e, key: t, args: n }, r) {
+		if (t == null) return console.error(`Error in fire and forget method ${e} on ${this.toString()}`, r);
+		let i = r instanceof Error ? r : Error(String(r));
+		this.sender.send({
+			variant: "invoke_response",
+			key: t,
+			result: void 0,
+			error: {
+				name: i.name,
+				message: `Failed to execute ${e}(${t}) with args ${JSON.stringify(n)} on ${this.toString()}: ${i.message}`,
+				stack: i.stack ?? ""
+			}
+		});
+	}
+	_invokeMethod(e) {
+		if (this.deleted) return;
+		let { method: t, key: n, args: r } = e, i = n != null, a = this._methodImplementations?.[t];
+		if (a == null) return this.handleInvokeError(e, /* @__PURE__ */ Error(`Method ${t} not found on ${this.toString()}`));
+		try {
+			let t = a(...r);
+			t instanceof Promise && t.then((e) => {
+				i && this.sender.send({
+					variant: "invoke_response",
+					key: n,
+					result: e
+				});
+			}).catch((t) => this.handleInvokeError(e, t));
+		} catch (t) {
+			this.handleInvokeError(e, t);
+		}
+	}
+}, _ = class extends g {
+	_children = /* @__PURE__ */ new Map();
+	get children() {
+		return Array.from(this._children.values());
+	}
+	getChild(e) {
+		return this._children.get(e) ?? null;
+	}
+	childrenOfType(...e) {
+		return this.children.filter((t) => e.includes(t.type));
+	}
+	_updateState(e) {
+		let { path: t, type: n, create: r } = e;
+		if (this.deleted) return;
+		let i = this.parsePath(t);
+		if (i.length === 0) {
+			if (this.childCtxChangedKeys.clear(), super._updateState(e), this.childCtxChangedKeys.size == 0) return;
+			this.updateChildContexts();
+			return;
+		}
+		let o = i[0], s = this.getChild(o);
+		if (s != null) return s._updateState({
+			...e,
+			path: i
+		});
+		if (i.length > 1) {
+			let e = t.slice(0, t.indexOf(o) + 1).join("."), r = t.join(".");
+			throw new a(`Child of ${this.toString()} at path ${e} does not exist,
+        but an extended path ${r} was provided. This means that the aether
+        tree is attempting to create a new child  of type ${n} (or nested children)
+        on a child that does not exist.
+
+        Children present: ${this.children.map((e) => `${e.type}:${e.key}`).join(".")}
+
+        `);
+		}
+		let c = r(this.childCtx());
+		c._updateState({
+			...e,
+			path: i
+		}), this._children.set(o, c);
+	}
+	_updateContext(e) {
+		super._updateContext(e), this.updateChildContexts();
+	}
+	childCtx() {
+		return {
+			get: (e) => this.childCtxValues.get(e) ?? this.parentCtxValues.get(e),
+			forEach: (e) => {
+				this.childCtxValues.forEach((t, n) => e(t, n, this.childCtxValues)), this.parentCtxValues.forEach((t, n) => {
+					this.childCtxValues.has(n) || e(t, n, this.parentCtxValues);
+				});
+			}
+		};
+	}
+	updateChildContexts() {
+		let e = this.childCtx();
+		this.children.forEach((t) => t._updateContext(e));
+	}
+	_delete(e) {
+		let t = this.parsePath(e);
+		if (t.length === 0) {
+			for (let e of this.children) e._delete([e.key]);
+			this._children.clear(), super._delete([this.key]);
+		}
+		let n = this.getChild(t[0]);
+		if (n != null) {
+			if (t.length > 1) return n._delete(t);
+			this._children.delete(n.key), n._delete(t);
+		}
+	}
+	findChildAtPath(e) {
+		if (e.length === 0) return null;
+		let [t, ...n] = e, r = this.getChild(t);
+		return r == null ? null : n.length === 0 ? r : "findChildAtPath" in r && typeof r.findChildAtPath == "function" ? r.findChildAtPath(n) : null;
+	}
+	parsePath(e, t) {
+		let [n, ...r] = e;
+		if (n == null) throw Error(`Composite ${this.toString()} received an empty path${t == null ? "" : ` for ${t}`}`);
+		if (n !== this.key) throw new a(`[Composite.getRequiredKey] - ${this.toString()} received a key ${n} but expected ${this.key}`);
+		return r;
+	}
+}, te = d.object({}), ne = () => {
+	throw Error("should not call create");
+}, v = class e extends _ {
+	static TYPE = "root";
+	static KEY = "root";
+	comms;
+	registry;
+	schema = te;
+	constructor({ comms: t, instrumentation: n = f.Instrumentation.NOOP, registry: r }) {
+		super({
+			key: e.KEY,
+			type: e.TYPE,
+			sender: t,
+			instrumentation: n,
+			parentCtxValues: null
+		}), this.comms = t, this.registry = r;
+	}
+	static render(t) {
+		let n = new e(t);
+		return n._updateState({
+			path: [e.KEY],
+			type: "",
+			state: {},
+			create: ne
+		}), n.comms.handle((e) => {
+			try {
+				n.handle(e);
+			} catch (e) {
+				let t = {
+					name: "unknown",
+					message: JSON.stringify(e),
+					stack: "unknown"
+				};
+				e instanceof Error && (t.name = e.name, t.message = e.message, t.stack = e.stack), n.comms.send({
+					variant: "error",
+					error: t
+				});
+			}
+		}), n;
+	}
+	handle(e) {
+		let { variant: t } = e;
+		if (t === "invoke_request") {
+			this.invokeAtPath(e);
+			return;
+		}
+		let { path: n, type: r } = e;
+		if (t === "delete") {
+			this._delete(n);
+			return;
+		}
+		let { state: i } = e;
+		this._updateState({
+			path: n,
+			type: r,
+			state: i,
+			create: (e) => {
+				let t = n[n.length - 1];
+				return this.create({
+					key: t,
+					type: r,
+					parentCtxValues: e
+				});
+			}
+		});
+	}
+	invokeAtPath(t) {
+		let { path: n } = t, [r, ...a] = n;
+		if (r !== e.KEY) {
+			this.handleInvokeError(t, /* @__PURE__ */ Error(`Invalid path: expected root key '${e.KEY}', got '${r}'`));
+			return;
+		}
+		if (a.length === 0) {
+			this._invokeMethod(t);
+			return;
+		}
+		let o = this.findChildAtPath(a);
+		if (o == null) {
+			this.handleInvokeError(t, new i(`Component at path ${n.join(".")} not found`));
+			return;
+		}
+		o._invokeMethod(t);
+	}
+	create({ key: e, type: t, parentCtxValues: n }) {
+		let r = this.registry[t];
+		if (r == null) throw new a(`[Root.create] - ${t} not found in registry`);
+		return new r({
+			key: e,
+			type: t,
+			sender: this.comms,
+			instrumentation: this.instrumentation,
+			parentCtxValues: n
+		});
+	}
+}, y = v.render.bind(v), b = (e, t) => Array.isArray(t) ? t.some((t) => t.matches(e)) : t?.matches(e) ?? !1, re = (e) => {
+	console.error(u.toString(e));
+}, x = (e, t, n) => {
+	let r = u.fromException(e, t);
+	return re(r), b(e, n) ? null : r;
+}, S = (e, t, n, r) => {
+	if (typeof e == "function") return !0;
+	let i = x(e, n, r);
+	return i != null && t(i), !1;
+}, C = async (e, t, n, r) => {
+	try {
+		let t = e();
+		t != null && await t;
+	} catch (e) {
+		let i = x(e, n, r);
+		if (i != null) return t(i);
+	}
+}, w = (e) => (t, n, r) => {
+	S(t, e, n, r) && C(t, e, n, r);
+}, T = (e) => async (t, n, r) => {
+	S(t, e, n, r) && await C(t, e, n, r);
+}, E = d.object({ statuses: u.statusZ().array() }), D = "status.aggregator", O = class extends _ {
+	static TYPE = "status.Aggregator";
+	schema = E;
+	afterUpdate(e) {
+		e.wasSetPreviously(D) || e.set(D, {
+			add: this.add.bind(this),
+			create: u.create
+		});
+	}
+	add(e) {
+		this.setState((t) => ({
+			...t,
+			statuses: [...t.statuses, u.create(e)]
+		}));
+	}
+}, k = (e) => e.get(D).add, ie = (e) => {
+	let t = e.getOptional(D);
+	return t == null ? () => {} : t.add;
+}, A = (e) => w(k(e)), ae = (e) => T(k(e)), oe = { [O.TYPE]: O }, se = d.object({
+	l0: s.colorZ,
+	l1: s.colorZ,
+	l2: s.colorZ,
+	l3: s.colorZ,
+	l4: s.colorZ,
+	l5: s.colorZ,
+	l6: s.colorZ,
+	l7: s.colorZ,
+	l8: s.colorZ,
+	l9: s.colorZ,
+	l10: s.colorZ,
+	l11: s.colorZ
+}), j = (e, t) => [
+	e[0],
+	e[1],
+	t,
+	e[3]
+], M = d.object({
+	m2: s.colorZ,
+	m1: s.colorZ,
+	z: s.colorZ,
+	p1: s.colorZ,
+	p2: s.colorZ
+}).or(s.colorZ.transform((e) => {
+	let t = s.hsla(e);
+	return {
+		m2: s.fromHSLA(j(t, 40)),
+		m1: s.fromHSLA(j(t, 45)),
+		z: e,
+		p1: s.fromHSLA(j(t, 55)),
+		p2: s.fromHSLA(j(t, 65))
+	};
+})), N = d.object({
+	name: d.string(),
+	key: d.string(),
+	colors: d.object({
+		border: s.colorZ,
+		primary: M,
+		gray: se,
+		error: M,
+		secondary: M,
+		warning: M,
+		palettes: d.record(d.string(), s.paletteZ),
+		visualization: d.object({ palettes: d.record(d.string(), d.array(s.colorZ)) }).default({ palettes: {} }),
+		white: s.colorZ,
+		black: s.colorZ,
+		text: s.colorZ,
+		textInverted: s.colorZ,
+		textOnPrimary: s.colorZ.default(s.ZERO),
+		primaryText: s.colorZ,
+		errorText: s.colorZ,
+		warningText: s.colorZ,
+		logo: d.string()
+	}),
+	sizes: d.object({
+		base: d.number(),
+		border: d.object({
+			radius: d.number(),
+			width: d.number(),
+			thickWidth: d.number()
+		}),
+		schematic: d.object({ elementStrokeWidth: d.number() })
+	}),
+	typography: d.object({
+		family: d.string(),
+		codeFamily: d.string(),
+		h1: n,
+		h2: n,
+		h3: n,
+		h4: n,
+		h5: n,
+		p: n,
+		small: n
+	})
+}).transform((e) => ((e.colors.textOnPrimary == null || s.isZero(e.colors.textOnPrimary)) && (e.colors.textOnPrimary = s.pickByContrast(e.colors.primary.z, e.colors.text, e.colors.textInverted)), e)), P = "\"Inter Variable\", sans-serif", F = "\"Geist Mono\", monospace", ce = 6, I = [
+	357,
+	91,
+	55,
+	1
+], L = [
+	48,
+	90,
+	55,
+	1
+], R = Object.fromEntries([
+	"#FEFEFE",
+	"#FAFAFA",
+	"#F2F2F2",
+	"#ECECEC",
+	"#E4E4E4",
+	"#D1D1D1",
+	"#BCBCBC",
+	"#ACACAC",
+	"#8F8F8F",
+	"#4F4F4F",
+	"#292929",
+	"#050505"
+].map((e, t) => [`l${t}`, e])), le = typeof window > "u" ? !1 : window.devicePixelRatio > 1, z = {
+	key: "synnaxBase",
+	name: "Synnax Base",
+	colors: {
+		primary: {
+			m2: "#041B3D",
+			m1: "#356fc5",
+			z: "#3774D0",
+			p1: "#5E94EE",
+			p2: "#8AB8FF"
+		},
+		secondary: {
+			m2: "#2D8F4E",
+			m1: "#38B261",
+			z: "#50C878",
+			p1: "#73D393",
+			p2: "#96DEAE"
+		},
+		gray: R,
+		border: R.l4,
+		error: {
+			m2: s.fromHSLA(j(I, 30)),
+			m1: s.fromHSLA(j(I, 40)),
+			z: s.fromHSLA(I),
+			p1: s.fromHSLA(j(I, 65)),
+			p2: s.fromHSLA(j(I, 77))
+		},
+		warning: {
+			m2: s.fromHSLA(j(L, 30)),
+			m1: s.fromHSLA(j(L, 40)),
+			z: s.fromHSLA(L),
+			p1: s.fromHSLA(j(L, 65)),
+			p2: s.fromHSLA(j(L, 75))
+		},
+		palettes: { recent: {
+			key: "recent",
+			name: "Recent",
+			swatches: []
+		} },
+		visualization: { palettes: { default: [
+			"#DC136C",
+			"#20A4F3",
+			"#7AC74F",
+			"#FFC43D",
+			"#FE5F55",
+			"#8075FF",
+			"#D90429",
+			"#f7aef8",
+			"#f18f01",
+			"#791e94",
+			"#279af1",
+			"#d9fff5",
+			"#ff6b6b",
+			"#52ffb8"
+		] } },
+		logo: "url(#synnax-linear-gradient)",
+		white: "#FFFFFF",
+		black: "#000000",
+		text: R.l11,
+		textInverted: R.l0,
+		textOnPrimary: R.l0,
+		primaryText: "#3b82f6",
+		errorText: "#ef4444",
+		warningText: "#f59e0b"
+	},
+	sizes: {
+		base: ce,
+		border: {
+			radius: 3,
+			width: le ? .5 : 1,
+			thickWidth: 1
+		},
+		schematic: { elementStrokeWidth: 2 }
+	},
+	typography: {
+		family: P,
+		codeFamily: F,
+		h1: {
+			size: 5.5,
+			weight: "500",
+			lineHeight: 5.5 * 1.5
+		},
+		h2: {
+			size: 4.5,
+			weight: "medium",
+			lineHeight: 4.5 * 1.5
+		},
+		h3: {
+			size: 3.5,
+			weight: "medium",
+			lineHeight: 3.5 * 1.5
+		},
+		h4: {
+			size: 2.6666,
+			weight: "medium",
+			lineHeight: 2.6666 * 1.5
+		},
+		h5: {
+			size: 2.333333,
+			weight: 450,
+			lineHeight: 2.333333 * 1.5
+		},
+		p: {
+			size: 2.1666666666,
+			weight: "regular",
+			lineHeight: 2 * 1.5
+		},
+		small: {
+			size: 1.916666,
+			weight: "regular",
+			lineHeight: 2.3333333
+		}
+	}
+}, B = Object.freeze({
+	...z,
+	key: "synnaxLight",
+	name: "Synnax Light"
+}), V = Object.fromEntries([
+	"#020202",
+	"#080808",
+	"#151515",
+	"#202020",
+	"#272727",
+	"#3B3B3B",
+	"#4A4A4A",
+	"#5C5C5C",
+	"#767676",
+	"#959595",
+	"#dadada",
+	"#FAFAFA"
+].map((e, t) => [`l${t}`, e])), H = Object.freeze({
+	...z,
+	key: "synnaxDark",
+	name: "Synnax Dark",
+	colors: {
+		...z.colors,
+		gray: V,
+		logo: "var(--pluto-text-color)",
+		border: V.l4,
+		text: V.l11,
+		textInverted: V.l0,
+		textOnPrimary: V.l11,
+		primaryText: "#93c5fd",
+		errorText: "#fca5a5",
+		warningText: "#fcd34d"
+	}
+}), U = {
+	synnaxDark: H,
+	synnaxLight: B
+}, W = [
+	"tiny",
+	"small",
+	"medium",
+	"large",
+	"huge"
+], G = d.enum(W), K = (e) => G.safeParse(e).success, q = [
+	{
+		weight: 200,
+		style: "light",
+		value: "Inter 200, sans-serif"
+	},
+	{
+		weight: 300,
+		value: "Inter Threee, sans-serif"
+	},
+	{
+		weight: 400,
+		value: "Inter Four, sans-serif"
+	},
+	{
+		weight: 500,
+		value: "Inter Five, sans-serif"
+	},
+	{
+		weight: 600,
+		value: "Inter Six, sans-serif"
+	},
+	{
+		weight: 700,
+		value: "Inter Seven, sans-serif"
+	},
+	{
+		weight: 800,
+		value: "Inter Eight, sans-serif"
+	},
+	{
+		weight: 900,
+		style: "bold",
+		value: "Inter Nine, sans-serif"
+	}
+], ue = (e) => q.find((t, n) => n === q.length - 1 ? !0 : typeof e == "number" ? e >= t.weight && e < q[n + 1].weight : t.style === e), J = (e, { level: t, weight: n, code: i }) => {
+	let { typography: a, sizes: { base: o } } = e, s = a.family;
+	if (i) s = a.codeFamily;
+	else if (n != null) {
+		let e = ue(n);
+		s = e == null ? "Inter Light, sans-serif" : e.value;
+	}
+	let c = (o * a[K(t) ? r[t] : t].size).toFixed(1), [l, u] = s.split(", ");
+	return n == null ? ` ${c}px ${s}` : ` ${n} ${c}px ${l}, ${u}`;
+}, Y = "pluto-theming-context", X = d.object({
+	name: d.string(),
+	url: d.string()
+}), de = d.object({
+	theme: N,
+	fontURLs: d.array(X)
+}), Z = class e extends _ {
+	static TYPE = "theming.Provider";
+	static z = de;
+	schema = e.z;
+	afterUpdate(e) {
+		e.getOptional(Y) != null && this.state.theme.key === this.prevState.theme.key || (e.set(Y, this.state.theme), A(e)(async () => {
+			await this.loadFonts();
+		}, "failed to load theme fonts"));
+	}
+	async loadFonts() {
+		await Promise.all(this.state.fontURLs.map(async ({ name: e, url: t }) => {
+			let n = new FontFace(e, `url(${t})`);
+			try {
+				await n.load(), self.fonts.add(n);
+			} catch (e) {
+				console.error(e);
+			}
+		}));
+	}
+}, Q = (e) => e.get(Y), $ = { [Z.TYPE]: Z }, fe = /* @__PURE__ */ e({
+	Provider: () => Z,
+	REGISTRY: () => $,
+	SYNNAX_DARK: () => H,
+	SYNNAX_LIGHT: () => B,
+	SYNNAX_THEMES: () => U,
+	fontSpecZ: () => X,
+	fontString: () => J,
+	themeZ: () => N,
+	use: () => Q
+});
+//#endregion
+export { g as C, p as D, y as E, _ as S, h as T, ae as _, J as a, T as b, G as c, U as d, N as f, k as g, E as h, Q as i, H as l, oe as m, Z as n, W as o, O as p, $ as r, K as s, fe as t, B as u, A as v, ee as w, w as x, ie as y };