@blac/core 2.0.0 → 2.0.1

package/dist/index.es.js

@@ -1,670 +0,0 @@
-var B = Object.defineProperty;
-var m = (c, t, e) => t in c ? B(c, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : c[t] = e;
-var n = (c, t, e) => m(c, typeof t != "symbol" ? t + "" : t, e);
-var _ = /* @__PURE__ */ ((c) => (c.BLOC_DISPOSED = "BLOC_DISPOSED", c.BLOC_CREATED = "BLOC_CREATED", c.LISTENER_REMOVED = "LISTENER_REMOVED", c.LISTENER_ADDED = "LISTENER_ADDED", c.STATE_CHANGED = "STATE_CHANGED", c.BLOC_CONSUMER_REMOVED = "BLOC_CONSUMER_REMOVED", c.BLOC_CONSUMER_ADDED = "BLOC_CONSUMER_ADDED", c))(_ || {});
-const r = class r {
-  /**
-   * Creates a new Blac instance.
-   * @param options - Configuration options including singleton control
-   */
-  constructor(t = {}) {
-    /** Timestamp when the instance was created */
-    n(this, "createdAt", Date.now());
-    /** Map storing all registered bloc instances by their class name and ID */
-    n(this, "blocInstanceMap", /* @__PURE__ */ new Map());
-    /** Map storing isolated bloc instances grouped by their constructor */
-    n(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
-    n(this, "pluginList", []);
-    /** Flag to control whether changes should be posted to document */
-    n(this, "postChangesToDocument", !1);
-    /**
-     * Logs messages to console when logging is enabled
-     * @param args - Arguments to log
-     */
-    n(this, "log", (...t) => {
-      r.enableLog && console.warn(`☢️ [Blac ${this.createdAt.toString()}]`, ...t);
-    });
-    /**
-     * Logs a warning message
-     * @param message - Warning message
-     * @param args - Additional arguments
-     */
-    n(this, "warn", (t, ...e) => {
-      r.enableLog && console.warn(`🚨 [Blac ${String(r.instance.createdAt)}]`, t, ...e);
-    });
-    /**
-     * Logs an error message
-     * @param message - Error message
-     * @param args - Additional arguments
-     */
-    n(this, "error", (t, ...e) => {
-      r.enableLog && console.error(`🚨 [Blac ${String(r.instance.createdAt)}]`, t, ...e);
-    });
-    /**
-     * Resets the Blac instance to a new one, disposing non-keepAlive blocs
-     * from the old instance.
-     */
-    n(this, "resetInstance", () => {
-      this.log("Reset Blac instance");
-      const t = new Map(this.blocInstanceMap), e = new Map(this.isolatedBlocMap);
-      t.forEach((s) => {
-        s._dispose();
-      }), e.forEach((s) => {
-        s.forEach((i) => {
-          i._dispose();
-        });
-      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), r.instance = new r({
-        __unsafe_ignore_singleton: !0
-      });
-    });
-    /**
-     * Adds a plugin to the Blac instance
-     * @param plugin - The plugin to add
-     */
-    n(this, "addPlugin", (t) => {
-      this.pluginList.findIndex((s) => s.name === t.name) === -1 && (this.log("Add plugin", t.name), this.pluginList.push(t));
-    });
-    /**
-     * Dispatches a lifecycle event to all registered plugins
-     * @param event - The lifecycle event to dispatch
-     * @param bloc - The bloc instance involved in the event
-     * @param params - Additional parameters for the event
-     */
-    n(this, "dispatchEventToPlugins", (t, e, s) => {
-      this.pluginList.forEach((i) => {
-        i.onEvent(t, e, s);
-      });
-    });
-    /**
-     * Dispatches a lifecycle event and handles related cleanup actions.
-     * This method is responsible for:
-     * - Logging the event
-     * - Handling bloc disposal when needed
-     * - Managing bloc consumer cleanup
-     * - Forwarding the event to plugins
-     * 
-     * @param event - The lifecycle event to dispatch
-     * @param bloc - The bloc instance involved in the event
-     * @param params - Additional parameters for the event
-     */
-    n(this, "dispatchEvent", (t, e, s) => {
-      switch (this.log(t, e, s), t) {
-        case "BLOC_DISPOSED":
-          this.disposeBloc(e);
-          break;
-        case "BLOC_CONSUMER_REMOVED":
-        case "LISTENER_REMOVED":
-          this.log(`[${e._name}:${String(e._id)}] Listener/Consumer removed. Listeners: ${String(e._observer.size)}, Consumers: ${String(e._consumers.size)}, KeepAlive: ${String(e._keepAlive)}`), e._observer.size === 0 && e._consumers.size === 0 && !e._keepAlive && (this.log(`[${e._name}:${String(e._id)}] No listeners or consumers left and not keepAlive. Disposing.`), e._dispose());
-          break;
-      }
-      this.dispatchEventToPlugins(t, e, s);
-    });
-    /**
-     * Disposes of a bloc instance by removing it from the appropriate registry
-     * @param bloc - The bloc instance to dispose
-     */
-    n(this, "disposeBloc", (t) => {
-      const e = t.constructor, s = this.createBlocInstanceMapKey(t._name, t._id);
-      this.log(`[${t._name}:${String(t._id)}] disposeBloc called. Isolated: ${String(e.isolated)}`), e.isolated ? (this.unregisterIsolatedBlocInstance(t), this.blocInstanceMap.delete(s)) : this.unregisterBlocInstance(t), this.dispatchEventToPlugins("BLOC_DISPOSED", t);
-    });
-    /**
-     * 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
-     */
-    n(this, "getBloc", (t, e = {}) => {
-      const { id: s } = e, i = t, a = s ?? t.name;
-      if (this.log(`[${t.name}:${String(a)}] getBloc called. Options:`, e), i.isolated) {
-        const o = this.findIsolatedBlocInstance(t, a);
-        if (o)
-          return this.log(`[${t.name}:${String(a)}] Found existing isolated instance.`), o;
-      }
-      if (!i.isolated) {
-        const o = this.findRegisteredBlocInstance(t, a);
-        if (o)
-          return this.log(`[${t.name}:${String(a)}] Found existing registered instance.`), o;
-      }
-      return this.log(`[${t.name}:${String(a)}] No existing instance found. Creating new one.`), this.createNewBlocInstance(
-        t,
-        a,
-        e
-      );
-    });
-    /**
-     * Gets a bloc instance or throws an error if it doesn't exist
-     * @param blocClass - The bloc class to get
-     * @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
-     */
-    n(this, "getBlocOrThrow", (t, e = {}) => {
-      const s = t.isolated, i = e.id || t.name, a = s ? this.findIsolatedBlocInstance(t, i) : this.findRegisteredBlocInstance(t, i);
-      if (a)
-        return a;
-      throw new Error(`Bloc ${t.name} not found`);
-    });
-    /**
-     * 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
-     */
-    n(this, "getAllBlocs", (t, e = {}) => {
-      const s = [];
-      if (this.blocInstanceMap.forEach((i) => {
-        i.constructor === t && s.push(i);
-      }), e.searchIsolated !== !1) {
-        const i = this.isolatedBlocMap.get(t);
-        i && s.push(...i.map((a) => a));
-      }
-      return s;
-    });
-    const { __unsafe_ignore_singleton: e = !1 } = t;
-    if (!e)
-      return r.instance;
-    r.instance = this;
-  }
-  /**
-   * Gets the singleton instance of Blac
-   * @returns The Blac instance
-   */
-  static getInstance() {
-    return r.instance;
-  }
-  /**
-   * 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(t, e) {
-    return `${t}:${String(e)}`;
-  }
-  /**
-   * Unregister a bloc instance from the main registry
-   * @param bloc - The bloc instance to unregister
-   */
-  unregisterBlocInstance(t) {
-    const e = this.createBlocInstanceMapKey(t._name, t._id);
-    this.blocInstanceMap.delete(e);
-  }
-  /**
-   * Registers a bloc instance in the main registry
-   * @param bloc - The bloc instance to register
-   */
-  registerBlocInstance(t) {
-    const e = this.createBlocInstanceMapKey(t._name, t._id);
-    this.blocInstanceMap.set(e, t);
-  }
-  /**
-   * 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(t, e) {
-    if (t.isolated) return;
-    const i = this.createBlocInstanceMapKey(t.name, e), a = this.blocInstanceMap.get(i);
-    return a && this.log(`[${t.name}:${String(e)}] Found registered instance. Returning.`), a;
-  }
-  /**
-   * Registers an isolated bloc instance in the isolated registry
-   * @param bloc - The isolated bloc instance to register
-   */
-  registerIsolatedBlocInstance(t) {
-    const e = t.constructor, s = this.isolatedBlocMap.get(e);
-    s ? s.push(t) : this.isolatedBlocMap.set(e, [t]);
-  }
-  /**
-   * Unregister an isolated bloc instance from the isolated registry
-   * @param bloc - The isolated bloc instance to unregister
-   */
-  unregisterIsolatedBlocInstance(t) {
-    const e = t.constructor, s = this.isolatedBlocMap.get(e);
-    if (s) {
-      const i = s.findIndex((a) => a._id === t._id);
-      i !== -1 && s.splice(i, 1), s.length === 0 && this.isolatedBlocMap.delete(e);
-    }
-  }
-  /**
-   * Finds an isolated bloc instance by its class and ID
-   */
-  findIsolatedBlocInstance(t, e) {
-    if (!t.isolated) return;
-    const i = this.isolatedBlocMap.get(t);
-    if (!i) return;
-    const a = i.find((o) => o._id === e);
-    return a && this.log(`[${t.name}:${String(e)}] Found isolated instance. Returning.`), a;
-  }
-  /**
-   * 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(t, e, s = {}) {
-    const { props: i, instanceRef: a } = s, o = new t(i);
-    return o._instanceRef = a, o.props = i || null, o._updateId(e), o.isIsolated ? (this.registerIsolatedBlocInstance(o), o) : (this.registerBlocInstance(o), o);
-  }
-};
-/** The singleton instance of Blac */
-n(r, "instance", new r()), n(r, "getAllBlocs", r.instance.getAllBlocs), n(r, "addPlugin", r.instance.addPlugin), /** Flag to enable/disable logging */
-n(r, "enableLog", !1), n(r, "log", r.instance.log), n(r, "warn", r.instance.warn), n(r, "error", r.instance.error), n(r, "resetInstance", r.instance.resetInstance), n(r, "getBloc", r.instance.getBloc), n(r, "getBlocOrThrow", r.instance.getBlocOrThrow);
-let h = r;
-class D {
-  /**
-   * Creates a new BlacObservable instance
-   * @param bloc - The Bloc instance to observe
-   */
-  constructor(t) {
-    /** The Bloc instance this observable is associated with */
-    n(this, "bloc");
-    n(this, "_observers", /* @__PURE__ */ new Set());
-    this.bloc = t;
-  }
-  /**
-   * Gets the number of active observers
-   * @returns The number of observers currently subscribed
-   */
-  get size() {
-    return this._observers.size;
-  }
-  /**
-   * Gets the set of all observers
-   * @returns The Set of all BlacObserver instances
-   */
-  get observers() {
-    return this._observers;
-  }
-  /**
-   * Subscribes an observer to state changes
-   * @param observer - The observer to subscribe
-   * @returns A function that can be called to unsubscribe the observer
-   */
-  subscribe(t) {
-    return this._observers.add(t), h.instance.dispatchEvent(_.LISTENER_ADDED, this.bloc, { listenerId: t.id }), t.lastState || (t.lastState = t.dependencyArray ? t.dependencyArray(this.bloc.state, this.bloc.state) : []), () => {
-      this.unsubscribe(t);
-    };
-  }
-  /**
-   * Unsubscribes an observer from state changes
-   * @param observer - The observer to unsubscribe
-   */
-  unsubscribe(t) {
-    this._observers.delete(t), h.instance.dispatchEvent(_.LISTENER_REMOVED, this.bloc, { listenerId: t.id });
-  }
-  /**
-   * Notifies all observers of a state change
-   * @param newState - The new state value
-   * @param oldState - The previous state value
-   * @param action - Optional action that triggered the state change
-   */
-  notify(t, e, s) {
-    this._observers.forEach((i) => {
-      let a = !1;
-      if (i.dependencyArray) {
-        const o = i.lastState || [], g = i.dependencyArray(t, e);
-        for (let p = 0; p < g.length; p++) {
-          const S = g[p], d = o[p] || [];
-          for (let l = 0; l < S.length; l++)
-            if (!Object.is(S[l], d[l])) {
-              a = !0;
-              break;
-            }
-        }
-        i.lastState = g;
-      } else
-        a = !0;
-      a && i.fn(t, e, s);
-    });
-  }
-  /**
-   * Disposes of all observers and clears the observer set
-   */
-  dispose() {
-    this._observers.forEach((t) => {
-      var e;
-      this.unsubscribe(t), (e = t.dispose) == null || e.call(t);
-    }), this._observers.clear();
-  }
-}
-class E {
-  /**
-   * Creates a new BlocBase instance with the given initial state.
-   * Sets up the observer, registers with the Blac manager, and initializes addons.
-   * 
-   * @param initialState The initial state value for this Bloc
-   */
-  constructor(t) {
-    /**
-     * Defines how dependencies are selected from the state for efficient updates.
-     * When provided, observers will only be notified when selected dependencies change.
-     */
-    n(this, "defaultDependencySelector");
-    /**
-     * @internal
-     * Optional array of addons to extend the functionality of this Bloc.
-     */
-    n(this, "_addons");
-    /**
-     * @internal
-     * Indicates if this specific Bloc instance is isolated from others of the same type.
-     */
-    n(this, "_isolated", !1);
-    /**
-     * @internal
-     * Observable responsible for managing state listeners and notifying consumers.
-     */
-    n(this, "_observer");
-    /**
-     * @internal
-     * Reference to the global Blac manager instance.
-     */
-    n(this, "_blac", h.getInstance());
-    /**
-     * The unique identifier for this Bloc instance.
-     * Defaults to the class name, but can be customized.
-     */
-    n(this, "_id");
-    /**
-     * @internal
-     * Reference string used internally for tracking and debugging.
-     */
-    n(this, "_instanceRef");
-    /**
-     * @internal
-     * Indicates if this specific Bloc instance should be kept alive when no consumers are present.
-     */
-    n(this, "_keepAlive", !1);
-    /**
-     * @readonly
-     * Timestamp when this Bloc instance was created, useful for debugging and performance tracking.
-     */
-    n(this, "_createdAt", Date.now());
-    /**
-     * @internal
-     * The current state of the Bloc.
-     */
-    n(this, "_state");
-    /**
-     * @internal
-     * The previous state of the Bloc, maintained for comparison and history.
-     */
-    n(this, "_oldState");
-    /**
-     * Props passed during Bloc instance creation.
-     * Can be used to configure or parameterize the Bloc's behavior.
-     */
-    n(this, "props", null);
-    /**
-     * @internal
-     * Updates the Bloc instance's ID to a new value.
-     * Only updates if the new ID is defined and different from the current one.
-     * 
-     * @param id The new ID to assign to this Bloc instance
-     */
-    n(this, "_updateId", (t) => {
-      const e = this._id;
-      !t || t === e || (this._id = t);
-    });
-    /**
-     * @internal
-     * Optional function to be called when the Bloc is disposed.
-     */
-    n(this, "onDispose");
-    /**
-     * @internal
-     * Set of consumer IDs currently listening to this Bloc's state changes.
-     */
-    n(this, "_consumers", /* @__PURE__ */ new Set());
-    /**
-     * @internal
-     * Registers a new consumer to this Bloc instance.
-     * Notifies the Blac manager that a consumer has been added.
-     * 
-     * @param consumerId The unique ID of the consumer being added
-     */
-    n(this, "_addConsumer", (t) => {
-      this._consumers.add(t), this._blac.dispatchEvent(_.BLOC_CONSUMER_ADDED, this, { consumerId: t });
-    });
-    /**
-     * @internal
-     * Unregisters a consumer from this Bloc instance.
-     * Notifies the Blac manager that a consumer has been removed.
-     * 
-     * @param consumerId The unique ID of the consumer being removed
-     */
-    n(this, "_removeConsumer", (t) => {
-      this._blac.log(`[${this._name}:${String(this._id ?? "default_id")}] Removing consumer: ${t}`), this._consumers.delete(t), this._blac.dispatchEvent(_.BLOC_CONSUMER_REMOVED, this, { consumerId: t });
-    });
-    /**
-     * @internal
-     * Initializes all registered addons for this Bloc instance.
-     * Calls the onInit lifecycle method on each addon if defined.
-     */
-    n(this, "_connectAddons", () => {
-      const { _addons: t } = this;
-      t && t.forEach((e) => {
-        var s;
-        (s = e.onInit) == null || s.call(e, this);
-      });
-    });
-    n(this, "lastUpdate", Date.now());
-    /**
-     * @internal
-     * Updates the state and notifies all observers of the change.
-     * 
-     * @param newState The new state to be set
-     * @param oldState The previous state for comparison
-     * @param action Optional metadata about what caused the state change
-     */
-    n(this, "_pushState", (t, e, s) => {
-      this._state = t, this._observer.notify(t, e, s), this.lastUpdate = Date.now();
-    });
-    this._state = t, this._observer = new D(this), this._blac.dispatchEvent(_.BLOC_CREATED, this), this._id = this.constructor.name;
-    const e = this.constructor;
-    this._keepAlive = e.keepAlive, this._isolated = e.isolated, this._addons = e.addons, this._connectAddons();
-  }
-  get isIsolated() {
-    return this._isolated;
-  }
-  get isKeepAlive() {
-    return this._keepAlive;
-  }
-  /**
-   * Returns the current state of the Bloc.
-   * Use this getter to access the state in a read-only manner.
-   */
-  get state() {
-    return this._state;
-  }
-  /**
-   * @internal
-   * Returns the name of the Bloc class for identification and debugging.
-   */
-  get _name() {
-    return this.constructor.name;
-  }
-  /**
-   * @internal
-   * Cleans up resources and removes this Bloc from the system.
-   * Notifies the Blac manager and clears all observers.
-   */
-  _dispose() {
-    var t;
-    this._observer.dispose(), this._blac.dispatchEvent(_.BLOC_DISPOSED, this), (t = this.onDispose) == null || t.call(this);
-  }
-}
-/**
- * When true, every consumer will receive its own unique instance of this Bloc.
- * Use this when state should not be shared between components.
- * @default false
- */
-n(E, "isolated", !1), /**
- * When true, the Bloc instance persists even when there are no active consumers.
- * Useful for maintaining state between component unmount/remount cycles.
- * @default false
- */
-n(E, "keepAlive", !1);
-class M extends E {
-  /**
-   * 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(t) {
-    if (Object.is(t, this.state))
-      return;
-    const e = this.state, s = t;
-    this._pushState(s, e);
-  }
-  /**
-   * 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(t, e = !1) {
-    if (typeof this.state != "object" || this.state === null) {
-      h.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 (e)
-      s = !0;
-    else
-      for (const i in t)
-        if (Object.prototype.hasOwnProperty.call(t, i)) {
-          const o = this.state[i];
-          if (!Object.is(t[i], o)) {
-            s = !0;
-            break;
-          }
-        }
-    s && this.emit({
-      ...this.state,
-      ...t
-    });
-  }
-}
-class w extends E {
-  constructor() {
-    super(...arguments);
-    // Stores handlers: Map<EventConstructor (subtype of A), HandlerFunction>
-    // The handler's event parameter will be correctly typed to the specific EventConstructor
-    // by the 'on' method's signature.
-    n(this, "eventHandlers", /* @__PURE__ */ new Map());
-    /**
-     * Dispatches an action/event to the Bloc.
-     * If a handler is registered for this specific event type (via 'on'), it will be invoked.
-     * Asynchronous handlers are awaited.
-     * @param action The action/event instance to be processed.
-     */
-    n(this, "add", async (e) => {
-      const s = e.constructor, i = this.eventHandlers.get(s);
-      if (i) {
-        const a = (o) => {
-          const g = this.state;
-          this._pushState(o, g, e);
-        };
-        try {
-          await i(e, a);
-        } catch (o) {
-          h.error(
-            `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${s.name}':`,
-            o,
-            "Action:",
-            e
-          );
-        }
-      } else {
-        const a = e.constructor.name || "UnnamedConstructor";
-        h.warn(
-          `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${a}'. Action was:`,
-          e
-        );
-      }
-    });
-  }
-  /**
-   * 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, s) {
-    this.eventHandlers.has(e) && h.warn(
-      `[Bloc ${this._name}:${String(this._id)}] Handler for event '${e.name}' already registered. It will be overwritten.`
-    ), this.eventHandlers.set(
-      e,
-      s
-    );
-  }
-}
-function I(c) {
-  switch (c) {
-    case "localStorage":
-      return localStorage;
-    case "sessionStorage":
-      return sessionStorage;
-    default:
-      return localStorage;
-  }
-}
-function $(c = {}) {
-  const {
-    keyPrefix: t = "blac",
-    keyName: e,
-    defaultValue: s,
-    storageType: i = "localStorage"
-  } = c, a = (d) => `${t}:${String(d)}`, o = (d) => {
-    var l;
-    try {
-      const u = I(i).getItem(a(d));
-      if (typeof u != "string")
-        return s;
-      const f = JSON.parse(u);
-      return typeof f.v < "u" ? f.v : s;
-    } catch (u) {
-      return (l = c.onError) == null || l.call(c, u), s;
-    }
-  }, g = (d) => {
-    const l = e ?? d._id, u = o(l);
-    d._pushState(u, null);
-  };
-  let p = "";
-  return {
-    name: "Persist",
-    onInit: g,
-    onEmit: ({ newState: d, cubit: l }) => {
-      const u = e ?? l._id, f = JSON.stringify({ v: d });
-      f !== p && (I(i).setItem(a(u), f), p = f);
-    }
-  };
-}
-export {
-  h as Blac,
-  _ as BlacLifecycleEvent,
-  D as BlacObservable,
-  w as Bloc,
-  E as BlocBase,
-  M as Cubit,
-  $ as Persist
-};
-//# sourceMappingURL=index.es.js.map