@blac/core 2.0.13 → 2.0.14

package/dist/resolve-dependencies-Dd8T6TLt.cjs

@@ -1,774 +1,832 @@
-const require_StateContainerRegistry = require("./StateContainerRegistry-CDH9mnQS.cjs");
-const require_config = require("./config-DEcslxan.cjs");
+const require_StateContainerRegistry = require('./StateContainerRegistry-CDH9mnQS.cjs');
+const require_config = require('./config-DEcslxan.cjs');
 //#region src/tracking/path-utils.ts
 /**
-* Path utilities for dependency tracking
-*
-* Provides utilities for parsing property paths and extracting values
-* from nested objects using path strings.
-*
-* @internal
-*/
-/**
-* Parse a property path string into an array of segments
-*
-* @internal
-*
-* Handles both dot notation (a.b.c) and bracket notation (a[0].b)
-*
-* @example
-* ```ts
-* parsePath('user.name') // ['user', 'name']
-* parsePath('items[0].name') // ['items', '0', 'name']
-* parsePath('data.users[2].address.city') // ['data', 'users', '2', 'address', 'city']
-* ```
-*/
+ * Path utilities for dependency tracking
+ *
+ * Provides utilities for parsing property paths and extracting values
+ * from nested objects using path strings.
+ *
+ * @internal
+ */
+/**
+ * Parse a property path string into an array of segments
+ *
+ * @internal
+ *
+ * Handles both dot notation (a.b.c) and bracket notation (a[0].b)
+ *
+ * @example
+ * ```ts
+ * parsePath('user.name') // ['user', 'name']
+ * parsePath('items[0].name') // ['items', '0', 'name']
+ * parsePath('data.users[2].address.city') // ['data', 'users', '2', 'address', 'city']
+ * ```
+ */
 function parsePath(path) {
-	const segments = [];
-	let current = "";
-	let i = 0;
-	while (i < path.length) {
-		const char = path[i];
-		if (char === ".") {
-			if (current) segments.push(current);
-			current = "";
-		} else if (char === "[") {
-			if (current) segments.push(current);
-			current = "";
-			i++;
-			while (i < path.length && path[i] !== "]") current += path[i++];
-			if (current) segments.push(current);
-			current = "";
-		} else current += char;
-		i++;
-	}
-	if (current) segments.push(current);
-	return segments;
-}
-/**
-* Get a value from an object using a path of segments
-*
-* @example
-* ```ts
-* const obj = { user: { name: 'Alice', age: 30 } }
-* getValueAtPath(obj, ['user', 'name']) // 'Alice'
-* getValueAtPath(obj, ['user', 'age']) // 30
-* getValueAtPath(obj, ['user', 'missing']) // undefined
-* ```
-*
-* @internal
-*/
+  const segments = [];
+  let current = '';
+  let i = 0;
+  while (i < path.length) {
+    const char = path[i];
+    if (char === '.') {
+      if (current) segments.push(current);
+      current = '';
+    } else if (char === '[') {
+      if (current) segments.push(current);
+      current = '';
+      i++;
+      while (i < path.length && path[i] !== ']') current += path[i++];
+      if (current) segments.push(current);
+      current = '';
+    } else current += char;
+    i++;
+  }
+  if (current) segments.push(current);
+  return segments;
+}
+/**
+ * Get a value from an object using a path of segments
+ *
+ * @example
+ * ```ts
+ * const obj = { user: { name: 'Alice', age: 30 } }
+ * getValueAtPath(obj, ['user', 'name']) // 'Alice'
+ * getValueAtPath(obj, ['user', 'age']) // 30
+ * getValueAtPath(obj, ['user', 'missing']) // undefined
+ * ```
+ *
+ * @internal
+ */
 function getValueAtPath(obj, segments) {
-	if (obj == null) return void 0;
-	let current = obj;
-	for (let i = 0; i < segments.length; i++) {
-		current = current[segments[i]];
-		if (current == null) return void 0;
-	}
-	return current;
-}
-/**
-* Shallow equality comparison for arrays
-*
-* Compares two arrays element-by-element using Object.is
-*
-* @example
-* ```ts
-* shallowEqual([1, 2, 3], [1, 2, 3]) // true
-* shallowEqual([1, 2, 3], [1, 2, 4]) // false
-* shallowEqual([1, 2], [1, 2, 3]) // false
-* ```
-*
-* @internal
-*/
+  if (obj == null) return void 0;
+  let current = obj;
+  for (let i = 0; i < segments.length; i++) {
+    current = current[segments[i]];
+    if (current == null) return void 0;
+  }
+  return current;
+}
+/**
+ * Shallow equality comparison for arrays
+ *
+ * Compares two arrays element-by-element using Object.is
+ *
+ * @example
+ * ```ts
+ * shallowEqual([1, 2, 3], [1, 2, 3]) // true
+ * shallowEqual([1, 2, 3], [1, 2, 4]) // false
+ * shallowEqual([1, 2], [1, 2, 3]) // false
+ * ```
+ *
+ * @internal
+ */
 function shallowEqual(arr1, arr2) {
-	if (arr1.length !== arr2.length) return false;
-	for (let i = 0; i < arr1.length; i++) if (!Object.is(arr1[i], arr2[i])) return false;
-	return true;
+  if (arr1.length !== arr2.length) return false;
+  for (let i = 0; i < arr1.length; i++)
+    if (!Object.is(arr1[i], arr2[i])) return false;
+  return true;
 }
 //#endregion
 //#region src/tracking/tracking-proxy.ts
 /**
-* Consolidated Tracking System
-*
-* This module provides all dependency and getter tracking functionality:
-* - Proxy creation for automatic property access tracking
-* - Dependency path tracking and change detection
-* - Getter execution tracking for computed properties
-* - Combined tracking proxy for watch/waitUntil use cases
-*/
-/**
-* Check if a value can be proxied
-* Returns true for plain objects and arrays only.
-* @internal
-*/
+ * Consolidated Tracking System
+ *
+ * This module provides all dependency and getter tracking functionality:
+ * - Proxy creation for automatic property access tracking
+ * - Dependency path tracking and change detection
+ * - Getter execution tracking for computed properties
+ * - Combined tracking proxy for watch/waitUntil use cases
+ */
+/**
+ * Check if a value can be proxied
+ * Returns true for plain objects and arrays only.
+ * @internal
+ */
 function isProxyable(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === Array.prototype;
+  if (typeof value !== 'object' || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === Array.prototype;
 }
 /**
-* Create a new proxy tracker state
-* @internal
-*/
+ * Create a new proxy tracker state
+ * @internal
+ */
 function createProxyState() {
-	return {
-		trackedPaths: /* @__PURE__ */ new Set(),
-		isTracking: false,
-		proxyCache: /* @__PURE__ */ new WeakMap(),
-		boundFunctionsCache: null,
-		lastProxiedState: null,
-		lastProxy: null,
-		maxDepth: 10
-	};
-}
-/**
-* Start tracking property accesses
-* @internal
-*/
+  return {
+    trackedPaths: /* @__PURE__ */ new Set(),
+    isTracking: false,
+    proxyCache: /* @__PURE__ */ new WeakMap(),
+    boundFunctionsCache: null,
+    lastProxiedState: null,
+    lastProxy: null,
+    maxDepth: 10,
+  };
+}
+/**
+ * Start tracking property accesses
+ * @internal
+ */
 function startProxy(state) {
-	state.isTracking = true;
-	state.trackedPaths.clear();
+  state.isTracking = true;
+  state.trackedPaths.clear();
 }
 /**
-* Stop tracking and return the tracked paths
-* @internal
-*/
+ * Stop tracking and return the tracked paths
+ * @internal
+ */
 function stopProxy(state) {
-	state.isTracking = false;
-	return new Set(state.trackedPaths);
+  state.isTracking = false;
+  return new Set(state.trackedPaths);
 }
 /**
-* Create a proxy for an array with property access tracking
-* @internal
-*/
+ * Create a proxy for an array with property access tracking
+ * @internal
+ */
 function createArrayProxy(state, target, path, depth = 0) {
-	const proxy = new Proxy(target, { get: (arr, prop) => {
-		if (typeof prop === "symbol") return Reflect.get(arr, prop);
-		const value = Reflect.get(arr, prop);
-		if (typeof value === "function") {
-			if (!state.boundFunctionsCache) state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
-			const cached = state.boundFunctionsCache.get(value);
-			if (cached) return cached;
-			const bound = value.bind(arr);
-			state.boundFunctionsCache.set(value, bound);
-			return bound;
-		}
-		if (prop === "length") {
-			if (state.isTracking) {
-				const fullPath = path ? `${path}.length` : "length";
-				state.trackedPaths.add(fullPath);
-			}
-			return value;
-		}
-		let fullPath;
-		if (typeof prop === "string") {
-			const index = Number(prop);
-			if (!isNaN(index) && index >= 0) fullPath = path ? `${path}[${index}]` : `[${index}]`;
-			else fullPath = path ? `${path}.${prop}` : prop;
-		} else return value;
-		if (isProxyable(value)) return createInternal(state, value, fullPath, depth + 1);
-		if (state.isTracking) state.trackedPaths.add(fullPath);
-		return value;
-	} });
-	state.proxyCache.set(target, proxy);
-	return proxy;
-}
-/**
-* Create a proxy for an object with property access tracking
-* @internal
-*/
-function createInternal(state, target, path = "", depth = 0) {
-	if (!state.isTracking || !isProxyable(target)) return target;
-	if (depth >= state.maxDepth) {
-		console.warn(`${require_StateContainerRegistry.BLAC_ERROR_PREFIX} Proxy depth limit (${state.maxDepth}) reached at path "${path}". Deeper property accesses won't be tracked for re-renders.`);
-		return target;
-	}
-	if (state.proxyCache.has(target)) return state.proxyCache.get(target);
-	if (Array.isArray(target)) return createArrayProxy(state, target, path, depth);
-	const proxy = new Proxy(target, {
-		get: (obj, prop) => {
-			if (typeof prop === "symbol") return Reflect.get(obj, prop);
-			const value = Reflect.get(obj, prop);
-			if (typeof value === "function") {
-				if (!state.boundFunctionsCache) state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
-				const cached = state.boundFunctionsCache.get(value);
-				if (cached) return cached;
-				const bound = value.bind(obj);
-				state.boundFunctionsCache.set(value, bound);
-				return bound;
-			}
-			const fullPath = path ? `${path}.${String(prop)}` : String(prop);
-			if (typeof prop === "string" && state.isTracking) {
-				if (!prop.startsWith("_") && !prop.startsWith("$$")) state.trackedPaths.add(fullPath);
-			}
-			if (isProxyable(value)) return createInternal(state, value, fullPath, depth + 1);
-			return value;
-		},
-		has: (obj, prop) => {
-			if (typeof prop === "string" && state.isTracking) {
-				const fullPath = path ? `${path}.${prop}` : prop;
-				state.trackedPaths.add(fullPath);
-			}
-			return Reflect.has(obj, prop);
-		},
-		ownKeys: (obj) => {
-			if (state.isTracking && path) state.trackedPaths.add(path);
-			return Reflect.ownKeys(obj);
-		}
-	});
-	state.proxyCache.set(target, proxy);
-	return proxy;
-}
-/**
-* Create a proxy for a target with caching
-* @internal
-*/
+  const proxy = new Proxy(target, {
+    get: (arr, prop) => {
+      if (typeof prop === 'symbol') return Reflect.get(arr, prop);
+      const value = Reflect.get(arr, prop);
+      if (typeof value === 'function') {
+        if (!state.boundFunctionsCache)
+          state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
+        const cached = state.boundFunctionsCache.get(value);
+        if (cached) return cached;
+        const bound = value.bind(arr);
+        state.boundFunctionsCache.set(value, bound);
+        return bound;
+      }
+      if (prop === 'length') {
+        if (state.isTracking) {
+          const fullPath = path ? `${path}.length` : 'length';
+          state.trackedPaths.add(fullPath);
+        }
+        return value;
+      }
+      let fullPath;
+      if (typeof prop === 'string') {
+        const index = Number(prop);
+        if (!isNaN(index) && index >= 0)
+          fullPath = path ? `${path}[${index}]` : `[${index}]`;
+        else fullPath = path ? `${path}.${prop}` : prop;
+      } else return value;
+      if (isProxyable(value))
+        return createInternal(state, value, fullPath, depth + 1);
+      if (state.isTracking) state.trackedPaths.add(fullPath);
+      return value;
+    },
+  });
+  state.proxyCache.set(target, proxy);
+  return proxy;
+}
+/**
+ * Create a proxy for an object with property access tracking
+ * @internal
+ */
+function createInternal(state, target, path = '', depth = 0) {
+  if (!state.isTracking || !isProxyable(target)) return target;
+  if (depth >= state.maxDepth) {
+    console.warn(
+      `${require_StateContainerRegistry.BLAC_ERROR_PREFIX} Proxy depth limit (${state.maxDepth}) reached at path "${path}". Deeper property accesses won't be tracked for re-renders.`,
+    );
+    return target;
+  }
+  if (state.proxyCache.has(target)) return state.proxyCache.get(target);
+  if (Array.isArray(target))
+    return createArrayProxy(state, target, path, depth);
+  const proxy = new Proxy(target, {
+    get: (obj, prop) => {
+      if (typeof prop === 'symbol') return Reflect.get(obj, prop);
+      const value = Reflect.get(obj, prop);
+      if (typeof value === 'function') {
+        if (!state.boundFunctionsCache)
+          state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
+        const cached = state.boundFunctionsCache.get(value);
+        if (cached) return cached;
+        const bound = value.bind(obj);
+        state.boundFunctionsCache.set(value, bound);
+        return bound;
+      }
+      const fullPath = path ? `${path}.${String(prop)}` : String(prop);
+      if (typeof prop === 'string' && state.isTracking) {
+        if (!prop.startsWith('_') && !prop.startsWith('$$'))
+          state.trackedPaths.add(fullPath);
+      }
+      if (isProxyable(value))
+        return createInternal(state, value, fullPath, depth + 1);
+      return value;
+    },
+    has: (obj, prop) => {
+      if (typeof prop === 'string' && state.isTracking) {
+        const fullPath = path ? `${path}.${prop}` : prop;
+        state.trackedPaths.add(fullPath);
+      }
+      return Reflect.has(obj, prop);
+    },
+    ownKeys: (obj) => {
+      if (state.isTracking && path) state.trackedPaths.add(path);
+      return Reflect.ownKeys(obj);
+    },
+  });
+  state.proxyCache.set(target, proxy);
+  return proxy;
+}
+/**
+ * Create a proxy for a target with caching
+ * @internal
+ */
 function createForTarget(state, target) {
-	if (state.lastProxiedState === target && state.lastProxy) return state.lastProxy;
-	state.proxyCache = /* @__PURE__ */ new WeakMap();
-	state.boundFunctionsCache = null;
-	const proxy = createInternal(state, target, "", 0);
-	state.lastProxiedState = target;
-	state.lastProxy = proxy;
-	return proxy;
+  if (state.lastProxiedState === target && state.lastProxy)
+    return state.lastProxy;
+  state.proxyCache = /* @__PURE__ */ new WeakMap();
+  state.boundFunctionsCache = null;
+  const proxy = createInternal(state, target, '', 0);
+  state.lastProxiedState = target;
+  state.lastProxy = proxy;
+  return proxy;
 }
 function isChildPath(child, parent) {
-	if (child === parent) return false;
-	return child.startsWith(parent + ".") || child.startsWith(parent + "[");
+  if (child === parent) return false;
+  return child.startsWith(parent + '.') || child.startsWith(parent + '[');
 }
 function getArrayParentPath(path) {
-	if (path.endsWith(".length")) return path.slice(0, -7);
-	const arrayIndexMatch = path.match(/^(.+?)\[\d+\]/);
-	if (arrayIndexMatch) return arrayIndexMatch[1];
-	return null;
+  if (path.endsWith('.length')) return path.slice(0, -7);
+  const arrayIndexMatch = path.match(/^(.+?)\[\d+\]/);
+  if (arrayIndexMatch) return arrayIndexMatch[1];
+  return null;
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function optimizeTrackedPaths(paths) {
-	if (paths.size === 0) return /* @__PURE__ */ new Set();
-	if (paths.size === 1) return new Set(paths);
-	const sortedPaths = Array.from(paths).sort((a, b) => b.length - a.length);
-	const optimized = /* @__PURE__ */ new Set();
-	for (const path of sortedPaths) {
-		let hasMoreSpecificChild = false;
-		for (const optimizedPath of optimized) if (isChildPath(optimizedPath, path)) {
-			hasMoreSpecificChild = true;
-			break;
-		}
-		if (!hasMoreSpecificChild) optimized.add(path);
-	}
-	const arrayParents = /* @__PURE__ */ new Set();
-	for (const path of optimized) {
-		const arrayParent = getArrayParentPath(path);
-		if (arrayParent) arrayParents.add(arrayParent);
-	}
-	for (const arrayParent of arrayParents) optimized.add(arrayParent);
-	return optimized;
-}
-/**
-* @internal
-*/
+  if (paths.size === 0) return /* @__PURE__ */ new Set();
+  if (paths.size === 1) return new Set(paths);
+  const sortedPaths = Array.from(paths).sort((a, b) => b.length - a.length);
+  const optimized = /* @__PURE__ */ new Set();
+  for (const path of sortedPaths) {
+    let hasMoreSpecificChild = false;
+    for (const optimizedPath of optimized)
+      if (isChildPath(optimizedPath, path)) {
+        hasMoreSpecificChild = true;
+        break;
+      }
+    if (!hasMoreSpecificChild) optimized.add(path);
+  }
+  const arrayParents = /* @__PURE__ */ new Set();
+  for (const path of optimized) {
+    const arrayParent = getArrayParentPath(path);
+    if (arrayParent) arrayParents.add(arrayParent);
+  }
+  for (const arrayParent of arrayParents) optimized.add(arrayParent);
+  return optimized;
+}
+/**
+ * @internal
+ */
 function createDependencyState() {
-	return {
-		proxyState: createProxyState(),
-		previousRenderPaths: /* @__PURE__ */ new Set(),
-		currentRenderPaths: /* @__PURE__ */ new Set(),
-		pathCache: /* @__PURE__ */ new Map(),
-		lastCheckedState: null,
-		lastCheckedValues: /* @__PURE__ */ new Map()
-	};
-}
-/**
-* @internal
-*/
+  return {
+    proxyState: createProxyState(),
+    previousRenderPaths: /* @__PURE__ */ new Set(),
+    currentRenderPaths: /* @__PURE__ */ new Set(),
+    pathCache: /* @__PURE__ */ new Map(),
+    lastCheckedState: null,
+    lastCheckedValues: /* @__PURE__ */ new Map(),
+  };
+}
+/**
+ * @internal
+ */
 function startDependency(tracker) {
-	startProxy(tracker.proxyState);
+  startProxy(tracker.proxyState);
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function createDependencyProxy(tracker, state) {
-	return createForTarget(tracker.proxyState, state);
+  return createForTarget(tracker.proxyState, state);
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function capturePaths(tracker, state) {
-	tracker.previousRenderPaths = tracker.currentRenderPaths;
-	tracker.currentRenderPaths = optimizeTrackedPaths(stopProxy(tracker.proxyState));
-	if (tracker.previousRenderPaths.size === 0 && tracker.currentRenderPaths.size === 0) return;
-	const trackedPathsUnion = new Set(tracker.previousRenderPaths);
-	for (const path of tracker.currentRenderPaths) trackedPathsUnion.add(path);
-	const canReuseCache = tracker.lastCheckedState === state;
-	for (const path of trackedPathsUnion) if (!tracker.pathCache.has(path)) {
-		const segments = parsePath(path);
-		const value = canReuseCache && tracker.lastCheckedValues.has(path) ? tracker.lastCheckedValues.get(path) : getValueAtPath(state, segments);
-		tracker.pathCache.set(path, {
-			segments,
-			value
-		});
-	} else {
-		const info = tracker.pathCache.get(path);
-		if (!info) continue;
-		info.value = canReuseCache && tracker.lastCheckedValues.has(path) ? tracker.lastCheckedValues.get(path) : getValueAtPath(state, info.segments);
-	}
-	tracker.lastCheckedValues.clear();
-}
-/**
-* @internal
-*/
+  tracker.previousRenderPaths = tracker.currentRenderPaths;
+  tracker.currentRenderPaths = optimizeTrackedPaths(
+    stopProxy(tracker.proxyState),
+  );
+  if (
+    tracker.previousRenderPaths.size === 0 &&
+    tracker.currentRenderPaths.size === 0
+  )
+    return;
+  const trackedPathsUnion = new Set(tracker.previousRenderPaths);
+  for (const path of tracker.currentRenderPaths) trackedPathsUnion.add(path);
+  const canReuseCache = tracker.lastCheckedState === state;
+  for (const path of trackedPathsUnion)
+    if (!tracker.pathCache.has(path)) {
+      const segments = parsePath(path);
+      const value =
+        canReuseCache && tracker.lastCheckedValues.has(path)
+          ? tracker.lastCheckedValues.get(path)
+          : getValueAtPath(state, segments);
+      tracker.pathCache.set(path, {
+        segments,
+        value,
+      });
+    } else {
+      const info = tracker.pathCache.get(path);
+      if (!info) continue;
+      info.value =
+        canReuseCache && tracker.lastCheckedValues.has(path)
+          ? tracker.lastCheckedValues.get(path)
+          : getValueAtPath(state, info.segments);
+    }
+  tracker.lastCheckedValues.clear();
+}
+/**
+ * @internal
+ */
 function hasDependencyChanges(tracker, state) {
-	if (tracker.pathCache.size === 0) return true;
-	tracker.lastCheckedValues.clear();
-	for (const [path, info] of tracker.pathCache.entries()) {
-		const currentValue = getValueAtPath(state, info.segments);
-		tracker.lastCheckedValues.set(path, currentValue);
-		if (!Object.is(currentValue, info.value)) {
-			tracker.lastCheckedState = state;
-			return true;
-		}
-	}
-	tracker.lastCheckedState = state;
-	return false;
-}
-/**
-* @internal
-*/
+  if (tracker.pathCache.size === 0) return true;
+  tracker.lastCheckedValues.clear();
+  for (const [path, info] of tracker.pathCache.entries()) {
+    const currentValue = getValueAtPath(state, info.segments);
+    tracker.lastCheckedValues.set(path, currentValue);
+    if (!Object.is(currentValue, info.value)) {
+      tracker.lastCheckedState = state;
+      return true;
+    }
+  }
+  tracker.lastCheckedState = state;
+  return false;
+}
+/**
+ * @internal
+ */
 function hasTrackedData(tracker) {
-	return tracker.proxyState.trackedPaths.size > 0 || tracker.pathCache.size > 0 || tracker.previousRenderPaths.size > 0;
+  return (
+    tracker.proxyState.trackedPaths.size > 0 ||
+    tracker.pathCache.size > 0 ||
+    tracker.previousRenderPaths.size > 0
+  );
 }
 const descriptorCache = /* @__PURE__ */ new WeakMap();
 const blocProxyCache = /* @__PURE__ */ new WeakMap();
 const activeTrackerMap = /* @__PURE__ */ new WeakMap();
