doxum 0.1.1

package/dist/dependency-DLcCvNKq.cjs

@@ -0,0 +1,1015 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region core/src/schema.ts
+const node = (value) => Object.freeze(value);
+const field = () => node({ kind: "field" });
+const optional = (value) => node({
+	...value,
+	optional: true
+});
+const object = (shape) => node({
+	kind: "object",
+	shape
+});
+const variant = (tag, variants) => node({
+	kind: "variant",
+	tag,
+	variants
+});
+const single = (value) => node({
+	kind: "single",
+	value
+});
+const table = (value) => node({
+	kind: "table",
+	value
+});
+const map = (value) => node({
+	kind: "map",
+	value
+});
+const record = () => node({ kind: "record" });
+const dict = () => node({ kind: "dict" });
+const list = (config) => ({
+	kind: "list",
+	keyOf: config.keyOf
+});
+const tree = () => node({ kind: "tree" });
+const pathProxy = (address) => new Proxy({ address }, { get: (_target, property) => {
+	if (property === "address") return address;
+	if (property === "item") return (id) => pathProxy([...address, id]);
+	if (typeof property === "symbol") return void 0;
+	return pathProxy([...address, property]);
+} });
+const select = (owner, kind, pick) => {
+	const selected = pick(pathProxy([]));
+	return Object.freeze({
+		kind,
+		schema: owner,
+		address: Object.freeze([...selected.address ?? []])
+	});
+};
+const schema = (shape) => {
+	const result = {
+		kind: "schema",
+		shape,
+		collection: (pick) => select(result, "collection", pick),
+		value: (pick) => select(result, "value", pick)
+	};
+	return Object.freeze(result);
+};
+//#endregion
+//#region core/src/profile.ts
+const active = { current: void 0 };
+const profile = {
+	clone: {
+		call: () => {
+			const value = active.current;
+			if (value) value.clone.calls += 1;
+		},
+		node: (reason) => {
+			const value = active.current;
+			if (!value) return;
+			value.clone.nodes[reason] += 1;
+		},
+		container: () => {
+			const value = active.current;
+			if (value) value.clone.containers += 1;
+		},
+		deepEqual: () => {
+			const value = active.current;
+			if (value) value.clone.deepEqual.calls += 1;
+		},
+		deepEqualContainer: () => {
+			const value = active.current;
+			if (value) value.clone.deepEqual.containers += 1;
+		},
+		initialDocument: () => {
+			const value = active.current;
+			if (value) value.clone.documents.initial += 1;
+		}
+	},
+	mutation: {
+		normalized: () => {
+			const value = active.current;
+			if (value) value.mutation.normalized += 1;
+		},
+		executed: () => {
+			const value = active.current;
+			if (value) value.mutation.executed += 1;
+		},
+		inverse: () => {
+			const value = active.current;
+			if (value) value.mutation.inverseCreated += 1;
+		}
+	},
+	batch: {
+		operation: () => {
+			const value = active.current;
+			if (value) value.batch.operations += 1;
+		},
+		entry: (amount = 1) => {
+			const value = active.current;
+			if (value) value.batch.entries += amount;
+		},
+		collectionResolved: () => {
+			const value = active.current;
+			if (value) value.batch.collectionsResolved += 1;
+		},
+		journalRecord: () => {
+			const value = active.current;
+			if (value) value.batch.journalRecords += 1;
+		},
+		rejected: () => {
+			const value = active.current;
+			if (value) value.batch.rejected += 1;
+		},
+		inverse: () => {
+			const value = active.current;
+			if (value) value.batch.inverseOperations += 1;
+		},
+		payloadTransferred: () => {
+			const value = active.current;
+			if (value) value.batch.payloadTransferred += 1;
+		},
+		payloadSnapshot: () => {
+			const value = active.current;
+			if (value) value.batch.payloadSnapshots += 1;
+		}
+	},
+	journal: {
+		subject: () => {
+			const value = active.current;
+			if (value) value.journal.subjects += 1;
+		},
+		comparison: () => {
+			const value = active.current;
+			if (value) value.journal.comparisons += 1;
+		},
+		absorbed: () => {
+			const value = active.current;
+			if (value) value.journal.absorbed += 1;
+		},
+		orderSnapshot: (items) => {
+			const value = active.current;
+			if (!value) return;
+			value.journal.orderSnapshots += 1;
+			value.journal.orderItems += items;
+		}
+	},
+	address: {
+		schemaStep: () => {
+			const value = active.current;
+			if (value) value.address.schemaSteps += 1;
+		},
+		documentStep: () => {
+			const value = active.current;
+			if (value) value.address.documentSteps += 1;
+		},
+		arrayCopied: () => {
+			const value = active.current;
+			if (value) value.address.arraysCopied += 1;
+		},
+		prefixComparison: () => {
+			const value = active.current;
+			if (value) value.address.prefixComparisons += 1;
+		},
+		segmentCompared: () => {
+			const value = active.current;
+			if (value) value.address.segmentsCompared += 1;
+		}
+	},
+	impact: { affects: () => {
+		const value = active.current;
+		if (value) value.impact.affectsChecks += 1;
+	} },
+	reader: {
+		session: () => {
+			const value = active.current;
+			if (value) value.reader.sessions += 1;
+		},
+		lookup: () => {
+			const value = active.current;
+			if (value) value.reader.nodeLookups += 1;
+		},
+		collectionIds: (amount = 1) => {
+			const value = active.current;
+			if (value) value.reader.collectionIds += amount;
+		},
+		structuralSnapshot: () => {
+			const value = active.current;
+			if (value) value.reader.structuralSnapshots += 1;
+		}
+	},
+	collectionView: {
+		mapped: () => {
+			const value = active.current;
+			if (value) value.collectionView.mappedItems += 1;
+		},
+		idsScanned: (amount = 1) => {
+			const value = active.current;
+			if (value) value.collectionView.idsScanned += amount;
+		},
+		arrayCopied: () => {
+			const value = active.current;
+			if (value) value.collectionView.arraysCopied += 1;
+		}
+	},
+	materialized: {
+		updated: () => {
+			const value = active.current;
+			if (value) value.materialized.updated += 1;
+		},
+		skipped: () => {
+			const value = active.current;
+			if (value) value.materialized.skipped += 1;
+		},
+		rebuilt: () => {
+			const value = active.current;
+			if (value) value.materialized.rebuilt += 1;
+		},
+		sourceChanged: () => {
+			const value = active.current;
+			if (value) value.materialized.sourceChanges += 1;
+		},
+		notification: () => {
+			const value = active.current;
+			if (value) value.materialized.notifications += 1;
+		}
+	}
+};
+//#endregion
+//#region core/src/address.ts
+const registries = /* @__PURE__ */ new WeakMap();
+const registryNode = () => ({ static: /* @__PURE__ */ new Map() });
+const registryFor = (schema) => {
+	const cached = registries.get(schema);
+	if (cached) return cached;
+	const registry = {
+		root: registryNode(),
+		nextPath: 0
+	};
+	registries.set(schema, registry);
+	return registry;
+};
+const hashText = (value, seed) => {
+	let hash = seed;
+	for (let index = 0; index < value.length; index += 1) hash = Math.imul(hash ^ value.charCodeAt(index), 16777619);
+	return hash >>> 0;
+};
+const appendAddressHash = (hash, segment) => hashText(segment, hashText("/", hash));
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const unwrap = (node) => {
+	let current = node;
+	while (current?.kind === "single") current = current.value;
+	return current;
+};
+const variantNode = (node, value) => {
+	const tag = isRecord$1(value) && typeof value[node.tag] === "string" ? value[node.tag] : void 0;
+	return node.variants[String(tag ?? Object.keys(node.variants)[0] ?? "")];
+};
+const schemaRoot$1 = (schema) => ({
+	kind: "object",
+	shape: schema.shape
+});
+const step = (nodeInput, value, segment) => {
+	let node = unwrap(nodeInput);
+	if (!node) return {
+		node: void 0,
+		dynamic: false
+	};
+	if (node.kind === "variant") node = unwrap(variantNode(node, value));
+	if (!node) return {
+		node: void 0,
+		dynamic: false
+	};
+	if (node.kind === "object") return {
+		node: node.shape[segment],
+		dynamic: false
+	};
+	if (node.kind === "table" || node.kind === "map") return {
+		node: node.value,
+		dynamic: true
+	};
+	if (node.kind === "record" || node.kind === "dict" || node.kind === "list" || node.kind === "tree") return {
+		node,
+		dynamic: true
+	};
+	return {
+		node: void 0,
+		dynamic: false
+	};
+};
+const pathFor = (schema, address, document) => {
+	const registry = registryFor(schema);
+	let trie = registry.root;
+	let node = schemaRoot$1(schema);
+	let value = document;
+	for (const segment of address) {
+		profile.address.schemaStep();
+		profile.address.documentStep();
+		const resolved = step(node, value, segment);
+		if (!resolved.node) return void 0;
+		trie = resolved.dynamic ? trie.dynamic ??= registryNode() : (() => {
+			const existing = trie.static.get(segment);
+			if (existing) return existing;
+			const created = registryNode();
+			trie.static.set(segment, created);
+			return created;
+		})();
+		node = resolved.node;
+		value = readSegment(value, segment);
+	}
+	if (trie.path === void 0) trie.path = registry.nextPath++;
+	return trie.path;
+};
+const resolveAddress = (schema, address, document) => {
+	if (!Array.isArray(address)) return void 0;
+	for (const segment of address) if (typeof segment !== "string") return void 0;
+	profile.address.arrayCopied();
+	const owned = Object.freeze(address.slice());
+	const path = pathFor(schema, owned, document);
+	return path === void 0 ? void 0 : {
+		path,
+		address: owned
+	};
+};
+const nodeAt = (schema, address, document) => {
+	let node = schemaRoot$1(schema);
+	let value = document;
+	for (const segment of address) {
+		node = step(node, value, segment).node;
+		value = readSegment(value, segment);
+		if (!node) return void 0;
+	}
+	return unwrap(node);
+};
+const readSegment = (value, segment) => {
+	if (!isRecord$1(value) && !Array.isArray(value)) return void 0;
+	if (isRecord$1(value) && "byId" in value && isRecord$1(value.byId)) {
+		const entity = value.byId[segment];
+		if (entity !== void 0 || Object.prototype.hasOwnProperty.call(value.byId, segment)) return entity;
+	}
+	return value[segment];
+};
+const read = (root, address) => {
+	let value = root;
+	for (const segment of address) {
+		value = readSegment(value, segment);
+		if (value === void 0) return void 0;
+	}
+	return value;
+};
+/** Resolves schema and document location in one address traversal. */
+const resolveLocated = (schema, root, address) => {
+	if (address.length === 0) return void 0;
+	let node = schemaRoot$1(schema);
+	let current = root;
+	let collection;
+	let addressHash = 2166136261;
+	for (let index = 0; index < address.length - 1; index += 1) {
+		profile.address.schemaStep();
+		profile.address.documentStep();
+		const resolved = step(node, current, address[index]);
+		if (!resolved.node) return void 0;
+		if (node?.kind === "table" || node?.kind === "map") collection = {
+			address: address.slice(0, index),
+			addressHash,
+			id: address[index],
+			...collection ? { parent: collection } : {}
+		};
+		addressHash = appendAddressHash(addressHash, address[index]);
+		node = resolved.node;
+		current = readSegment(current, address[index]);
+		if (!node) return void 0;
+	}
+	profile.address.schemaStep();
+	profile.address.documentStep();
+	const last = address[address.length - 1];
+	const resolved = step(node, current, last);
+	if (!resolved.node || !isRecord$1(current) && !Array.isArray(current)) return void 0;
+	if (node?.kind === "table" || node?.kind === "map") collection = {
+		address: address.slice(0, -1),
+		addressHash,
+		id: last,
+		...collection ? { parent: collection } : {}
+	};
+	addressHash = appendAddressHash(addressHash, last);
+	if (isRecord$1(current) && "byId" in current && isRecord$1(current.byId) && last in current.byId) return {
+		addressHash,
+		node: resolved.node,
+		parent: current.byId,
+		key: last,
+		value: current.byId[last],
+		...collection ? { collection } : {}
+	};
+	return {
+		addressHash,
+		node: resolved.node,
+		parent: current,
+		key: Array.isArray(current) && /^\d+$/.test(last) ? Number(last) : last,
+		value: readSegment(current, last),
+		...collection ? { collection } : {}
+	};
+};
+const locate = (root, address) => {
+	if (address.length === 0) return void 0;
+	let current = root;
+	for (let index = 0; index < address.length - 1; index += 1) current = readSegment(current, address[index]);
+	if (!isRecord$1(current) && !Array.isArray(current)) return void 0;
+	const last = address[address.length - 1];
+	if (isRecord$1(current) && "byId" in current && isRecord$1(current.byId) && last in current.byId) return {
+		parent: current.byId,
+		key: last,
+		value: current.byId[last]
+	};
+	return {
+		parent: current,
+		key: Array.isArray(current) && /^\d+$/.test(last) ? Number(last) : last,
+		value: readSegment(current, last)
+	};
+};
+const set = (root, address, value) => {
+	const target = locate(root, address);
+	if (!target) return false;
+	target.parent[target.key] = value;
+	return true;
+};
+const contains = (parent, child) => {
+	profile.address.prefixComparison();
+	if (parent.length > child.length) return false;
+	for (let index = 0; index < parent.length; index += 1) {
+		profile.address.segmentCompared();
+		if (parent[index] !== child[index]) return false;
+	}
+	return true;
+};
+const overlaps = (a, b) => contains(a, b) || contains(b, a);
+const debugKey = (address) => {
+	let result = "";
+	for (let index = 0; index < address.length; index += 1) {
+		if (index > 0) result += "/";
+		result += address[index].replaceAll("~", "~~").replaceAll("/", "~/");
+	}
+	return result;
+};
+//#endregion
+//#region core/src/impact-target.ts
+var impact_target_exports = /* @__PURE__ */ __exportAll({
+	address: () => address,
+	belongs: () => belongs,
+	bucket: () => bucket,
+	id: () => id,
+	same: () => same
+});
+const address = (target) => "at" in target ? target.at : target.address;
+const id = (target) => target.kind === "collection" && "id" in target ? target.id : void 0;
+const belongs = (target, schema) => !("schema" in target) || target.schema === schema;
+const same = (left, right) => {
+	if (left.kind !== right.kind) return false;
+	if ("schema" in left && "schema" in right && left.schema !== right.schema) return false;
+	const leftAddress = address(left);
+	const rightAddress = address(right);
+	if (leftAddress.length !== rightAddress.length) return false;
+	for (let index = 0; index < leftAddress.length; index += 1) if (leftAddress[index] !== rightAddress[index]) return false;
+	return left.kind !== "collection" || id(left) === id(right);
+};
+const bucket = (target) => address(target)[0];
+//#endregion
+//#region core/src/value/ownership.ts
+const stablePayloads = /* @__PURE__ */ new WeakSet();
+const markStablePayload = (value) => {
+	if (Array.isArray(value) || isPlainObject(value)) stablePayloads.add(value);
+	return value;
+};
+const isStablePayload = (value) => (Array.isArray(value) || isPlainObject(value)) && stablePayloads.has(value);
+const isPlainObject = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const countCloneReason = (reason) => {
+	if (reason) profile.clone.node(reason);
+};
+const cloneValue = (value, reason) => {
+	profile.clone.call();
+	countCloneReason(reason);
+	if (Array.isArray(value)) {
+		profile.clone.container();
+		const result = new Array(value.length);
+		for (let index = 0; index < value.length; index += 1) result[index] = cloneValue(value[index], reason);
+		return reason === "commit" || reason === "inverse" ? markStablePayload(Object.freeze(result)) : result;
+	}
+	if (isPlainObject(value)) {
+		profile.clone.container();
+		const result = Object.create(Object.getPrototypeOf(value));
+		for (const key in value) if (Object.prototype.hasOwnProperty.call(value, key)) result[key] = cloneValue(value[key], reason);
+		return reason === "commit" || reason === "inverse" ? markStablePayload(Object.freeze(result)) : result;
+	}
+	return value;
+};
+const ownPayload = (value, reason = "canonical") => Array.isArray(value) || isPlainObject(value) ? cloneValue(value, reason) : value;
+const transferPayload = (value) => {
+	profile.batch.payloadTransferred();
+	return value;
+};
+const snapshotPayload = (value, reason = "commit") => (profile.batch.payloadSnapshot(), ownPayload(value, reason));
+const operationOwnsStructuralPayload = (operation) => operation.type === "variant.replace" || operation.type === "dict.replace" || operation.type === "entity.create" || operation.type === "list.insert" || operation.type === "list.replace" || operation.type === "tree.replace";
+const deepEqual = (left, right) => {
+	profile.clone.deepEqual();
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) && Array.isArray(right)) {
+		profile.clone.deepEqualContainer();
+		if (left.length !== right.length) return false;
+		for (let index = 0; index < left.length; index += 1) if (!deepEqual(left[index], right[index])) return false;
+		return true;
+	}
+	if (isPlainObject(left) && isPlainObject(right)) {
+		profile.clone.deepEqualContainer();
+		const leftKeys = Object.keys(left);
+		if (leftKeys.length !== Object.keys(right).length) return false;
+		for (const key of leftKeys) if (!Object.prototype.hasOwnProperty.call(right, key) || !deepEqual(left[key], right[key])) return false;
+		return true;
+	}
+	return false;
+};
+const sameStructuralValue = (left, right) => Object.is(left, right) || (Array.isArray(left) || isPlainObject(left)) && deepEqual(left, right);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+//#region core/src/access/reader.ts
+const schemaRoot = (schema) => object(schema.shape);
+const assertActive = (context) => {
+	if (!context.active()) throw new Error("Document reader is no longer active.");
+};
+const readAt = (context, address) => {
+	assertActive(context);
+	profile.reader.lookup();
+	return read(context.root(), address);
+};
+const collectValue = (context, address) => {
+	context.dependencies?.record({
+		kind: "value",
+		at: address
+	});
+};
+const collectCollection = (context, address, id) => {
+	const target = {
+		kind: "collection",
+		at: address,
+		...id === void 0 ? {} : { id }
+	};
+	context.dependencies?.record(target);
+};
+const readerFor = (node, context, address = []) => {
+	if (node.kind === "field") return { get: () => {
+		collectValue(context, address);
+		return readAt(context, address);
+	} };
+	if (node.kind === "dict" || node.kind === "record") return { get: () => {
+		collectValue(context, address);
+		profile.reader.structuralSnapshot();
+		return cloneValue(readAt(context, address), "reader");
+	} };
+	if (node.kind === "list") return {
+		values: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(Array.isArray(value) ? value : [], "reader");
+		},
+		length: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return Array.isArray(value) ? value.length : 0;
+		},
+		at: (index) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(Array.isArray(value) ? value[index] : void 0, "reader");
+		}
+	};
+	if (node.kind === "tree") return {
+		rootId: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return isRecord(value) && typeof value.rootId === "string" ? value.rootId : void 0;
+		},
+		has: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return isRecord(value) && isRecord(value.nodes) && Object.prototype.hasOwnProperty.call(value.nodes, id);
+		},
+		value: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(isRecord(value) && isRecord(value.nodes) && isRecord(value.nodes[id]) ? value.nodes[id].value : void 0, "reader");
+		},
+		parent: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			const entry = isRecord(value) && isRecord(value.nodes) ? value.nodes[id] : void 0;
+			return isRecord(entry) && typeof entry.parentId === "string" ? entry.parentId : void 0;
+		},
+		children: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			const entry = isRecord(value) && isRecord(value.nodes) ? value.nodes[id] : void 0;
+			return isRecord(entry) && Array.isArray(entry.children) ? [...entry.children] : [];
+		}
+	};
+	if (node.kind === "table" || node.kind === "map") {
+		let items;
+		return {
+			ids: () => {
+				collectCollection(context, address);
+				const value = readAt(context, address);
+				const ids = node.kind === "table" && isRecord(value) && Array.isArray(value.ids) ? [...value.ids] : isRecord(value) ? Object.keys(value) : [];
+				profile.reader.collectionIds(ids.length);
+				return ids;
+			},
+			has: (id) => {
+				collectCollection(context, address, id);
+				const value = readAt(context, address);
+				const byId = node.kind === "table" && isRecord(value) && isRecord(value.byId) ? value.byId : value;
+				return isRecord(byId) && Object.prototype.hasOwnProperty.call(byId, id);
+			},
+			get: (id) => {
+				collectCollection(context, address, id);
+				const value = readAt(context, address);
+				const byId = node.kind === "table" && isRecord(value) && isRecord(value.byId) ? value.byId : value;
+				if (!isRecord(byId) || !Object.prototype.hasOwnProperty.call(byId, id)) return void 0;
+				const cached = items?.get(id);
+				if (cached) return cached;
+				const reader = readerFor(node.value, context, [...address, id]);
+				(items ??= /* @__PURE__ */ new Map()).set(id, reader);
+				return reader;
+			}
+		};
+	}
+	if (node.kind === "single") return readerFor(node.value, context, address);
+	if (node.kind === "variant") return new Proxy({}, { get: (_target, property) => {
+		if (typeof property === "symbol") return void 0;
+		const value = readAt(context, address);
+		const tag = isRecord(value) && typeof value[node.tag] === "string" ? String(value[node.tag]) : void 0;
+		const child = (tag ? node.variants[tag] : void 0)?.shape[property];
+		return child ? readerFor(child, context, [...address, property]) : void 0;
+	} });
+	let children;
+	return new Proxy({}, { get: (_target, property) => {
+		if (typeof property === "symbol") return void 0;
+		const child = node.shape[property];
+		if (!child) return void 0;
+		const cached = children?.get(property);
+		if (cached) return cached;
+		const reader = readerFor(child, context, [...address, property]);
+		(children ??= /* @__PURE__ */ new Map()).set(property, reader);
+		return reader;
+	} });
+};
+const documentReader = (schema, root, active, dependencies) => {
+	profile.reader.session();
+	return readerFor(schemaRoot(schema), {
+		root,
+		active,
+		dependencies
+	});
+};
+//#endregion
+//#region core/src/runtime/contract.ts
+var DocumentReentrancyError = class extends Error {
+	constructor() {
+		super("Document writes cannot be re-entered during an update or notification.");
+		this.name = "DocumentReentrancyError";
+	}
+};
+var DocumentDisposedError = class extends Error {
+	constructor() {
+		super("Doxum runtime has been disposed.");
+		this.name = "DocumentDisposedError";
+	}
+};
+//#endregion
+//#region core/src/runtime/access.ts
+const states = /* @__PURE__ */ new WeakMap();
+const bindRuntimeAccess = (runtime, state) => {
+	states.set(runtime, state);
+};
+const accessOf = (runtime) => {
+	const state = states.get(runtime);
+	if (!state) throw new Error("Unknown Doxum runtime.");
+	return state;
+};
+const schemaOf = (runtime) => accessOf(runtime).schema;
+const documentOf = (runtime) => accessOf(runtime).document;
+const readWith = (runtime, run, dependencies) => {
+	const state = accessOf(runtime);
+	if (state.disposed) throw new DocumentDisposedError();
+	let active = true;
+	const reader = documentReader(state.schema, () => state.document, () => active, dependencies);
+	try {
+		return run(reader);
+	} finally {
+		active = false;
+	}
+};
+//#endregion
+//#region core/src/access/dependency.ts
+const createDependencyTracker = () => {
+	const targets = [];
+	return {
+		record: (value) => {
+			if (!targets.some((entry) => same(entry, value))) targets.push(value);
+		},
+		clear: () => {
+			targets.length = 0;
+		},
+		size: () => targets.length,
+		some: (test) => targets.some(test),
+		snapshot: () => Object.freeze(targets.slice())
+	};
+};
+//#endregion
+Object.defineProperty(exports, "DocumentDisposedError", {
+	enumerable: true,
+	get: function() {
+		return DocumentDisposedError;
+	}
+});
+Object.defineProperty(exports, "DocumentReentrancyError", {
+	enumerable: true,
+	get: function() {
+		return DocumentReentrancyError;
+	}
+});
+Object.defineProperty(exports, "address", {
+	enumerable: true,
+	get: function() {
+		return address;
+	}
+});
+Object.defineProperty(exports, "belongs", {
+	enumerable: true,
+	get: function() {
+		return belongs;
+	}
+});
+Object.defineProperty(exports, "bindRuntimeAccess", {
+	enumerable: true,
+	get: function() {
+		return bindRuntimeAccess;
+	}
+});
+Object.defineProperty(exports, "bucket", {
+	enumerable: true,
+	get: function() {
+		return bucket;
+	}
+});
+Object.defineProperty(exports, "cloneValue", {
+	enumerable: true,
+	get: function() {
+		return cloneValue;
+	}
+});
+Object.defineProperty(exports, "contains", {
+	enumerable: true,
+	get: function() {
+		return contains;
+	}
+});
+Object.defineProperty(exports, "createDependencyTracker", {
+	enumerable: true,
+	get: function() {
+		return createDependencyTracker;
+	}
+});
+Object.defineProperty(exports, "debugKey", {
+	enumerable: true,
+	get: function() {
+		return debugKey;
+	}
+});
+Object.defineProperty(exports, "deepEqual", {
+	enumerable: true,
+	get: function() {
+		return deepEqual;
+	}
+});
+Object.defineProperty(exports, "dict", {
+	enumerable: true,
+	get: function() {
+		return dict;
+	}
+});
+Object.defineProperty(exports, "documentOf", {
+	enumerable: true,
+	get: function() {
+		return documentOf;
+	}
+});
+Object.defineProperty(exports, "documentReader", {
+	enumerable: true,
+	get: function() {
+		return documentReader;
+	}
+});
+Object.defineProperty(exports, "field", {
+	enumerable: true,
+	get: function() {
+		return field;
+	}
+});
+Object.defineProperty(exports, "id", {
+	enumerable: true,
+	get: function() {
+		return id;
+	}
+});
+Object.defineProperty(exports, "impact_target_exports", {
+	enumerable: true,
+	get: function() {
+		return impact_target_exports;
+	}
+});
+Object.defineProperty(exports, "isRecord", {
+	enumerable: true,
+	get: function() {
+		return isRecord;
+	}
+});
+Object.defineProperty(exports, "isStablePayload", {
+	enumerable: true,
+	get: function() {
+		return isStablePayload;
+	}
+});
+Object.defineProperty(exports, "list", {
+	enumerable: true,
+	get: function() {
+		return list;
+	}
+});
+Object.defineProperty(exports, "locate", {
+	enumerable: true,
+	get: function() {
+		return locate;
+	}
+});
+Object.defineProperty(exports, "map", {
+	enumerable: true,
+	get: function() {
+		return map;
+	}
+});
+Object.defineProperty(exports, "nodeAt", {
+	enumerable: true,
+	get: function() {
+		return nodeAt;
+	}
+});
+Object.defineProperty(exports, "object", {
+	enumerable: true,
+	get: function() {
+		return object;
+	}
+});
+Object.defineProperty(exports, "operationOwnsStructuralPayload", {
+	enumerable: true,
+	get: function() {
+		return operationOwnsStructuralPayload;
+	}
+});
+Object.defineProperty(exports, "optional", {
+	enumerable: true,
+	get: function() {
+		return optional;
+	}
+});
+Object.defineProperty(exports, "overlaps", {
+	enumerable: true,
+	get: function() {
+		return overlaps;
+	}
+});
+Object.defineProperty(exports, "ownPayload", {
+	enumerable: true,
+	get: function() {
+		return ownPayload;
+	}
+});
+Object.defineProperty(exports, "profile", {
+	enumerable: true,
+	get: function() {
+		return profile;
+	}
+});
+Object.defineProperty(exports, "read", {
+	enumerable: true,
+	get: function() {
+		return read;
+	}
+});
+Object.defineProperty(exports, "readWith", {
+	enumerable: true,
+	get: function() {
+		return readWith;
+	}
+});
+Object.defineProperty(exports, "readerFor", {
+	enumerable: true,
+	get: function() {
+		return readerFor;
+	}
+});
+Object.defineProperty(exports, "record", {
+	enumerable: true,
+	get: function() {
+		return record;
+	}
+});
+Object.defineProperty(exports, "resolveAddress", {
+	enumerable: true,
+	get: function() {
+		return resolveAddress;
+	}
+});
+Object.defineProperty(exports, "resolveLocated", {
+	enumerable: true,
+	get: function() {
+		return resolveLocated;
+	}
+});
+Object.defineProperty(exports, "sameStructuralValue", {
+	enumerable: true,
+	get: function() {
+		return sameStructuralValue;
+	}
+});
+Object.defineProperty(exports, "schema", {
+	enumerable: true,
+	get: function() {
+		return schema;
+	}
+});
+Object.defineProperty(exports, "schemaOf", {
+	enumerable: true,
+	get: function() {
+		return schemaOf;
+	}
+});
+Object.defineProperty(exports, "set", {
+	enumerable: true,
+	get: function() {
+		return set;
+	}
+});
+Object.defineProperty(exports, "single", {
+	enumerable: true,
+	get: function() {
+		return single;
+	}
+});
+Object.defineProperty(exports, "snapshotPayload", {
+	enumerable: true,
+	get: function() {
+		return snapshotPayload;
+	}
+});
+Object.defineProperty(exports, "table", {
+	enumerable: true,
+	get: function() {
+		return table;
+	}
+});
+Object.defineProperty(exports, "transferPayload", {
+	enumerable: true,
+	get: function() {
+		return transferPayload;
+	}
+});
+Object.defineProperty(exports, "tree", {
+	enumerable: true,
+	get: function() {
+		return tree;
+	}
+});
+Object.defineProperty(exports, "variant", {
+	enumerable: true,
+	get: function() {
+		return variant;
+	}
+});
+
+//# sourceMappingURL=dependency-DLcCvNKq.cjs.map