@blac/core 2.0.13 → 2.0.14

package/dist/resolve-dependencies-DP6U1EYB.cjs

@@ -0,0 +1,840 @@
+const require_StateContainerRegistry = require('./StateContainerRegistry-CehuIpK_.cjs');
+const require_config = require('./config-C0yumL1H.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']
+ * ```
+ */
+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
+ */
+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
+ */
+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;
+}
+//#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
+ */
+function isProxyable(value) {
+  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
+ */
+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
+ */
+function startProxy(state) {
+  state.isTracking = true;
+  state.trackedPaths.clear();
+}
+/**
+ * Stop tracking and return the tracked paths
+ * @internal
+ */
+function stopProxy(state) {
+  state.isTracking = false;
+  const paths = state.trackedPaths;
+  state.trackedPaths = /* @__PURE__ */ new Set();
+  return paths;
+}
+/**
+ * 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
+ */
+function createForTarget(state, target) {
+  if (state.lastProxiedState === target && state.lastProxy)
+    return state.lastProxy;
+  if (state.lastProxiedState !== null)
+    state.proxyCache.delete(state.lastProxiedState);
+  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 + '[');
+}
+function getArrayParentPath(path) {
+  if (path.endsWith('.length')) return path.slice(0, -7);
+  const arrayIndexMatch = path.match(/^(.+?)\[\d+\]/);
+  if (arrayIndexMatch) return arrayIndexMatch[1];
+  return null;
+}
+/**
+ * @internal
+ */
+function optimizeTrackedPaths(paths) {
+  if (paths.size <= 1) return paths;
+  let allFlat = true;
+  for (const path of paths)
+    if (path.charCodeAt(path.length - 1) === 93 || path.includes('.')) {
+      allFlat = false;
+      break;
+    }
+  if (allFlat) return paths;
+  const sortedPaths = Array.from(paths).sort((a, b) =>
+    a > b ? -1 : a < b ? 1 : 0,
+  );
+  const optimized = /* @__PURE__ */ new Set();
+  let lastKept;
+  for (const path of sortedPaths) {
+    if (lastKept !== void 0 && isChildPath(lastKept, path)) continue;
+    optimized.add(path);
+    lastKept = 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
+ */
+function startDependency(tracker) {
+  startProxy(tracker.proxyState);
+}
+/**
+ * @internal
+ */
+function createDependencyProxy(tracker, state) {
+  return createForTarget(tracker.proxyState, state);
+}
+/**
+ * @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
+ */
+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
+ */
+function hasTrackedData(tracker) {
+  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;
+/**
+ * @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
+ */
+function isGetter(obj, prop) {
+  return getDescriptor(obj, prop)?.get !== void 0;
+}
+/**
+ * @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
+ */
+function setActiveTracker(bloc, tracker) {
+  activeTrackerMap.set(bloc, tracker);
+}
+/**
+ * @internal
+ */
+function clearActiveTracker(bloc) {
+  activeTrackerMap.delete(bloc);
+}
+/**
+ * @internal
+ */
+function commitTrackedGetters(tracker) {
+  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
+ */
+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
+ */
+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
+ */
+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
+ */
+function invalidateRenderCache(tracker) {
+  tracker.cacheValid = false;
+}
+/**
+ * Create a new tracking proxy state.
+ */
+function createState() {
+  return {
+    dependencyState: createDependencyState(),
+    getterState: createGetterState(),
+    dependencies: /* @__PURE__ */ new Set(),
+    isTracking: false,
+  };
+}
+/**
+ * Start tracking on a tracking proxy.
+ */
+function startTracking(tracker) {
+  tracker.isTracking = true;
+  tracker.dependencies.clear();
+  tracker.getterState.isTracking = true;
+  startDependency(tracker.dependencyState);
+}
+/**
+ * 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);
+}
+/**
+ * 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.
+ */
+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;
+    },
+  });
+}
+//#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.
+ */
+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;
+  }
+};
+//#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
+ */
+function resolveDependencies(bloc) {
+  const result = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [bloc];
+  let head = 0;
+  while (head < queue.length) {
+    const current = queue[head++];
+    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, 'capturePaths', {
+  enumerable: true,
+  get: function () {
+    return capturePaths;
+  },
+});
+Object.defineProperty(exports, 'clearActiveTracker', {
+  enumerable: true,
+  get: function () {
+    return clearActiveTracker;
+  },
+});
+Object.defineProperty(exports, 'commitTrackedGetters', {
+  enumerable: true,
+  get: function () {
+    return commitTrackedGetters;
+  },
+});
+Object.defineProperty(exports, 'createBlocProxy', {
+  enumerable: true,
+  get: function () {
+    return createBlocProxy;
+  },
+});
+Object.defineProperty(exports, 'createDependencyProxy', {
+  enumerable: true,
+  get: function () {
+    return createDependencyProxy;
+  },
+});
+Object.defineProperty(exports, 'createDependencyState', {
+  enumerable: true,
+  get: function () {
+    return createDependencyState;
+  },
+});
+Object.defineProperty(exports, 'createGetterState', {
+  enumerable: true,
+  get: function () {
+    return createGetterState;
+  },
+});
+Object.defineProperty(exports, 'createState', {
+  enumerable: true,
+  get: function () {
+    return createState;
+  },
+});
+Object.defineProperty(exports, 'createTrackingProxy', {
+  enumerable: true,
+  get: function () {
+    return createTrackingProxy;
+  },
+});
+Object.defineProperty(exports, 'hasChanges', {
+  enumerable: true,
+  get: function () {
+    return hasChanges;
+  },
+});
+Object.defineProperty(exports, 'hasDependencyChanges', {
+  enumerable: true,
+  get: function () {
+    return hasDependencyChanges;
+  },
+});
+Object.defineProperty(exports, 'hasGetterChanges', {
+  enumerable: true,
+  get: function () {
+    return hasGetterChanges;
+  },
+});
+Object.defineProperty(exports, 'hasTrackedData', {
+  enumerable: true,
+  get: function () {
+    return hasTrackedData;
+  },
+});
+Object.defineProperty(exports, 'invalidateRenderCache', {
+  enumerable: true,
+  get: function () {
+    return invalidateRenderCache;
+  },
+});
+Object.defineProperty(exports, 'resolveDependencies', {
+  enumerable: true,
+  get: function () {
+    return resolveDependencies;
+  },
+});
+Object.defineProperty(exports, 'setActiveTracker', {
+  enumerable: true,
+  get: function () {
+    return setActiveTracker;
+  },
+});
+Object.defineProperty(exports, 'shallowEqual', {
+  enumerable: true,
+  get: function () {
+    return shallowEqual;
+  },
+});
+Object.defineProperty(exports, 'startDependency', {
+  enumerable: true,
+  get: function () {
+    return startDependency;
+  },
+});
+Object.defineProperty(exports, 'startTracking', {
+  enumerable: true,
+  get: function () {
+    return startTracking;
+  },
+});
+Object.defineProperty(exports, 'stopTracking', {
+  enumerable: true,
+  get: function () {
+    return stopTracking;
+  },
+});
+
+//# sourceMappingURL=resolve-dependencies-DP6U1EYB.cjs.map