-const MAX_GETTER_DEPTH = require_StateContainerRegistry.BLAC_DEFAULTS.MAX_GETTER_DEPTH;
+const MAX_GETTER_DEPTH =
+  require_StateContainerRegistry.BLAC_DEFAULTS.MAX_GETTER_DEPTH;
 /**
-* @internal
-*/
+ * @internal
+ */
 function getDescriptor(obj, prop) {
-	const constructor = obj.constructor;
-	let constructorCache = descriptorCache.get(constructor);
-	if (constructorCache?.has(prop)) return constructorCache.get(prop);
-	let current = obj;
-	let descriptor;
-	while (current && current !== Object.prototype) {
-		descriptor = Object.getOwnPropertyDescriptor(current, prop);
-		if (descriptor) break;
-		current = Object.getPrototypeOf(current);
-	}
-	if (!constructorCache) {
-		constructorCache = /* @__PURE__ */ new Map();
-		descriptorCache.set(constructor, constructorCache);
-	}
-	constructorCache.set(prop, descriptor);
-	return descriptor;
-}
-/**
-* @internal
-*/
+  const constructor = obj.constructor;
+  let constructorCache = descriptorCache.get(constructor);
+  if (constructorCache?.has(prop)) return constructorCache.get(prop);
+  let current = obj;
+  let descriptor;
+  while (current && current !== Object.prototype) {
+    descriptor = Object.getOwnPropertyDescriptor(current, prop);
+    if (descriptor) break;
+    current = Object.getPrototypeOf(current);
+  }
+  if (!constructorCache) {
+    constructorCache = /* @__PURE__ */ new Map();
+    descriptorCache.set(constructor, constructorCache);
+  }
+  constructorCache.set(prop, descriptor);
+  return descriptor;
+}
+/**
+ * @internal
+ */
 function isGetter(obj, prop) {
-	return getDescriptor(obj, prop)?.get !== void 0;
+  return getDescriptor(obj, prop)?.get !== void 0;
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function createGetterState() {
-	return {
-		trackedValues: /* @__PURE__ */ new Map(),
-		currentlyAccessing: /* @__PURE__ */ new Set(),
-		trackedGetters: /* @__PURE__ */ new Set(),
-		isTracking: false,
-		renderCache: /* @__PURE__ */ new Map(),
-		cacheValid: false,
-		depth: 0,
-		visitedBlocs: /* @__PURE__ */ new Set()
-	};
-}
-/**
-* @internal
-*/
+  return {
+    trackedValues: /* @__PURE__ */ new Map(),
+    currentlyAccessing: /* @__PURE__ */ new Set(),
+    trackedGetters: /* @__PURE__ */ new Set(),
+    isTracking: false,
+    renderCache: /* @__PURE__ */ new Map(),
+    cacheValid: false,
+    depth: 0,
+    visitedBlocs: /* @__PURE__ */ new Set(),
+  };
+}
+/**
+ * @internal
+ */
 function setActiveTracker(bloc, tracker) {
-	activeTrackerMap.set(bloc, tracker);
+  activeTrackerMap.set(bloc, tracker);
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function clearActiveTracker(bloc) {
-	activeTrackerMap.delete(bloc);
+  activeTrackerMap.delete(bloc);
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function commitTrackedGetters(tracker) {
-	if (tracker.currentlyAccessing.size > 0) tracker.trackedGetters = new Set(tracker.currentlyAccessing);
-	tracker.currentlyAccessing.clear();
+  if (tracker.currentlyAccessing.size > 0)
+    tracker.trackedGetters = new Set(tracker.currentlyAccessing);
+  tracker.currentlyAccessing.clear();
 }
 /**
-* Execute a tracked getter with depth/circular dependency checks and context management.
-* @internal
-*/
+ * Execute a tracked getter with depth/circular dependency checks and context management.
+ * @internal
+ */
 function executeTrackedGetter(target, prop, tracker) {
-	tracker.currentlyAccessing.add(prop);
-	if (tracker.cacheValid && tracker.renderCache.has(prop)) {
-		const cachedValue = tracker.renderCache.get(prop);
-		tracker.trackedValues.set(prop, cachedValue);
-		return cachedValue;
-	}
-	if (tracker.depth >= MAX_GETTER_DEPTH) throw new Error(`${require_StateContainerRegistry.BLAC_ERROR_PREFIX} Maximum getter depth (${MAX_GETTER_DEPTH}) exceeded. Possible circular dependency in getter "${String(prop)}" on ${target.constructor.name}.`);
-	if (tracker.visitedBlocs.has(target)) throw new Error(`${require_StateContainerRegistry.BLAC_ERROR_PREFIX} Circular dependency detected: getter "${String(prop)}" on ${target.constructor.name}.`);
-	const prevDepth = tracker.depth;
-	const prevVisited = new Set(tracker.visitedBlocs);
-	tracker.depth++;
-	tracker.visitedBlocs.add(target);
-	try {
-		const descriptor = getDescriptor(target, prop);
-		if (!descriptor?.get) return target[prop];
-		const value = descriptor.get.call(target);
-		tracker.trackedValues.set(prop, value);
-		return value;
-	} catch (error) {
-		tracker.currentlyAccessing.delete(prop);
-		throw error;
-	} finally {
-		tracker.depth = prevDepth;
-		tracker.visitedBlocs = prevVisited;
-	}
-}
-/**
-* @internal
-*/
+  tracker.currentlyAccessing.add(prop);
+  if (tracker.cacheValid && tracker.renderCache.has(prop)) {
+    const cachedValue = tracker.renderCache.get(prop);
+    tracker.trackedValues.set(prop, cachedValue);
+    return cachedValue;
+  }
+  if (tracker.depth >= MAX_GETTER_DEPTH)
+    throw new Error(
+      `${require_StateContainerRegistry.BLAC_ERROR_PREFIX} Maximum getter depth (${MAX_GETTER_DEPTH}) exceeded. Possible circular dependency in getter "${String(prop)}" on ${target.constructor.name}.`,
+    );
+  if (tracker.visitedBlocs.has(target))
+    throw new Error(
+      `${require_StateContainerRegistry.BLAC_ERROR_PREFIX} Circular dependency detected: getter "${String(prop)}" on ${target.constructor.name}.`,
+    );
+  const prevDepth = tracker.depth;
+  const prevVisited = new Set(tracker.visitedBlocs);
+  tracker.depth++;
+  tracker.visitedBlocs.add(target);
+  try {
+    const descriptor = getDescriptor(target, prop);
+    if (!descriptor?.get) return target[prop];
+    const value = descriptor.get.call(target);
+    tracker.trackedValues.set(prop, value);
+    return value;
+  } catch (error) {
+    tracker.currentlyAccessing.delete(prop);
+    throw error;
+  } finally {
+    tracker.depth = prevDepth;
+    tracker.visitedBlocs = prevVisited;
+  }
+}
+/**
+ * @internal
+ */
 function createBlocProxy(bloc) {
-	const cached = blocProxyCache.get(bloc);
-	if (cached) return cached;
-	const proxy = new Proxy(bloc, { get(target, prop, receiver) {
-		const tracker = activeTrackerMap.get(target);
-		if (tracker?.isTracking && isGetter(target, prop)) return executeTrackedGetter(target, prop, tracker);
-		return Reflect.get(target, prop, receiver);
-	} });
-	blocProxyCache.set(bloc, proxy);
-	return proxy;
-}
-/**
-* @internal
-*/
+  const cached = blocProxyCache.get(bloc);
+  if (cached) return cached;
+  const proxy = new Proxy(bloc, {
+    get(target, prop, receiver) {
+      const tracker = activeTrackerMap.get(target);
+      if (tracker?.isTracking && isGetter(target, prop))
+        return executeTrackedGetter(target, prop, tracker);
+      return Reflect.get(target, prop, receiver);
+    },
+  });
+  blocProxyCache.set(bloc, proxy);
+  return proxy;
+}
+/**
+ * @internal
+ */
 function hasGetterChanges(bloc, tracker) {
-	if (!tracker || tracker.trackedGetters.size === 0) return false;
-	tracker.renderCache.clear();
-	let hasAnyChange = false;
-	for (const prop of tracker.trackedGetters) try {
-		const descriptor = getDescriptor(bloc, prop);
-		if (!descriptor?.get) continue;
-		const newValue = descriptor.get.call(bloc);
-		const oldValue = tracker.trackedValues.get(prop);
-		tracker.renderCache.set(prop, newValue);
-		tracker.trackedValues.set(prop, newValue);
-		if (!Object.is(newValue, oldValue)) hasAnyChange = true;
-	} catch (error) {
-		console.warn(`${require_StateContainerRegistry.BLAC_ERROR_PREFIX} Getter "${String(prop)}" threw error during change detection. Stopping tracking for this getter.`, error);
-		tracker.trackedGetters.delete(prop);
-		tracker.trackedValues.delete(prop);
-		tracker.cacheValid = false;
-		return true;
-	}
-	tracker.cacheValid = true;
-	return hasAnyChange;
-}
-/**
-* @internal
-*/
+  if (!tracker || tracker.trackedGetters.size === 0) return false;
+  tracker.renderCache.clear();
+  let hasAnyChange = false;
+  for (const prop of tracker.trackedGetters)
+    try {
+      const descriptor = getDescriptor(bloc, prop);
+      if (!descriptor?.get) continue;
+      const newValue = descriptor.get.call(bloc);
+      const oldValue = tracker.trackedValues.get(prop);
+      tracker.renderCache.set(prop, newValue);
+      tracker.trackedValues.set(prop, newValue);
+      if (!Object.is(newValue, oldValue)) hasAnyChange = true;
+    } catch (error) {
+      console.warn(
+        `${require_StateContainerRegistry.BLAC_ERROR_PREFIX} Getter "${String(prop)}" threw error during change detection. Stopping tracking for this getter.`,
+        error,
+      );
+      tracker.trackedGetters.delete(prop);
+      tracker.trackedValues.delete(prop);
+      tracker.cacheValid = false;
+      return true;
+    }
+  tracker.cacheValid = true;
+  return hasAnyChange;
+}
+/**
+ * @internal
+ */
 function invalidateRenderCache(tracker) {
-	tracker.cacheValid = false;
+  tracker.cacheValid = false;
 }
 /**
-* Create a new tracking proxy state.
-*/
+ * Create a new tracking proxy state.
+ */
 function createState() {
-	return {
-		dependencyState: createDependencyState(),
-		getterState: createGetterState(),
-		dependencies: /* @__PURE__ */ new Set(),
-		isTracking: false
-	};
+  return {
+    dependencyState: createDependencyState(),
+    getterState: createGetterState(),
+    dependencies: /* @__PURE__ */ new Set(),
+    isTracking: false,
+  };
 }
 /**
-* Start tracking on a tracking proxy.
-*/
+ * Start tracking on a tracking proxy.
+ */
 function startTracking(tracker) {
-	tracker.isTracking = true;
-	tracker.dependencies.clear();
-	tracker.getterState.isTracking = true;
-	startDependency(tracker.dependencyState);
+  tracker.isTracking = true;
+  tracker.dependencies.clear();
+  tracker.getterState.isTracking = true;
+  startDependency(tracker.dependencyState);
 }
 /**
-* Stop tracking and collect all dependencies.
-*/
+ * Stop tracking and collect all dependencies.
+ */
 function stopTracking(tracker, bloc) {
-	tracker.isTracking = false;
-	tracker.getterState.isTracking = false;
-	capturePaths(tracker.dependencyState, bloc.state);
-	commitTrackedGetters(tracker.getterState);
-	return new Set(tracker.dependencies);
+  tracker.isTracking = false;
+  tracker.getterState.isTracking = false;
+  capturePaths(tracker.dependencyState, bloc.state);
+  commitTrackedGetters(tracker.getterState);
+  return new Set(tracker.dependencies);
 }
 /**
-* Check if tracked state or getters have changed.
-*/
+ * Check if tracked state or getters have changed.
+ */
 function hasChanges(tracker, bloc) {
-	invalidateRenderCache(tracker.getterState);
-	const stateChanged = hasDependencyChanges(tracker.dependencyState, bloc.state);
-	const getterChanged = hasGetterChanges(bloc, tracker.getterState);
-	return stateChanged || getterChanged;
-}
-/**
-* Create a tracking proxy for a bloc instance.
-* Tracks both state property access and getter access.
-*/
+  invalidateRenderCache(tracker.getterState);
+  const stateChanged = hasDependencyChanges(
+    tracker.dependencyState,
+    bloc.state,
+  );
+  const getterChanged = hasGetterChanges(bloc, tracker.getterState);
+  return stateChanged || getterChanged;
+}
+/**
+ * Create a tracking proxy for a bloc instance.
+ * Tracks both state property access and getter access.
+ */
 function createTrackingProxy(bloc, tracker) {
-	tracker.dependencies.add(bloc);
-	const stateProxyCache = /* @__PURE__ */ new WeakMap();
-	return new Proxy(bloc, { get(target, prop, receiver) {
-		if (prop === "state") {
-			if (!tracker.isTracking) return target.state;
-			const rawState = target.state;
-			if (rawState === null || typeof rawState !== "object") return rawState;
-			if (stateProxyCache.has(rawState)) return stateProxyCache.get(rawState);
-			const stateProxy = createDependencyProxy(tracker.dependencyState, rawState);
-			stateProxyCache.set(rawState, stateProxy);
-			return stateProxy;
-		}
-		if (typeof prop === "symbol") return Reflect.get(target, prop, receiver);
-		const value = Reflect.get(target, prop, receiver);
-		if (typeof value === "function") return value.bind(target);
-		if (tracker.isTracking && isGetter(target, prop)) return executeTrackedGetter(target, prop, tracker.getterState);
-		return value;
-	} });
+  tracker.dependencies.add(bloc);
+  const stateProxyCache = /* @__PURE__ */ new WeakMap();
+  return new Proxy(bloc, {
+    get(target, prop, receiver) {
+      if (prop === 'state') {
+        if (!tracker.isTracking) return target.state;
+        const rawState = target.state;
+        if (rawState === null || typeof rawState !== 'object') return rawState;
+        if (stateProxyCache.has(rawState)) return stateProxyCache.get(rawState);
+        const stateProxy = createDependencyProxy(
+          tracker.dependencyState,
+          rawState,
+        );
+        stateProxyCache.set(rawState, stateProxy);
+        return stateProxy;
+      }
+      if (typeof prop === 'symbol') return Reflect.get(target, prop, receiver);
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === 'function') return value.bind(target);
+      if (tracker.isTracking && isGetter(target, prop))
+        return executeTrackedGetter(target, prop, tracker.getterState);
+      return value;
+    },
+  });
 }
 //#endregion
 //#region src/tracking/dependency-manager.ts
 /**
-* Manages subscriptions to state container dependencies.
-* Provides efficient sync mechanism to add/remove subscriptions
-* as dependencies change between callback invocations.
-*/
+ * Manages subscriptions to state container dependencies.
+ * Provides efficient sync mechanism to add/remove subscriptions
+ * as dependencies change between callback invocations.
+ */
 var DependencyManager = class {
-	constructor() {
-		this.subscriptions = /* @__PURE__ */ new Map();
-		this.currentDeps = /* @__PURE__ */ new Set();
-	}
-	/**
-	* Sync subscriptions with a new set of dependencies.
-	* Adds subscriptions for new deps, removes subscriptions for stale deps.
-	*
-	* @param newDeps - The new set of dependencies to subscribe to
-	* @param onChange - Callback to invoke when any dependency changes
-	* @param exclude - Optional instance to exclude from subscriptions (e.g., primary bloc)
-	* @returns true if the dependency set changed, false if unchanged
-	*/
-	sync(newDeps, onChange, exclude) {
-		const filteredNewDeps = /* @__PURE__ */ new Set();
-		for (const dep of newDeps) if (dep !== exclude && !dep.isDisposed) filteredNewDeps.add(dep);
-		if (this.areSetsEqual(this.currentDeps, filteredNewDeps)) return false;
-		for (const dep of this.currentDeps) if (!filteredNewDeps.has(dep)) {
-			const unsub = this.subscriptions.get(dep);
-			if (unsub) {
-				unsub();
-				this.subscriptions.delete(dep);
-			}
-		}
-		for (const dep of filteredNewDeps) if (!this.currentDeps.has(dep) && !this.subscriptions.has(dep)) {
-			const unsub = dep.subscribe(onChange);
-			this.subscriptions.set(dep, unsub);
-		}
-		this.currentDeps = filteredNewDeps;
-		return true;
-	}
-	/**
-	* Add a single dependency subscription.
-	*/
-	add(dep, onChange) {
-		if (this.subscriptions.has(dep) || dep.isDisposed) return;
-		const unsub = dep.subscribe(onChange);
-		this.subscriptions.set(dep, unsub);
-		this.currentDeps.add(dep);
-	}
-	/**
-	* Check if a dependency is currently subscribed.
-	*/
-	has(dep) {
-		return this.currentDeps.has(dep);
-	}
-	/**
-	* Get the current set of dependencies.
-	*/
-	getDependencies() {
-		return new Set(this.currentDeps);
-	}
-	/**
-	* Clean up all active subscriptions.
-	*/
-	cleanup() {
-		for (const unsub of this.subscriptions.values()) unsub();
-		this.subscriptions.clear();
-		this.currentDeps.clear();
-	}
-	areSetsEqual(a, b) {
-		if (a.size !== b.size) return false;
-		for (const item of a) if (!b.has(item)) return false;
-		return true;
-	}
+  constructor() {
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.currentDeps = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Sync subscriptions with a new set of dependencies.
+   * Adds subscriptions for new deps, removes subscriptions for stale deps.
+   *
+   * @param newDeps - The new set of dependencies to subscribe to
+   * @param onChange - Callback to invoke when any dependency changes
+   * @param exclude - Optional instance to exclude from subscriptions (e.g., primary bloc)
+   * @returns true if the dependency set changed, false if unchanged
+   */
+  sync(newDeps, onChange, exclude) {
+    const filteredNewDeps = /* @__PURE__ */ new Set();
+    for (const dep of newDeps)
+      if (dep !== exclude && !dep.isDisposed) filteredNewDeps.add(dep);
+    if (this.areSetsEqual(this.currentDeps, filteredNewDeps)) return false;
+    for (const dep of this.currentDeps)
+      if (!filteredNewDeps.has(dep)) {
+        const unsub = this.subscriptions.get(dep);
+        if (unsub) {
+          unsub();
+          this.subscriptions.delete(dep);
+        }
+      }
+    for (const dep of filteredNewDeps)
+      if (!this.currentDeps.has(dep) && !this.subscriptions.has(dep)) {
+        const unsub = dep.subscribe(onChange);
+        this.subscriptions.set(dep, unsub);
+      }
+    this.currentDeps = filteredNewDeps;
+    return true;
+  }
+  /**
+   * Add a single dependency subscription.
+   */
+  add(dep, onChange) {
+    if (this.subscriptions.has(dep) || dep.isDisposed) return;
+    const unsub = dep.subscribe(onChange);
+    this.subscriptions.set(dep, unsub);
+    this.currentDeps.add(dep);
+  }
+  /**
+   * Check if a dependency is currently subscribed.
+   */
+  has(dep) {
+    return this.currentDeps.has(dep);
+  }
+  /**
+   * Get the current set of dependencies.
+   */
+  getDependencies() {
+    return new Set(this.currentDeps);
+  }
+  /**
+   * Clean up all active subscriptions.
+   */
+  cleanup() {
+    for (const unsub of this.subscriptions.values()) unsub();
+    this.subscriptions.clear();
+    this.currentDeps.clear();
+  }
+  areSetsEqual(a, b) {
+    if (a.size !== b.size) return false;
+    for (const item of a) if (!b.has(item)) return false;
+    return true;
+  }
 };
 //#endregion
 //#region src/tracking/resolve-dependencies.ts
 /**
-* Resolve all transitive dependencies of a bloc via BFS over `dependencies` maps.
-* Uses cycle detection to avoid infinite loops.
-* @internal
-*/
+ * Resolve all transitive dependencies of a bloc via BFS over `dependencies` maps.
+ * Uses cycle detection to avoid infinite loops.
+ * @internal
+ */
 function resolveDependencies(bloc) {
-	const result = /* @__PURE__ */ new Set();
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [bloc];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (!current) break;
-		for (const [Type, key] of current.dependencies) {
-			const visitKey = `${Type.name}::${key}`;
-			if (visited.has(visitKey)) continue;
-			visited.add(visitKey);
-			const dep = require_config.getRegistry().ensure(Type, key);
-			result.add(dep);
-			if (dep.dependencies.size > 0) queue.push(dep);
-		}
-	}
-	result.delete(bloc);
-	return result;
+  const result = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [bloc];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) break;
+    for (const [Type, key] of current.dependencies) {
+      const visitKey = `${Type.name}::${key}`;
+      if (visited.has(visitKey)) continue;
+      visited.add(visitKey);
+      const dep = require_config.getRegistry().ensure(Type, key);
+      result.add(dep);
+      if (dep.dependencies.size > 0) queue.push(dep);
+    }
+  }
+  result.delete(bloc);
+  return result;
 }
 //#endregion
