@dialecte/core 0.6.4 → 0.8.0

package/dist/project-key-Ch34EtFa.js

@@ -0,0 +1,1435 @@
+import { A as e, B as t, F as n, O as r, R as i, S as a, W as o, a as s, f as c, h as l, w as u, y as d } from "./utils-USNkj4sT.js";
+// src/store/store.constants.ts
+var f = [
+	"",
+	".",
+	".."
+], p = 2e3, m = "_documents", h = "_changeLog", g = "_meta", _ = "xel_";
+function ee(e) {
+	return `${_}${e}`;
+}
+var te = "_blobs", v = "blob_";
+function ne(e) {
+	return `${v}${e}`;
+}
+var re = {
+	primaryKey: "id",
+	indexes: ["name", "configKey"],
+	compoundIndexes: [],
+	arrayIndexes: []
+}, ie = {
+	primaryKey: "id",
+	autoIncrement: !0,
+	indexes: ["documentId"],
+	compoundIndexes: [["documentId", "sequenceNumber"]],
+	arrayIndexes: []
+}, ae = {
+	primaryKey: "key",
+	indexes: [],
+	compoundIndexes: [],
+	arrayIndexes: []
+}, oe = {
+	primaryKey: "id",
+	indexes: ["documentId"],
+	compoundIndexes: [],
+	arrayIndexes: []
+}, se = {
+	primaryKey: "id",
+	indexes: [],
+	compoundIndexes: [],
+	arrayIndexes: []
+};
+// src/store/project-name.ts
+function ce(e) {
+	let { project: t, dialecteId: n } = e;
+	(f.includes(t) || n !== void 0 && f.includes(n)) && o("PROJECT_NAME_INVALID", {
+		detail: `A project cannot be named ${JSON.stringify(t)}${n === void 0 ? "" : ` in dialecte ${JSON.stringify(n)}`}: neither its name nor its dialecte's id may be empty, \`.\` or \`..\``,
+		meta: {
+			project: t,
+			...n !== void 0 && { dialecteId: n }
+		}
+	});
+}
+// src/store/json-values.constants.ts
+var le = {
+	bigint: "a BigInt",
+	function: "a function",
+	symbol: "a symbol"
+}, y = "not well-formed UTF-16 (a lone surrogate)", ue = `text that is ${y}`, b = `a key that is ${y}`;
+// src/store/store-errors.ts
+function de(e) {
+	let { documentId: t } = e;
+	o("STORE_DUPLICATE_ID", {
+		detail: `Document "${t}" is already registered`,
+		meta: { documentId: t }
+	});
+}
+function fe(e) {
+	let { path: t, reason: n } = e;
+	o("DOCUMENT_PATH_INVALID", {
+		detail: `The document path ${JSON.stringify(t)} is refused: ${n}`,
+		meta: { path: t }
+	});
+}
+function pe(e) {
+	let { documentId: t, path: n, takenBy: r } = e;
+	o("DOCUMENT_PATH_TAKEN", {
+		detail: `Document "${t}" cannot take the path "${n}": document "${r}" holds that place`,
+		meta: {
+			documentId: t,
+			path: n,
+			takenBy: r
+		}
+	});
+}
+function me(e) {
+	let { documentId: t, what: n } = e;
+	o("DOCUMENT_NOT_REGISTERED", {
+		detail: `Cannot write ${n} to document "${t}": it is not registered`,
+		meta: { documentId: t }
+	});
+}
+function he(e) {
+	let { documentId: t, recordId: n } = e;
+	o("STORE_RECORD_NOT_FOUND", {
+		detail: `Record "${n}" is not in document "${t}": nothing to update`,
+		meta: {
+			documentId: t,
+			recordId: n
+		}
+	});
+}
+function ge(e) {
+	let { documentId: t, held: n, repeated: r, cause: i } = e, a = [n.length > 0 ? `already holds: ${x(n).join(", ")}` : void 0, r.length > 0 ? `given twice: ${x(r).join(", ")}` : void 0].filter((e) => e !== void 0);
+	o("STORE_DUPLICATE_ID", {
+		detail: `Document "${t}" refuses ids to create - ${a.join("; ")}`,
+		meta: {
+			documentId: t,
+			recordIds: x([...n, ...r])
+		},
+		cause: i
+	});
+}
+function x(e) {
+	return [...new Set(e)];
+}
+function _e(e) {
+	let { storeName: t, connections: n } = e;
+	o("PROJECT_OPEN_ELSEWHERE", {
+		detail: `Project "${t}" cannot be destroyed while another connection has it open: close that one first`,
+		meta: {
+			project: t,
+			...n !== void 0 && { connections: n }
+		}
+	});
+}
+function ve(e) {
+	let { storeName: t } = e;
+	o("STORE_CLOSED", {
+		detail: `Store "${t}" is closed: open it again before using it`,
+		meta: { storeName: t }
+	});
+}
+// src/store/json-values.ts
+function ye(e) {
+	Se({ walk: function() {
+		S({
+			value: e.value,
+			field: "",
+			inArray: !1,
+			ancestors: []
+		});
+	} });
+}
+function be(e) {
+	ye({ value: { writeId: e.writeId } });
+}
+function xe(e) {
+	return Se({ walk: function() {
+		return C({
+			value: e.value,
+			field: "",
+			inArray: !1,
+			ancestors: []
+		});
+	} });
+}
+function Se(e) {
+	try {
+		return e.walk();
+	} catch (e) {
+		let t = e instanceof Error ? e : void 0;
+		o("STORE_VALUE_NOT_JSON", {
+			detail: t?.message ?? String(e),
+			cause: t
+		});
+	}
+}
+function S(e) {
+	let t = E(e);
+	if (t === "leaf") return;
+	let { ancestors: n } = e;
+	if (n.push(e.value), t === "array") {
+		let t = e.value, { length: r } = t;
+		for (let e = 0; e < r; e++) {
+			let r = t[e];
+			T({ value: r }) || S({
+				value: r,
+				field: e,
+				inArray: !0,
+				ancestors: n
+			});
+		}
+	} else {
+		let t = e.value;
+		for (let r of Object.keys(t)) {
+			r.isWellFormed() || k({
+				step: e,
+				kind: b
+			});
+			let i = t[r];
+			T({ value: i }) || S({
+				value: i,
+				field: r,
+				inArray: !1,
+				ancestors: n
+			});
+		}
+	}
+	n.pop();
+}
+function C(e) {
+	let t = E(e);
+	if (t === "leaf") return w({ value: e.value });
+	let { ancestors: n } = e;
+	n.push(e.value);
+	let r = t === "array" ? Ce(e) : we(e);
+	return n.pop(), r;
+}
+function Ce(e) {
+	let { ancestors: t } = e, n = e.value, r = [], { length: i } = n;
+	for (let e = 0; e < i; e++) {
+		let i = n[e];
+		r.push(T({ value: i }) ? w({ value: i }) : C({
+			value: i,
+			field: e,
+			inArray: !0,
+			ancestors: t
+		}));
+	}
+	return r;
+}
+function we(e) {
+	let { ancestors: t } = e, n = e.value, r = {};
+	for (let i of Object.keys(n)) {
+		i.isWellFormed() || k({
+			step: e,
+			kind: b
+		});
+		let a = n[i], o = T({ value: a }) ? w({ value: a }) : C({
+			value: a,
+			field: i,
+			inArray: !1,
+			ancestors: t
+		});
+		o !== void 0 && (i === "__proto__" ? Object.defineProperty(r, i, {
+			value: o,
+			writable: !0,
+			enumerable: !0,
+			configurable: !0
+		}) : r[i] = o);
+	}
+	return r;
+}
+function w(e) {
+	return e.value === 0 ? 0 : e.value;
+}
+function T(e) {
+	let { value: t } = e;
+	switch (typeof t) {
+		case "string": return t.isWellFormed();
+		case "boolean": return !0;
+		case "number": return Number.isFinite(t);
+		case "object": return t === null;
+		default: return !1;
+	}
+}
+function E(e) {
+	let { value: t } = e, n = typeof t;
+	switch (n) {
+		case "string": return t.isWellFormed() ? "leaf" : k({
+			step: e,
+			kind: ue
+		});
+		case "boolean": return "leaf";
+		case "number": return Number.isFinite(t) ? "leaf" : k({
+			step: e,
+			kind: String(t)
+		});
+		case "undefined": return t === void 0 ? e.inArray ? k({
+			step: e,
+			kind: "undefined in an array"
+		}) : "leaf" : D({
+			step: e,
+			held: t
+		});
+		case "object": return t === null ? "leaf" : D({
+			step: e,
+			held: t
+		});
+		default: return k({
+			step: e,
+			kind: le[n]
+		});
+	}
+}
+function D(e) {
+	let { step: t, held: n } = e, r = Array.isArray(n), i = Object.getPrototypeOf(n);
+	return O({
+		prototype: i,
+		name: r ? "Array" : "Object"
+	}) || k({
+		step: t,
+		kind: `an instance of ${n.constructor?.name || "a class"}`
+	}), i === null && JSON.isRawJSON?.(n) && k({
+		step: t,
+		kind: "a raw JSON value"
+	}), typeof n.toJSON == "function" && k({
+		step: t,
+		kind: "a value with toJSON"
+	}), t.ancestors.includes(n) && k({
+		step: t,
+		kind: "a cycle"
+	}), t.ancestors.length >= 512 && k({
+		step: t,
+		kind: "a value nested more than 512 levels deep"
+	}), r ? "array" : "object";
+}
+function O(e) {
+	let { prototype: t, name: n } = e;
+	if (t === (n === "Array" ? Array.prototype : Object.prototype)) return !0;
+	if (t === null) return n === "Object";
+	let r = Object.getOwnPropertyDescriptor(t, "constructor")?.value;
+	return typeof r == "function" && r.name === n;
+}
+function k(e) {
+	let t = String(e.step.field);
+	throw TypeError(`${e.kind} is not a JSON value${t ? ` (field "${t}")` : ""}`);
+}
+// src/utils/tell-listener.ts
+var A = /* @__PURE__ */ new WeakSet();
+function j(e) {
+	let { listener: t, value: n, of: r, call: i } = e;
+	if (t) try {
+		let e = t(n);
+		De(e) && Promise.resolve(e).catch(function(e) {
+			M({
+				call: i,
+				of: r,
+				thrown: e
+			});
+		});
+	} catch (e) {
+		M({
+			call: i,
+			of: r,
+			thrown: e
+		});
+	}
+}
+function Te(e) {
+	return `the changes of project "${e.name}"`;
+}
+function Ee(e) {
+	let { listeners: t, value: n, of: r } = e;
+	for (let e of Array.from(t)) j({
+		listener: e,
+		value: n,
+		of: r
+	});
+}
+function M(e) {
+	let { call: t } = e;
+	if (t !== void 0) {
+		if (A.has(t)) return;
+		A.add(t);
+	}
+	console.error(`[dialecte] a listener of ${e.of} threw; what told it goes on:`, e.thrown);
+}
+function De(e) {
+	return typeof e == "object" && !!e && typeof e.then == "function";
+}
+// src/utils/tell-listener.constants.ts
+var N = {
+	importProgress: "an import's progress",
+	exportProgress: "an export's progress",
+	commitProgress: "a commit's progress",
+	callProgress: "a call's progress",
+	engineChanges: "a project engine's changes"
+}, P = Object.freeze({
+	start() {},
+	stop() {},
+	count() {},
+	time(e, t) {
+		return t();
+	},
+	profile(e, t) {
+		return t();
+	},
+	report() {
+		return {};
+	},
+	log() {},
+	reset() {},
+	snapshot() {
+		return {
+			timeOrigin: performance.timeOrigin,
+			spans: [],
+			totals: {}
+		};
+	},
+	merge() {}
+}), F = "dialecte::";
+function I({ enabled: e, timeline: t = !0 }) {
+	if (!e) return P;
+	let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = [], o = 0;
+	function s(e) {
+		t ? performance.measure(F + e.name, {
+			start: e.startTime,
+			duration: e.duration
+		}) : a.push(e);
+	}
+	function c() {
+		return t ? performance.getEntriesByType("measure").filter((e) => e.name.startsWith(F)).map((e) => ({
+			name: e.name.slice(10),
+			startTime: e.startTime,
+			duration: e.duration
+		})) : a;
+	}
+	function l(e, t, n) {
+		let r = i.get(e) ?? i.set(e, {
+			calls: 0,
+			totalMs: 0
+		}).get(e);
+		r.calls += t, r.totalMs += n;
+	}
+	let u = {
+		start(e) {
+			let r = F + e, i = `${r}:${++o}`;
+			t && performance.mark(i), (n.get(r) ?? n.set(r, []).get(r)).push({
+				mark: i,
+				startTime: performance.now()
+			});
+		},
+		stop(e) {
+			let r = F + e, i = n.get(r)?.pop();
+			i && (t ? (performance.measure(r, i.mark), performance.clearMarks(i.mark)) : a.push({
+				name: e,
+				startTime: i.startTime,
+				duration: performance.now() - i.startTime
+			}));
+		},
+		count(e) {
+			let t = F + e;
+			r.set(t, (r.get(t) ?? 0) + 1);
+		},
+		time(e, t) {
+			let n = F + e, r = performance.now();
+			try {
+				return t();
+			} finally {
+				l(n, 1, performance.now() - r);
+			}
+		},
+		profile(e, t) {
+			return typeof console.profile == "function" ? (console.profile(F + e), Promise.resolve(t()).finally(() => console.profileEnd(F + e))) : t();
+		},
+		report() {
+			let e = {};
+			for (let { name: t, duration: n } of c()) {
+				let r = e[t] ??= {
+					calls: 0,
+					totalMs: 0,
+					avgMs: 0
+				};
+				r.calls++, r.totalMs += n, r.avgMs = r.totalMs / r.calls;
+			}
+			return d(e);
+		},
+		log() {
+			console.table(u.report());
+		},
+		reset() {
+			t && (performance.clearMarks(), performance.clearMeasures()), n.clear(), a.length = 0, r.clear(), i.clear();
+		},
+		snapshot() {
+			return {
+				timeOrigin: performance.timeOrigin,
+				spans: [...c()],
+				totals: d({})
+			};
+		},
+		merge({ report: e, prefix: t }) {
+			let n = e.timeOrigin - performance.timeOrigin;
+			for (let r of e.spans) s({
+				name: `${t}::${r.name}`,
+				startTime: Math.max(0, r.startTime + n),
+				duration: r.duration
+			});
+			for (let [n, i] of Object.entries(e.totals)) {
+				let e = `${F}${t}::${n}`;
+				i.calls > 0 && l(e, i.calls, i.totalMs), i.count !== void 0 && r.set(e, (r.get(e) ?? 0) + i.count);
+			}
+		}
+	};
+	function d(e) {
+		for (let [t, n] of i) {
+			let r = t.slice(10), i = e[r] ??= {
+				calls: 0,
+				totalMs: 0,
+				avgMs: 0
+			};
+			i.calls += n.calls, i.totalMs += n.totalMs, i.avgMs = i.calls ? i.totalMs / i.calls : 0;
+		}
+		for (let [t, n] of r) {
+			let r = t.slice(10), i = e[r] ??= {
+				calls: 0,
+				totalMs: 0,
+				avgMs: 0
+			};
+			i.count = n;
+		}
+		return e;
+	}
+	return u;
+}
+// src/project/io/resolve-config.ts
+function L(e) {
+	let { configs: t, defaultConfigKey: n, configKey: r = n } = e, i = t[r];
+	return c(i, {
+		key: "UNKNOWN_CONFIG_KEY",
+		detail: `Unknown configKey: "${r}". Available: ${Object.keys(t).join(", ")}`
+	}), {
+		configKey: r,
+		config: i
+	};
+}
+// src/utils/yield-to-queue.ts
+function Oe() {
+	return new Promise(function(e) {
+		let t = new MessageChannel();
+		t.port1.onmessage = function() {
+			t.port1.close(), e();
+		}, t.port2.postMessage(null);
+	});
+}
+// src/xml/build/document-root.ts
+function ke(e) {
+	let { record: t, config: n } = e;
+	return t.tagName === n.rootElementName && t.parent === null;
+}
+// src/xml/build/constant.ts
+var R = "_temp-idb-id", Ae = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>", je = "    ", Me = /[&<>"\t\n\r]/, Ne = /[&<>"\t\n\r]/g, Pe = /[&<>]/, Fe = /[&<>]/g, Ie = /[&<>\r]/, Le = /[&<>\r]/g, Re = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"	": "&#9;",
+	"\n": "&#10;",
+	"\r": "&#13;"
+}, ze = {
+	bindings: /* @__PURE__ */ new Map(),
+	parent: void 0
+}, Be = /* @__PURE__ */ new Set();
+// src/xml/build/xml-element.ts
+function Ve(e) {
+	let { namespaceURI: t, qualifiedName: n, parent: r } = e;
+	if (t === null) return {
+		namespaceURI: t,
+		prefix: null,
+		localName: n,
+		attributes: [],
+		parent: r
+	};
+	let { prefix: i, localName: a } = Ze(n);
+	return {
+		namespaceURI: t,
+		prefix: i,
+		localName: a,
+		attributes: [],
+		parent: r
+	};
+}
+function z(e) {
+	let { element: t, qualifiedName: n, value: r } = e, i = t.attributes.find((e) => G(e) === n);
+	i ? i.value = r : t.attributes.push({
+		namespaceURI: null,
+		prefix: null,
+		localName: n,
+		value: r
+	});
+}
+function B(e) {
+	let { element: t, namespaceURI: n, qualifiedName: r, value: i } = e, { prefix: a, localName: o } = Ze(r), s = K({
+		element: t,
+		namespaceURI: n,
+		localName: o
+	});
+	s ? s.value = i : t.attributes.push({
+		namespaceURI: n,
+		prefix: a,
+		localName: o,
+		value: i
+	});
+}
+function He(e) {
+	let { element: t, qualifiedName: n } = e;
+	return t.attributes.some((e) => G(e) === n);
+}
+function Ue(e) {
+	return K(e)?.value ?? null;
+}
+function We(e) {
+	return K(e) !== void 0;
+}
+function V(e) {
+	let { prefix: t } = e;
+	for (let n = e.element; n; n = n.parent) {
+		if (n.namespaceURI !== null && n.prefix === t) return n.namespaceURI;
+		let e = n.attributes.find((e) => Qe({
+			attribute: e,
+			prefix: t
+		}));
+		if (e) return e.value || null;
+	}
+	return null;
+}
+function Ge(e) {
+	let { namespaceURI: t } = e;
+	if (!t) return null;
+	for (let n = e.element; n; n = n.parent) {
+		if (n.namespaceURI === t && n.prefix !== null) return n.prefix;
+		let e = n.attributes.find((e) => e.namespaceURI === "http://www.w3.org/2000/xmlns/" && e.prefix === "xmlns" && e.value === t);
+		if (e) return e.localName;
+	}
+	return null;
+}
+function H(e) {
+	let { element: t, prefixes: n } = e, r, i = e.scope, a;
+	for (let e of t.attributes) {
+		let t = $e(e);
+		t !== void 0 && q({
+			parent: i,
+			own: a,
+			prefix: t
+		}) !== e.value && (a ??= /* @__PURE__ */ new Map(), a.set(t, e.value));
+	}
+	let o = `<${G(t)}`, s = t.prefix ?? "", c = t.namespaceURI ?? "", l = q({
+		parent: i,
+		own: a,
+		prefix: ""
+	});
+	(t.namespaceURI !== null || l) && (q({
+		parent: i,
+		own: a,
+		prefix: s
+	}) ?? "") !== c && (o += s ? ` xmlns:${s}="${U(c)}"` : ` xmlns="${U(c)}"`, a ??= /* @__PURE__ */ new Map(), a.set(s, c));
+	for (let e of t.attributes) {
+		let { namespaceURI: t } = e;
+		if (t === null || t === "http://www.w3.org/2000/xmlns/" || t === "http://www.w3.org/XML/1998/namespace" || e.prefix === null) {
+			o += ` ${G(e)}="${U(e.value)}"`;
+			continue;
+		}
+		let { prefix: s, declare: c } = Ke({
+			attribute: e,
+			parent: i,
+			own: a,
+			prefixes: n
+		});
+		c && (o += ` xmlns:${s}="${U(t)}"`, a ??= /* @__PURE__ */ new Map(), a.set(s, t), r ??= /* @__PURE__ */ new Set(), r.add(s)), o += ` ${s}:${e.localName}="${U(e.value)}"`;
+	}
+	return {
+		text: o,
+		scope: a ? {
+			bindings: a,
+			parent: i
+		} : i,
+		generated: r ?? Be
+	};
+}
+function Ke(e) {
+	let { attribute: t, parent: n, own: r, prefixes: i } = e, a = t.namespaceURI, o = t.prefix, s = q({
+		parent: n,
+		own: r,
+		prefix: o
+	});
+	if (s === a) return {
+		prefix: o,
+		declare: !1
+	};
+	let c = qe({
+		parent: n,
+		own: r,
+		namespaceURI: a
+	});
+	if (c !== void 0) return {
+		prefix: c,
+		declare: !1
+	};
+	if (s === void 0) return {
+		prefix: o,
+		declare: !0
+	};
+	for (;;) {
+		let e = `ns${i.next}`;
+		if (i.next++, q({
+			parent: n,
+			own: r,
+			prefix: e
+		}) === void 0) return {
+			prefix: e,
+			declare: !0
+		};
+	}
+}
+function qe(e) {
+	let { parent: t, own: n, namespaceURI: r } = e, i = /* @__PURE__ */ new Set(), a = [n, ...Je(t)];
+	for (let e of a) if (e) {
+		for (let [t, n] of [...e].reverse()) if (!i.has(t) && (i.add(t), t && n === r)) return t;
+	}
+}
+function Je(e) {
+	let t = [];
+	for (let n = e; n; n = n.parent) t.push(n.bindings);
+	return t;
+}
+function U(e) {
+	return Me.test(e) ? e.replace(Ne, W) : e;
+}
+function Ye(e) {
+	return Ie.test(e) ? e.replace(Le, W) : e;
+}
+function Xe(e) {
+	return Pe.test(e) ? e.replace(Fe, W) : e;
+}
+function W(e) {
+	return Re[e];
+}
+function Ze(e) {
+	let t = e.indexOf(":");
+	return t === -1 ? {
+		prefix: null,
+		localName: e
+	} : {
+		prefix: e.slice(0, t),
+		localName: e.slice(t + 1)
+	};
+}
+function G(e) {
+	return e.prefix ? `${e.prefix}:${e.localName}` : e.localName;
+}
+function K(e) {
+	let { element: t, namespaceURI: n, localName: r } = e;
+	return t.attributes.find((e) => e.namespaceURI === n && e.localName === r);
+}
+function Qe(e) {
+	let { attribute: t, prefix: n } = e;
+	return t.namespaceURI === "http://www.w3.org/2000/xmlns/" ? n === null ? t.prefix === null && t.localName === "xmlns" : t.prefix === "xmlns" && t.localName === n : !1;
+}
+function $e(e) {
+	if (e.namespaceURI === "http://www.w3.org/2000/xmlns/") return e.prefix === "xmlns" ? e.localName : "";
+	if (e.namespaceURI === null && e.localName === "xmlns") return "";
+}
+function et(e) {
+	let { prefix: t } = e;
+	for (let n = e.scope; n; n = n.parent) {
+		let e = n.bindings.get(t);
+		if (e !== void 0) return e;
+	}
+}
+function q(e) {
+	let { parent: t, own: n, prefix: r } = e;
+	return n?.get(r) ?? et({
+		scope: t,
+		prefix: r
+	});
+}
+// src/xml/build/record-element.ts
+function tt(e) {
+	let { context: t, record: n, parent: r } = e;
+	return r === void 0 ? nt({
+		context: t,
+		record: n
+	}) : rt({
+		context: t,
+		record: n,
+		parent: r
+	});
+}
+function nt(e) {
+	let { context: t, record: n } = e, { config: r, declareNamespaces: i, withDatabaseIds: a } = t, o = it({
+		context: t,
+		record: n,
+		parent: void 0
+	});
+	return t.rootElement = o, i && z({
+		element: o,
+		qualifiedName: "xmlns",
+		value: n.namespace.uri
+	}), at({
+		context: t,
+		element: o,
+		attributes: n.attributes,
+		isRoot: !0
+	}), t.documentRoot && st({
+		config: r,
+		element: o,
+		namespace: n.namespace,
+		rootRecord: t.documentRoot
+	}), a && z({
+		element: o,
+		qualifiedName: R,
+		value: n.id
+	}), i && ct({
+		context: t,
+		element: o,
+		record: n
+	}), o;
+}
+function rt(e) {
+	let { context: t, record: n, parent: r } = e, { config: i, declareNamespaces: a, withDatabaseIds: o } = t, s = n.namespace.uri === i.namespaces.default.uri, c = it({
+		context: t,
+		record: n,
+		parent: r
+	});
+	return a && !s && n.namespace.prefix && n.namespace.prefix !== "xmlns" && J({
+		context: t,
+		namespace: n.namespace
+	}), at({
+		context: t,
+		element: c,
+		attributes: n.attributes,
+		isRoot: !1
+	}), a && ot({
+		context: t,
+		element: c,
+		record: n
+	}), o && z({
+		element: c,
+		qualifiedName: R,
+		value: n.id
+	}), a && ct({
+		context: t,
+		element: c,
+		record: n
+	}), c;
+}
+function it(e) {
+	let { context: t, record: n, parent: r } = e, i = n.namespace.uri !== t.config.namespaces.default.uri && n.namespace.prefix && n.namespace.prefix !== "xmlns" ? `${n.namespace.prefix}:${n.tagName}` : n.tagName;
+	return Ve({
+		namespaceURI: t.declareNamespaces ? n.namespace.uri : null,
+		qualifiedName: i,
+		parent: r
+	});
+}
+function at(e) {
+	let { context: t, element: n, attributes: r, isRoot: i } = e;
+	for (let e of r) {
+		if (dt(e)) continue;
+		let r = String(e.value);
+		if (!ut(e) || !e.namespace.prefix) {
+			z({
+				element: n,
+				qualifiedName: e.name,
+				value: r
+			});
+			continue;
+		}
+		let a = `${e.namespace.prefix}:${d(e.name)}`;
+		t.declareNamespaces ? (i || J({
+			context: t,
+			namespace: e.namespace
+		}), B({
+			element: n,
+			namespaceURI: e.namespace.uri,
+			qualifiedName: a,
+			value: r
+		})) : z({
+			element: n,
+			qualifiedName: a,
+			value: r
+		});
+	}
+}
+function ot(e) {
+	let { context: t, element: n, record: r } = e, { config: i } = t, o = u({
+		dialecteConfig: i,
+		record: r
+	})?.attributes.details;
+	if (o) for (let [e, s] of Object.entries(o)) {
+		let o = a({
+			dialecteConfig: i,
+			record: r,
+			attributeName: e,
+			defaults: "required"
+		});
+		if (o === void 0) continue;
+		let c = d(e);
+		(s.namespace ? We({
+			element: n,
+			namespaceURI: s.namespace.uri,
+			localName: c
+		}) : He({
+			element: n,
+			qualifiedName: c
+		})) || (s.namespace && s.namespace.prefix && s.namespace.prefix !== "xmlns" ? (J({
+			context: t,
+			namespace: s.namespace
+		}), B({
+			element: n,
+			namespaceURI: s.namespace.uri,
+			qualifiedName: `${s.namespace.prefix}:${c}`,
+			value: o
+		})) : z({
+			element: n,
+			qualifiedName: c,
+			value: o
+		}));
+	}
+}
+function J(e) {
+	let { context: t, namespace: r } = e, i = t.rootElement;
+	i && r.prefix && r.prefix !== "xmlns" && Ue({
+		element: i,
+		namespaceURI: "http://www.w3.org/2000/xmlns/",
+		localName: r.prefix
+	}) === null && (B({
+		element: i,
+		namespaceURI: n,
+		qualifiedName: `xmlns:${r.prefix}`,
+		value: r.uri
+	}), t.documentRoot && st({
+		config: t.config,
+		element: i,
+		namespace: r,
+		rootRecord: t.documentRoot
+	}));
+}
+function st(e) {
+	let { config: t, element: n, namespace: r, rootRecord: i } = e, o = u({
+		dialecteConfig: t,
+		record: i
+	})?.attributes.details ?? {}, s = r.uri === t.namespaces.default.uri;
+	for (let [e, c] of Object.entries(o)) {
+		let o = a({
+			dialecteConfig: t,
+			record: i,
+			attributeName: e,
+			defaults: "required"
+		});
+		if (o === void 0 || !(s ? !c.namespace : c.namespace?.prefix === r.prefix && c.namespace?.uri === r.uri)) continue;
+		let l = d(e);
+		(c.namespace ? We({
+			element: n,
+			namespaceURI: c.namespace.uri,
+			localName: l
+		}) : He({
+			element: n,
+			qualifiedName: l
+		})) || (c.namespace ? B({
+			element: n,
+			namespaceURI: c.namespace.uri,
+			qualifiedName: `${c.namespace.prefix}:${l}`,
+			value: o
+		}) : z({
+			element: n,
+			qualifiedName: l,
+			value: o
+		}));
+	}
+}
+function ct(t) {
+	let { context: a, element: o, record: s } = t, { config: c } = a, l = Ue({
+		element: o,
+		namespaceURI: i.uri,
+		localName: "type"
+	});
+	if (l === null) return;
+	let u = e({
+		value: l,
+		namespaceOf: r({
+			dialecteConfig: c,
+			attributes: s.attributes
+		})
+	});
+	if (u === void 0 || u.namespace === "") return;
+	let d = l.indexOf(":"), f = d === -1 ? "" : l.slice(0, d), p = Object.values(c.namespaces).some((e) => e.prefix === f && e.uri === u.namespace);
+	if (f && p && J({
+		context: a,
+		namespace: {
+			prefix: f,
+			uri: u.namespace
+		}
+	}), V({
+		element: o,
+		prefix: f || null
+	}) === u.namespace) return;
+	let m = Ge({
+		element: o,
+		namespaceURI: u.namespace
+	}), h = m !== null && V({
+		element: o,
+		prefix: m
+	}) === u.namespace ? m : null, g = h ?? lt({ element: o });
+	h === null && B({
+		element: o,
+		namespaceURI: n,
+		qualifiedName: `xmlns:${g}`,
+		value: u.namespace
+	});
+	let _ = Ge({
+		element: o,
+		namespaceURI: i.uri
+	}) ?? "xsi";
+	B({
+		element: o,
+		namespaceURI: i.uri,
+		qualifiedName: `${_}:type`,
+		value: `${g}:${u.local}`
+	});
+}
+function lt(e) {
+	let { element: t } = e;
+	for (let e = 1;; e++) {
+		let n = `ns${e}`;
+		if (V({
+			element: t,
+			prefix: n
+		}) === null) return n;
+	}
+}
+function ut(e) {
+	return !!e.namespace;
+}
+function dt(e) {
+	return e.name === "xmlns" || e.name.startsWith("xmlns:") ? !0 : e.namespace?.prefix === "xmlns";
+}
+// src/utils/xml-characters.ts
+function ft(e) {
+	let t = l.exec(e.text);
+	if (t) return `U+${t[0].charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}`;
+}
+// src/helpers/assert-xml-characters.ts
+function pt(e) {
+	let { record: t, withId: n = !1 } = e, r = mt({ record: t }) ?? ht({
+		record: t,
+		withId: n
+	});
+	if (!r) return;
+	let { character: i, attribute: a, part: s } = r, c = t.tagName ? `<${t.tagName}> '${t.id}'` : `the record '${t.id}'`;
+	o("XML_CHARACTER_NOT_ALLOWED", {
+		detail: `${gt({
+			place: r,
+			element: c
+		})} holds ${i}, a character XML does not allow.`,
+		...t.tagName && { ref: {
+			tagName: t.tagName,
+			id: t.id
+		} },
+		meta: {
+			recordId: t.id,
+			...t.tagName && { tagName: t.tagName },
+			...a && { attribute: a },
+			part: s,
+			character: i
+		}
+	});
+}
+function mt(e) {
+	let { record: t } = e, n = t.value === void 0 ? void 0 : Y({
+		text: t.value,
+		part: "value"
+	});
+	if (n) return n;
+	let r = t.namespace && Y({
+		text: t.namespace.uri,
+		part: "namespace"
+	});
+	if (r) return r;
+	for (let e of t.attributes ?? []) {
+		let t = Y({
+			text: e.value,
+			part: "value",
+			attribute: e.name
+		}) ?? (e.namespace && Y({
+			text: e.namespace.uri,
+			part: "namespace",
+			attribute: e.name
+		}));
+		if (t) return t;
+	}
+}
+function ht(e) {
+	let { record: t, withId: n } = e, r = t.tagName === void 0 ? void 0 : Y({
+		text: t.tagName,
+		part: "name"
+	});
+	if (r) return r;
+	let i = t.namespace && Y({
+		text: t.namespace.prefix,
+		part: "prefix"
+	});
+	if (i) return i;
+	for (let e of t.attributes ?? []) {
+		let t = e.namespace && Y({
+			text: e.namespace.prefix,
+			part: "prefix",
+			attribute: e.name
+		}) || Y({
+			text: e.name,
+			part: "name",
+			attribute: e.name
+		});
+		if (t) return t;
+	}
+	return n ? Y({
+		text: t.id,
+		part: "id"
+	}) : void 0;
+}
+function gt(e) {
+	let { place: t, element: n } = e, { part: r, attribute: i } = t;
+	return i ? r === "value" ? `The attribute ${i} of ${n}` : r === "name" ? `The name of the attribute ${i} of ${n}` : `The ${r === "prefix" ? "namespace prefix" : "namespace URI"} of the attribute ${i} of ${n}` : r === "name" ? `The tag name of ${n}` : r === "prefix" ? `The namespace prefix of ${n}` : r === "namespace" ? `The namespace URI of ${n}` : r === "id" ? `The id of ${n}` : `The value of ${n}`;
+}
+function Y(e) {
+	let { text: t, part: n, attribute: r } = e, i = ft({ text: t });
+	if (i) return {
+		character: i,
+		part: n,
+		...r !== void 0 && { attribute: r }
+	};
+}
+// src/xml/build/xml-writer.ts
+var _t = class {
+	constructor(e) {
+		this.openElements = [], this.body = [], this.rootBindings = /* @__PURE__ */ new Map(), this.rootScope = {
+			bindings: this.rootBindings,
+			parent: void 0
+		}, this.rootAttributeCount = -1, this.prefixes = { next: 1 }, this.newLines = [];
+		let { config: t, documentRoot: n, declareNamespaces: r = !0, withDatabaseIds: i = !1 } = e;
+		this.context = {
+			config: t,
+			declareNamespaces: r,
+			withDatabaseIds: i,
+			documentRoot: n,
+			rootElement: void 0
+		}, this.indent = e.indent ?? !0, this.includeXmlDeclaration = e.includeXmlDeclaration ?? !0;
+	}
+	openElement(e) {
+		let { record: n } = e;
+		pt({
+			record: n,
+			withId: this.context.withDatabaseIds
+		});
+		let r = this.openElements.at(-1), i = tt({
+			context: this.context,
+			record: n,
+			parent: r?.element
+		}), a = n.value ? t({ text: n.value }) : "", o = n.children.length > 0, s = r ? r.level + 1 : 0, c = r ? r.inline || r.insideInline : !1, l = {
+			element: i,
+			qualifiedName: G(i),
+			level: s,
+			scope: this.rootScope,
+			empty: !a && !o,
+			inline: !this.indent || c || vt({
+				element: i,
+				text: a,
+				hasChildren: o
+			}),
+			insideInline: c
+		};
+		if (r) {
+			this.refreshRootScope();
+			let { text: e, scope: t } = H({
+				element: i,
+				scope: r.scope,
+				prefixes: this.prefixes
+			});
+			l.scope = t, c || this.newLine({ level: s }), this.body.push(e, l.empty ? "/>" : ">");
+		} else this.root = l;
+		this.openElements.push(l), a && this.writeText({
+			text: a,
+			owner: l
+		});
+	}
+	closeElement() {
+		let e = this.openElements.pop();
+		e && !e.empty && (e.inline || this.newLine({ level: e.level }), this.body.push(`</${e.qualifiedName}>`));
+	}
+	take() {
+		let e = this.body.join("");
+		return this.body = [], e;
+	}
+	head() {
+		let e = this.root;
+		if (!e) return "";
+		let { text: t } = H({
+			element: e.element,
+			scope: ze,
+			prefixes: { next: 1 }
+		});
+		return (this.includeXmlDeclaration ? Ae + (this.indent ? "\r\n" : "") : "") + t + (e.empty ? "/>" : ">");
+	}
+	refreshRootScope() {
+		let e = this.root;
+		if (!e) return;
+		let t = e.element.attributes.length;
+		if (t === this.rootAttributeCount) return;
+		this.rootAttributeCount = t;
+		let { scope: n, generated: r } = H({
+			element: e.element,
+			scope: ze,
+			prefixes: { next: 1 }
+		});
+		this.rootBindings.clear();
+		for (let [e, t] of n.bindings) r.has(e) || this.rootBindings.set(e, t);
+	}
+	writeText(e) {
+		let { text: t, owner: n } = e;
+		if (!this.indent) {
+			this.body.push(Ye(t));
+			return;
+		}
+		let r = Xe(t);
+		n.inline || this.newLine({ level: n.level + 1 }), this.body.push(bt(r));
+	}
+	newLine(e) {
+		if (!this.indent) return;
+		let { level: t } = e;
+		this.newLines[t] ??= "\r\n" + je.repeat(t), this.body.push(this.newLines[t]);
+	}
+};
+function vt(e) {
+	let { element: t, text: n, hasChildren: r } = e;
+	return yt(t) ? !0 : n ? !r || !n.includes("\n") : !1;
+}
+function yt(e) {
+	return e.attributes.some((e) => e.value === "preserve" && (e.namespaceURI === "http://www.w3.org/XML/1998/namespace" && e.localName === "space" || e.namespaceURI === null && e.localName === "xml:space"));
+}
+function bt(e) {
+	return e.includes("\n") ? e.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n") : e;
+}
+// src/project/io/run-export.ts
+async function xt(e, t = {}) {
+	let { source: n, runtime: r, documentId: i } = e, a = I({
+		enabled: r.perf ?? !1,
+		timeline: !1
+	});
+	$({
+		signal: t.signal,
+		documentId: i
+	});
+	let s = await Ct({
+		source: n,
+		documentId: i
+	}), { config: c } = L({
+		configs: r.configs,
+		defaultConfigKey: r.defaultConfigKey,
+		configKey: s.configKey
+	}), l = St({ options: e.options });
+	a.start("export");
+	let u;
+	try {
+		let n = await wt({
+			...e,
+			config: c,
+			control: t,
+			perf: a,
+			batchSize: l
+		});
+		u = n.status === "moved" ? await wt({
+			...e,
+			config: c,
+			control: t,
+			perf: a,
+			batchSize: l
+		}) : n;
+	} finally {
+		a.stop("export");
+	}
+	return u.status === "moved" && o("EXPORT_CONFLICT", {
+		detail: `Document "${s.name}" changed twice while it was exported: export it again`,
+		meta: { documentId: i }
+	}), {
+		file: u.file,
+		filename: `${s.name}${s.extension}`,
+		...r.perf && { perf: a.snapshot() }
+	};
+}
+function St(e) {
+	let t = e.options?.batchSize ?? 2e3;
+	return (!Number.isInteger(t) || t < 1) && o("ASSERTION_FAILED", { detail: `An export batch size is a whole number from 1, not ${t}` }), t;
+}
+async function Ct(e) {
+	let { source: t, documentId: n } = e, r = await t.getDocument(n);
+	return r && r.status === "ready" || Q({ documentId: n }), r;
+}
+async function wt(e) {
+	let { source: t, documentId: n, options: r, config: i, control: a, perf: s, batchSize: c } = e, l = await t.getExportVersion({ documentId: n });
+	l === void 0 && Q({ documentId: n });
+	let u = await t.count(n), d = await Et({
+		source: t,
+		documentId: n,
+		config: i
+	});
+	if (!d) {
+		if (await Z({
+			source: t,
+			documentId: n,
+			version: l
+		})) return { status: "moved" };
+		o("EXPORT_ROOT_NOT_FOUND", { detail: `No ${i.rootElementName} root element found in document "${n}"` });
+	}
+	let f = {
+		source: t,
+		documentId: n,
+		version: l,
+		totalRecords: u,
+		control: a,
+		perf: s,
+		writer: new _t({
+			config: i,
+			documentRoot: d,
+			indent: r?.indent,
+			withDatabaseIds: r?.withDatabaseIds
+		}),
+		parts: [],
+		recordsWritten: 0
+	}, p = [Tt({
+		pass: f,
+		record: d,
+		config: i
+	})];
+	if (f.recordsWritten % c === 0 && await X(f)) return { status: "moved" };
+	for (; p.length > 0;) {
+		let e = p.at(-1);
+		if (e.next >= e.childRefs.length) {
+			s.time("export::write", () => f.writer.closeElement()), p.pop();
+			continue;
+		}
+		if (e.next >= e.chunkStart + e.chunk.length) {
+			let r = e.childRefs.slice(e.next, e.next + c).map(Ot);
+			s.start("export::read");
+			try {
+				e.chunk = await t.getMany(r, n);
+			} finally {
+				s.stop("export::read");
+			}
+			e.chunkStart = e.next;
+		}
+		let r = e.childRefs[e.next], a = e.chunk[e.next - e.chunkStart];
+		if (e.next++, !a) {
+			if (await Z(f)) return { status: "moved" };
+			o("EXPORT_ORPHAN_CHILD_REF", {
+				detail: `Parent '${e.record.tagName}' references non-existent child '${r.tagName}' (id: ${r.id})`,
+				ref: {
+					tagName: e.record.tagName,
+					id: e.record.id
+				}
+			});
+		}
+		if (p.push(Tt({
+			pass: f,
+			record: a,
+			config: i
+		})), f.recordsWritten % c === 0 && await X(f)) return { status: "moved" };
+	}
+	if (Dt(f), f.recordsWritten % c !== 0 && await X(f)) return { status: "moved" };
+	s.start("export::assemble");
+	try {
+		return {
+			status: "written",
+			file: new Blob([f.writer.head(), ...f.parts], { type: "application/xml" })
+		};
+	} finally {
+		s.stop("export::assemble");
+	}
+}
+function Tt(e) {
+	let { pass: t, record: n, config: r } = e;
+	return t.perf.time("export::write", () => t.writer.openElement({ record: n })), t.recordsWritten++, {
+		record: n,
+		childRefs: s({
+			parentTagName: n.tagName,
+			children: n.children,
+			childrenConfig: r.children,
+			definition: r.definition
+		}),
+		next: 0,
+		chunk: [],
+		chunkStart: 0
+	};
+}
+async function Et(e) {
+	let { source: t, documentId: n, config: r } = e;
+	return (await t.getByTagNameInDocument(r.rootElementName, n)).find((e) => ke({
+		record: e,
+		config: r
+	}));
+}
+async function X(e) {
+	let { control: t, documentId: n, recordsWritten: r, totalRecords: i } = e;
+	return Dt(e), j({
+		listener: t.onProgress,
+		value: {
+			recordsWritten: r,
+			totalRecords: i
+		},
+		of: N.exportProgress,
+		call: t
+	}), $({
+		signal: t.signal,
+		documentId: n
+	}), await Oe(), Z(e);
+}
+function Dt(e) {
+	let t = e.writer.take();
+	t && e.parts.push(new Blob([t]));
+}
+async function Z(e) {
+	let { source: t, documentId: n, version: r } = e, i = await t.getExportVersion({ documentId: n });
+	return i === void 0 && Q({ documentId: n }), i !== r;
+}
+function Ot(e) {
+	return e.id;
+}
+function Q(e) {
+	let { documentId: t } = e;
+	o("DOCUMENT_NOT_REGISTERED", {
+		detail: `Document "${t}" is not registered, or not ready, in this store`,
+		meta: { documentId: t }
+	});
+}
+function $(e) {
+	let { signal: t, documentId: n } = e;
+	t?.aborted && o("EXPORT_ABORTED", {
+		detail: `The export of document "${n}" was aborted`,
+		meta: { documentId: n }
+	});
+}
+// src/store/engine/engine.constants.ts
+var kt = "dialecte:engine:", At = {
+	heartbeat: "heartbeat",
+	busy: "busy",
+	progress: "progress",
+	event: "event"
+};
+// src/store/engine/project-key.ts
+function jt(e) {
+	let { dialecteId: t, project: n } = e;
+	return `${encodeURIComponent(t)}/${encodeURIComponent(n)}`;
+}
+function Mt(e) {
+	return `${kt}${jt(e)}`;
+}
+export { _e as A, ae as B, O as C, fe as D, me as E, oe as F, g as G, v as H, se as I, ee as J, _ as K, ie as L, ve as M, y as N, pe as O, ce as P, re as R, be as S, de as T, h as U, te as V, m as W, N as _, $ as a, Ee as b, gt as c, R as d, ke as f, P as g, I as h, xt as i, he as j, ge as k, mt as l, L as m, jt as n, _t as o, Oe as p, ne as q, At as r, pt as s, Mt as t, ft as u, Te as v, xe as w, ye as x, j as y, p as z };