@likec4/diagram 1.55.1 → 1.57.0

package/dist/node_modules/.pnpm/@xstate_store@3.17.1_react@19.2.4/node_modules/@xstate/store/dist/store-cfe7da62.cjs.js

@@ -1,761 +0,0 @@
-import { __exports as storeCfe7da62_cjs } from '../../../../../../../_virtual/store-cfe7da62.cjs.js';
-
-var hasRequiredStoreCfe7da62_cjs;
-
-function requireStoreCfe7da62_cjs () {
-	if (hasRequiredStoreCfe7da62_cjs) return storeCfe7da62_cjs;
-	hasRequiredStoreCfe7da62_cjs = 1;
-
-	/* eslint-disable */
-	// Adapted from Alien Signals
-	// https://github.com/stackblitz/alien-signals/
-
-	let ReactiveFlags = /*#__PURE__*/function (ReactiveFlags) {
-	  ReactiveFlags[ReactiveFlags["None"] = 0] = "None";
-	  ReactiveFlags[ReactiveFlags["Mutable"] = 1] = "Mutable";
-	  ReactiveFlags[ReactiveFlags["Watching"] = 2] = "Watching";
-	  ReactiveFlags[ReactiveFlags["RecursedCheck"] = 4] = "RecursedCheck";
-	  ReactiveFlags[ReactiveFlags["Recursed"] = 8] = "Recursed";
-	  ReactiveFlags[ReactiveFlags["Dirty"] = 16] = "Dirty";
-	  ReactiveFlags[ReactiveFlags["Pending"] = 32] = "Pending";
-	  return ReactiveFlags;
-	}({});
-	function createReactiveSystem({
-	  update,
-	  notify,
-	  unwatched
-	}) {
-	  return {
-	    link,
-	    unlink,
-	    propagate,
-	    checkDirty,
-	    shallowPropagate
-	  };
-	  function link(dep, sub, version) {
-	    const prevDep = sub.depsTail;
-	    if (prevDep !== undefined && prevDep.dep === dep) {
-	      return;
-	    }
-	    const nextDep = prevDep !== undefined ? prevDep.nextDep : sub.deps;
-	    if (nextDep !== undefined && nextDep.dep === dep) {
-	      nextDep.version = version;
-	      sub.depsTail = nextDep;
-	      return;
-	    }
-	    const prevSub = dep.subsTail;
-	    if (prevSub !== undefined && prevSub.version === version && prevSub.sub === sub) {
-	      return;
-	    }
-	    const newLink = sub.depsTail = dep.subsTail = {
-	      version,
-	      dep,
-	      sub,
-	      prevDep,
-	      nextDep,
-	      prevSub,
-	      nextSub: undefined
-	    };
-	    if (nextDep !== undefined) {
-	      nextDep.prevDep = newLink;
-	    }
-	    if (prevDep !== undefined) {
-	      prevDep.nextDep = newLink;
-	    } else {
-	      sub.deps = newLink;
-	    }
-	    if (prevSub !== undefined) {
-	      prevSub.nextSub = newLink;
-	    } else {
-	      dep.subs = newLink;
-	    }
-	  }
-	  function unlink(link, sub = link.sub) {
-	    const dep = link.dep;
-	    const prevDep = link.prevDep;
-	    const nextDep = link.nextDep;
-	    const nextSub = link.nextSub;
-	    const prevSub = link.prevSub;
-	    if (nextDep !== undefined) {
-	      nextDep.prevDep = prevDep;
-	    } else {
-	      sub.depsTail = prevDep;
-	    }
-	    if (prevDep !== undefined) {
-	      prevDep.nextDep = nextDep;
-	    } else {
-	      sub.deps = nextDep;
-	    }
-	    if (nextSub !== undefined) {
-	      nextSub.prevSub = prevSub;
-	    } else {
-	      dep.subsTail = prevSub;
-	    }
-	    if (prevSub !== undefined) {
-	      prevSub.nextSub = nextSub;
-	    } else if ((dep.subs = nextSub) === undefined) {
-	      unwatched(dep);
-	    }
-	    return nextDep;
-	  }
-	  function propagate(link) {
-	    let next = link.nextSub;
-	    let stack;
-	    top: do {
-	      const sub = link.sub;
-	      let flags = sub.flags;
-	      if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed | ReactiveFlags.Dirty | ReactiveFlags.Pending))) {
-	        sub.flags = flags | ReactiveFlags.Pending;
-	      } else if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed))) {
-	        flags = ReactiveFlags.None;
-	      } else if (!(flags & ReactiveFlags.RecursedCheck)) {
-	        sub.flags = flags & ~ReactiveFlags.Recursed | ReactiveFlags.Pending;
-	      } else if (!(flags & (ReactiveFlags.Dirty | ReactiveFlags.Pending)) && isValidLink(link, sub)) {
-	        sub.flags = flags | (ReactiveFlags.Recursed | ReactiveFlags.Pending);
-	        flags &= ReactiveFlags.Mutable;
-	      } else {
-	        flags = ReactiveFlags.None;
-	      }
-	      if (flags & ReactiveFlags.Watching) {
-	        notify(sub);
-	      }
-	      if (flags & ReactiveFlags.Mutable) {
-	        const subSubs = sub.subs;
-	        if (subSubs !== undefined) {
-	          const nextSub = (link = subSubs).nextSub;
-	          if (nextSub !== undefined) {
-	            stack = {
-	              value: next,
-	              prev: stack
-	            };
-	            next = nextSub;
-	          }
-	          continue;
-	        }
-	      }
-	      if ((link = next) !== undefined) {
-	        next = link.nextSub;
-	        continue;
-	      }
-	      while (stack !== undefined) {
-	        link = stack.value;
-	        stack = stack.prev;
-	        if (link !== undefined) {
-	          next = link.nextSub;
-	          continue top;
-	        }
-	      }
-	      break;
-	    } while (true);
-	  }
-	  function checkDirty(link, sub) {
-	    let stack;
-	    let checkDepth = 0;
-	    let dirty = false;
-	    top: do {
-	      const dep = link.dep;
-	      const flags = dep.flags;
-	      if (sub.flags & ReactiveFlags.Dirty) {
-	        dirty = true;
-	      } else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) === (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) {
-	        if (update(dep)) {
-	          const subs = dep.subs;
-	          if (subs.nextSub !== undefined) {
-	            shallowPropagate(subs);
-	          }
-	          dirty = true;
-	        }
-	      } else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Pending)) === (ReactiveFlags.Mutable | ReactiveFlags.Pending)) {
-	        if (link.nextSub !== undefined || link.prevSub !== undefined) {
-	          stack = {
-	            value: link,
-	            prev: stack
-	          };
-	        }
-	        link = dep.deps;
-	        sub = dep;
-	        ++checkDepth;
-	        continue;
-	      }
-	      if (!dirty) {
-	        const nextDep = link.nextDep;
-	        if (nextDep !== undefined) {
-	          link = nextDep;
-	          continue;
-	        }
-	      }
-	      while (checkDepth--) {
-	        const firstSub = sub.subs;
-	        const hasMultipleSubs = firstSub.nextSub !== undefined;
-	        if (hasMultipleSubs) {
-	          link = stack.value;
-	          stack = stack.prev;
-	        } else {
-	          link = firstSub;
-	        }
-	        if (dirty) {
-	          if (update(sub)) {
-	            if (hasMultipleSubs) {
-	              shallowPropagate(firstSub);
-	            }
-	            sub = link.sub;
-	            continue;
-	          }
-	          dirty = false;
-	        } else {
-	          sub.flags &= ~ReactiveFlags.Pending;
-	        }
-	        sub = link.sub;
-	        const nextDep = link.nextDep;
-	        if (nextDep !== undefined) {
-	          link = nextDep;
-	          continue top;
-	        }
-	      }
-	      return dirty;
-	    } while (true);
-	  }
-	  function shallowPropagate(link) {
-	    do {
-	      const sub = link.sub;
-	      const flags = sub.flags;
-	      if ((flags & (ReactiveFlags.Pending | ReactiveFlags.Dirty)) === ReactiveFlags.Pending) {
-	        sub.flags = flags | ReactiveFlags.Dirty;
-	        if ((flags & (ReactiveFlags.Watching | ReactiveFlags.RecursedCheck)) === ReactiveFlags.Watching) {
-	          notify(sub);
-	        }
-	      }
-	    } while ((link = link.nextSub) !== undefined);
-	  }
-	  function isValidLink(checkLink, sub) {
-	    let link = sub.depsTail;
-	    while (link !== undefined) {
-	      if (link === checkLink) {
-	        return true;
-	      }
-	      link = link.prevDep;
-	    }
-	    return false;
-	  }
-	}
-
-	function toObserver(nextHandler, errorHandler, completionHandler) {
-	  const isObserver = typeof nextHandler === 'object';
-	  const self = isObserver ? nextHandler : undefined;
-	  return {
-	    next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
-	    error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
-	    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
-	  };
-	}
-
-	const queuedEffects = [];
-	let cycle = 0;
-	const {
-	  link,
-	  unlink,
-	  propagate,
-	  checkDirty,
-	  shallowPropagate
-	} = createReactiveSystem({
-	  update(atom) {
-	    return atom._update();
-	  },
-	  notify(effect) {
-	    queuedEffects[queuedEffectsLength++] = effect;
-	    effect.flags &= ~ReactiveFlags.Watching;
-	  },
-	  unwatched(atom) {
-	    if (atom.depsTail !== undefined) {
-	      atom.depsTail = undefined;
-	      atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-	      purgeDeps(atom);
-	    }
-	  }
-	});
-	let notifyIndex = 0;
-	let queuedEffectsLength = 0;
-	let activeSub;
-	function purgeDeps(sub) {
-	  const depsTail = sub.depsTail;
-	  let dep = depsTail !== undefined ? depsTail.nextDep : sub.deps;
-	  while (dep !== undefined) {
-	    dep = unlink(dep, sub);
-	  }
-	}
-	function flush() {
-	  while (notifyIndex < queuedEffectsLength) {
-	    const effect = queuedEffects[notifyIndex];
-	    queuedEffects[notifyIndex++] = undefined;
-	    effect.notify();
-	  }
-	  notifyIndex = 0;
-	  queuedEffectsLength = 0;
-	}
-	function createAsyncAtom(getValue, options) {
-	  const ref = {};
-	  const atom = createAtom(() => {
-	    getValue().then(data => {
-	      const internalAtom = ref.current;
-	      if (internalAtom._update({
-	        status: 'done',
-	        data
-	      })) {
-	        const subs = internalAtom.subs;
-	        if (subs !== undefined) {
-	          propagate(subs);
-	          shallowPropagate(subs);
-	          flush();
-	        }
-	      }
-	    }, error => {
-	      const internalAtom = ref.current;
-	      if (internalAtom._update({
-	        status: 'error',
-	        error
-	      })) {
-	        const subs = internalAtom.subs;
-	        if (subs !== undefined) {
-	          propagate(subs);
-	          shallowPropagate(subs);
-	          flush();
-	        }
-	      }
-	    });
-	    return {
-	      status: 'pending'
-	    };
-	  }, options);
-	  ref.current = atom;
-	  return atom;
-	}
-	function createAtom(valueOrFn, options) {
-	  const isComputed = typeof valueOrFn === 'function';
-	  const getter = valueOrFn;
-
-	  // Create plain object atom
-	  const atom = {
-	    _snapshot: isComputed ? undefined : valueOrFn,
-	    subs: undefined,
-	    subsTail: undefined,
-	    deps: undefined,
-	    depsTail: undefined,
-	    flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,
-	    get() {
-	      if (activeSub !== undefined) {
-	        link(atom, activeSub, cycle);
-	      }
-	      return atom._snapshot;
-	    },
-	    subscribe(observerOrFn) {
-	      const obs = toObserver(observerOrFn);
-	      const observed = {
-	        current: false
-	      };
-	      const e = effect(() => {
-	        atom.get();
-	        if (!observed.current) {
-	          observed.current = true;
-	        } else {
-	          obs.next?.(atom._snapshot);
-	        }
-	      });
-	      return {
-	        unsubscribe: () => {
-	          e.stop();
-	        }
-	      };
-	    },
-	    _update(getValue) {
-	      const prevSub = activeSub;
-	      const compare = options?.compare ?? Object.is;
-	      activeSub = atom;
-	      ++cycle;
-	      atom.depsTail = undefined;
-	      if (isComputed) {
-	        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;
-	      }
-	      try {
-	        const oldValue = atom._snapshot;
-	        const read = a => a.get();
-	        const newValue = typeof getValue === 'function' ? getValue(oldValue) : getValue === undefined && isComputed ? getter(read, oldValue) : getValue;
-	        if (oldValue === undefined || !compare(oldValue, newValue)) {
-	          atom._snapshot = newValue;
-	          return true;
-	        }
-	        return false;
-	      } finally {
-	        activeSub = prevSub;
-	        if (isComputed) {
-	          atom.flags &= ~ReactiveFlags.RecursedCheck;
-	        }
-	        purgeDeps(atom);
-	      }
-	    }
-	  };
-	  if (isComputed) {
-	    atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-	    atom.get = function () {
-	      const flags = atom.flags;
-	      if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(atom.deps, atom)) {
-	        if (atom._update()) {
-	          const subs = atom.subs;
-	          if (subs !== undefined) {
-	            shallowPropagate(subs);
-	          }
-	        }
-	      } else if (flags & ReactiveFlags.Pending) {
-	        atom.flags = flags & ~ReactiveFlags.Pending;
-	      }
-	      if (activeSub !== undefined) {
-	        link(atom, activeSub, cycle);
-	      }
-	      return atom._snapshot;
-	    };
-	  } else {
-	    atom.set = function (valueOrFn) {
-	      if (atom._update(valueOrFn)) {
-	        const subs = atom.subs;
-	        if (subs !== undefined) {
-	          propagate(subs);
-	          shallowPropagate(subs);
-	          flush();
-	        }
-	      }
-	    };
-	  }
-	  return atom;
-	}
-	function effect(fn) {
-	  const run = () => {
-	    const prevSub = activeSub;
-	    activeSub = effectObj;
-	    ++cycle;
-	    effectObj.depsTail = undefined;
-	    effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
-	    try {
-	      return fn();
-	    } finally {
-	      activeSub = prevSub;
-	      effectObj.flags &= ~ReactiveFlags.RecursedCheck;
-	      purgeDeps(effectObj);
-	    }
-	  };
-	  const effectObj = {
-	    deps: undefined,
-	    depsTail: undefined,
-	    subs: undefined,
-	    subsTail: undefined,
-	    flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,
-	    notify() {
-	      const flags = this.flags;
-	      if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(this.deps, this)) {
-	        run();
-	      } else {
-	        this.flags = ReactiveFlags.Watching;
-	      }
-	    },
-	    stop() {
-	      this.flags = ReactiveFlags.None;
-	      this.depsTail = undefined;
-	      purgeDeps(this);
-	    }
-	  };
-	  run();
-	  return effectObj;
-	}
-
-	const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
-	const inspectionObservers = new WeakMap();
-	function createStoreCore(logic, emits) {
-	  let listeners;
-	  const initialSnapshot = logic.getInitialSnapshot();
-	  let currentSnapshot = initialSnapshot;
-	  const atom = createAtom(currentSnapshot);
-	  const emit = ev => {
-	    if (!listeners) {
-	      return;
-	    }
-	    const type = ev.type;
-	    const typeListeners = listeners.get(type);
-	    if (typeListeners) {
-	      typeListeners.forEach(listener => listener(ev));
-	    }
-	    const wildcardListeners = listeners.get('*');
-	    if (wildcardListeners) {
-	      wildcardListeners.forEach(listener => listener(ev));
-	    }
-	  };
-	  const transition = logic.transition;
-	  function receive(event) {
-	    const [nextSnapshot, effects] = transition(currentSnapshot, event);
-	    currentSnapshot = nextSnapshot;
-	    inspectionObservers.get(store)?.forEach(observer => {
-	      observer.next?.({
-	        type: '@xstate.snapshot',
-	        event,
-	        snapshot: nextSnapshot,
-	        actorRef: store,
-	        rootId: store.sessionId
-	      });
-	    });
-	    atom.set(nextSnapshot);
-	    for (const effect of effects) {
-	      if (typeof effect === 'function') {
-	        effect();
-	      } else {
-	        // handle the inherent effect first
-	        emits?.[effect.type]?.(effect);
-	        emit(effect);
-	      }
-	    }
-	  }
-	  const store = {
-	    get _snapshot() {
-	      return atom._snapshot;
-	    },
-	    on(emittedEventType, handler) {
-	      if (!listeners) {
-	        listeners = new Map();
-	      }
-	      let eventListeners = listeners.get(emittedEventType);
-	      if (!eventListeners) {
-	        eventListeners = new Set();
-	        listeners.set(emittedEventType, eventListeners);
-	      }
-	      const wrappedHandler = handler.bind(undefined);
-	      eventListeners.add(wrappedHandler);
-	      return {
-	        unsubscribe() {
-	          eventListeners.delete(wrappedHandler);
-	        }
-	      };
-	    },
-	    transition: logic.transition,
-	    // TODO: fix this
-	    sessionId: uniqueId(),
-	    send(event) {
-	      inspectionObservers.get(store)?.forEach(observer => {
-	        observer.next?.({
-	          type: '@xstate.event',
-	          event,
-	          sourceRef: undefined,
-	          actorRef: store,
-	          rootId: store.sessionId
-	        });
-	      });
-	      receive(event);
-	    },
-	    getSnapshot() {
-	      return currentSnapshot;
-	    },
-	    get() {
-	      return atom.get();
-	    },
-	    getInitialSnapshot() {
-	      return initialSnapshot;
-	    },
-	    subscribe: atom.subscribe.bind(atom),
-	    [symbolObservable]() {
-	      return this;
-	    },
-	    inspect: observerOrFn => {
-	      const observer = toObserver(observerOrFn);
-	      inspectionObservers.set(store, inspectionObservers.get(store) ?? new Set());
-	      inspectionObservers.get(store).add(observer);
-	      observer.next?.({
-	        type: '@xstate.actor',
-	        actorRef: store,
-	        rootId: store.sessionId
-	      });
-	      observer.next?.({
-	        type: '@xstate.snapshot',
-	        snapshot: initialSnapshot,
-	        event: {
-	          type: '@xstate.init'
-	        },
-	        actorRef: store,
-	        rootId: store.sessionId
-	      });
-	      return {
-	        unsubscribe() {
-	          return inspectionObservers.get(store)?.delete(observer);
-	        }
-	      };
-	    },
-	    trigger: new Proxy({}, {
-	      get: (_, eventType) => {
-	        return payload => {
-	          store.send({
-	            ...payload,
-	            type: eventType
-	          });
-	        };
-	      }
-	    }),
-	    select(selector, equalityFn = Object.is) {
-	      return createAtom(() => selector(store.get().context), {
-	        compare: equalityFn
-	      });
-	    },
-	    with(extension) {
-	      const extendedLogic = extension(logic);
-	      return createStoreCore(extendedLogic, emits);
-	    }
-	  };
-	  return store;
-	}
-
-	/**
-	 * Creates a **store** that has its own internal state and can be sent events
-	 * that update its internal state based on transitions.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * const store = createStore({
-	 *   context: { count: 0, name: 'Ada' },
-	 *   on: {
-	 *     inc: (context, event: { by: number }) => ({
-	 *       ...context,
-	 *       count: context.count + event.by
-	 *     })
-	 *   }
-	 * });
-	 *
-	 * store.subscribe((snapshot) => {
-	 *   console.log(snapshot);
-	 * });
-	 *
-	 * store.send({ type: 'inc', by: 5 });
-	 * // Logs { context: { count: 5, name: 'Ada' }, status: 'active', ... }
-	 * ```
-	 *
-	 * @param config - The store configuration object
-	 * @param config.context - The initial state of the store
-	 * @param config.on - An object mapping event types to transition functions
-	 * @param config.emits - An object mapping emitted event types to handlers
-	 * @returns A store instance with methods to send events and subscribe to state
-	 *   changes
-	 */
-
-	function createStore(definitionOrLogic) {
-	  if ('transition' in definitionOrLogic) {
-	    return createStoreCore(definitionOrLogic);
-	  }
-	  const transition = createStoreTransition(definitionOrLogic.on);
-	  const logic = {
-	    getInitialSnapshot: () => ({
-	      status: 'active',
-	      context: definitionOrLogic.context,
-	      output: undefined,
-	      error: undefined
-	    }),
-	    transition
-	  };
-	  return createStoreCore(logic, definitionOrLogic.emits);
-	}
-	function _createStoreConfig(definition) {
-	  return definition;
-	}
-	const createStoreConfig = _createStoreConfig;
-
-	/**
-	 * Creates a `Store` with a provided producer (such as Immer's `producer(…)` A
-	 * store has its own internal state and can receive events.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * import { produce } from 'immer';
-	 *
-	 * const store = createStoreWithProducer(produce, {
-	 *   context: { count: 0 },
-	 *   on: {
-	 *     inc: (context, event: { by: number }) => {
-	 *       context.count += event.by;
-	 *     }
-	 *   }
-	 * });
-	 *
-	 * store.subscribe((snapshot) => {
-	 *   console.log(snapshot);
-	 * });
-	 *
-	 * store.send({ type: 'inc', by: 5 });
-	 * // Logs { context: { count: 5 }, status: 'active', ... }
-	 * ```
-	 */
-	function createStoreWithProducer(producer, config) {
-	  const transition = createStoreTransition(config.on, producer);
-	  const logic = {
-	    getInitialSnapshot: () => ({
-	      status: 'active',
-	      context: config.context,
-	      output: undefined,
-	      error: undefined
-	    }),
-	    transition
-	  };
-	  return createStoreCore(logic, config.emits);
-	}
-	/**
-	 * Creates a store transition function that handles state updates based on
-	 * events.
-	 *
-	 * @param transitions - An object mapping event types to transition functions
-	 * @param producer - Optional producer function (e.g., Immer's produce) for
-	 *   immutable updates
-	 * @returns A transition function that takes a snapshot and event and returns a
-	 *   new snapshot with effects
-	 */
-	function createStoreTransition(transitions, producer) {
-	  return (snapshot, event) => {
-	    const currentContext = snapshot.context;
-	    const assigner = transitions?.[event.type];
-	    const effects = [];
-	    const enqueue = {
-	      emit: new Proxy({}, {
-	        get: (_, eventType) => {
-	          return payload => {
-	            effects.push({
-	              ...payload,
-	              type: eventType
-	            });
-	          };
-	        }
-	      }),
-	      effect: fn => {
-	        effects.push(fn);
-	      }
-	    };
-	    if (!assigner) {
-	      return [snapshot, effects];
-	    }
-	    const nextContext = producer ? producer(currentContext, draftContext => assigner(draftContext, event, enqueue)) : assigner(currentContext, event, enqueue) ?? currentContext;
-	    return [nextContext === currentContext ? snapshot : {
-	      ...snapshot,
-	      context: nextContext
-	    }, effects];
-	  };
-	}
-
-	/**
-	 * Generates a unique 6-character identifier.
-	 *
-	 * @returns A random string identifier
-	 */
-	function uniqueId() {
-	  return Math.random().toString(36).slice(6);
-	}
-
-	storeCfe7da62_cjs.createAsyncAtom = createAsyncAtom;
-	storeCfe7da62_cjs.createAtom = createAtom;
-	storeCfe7da62_cjs.createStore = createStore;
-	storeCfe7da62_cjs.createStoreConfig = createStoreConfig;
-	storeCfe7da62_cjs.createStoreTransition = createStoreTransition;
-	storeCfe7da62_cjs.createStoreWithProducer = createStoreWithProducer;
-	return storeCfe7da62_cjs;
-}
-
-export { requireStoreCfe7da62_cjs as __require };