-Object.defineProperty(exports, "DependencyManager", {
-	enumerable: true,
-	get: function() {
-		return DependencyManager;
-	}
+Object.defineProperty(exports, 'DependencyManager', {
+  enumerable: true,
+  get: function () {
+    return DependencyManager;
+  },
 });
-Object.defineProperty(exports, "capturePaths", {
-	enumerable: true,
-	get: function() {
-		return capturePaths;
-	}
+Object.defineProperty(exports, 'capturePaths', {
+  enumerable: true,
+  get: function () {
+    return capturePaths;
+  },
 });
-Object.defineProperty(exports, "clearActiveTracker", {
-	enumerable: true,
-	get: function() {
-		return clearActiveTracker;
-	}
+Object.defineProperty(exports, 'clearActiveTracker', {
+  enumerable: true,
+  get: function () {
+    return clearActiveTracker;
+  },
 });
-Object.defineProperty(exports, "commitTrackedGetters", {
-	enumerable: true,
-	get: function() {
-		return commitTrackedGetters;
-	}
+Object.defineProperty(exports, 'commitTrackedGetters', {
+  enumerable: true,
+  get: function () {
+    return commitTrackedGetters;
+  },
 });
-Object.defineProperty(exports, "createBlocProxy", {
-	enumerable: true,
-	get: function() {
-		return createBlocProxy;
-	}
+Object.defineProperty(exports, 'createBlocProxy', {
+  enumerable: true,
+  get: function () {
+    return createBlocProxy;
+  },
 });
-Object.defineProperty(exports, "createDependencyProxy", {
-	enumerable: true,
-	get: function() {
-		return createDependencyProxy;
-	}
+Object.defineProperty(exports, 'createDependencyProxy', {
+  enumerable: true,
+  get: function () {
+    return createDependencyProxy;
+  },
 });
-Object.defineProperty(exports, "createDependencyState", {
-	enumerable: true,
-	get: function() {
-		return createDependencyState;
-	}
+Object.defineProperty(exports, 'createDependencyState', {
+  enumerable: true,
+  get: function () {
+    return createDependencyState;
+  },
 });
-Object.defineProperty(exports, "createGetterState", {
-	enumerable: true,
-	get: function() {
-		return createGetterState;
-	}
+Object.defineProperty(exports, 'createGetterState', {
+  enumerable: true,
+  get: function () {
+    return createGetterState;
+  },
 });
-Object.defineProperty(exports, "createState", {
-	enumerable: true,
-	get: function() {
-		return createState;
-	}
+Object.defineProperty(exports, 'createState', {
+  enumerable: true,
+  get: function () {
+    return createState;
+  },
 });
-Object.defineProperty(exports, "createTrackingProxy", {
-	enumerable: true,
-	get: function() {
-		return createTrackingProxy;
-	}
+Object.defineProperty(exports, 'createTrackingProxy', {
+  enumerable: true,
+  get: function () {
+    return createTrackingProxy;
+  },
 });
-Object.defineProperty(exports, "hasChanges", {
-	enumerable: true,
-	get: function() {
-		return hasChanges;
-	}
+Object.defineProperty(exports, 'hasChanges', {
+  enumerable: true,
+  get: function () {
+    return hasChanges;
+  },
 });
-Object.defineProperty(exports, "hasDependencyChanges", {
-	enumerable: true,
-	get: function() {
-		return hasDependencyChanges;
-	}
+Object.defineProperty(exports, 'hasDependencyChanges', {
+  enumerable: true,
+  get: function () {
+    return hasDependencyChanges;
+  },
 });
-Object.defineProperty(exports, "hasGetterChanges", {
-	enumerable: true,
-	get: function() {
-		return hasGetterChanges;
-	}
+Object.defineProperty(exports, 'hasGetterChanges', {
+  enumerable: true,
+  get: function () {
+    return hasGetterChanges;
+  },
 });
-Object.defineProperty(exports, "hasTrackedData", {
-	enumerable: true,
-	get: function() {
-		return hasTrackedData;
-	}
+Object.defineProperty(exports, 'hasTrackedData', {
+  enumerable: true,
+  get: function () {
+    return hasTrackedData;
+  },
 });
-Object.defineProperty(exports, "invalidateRenderCache", {
-	enumerable: true,
-	get: function() {
-		return invalidateRenderCache;
-	}
+Object.defineProperty(exports, 'invalidateRenderCache', {
+  enumerable: true,
+  get: function () {
+    return invalidateRenderCache;
+  },
 });
-Object.defineProperty(exports, "resolveDependencies", {
-	enumerable: true,
-	get: function() {
-		return resolveDependencies;
-	}
+Object.defineProperty(exports, 'resolveDependencies', {
+  enumerable: true,
+  get: function () {
+    return resolveDependencies;
+  },
 });
-Object.defineProperty(exports, "setActiveTracker", {
-	enumerable: true,
-	get: function() {
-		return setActiveTracker;
-	}
+Object.defineProperty(exports, 'setActiveTracker', {
+  enumerable: true,
+  get: function () {
+    return setActiveTracker;
+  },
 });
-Object.defineProperty(exports, "shallowEqual", {
-	enumerable: true,
-	get: function() {
-		return shallowEqual;
-	}
+Object.defineProperty(exports, 'shallowEqual', {
+  enumerable: true,
+  get: function () {
+    return shallowEqual;
+  },
 });
-Object.defineProperty(exports, "startDependency", {
-	enumerable: true,
-	get: function() {
-		return startDependency;
-	}
+Object.defineProperty(exports, 'startDependency', {
+  enumerable: true,
+  get: function () {
+    return startDependency;
+  },
 });
-Object.defineProperty(exports, "startTracking", {
-	enumerable: true,
-	get: function() {
-		return startTracking;
-	}
+Object.defineProperty(exports, 'startTracking', {
+  enumerable: true,
+  get: function () {
+    return startTracking;
+  },
 });
-Object.defineProperty(exports, "stopTracking", {
-	enumerable: true,
-	get: function() {
-		return stopTracking;
-	}
+Object.defineProperty(exports, 'stopTracking', {
+  enumerable: true,
+  get: function () {
+    return stopTracking;
+  },
 });
 
-//# sourceMappingURL=resolve-dependencies-Dd8T6TLt.cjs.map
+//# sourceMappingURL=resolve-dependencies-Dd8T6TLt.cjs.map