doxum 0.1.23 → 0.1.26

package/dist/advanced-Cle5g3B4.cjs

@@ -1,1517 +0,0 @@
-const require_context = require("./context-BcLKGfq8.cjs");
-const profile = {
-	projection: (key, amount = 1) => {},
-	recorder: (key, amount = 1) => {},
-	access: (key) => {},
-	copy: {
-		structure: () => {},
-		treeNode: () => {},
-		shallowRecord: (items) => {}
-	},
-	equality: {
-		call: () => {},
-		container: () => {}
-	},
-	address: {
-		listIndex: (items) => {},
-		schemaStep: () => {},
-		documentStep: () => {},
-		prefixComparison: () => {},
-		segmentCompared: () => {}
-	},
-	impact: {
-		index: () => {},
-		affects: () => {}
-	},
-	collectionIndex: {
-		node: () => {},
-		build: (items) => {}
-	},
-	collectionView: {
-		mapped: () => {},
-		idsScanned: (amount = 1) => {},
-		arrayCopied: () => {}
-	},
-	materialized: {
-		updated: () => {},
-		rebuilt: () => {},
-		notification: () => {}
-	}
-};
-//#endregion
-//#region core/src/order/sequence.ts
-const length = (keys) => keys.length;
-const keyAt = (keys, index) => Array.isArray(keys) ? keys[index] : keys.at(index);
-const equal = (left, right) => {
-	profile.equality.call();
-	if (left === right) return true;
-	profile.equality.container();
-	if (left.length !== right.length) return false;
-	for (let index = 0; index < left.length; index++) if (left[index] !== keyAt(right, index)) return false;
-	return true;
-};
-const keys = (values, keyOf) => ({
-	length: values.length,
-	at: (index) => index >= 0 && index < values.length ? keyOf(values[index]) : void 0,
-	index: (key) => {
-		for (let index = 0; index < values.length; index += 1) if (keyOf(values[index]) === key) return index;
-		return -1;
-	}
-});
-const listIndexes = /* @__PURE__ */ new WeakMap();
-const knownKeys = (values) => {
-	let positions;
-	return {
-		length: values.length,
-		at: (index) => values[index],
-		index: (key) => {
-			if (!positions) {
-				positions = /* @__PURE__ */ new Map();
-				for (let index = 0; index < values.length; index++) positions.set(values[index], index);
-				profile.address.listIndex(values.length);
-			}
-			return positions.get(key) ?? -1;
-		}
-	};
-};
-const cacheKnownKeys = (values, keyOf, order) => {
-	listIndexes.set(values, {
-		keyOf,
-		order: knownKeys(order)
-	});
-};
-/** Canonical lists keep their key positions until a structural write invalidates them. */
-const indexedKeys = (values, keyOf) => {
-	const cached = listIndexes.get(values);
-	if (cached?.keyOf === keyOf) return cached.order;
-	let positions;
-	const order = {
-		length: values.length,
-		at: (index) => index >= 0 && index < values.length ? keyOf(values[index]) : void 0,
-		index: (key) => {
-			if (!positions) {
-				positions = /* @__PURE__ */ new Map();
-				for (let index = 0; index < values.length; index++) positions.set(keyOf(values[index]), index);
-				profile.address.listIndex(values.length);
-			}
-			return positions.get(key) ?? -1;
-		}
-	};
-	listIndexes.set(values, {
-		keyOf,
-		order
-	});
-	return order;
-};
-const toArray = (keys) => {
-	const result = new Array(length(keys));
-	for (let index = 0; index < result.length; index++) result[index] = keyAt(keys, index);
-	return result;
-};
-/** One operation-local list scan provides both stable keys and item association. */
-const listSequence = (values, keyOf) => {
-	const current = indexedKeys(values, keyOf);
-	const order = new Array(values.length);
-	const byKey = /* @__PURE__ */ new Map();
-	for (let index = 0; index < values.length; index++) {
-		const key = current.at(index);
-		order[index] = key;
-		byKey.set(key, values[index]);
-	}
-	cacheKnownKeys(values, keyOf, order);
-	return {
-		order,
-		values: byKey
-	};
-};
-/** Structural sequence writes own invalidation, including rollback writes. */
-const insert = (values, index, value) => {
-	values.splice(index, 0, value);
-	listIndexes.delete(values);
-};
-const remove = (values, index) => {
-	values.splice(index, 1);
-	listIndexes.delete(values);
-};
-/** Installs an exact string-key sequence such as table ids in one structural write. */
-const installKeys = (values, order) => {
-	values.length = order.length;
-	for (let index = 0; index < order.length; index++) values[index] = order[index];
-};
-/** Installs a pre-resolved list sequence without running keyOf again. */
-const installList = (values, keyOf, sequence, order) => {
-	values.length = order.length;
-	for (let index = 0; index < order.length; index++) values[index] = sequence.values.get(order[index]);
-	cacheKnownKeys(values, keyOf, order);
-};
-const install = (values, keyOf, order) => {
-	installList(values, keyOf, listSequence(values, keyOf), order);
-};
-const matches = (order, members) => {
-	if (order.length !== members.length) return false;
-	const ids = new Set(order);
-	return ids.size === order.length && members.every((id) => ids.has(id));
-};
-//#endregion
-//#region core/src/schema/layout.ts
-const compiledObjects = /* @__PURE__ */ new WeakMap();
-const compiledEntries = /* @__PURE__ */ new WeakMap();
-const objectBranch = (node, value) => {
-	if (node.kind === "object") return node;
-	if (node.kind !== "variant" || typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-	const record = value;
-	const tag = typeof record[node.tag] === "string" ? record[node.tag] : void 0;
-	return node.variants[String(tag ?? Object.keys(node.variants)[0] ?? "")];
-};
-const compiledShape = (node, value) => {
-	const branch = objectBranch(node, value);
-	if (!branch) return void 0;
-	const shape = branch.shape;
-	let layout = compiledObjects.get(shape);
-	if (!layout) {
-		const members = /* @__PURE__ */ new Map();
-		for (const key of Object.keys(shape).sort()) {
-			profile.address.schemaStep();
-			members.set(key, {
-				kind: "fixed",
-				key,
-				node: shape[key],
-				field: shape[key].kind === "field",
-				slot: members.size
-			});
-		}
-		layout = {
-			kind: "fixed",
-			members
-		};
-		compiledObjects.set(shape, layout);
-	}
-	return layout;
-};
-const compiledLayout = (node, value) => {
-	if (node.kind !== "map" && node.kind !== "table" && node.kind !== "list") return compiledShape(node, value);
-	let layout = compiledEntries.get(node);
-	if (!layout) {
-		layout = {
-			kind: "dynamic",
-			entry: {
-				kind: "entry",
-				node: node.value,
-				field: node.value.kind === "field"
-			}
-		};
-		compiledEntries.set(node, layout);
-	}
-	return layout;
-};
-//#endregion
-//#region core/src/schema/value.ts
-var ParseError = class extends TypeError {
-	issues;
-	constructor(issue) {
-		super(`${issue.message} at ${JSON.stringify(issue.address)}`);
-		this.name = "ParseError";
-		this.issues = Object.freeze([Object.freeze({
-			...issue,
-			address: Object.freeze([...issue.address])
-		})]);
-	}
-};
-const issue = (address, message, code = "invalid-value") => ({
-	address,
-	message,
-	code
-});
-const checkScalar = (validator, value, address, strict) => {
-	if (!validator) return strict ? issue(address, "A validator is required to parse an opaque value.", "missing-validator") : void 0;
-	try {
-		const result = typeof validator === "function" ? validator(value) : validator["~standard"].validate(value);
-		if (result && (typeof result === "object" || typeof result === "function") && "then" in result && typeof result.then === "function") return issue(address, "Validators must be synchronous.");
-		if (typeof validator !== "function") {
-			if (!require_context.isRecord(result)) return issue(address, "Malformed validator result.");
-			if (Array.isArray(result.issues)) {
-				const first = result.issues[0];
-				return issue([...address, ...(first?.path ?? []).map((part) => String(typeof part === "object" ? part.key : part))], first?.message ?? "Value validation failed.");
-			}
-			if (!Object.hasOwn(result, "value")) return issue(address, "Malformed validator result.");
-		}
-		return;
-	} catch (error) {
-		return issue(address, error instanceof Error ? error.message : "Value validation failed.");
-	}
-};
-const checkKey = (validator, value, address) => {
-	if (typeof value !== "string") return issue(address, "Collection keys must be strings.", "invalid-key");
-	const failure = checkScalar(validator, value, address, false);
-	return failure ? {
-		...failure,
-		code: "invalid-key"
-	} : void 0;
-};
-const checkValue = (node, value, address = [], strict = false) => {
-	if (node.optional && value === void 0) return void 0;
-	if (node.kind === "field") return checkScalar(node.validator, value, address, strict);
-	if (node.kind === "object" || node.kind === "variant") {
-		if (!require_context.isPlainObject(value)) return issue(address, "Expected an object.");
-		if (node.kind === "variant") {
-			const tag = value[node.tag];
-			if (!Object.hasOwn(value, node.tag) || typeof tag !== "string" || !Object.hasOwn(node.variants, tag)) return issue([...address, node.tag], "Unknown variant tag.");
-		}
-		const { members } = compiledShape(node, value);
-		for (const key of Reflect.ownKeys(value)) {
-			if (node.kind === "variant" && key === node.tag) continue;
-			if (typeof key !== "string" || !members.has(key)) return issue([...address, String(key)], "Property is not declared in the object schema.");
-		}
-		for (const [key, member] of members) {
-			const child = member.node;
-			if (!Object.prototype.hasOwnProperty.call(value, key) && !child.optional) return issue([...address, key], "Required property is missing.");
-			const failure = checkValue(child, value[key], [...address, key], strict);
-			if (failure) return failure;
-		}
-		return;
-	}
-	if (node.kind === "table" || node.kind === "map") {
-		if (!require_context.isPlainObject(value)) return issue(address, "Expected a collection object.");
-		const entries = node.kind === "table" ? value.byId : value;
-		if (!require_context.isPlainObject(entries)) return issue(address, "Expected a byId object.");
-		if (node.kind === "table") {
-			if (!Array.isArray(value.ids) || value.ids.length !== Object.keys(entries).length) return issue(address, "Table ids and entries must agree.");
-			const seen = /* @__PURE__ */ new Set();
-			for (const id of value.ids) {
-				const failure = checkKey(node.key, id, address);
-				if (failure) return failure;
-				if (seen.has(id) || !Object.prototype.hasOwnProperty.call(entries, id)) return issue(address, "Table ids must be unique and reference existing entries.");
-				seen.add(id);
-			}
-		}
-		for (const id of Object.keys(entries)) {
-			const failure = checkKey(node.key, id, [...address, id]) ?? checkValue(node.value, entries[id], [...address, id], strict);
-			if (failure) return failure;
-		}
-		return;
-	}
-	if (node.kind === "list") {
-		if (!Array.isArray(value)) return issue(address, "Expected a list.");
-		const seen = /* @__PURE__ */ new Set();
-		const order = keys(value, node.keyOf);
-		for (let i = 0; i < value.length; i++) {
-			const failure = checkValue(node.value, value[i], [...address, String(i)], strict);
-			if (failure) return failure;
-			let key;
-			try {
-				key = order.at(i);
-			} catch {
-				return issue(address, "List keyOf failed.");
-			}
-			if (typeof key !== "string" || seen.has(key)) return issue(address, "List keys must be unique strings.", "invalid-key");
-			seen.add(key);
-		}
-		return;
-	}
-	if (!require_context.validate(value)) return issue(address, "Invalid tree structure.", "invalid-tree");
-	for (const id of Object.keys(value.nodes)) {
-		const failure = checkTreePayload(node.value, value.nodes[id], [...address, id], strict);
-		if (failure) return failure;
-	}
-};
-const checkTreePayload = (node, value, address, strict = false) => {
-	if (!require_context.isRecord(value)) return issue(address, "Invalid tree node.", "invalid-tree");
-	const present = Object.prototype.hasOwnProperty.call(value, "value");
-	if (!present && !node.optional) return issue(address, "Tree node value is required.");
-	return present ? checkValue(node, value.value, address, strict) : void 0;
-};
-const copyTreeNode = (value) => {
-	profile.copy.treeNode();
-	return {
-		...value,
-		children: [...value.children]
-	};
-};
-const equalTreeNode = (left, right) => {
-	if (left === right) return true;
-	if (!left || !right) return false;
-	return left.parentId === right.parentId && equal(left.children, right.children) && Object.hasOwn(left, "value") === Object.hasOwn(right, "value") && Object.is(left.value, right.value);
-};
-/** Copy editable structure; atomic payloads retain their immutable ownership contract. */
-const copyValue = (node, value) => {
-	if (value === void 0 || node.kind === "field") return value;
-	profile.copy.structure();
-	if ((node.kind === "object" || node.kind === "variant") && require_context.isRecord(value)) {
-		const result = Object.create(Object.getPrototypeOf(value));
-		const { members } = compiledShape(node, value);
-		for (const key of Object.getOwnPropertyNames(value)) Object.defineProperty(result, key, {
-			value: node.kind === "variant" && key === node.tag ? value[key] : copyValue(members.get(key).node, value[key]),
-			writable: true,
-			enumerable: Object.getOwnPropertyDescriptor(value, key)?.enumerable,
-			configurable: true
-		});
-		return result;
-	}
-	if ((node.kind === "table" || node.kind === "map") && require_context.isRecord(value)) {
-		const entries = node.kind === "table" ? value.byId : value;
-		const result = Object.fromEntries(Object.keys(entries).map((id) => [id, copyValue(node.value, entries[id])]));
-		return node.kind === "table" ? {
-			ids: [...value.ids],
-			byId: result
-		} : result;
-	}
-	if (node.kind === "list") return [...value];
-	if (node.kind === "tree" && require_context.isRecord(value)) {
-		const entries = value.nodes;
-		return {
-			...value,
-			nodes: Object.fromEntries(Object.entries(entries).map(([id, n]) => [id, copyTreeNode(n)]))
-		};
-	}
-	return value;
-};
-const equalValue = (node, left, right) => {
-	if (Object.is(left, right)) return true;
-	if (node.kind === "field" || left === void 0 || right === void 0) return false;
-	if ((node.kind === "object" || node.kind === "variant") && require_context.isRecord(left) && require_context.isRecord(right)) {
-		if (node.kind === "variant" && left[node.tag] !== right[node.tag]) return false;
-		for (const [key, member] of compiledShape(node, left).members) {
-			if (Object.hasOwn(left, key) !== Object.hasOwn(right, key)) return false;
-			if (!equalValue(member.node, left[key], right[key])) return false;
-		}
-		return true;
-	}
-	if (node.kind === "list" && Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((v, i) => equalValue(node.value, v, right[i]));
-	if (node.kind === "table" && require_context.isRecord(left) && require_context.isRecord(right)) return equal(left.ids, right.ids) && equalValue({
-		kind: "map",
-		value: node.value
-	}, left.byId, right.byId);
-	if (node.kind === "tree" && require_context.isRecord(left) && require_context.isRecord(right)) {
-		if (left.rootId !== right.rootId) return false;
-		const a = left.nodes, b = right.nodes;
-		return Object.keys(a).length === Object.keys(b).length && Object.keys(a).every((id) => Object.hasOwn(b, id) && equalTreeNode(a[id], b[id]));
-	}
-	if (node.kind === "map" && require_context.isRecord(left) && require_context.isRecord(right)) {
-		const keys = Object.keys(left);
-		return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && equalValue(node.value, left[key], right[key]));
-	}
-	return false;
-};
-const parse = (node, input) => {
-	const valueNode = node;
-	const failure = checkValue(valueNode, input, [], true);
-	if (failure) throw new ParseError(failure);
-	return copyValue(valueNode, input);
-};
-//#endregion
-//#region core/src/schema.ts
-const collectionEntryNode = (node) => node.kind === "map" || node.kind === "table" || node.kind === "list" ? node.value : void 0;
-const node = (value) => Object.freeze(value);
-const field = (validator) => node({
-	kind: "field",
-	...validator ? { validator } : {}
-});
-const optional = (value) => {
-	if (![
-		"field",
-		"variant",
-		"map",
-		"list",
-		"tree"
-	].includes(value.kind)) throw new TypeError("Only field, variant, map, list and tree nodes support optional presence.");
-	return node({
-		...value,
-		optional: true
-	});
-};
-const object = (shape) => node({
-	kind: "object",
-	shape: Object.freeze({ ...shape })
-});
-const variant = (tag, variants) => node({
-	kind: "variant",
-	tag,
-	variants: Object.freeze({ ...variants })
-});
-const table = (value, options) => node({
-	kind: "table",
-	value,
-	...options
-});
-const map = (value, options) => node({
-	kind: "map",
-	value,
-	...options
-});
-const list = (value, config) => node({
-	kind: "list",
-	keyOf: config.keyOf,
-	value
-});
-const tree = (value) => Object.freeze({
-	kind: "tree",
-	value
-});
-const paths = /* @__PURE__ */ new WeakMap();
-const pathProxy = (nodes, address, owner, treeSelection) => {
-	const proxy = new Proxy({}, { get: (_target, property) => {
-		if (typeof property !== "string") return void 0;
-		const trees = nodes.every((node) => node.kind === "tree");
-		if (!treeSelection && trees && property === "rootId") return pathProxy(nodes, address, owner, { kind: "root" });
-		if (!treeSelection && trees && property === "nodes") return pathProxy(nodes, address, owner, { kind: "nodes" });
-		if (treeSelection?.kind === "nodes" && property === "item") return (id) => {
-			if (typeof id !== "string") throw new TypeError("Tree node keys must be strings.");
-			return pathProxy(nodes, address, owner, {
-				kind: "node",
-				id
-			});
-		};
-		if (treeSelection) throw new TypeError(`Invalid tree path segment: ${property}`);
-		if (nodes.every((node) => collectionEntryNode(node) !== void 0) && property === "item") return (id) => {
-			if (typeof id !== "string") throw new TypeError("Collection keys must be strings.");
-			for (const node of nodes) if (node.kind === "table" || node.kind === "map") {
-				const invalid = checkKey(node.key, id, [...address, id]);
-				if (invalid) throw new TypeError(invalid.message);
-			}
-			return pathProxy(nodes.map((node) => collectionEntryNode(node)), [...address, id], owner);
-		};
-		const children = nodes.flatMap((node) => {
-			if (node.kind === "object") return Object.hasOwn(node.shape, property) ? [node.shape[property]] : [];
-			if (node.kind !== "variant") return [];
-			if (property === node.tag) return [field()];
-			return Object.values(node.variants).flatMap((branch) => Object.hasOwn(branch.shape, property) ? [branch.shape[property]] : []);
-		});
-		if (!children.length) throw new TypeError(`Invalid schema path segment: ${property}`);
-		return pathProxy(children, [...address, property], owner);
-	} });
-	paths.set(proxy, {
-		nodes,
-		address,
-		owner,
-		...treeSelection ? { tree: treeSelection } : {}
-	});
-	return proxy;
-};
-const compilePath = (owner, kind, pick) => {
-	const scope = {};
-	const value = pick(pathProxy([owner], [], scope));
-	const selected = typeof value === "object" && value !== null ? paths.get(value) : void 0;
-	if (!selected || selected.owner !== scope) throw new TypeError("Selector must return a path from its callback.");
-	const collection = selected.tree?.kind === "nodes" || selected.nodes.every((node) => collectionEntryNode(node) !== void 0);
-	if (kind === "collection" && !collection) throw new TypeError("Collection selectors require a map, table, list or tree nodes path.");
-	return Object.freeze({
-		kind: kind === "auto" ? collection ? "collection" : "value" : kind,
-		schema: owner,
-		address: Object.freeze([...selected.address]),
-		...selected.tree ? { tree: Object.freeze({ ...selected.tree }) } : {}
-	});
-};
-//#endregion
-//#region core/src/projection/collection/view.ts
-const mapRead = (value) => ({
-	get: (key) => value.get(key),
-	has: (key) => value.has(key),
-	ids: () => Object.freeze([...value.keys()])
-});
-/** Immutable map-like view over a CollectionRead. */
-const collectionView = (read) => {
-	const ids = read.ids();
-	const entries = function* () {
-		for (const key of ids) yield [key, read.get(key)];
-	};
-	const values = function* () {
-		for (const key of ids) yield read.get(key);
-	};
-	const view = {
-		get: (key) => read.get(key),
-		has: (key) => read.has(key),
-		get size() {
-			return ids.length;
-		},
-		keys: () => ids[Symbol.iterator](),
-		values,
-		entries,
-		forEach: (callback, thisArg) => {
-			for (const key of ids) callback.call(thisArg, read.get(key), key, view);
-		},
-		[Symbol.iterator]: entries
-	};
-	return Object.freeze(view);
-};
-/** Eager durable view used when a processor result may retain its dependency value. */
-const snapshotCollectionView = (read) => {
-	const ids = read.ids();
-	const values = /* @__PURE__ */ new Map();
-	for (const key of ids) values.set(key, read.get(key));
-	return collectionView(mapRead(values));
-};
-//#endregion
-//#region core/src/projection/contract.ts
-var ProjectionError = class extends Error {
-	constructor(phase, identity, revisions, cause) {
-		super(`Projection ${phase} failed: ${identity}`, { cause });
-		this.phase = phase;
-		this.identity = identity;
-		this.revisions = revisions;
-		this.name = "ProjectionError";
-	}
-};
-var ProjectionDisposedError = class extends Error {
-	constructor() {
-		super("Projection has been disposed.");
-		this.name = "ProjectionDisposedError";
-	}
-};
-//#endregion
-//#region core/src/projection/graph/scheduler.ts
-const createScheduler = (onError) => {
-	let disposed = false;
-	let depth = 0;
-	let batchSequence = 0;
-	let activeBatch;
-	let phase = "idle";
-	let sequence = 0;
-	const sources = /* @__PURE__ */ new Set();
-	const processors = /* @__PURE__ */ new Set();
-	const pendingSources = /* @__PURE__ */ new Set();
-	const heap = [];
-	const queued = /* @__PURE__ */ new Set();
-	const completed = /* @__PURE__ */ new Set();
-	const emissions = /* @__PURE__ */ new Set();
-	const errors = [];
-	let reportingFailures = [];
-	const guards = /* @__PURE__ */ new Set();
-	const cleanups = /* @__PURE__ */ new Set();
-	const assertActive = () => {
-		if (disposed) throw new ProjectionDisposedError();
-	};
-	const assertIdle = () => {
-		assertActive();
-		if (phase !== "idle") throw new Error("Projection cannot be re-entered during processing or notification.");
-	};
-	const lock = (value) => guards.forEach((guard) => guard(value));
-	const enqueue = (processor) => {
-		if (processor.disposed || queued.has(processor)) return;
-		queued.add(processor);
-		profile.projection("scheduledNodes");
-		let index = heap.length;
-		heap.push(processor);
-		while (index > 0) {
-			const parent = index - 1 >> 1;
-			if (heap[parent].order < processor.order) break;
-			heap[index] = heap[parent];
-			index = parent;
-		}
-		heap[index] = processor;
-	};
-	const pop = () => {
-		const first = heap[0];
-		const last = heap.pop();
-		if (heap.length) {
-			let index = 0;
-			while (index * 2 + 1 < heap.length) {
-				let child = index * 2 + 1;
-				if (child + 1 < heap.length && heap[child + 1].order < heap[child].order) child++;
-				if (last.order < heap[child].order) break;
-				heap[index] = heap[child];
-				index = child;
-			}
-			heap[index] = last;
-		}
-		return first;
-	};
-	const revisionsOf = (producer) => producer.kind === "processor" ? producer.dependencies.map((output) => output.revision()) : producer.outputs.map((output) => output.revision());
-	const errorFor = (producer, cause, kind = producer.kind === "source" ? "source" : "processor") => new ProjectionError(kind, producer.name, revisionsOf(producer), cause);
-	const capture = (source) => {
-		if (disposed) return;
-		if (phase !== "idle") {
-			source.fault = errorFor(source, /* @__PURE__ */ new Error("Source changed while projection was running."), "source");
-			errors.push(source.fault);
-			throw source.fault;
-		}
-		pendingSources.add(source);
-		profile.projection("sourceEvents");
-		if (source.fault) errors.push(source.fault);
-	};
-	const settleCause = () => {
-		if (activeBatch?.cause !== void 0) return activeBatch.cause;
-		for (const source of pendingSources) {
-			const cause = source.pendingCause();
-			if (cause !== void 0) return cause;
-		}
-	};
-	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
-		phase = "compute";
-		lock(true);
-		const cause = settleCause();
-		try {
-			for (const source of pendingSources) {
-				if (source.disposed) continue;
-				const wasFaulted = source.fault !== void 0;
-				let changed = false;
-				let force = false;
-				if (!source.fault || source.recovering()) try {
-					const prepared = source.prepare(cause);
-					changed = prepared.changed;
-					force = prepared.force;
-					source.fault = void 0;
-				} catch (failure) {
-					source.fault = errorFor(source, failure, "source");
-					errors.push(source.fault);
-				}
-				const recovered = wasFaulted && !source.fault;
-				if (changed) source.publish();
-				if (source.fault || changed || force || recovered) {
-					const output = source.outputs[0];
-					emissions.add(output);
-					output.consumers.forEach(enqueue);
-				}
-			}
-			while (heap.length) {
-				const processor = pop();
-				if (processor.disposed) continue;
-				const wasFaulted = processor.fault !== void 0;
-				profile.projection("processedNodes");
-				let changedOutputs = Object.freeze([]);
-				const blocked = processor.dependencies.find((output) => output.owner.fault || output.owner.disposed);
-				if (blocked) processor.fault = errorFor(processor, blocked.owner.fault ?? new ProjectionDisposedError(), "blocked");
-				else {
-					const reset = wasFaulted || processor.dependencies.some((output) => output.reset());
-					try {
-						changedOutputs = processor.evaluate(reset, cause);
-						const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
-						if (dependencyFailure) throw dependencyFailure;
-						processor.fault = void 0;
-					} catch (failure) {
-						const error = errorFor(processor, failure);
-						processor.fault = error;
-						if (!reset) try {
-							changedOutputs = processor.evaluate(true, cause);
-							const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
-							if (dependencyFailure) throw dependencyFailure;
-							processor.fault = void 0;
-							errors.push(error);
-						} catch (rebuildFailure) {
-							processor.fault = errorFor(processor, rebuildFailure);
-							errors.push(processor.fault);
-						}
-						else errors.push(error);
-					}
-				}
-				completed.add(processor);
-				const recovered = wasFaulted && !processor.fault;
-				if (processor.fault) processor.outputs.forEach((output) => {
-					emissions.add(output);
-					output.consumers.forEach(enqueue);
-				});
-				else {
-					if (changedOutputs.length) {
-						processor.publish();
-						changedOutputs.forEach((output) => emissions.add(output));
-					}
-					(recovered ? processor.outputs : changedOutputs).forEach((output) => output.consumers.forEach(enqueue));
-				}
-				if (processor.fault || changedOutputs.length) profile.projection("publishedNodes");
-			}
-		} finally {
-			lock(false);
-			phase = "idle";
-		}
-	};
-	const flush = () => {
-		if (disposed || depth) return [];
-		if (pendingSources.size || completed.size) profile.projection("flushes");
-		phase = "notify";
-		lock(true);
-		const reportFailures = [];
-		try {
-			emissions.forEach((output) => output.emit((listener) => {
-				try {
-					listener();
-				} catch (cause) {
-					errors.push(errorFor(output.owner, cause, "listener"));
-				}
-			}));
-			for (const error of errors.slice()) try {
-				onError(error);
-			} catch (cause) {
-				reportFailures.push(cause);
-			}
-			return Object.freeze([...errors.map((error) => Object.freeze({
-				phase: error.phase === "listener" ? "listener" : "processor",
-				error
-			})), ...reportFailures.map((error) => Object.freeze({
-				phase: "listener",
-				error
-			}))]);
-		} finally {
-			pendingSources.forEach((source) => source.clear());
-			completed.forEach((processor) => processor.clear());
-			pendingSources.clear();
-			queued.clear();
-			completed.clear();
-			emissions.clear();
-			errors.length = 0;
-			reportingFailures = reportFailures;
-			lock(false);
-			phase = "idle";
-		}
-	};
-	const run = () => {
-		settle();
-		const result = flush();
-		const failures = reportingFailures;
-		reportingFailures = [];
-		if (failures.length) throw new AggregateError(failures, "Projection error reporter failed.");
-		return result;
-	};
-	const batch = (optionsOrCallback, maybeCallback) => {
-		assertIdle();
-		const options = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-		const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : maybeCallback;
-		if (!callback) throw new TypeError("Projection batch requires a callback.");
-		if (depth === 0) activeBatch = Object.freeze({
-			id: ++batchSequence,
-			...options?.cause === void 0 ? {} : { cause: options.cause }
-		});
-		depth++;
-		let failed = false;
-		try {
-			const value = callback();
-			assertSynchronous(value);
-			return value;
-		} catch (error) {
-			failed = true;
-			throw error;
-		} finally {
-			depth--;
-			if (!depth) try {
-				if (failed) try {
-					run();
-				} catch {}
-				else run();
-			} finally {
-				activeBatch = void 0;
-			}
-		}
-	};
-	const releaseProducer = (producer) => {
-		assertIdle();
-		if (producer.outputs.some((output) => output.consumers.size)) throw new Error("Projection producer is still used by another processor.");
-		producer.disposed = true;
-		if (producer.kind === "processor") {
-			producer.dependencies.forEach((output) => output.consumers.delete(producer));
-			processors.delete(producer);
-			queued.delete(producer);
-			completed.delete(producer);
-		} else {
-			sources.delete(producer);
-			pendingSources.delete(producer);
-		}
-		producer.release();
-		producer.clear();
-		producer.outputs.forEach((output) => emissions.delete(output));
-	};
-	return {
-		assertActive,
-		assertIdle,
-		capture,
-		settle,
-		flush,
-		run,
-		guards,
-		cleanups,
-		get active() {
-			return !disposed;
-		},
-		addSource(source) {
-			assertIdle();
-			sources.add(source);
-		},
-		addProcessor(processor) {
-			assertIdle();
-			processors.add(processor);
-			processor.dependencies.forEach((output) => output.consumers.add(processor));
-		},
-		releaseProducer,
-		order: () => sequence++,
-		initialize(callback) {
-			assertIdle();
-			phase = "compute";
-			lock(true);
-			try {
-				return callback();
-			} finally {
-				lock(false);
-				phase = "idle";
-			}
-		},
-		batch,
-		batchContext: () => activeBatch,
-		dispose() {
-			if (disposed) return;
-			assertIdle();
-			disposed = true;
-			const failures = [];
-			cleanups.forEach((cleanup) => {
-				try {
-					cleanup();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			cleanups.clear();
-			processors.forEach((processor) => {
-				processor.disposed = true;
-				try {
-					processor.release();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			sources.forEach((source) => {
-				source.disposed = true;
-				try {
-					source.release();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			processors.clear();
-			sources.clear();
-			pendingSources.clear();
-			heap.length = 0;
-			queued.clear();
-			completed.clear();
-			emissions.clear();
-			guards.clear();
-			errors.length = 0;
-			reportingFailures = [];
-			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
-		}
-	};
-};
-const assertSynchronous = (value) => {
-	if (value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function") throw new TypeError("Projection callbacks must be synchronous.");
-};
-const assertScope = (active) => {
-	if (!active()) throw new Error("Projection reader or writer is no longer active.");
-};
-//#endregion
-//#region core/src/projection/definition.ts
-const projections = /* @__PURE__ */ new WeakMap();
-const defineRef = (producer, output) => {
-	const handle = Object.freeze({});
-	projections.set(handle, Object.freeze({
-		producer,
-		output
-	}));
-	return handle;
-};
-const projectionRef = (projection) => {
-	const ref = projections.get(projection);
-	if (!ref) throw new TypeError("Unknown projection definition.");
-	return ref;
-};
-const producerOf = (projection) => projectionRef(projection).producer;
-const isProjection = (value) => value !== null && typeof value === "object" && projections.has(value);
-const ownProjection = (projection, owner) => {
-	const producer = producerOf(projection);
-	if (producer.owner !== void 0 && producer.owner !== owner) throw new TypeError("Projection producer already belongs to another scope.");
-	if (producer.kind === "processor") for (const dependency of producer.dependencies) {
-		const dependencyOwner = producerOf(dependency).owner;
-		if (dependencyOwner !== void 0 && dependencyOwner !== owner) throw new TypeError("A scope cannot depend on another scope.");
-	}
-	producer.owner = owner;
-	return projection;
-};
-const freezeOutput = (output) => Object.freeze({
-	kind: output.kind,
-	equality: output.equality,
-	...output.path ? { path: Object.freeze([...output.path]) } : {}
-});
-const defineProcessor = (definition) => {
-	if (!Array.isArray(definition.dependencies)) throw new TypeError("Projection dependencies must be an array.");
-	definition.dependencies.forEach(projectionRef);
-	if (!definition.outputs.length) throw new TypeError("Projection processor requires an output.");
-	const producer = {
-		kind: "processor",
-		dependencies: Object.freeze([...definition.dependencies]),
-		outputs: Object.freeze(definition.outputs.map(freezeOutput)),
-		create: definition.create,
-		...definition.name ? { name: definition.name } : {}
-	};
-	return Object.freeze(producer.outputs.map((_, output) => defineRef(producer, output)));
-};
-const defineSource = (source, output) => {
-	return defineRef({
-		kind: "source",
-		source,
-		output: freezeOutput(output)
-	}, 0);
-};
-const sourceValue = (source) => source.kind === "value" ? source.value : snapshotCollectionView(source.read);
-const valueInput = (initial, equality = Object.is) => defineSource({
-	kind: "value-input",
-	initial,
-	equality
-}, {
-	kind: "value",
-	equality
-});
-const collectionInput = (initial = /* @__PURE__ */ new Map()) => {
-	const entries = /* @__PURE__ */ new Map();
-	for (const [key, value] of initial) {
-		if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-		entries.set(key, value);
-	}
-	return defineSource({
-		kind: "collection-input",
-		initial: entries
-	}, {
-		kind: "collection",
-		equality: Object.is
-	});
-};
-const input = Object.assign(valueInput, { collection: collectionInput });
-function observe(source, selector) {
-	if (isExternalSource(source)) return source.kind === "collection" ? defineSource({
-		kind: "external-collection",
-		source
-	}, {
-		kind: "collection",
-		equality: Object.is
-	}) : defineSource({
-		kind: "external-value",
-		source,
-		equality: Object.is
-	}, {
-		kind: "value",
-		equality: Object.is
-	});
-	if ("current" in source && typeof source.current === "function") return defineSource({
-		kind: "readable",
-		readable: source,
-		equality: Object.is
-	}, {
-		kind: "value",
-		equality: Object.is
-	});
-	const document = source;
-	const state = require_context.contextOf(document).state;
-	const selected = selector ? compilePath(state.schema, "auto", selector) : Object.freeze({
-		kind: "value",
-		schema: state.schema,
-		address: Object.freeze([])
-	});
-	return defineSource({
-		kind: "document",
-		document,
-		selector: selected
-	}, {
-		kind: selected.kind,
-		equality: Object.is
-	});
-}
-const isExternalSource = (source) => {
-	if (!source || typeof source !== "object") return false;
-	const candidate = source;
-	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
-};
-function derive(dependencies, compute, equality = Object.is) {
-	const [projection] = defineProcessor({
-		dependencies,
-		outputs: [{
-			kind: "value",
-			equality
-		}],
-		create: () => ({ evaluate: (evaluation) => {
-			const output = evaluation.outputs[0];
-			if (output.kind !== "value") throw new Error("derive requires a value output.");
-			const next = compute(...evaluation.sources.map(sourceValue));
-			assertSynchronous(next);
-			output.output.set(next);
-		} })
-	});
-	return projection;
-}
-//#endregion
-//#region core/src/projection/advanced.ts
-const resetCollectionChange = Object.freeze({ kind: "reset" });
-const isRebuild = (value) => value !== null && typeof value === "object" && value.kind === "rebuild";
-const publicValue = (source) => source.kind === "value" ? source.value : collectionView(source.read);
-const publicInputs = (sources, reset) => ({
-	values: Object.freeze(sources.map(publicValue)),
-	changes: Object.freeze(sources.map((source) => source.kind === "collection" ? reset ? resetCollectionChange : source.change : void 0))
-});
-const validateDependencies = (dependencies) => {
-	if (!Array.isArray(dependencies)) throw new TypeError("Incremental dependencies must be projections.");
-	dependencies.forEach(projectionRef);
-};
-function createIncrementalValue(dependencies, processor) {
-	validateDependencies(dependencies);
-	const [projection] = defineProcessor({
-		dependencies,
-		outputs: [{
-			kind: "value",
-			equality: Object.is
-		}],
-		create: () => {
-			const state = Object.create(null);
-			return { evaluate: (evaluation) => {
-				const output = evaluation.outputs[0];
-				if (output.kind !== "value") throw new Error("Incremental value output is invalid.");
-				const publicInput = publicInputs(evaluation.sources, evaluation.reset);
-				const result = processor({
-					sources: publicInput.values,
-					changes: publicInput.changes,
-					previous: output.previous,
-					reset: evaluation.reset,
-					cause: evaluation.cause,
-					state
-				});
-				assertSynchronous(result);
-				if (isRebuild(result)) return result;
-				output.output.set(result);
-			} };
-		}
-	});
-	return projection;
-}
-function createIncrementalCollection(dependencies, processor) {
-	validateDependencies(dependencies);
-	const [projection] = defineProcessor({
-		dependencies,
-		outputs: [{
-			kind: "collection",
-			equality: Object.is
-		}],
-		create: () => {
-			const state = Object.create(null);
-			return { evaluate: (evaluation) => {
-				const output = evaluation.outputs[0];
-				if (output.kind !== "collection") throw new Error("Incremental collection output is invalid.");
-				const publicInput = publicInputs(evaluation.sources, evaluation.reset);
-				const result = processor({
-					sources: publicInput.values,
-					changes: publicInput.changes,
-					previous: output.previous,
-					next: output.next,
-					reset: evaluation.reset,
-					cause: evaluation.cause,
-					state,
-					output: output.output
-				});
-				assertSynchronous(result);
-				return isRebuild(result) ? result : void 0;
-			} };
-		}
-	});
-	return projection;
-}
-const isPlainGroupNamespace = (value, metadata) => require_context.isPlainObject(value) && !metadata.has(value);
-const compileGroupShape = (value, path, metadata, used, outputs) => {
-	if (value !== null && typeof value === "object") {
-		const output = metadata.get(value);
-		if (output) {
-			if (used.has(value)) throw new TypeError("An incremental group output cannot be reused.");
-			used.add(value);
-			const index = outputs.length;
-			outputs.push({
-				kind: output.kind,
-				equality: output.equality,
-				path: Object.freeze([...path])
-			});
-			return index;
-		}
-	}
-	if (!isPlainGroupNamespace(value, metadata)) throw new TypeError("Incremental group outputs must be a static object tree.");
-	for (const key of Reflect.ownKeys(value)) {
-		if (typeof key !== "string") throw new TypeError("Incremental group output names must be strings.");
-		if (!Object.prototype.propertyIsEnumerable.call(value, key)) throw new TypeError("Incremental group namespaces must contain enumerable properties.");
-	}
-	const keys = Object.keys(value);
-	if (!keys.length) throw new TypeError("Incremental group namespaces cannot be empty.");
-	const result = Object.create(null);
-	for (const key of keys) {
-		if (key === "__proto__" || key === "prototype" || key === "constructor") throw new TypeError(`Invalid incremental group output name: ${key}`);
-		const descriptor = Object.getOwnPropertyDescriptor(value, key);
-		if (!descriptor || !("value" in descriptor)) throw new TypeError("Incremental group namespaces cannot contain accessors.");
-		result[key] = compileGroupShape(descriptor.value, [...path, key], metadata, used, outputs);
-	}
-	return Object.freeze(result);
-};
-const hydrateGroupShape = (shape, values) => {
-	if (typeof shape === "number") return values[shape];
-	const result = {};
-	for (const [key, child] of Object.entries(shape)) result[key] = hydrateGroupShape(child, values);
-	return Object.freeze(result);
-};
-const hydrateGroupReads = (shape, outputs, next) => {
-	if (typeof shape === "number") {
-		const output = outputs[shape];
-		return next && output.kind === "value" ? output.next() : next ? output.next : output.previous;
-	}
-	const result = {};
-	for (const [key, child] of Object.entries(shape)) if (typeof child === "number" && next && outputs[child].kind === "value") Object.defineProperty(result, key, {
-		enumerable: true,
-		configurable: false,
-		get: () => outputs[child].next()
-	});
-	else result[key] = hydrateGroupReads(child, outputs, next);
-	return Object.freeze(result);
-};
-function createIncrementalGroup(dependencies, defineOutputs, processor) {
-	validateDependencies(dependencies);
-	if (typeof defineOutputs !== "function") throw new TypeError("Incremental group outputs must be declared by a callback.");
-	if (typeof processor !== "function") throw new TypeError("Incremental group processor must be a function.");
-	let active = true;
-	const metadata = /* @__PURE__ */ new Map();
-	const declared = defineOutputs({
-		collection: (equality = Object.is) => {
-			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
-			const descriptor = Object.freeze({});
-			metadata.set(descriptor, {
-				kind: "collection",
-				equality
-			});
-			return descriptor;
-		},
-		value: (equality = Object.is) => {
-			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
-			const descriptor = Object.freeze({});
-			metadata.set(descriptor, {
-				kind: "value",
-				equality
-			});
-			return descriptor;
-		}
-	});
-	assertSynchronous(declared);
-	active = false;
-	const outputs = [];
-	const used = /* @__PURE__ */ new Set();
-	const shape = compileGroupShape(declared, [], metadata, used, outputs);
-	if (typeof shape === "number") throw new TypeError("Incremental group declarations must return an output namespace.");
-	if (used.size === 0 || used.size !== metadata.size) throw new TypeError("Every incremental group output must be returned by the declaration.");
-	return hydrateGroupShape(shape, defineProcessor({
-		dependencies,
-		outputs,
-		create: () => {
-			const state = Object.create(null);
-			return { evaluate: (evaluation) => {
-				const publicInput = publicInputs(evaluation.sources, evaluation.reset);
-				const result = processor({
-					sources: publicInput.values,
-					changes: publicInput.changes,
-					previous: hydrateGroupReads(shape, evaluation.outputs, false),
-					next: hydrateGroupReads(shape, evaluation.outputs, true),
-					outputs: hydrateGroupShape(shape, evaluation.outputs.map((output) => output.output)),
-					reset: evaluation.reset,
-					cause: evaluation.cause,
-					state
-				});
-				assertSynchronous(result);
-				return isRebuild(result) ? result : void 0;
-			} };
-		},
-		name: `processor-group:${outputs.map((output) => output.path?.join(".") ?? "").join(",")}`
-	}));
-}
-const incremental = Object.assign(createIncrementalValue, {
-	collection: createIncrementalCollection,
-	group: createIncrementalGroup
-});
-//#endregion
-Object.defineProperty(exports, "ParseError", {
-	enumerable: true,
-	get: function() {
-		return ParseError;
-	}
-});
-Object.defineProperty(exports, "ProjectionDisposedError", {
-	enumerable: true,
-	get: function() {
-		return ProjectionDisposedError;
-	}
-});
-Object.defineProperty(exports, "ProjectionError", {
-	enumerable: true,
-	get: function() {
-		return ProjectionError;
-	}
-});
-Object.defineProperty(exports, "assertScope", {
-	enumerable: true,
-	get: function() {
-		return assertScope;
-	}
-});
-Object.defineProperty(exports, "assertSynchronous", {
-	enumerable: true,
-	get: function() {
-		return assertSynchronous;
-	}
-});
-Object.defineProperty(exports, "checkKey", {
-	enumerable: true,
-	get: function() {
-		return checkKey;
-	}
-});
-Object.defineProperty(exports, "checkTreePayload", {
-	enumerable: true,
-	get: function() {
-		return checkTreePayload;
-	}
-});
-Object.defineProperty(exports, "checkValue", {
-	enumerable: true,
-	get: function() {
-		return checkValue;
-	}
-});
-Object.defineProperty(exports, "collectionEntryNode", {
-	enumerable: true,
-	get: function() {
-		return collectionEntryNode;
-	}
-});
-Object.defineProperty(exports, "collectionView", {
-	enumerable: true,
-	get: function() {
-		return collectionView;
-	}
-});
-Object.defineProperty(exports, "compilePath", {
-	enumerable: true,
-	get: function() {
-		return compilePath;
-	}
-});
-Object.defineProperty(exports, "compiledLayout", {
-	enumerable: true,
-	get: function() {
-		return compiledLayout;
-	}
-});
-Object.defineProperty(exports, "compiledShape", {
-	enumerable: true,
-	get: function() {
-		return compiledShape;
-	}
-});
-Object.defineProperty(exports, "copyTreeNode", {
-	enumerable: true,
-	get: function() {
-		return copyTreeNode;
-	}
-});
-Object.defineProperty(exports, "copyValue", {
-	enumerable: true,
-	get: function() {
-		return copyValue;
-	}
-});
-Object.defineProperty(exports, "createScheduler", {
-	enumerable: true,
-	get: function() {
-		return createScheduler;
-	}
-});
-Object.defineProperty(exports, "derive", {
-	enumerable: true,
-	get: function() {
-		return derive;
-	}
-});
-Object.defineProperty(exports, "equal", {
-	enumerable: true,
-	get: function() {
-		return equal;
-	}
-});
-Object.defineProperty(exports, "equalTreeNode", {
-	enumerable: true,
-	get: function() {
-		return equalTreeNode;
-	}
-});
-Object.defineProperty(exports, "equalValue", {
-	enumerable: true,
-	get: function() {
-		return equalValue;
-	}
-});
-Object.defineProperty(exports, "field", {
-	enumerable: true,
-	get: function() {
-		return field;
-	}
-});
-Object.defineProperty(exports, "incremental", {
-	enumerable: true,
-	get: function() {
-		return incremental;
-	}
-});
-Object.defineProperty(exports, "indexedKeys", {
-	enumerable: true,
-	get: function() {
-		return indexedKeys;
-	}
-});
-Object.defineProperty(exports, "input", {
-	enumerable: true,
-	get: function() {
-		return input;
-	}
-});
-Object.defineProperty(exports, "insert", {
-	enumerable: true,
-	get: function() {
-		return insert;
-	}
-});
-Object.defineProperty(exports, "install", {
-	enumerable: true,
-	get: function() {
-		return install;
-	}
-});
-Object.defineProperty(exports, "installKeys", {
-	enumerable: true,
-	get: function() {
-		return installKeys;
-	}
-});
-Object.defineProperty(exports, "installList", {
-	enumerable: true,
-	get: function() {
-		return installList;
-	}
-});
-Object.defineProperty(exports, "isProjection", {
-	enumerable: true,
-	get: function() {
-		return isProjection;
-	}
-});
-Object.defineProperty(exports, "keys", {
-	enumerable: true,
-	get: function() {
-		return keys;
-	}
-});
-Object.defineProperty(exports, "list", {
-	enumerable: true,
-	get: function() {
-		return list;
-	}
-});
-Object.defineProperty(exports, "listSequence", {
-	enumerable: true,
-	get: function() {
-		return listSequence;
-	}
-});
-Object.defineProperty(exports, "map", {
-	enumerable: true,
-	get: function() {
-		return map;
-	}
-});
-Object.defineProperty(exports, "mapRead", {
-	enumerable: true,
-	get: function() {
-		return mapRead;
-	}
-});
-Object.defineProperty(exports, "matches", {
-	enumerable: true,
-	get: function() {
-		return matches;
-	}
-});
-Object.defineProperty(exports, "object", {
-	enumerable: true,
-	get: function() {
-		return object;
-	}
-});
-Object.defineProperty(exports, "observe", {
-	enumerable: true,
-	get: function() {
-		return observe;
-	}
-});
-Object.defineProperty(exports, "optional", {
-	enumerable: true,
-	get: function() {
-		return optional;
-	}
-});
-Object.defineProperty(exports, "ownProjection", {
-	enumerable: true,
-	get: function() {
-		return ownProjection;
-	}
-});
-Object.defineProperty(exports, "parse", {
-	enumerable: true,
-	get: function() {
-		return parse;
-	}
-});
-Object.defineProperty(exports, "producerOf", {
-	enumerable: true,
-	get: function() {
-		return producerOf;
-	}
-});
-Object.defineProperty(exports, "profile", {
-	enumerable: true,
-	get: function() {
-		return profile;
-	}
-});
-Object.defineProperty(exports, "projectionRef", {
-	enumerable: true,
-	get: function() {
-		return projectionRef;
-	}
-});
-Object.defineProperty(exports, "remove", {
-	enumerable: true,
-	get: function() {
-		return remove;
-	}
-});
-Object.defineProperty(exports, "snapshotCollectionView", {
-	enumerable: true,
-	get: function() {
-		return snapshotCollectionView;
-	}
-});
-Object.defineProperty(exports, "table", {
-	enumerable: true,
-	get: function() {
-		return table;
-	}
-});
-Object.defineProperty(exports, "toArray", {
-	enumerable: true,
-	get: function() {
-		return toArray;
-	}
-});
-Object.defineProperty(exports, "tree", {
-	enumerable: true,
-	get: function() {
-		return tree;
-	}
-});
-Object.defineProperty(exports, "variant", {
-	enumerable: true,
-	get: function() {
-		return variant;
-	}
-});
-
-//# sourceMappingURL=advanced-Cle5g3B4.cjs.map