@blac/core 2.0.0-rc-14 → 2.0.0-rc-16

package/dist/index.es.js

@@ -1,2275 +0,0 @@
-var u = /* @__PURE__ */ ((r) => (r.ACTIVE = "active", r.DISPOSAL_REQUESTED = "disposal_requested", r.DISPOSING = "disposing", r.DISPOSED = "disposed", r))(u || {});
-class B {
-  disposalState = "active";
-  disposalLock = !1;
-  disposalTimer;
-  disposalHandler;
-  get currentState() {
-    return this.disposalState;
-  }
-  get isDisposed() {
-    return this.disposalState === "disposed";
-  }
-  /**
-   * Atomic state transition for disposal
-   */
-  atomicStateTransition(e, t) {
-    if (this.disposalLock)
-      return {
-        success: !1,
-        currentState: this.disposalState,
-        previousState: this.disposalState
-      };
-    this.disposalLock = !0;
-    try {
-      if (this.disposalState !== e)
-        return {
-          success: !1,
-          currentState: this.disposalState,
-          previousState: this.disposalState
-        };
-      const s = this.disposalState;
-      return this.disposalState = t, {
-        success: !0,
-        currentState: t,
-        previousState: s
-      };
-    } finally {
-      this.disposalLock = !1;
-    }
-  }
-  /**
-   * Schedule disposal after a delay
-   */
-  scheduleDisposal(e, t, s) {
-    this.disposalTimer && (clearTimeout(this.disposalTimer), this.disposalTimer = void 0), this.atomicStateTransition(
-      "active",
-      "disposal_requested"
-      /* DISPOSAL_REQUESTED */
-    ).success && (this.disposalTimer = setTimeout(() => {
-      t() && this.disposalState === "disposal_requested" ? s() : this.atomicStateTransition(
-        "disposal_requested",
-        "active"
-        /* ACTIVE */
-      );
-    }, e));
-  }
-  /**
-   * Cancel disposal if in disposal requested state
-   */
-  cancelDisposal() {
-    return this.disposalState === "disposal_requested" ? (this.disposalTimer && (clearTimeout(this.disposalTimer), this.disposalTimer = void 0), this.atomicStateTransition(
-      "disposal_requested",
-      "active"
-      /* ACTIVE */
-    ).success) : !1;
-  }
-  /**
-   * Set disposal handler
-   */
-  setDisposalHandler(e) {
-    this.disposalHandler = e;
-  }
-  /**
-   * Get disposal handler
-   */
-  getDisposalHandler() {
-    return this.disposalHandler;
-  }
-  /**
-   * Clear disposal timer
-   */
-  clearDisposalTimer() {
-    this.disposalTimer && (clearTimeout(this.disposalTimer), this.disposalTimer = void 0);
-  }
-}
-class T {
-  plugins = /* @__PURE__ */ new Map();
-  metrics = /* @__PURE__ */ new Map();
-  executionOrder = [];
-  /**
-   * Add a system plugin
-   */
-  add(e) {
-    if (this.plugins.has(e.name))
-      throw new Error(`Plugin '${e.name}' is already registered`);
-    this.plugins.set(e.name, e), this.executionOrder.push(e.name), this.initializeMetrics(e.name);
-  }
-  /**
-   * Remove a system plugin
-   */
-  remove(e) {
-    return this.plugins.get(e) ? (this.plugins.delete(e), this.metrics.delete(e), this.executionOrder = this.executionOrder.filter(
-      (s) => s !== e
-    ), !0) : !1;
-  }
-  /**
-   * Get a plugin by name
-   */
-  get(e) {
-    return this.plugins.get(e);
-  }
-  /**
-   * Get all plugins in execution order
-   */
-  getAll() {
-    return this.executionOrder.map((e) => this.plugins.get(e));
-  }
-  /**
-   * Clear all plugins
-   */
-  clear() {
-    this.plugins.clear(), this.metrics.clear(), this.executionOrder = [];
-  }
-  /**
-   * Execute a hook on all plugins
-   */
-  executeHook(e, t, s) {
-    for (const i of this.executionOrder) {
-      const n = this.plugins.get(i), a = n[e];
-      if (typeof a != "function") continue;
-      const c = performance.now();
-      try {
-        a.apply(n, t), this.recordSuccess(i, e, c);
-      } catch (l) {
-        this.recordError(i, e, l), s ? s(l, n) : console.error(
-          `Plugin '${i}' error in hook '${e}':`,
-          l
-        );
-      }
-    }
-  }
-  /**
-   * Bootstrap all plugins
-   */
-  bootstrap() {
-    this.executeHook("beforeBootstrap", []), this.executeHook("afterBootstrap", []);
-  }
-  /**
-   * Shutdown all plugins
-   */
-  shutdown() {
-    this.executeHook("beforeShutdown", []), this.executeHook("afterShutdown", []);
-  }
-  /**
-   * Notify plugins of bloc creation
-   */
-  notifyBlocCreated(e) {
-    this.executeHook("onBlocCreated", [e]);
-  }
-  /**
-   * Notify plugins of bloc disposal
-   */
-  notifyBlocDisposed(e) {
-    this.executeHook("onBlocDisposed", [e]);
-  }
-  /**
-   * Notify plugins of state change
-   */
-  notifyStateChanged(e, t, s) {
-    this.executeHook("onStateChanged", [e, t, s]);
-  }
-  /**
-   * Notify plugins of event addition
-   */
-  notifyEventAdded(e, t) {
-    this.executeHook("onEventAdded", [e, t]);
-  }
-  /**
-   * Notify plugins of errors
-   */
-  notifyError(e, t, s) {
-    this.executeHook("onError", [e, t, s], (i, n) => {
-      console.error(`Plugin '${n.name}' error handler failed:`, i);
-    });
-  }
-  /**
-   * Notify plugins of adapter lifecycle events
-   */
-  notifyAdapterCreated(e, t) {
-    this.executeHook("onAdapterCreated", [e, t]);
-  }
-  notifyAdapterMount(e, t) {
-    this.executeHook("onAdapterMount", [e, t]);
-  }
-  notifyAdapterUnmount(e, t) {
-    this.executeHook("onAdapterUnmount", [e, t]);
-  }
-  notifyAdapterRender(e, t) {
-    this.executeHook("onAdapterRender", [e, t]);
-  }
-  notifyAdapterDisposed(e, t) {
-    this.executeHook("onAdapterDisposed", [e, t]);
-  }
-  /**
-   * Get metrics for a plugin
-   */
-  getMetrics(e) {
-    return this.metrics.get(e);
-  }
-  initializeMetrics(e) {
-    this.metrics.set(e, /* @__PURE__ */ new Map());
-  }
-  recordSuccess(e, t, s) {
-    const i = this.metrics.get(e), n = i.get(t) || {
-      executionTime: 0,
-      executionCount: 0,
-      errorCount: 0
-    }, a = performance.now() - s;
-    i.set(t, {
-      ...n,
-      executionTime: n.executionTime + a,
-      executionCount: n.executionCount + 1,
-      lastExecutionTime: a
-    });
-  }
-  recordError(e, t, s) {
-    const i = this.metrics.get(e), n = i.get(t) || {
-      executionTime: 0,
-      executionCount: 0,
-      errorCount: 0
-    };
-    i.set(t, {
-      ...n,
-      errorCount: n.errorCount + 1,
-      lastError: s
-    });
-  }
-}
-var v = /* @__PURE__ */ ((r) => (r.LIFECYCLE = "LIFECYCLE", r.STATE = "STATE", r.PLUGIN = "PLUGIN", r.VALIDATION = "VALIDATION", r.DISPOSAL = "DISPOSAL", r.CONSUMER = "CONSUMER", r))(v || {}), y = /* @__PURE__ */ ((r) => (r.FATAL = "FATAL", r.ERROR = "ERROR", r.WARNING = "WARNING", r.INFO = "INFO", r))(y || {});
-class m extends Error {
-  constructor(e, t, s, i, n) {
-    super(e), this.category = t, this.severity = s, this.context = i, this.cause = n, this.name = "BlacError", Object.setPrototypeOf(this, m.prototype);
-  }
-  toString() {
-    const e = this.context ? ` [${Object.entries(this.context).filter(([t, s]) => s !== void 0).map(([t, s]) => `${t}: ${s}`).join(", ")}]` : "";
-    return `${this.name} [${this.severity}/${this.category}]: ${this.message}${e}`;
-  }
-}
-const P = {
-  shouldPropagate: (r) => r.severity === "FATAL",
-  shouldLog: (r) => r.severity !== "INFO",
-  handle: (r) => {
-    P.shouldLog(r) && console.error(r.toString(), r.cause);
-  }
-};
-class f {
-  static instance;
-  handlers = /* @__PURE__ */ new Set();
-  strategy = P;
-  /**
-   * Get the singleton instance of ErrorManager
-   */
-  static getInstance() {
-    return f.instance || (f.instance = new f()), f.instance;
-  }
-  /**
-   * Set a custom error handling strategy
-   */
-  setStrategy(e) {
-    this.strategy = e;
-  }
-  /**
-   * Add a custom error handler that will be called for all errors
-   */
-  addHandler(e) {
-    this.handlers.add(e);
-  }
-  /**
-   * Remove a previously added error handler
-   */
-  removeHandler(e) {
-    this.handlers.delete(e);
-  }
-  /**
-   * Process an error through all handlers and apply the configured strategy
-   */
-  handle(e) {
-    if (this.handlers.forEach((t) => {
-      try {
-        t(e);
-      } catch (s) {
-        console.error("Error in error handler:", s);
-      }
-    }), this.strategy.handle(e), this.strategy.shouldPropagate(e))
-      throw e;
-  }
-  /**
-   * Convenience method for wrapping operations with error handling
-   */
-  wrap(e, t) {
-    try {
-      return e();
-    } catch (s) {
-      const i = t(s);
-      this.handle(i);
-      return;
-    }
-  }
-  /**
-   * Async version of wrap
-   */
-  async wrapAsync(e, t) {
-    try {
-      return await e();
-    } catch (s) {
-      const i = t(s);
-      this.handle(i);
-      return;
-    }
-  }
-}
-class g {
-  static _instance;
-  getInstance() {
-    return g._instance || (g._instance = new o({
-      __unsafe_ignore_singleton: !0
-    })), g._instance;
-  }
-  setInstance(e) {
-    g._instance = e;
-  }
-  resetInstance() {
-    const e = g._instance;
-    if (g._instance = new o({
-      __unsafe_ignore_singleton: !0
-    }), e)
-      for (const t of e.keepAliveBlocs)
-        g._instance.keepAliveBlocs.add(t), g._instance.uidRegistry.set(t.uid, t);
-  }
-}
-let b = new g();
-function H(r) {
-  b = r;
-}
-class o {
-  static get instance() {
-    return b.getInstance();
-  }
-  /** Timestamp when the instance was created */
-  createdAt = Date.now();
-  errorManager = f.getInstance();
-  static get getAllBlocs() {
-    return o.instance.getAllBlocs;
-  }
-  /** Private static configuration */
-  static _config = {
-    proxyDependencyTracking: !0
-  };
-  /** Get current configuration */
-  static get config() {
-    return { ...this._config };
-  }
-  /**
-   * Set or update Blac configuration
-   * @param config - Partial configuration to merge with existing config
-   * @throws Error if configuration is invalid
-   */
-  static setConfig(e) {
-    if (e.proxyDependencyTracking !== void 0 && typeof e.proxyDependencyTracking != "boolean") {
-      const t = new m(
-        "BlacConfig.proxyDependencyTracking must be a boolean",
-        v.VALIDATION,
-        y.FATAL
-      );
-      this.instance.errorManager.handle(t);
-    }
-    this._config = {
-      ...this._config,
-      ...e
-    }, this.enableLog && this.instance.log("Blac config updated:", this._config);
-  }
-  /** Map storing all registered bloc instances by their class name and ID */
-  blocInstanceMap = /* @__PURE__ */ new Map();
-  /** Map storing isolated bloc instances grouped by their constructor */
-  // Using BlocConstructor<BlocBase<unknown>> would break type inference when storing
-  // different bloc types in the same map. The 'any' allows proper polymorphic storage
-  // while maintaining type safety at usage sites through the BlocConstructor constraint.
-  isolatedBlocMap = /* @__PURE__ */ new Map();
-  /** Map for O(1) lookup of isolated blocs by UID */
-  isolatedBlocIndex = /* @__PURE__ */ new Map();
-  /** Map tracking UIDs to prevent memory leaks */
-  uidRegistry = /* @__PURE__ */ new Map();
-  /** Set of keep-alive blocs for controlled cleanup */
-  keepAliveBlocs = /* @__PURE__ */ new Set();
-  /** Flag to control whether changes should be posted to document */
-  postChangesToDocument = !1;
-  /** System plugin registry */
-  plugins = new T();
-  /**
-   * Creates a new Blac instance.
-   * @param options - Configuration options including singleton control
-   */
-  constructor(e = {}) {
-    const { __unsafe_ignore_singleton: t = !1 } = e;
-    if (!t)
-      return o.instance;
-    b.setInstance(this), this.plugins.bootstrap();
-  }
-  /** Flag to enable/disable logging */
-  static enableLog = !1;
-  static logLevel = "warn";
-  static logSpy = null;
-  /**
-   * Logs messages to console when logging is enabled
-   * @param args - Arguments to log
-   */
-  log = (...e) => {
-    o.logSpy && o.logSpy(e), o.enableLog && o.logLevel, o.enableLog && o.logLevel;
-  };
-  static get log() {
-    return o.instance.log;
-  }
-  /**
-   * Gets the current Blac instance
-   * @returns The Blac instance
-   */
-  static getInstance() {
-    return b.getInstance();
-  }
-  /**
-   * Logs a warning message
-   * @param message - Warning message
-   * @param args - Additional arguments
-   */
-  warn = (e, ...t) => {
-    console.warn(e, ...t);
-  };
-  static get warn() {
-    return o.instance.warn;
-  }
-  /**
-   * Logs an error message
-   * @param message - Error message
-   * @param args - Additional arguments
-   */
-  error = (e, ...t) => {
-    o.enableLog && console.error(e, ...t);
-  };
-  static get error() {
-    return o.instance.error;
-  }
-  /**
-   * Resets the Blac instance to a new one, disposing non-keepAlive blocs
-   * from the old instance.
-   */
-  resetInstance = () => {
-    this.log("Reset Blac instance");
-    const e = new Map(this.blocInstanceMap), t = new Map(this.isolatedBlocMap);
-    e.forEach((s) => {
-      !s._keepAlive && s._disposalState === u.ACTIVE && this.disposeBloc(s);
-    }), t.forEach((s) => {
-      s.forEach((i) => {
-        !i._keepAlive && i._disposalState === u.ACTIVE && this.disposeBloc(i);
-      });
-    }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), this.isolatedBlocIndex.clear(), b.resetInstance();
-  };
-  static resetInstance = () => {
-    b.resetInstance();
-  };
-  /**
-   * Disposes of a bloc instance by removing it from the appropriate registry
-   * @param bloc - The bloc instance to dispose
-   */
-  disposeBloc = (e) => {
-    const t = e._disposalState;
-    if (![
-      u.ACTIVE,
-      u.DISPOSAL_REQUESTED
-    ].includes(t)) {
-      this.log(
-        `[${e._name}:${String(e._id)}] disposeBloc called on bloc in invalid state: ${t}`
-      );
-      return;
-    }
-    const i = e.constructor, n = this.createBlocInstanceMapKey(e._name, e._id);
-    this.log(
-      `[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(i.isolated)}`
-    ), e.dispose(), this.plugins.notifyBlocDisposed(e), i.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(n)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
-  };
-  static get disposeBloc() {
-    return o.instance.disposeBloc;
-  }
-  /**
-   * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
-   * @param blocClassName - The name of the bloc class
-   * @param id - The instance ID
-   * @returns A unique key string in the format "className:id"
-   */
-  createBlocInstanceMapKey(e, t) {
-    return `${e}:${String(t)}`;
-  }
-  /**
-   * Unregister a bloc instance from the main registry
-   * @param bloc - The bloc instance to unregister
-   */
-  unregisterBlocInstance(e) {
-    const t = this.createBlocInstanceMapKey(e._name, e._id);
-    this.blocInstanceMap.delete(t), this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e);
-  }
-  /**
-   * Registers a bloc instance in the main registry
-   * @param bloc - The bloc instance to register
-   */
-  registerBlocInstance(e) {
-    const t = this.createBlocInstanceMapKey(e._name, e._id);
-    this.blocInstanceMap.set(t, e), this.uidRegistry.set(e.uid, e), e._keepAlive && this.keepAliveBlocs.add(e);
-  }
-  /**
-   * Finds a registered bloc instance by its class and ID
-   * @param blocClass - The bloc class to search for
-   * @param id - The instance ID
-   * @returns The found bloc instance or undefined if not found
-   */
-  findRegisteredBlocInstance(e, t) {
-    if (e.isolated) return;
-    const i = this.createBlocInstanceMapKey(e.name, t), n = this.blocInstanceMap.get(i);
-    if (!(n && n.isDisposed))
-      return n;
-  }
-  /**
-   * Registers an isolated bloc instance in the isolated registry
-   * @param bloc - The isolated bloc instance to register
-   */
-  registerIsolatedBlocInstance(e) {
-    const t = e.constructor, s = this.isolatedBlocMap.get(t);
-    s ? s.push(e) : this.isolatedBlocMap.set(t, [e]), this.isolatedBlocIndex.set(e.uid, e), this.uidRegistry.set(e.uid, e), e._keepAlive && this.keepAliveBlocs.add(e);
-  }
-  /**
-   * Unregister an isolated bloc instance from the isolated registry
-   * @param bloc - The isolated bloc instance to unregister
-   */
-  unregisterIsolatedBlocInstance(e) {
-    const t = e.constructor, s = this.isolatedBlocMap.get(t);
-    let i = !1;
-    if (s) {
-      const a = s.findIndex((c) => c.uid === e.uid);
-      a !== -1 && (s.splice(a, 1), i = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
-    }
-    const n = this.isolatedBlocIndex.delete(e.uid);
-    this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e), i !== n && this.warn(
-      `[Blac] Inconsistent state detected during isolated bloc cleanup for ${e._name}:${e.uid}. Map removal: ${i}, Index removal: ${n}`
-    );
-  }
-  /**
-   * Finds an isolated bloc instance by its class and ID (O(n) lookup)
-   */
-  findIsolatedBlocInstance(e, t) {
-    if (!e.isolated) return;
-    const i = this.isolatedBlocMap.get(e);
-    return i ? i.find((a) => a._id === t && !a.isDisposed) : void 0;
-  }
-  /**
-   * Finds an isolated bloc instance by UID (O(1) lookup)
-   */
-  findIsolatedBlocInstanceByUid(e) {
-    return this.isolatedBlocIndex.get(e);
-  }
-  /**
-   * Creates a new bloc instance and registers it in the appropriate registry
-   * @param blocClass - The bloc class to instantiate
-   * @param id - The instance ID
-   * @param props - Properties to pass to the bloc constructor
-   * @param instanceRef - Optional reference string for the instance
-   * @returns The newly created bloc instance
-   */
-  createNewBlocInstance(e, t, s = {}) {
-    const { constructorParams: i, instanceRef: n } = s, a = new e(i);
-    return a.blacInstance = this, a._instanceRef = n, a._id = t, a.setDisposalHandler((c) => this.disposeBloc(c)), a.isIsolated ? this.registerIsolatedBlocInstance(a) : this.registerBlocInstance(a), this.plugins.notifyBlocCreated(a), a;
-  }
-  activateBloc = (e) => {
-    if (e._disposalState !== u.ACTIVE) {
-      this.log(
-        `[${e._name}:${String(e._id)}] activateBloc called on disposed bloc. Ignoring.`
-      );
-      return;
-    }
-    const t = e.constructor;
-    (e.isIsolated ? this.findIsolatedBlocInstance(t, e._id) : this.findRegisteredBlocInstance(t, e._id)) || (this.log(
-      `[${e._name}:${String(e._id)}] activateBloc called. Isolated: ${String(e.isIsolated)}`
-    ), e.isIsolated ? this.registerIsolatedBlocInstance(e) : this.registerBlocInstance(e));
-  };
-  static get activateBloc() {
-    return o.instance.activateBloc;
-  }
-  /**
-   * Gets or creates a bloc instance based on the provided class and options.
-   * If a bloc with the given ID exists, it will be returned. Otherwise, a new instance will be created.
-   *
-   * @param blocClass - The bloc class to get or create
-   * @param options - Options including:
-   *   - id: The instance ID (defaults to class name if not provided)
-   *   - props: Properties to pass to the bloc constructor
-   *   - instanceRef: Optional reference string for the instance
-   * @returns The bloc instance
-   */
-  getBloc = (e, t = {}) => {
-    const { id: s, forceNewInstance: i } = t, n = e, a = s ?? e.name;
-    if (this.log(`[${e.name}:${String(a)}] (getBloc) Called:`, {
-      options: t,
-      base: n
-    }), !i)
-      if (n.isolated) {
-        const l = this.findIsolatedBlocInstance(
-          e,
-          t.instanceRef ?? a
-        );
-        if (l)
-          return l;
-        if (t.throwIfNotFound)
-          throw new Error(`Isolated bloc ${e.name} not found`);
-      } else {
-        const l = this.findRegisteredBlocInstance(
-          e,
-          a
-        );
-        if (l)
-          return l;
-        if (t.throwIfNotFound)
-          throw new Error(`Registered bloc ${e.name} not found`);
-      }
-    const c = this.createNewBlocInstance(e, a, t);
-    if (this.log(
-      `[${e.name}:${String(a)}] (getBloc) No existing instance found. Creating new one.`,
-      t,
-      c
-    ), !c)
-      throw new Error(
-        `[getBloc] Failed to create bloc instance for ${e.name}. This should never happen.`
-      );
-    return c;
-  };
-  static get getBloc() {
-    return o.instance.getBloc;
-  }
-  /**
-   * Gets all instances of a specific bloc class
-   * @param blocClass - The bloc class to search for
-   * @param options - Options including:
-   *   - searchIsolated: Whether to search in isolated blocs (defaults to bloc's isolated property)
-   * @returns Array of matching bloc instances
-   */
-  getAllBlocs = (e, t = {}) => {
-    const s = [];
-    if (this.blocInstanceMap.forEach((i) => {
-      i.constructor === e && s.push(i);
-    }), t.searchIsolated !== !1) {
-      const i = this.isolatedBlocMap.get(e);
-      i && s.push(...i.map((n) => n));
-    }
-    return s;
-  };
-  /**
-   * Disposes all keep-alive blocs of a specific type
-   * @param blocClass - The bloc class to dispose
-   */
-  disposeKeepAliveBlocs = (e) => {
-    const t = [];
-    for (const s of this.keepAliveBlocs)
-      (!e || s.constructor === e) && t.push(s);
-    t.forEach((s) => s.dispose());
-  };
-  static get disposeKeepAliveBlocs() {
-    return o.instance.disposeKeepAliveBlocs;
-  }
-  /**
-   * Disposes all blocs matching a pattern
-   * @param predicate - Function to test each bloc for disposal
-   */
-  disposeBlocs = (e) => {
-    const t = [];
-    for (const s of this.blocInstanceMap.values())
-      e(s) && t.push(s);
-    for (const s of this.isolatedBlocMap.values())
-      for (const i of s)
-        e(i) && t.push(i);
-    t.forEach((s) => s.dispose());
-  };
-  static get disposeBlocs() {
-    return o.instance.disposeBlocs;
-  }
-  /**
-   * Gets memory usage statistics for debugging
-   */
-  getMemoryStats = () => ({
-    totalBlocs: this.uidRegistry.size,
-    registeredBlocs: this.blocInstanceMap.size,
-    isolatedBlocs: Array.from(this.isolatedBlocMap.values()).reduce(
-      (e, t) => e + t.length,
-      0
-    ),
-    keepAliveBlocs: this.keepAliveBlocs.size,
-    isolatedBlocTypes: this.isolatedBlocMap.size
-  });
-  static get getMemoryStats() {
-    return o.instance.getMemoryStats;
-  }
-  /**
-   * Validates subscription references and cleans up orphaned blocs
-   */
-  validateConsumers = () => {
-    for (const e of this.uidRegistry.values())
-      e.subscriptionCount === 0 && !e._keepAlive && e._disposalState === u.ACTIVE && setTimeout(() => {
-        e.subscriptionCount === 0 && !e._keepAlive && e._disposalState === u.ACTIVE && this.disposeBloc(e);
-      }, 1e3);
-  };
-  static get validateConsumers() {
-    return o.instance.validateConsumers;
-  }
-  /**
-   * Bootstrap the Blac instance and all plugins
-   */
-  bootstrap() {
-    this.plugins.bootstrap();
-  }
-  /**
-   * Shutdown the Blac instance and all plugins
-   */
-  shutdown() {
-    this.plugins.shutdown();
-    for (const e of this.blocInstanceMap.values())
-      e._keepAlive || this.disposeBloc(e);
-    for (const e of this.isolatedBlocMap.values())
-      for (const t of e)
-        t._keepAlive || this.disposeBloc(t);
-  }
-}
-function A() {
-  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(r) {
-    const e = Math.random() * 16 | 0;
-    return (r === "x" ? e : e & 3 | 8).toString(16);
-  });
-}
-const x = {
-  fatal: (r, e, t, s) => {
-    const i = new m(
-      r,
-      e,
-      y.FATAL,
-      t,
-      s
-    );
-    throw f.getInstance().handle(i), i;
-  },
-  error: (r, e, t, s) => {
-    const i = new m(
-      r,
-      e,
-      y.ERROR,
-      t,
-      s
-    );
-    f.getInstance().handle(i);
-  },
-  warn: (r, e, t, s) => {
-    const i = new m(
-      r,
-      e,
-      y.WARNING,
-      t,
-      s
-    );
-    f.getInstance().handle(i);
-  },
-  info: (r, e, t) => {
-    const s = new m(r, e, y.INFO, t);
-    f.getInstance().handle(s);
-  },
-  /**
-   * Wraps a function to catch and handle errors
-   */
-  wrap: (r, e, t, s = y.ERROR) => {
-    try {
-      return r();
-    } catch (i) {
-      const n = i instanceof Error ? i.message : String(i), a = new m(n, e, s, t, i);
-      f.getInstance().handle(a);
-      return;
-    }
-  },
-  /**
-   * Wraps an async function to catch and handle errors
-   */
-  wrapAsync: async (r, e, t, s = y.ERROR) => {
-    try {
-      return await r();
-    } catch (i) {
-      const n = i instanceof Error ? i.message : String(i), a = new m(n, e, s, t, i);
-      f.getInstance().handle(a);
-      return;
-    }
-  }
-};
-class w {
-  plugins = /* @__PURE__ */ new Map();
-  executionOrder = [];
-  attached = !1;
-  /**
-   * Add a bloc plugin
-   */
-  add(e) {
-    if (this.plugins.has(e.name))
-      throw new Error(`Plugin '${e.name}' is already registered`);
-    e.capabilities && this.validateCapabilities(e), this.plugins.set(e.name, e), this.executionOrder.push(e.name);
-  }
-  /**
-   * Remove a bloc plugin
-   */
-  remove(e) {
-    const t = this.plugins.get(e);
-    return t ? (this.attached && t.onDetach && x.wrap(() => t.onDetach(), v.PLUGIN, {
-      pluginName: e,
-      operation: "onDetach"
-    }), this.plugins.delete(e), this.executionOrder = this.executionOrder.filter(
-      (s) => s !== e
-    ), !0) : !1;
-  }
-  /**
-   * Get a plugin by name
-   */
-  get(e) {
-    return this.plugins.get(e);
-  }
-  /**
-   * Get all plugins in execution order
-   */
-  getAll() {
-    return this.executionOrder.map((e) => this.plugins.get(e));
-  }
-  /**
-   * Clear all plugins
-   */
-  clear() {
-    if (this.attached)
-      for (const e of this.getAll())
-        e.onDetach && x.wrap(() => e.onDetach(), v.PLUGIN, {
-          pluginName: e.name,
-          operation: "onDetach"
-        });
-    this.plugins.clear(), this.executionOrder = [], this.attached = !1;
-  }
-  /**
-   * Attach all plugins to a bloc
-   */
-  attach(e) {
-    if (this.attached)
-      throw new Error("Plugins are already attached");
-    for (const t of this.getAll())
-      if (t.onAttach)
-        try {
-          t.onAttach(e);
-        } catch (s) {
-          console.error(`Plugin '${t.name}' error in onAttach:`, s), this.remove(t.name);
-        }
-    this.attached = !0;
-  }
-  /**
-   * Transform state through all plugins
-   */
-  transformState(e, t) {
-    let s = t;
-    for (const i of this.getAll())
-      if (i.transformState && this.canTransformState(i))
-        try {
-          s = i.transformState(
-            e,
-            s
-          );
-        } catch (n) {
-          console.error(
-            `Plugin '${i.name}' error in transformState:`,
-            n
-          );
-        }
-    return s;
-  }
-  /**
-   * Transform event through all plugins
-   */
-  transformEvent(e) {
-    let t = e;
-    for (const s of this.getAll()) {
-      if (t === null) break;
-      if (s.transformEvent && this.canInterceptEvents(s))
-        try {
-          t = s.transformEvent(t);
-        } catch (i) {
-          console.error(
-            `Plugin '${s.name}' error in transformEvent:`,
-            i
-          );
-        }
-    }
-    return t;
-  }
-  /**
-   * Notify plugins of state change
-   */
-  notifyStateChange(e, t) {
-    for (const s of this.getAll())
-      if (s.onStateChange && this.canReadState(s))
-        try {
-          s.onStateChange(e, t);
-        } catch (i) {
-          console.error(
-            `Plugin '${s.name}' error in onStateChange:`,
-            i
-          );
-        }
-  }
-  /**
-   * Notify plugins of event
-   */
-  notifyEvent(e) {
-    for (const t of this.getAll())
-      if (t.onEvent && this.canReadState(t))
-        try {
-          t.onEvent(e);
-        } catch (s) {
-          console.error(`Plugin '${t.name}' error in onEvent:`, s);
-        }
-  }
-  /**
-   * Notify plugins of error
-   */
-  notifyError(e, t) {
-    for (const s of this.getAll())
-      if (s.onError)
-        try {
-          s.onError(e, t);
-        } catch (i) {
-          console.error(`Plugin '${s.name}' error in onError:`, i);
-        }
-  }
-  validateCapabilities(e) {
-    const t = e.capabilities;
-    if (t.transformState && !t.readState)
-      throw new Error(
-        `Plugin '${e.name}': transformState requires readState capability`
-      );
-    if (t.interceptEvents && !t.readState)
-      throw new Error(
-        `Plugin '${e.name}': interceptEvents requires readState capability`
-      );
-  }
-  canReadState(e) {
-    return !e.capabilities || e.capabilities.readState !== !1;
-  }
-  canTransformState(e) {
-    return !e.capabilities || e.capabilities.transformState === !0;
-  }
-  canInterceptEvents(e) {
-    return !e.capabilities || e.capabilities.interceptEvents === !0;
-  }
-}
-class E {
-  constructor(e) {
-    this.bloc = e;
-  }
-  subscriptions = /* @__PURE__ */ new Map();
-  pathToSubscriptions = /* @__PURE__ */ new Map();
-  weakRefCleanupScheduled = !1;
-  totalNotifications = 0;
-  /**
-   * Subscribe to state changes
-   */
-  subscribe(e) {
-    const t = `${e.type}-${A()}`, s = {
-      id: t,
-      type: e.type,
-      selector: e.selector,
-      equalityFn: e.equalityFn || Object.is,
-      notify: e.notify,
-      priority: e.priority ?? 0,
-      weakRef: e.weakRef,
-      dependencies: /* @__PURE__ */ new Set(),
-      metadata: {
-        lastNotified: Date.now(),
-        hasRendered: !1,
-        accessCount: 0,
-        firstAccessTime: Date.now()
-      }
-    };
-    if (s.selector)
-      try {
-        s.lastValue = s.selector(
-          this.bloc.state,
-          this.bloc
-        );
-      } catch (i) {
-        o.error(`SubscriptionManager: Error in selector for ${t}:`, i);
-      }
-    return this.subscriptions.set(t, s), o.log(
-      `[${this.bloc._name}:${this.bloc._id}] Subscription added: ${t}. Total: ${this.subscriptions.size}`
-    ), this.bloc._cancelDisposalIfRequested(), () => this.unsubscribe(t);
-  }
-  /**
-   * Unsubscribe by ID
-   */
-  unsubscribe(e) {
-    const t = this.subscriptions.get(e);
-    if (t) {
-      if (t.dependencies)
-        for (const s of t.dependencies) {
-          const i = this.pathToSubscriptions.get(s);
-          i && (i.delete(e), i.size === 0 && this.pathToSubscriptions.delete(s));
-        }
-      this.subscriptions.delete(e), o.log(
-        `[${this.bloc._name}:${this.bloc._id}] Subscription removed: ${e}. Remaining: ${this.subscriptions.size}`
-      ), this.bloc.checkDisposal();
-    }
-  }
-  /**
-   * Notify all subscriptions of state change
-   */
-  notify(e, t, s) {
-    this.cleanupDeadReferences();
-    const i = Array.from(this.subscriptions.values()).sort(
-      (n, a) => (a.priority ?? 0) - (n.priority ?? 0)
-    );
-    for (const n of i) {
-      if (n.weakRef && !n.weakRef.deref()) {
-        this.scheduleWeakRefCleanup();
-        continue;
-      }
-      let a = !1, c, l;
-      if (n.selector)
-        try {
-          c = n.selector(e, this.bloc), l = n.lastValue, a = !(n.equalityFn || Object.is)(l, c), a && (n.lastValue = c);
-        } catch (h) {
-          o.error(
-            `SubscriptionManager: Error in selector for ${n.id}:`,
-            h
-          );
-          continue;
-        }
-      else {
-        if (n.dependencies && n.dependencies.size > 0) {
-          const h = this.getChangedPaths(t, e);
-          a = this.shouldNotifyForPaths(
-            n.id,
-            h
-          ), o.config.logLevel === "debug" && (o.log(
-            `[SubscriptionManager] Subscription ${n.id} dependencies:`,
-            Array.from(n.dependencies)
-          ), o.log(
-            "[SubscriptionManager] Changed paths:",
-            Array.from(h)
-          ), o.log("[SubscriptionManager] Should notify:", a));
-        } else
-          a = !0;
-        c = e, l = t;
-      }
-      if (a)
-        try {
-          n.notify(c, l, s), this.totalNotifications++, n.metadata && (n.metadata.lastNotified = Date.now(), n.metadata.hasRendered = !0);
-        } catch (h) {
-          o.error(
-            `SubscriptionManager: Error in notify for ${n.id}:`,
-            h
-          );
-        }
-    }
-  }
-  /**
-   * Track a path access for a subscription
-   */
-  trackAccess(e, t, s) {
-    const i = this.subscriptions.get(e);
-    if (!i) return;
-    i.dependencies || (i.dependencies = /* @__PURE__ */ new Set()), i.dependencies.add(t);
-    let n = this.pathToSubscriptions.get(t);
-    n || (n = /* @__PURE__ */ new Set(), this.pathToSubscriptions.set(t, n)), n.add(e), i.metadata && (i.metadata.accessCount = (i.metadata.accessCount || 0) + 1, i.metadata.lastAccessTime = Date.now());
-  }
-  /**
-   * Get the paths that changed between two states
-   */
-  getChangedPaths(e, t, s = "") {
-    const i = /* @__PURE__ */ new Set();
-    if (e === t) return i;
-    if (typeof e != "object" || typeof t != "object" || e === null || t === null)
-      return s && i.add(s), i;
-    const n = /* @__PURE__ */ new Set([
-      ...Object.keys(e),
-      ...Object.keys(t)
-    ]);
-    for (const a of n) {
-      const c = s ? `${s}.${a}` : a, l = e[a], h = t[a];
-      l !== h && (i.add(c), typeof l == "object" && typeof h == "object" && l !== null && h !== null && this.getChangedPaths(
-        l,
-        h,
-        c
-      ).forEach((S) => i.add(S)));
-    }
-    return i;
-  }
-  /**
-   * Check if a subscription should be notified based on changed paths
-   */
-  shouldNotifyForPaths(e, t) {
-    const s = this.subscriptions.get(e);
-    if (!s || !s.dependencies) return !0;
-    for (const i of s.dependencies) {
-      if (i.startsWith("_class.")) {
-        if (t.size > 0)
-          return !0;
-        continue;
-      }
-      if (t.has(i)) return !0;
-      for (const n of t)
-        if (n.startsWith(i + ".") || i.startsWith(n + "."))
-          return !0;
-    }
-    return !1;
-  }
-  /**
-   * Get statistics about subscriptions
-   */
-  getStats() {
-    let e = 0, t = 0;
-    for (const s of this.subscriptions.values())
-      s.type === "consumer" ? e++ : t++;
-    return {
-      activeSubscriptions: this.subscriptions.size,
-      consumerCount: e,
-      observerCount: t,
-      totalNotifications: this.totalNotifications,
-      trackedDependencies: this.pathToSubscriptions.size
-    };
-  }
-  /**
-   * Clear all subscriptions
-   */
-  clear() {
-    this.subscriptions.clear(), this.pathToSubscriptions.clear();
-  }
-  /**
-   * Get subscription by ID
-   */
-  getSubscription(e) {
-    return this.subscriptions.get(e);
-  }
-  /**
-   * Check if there are any active subscriptions
-   */
-  get hasSubscriptions() {
-    return this.subscriptions.size > 0;
-  }
-  /**
-   * Get count of active subscriptions
-   */
-  get size() {
-    return this.subscriptions.size;
-  }
-  /**
-   * Clean up subscriptions with dead weak references
-   */
-  cleanupDeadReferences() {
-    if (!this.weakRefCleanupScheduled) return;
-    const e = [];
-    for (const [t, s] of this.subscriptions)
-      s.weakRef && !s.weakRef.deref() && e.push(t);
-    for (const t of e)
-      this.unsubscribe(t);
-    this.weakRefCleanupScheduled = !1;
-  }
-  /**
-   * Schedule weak reference cleanup for next tick
-   */
-  scheduleWeakRefCleanup() {
-    this.weakRefCleanupScheduled || (this.weakRefCleanupScheduled = !0, queueMicrotask(() => this.cleanupDeadReferences()));
-  }
-}
-class D {
-  pendingUpdates = [];
-  isBatching = !1;
-  /**
-   * Execute a callback with batched updates
-   */
-  batchUpdates(e, t) {
-    if (this.isBatching) {
-      e();
-      return;
-    }
-    this.isBatching = !0, this.pendingUpdates = [];
-    try {
-      if (e(), this.pendingUpdates.length > 0) {
-        const s = this.pendingUpdates[this.pendingUpdates.length - 1];
-        t(s);
-      }
-    } finally {
-      this.isBatching = !1, this.pendingUpdates = [];
-    }
-  }
-  /**
-   * Add an update to the batch
-   */
-  addUpdate(e) {
-    this.isBatching && this.pendingUpdates.push(e);
-  }
-  /**
-   * Check if currently batching
-   */
-  get isCurrentlyBatching() {
-    return this.isBatching;
-  }
-}
-class C {
-  uid = A();
-  blacInstance;
-  static isolated = !1;
-  get isIsolated() {
-    return this._isolated;
-  }
-  static keepAlive = !1;
-  get isKeepAlive() {
-    return this._keepAlive;
-  }
-  _isolated = !1;
-  _id;
-  _instanceRef;
-  _name;
-  /**
-   * Unified subscription manager for all state notifications
-   */
-  _subscriptionManager;
-  _state;
-  _lifecycleManager = new B();
-  _batchingManager = new D();
-  _keepAlive = !1;
-  lastUpdate;
-  _plugins = new w();
-  onDispose;
-  /**
-   * Creates a new BlocBase instance with unified subscription management
-   */
-  constructor(e) {
-    this._state = e, this._id = this.constructor.name, this._name = this.constructor.name, this._subscriptionManager = new E(this);
-    const t = this.constructor;
-    if (this._keepAlive = typeof t.keepAlive == "boolean" ? t.keepAlive : !1, this._isolated = typeof t.isolated == "boolean" ? t.isolated : !1, this._plugins = new w(), t.plugins && Array.isArray(t.plugins))
-      for (const s of t.plugins)
-        this._plugins.add(s);
-    this._plugins.attach(this);
-  }
-  /**
-   * Returns the current state
-   */
-  get state() {
-    return this._lifecycleManager.isDisposed ? this._state : this._state;
-  }
-  /**
-   * Subscribe to all state changes
-   */
-  subscribe(e) {
-    return this._subscriptionManager.subscribe({
-      type: "observer",
-      notify: (t) => e(t)
-    });
-  }
-  /**
-   * Subscribe with a selector for optimized updates
-   */
-  subscribeWithSelector(e, t, s) {
-    return this._subscriptionManager.subscribe({
-      type: "consumer",
-      selector: e,
-      equalityFn: s,
-      notify: (i) => t(i)
-    });
-  }
-  /**
-   * Subscribe with React component reference for automatic cleanup
-   */
-  subscribeComponent(e, t) {
-    return this._subscriptionManager.subscribe({
-      type: "consumer",
-      weakRef: e,
-      notify: t
-    });
-  }
-  /**
-   * Get current subscription count
-   */
-  get subscriptionCount() {
-    return this._subscriptionManager.size;
-  }
-  /**
-   * Track property access for a subscription
-   */
-  trackAccess(e, t, s) {
-    this._subscriptionManager.trackAccess(e, t, s);
-  }
-  /**
-   * Emit a new state
-   */
-  emit(e, t) {
-    this._pushState(e, this._state, t);
-  }
-  /**
-   * Internal state push method used by Bloc
-   */
-  _pushState(e, t, s) {
-    if (this._lifecycleManager.currentState !== u.ACTIVE) {
-      this.blacInstance?.error(
-        `[${this._name}:${this._id}] Attempted state update on ${this._lifecycleManager.currentState} bloc. Update ignored.`
-      );
-      return;
-    }
-    if (e === void 0)
-      return;
-    this._state = e;
-    const i = this._plugins.transformState(
-      t,
-      e
-    );
-    if (this._state = i, this._plugins.notifyStateChange(t, i), this.blacInstance?.plugins.notifyStateChanged(
-      this,
-      t,
-      i
-    ), this._batchingManager.isCurrentlyBatching) {
-      this._batchingManager.addUpdate({
-        newState: i,
-        oldState: t,
-        action: s
-      });
-      return;
-    }
-    this._subscriptionManager.notify(i, t, s), this.lastUpdate = Date.now();
-  }
-  _batchUpdates(e) {
-    this._batchingManager.batchUpdates(e, (t) => {
-      this._subscriptionManager.notify(
-        t.newState,
-        t.oldState,
-        t.action
-      );
-    });
-  }
-  /**
-   * Add a plugin
-   */
-  addPlugin(e) {
-    if (this._plugins.add(e), this._plugins.attached && e.onAttach)
-      try {
-        e.onAttach(this);
-      } catch (t) {
-        console.error(`Plugin '${e.name}' error in onAttach:`, t);
-      }
-  }
-  /**
-   * Remove a plugin
-   */
-  removePlugin(e) {
-    this._plugins.remove(e.name);
-  }
-  /**
-   * Get all plugins
-   */
-  get plugins() {
-    return this._plugins.getAll();
-  }
-  /**
-   * Disposal management
-   */
-  get isDisposed() {
-    return this._lifecycleManager.isDisposed;
-  }
-  /**
-   * Atomic state transition for disposal
-   */
-  _atomicStateTransition(e, t) {
-    return this._lifecycleManager.atomicStateTransition(
-      e,
-      t
-    );
-  }
-  /**
-   * Dispose the bloc and clean up resources
-   */
-  async dispose() {
-    if (!this._lifecycleManager.atomicStateTransition(
-      u.ACTIVE,
-      u.DISPOSING
-    ).success)
-      if (this._lifecycleManager.currentState === u.DISPOSAL_REQUESTED)
-        this._lifecycleManager.atomicStateTransition(
-          u.DISPOSAL_REQUESTED,
-          u.DISPOSING
-        );
-      else
-        return;
-    try {
-      this._subscriptionManager.clear(), this.onDispose && this.onDispose();
-      for (const s of this._plugins.getAll())
-        try {
-          "onDispose" in s && typeof s.onDispose == "function" && s.onDispose(this);
-        } catch (i) {
-          console.error("Plugin disposal error:", i);
-        }
-      const t = this._lifecycleManager.getDisposalHandler();
-      t && t(this);
-    } finally {
-      this._lifecycleManager.atomicStateTransition(
-        u.DISPOSING,
-        u.DISPOSED
-      );
-    }
-  }
-  /**
-   * Schedule disposal when no subscriptions remain
-   */
-  _scheduleDisposal() {
-    this._subscriptionManager.size === 0 && !this._keepAlive && this._lifecycleManager.scheduleDisposal(
-      16,
-      () => this._subscriptionManager.size === 0 && !this._keepAlive,
-      () => this.dispose()
-    );
-  }
-  /**
-   * Set disposal handler
-   */
-  setDisposalHandler(e) {
-    this._lifecycleManager.setDisposalHandler(
-      e
-    );
-  }
-  /**
-   * Check if disposal should be scheduled (called by subscription manager)
-   */
-  checkDisposal() {
-    this._subscriptionManager.size === 0 && !this._keepAlive && this._lifecycleManager.currentState === u.ACTIVE && this._scheduleDisposal();
-  }
-  /**
-   * Cancel disposal if bloc is in disposal_requested state
-   */
-  _cancelDisposalIfRequested() {
-    this.blacInstance?.log(
-      `[${this._name}:${this._id}] _cancelDisposalIfRequested called. Current state: ${this._lifecycleManager.currentState}`
-    ), this._lifecycleManager.cancelDisposal() ? this.blacInstance?.log(
-      `[${this._name}:${this._id}] Disposal cancelled - new subscription added`
-    ) : this._lifecycleManager.currentState === u.DISPOSAL_REQUESTED ? this.blacInstance?.warn(
-      `[${this._name}:${this._id}] Failed to cancel disposal. Current state: ${this._lifecycleManager.currentState}`
-    ) : this._lifecycleManager.isDisposed && this.blacInstance?.error(
-      `[${this._name}:${this._id}] Cannot cancel disposal - bloc is already disposed`
-    );
-  }
-}
-class R extends C {
-  eventHandlers = /* @__PURE__ */ new Map();
-  /**
-   * @internal
-   * Event queue to ensure sequential processing of async events
-   */
-  _eventQueue = [];
-  /**
-   * @internal
-   * Flag indicating if an event is currently being processed
-   */
-  _isProcessingEvent = !1;
-  /**
-   * Registers an event handler for a specific event type.
-   * This method is typically called in the constructor of a derived Bloc class.
-   * @param eventConstructor The constructor of the event to handle (e.g., LoadDataEvent).
-   * @param handler A function that processes the event and can emit new states.
-   *                The 'event' parameter in the handler will be typed to the specific eventConstructor.
-   */
-  on(e, t) {
-    this.eventHandlers.has(e) && o.warn(
-      `[Bloc ${this._name}:${String(this._id)}] Handler for event '${e.name}' already registered. It will be overwritten.`
-    ), this.eventHandlers.set(
-      e,
-      t
-    );
-  }
-  /**
-   * Dispatches an action/event to the Bloc.
-   * Events are queued and processed sequentially to prevent race conditions.
-   * @param action The action/event instance to be processed.
-   */
-  add = async (e) => {
-    let t = e;
-    try {
-      t = this._plugins.transformEvent(e);
-    } catch (s) {
-      console.error("Error transforming event:", s);
-    }
-    if (t !== null) {
-      try {
-        this._plugins.notifyEvent(t);
-      } catch (s) {
-        console.error("Error notifying plugins of event:", s);
-      }
-      o.instance.plugins.notifyEventAdded(this, t), this._eventQueue.push(t), this._isProcessingEvent || await this._processEventQueue();
-    }
-  };
-  /**
-   * @internal
-   * Processes events from the queue sequentially
-   */
-  async _processEventQueue() {
-    if (!this._isProcessingEvent) {
-      this._isProcessingEvent = !0;
-      try {
-        for (; this._eventQueue.length > 0; ) {
-          const e = this._eventQueue.shift();
-          await this._processEvent(e);
-        }
-      } finally {
-        this._isProcessingEvent = !1;
-      }
-    }
-  }
-  /**
-   * @internal
-   * Processes a single event
-   */
-  async _processEvent(e) {
-    const t = e.constructor, s = this.eventHandlers.get(t);
-    if (s) {
-      const i = (n) => {
-        const a = this.state;
-        this._pushState(n, a, e);
-      };
-      try {
-        await s(e, i);
-      } catch (n) {
-        const a = e.constructor.name || "UnnamedConstructor", c = {
-          blocName: this._name,
-          blocId: String(this._id),
-          eventType: a,
-          currentState: this.state,
-          action: e,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        if (o.error(
-          `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${a}':`,
-          n,
-          "Context:",
-          c
-        ), n instanceof Error)
-          try {
-            this._plugins.notifyError(n, {
-              phase: "event-processing",
-              operation: "handler",
-              metadata: { event: e }
-            }), o.instance.plugins.notifyError(n, this, {
-              phase: "event-processing",
-              operation: "handler",
-              metadata: { event: e }
-            });
-          } catch (l) {
-            console.error("Error notifying plugins:", l);
-          }
-        if (n instanceof Error && n.name === "CriticalError")
-          throw n;
-      }
-    } else {
-      const i = e.constructor.name || "UnnamedConstructor";
-      o.warn(
-        `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${i}'.`,
-        "Registered handlers:",
-        Array.from(this.eventHandlers.keys()).map((n) => n.name),
-        "Action was:",
-        e
-      );
-    }
-  }
-}
-class O extends C {
-  /**
-   * Updates the current state and notifies all observers of the change.
-   * If the new state is identical to the current state (using Object.is),
-   * no update will occur.
-   * @param state - The new state to set
-   */
-  emit(e) {
-    if (Object.is(e, this.state))
-      return;
-    const t = this.state, s = e;
-    this._pushState(s, t);
-  }
-  /**
-   * Partially updates the current state by merging it with the provided state patch.
-   * This method is only applicable when the state is an object type.
-   *
-   * @param statePatch - A partial state object containing only the properties to update
-   * @param ignoreChangeCheck - If true, skips checking if the state has actually changed
-   * @throws {TypeError} If the state is not an object type
-   */
-  patch(e, t = !1) {
-    if (typeof this.state != "object" || this.state === null) {
-      o.warn(
-        "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
-      );
-      return;
-    }
-    let s = !1;
-    if (t)
-      s = !0;
-    else
-      for (const i in e)
-        if (Object.prototype.hasOwnProperty.call(e, i)) {
-          const a = this.state[i];
-          if (!Object.is(e[i], a)) {
-            s = !0;
-            break;
-          }
-        }
-    s && this.emit({
-      ...this.state,
-      ...e
-    });
-  }
-}
-class L {
-  constructor(e) {
-    this.props = e;
-  }
-}
-function V(r, e) {
-  if (Object.is(r, e))
-    return !0;
-  if (typeof r != "object" || r === null || typeof e != "object" || e === null)
-    return !1;
-  const t = Object.keys(r), s = Object.keys(e);
-  if (t.length !== s.length)
-    return !1;
-  for (let i = 0; i < t.length; i++) {
-    const n = t[i];
-    if (!Object.prototype.hasOwnProperty.call(e, n) || !Object.is(r[n], e[n]))
-      return !1;
-  }
-  return !0;
-}
-function N(r) {
-  if (!r || typeof r != "object")
-    return;
-  const e = [];
-  for (const [s, i] of Object.entries(r)) {
-    const n = typeof i;
-    (n === "string" || n === "number" || n === "boolean" || i === null || i === void 0) && e.push([s, i]);
-  }
-  if (e.length === 0)
-    return;
-  e.sort(([s], [i]) => s.localeCompare(i));
-  const t = [];
-  for (const [s, i] of e)
-    i === null ? t.push(`${s}:null`) : i === void 0 ? t.push(`${s}:undefined`) : t.push(`${s}:${String(i)}`);
-  return t.join("|");
-}
-class F {
-  static componentRenderCounts = /* @__PURE__ */ new Map();
-  static lastRenderTimestamps = /* @__PURE__ */ new Map();
-  static groupedLogs = /* @__PURE__ */ new Map();
-  static groupTimeouts = /* @__PURE__ */ new Map();
-  /**
-   * Log a component rerender with detailed information
-   */
-  static logRerender(e) {
-    const t = o._config?.rerenderLogging;
-    if (!t) return;
-    const s = this.parseConfig(t);
-    if (!s.enabled || s.filter && !s.filter({
-      componentName: e.componentName,
-      blocName: e.blocName
-    }))
-      return;
-    const i = `${e.componentName}-${e.blocId}`, n = this.componentRenderCounts.get(i) || 0;
-    this.componentRenderCounts.set(i, n + 1), e.renderCount = n + 1;
-    const a = this.lastRenderTimestamps.get(i);
-    a && (e.duration = e.timestamp - a), this.lastRenderTimestamps.set(i, e.timestamp), s.includeStackTrace && s.level === "detailed" && (e.stackTrace = new Error().stack), s.groupRerenders ? this.logGrouped(e, s) : this.logImmediate(e, s);
-  }
-  /**
-   * Parse the logging configuration
-   */
-  static parseConfig(e) {
-    return e === !0 ? { enabled: !0, level: "normal" } : typeof e == "string" ? {
-      enabled: !0,
-      level: e === "minimal" ? "minimal" : "detailed"
-    } : {
-      enabled: e.enabled,
-      level: e.level || "normal",
-      filter: e.filter,
-      includeStackTrace: e.includeStackTrace,
-      groupRerenders: e.groupRerenders
-    };
-  }
-  /**
-   * Log immediately without grouping
-   */
-  static logImmediate(e, t) {
-    const s = this.formatMessage(e, t.level);
-    t.level === "detailed" ? (console.group(s.header), s.details && console.log(s.details), s.values && console.table(s.values), e.stackTrace && console.log("Stack trace:", e.stackTrace), console.groupEnd()) : console.log(s.header, s.details || "");
-  }
-  /**
-   * Log with grouping (batch multiple rerenders)
-   */
-  static logGrouped(e, t) {
-    const s = `${e.componentName}-${e.blocId}`, i = this.groupTimeouts.get(s);
-    i && clearTimeout(i);
-    const n = this.groupedLogs.get(s) || [];
-    n.push(e), this.groupedLogs.set(s, n);
-    const a = setTimeout(() => {
-      const c = this.groupedLogs.get(s) || [];
-      this.groupedLogs.delete(s), this.groupTimeouts.delete(s), c.length === 1 ? this.logImmediate(c[0], t) : (console.group(
-        `🔄 ${e.componentName} rendered ${c.length} times (${e.blocName})`
-      ), c.forEach((l, h) => {
-        const p = this.formatMessage(l, t.level);
-        console.log(`  ${h + 1}. ${p.details || p.header}`);
-      }), console.groupEnd());
-    }, 50);
-    this.groupTimeouts.set(s, a);
-  }
-  /**
-   * Format the log message based on level
-   */
-  static formatMessage(e, t) {
-    const s = this.getReasonEmoji(e.reason.type);
-    if (t === "minimal")
-      return {
-        header: `${s} ${e.componentName} #${e.renderCount}`,
-        details: null,
-        values: null
-      };
-    const i = `${s} ${e.componentName} rerender #${e.renderCount} (${e.blocName})`;
-    let n = `Reason: ${e.reason.description || e.reason.type}`;
-    e.duration !== void 0 && (n += ` | Time since last: ${e.duration}ms`), t === "normal" && e.reason.changedPaths && e.reason.changedPaths.length > 0 && (n += ` | Changed: ${e.reason.changedPaths.join(", ")}`);
-    let a = null;
-    return t === "detailed" && e.reason.changedPaths && e.reason.changedPaths.length > 0 && (a = {}, e.reason.changedPaths.forEach((c) => {
-      a[c] = {
-        old: e.reason.oldValues?.[c],
-        new: e.reason.newValues?.[c]
-      };
-    }), Object.keys(a).length === 0 && (a = null)), { header: i, details: n, values: a };
-  }
-  /**
-   * Get emoji for reason type
-   */
-  static getReasonEmoji(e) {
-    switch (e) {
-      case "state-change":
-        return "📊";
-      case "dependency-change":
-        return "🔗";
-      case "mount":
-        return "🚀";
-      case "props-change":
-        return "📦";
-      default:
-        return "🔄";
-    }
-  }
-  /**
-   * Clear all tracking data
-   */
-  static clear() {
-    this.componentRenderCounts.clear(), this.lastRenderTimestamps.clear(), this.groupedLogs.clear(), this.groupTimeouts.forEach((e) => clearTimeout(e)), this.groupTimeouts.clear();
-  }
-  /**
-   * Get render count for a component
-   */
-  static getRenderCount(e, t) {
-    return this.componentRenderCounts.get(`${e}-${t}`) || 0;
-  }
-}
-class j {
-  static originalInstance;
-  /**
-   * Sets up a clean test environment
-   */
-  static setUp() {
-    this.originalInstance = o.instance, o.resetInstance(), o.enableLog = !1;
-  }
-  /**
-   * Tears down the test environment and restores original state
-   */
-  static tearDown() {
-    o.resetInstance();
-  }
-  /**
-   * Creates a test bloc with automatic cleanup
-   */
-  static createBloc(e, ...t) {
-    const s = new e(...t);
-    return o.activateBloc(s), s;
-  }
-  /**
-   * Waits for a bloc to emit a specific state
-   */
-  static async waitForState(e, t, s = 5e3) {
-    return new Promise((i, n) => {
-      const a = setTimeout(() => {
-        n(
-          new Error(
-            `Timeout waiting for state matching predicate after ${s}ms`
-          )
-        );
-      }, s), c = e.subscribe((l) => {
-        t(l) && (clearTimeout(a), c(), i(l));
-      });
-      t(e.state) && (clearTimeout(a), c(), i(e.state));
-    });
-  }
-  /**
-   * Expects a bloc to emit specific states in order
-   */
-  static async expectStates(e, t, s = 5e3) {
-    const i = [];
-    return new Promise((n, a) => {
-      const c = setTimeout(() => {
-        a(
-          new Error(
-            `Timeout waiting for states. Expected: ${JSON.stringify(t)}, Received: ${JSON.stringify(i)}`
-          )
-        );
-      }, s), l = e.subscribe((h) => {
-        if (i.push(h), i.length === t.length) {
-          clearTimeout(c), l();
-          for (let p = 0; p < t.length; p++) {
-            const S = t[p], k = i[p];
-            if (JSON.stringify(S) !== JSON.stringify(k)) {
-              a(
-                new Error(
-                  `State mismatch at index ${p}. Expected: ${JSON.stringify(S)}, Received: ${JSON.stringify(k)}`
-                )
-              );
-              return;
-            }
-          }
-          n();
-        }
-      });
-    });
-  }
-}
-class z extends R {
-  mockHandlers = /* @__PURE__ */ new Map();
-  constructor(e) {
-    super(e);
-  }
-  /**
-   * Mock an event handler for testing
-   */
-  mockEventHandler(e, t) {
-    this.on(e, t);
-  }
-  /**
-   * Get the number of registered handlers
-   */
-  getHandlerCount() {
-    return this.eventHandlers.size;
-  }
-  /**
-   * Check if a handler is registered for an event type
-   */
-  hasHandler(e) {
-    return this.eventHandlers.has(e);
-  }
-}
-class q extends O {
-  stateHistory = [];
-  constructor(e) {
-    super(e), this.stateHistory.push(e);
-  }
-  /**
-   * Override emit to track state history
-   */
-  emit(e) {
-    this.stateHistory.push(e), super.emit(e);
-  }
-  /**
-   * Get the history of all states
-   */
-  getStateHistory() {
-    return [...this.stateHistory];
-  }
-  /**
-   * Clear state history
-   */
-  clearStateHistory() {
-    this.stateHistory = [this.state];
-  }
-}
-class W {
-  initialStats;
-  constructor() {
-    this.initialStats = o.getMemoryStats();
-  }
-  /**
-   * Check for memory leaks and return a report
-   */
-  checkForLeaks() {
-    const e = o.getMemoryStats(), t = e.registeredBlocs > this.initialStats.registeredBlocs || e.isolatedBlocs > this.initialStats.isolatedBlocs || e.keepAliveBlocs > this.initialStats.keepAliveBlocs, s = `
-Memory Leak Detection Report:
-- Initial registered blocs: ${this.initialStats.registeredBlocs}
-- Current registered blocs: ${e.registeredBlocs}
-- Initial isolated blocs: ${this.initialStats.isolatedBlocs}  
-- Current isolated blocs: ${e.isolatedBlocs}
-- Initial keep-alive blocs: ${this.initialStats.keepAliveBlocs}
-- Current keep-alive blocs: ${e.keepAliveBlocs}
-- Potential leaks detected: ${t ? "YES" : "NO"}
-    `.trim();
-    return {
-      hasLeaks: t,
-      report: s,
-      stats: e
-    };
-  }
-}
-const I = /* @__PURE__ */ new WeakMap(), d = {
-  stateProxiesCreated: 0,
-  classProxiesCreated: 0,
-  cacheHits: 0,
-  cacheMisses: 0,
-  totalProxiesCreated: 0
-}, _ = (r, e, t, s = "") => {
-  if (!e || !t || typeof r != "object" || r === null)
-    return r;
-  if (!s) {
-    let n = I.get(r);
-    n || (n = /* @__PURE__ */ new WeakMap(), I.set(r, n));
-    const a = n.get(e);
-    if (a)
-      return d.cacheHits++, a;
-    d.cacheMisses++;
-  }
-  const i = new Proxy(r, {
-    get(n, a) {
-      if (typeof a == "symbol" || a === "constructor")
-        return Reflect.get(n, a);
-      const c = s ? `${s}.${a}` : a, l = Reflect.get(n, a), h = l && typeof l == "object";
-      return t.trackAccess(
-        e,
-        "state",
-        c,
-        h ? void 0 : l
-      ), h && (Array.isArray(l) || Object.getPrototypeOf(l) === Object.prototype) ? _(l, e, t, c) : l;
-    },
-    set: () => !1,
-    // State should be immutable
-    deleteProperty: () => !1
-    // State properties should not be deleted
-  });
-  return s || (I.get(r).set(e, i), d.stateProxiesCreated++, d.totalProxiesCreated++), i;
-}, M = (r, e, t) => {
-  if (!e || !t)
-    return r;
-  let s = I.get(r);
-  s || (s = /* @__PURE__ */ new WeakMap(), I.set(r, s));
-  const i = s.get(e);
-  if (i)
-    return d.cacheHits++, i;
-  d.cacheMisses++;
-  const n = new Proxy(r, {
-    get(a, c) {
-      const l = Reflect.get(a, c);
-      if (U(a, c)?.get) {
-        const p = l !== null && typeof l != "object";
-        t.trackAccess(
-          e,
-          "class",
-          String(c),
-          p ? l : void 0
-        );
-      }
-      return l;
-    }
-  });
-  return s.set(e, n), d.classProxiesCreated++, d.totalProxiesCreated++, n;
-}, U = (r, e, t = 10) => {
-  let s = r, i = 0;
-  for (; s && i < t; ) {
-    const n = Object.getOwnPropertyDescriptor(s, e);
-    if (n) return n;
-    s = Object.getPrototypeOf(s), i++;
-  }
-}, $ = {
-  createStateProxy: (r) => _(
-    r.target,
-    r.consumerRef,
-    r.consumerTracker,
-    r.path
-  ),
-  createClassProxy: (r) => M(
-    r.target,
-    r.consumerRef,
-    r.consumerTracker
-  ),
-  getProxyState: (r) => _(
-    r.state,
-    r.consumerRef,
-    r.consumerTracker
-  ),
-  getProxyBlocInstance: (r) => M(
-    r.blocInstance,
-    r.consumerRef,
-    r.consumerTracker
-  ),
-  // Compatibility functions that return expected structure
-  getStats: () => ({
-    ...d,
-    propertyAccesses: 0,
-    nestedProxiesCreated: 0,
-    cacheEfficiency: d.cacheHits + d.cacheMisses > 0 ? `${(d.cacheHits / (d.cacheHits + d.cacheMisses) * 100).toFixed(1)}%` : "N/A",
-    lifetime: "0ms",
-    proxiesPerSecond: "N/A"
-  }),
-  resetStats: () => {
-    d.stateProxiesCreated = 0, d.classProxiesCreated = 0, d.cacheHits = 0, d.cacheMisses = 0, d.totalProxiesCreated = 0;
-  }
-};
-class G {
-  id = `adapter-${A()}`;
-  blocConstructor;
-  componentRef = { current: {} };
-  blocInstance;
-  unmountTime = 0;
-  mountTime = 0;
-  // Subscription management
-  subscriptionId;
-  unsubscribe;
-  // Dependency tracking
-  dependencyValues;
-  isUsingDependencies = !1;
-  trackedPaths = /* @__PURE__ */ new Set();
-  pendingTrackedPaths = /* @__PURE__ */ new Set();
-  // Paths tracked before subscription exists
-  // Proxy caching
-  cachedStateProxy;
-  cachedBlocProxy;
-  lastProxiedState;
-  // Lifecycle state
-  hasMounted = !1;
-  mountCount = 0;
-  // Rerender tracking
-  lastState;
-  lastDependencyValues;
-  componentName;
-  renderCount = 0;
-  lastDependenciesFn;
-  options;
-  constructor(e, t) {
-    this.options = t, this.blocConstructor = e.blocConstructor, this.componentRef = e.componentRef, this.isUsingDependencies = !!t?.dependencies, this.updateBlocInstance(), this.isUsingDependencies && t?.dependencies && (this.dependencyValues = t.dependencies(this.blocInstance));
-    const s = this.getAdapterMetadata();
-    o.getInstance().plugins.notifyAdapterCreated(this, s);
-  }
-  trackAccess(e, t, s, i) {
-    const n = t === "class" ? `_class.${s}` : s;
-    this.trackedPaths.add(n), this.subscriptionId ? this.blocInstance.trackAccess(this.subscriptionId, n, i) : (this.pendingTrackedPaths.add(n), o.config.logLevel === "debug" && o.log(`[BlacAdapter] trackAccess storing pending path: ${s}`));
-  }
-  updateBlocInstance() {
-    let e = this.options?.instanceId;
-    if (!e && this.options?.staticProps) {
-      const t = N(this.options.staticProps);
-      t && (e = t);
-    }
-    return this.blocInstance = o.instance.getBloc(this.blocConstructor, {
-      constructorParams: this.options?.staticProps,
-      id: e,
-      instanceRef: this.id
-    }), this.blocInstance;
-  }
-  createSubscription = (e) => {
-    if (this.isUsingDependencies && this.options?.dependencies)
-      this.unsubscribe = this.blocInstance.subscribeWithSelector(
-        (t) => this.options.dependencies(this.blocInstance),
-        (t) => {
-          this.hasDependencyValuesChanged(
-            this.dependencyValues,
-            t
-          ) && (this.dependencyValues = t, e.onChange());
-        }
-      );
-    else {
-      const t = new WeakRef(this.componentRef.current);
-      this.unsubscribe = this.blocInstance.subscribeComponent(
-        t,
-        e.onChange
-      );
-      const s = this.blocInstance._subscriptionManager.subscriptions;
-      if (this.subscriptionId = Array.from(s.keys()).pop(), this.subscriptionId && this.pendingTrackedPaths.size > 0) {
-        for (const i of this.pendingTrackedPaths)
-          this.blocInstance.trackAccess(this.subscriptionId, i);
-        this.pendingTrackedPaths.clear();
-      }
-    }
-    return () => {
-      this.unsubscribe && (this.unsubscribe(), this.unsubscribe = void 0, this.subscriptionId = void 0);
-    };
-  };
-  hasDependencyValuesChanged = (e, t) => {
-    if (!e || e.length !== t.length) return !0;
-    for (let s = 0; s < e.length; s++)
-      if (!Object.is(e[s], t[s]))
-        return !0;
-    return !1;
-  };
-  getStateProxy = () => {
-    if (this.isUsingDependencies || !o.config.proxyDependencyTracking)
-      return this.blocInstance.state;
-    const e = this.blocInstance.state;
-    return this.cachedStateProxy && this.lastProxiedState === e ? this.cachedStateProxy : (this.lastProxiedState = e, this.cachedStateProxy = this.createStateProxy({ target: e }), this.cachedStateProxy);
-  };
-  getBlocProxy = () => this.isUsingDependencies || !o.config.proxyDependencyTracking ? this.blocInstance : this.cachedBlocProxy ? this.cachedBlocProxy : (this.cachedBlocProxy = this.createClassProxy({ target: this.blocInstance }), this.cachedBlocProxy);
-  createStateProxy = (e) => $.createStateProxy({
-    target: e.target,
-    consumerRef: this.componentRef.current,
-    consumerTracker: this
-  });
-  createClassProxy = (e) => $.createClassProxy({
-    target: e.target,
-    consumerRef: this.componentRef.current,
-    consumerTracker: this
-  });
-  // Lifecycle methods
-  mount = () => {
-    this.hasMounted = !0, this.mountCount++, this.mountTime = Date.now(), this.options?.onMount && this.options.onMount(this.blocInstance), this.isUsingDependencies && this.options?.dependencies && (this.dependencyValues = this.options.dependencies(this.blocInstance));
-    const e = this.getAdapterMetadata();
-    o.getInstance().plugins.notifyAdapterMount(this, e);
-  };
-  unmount = () => {
-    if (this.unmountTime = Date.now(), this.unsubscribe && (this.unsubscribe(), this.unsubscribe = void 0, this.subscriptionId = void 0), this.options?.onUnmount)
-      try {
-        this.options.onUnmount(this.blocInstance);
-      } catch (t) {
-        console.error("Error in onUnmount hook:", t);
-      }
-    const e = this.getAdapterMetadata();
-    o.getInstance().plugins.notifyAdapterUnmount(this, e);
-  };
-  // Reset tracking for next render
-  resetTracking() {
-    if (this.trackedPaths.clear(), this.pendingTrackedPaths.clear(), this.subscriptionId) {
-      const e = this.blocInstance._subscriptionManager.subscriptions.get(this.subscriptionId);
-      e && e.dependencies && e.dependencies.clear();
-    }
-  }
-  // Set component name for rerender logging
-  setComponentName(e) {
-    this.componentName = e;
-  }
-  // Notify plugins about render
-  notifyRender() {
-    this.renderCount++, this.isUsingDependencies && this.options?.dependencies && (this.lastDependencyValues = this.dependencyValues, this.dependencyValues = this.options.dependencies(this.blocInstance));
-    const e = this.getAdapterMetadata();
-    o.getInstance().plugins.notifyAdapterRender(this, e);
-  }
-  // Get adapter metadata for plugins
-  getAdapterMetadata() {
-    return {
-      componentName: this.componentName,
-      blocInstance: this.blocInstance,
-      renderCount: this.renderCount,
-      trackedPaths: Array.from(this.trackedPaths),
-      isUsingDependencies: this.isUsingDependencies,
-      lastState: this.lastState,
-      lastDependencyValues: this.lastDependencyValues,
-      currentDependencyValues: this.dependencyValues
-    };
-  }
-  // Get value at a dot-notated path
-  getValueAtPath(e, t) {
-    const s = t.split(".");
-    let i = e;
-    for (const n of s) {
-      if (i == null) return;
-      i = i[n];
-    }
-    return i;
-  }
-  // Get paths that changed between states
-  getStateChangedPaths(e, t) {
-    const s = [];
-    if (this.trackedPaths.size > 0)
-      for (const i of this.trackedPaths) {
-        if (i.startsWith("_class.")) continue;
-        const n = this.getValueAtPath(e, i), a = this.getValueAtPath(t, i);
-        Object.is(n, a) || s.push(i);
-      }
-    else if (e !== t) {
-      const i = this.getDeepChangedPaths(e, t);
-      if (i.length > 0)
-        return i;
-      s.push("(entire state)");
-    }
-    return s;
-  }
-  // Deep comparison to find all changed paths
-  getDeepChangedPaths(e, t, s = "") {
-    const i = [];
-    if (e === t) return i;
-    if (e == null || t == null)
-      return i.push(s || "(root)"), i;
-    if (typeof e != "object" || typeof t != "object")
-      return e !== t && i.push(s || "(root)"), i;
-    if (Array.isArray(e) || Array.isArray(t)) {
-      if (!Array.isArray(e) || !Array.isArray(t) || e.length !== t.length)
-        return i.push(s || "(root)"), i;
-      for (let a = 0; a < e.length; a++) {
-        const c = s ? `${s}[${a}]` : `[${a}]`;
-        i.push(
-          ...this.getDeepChangedPaths(e[a], t[a], c)
-        );
-      }
-      return i;
-    }
-    const n = /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(t)]);
-    for (const a of n) {
-      const c = s ? `${s}.${a}` : a;
-      if (!(a in e))
-        i.push(`${c} (added)`);
-      else if (!(a in t))
-        i.push(`${c} (removed)`);
-      else {
-        const l = e[a], h = t[a];
-        if (!Object.is(l, h))
-          if (typeof l != "object" || typeof h != "object" || l === null || h === null)
-            i.push(c);
-          else {
-            const p = this.getDeepChangedPaths(
-              l,
-              h,
-              c
-            );
-            p.length > 0 ? i.push(...p) : i.push(c);
-          }
-      }
-    }
-    return i;
-  }
-  // Get last rerender reason
-  getLastRerenderReason() {
-  }
-}
-export {
-  o as Blac,
-  G as BlacAdapter,
-  m as BlacError,
-  R as Bloc,
-  C as BlocBase,
-  B as BlocLifecycleManager,
-  u as BlocLifecycleState,
-  w as BlocPluginRegistry,
-  j as BlocTest,
-  O as Cubit,
-  P as DefaultErrorStrategy,
-  v as ErrorCategory,
-  f as ErrorManager,
-  y as ErrorSeverity,
-  W as MemoryLeakDetector,
-  z as MockBloc,
-  q as MockCubit,
-  L as PropsUpdated,
-  $ as ProxyFactory,
-  F as RerenderLogger,
-  E as SubscriptionManager,
-  T as SystemPluginRegistry,
-  M as createBlocProxy,
-  _ as createStateProxy,
-  N as generateInstanceIdFromProps,
-  A as generateUUID,
-  x as handleError,
-  H as setBlacInstanceManager,
-  V as shallowEqual
-};
-//# sourceMappingURL=index.es.js.map