@optique/core 1.0.0-dev.921 → 1.0.1

package/dist/annotation-state.js

@@ -0,0 +1,414 @@
+import { annotationKey, getAnnotations, inheritAnnotations, injectAnnotations, isInjectedAnnotationWrapper, unwrapInjectedAnnotationWrapper } from "./internal/annotations.js";
+import { inheritParentAnnotationsKey } from "./internal/parser.js";
+
+//#region src/annotation-state.ts
+/**
+* Shared targets for annotation-view proxies.
+*
+* Maps a proxy returned by {@link withAnnotationView} back to its original
+* target object.
+*
+* @internal
+*/
+const annotationViewTargets = /* @__PURE__ */ new WeakMap();
+const delegatedAnnotationCloneTargets = /* @__PURE__ */ new WeakMap();
+/**
+* Unwraps an annotation-view proxy to its original target object.
+*
+* @param value The candidate value that may be an annotation-view proxy.
+* @returns The original target object when the input is a tracked
+*          annotation-view proxy; otherwise the input value unchanged.
+* @internal
+*/
+function unwrapAnnotationView(value) {
+	if (value == null || typeof value !== "object") return value;
+	return annotationViewTargets.get(value) ?? value;
+}
+function unwrapDelegatedAnnotationClone(value) {
+	if (value == null || typeof value !== "object") return value;
+	return delegatedAnnotationCloneTargets.get(value) ?? value;
+}
+/**
+* Creates an annotation-aware proxy without changing the target shape.
+*
+* @param state The object state to expose through an annotation-aware view.
+* @param annotations The annotations to surface through the proxy.
+* @returns A proxy over the unwrapped target object that reports the supplied
+*          annotations while preserving the target's structural behavior.
+* @since 1.0.0
+*/
+function withAnnotationView(state, annotations) {
+	const target = unwrapAnnotationView(state);
+	const view = new Proxy(target, {
+		get(target$1, key) {
+			if (key === annotationKey) return annotations;
+			const value = Reflect.get(target$1, key, target$1);
+			return typeof value === "function" ? value.bind(target$1) : value;
+		},
+		has(target$1, key) {
+			return key === annotationKey || Reflect.has(target$1, key);
+		}
+	});
+	annotationViewTargets.set(view, target);
+	return view;
+}
+/**
+* Removes Optique's internal primitive-state annotation wrapper when present.
+*
+* @param state The parser state to normalize.
+* @returns The wrapped primitive sentinel when the input is an injected
+*          annotation wrapper; otherwise the original input unchanged.
+* @internal
+*/
+function normalizeInjectedAnnotationState(state) {
+	return unwrapInjectedAnnotationWrapper(state);
+}
+function isNonPlainDelegatedObject(state) {
+	const proto = Object.getPrototypeOf(state);
+	if (proto === Array.prototype || proto === Date.prototype || proto === Map.prototype || proto === Set.prototype || proto === RegExp.prototype) return false;
+	return proto !== Object.prototype && proto !== null;
+}
+function inheritDelegatedAnnotations(parentState, childState) {
+	const target = normalizeDelegatedAnnotationState(childState);
+	const delegatedState = inheritAnnotations(parentState, target);
+	if (delegatedState !== target) delegatedAnnotationCloneTargets.set(delegatedState, target);
+	return delegatedState;
+}
+/**
+* Removes Optique's internal annotation carriers from a delegated state.
+*
+* This unwraps primitive-state annotation wrappers, tracked delegated clones,
+* and annotation-view proxies used for object states.
+*
+* @param state The delegated state to normalize.
+* @returns The original underlying state value.
+* @internal
+*/
+function normalizeDelegatedAnnotationState(state) {
+	return normalizeInjectedAnnotationState(unwrapDelegatedAnnotationClone(unwrapAnnotationView(state)));
+}
+/**
+* Returns whether the given state uses an internal delegated annotation carrier.
+*
+* @param state The candidate state to inspect.
+* @returns `true` when the state is an injected primitive wrapper, a tracked
+*          delegated clone, or an annotation-view proxy.
+* @internal
+*/
+function hasDelegatedAnnotationCarrier(state) {
+	return state != null && typeof state === "object" && (isInjectedAnnotationWrapper(state) || delegatedAnnotationCloneTargets.has(state) || annotationViewTargets.has(state));
+}
+function getOrCreateNestedNormalizationClone(entry) {
+	entry.clone ??= entry.createClone();
+	return entry.clone;
+}
+function getPendingNestedNormalizationEntry(originalValue, normalizedValue, seen) {
+	if (originalValue == null || typeof originalValue !== "object") return void 0;
+	const entry = seen.get(originalValue);
+	return entry != null && entry.clone != null && entry.clone === normalizedValue && (!entry.finalized || entry.preferCloneOnRead) ? entry : void 0;
+}
+function createPendingNestedNormalizationClone(source) {
+	if (!Array.isArray(source)) return Object.create(Object.getPrototypeOf(source));
+	if (Object.getPrototypeOf(source) === Array.prototype) return [];
+	try {
+		return source.slice(0, 0);
+	} catch {
+		return [];
+	}
+}
+function createPendingNestedNormalizationCollectionClone(source) {
+	const proto = Object.getPrototypeOf(source);
+	if (source instanceof Map && proto === Map.prototype) return /* @__PURE__ */ new Map();
+	if (source instanceof Set && proto === Set.prototype) return /* @__PURE__ */ new Set();
+	const Constructor = source.constructor;
+	if (typeof Constructor === "function") try {
+		return new Constructor();
+	} catch {}
+	return source instanceof Map ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
+}
+function normalizeNestedDelegatedStructuredState(source, seen, preferPendingClone) {
+	const entry = {
+		clone: void 0,
+		createClone: () => createPendingNestedNormalizationClone(source),
+		finalized: false,
+		result: source,
+		preferCloneOnRead: false
+	};
+	seen.set(source, entry);
+	const overrides = /* @__PURE__ */ new Map();
+	let changed = false;
+	let hasPendingAliasOverride = false;
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (descriptor == null || !("value" in descriptor)) continue;
+		const nextValue = normalizeNestedDelegatedAnnotationState(descriptor.value, seen, true);
+		if (nextValue === descriptor.value) continue;
+		overrides.set(key, nextValue);
+		if (getPendingNestedNormalizationEntry(descriptor.value, nextValue, seen) == null) changed = true;
+		else hasPendingAliasOverride = true;
+	}
+	if (!changed && !hasPendingAliasOverride) {
+		entry.finalized = true;
+		entry.result = source;
+		return source;
+	}
+	const descriptors = Object.getOwnPropertyDescriptors(source);
+	for (const [key, nextValue] of overrides) {
+		const descriptor = descriptors[key];
+		if (descriptor == null || !("value" in descriptor)) continue;
+		descriptors[key] = {
+			...descriptor,
+			value: nextValue
+		};
+	}
+	const clone = getOrCreateNestedNormalizationClone(entry);
+	Object.defineProperties(clone, descriptors);
+	entry.finalized = true;
+	entry.preferCloneOnRead = !changed && hasPendingAliasOverride;
+	entry.result = changed ? clone : source;
+	return changed || preferPendingClone ? clone : source;
+}
+function normalizeNestedDelegatedMapState(source, seen, preferPendingClone) {
+	const entry = {
+		clone: void 0,
+		createClone: () => createPendingNestedNormalizationCollectionClone(source),
+		finalized: false,
+		result: source,
+		preferCloneOnRead: false
+	};
+	seen.set(source, entry);
+	const normalizedEntries = [];
+	const overrides = /* @__PURE__ */ new Map();
+	let changed = false;
+	let hasPendingAliasOverride = false;
+	for (const [key, value] of source) {
+		const nextKey = normalizeNestedDelegatedAnnotationState(key, seen, true);
+		const nextValue = normalizeNestedDelegatedAnnotationState(value, seen, true);
+		normalizedEntries.push([nextKey, nextValue]);
+		if (nextKey !== key) if (getPendingNestedNormalizationEntry(key, nextKey, seen) == null) changed = true;
+		else hasPendingAliasOverride = true;
+		if (nextValue !== value) if (getPendingNestedNormalizationEntry(value, nextValue, seen) == null) changed = true;
+		else hasPendingAliasOverride = true;
+	}
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (descriptor == null || !("value" in descriptor)) continue;
+		const nextValue = normalizeNestedDelegatedAnnotationState(descriptor.value, seen, true);
+		if (nextValue === descriptor.value) continue;
+		overrides.set(key, nextValue);
+		if (getPendingNestedNormalizationEntry(descriptor.value, nextValue, seen) == null) changed = true;
+		else hasPendingAliasOverride = true;
+	}
+	if (!changed && !hasPendingAliasOverride) {
+		entry.finalized = true;
+		entry.result = source;
+		return source;
+	}
+	const clone = getOrCreateNestedNormalizationClone(entry);
+	for (const [key, value] of normalizedEntries) clone.set(key, value);
+	const descriptors = Object.getOwnPropertyDescriptors(source);
+	for (const [key, nextValue] of overrides) {
+		const descriptor = descriptors[key];
+		if (descriptor == null || !("value" in descriptor)) continue;
+		descriptors[key] = {
+			...descriptor,
+			value: nextValue
+		};
+	}
+	Object.defineProperties(clone, descriptors);
+	entry.finalized = true;
+	entry.preferCloneOnRead = !changed && hasPendingAliasOverride;
+	entry.result = changed ? clone : source;
+	return changed || preferPendingClone ? clone : source;
+}
+function normalizeNestedDelegatedSetState(source, seen, preferPendingClone) {
+	const entry = {
+		clone: void 0,
+		createClone: () => createPendingNestedNormalizationCollectionClone(source),
+		finalized: false,
+		result: source,
+		preferCloneOnRead: false
+	};
+	seen.set(source, entry);
+	const normalizedValues = [];
+	const overrides = /* @__PURE__ */ new Map();
+	let changed = false;
+	let hasPendingAliasOverride = false;
+	for (const value of source) {
+		const nextValue = normalizeNestedDelegatedAnnotationState(value, seen, true);
+		normalizedValues.push(nextValue);
+		if (nextValue === value) continue;
+		if (getPendingNestedNormalizationEntry(value, nextValue, seen) == null) changed = true;
+		else hasPendingAliasOverride = true;
+	}
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (descriptor == null || !("value" in descriptor)) continue;
+		const nextValue = normalizeNestedDelegatedAnnotationState(descriptor.value, seen, true);
+		if (nextValue === descriptor.value) continue;
+		overrides.set(key, nextValue);
+		if (getPendingNestedNormalizationEntry(descriptor.value, nextValue, seen) == null) changed = true;
+		else hasPendingAliasOverride = true;
+	}
+	if (!changed && !hasPendingAliasOverride) {
+		entry.finalized = true;
+		entry.result = source;
+		return source;
+	}
+	const clone = getOrCreateNestedNormalizationClone(entry);
+	for (const value of normalizedValues) clone.add(value);
+	const descriptors = Object.getOwnPropertyDescriptors(source);
+	for (const [key, nextValue] of overrides) {
+		const descriptor = descriptors[key];
+		if (descriptor == null || !("value" in descriptor)) continue;
+		descriptors[key] = {
+			...descriptor,
+			value: nextValue
+		};
+	}
+	Object.defineProperties(clone, descriptors);
+	entry.finalized = true;
+	entry.preferCloneOnRead = !changed && hasPendingAliasOverride;
+	entry.result = changed ? clone : source;
+	return changed || preferPendingClone ? clone : source;
+}
+/**
+* Recursively removes delegated annotation carriers from plain-object, array,
+* and built-in collection structures.
+*
+* Nested plain objects, arrays, Maps, and Sets are shallow-cloned only when a
+* delegated carrier is found below them. Other non-plain objects are unwrapped
+* at the top level and then preserved as-is to avoid mutating or reconstructing
+* class instances.
+*
+* @param value The candidate value to normalize.
+* @param seen Tracks already-normalized objects so cyclic values keep their
+*             shape.
+* @returns The original value when no delegated carriers are present, or a
+*          normalized clone with delegated carriers removed.
+* @internal
+*/
+function normalizeNestedDelegatedAnnotationState(value, seen = /* @__PURE__ */ new WeakMap(), preferPendingClone = false) {
+	const normalized = normalizeDelegatedAnnotationState(value);
+	if (normalized == null || typeof normalized !== "object") return normalized;
+	const source = normalized;
+	const existing = seen.get(source);
+	if (existing != null) {
+		if (!existing.finalized) return getOrCreateNestedNormalizationClone(existing);
+		return preferPendingClone && existing.preferCloneOnRead ? getOrCreateNestedNormalizationClone(existing) : existing.result;
+	}
+	if (Array.isArray(source)) return normalizeNestedDelegatedStructuredState(source, seen, preferPendingClone);
+	if (source instanceof Map) return normalizeNestedDelegatedMapState(source, seen, preferPendingClone);
+	if (source instanceof Set) return normalizeNestedDelegatedSetState(source, seen, preferPendingClone);
+	const proto = Object.getPrototypeOf(source);
+	if (proto !== Object.prototype && proto !== null) return normalized;
+	return normalizeNestedDelegatedStructuredState(source, seen, preferPendingClone);
+}
+/**
+* Creates a short-lived delegated state that exposes the parent's annotations
+* regardless of the child state's runtime shape.
+*
+* Primitive and nullish states use `injectAnnotations()`, clone-based object
+* delegation is tracked so it can be normalized back out later, and non-plain
+* objects use an annotation-view proxy so class invariants such as private
+* fields remain intact.
+*
+* @param parentState The state carrying the annotations to delegate.
+* @param childState The child state that should observe those annotations.
+* @returns A delegated child state that exposes the parent's annotations.
+* @internal
+*/
+function getDelegatedAnnotationState(parentState, childState) {
+	const annotations = getAnnotations(parentState);
+	if (annotations === void 0) return childState;
+	if (isInjectedAnnotationWrapper(childState)) return injectAnnotations(normalizeInjectedAnnotationState(childState), annotations);
+	if (childState == null || typeof childState !== "object") return injectAnnotations(childState, annotations);
+	if (getAnnotations(childState) === annotations && (delegatedAnnotationCloneTargets.has(childState) || annotationViewTargets.has(childState))) return childState;
+	if (isNonPlainDelegatedObject(childState)) return withAnnotationView(childState, annotations);
+	return inheritDelegatedAnnotations(parentState, childState);
+}
+/**
+* Returns whether a state is still at the initial sentinel after normalizing
+* Optique's injected annotation wrapper.
+*
+* This treats plain `undefined` and annotation-wrapped `undefined` the same.
+*
+* @param state The parser state to inspect.
+* @returns `true` when the normalized state is still `undefined`;
+*          otherwise `false`.
+* @internal
+*/
+function isAnnotationWrappedInitialState(state) {
+	return normalizeInjectedAnnotationState(state) === void 0;
+}
+/**
+* Propagates parent annotations into a child parse state when the child parser
+* explicitly opts into parent annotation inheritance.
+*
+* @param parentState The parent parser state that may carry annotations.
+* @param childState The child parse state that may receive inherited
+*                   annotations.
+* @param parser The child parser whose inheritance marker controls whether
+*               wrapper injection is allowed.
+* @returns The original child state when no injection is needed or possible,
+*          or an annotation-injected child state that preserves the original
+*          sentinel or object shape when inheritance applies.
+* @internal
+*/
+function getWrappedChildParseState(parentState, childState, parser) {
+	const annotations = getAnnotations(parentState);
+	const shouldInheritAnnotations = Reflect.get(parser, inheritParentAnnotationsKey) === true;
+	if (childState == null) {
+		if (annotations !== void 0 && shouldInheritAnnotations) return injectAnnotations(childState, annotations);
+		return childState;
+	}
+	if (annotations === void 0 || typeof childState !== "object" || getAnnotations(childState) === annotations || !shouldInheritAnnotations) return childState;
+	const injectedState = injectAnnotations(childState, annotations);
+	return getAnnotations(injectedState) === annotations ? injectedState : childState;
+}
+/**
+* Propagates parent annotations into a child state while preserving the child
+* state's shape for parsers that do not opt into full wrapper injection.
+*
+* @param parentState The parent parser state that may carry annotations.
+* @param childState The child state that may receive inherited annotations.
+* @param parser The child parser whose inheritance marker controls whether
+*               full wrapper injection is allowed.
+* @returns The original child state when no wrapping is needed, an
+*          annotation-injected child state when inheritance applies, or an
+*          annotation-view proxy that preserves the child's object shape.
+* @internal
+*/
+function getWrappedChildState(parentState, childState, parser) {
+	const annotations = getAnnotations(parentState);
+	const shouldInheritAnnotations = Reflect.get(parser, inheritParentAnnotationsKey) === true;
+	if (childState == null) {
+		if (annotations !== void 0 && shouldInheritAnnotations) return injectAnnotations(childState, annotations);
+		return childState;
+	}
+	if (annotations === void 0 || typeof childState !== "object" || getAnnotations(childState) === annotations) return childState;
+	if (shouldInheritAnnotations) {
+		const injectedState = injectAnnotations(childState, annotations);
+		if (getAnnotations(injectedState) === annotations) return injectedState;
+	}
+	return withAnnotationView(childState, annotations);
+}
+/**
+* Reconciles object-owned child state with parent annotations using the same
+* shared object-state inheritance rule across parser families.
+*
+* @param parentState The parent parser state that may carry annotations.
+* @param childState The object-owned child state to reconcile.
+* @returns The original child state when no reconciliation is needed, or a
+*          child state with inherited annotations when the object state should
+*          carry the parent's annotations.
+* @internal
+*/
+function reconcileObjectChildState(parentState, childState) {
+	const annotations = getAnnotations(parentState);
+	if (annotations === void 0 || childState == null || typeof childState !== "object" || getAnnotations(childState) === annotations) return childState;
+	return inheritAnnotations(parentState, childState);
+}
+
+//#endregion
+export { annotationViewTargets, getDelegatedAnnotationState, getWrappedChildParseState, getWrappedChildState, hasDelegatedAnnotationCarrier, isAnnotationWrappedInitialState, normalizeDelegatedAnnotationState, normalizeInjectedAnnotationState, normalizeNestedDelegatedAnnotationState, reconcileObjectChildState, unwrapAnnotationView, withAnnotationView };

