doxum 0.1.21 → 0.1.23

package/dist/issue-DjK1xp5K.cjs

@@ -1,881 +0,0 @@
-const profile = {
-	projection: (key, amount = 1) => {},
-	recorder: (key, amount = 1) => {},
-	access: (key) => {},
-	copy: { structure: () => {} },
-	equality: {
-		call: () => {},
-		container: () => {}
-	},
-	address: {
-		listIndex: (items) => {},
-		schemaStep: () => {},
-		documentStep: () => {},
-		arrayCopied: () => {},
-		prefixComparison: () => {},
-		segmentCompared: () => {}
-	},
-	impact: {
-		index: () => {},
-		affects: () => {}
-	},
-	collectionView: {
-		mapped: () => {},
-		idsScanned: (amount = 1) => {},
-		arrayCopied: () => {}
-	},
-	materialized: {
-		updated: () => {},
-		rebuilt: () => {},
-		notification: () => {}
-	}
-};
-//#endregion
-//#region core/src/mutation/anchor.ts
-const equal = (left, right) => {
-	profile.equality.call();
-	if (left === right) return true;
-	profile.equality.container();
-	if (left.length !== right.length) return false;
-	for (let i = 0; i < left.length; i++) if (left[i] !== keyAt(right, i)) return false;
-	return true;
-};
-const length = (keys) => keys.length;
-const keyAt = (keys, index) => Array.isArray(keys) ? keys[index] : keys.at(index);
-const keyIndex = (keys, key) => Array.isArray(keys) ? keys.indexOf(key) : keys.index(key);
-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 = (keys) => {
-	let positions;
-	return {
-		length: keys.length,
-		at: (index) => keys[index],
-		index: (key) => {
-			if (!positions) {
-				positions = /* @__PURE__ */ new Map();
-				for (let index = 0; index < keys.length; index++) positions.set(keys[index], index);
-				profile.address.listIndex(keys.length);
-			}
-			return positions.get(key) ?? -1;
-		}
-	};
-};
-const cacheKnownKeys = (values, keyOf, keys) => {
-	listIndexes.set(values, {
-		keyOf,
-		order: knownKeys(keys)
-	});
-};
-/** 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 i = 0; i < values.length; i++) positions.set(keyOf(values[i]), i);
-				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
-	};
-};
-/** Plan one relative move against the order that remains after removing the selection. */
-const moveSelection = (current, selection, position) => {
-	if (!selection.length) return {
-		kind: "ok",
-		order: current
-	};
-	const selected = /* @__PURE__ */ new Set();
-	for (const key of selection) {
-		if (selected.has(key)) return { kind: "duplicate" };
-		selected.add(key);
-	}
-	const moved = [];
-	const remaining = [];
-	for (const key of current) (selected.has(key) ? moved : remaining).push(key);
-	if (moved.length !== selected.size) return { kind: "missing" };
-	if (!valid(remaining, position)) return { kind: "invalid-anchor" };
-	const insertion = index(remaining, position);
-	return {
-		kind: "ok",
-		order: [
-			...remaining.slice(0, insertion),
-			...moved,
-			...remaining.slice(insertion)
-		]
-	};
-};
-/** 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);
-};
-/** Install 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];
-};
-/** Install 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));
-};
-const index = (keys, anchor) => {
-	if (!anchor) return length(keys);
-	if ("at" in anchor) return anchor.at === "start" ? 0 : length(keys);
-	if ("before" in anchor) return keyIndex(keys, anchor.before);
-	return keyIndex(keys, anchor.after) + 1;
-};
-const valid = (keys, anchor) => {
-	if (!anchor) return true;
-	if (typeof anchor !== "object" || anchor === null) return false;
-	if (Number("at" in anchor) + Number("before" in anchor) + Number("after" in anchor) !== 1) return false;
-	if ("at" in anchor) return anchor.at === "start" || anchor.at === "end";
-	return keyIndex(keys, "before" in anchor ? anchor.before : anchor.after) >= 0;
-};
-//#endregion
-//#region core/src/value/ownership.ts
-const isPlainObject = (value) => {
-	if (value === null || typeof value !== "object") return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-};
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-//#endregion
-//#region core/src/mutation/tree.ts
-const node = (tree, id) => Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
-const is = (value) => isRecord$1(value) && isRecord$1(value.nodes);
-const validNode = (value) => {
-	if (!isRecord$1(value) || !Array.isArray(value.children)) return false;
-	if (value.parentId !== void 0 && typeof value.parentId !== "string") return false;
-	const children = /* @__PURE__ */ new Set();
-	for (const id of value.children) {
-		if (typeof id !== "string" || children.has(id)) return false;
-		children.add(id);
-	}
-	return true;
-};
-const contains$1 = (tree, id) => Object.hasOwn(tree.nodes, id);
-const parent = (tree, id) => node(tree, id)?.parentId;
-const children = (tree, id) => node(tree, id)?.children;
-const validate = (value) => {
-	if (!is(value)) return false;
-	const ids = Object.keys(value.nodes);
-	if (ids.length === 0) return value.rootId === void 0;
-	if (typeof value.rootId !== "string" || !Object.hasOwn(value.nodes, value.rootId)) return false;
-	for (const id of ids) {
-		const entry = value.nodes[id];
-		if (!validNode(entry)) return false;
-		if (id === value.rootId) {
-			if (entry.parentId !== void 0) return false;
-		} else if (entry.parentId === void 0 || !Object.hasOwn(value.nodes, entry.parentId)) return false;
-		for (const child of entry.children) {
-			const childNode = value.nodes[child];
-			if (!childNode || childNode.parentId !== id) return false;
-		}
-	}
-	const seen = /* @__PURE__ */ new Set();
-	const stack = [value.rootId];
-	while (stack.length) {
-		const id = stack.pop();
-		if (seen.has(id)) return false;
-		seen.add(id);
-		const entry = value.nodes[id];
-		if (!entry) return false;
-		for (const child of entry.children) stack.push(child);
-	}
-	return seen.size === ids.length;
-};
-//#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 isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const variantNode = (node, value) => {
-	const tag = isRecord(value) && typeof value[node.tag] === "string" ? value[node.tag] : void 0;
-	return node.variants[String(tag ?? Object.keys(node.variants)[0] ?? "")];
-};
-const step = (nodeInput, value, segment) => {
-	let node = nodeInput;
-	if (!node) return void 0;
-	if (node.kind === "variant") node = variantNode(node, value);
-	if (!node) return void 0;
-	if (node.kind === "object") return Object.hasOwn(node.shape, segment) ? node.shape[segment] : void 0;
-	if (node.kind === "table" || node.kind === "map") return node.value;
-	if (node.kind === "list") return node.value;
-};
-const pathFor = (schema, address, document) => {
-	const registry = registryFor(schema);
-	let trie = registry.root;
-	let node = schema;
-	let value = document;
-	for (const segment of address) {
-		profile.address.schemaStep();
-		profile.address.documentStep();
-		const resolved = step(node, value, segment);
-		if (!resolved) return void 0;
-		trie = node && (node.kind === "table" || node.kind === "map" || node.kind === "list" || node.kind === "tree") ? trie.dynamic ??= registryNode() : (() => {
-			const existing = trie.static.get(segment);
-			if (existing) return existing;
-			const created = registryNode();
-			trie.static.set(segment, created);
-			return created;
-		})();
-		value = readSegment(value, segment, node);
-		node = resolved;
-	}
-	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 = schema;
-	let value = document;
-	for (const segment of address) {
-		const resolved = step(node, value, segment);
-		value = readSegment(value, segment, node);
-		node = resolved;
-		if (!node) return void 0;
-	}
-	return node;
-};
-const readSegment = (value, segment, node) => {
-	if (!isRecord(value) && !Array.isArray(value)) return void 0;
-	if (node?.kind === "list" && Array.isArray(value)) return value[indexedKeys(value, node.keyOf).index(segment)];
-	if (node?.kind === "table" && isRecord(value) && isRecord(value.byId)) return Object.hasOwn(value.byId, segment) ? value.byId[segment] : void 0;
-	return Object.prototype.hasOwnProperty.call(value, segment) ? value[segment] : void 0;
-};
-const read = (root, address, schema) => {
-	let value = root;
-	let node = schema;
-	for (const segment of address) {
-		const next = step(node, value, segment);
-		value = readSegment(value, segment, node);
-		node = next;
-		if (value === void 0) return void 0;
-	}
-	return value;
-};
-const compiledObjects = /* @__PURE__ */ new WeakMap();
-const compiledEntries = /* @__PURE__ */ new WeakMap();
-const compiledShape = (node, value) => {
-	const branch = node.kind === "variant" ? variantNode(node, value) : node;
-	if (branch?.kind !== "object") return void 0;
-	const shape = branch.shape;
-	let layout = compiledObjects.get(shape);
-	if (!layout) {
-		const compiled = /* @__PURE__ */ new Map();
-		for (const key of Object.keys(shape).sort()) {
-			profile.address.schemaStep();
-			compiled.set(key, {
-				kind: "fixed",
-				key,
-				node: shape[key],
-				field: shape[key].kind === "field",
-				slot: compiled.size
-			});
-		}
-		layout = {
-			kind: "fixed",
-			members: compiled
-		};
-		compiledObjects.set(shape, layout);
-	}
-	return layout;
-};
-const resolveContainer = (owner, generation, at, node, value) => {
-	if (!node || !isRecord(value) && !Array.isArray(value)) return void 0;
-	const parent = node.kind === "table" && isRecord(value) ? value.byId : value;
-	if (!isRecord(parent) && !Array.isArray(parent)) return void 0;
-	if (node.kind === "tree") return void 0;
-	let layout;
-	if (node.kind === "map" || node.kind === "table" || node.kind === "list") {
-		let dynamic = compiledEntries.get(node);
-		if (!dynamic) {
-			dynamic = {
-				kind: "dynamic",
-				entry: {
-					kind: "entry",
-					node: node.value,
-					field: node.value.kind === "field"
-				}
-			};
-			compiledEntries.set(node, dynamic);
-		}
-		layout = dynamic;
-	} else {
-		const fixed = compiledShape(node, value);
-		if (!fixed) return void 0;
-		layout = fixed;
-	}
-	return {
-		owner,
-		generation,
-		at,
-		node,
-		parent,
-		value,
-		layout
-	};
-};
-const resolveTreeContainer = (owner, generation, at, node, value) => node?.kind === "tree" && is(value) ? {
-	owner,
-	generation,
-	at,
-	node,
-	value
-} : void 0;
-const memberKey = (container, key) => container.node.kind === "list" ? indexedKeys(container.parent, container.node.keyOf).index(key) : key;
-/** One recent path per transaction; structural writes invalidate all retained locations. */
-const createAddressResolver = (schema, root) => {
-	const prefix = [];
-	return {
-		container: (owner, generation, at) => {
-			if (!at.length) return resolveContainer(owner, generation, at, schema, root);
-			const location = resolveWithPrefix(schema, root, at, prefix);
-			if (!location || !Object.hasOwn(location.parent, location.key)) return void 0;
-			return resolveContainer(owner, generation, at, location.node, location.parent[location.key]);
-		},
-		invalidate: () => {
-			prefix.length = 0;
-		}
-	};
-};
-/** A subtree root is a value, not a fabricated member of an ObjectNode. */
-const resolveValue = (schema, root, address, prefix) => {
-	if (!address.length) return {
-		node: schema,
-		value: root
-	};
-	const location = resolveWithPrefix(schema, root, address, prefix);
-	return location && {
-		node: location.node,
-		value: Object.hasOwn(location.parent, location.key) ? location.parent[location.key] : void 0
-	};
-};
-/** Resolves schema and document location in one address traversal. */
-const resolveLocated = (schema, root, address) => resolveWithPrefix(schema, root, address);
-const resolveWithPrefix = (schema, root, address, prefix) => {
-	if (address.length === 0) return void 0;
-	let node = schema;
-	let current = root;
-	let start = 0;
-	if (prefix) {
-		while (start < prefix.length && start < address.length - 1 && prefix[start].segment === address[start]) start++;
-		prefix.length = start;
-		if (start) {
-			const retained = prefix[start - 1];
-			node = retained.node;
-			current = retained.value;
-		}
-	}
-	let cacheable = true;
-	for (let index = start; index < address.length - 1; index += 1) {
-		profile.address.schemaStep();
-		profile.address.documentStep();
-		const resolved = step(node, current, address[index]);
-		if (!resolved) return void 0;
-		if (node?.kind !== "object" && node?.kind !== "table" && node?.kind !== "map") cacheable = false;
-		current = readSegment(current, address[index], node);
-		node = resolved;
-		if (prefix && cacheable) prefix.push({
-			segment: address[index],
-			node: resolved,
-			value: current
-		});
-		if (!node) return void 0;
-	}
-	const last = address[address.length - 1];
-	return resolveChild(node, current, last);
-};
-/** Resolves one member from an already current schema/container pair. */
-const resolveChild = (node, current, last) => {
-	profile.address.schemaStep();
-	profile.address.documentStep();
-	const resolved = step(node, current, last);
-	if (!resolved || !isRecord(current) && !Array.isArray(current)) return void 0;
-	if (node?.kind === "table" && isRecord(current) && isRecord(current.byId)) return {
-		node: resolved,
-		parent: current.byId,
-		key: last
-	};
-	return {
-		node: resolved,
-		parent: current,
-		key: node?.kind === "list" && Array.isArray(current) ? indexedKeys(current, node.keyOf).index(last) : last
-	};
-};
-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;
-};
-/** An index over canonical address segments, shared by impact and subscriptions. */
-var AddressIndex = class {
-	root = {
-		children: /* @__PURE__ */ new Map(),
-		values: /* @__PURE__ */ new Set()
-	};
-	add(address, value, member) {
-		let node = this.root;
-		for (let i = 0; i < address.length + (member === void 0 ? 0 : 1); i++) {
-			const segment = i < address.length ? address[i] : member;
-			let child = node.children.get(segment);
-			if (!child) {
-				child = {
-					children: /* @__PURE__ */ new Map(),
-					values: /* @__PURE__ */ new Set()
-				};
-				node.children.set(segment, child);
-			}
-			node = child;
-		}
-		node.values.add(value);
-	}
-	delete(address, value) {
-		const parents = [];
-		let node = this.root;
-		for (const segment of address) {
-			const child = node.children.get(segment);
-			if (!child) return;
-			parents.push(node);
-			node = child;
-		}
-		node.values.delete(value);
-		for (let i = address.length - 1; i >= 0 && !node.values.size && !node.children.size; i--) {
-			node = parents[i];
-			node.children.delete(address[i]);
-		}
-	}
-	exact(address) {
-		let node = this.root;
-		for (const segment of address) {
-			const child = node.children.get(segment);
-			if (!child) return void 0;
-			node = child;
-		}
-		return node.values;
-	}
-	hasAncestor(address, strict = false) {
-		let node = this.root;
-		for (let i = 0; i < address.length; i++) {
-			if (node.values.size) return true;
-			const child = node.children.get(address[i]);
-			if (!child) return false;
-			node = child;
-		}
-		return !strict && node.values.size > 0;
-	}
-	someAncestor(address, predicate) {
-		let node = this.root;
-		for (let i = 0;; i++) {
-			for (const value of node.values) if (predicate(value)) return true;
-			if (i === address.length) return false;
-			const child = node.children.get(address[i]);
-			if (!child) return false;
-			node = child;
-		}
-	}
-	overlaps(address) {
-		let node = this.root;
-		for (const segment of address) {
-			if (node.values.size) return true;
-			const child = node.children.get(segment);
-			if (!child) return false;
-			node = child;
-		}
-		return node.values.size > 0 || node.children.size > 0;
-	}
-	hasDescendant(address) {
-		let node = this.root;
-		for (const segment of address) {
-			const child = node.children.get(segment);
-			if (!child) return false;
-			node = child;
-		}
-		return node.values.size > 0 || node.children.size > 0;
-	}
-	query(visit, relation = "overlap") {
-		const visited = /* @__PURE__ */ new Set();
-		const subtrees = /* @__PURE__ */ new Set();
-		const values = (node) => {
-			if (visited.has(node)) return;
-			visited.add(node);
-			node.values.forEach(visit);
-		};
-		const descend = (current) => {
-			if (subtrees.has(current)) return;
-			subtrees.add(current);
-			values(current);
-			current.children.forEach(descend);
-		};
-		const terminal = (node) => relation === "ancestors" ? values(node) : descend(node);
-		return (address, members) => {
-			let node = this.root;
-			for (const segment of address) {
-				if (subtrees.has(node)) return;
-				if (relation !== "descendants") values(node);
-				const child = node.children.get(segment);
-				if (!child) return;
-				node = child;
-			}
-			if (!members) terminal(node);
-			else {
-				if (relation !== "descendants") values(node);
-				for (const member of members) {
-					const child = node.children.get(member.key);
-					if (child) terminal(child);
-				}
-			}
-		};
-	}
-	clear() {
-		this.root.values.clear();
-		this.root.children.clear();
-	}
-};
-//#endregion
-//#region core/src/mutation/issue.ts
-const at = (address, code, message) => Object.freeze({
-	source: "mutation",
-	code,
-	address: Object.freeze([...address]),
-	message
-});
-var MutationRejected = class extends Error {
-	constructor(issue) {
-		super(issue.message);
-		this.issue = issue;
-	}
-};
-const fail = (address, code, message) => {
-	throw new MutationRejected(at(address, code, message));
-};
-const invalidValue = (issue, address = issue.address) => fail(address, issue.code === "missing-validator" ? "invalid-value" : issue.code, issue.message);
-//#endregion
-Object.defineProperty(exports, "AddressIndex", {
-	enumerable: true,
-	get: function() {
-		return AddressIndex;
-	}
-});
-Object.defineProperty(exports, "MutationRejected", {
-	enumerable: true,
-	get: function() {
-		return MutationRejected;
-	}
-});
-Object.defineProperty(exports, "children", {
-	enumerable: true,
-	get: function() {
-		return children;
-	}
-});
-Object.defineProperty(exports, "compiledShape", {
-	enumerable: true,
-	get: function() {
-		return compiledShape;
-	}
-});
-Object.defineProperty(exports, "contains", {
-	enumerable: true,
-	get: function() {
-		return contains;
-	}
-});
-Object.defineProperty(exports, "contains$1", {
-	enumerable: true,
-	get: function() {
-		return contains$1;
-	}
-});
-Object.defineProperty(exports, "createAddressResolver", {
-	enumerable: true,
-	get: function() {
-		return createAddressResolver;
-	}
-});
-Object.defineProperty(exports, "debugKey", {
-	enumerable: true,
-	get: function() {
-		return debugKey;
-	}
-});
-Object.defineProperty(exports, "equal", {
-	enumerable: true,
-	get: function() {
-		return equal;
-	}
-});
-Object.defineProperty(exports, "fail", {
-	enumerable: true,
-	get: function() {
-		return fail;
-	}
-});
-Object.defineProperty(exports, "index", {
-	enumerable: true,
-	get: function() {
-		return index;
-	}
-});
-Object.defineProperty(exports, "indexedKeys", {
-	enumerable: true,
-	get: function() {
-		return indexedKeys;
-	}
-});
-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, "invalidValue", {
-	enumerable: true,
-	get: function() {
-		return invalidValue;
-	}
-});
-Object.defineProperty(exports, "isPlainObject", {
-	enumerable: true,
-	get: function() {
-		return isPlainObject;
-	}
-});
-Object.defineProperty(exports, "isRecord", {
-	enumerable: true,
-	get: function() {
-		return isRecord$1;
-	}
-});
-Object.defineProperty(exports, "keys", {
-	enumerable: true,
-	get: function() {
-		return keys;
-	}
-});
-Object.defineProperty(exports, "listSequence", {
-	enumerable: true,
-	get: function() {
-		return listSequence;
-	}
-});
-Object.defineProperty(exports, "matches", {
-	enumerable: true,
-	get: function() {
-		return matches;
-	}
-});
-Object.defineProperty(exports, "memberKey", {
-	enumerable: true,
-	get: function() {
-		return memberKey;
-	}
-});
-Object.defineProperty(exports, "moveSelection", {
-	enumerable: true,
-	get: function() {
-		return moveSelection;
-	}
-});
-Object.defineProperty(exports, "nodeAt", {
-	enumerable: true,
-	get: function() {
-		return nodeAt;
-	}
-});
-Object.defineProperty(exports, "overlaps", {
-	enumerable: true,
-	get: function() {
-		return overlaps;
-	}
-});
-Object.defineProperty(exports, "parent", {
-	enumerable: true,
-	get: function() {
-		return parent;
-	}
-});
-Object.defineProperty(exports, "profile", {
-	enumerable: true,
-	get: function() {
-		return profile;
-	}
-});
-Object.defineProperty(exports, "read", {
-	enumerable: true,
-	get: function() {
-		return read;
-	}
-});
-Object.defineProperty(exports, "remove", {
-	enumerable: true,
-	get: function() {
-		return remove;
-	}
-});
-Object.defineProperty(exports, "resolveAddress", {
-	enumerable: true,
-	get: function() {
-		return resolveAddress;
-	}
-});
-Object.defineProperty(exports, "resolveChild", {
-	enumerable: true,
-	get: function() {
-		return resolveChild;
-	}
-});
-Object.defineProperty(exports, "resolveContainer", {
-	enumerable: true,
-	get: function() {
-		return resolveContainer;
-	}
-});
-Object.defineProperty(exports, "resolveLocated", {
-	enumerable: true,
-	get: function() {
-		return resolveLocated;
-	}
-});
-Object.defineProperty(exports, "resolveTreeContainer", {
-	enumerable: true,
-	get: function() {
-		return resolveTreeContainer;
-	}
-});
-Object.defineProperty(exports, "resolveValue", {
-	enumerable: true,
-	get: function() {
-		return resolveValue;
-	}
-});
-Object.defineProperty(exports, "toArray", {
-	enumerable: true,
-	get: function() {
-		return toArray;
-	}
-});
-Object.defineProperty(exports, "valid", {
-	enumerable: true,
-	get: function() {
-		return valid;
-	}
-});
-Object.defineProperty(exports, "validNode", {
-	enumerable: true,
-	get: function() {
-		return validNode;
-	}
-});
-Object.defineProperty(exports, "validate", {
-	enumerable: true,
-	get: function() {
-		return validate;
-	}
-});
-
-//# sourceMappingURL=issue-DjK1xp5K.cjs.map