package/dist/annotations.cjs

@@ -1,249 +1,3 @@
+const require_annotations = require('./internal/annotations.cjs');
 
-//#region src/annotations.ts
-/**
-* Runtime context extension system for Optique parsers.
-*
-* This module provides the annotations system that allows external runtime data
-* to be passed to parsers during the parsing session. This enables use cases like
-* config file fallbacks, environment-based validation, and shared context.
-*
-* @module
-* @since 0.10.0
-*/
-/**
-* Annotation key symbol for storing data in parser state.
-* @since 0.10.0
-*/
-const annotationKey = Symbol.for("@optique/core/parser/annotation");
-/**
-* Internal marker attached during the first pass of `runWith()` so wrappers
-* with side effects can defer work until dynamic contexts have resolved.
-*
-* @internal
-*/
-const firstPassAnnotationKey = Symbol.for("@optique/core/parser/firstPass");
-/**
-* Internal key for preserving primitive parser state values when annotations
-* are injected into non-object states.
-* @internal
-*/
-const annotationStateValueKey = Symbol.for("@optique/core/parser/annotationStateValue");
-/**
-* Internal marker key that indicates annotation wrapping was injected by
-* Optique internals for non-object states.
-* @internal
-*/
-const annotationWrapperKey = Symbol.for("@optique/core/parser/annotationWrapper");
-/**
-* Internal symbol keys that define Optique's primitive-state annotation
-* wrapper shape.
-* @internal
-*/
-const annotationWrapperKeys = new Set([
-	annotationKey,
-	annotationStateValueKey,
-	annotationWrapperKey
-]);
-const injectedAnnotationWrappers = /* @__PURE__ */ new WeakSet();
-/**
-* Extracts annotations from parser state.
-*
-* @param state Parser state that may contain annotations
-* @returns Annotations object or undefined if no annotations are present
-* @since 0.10.0
-*
-* @example
-* ```typescript
-* const annotations = getAnnotations(state);
-* const myData = annotations?.[myDataKey];
-* ```
-*/
-function getAnnotations(state) {
-	if (state == null || typeof state !== "object") return void 0;
-	const stateObj = state;
-	const annotations = stateObj[annotationKey];
-	if (annotations != null && typeof annotations === "object") return annotations;
-	return void 0;
-}
-/**
-* Reattaches annotations to a freshly created array state.
-*
-* Array spread copies elements but drops symbol properties, so parsers that
-* rebuild array states need to copy annotations back explicitly.
-*
-* @param source The original state that may carry annotations.
-* @param target The freshly created array state.
-* @returns The target array, with annotations copied when available.
-* @internal
-*/
-function annotateFreshArray(source, target) {
-	const annotations = getAnnotations(source);
-	if (annotations === void 0) return target;
-	const annotated = target;
-	annotated[annotationKey] = annotations;
-	return annotated;
-}
-/**
-* Propagates annotations from one parser state to another.
-*
-* This is mainly used by parsers that rebuild array states with spread syntax.
-* Array spread copies elements but drops custom symbol properties, so we need
-* to reattach annotations explicitly when present.
-*
-* @param source The original state that may carry annotations.
-* @param target The new state to receive annotations.
-* @returns The target state, with annotations copied when available.
-* @internal
-*/
-function inheritAnnotations(source, target) {
-	const annotations = getAnnotations(source);
-	if (annotations === void 0) return target;
-	if (target == null || typeof target !== "object") return injectAnnotations(target, annotations);
-	if (isInjectedAnnotationWrapper(target)) return injectAnnotations(target, annotations);
-	if (Array.isArray(target)) {
-		const cloned$1 = [...target];
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	if (target instanceof Date) {
-		const cloned$1 = new Date(target.getTime());
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	if (target instanceof Map) {
-		const cloned$1 = new Map(target);
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	if (target instanceof Set) {
-		const cloned$1 = new Set(target);
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	if (target instanceof RegExp) {
-		const cloned$1 = new RegExp(target);
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	if (Object.getPrototypeOf(target) !== Object.prototype && Object.getPrototypeOf(target) !== null) return target;
-	const cloned = Object.create(Object.getPrototypeOf(target), Object.getOwnPropertyDescriptors(target));
-	cloned[annotationKey] = annotations;
-	return cloned;
-}
-/**
-* Injects annotations into parser state while preserving state shape.
-*
-* - Primitive, null, and undefined states are wrapped with internal metadata.
-* - Array states are cloned and annotated without mutating the original.
-* - Plain object states are shallow-cloned with annotations attached.
-* - Built-in object states (Date/Map/Set/RegExp) are cloned by constructor.
-* - Other non-plain object states are cloned via prototype/descriptors.
-*
-* @param state The parser state to annotate.
-* @param annotations The annotations to inject.
-* @returns Annotated state.
-* @internal
-*/
-function injectAnnotations(state, annotations) {
-	if (state == null || typeof state !== "object") {
-		const wrapper = {};
-		Object.defineProperties(wrapper, {
-			[annotationKey]: {
-				value: annotations,
-				enumerable: true,
-				writable: true,
-				configurable: true
-			},
-			[annotationStateValueKey]: {
-				value: state,
-				enumerable: false,
-				writable: true,
-				configurable: true
-			},
-			[annotationWrapperKey]: {
-				value: true,
-				enumerable: false,
-				writable: true,
-				configurable: true
-			}
-		});
-		injectedAnnotationWrappers.add(wrapper);
-		return wrapper;
-	}
-	if (Array.isArray(state)) {
-		const cloned$1 = [...state];
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	if (isInjectedAnnotationWrapper(state)) {
-		state[annotationKey] = annotations;
-		return state;
-	}
-	if (state instanceof Date) {
-		const cloned$1 = new Date(state.getTime());
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	if (state instanceof Map) {
-		const cloned$1 = new Map(state);
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	if (state instanceof Set) {
-		const cloned$1 = new Set(state);
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	if (state instanceof RegExp) {
-		const cloned$1 = new RegExp(state);
-		cloned$1[annotationKey] = annotations;
-		return cloned$1;
-	}
-	const proto = Object.getPrototypeOf(state);
-	if (proto === Object.prototype || proto === null) return {
-		...state,
-		[annotationKey]: annotations
-	};
-	const cloned = Object.create(proto, Object.getOwnPropertyDescriptors(state));
-	cloned[annotationKey] = annotations;
-	return cloned;
-}
-/**
-* Unwraps a primitive-state annotation wrapper injected by Optique internals.
-*
-* @param value Value to potentially unwrap.
-* @returns The unwrapped primitive value when the input is an injected wrapper;
-*          otherwise the original value.
-* @internal
-*/
-function unwrapInjectedAnnotationWrapper(value) {
-	if (value == null || typeof value !== "object") return value;
-	const valueRecord = value;
-	if (valueRecord[annotationWrapperKey] !== true) return value;
-	const ownKeys = Reflect.ownKeys(valueRecord);
-	if (ownKeys.length === 3 && ownKeys.every((key) => annotationWrapperKeys.has(key)) && isInjectedAnnotationWrapper(value)) return valueRecord[annotationStateValueKey];
-	return value;
-}
-/**
-* Returns whether the given value is an internal primitive-state annotation
-* wrapper that was injected by Optique.
-*
-* @param value Value to check.
-* @returns `true` if the value is an injected internal wrapper.
-* @internal
-*/
-function isInjectedAnnotationWrapper(value) {
-	return value != null && typeof value === "object" && injectedAnnotationWrappers.has(value);
-}
-
-//#endregion
-exports.annotateFreshArray = annotateFreshArray;
-exports.annotationKey = annotationKey;
-exports.annotationStateValueKey = annotationStateValueKey;
-exports.annotationWrapperKey = annotationWrapperKey;
-exports.firstPassAnnotationKey = firstPassAnnotationKey;
-exports.getAnnotations = getAnnotations;
-exports.inheritAnnotations = inheritAnnotations;
-exports.injectAnnotations = injectAnnotations;
-exports.isInjectedAnnotationWrapper = isInjectedAnnotationWrapper;
-exports.unwrapInjectedAnnotationWrapper = unwrapInjectedAnnotationWrapper;
+exports.getAnnotations = require_annotations.getAnnotations;