{"version":3,"file":"index.cjs","sources":["../src/createIsolation.tsx","../src/types.ts","../src/utils.ts","../src/env.ts","../src/ScopeProvider/scope.ts","../src/ScopeProvider/ScopeProvider.tsx"],"sourcesContent":["import { createContext, createElement, useContext, useRef } from 'react'\nimport type { ReactNode } from 'react'\nimport {\n  useAtom as useAtomOrig,\n  useAtomValue as useAtomValueOrig,\n  useSetAtom as useSetAtomOrig,\n  useStore as useStoreOrig,\n} from 'jotai/react'\nimport { useHydrateAtoms } from 'jotai/react/utils'\nimport { createStore } from 'jotai/vanilla'\nimport type { INTERNAL_Store as Store } from 'jotai/vanilla/internals'\nimport type { AnyWritableAtom } from './types'\n\ntype CreateIsolationResult = {\n  Provider: (props: {\n    store?: Store\n    initialValues?: Iterable<readonly [AnyWritableAtom, unknown]>\n    children: ReactNode\n  }) => React.JSX.Element\n  useStore: typeof useStoreOrig\n  useAtom: typeof useAtomOrig\n  useAtomValue: typeof useAtomValueOrig\n  useSetAtom: typeof useSetAtomOrig\n}\n\nexport function createIsolation(): CreateIsolationResult {\n  const StoreContext = createContext<Store | null>(null)\n\n  function Provider({\n    store,\n    initialValues = [],\n    children,\n  }: {\n    store?: Store\n    initialValues?: Iterable<readonly [AnyWritableAtom, unknown]>\n    children: ReactNode\n  }) {\n    const storeRef = useRef(store)\n    if (!storeRef.current) {\n      storeRef.current = createStore()\n    }\n    useHydrateAtoms(initialValues as any, { store: storeRef.current })\n    return createElement(StoreContext.Provider, {\n      value: storeRef.current,\n      children,\n    })\n  }\n\n  const useStore = ((options?: any) => {\n    const store = useContext(StoreContext)\n    if (!store) throw new Error('Missing Provider from createIsolation')\n    return useStoreOrig({ store, ...options })\n  }) as typeof useStoreOrig\n\n  const useAtom = ((anAtom: any, options?: any) => {\n    const store = useStore()\n    return useAtomOrig(anAtom, { store, ...options })\n  }) as typeof useAtomOrig\n\n  const useAtomValue = ((anAtom: any, options?: any) => {\n    const store = useStore()\n    return useAtomValueOrig(anAtom, { store, ...options })\n  }) as typeof useAtomValueOrig\n\n  const useSetAtom = ((anAtom: any, options?: any) => {\n    const store = useStore()\n    return useSetAtomOrig(anAtom, { store, ...options })\n  }) as typeof useSetAtomOrig\n\n  return { Provider, useStore, useAtom, useAtomValue, useSetAtom }\n}\n","import { type Atom, type WritableAtom } from 'jotai'\nimport type {\n  INTERNAL_ChangedAtoms as ChangedAtoms,\n  INTERNAL_StoreHooks,\n  INTERNAL_Store as Store,\n} from 'jotai/vanilla/internals'\nimport type { AtomFamily } from 'jotai/vanilla/utils/atomFamily'\n\nexport type ScopedStore = Store\n\nexport type AnyAtom = Atom<any> | AnyWritableAtom\n\nexport type AnyAtomFamily = AtomFamily<any, AnyAtom>\n\nexport type AnyWritableAtom = WritableAtom<any, any[], any>\n\nexport type Scope = {\n  /**\n   * Returns a scoped atom from the original atom.\n   * @param anAtom\n   * @param implicitScope the atom is implicitly scoped in the provided scope\n   * @returns the scoped atom and the scope of the atom\n   */\n  getAtom: <T extends AnyAtom>(anAtom: T, implicitScope?: Scope) => [T, Scope?]\n\n  /**\n   * Cleans up the scope\n   */\n  cleanup: () => void\n\n  /**\n   * @modifies the atom's write function for atoms that can hold a value\n   * @returns a function to restore the original write function\n   */\n  prepareWriteAtom: <T extends AnyAtom>(\n    anAtom: T,\n    originalAtom: T,\n    implicitScope?: Scope,\n    writeScope?: Scope\n  ) => (() => void) | undefined\n\n  /**\n   * The base store (unpatched) that this scope is built on\n   */\n  baseStore: Store\n\n  /**\n   * @debug\n   */\n  name?: string\n\n  /**\n   * @debug\n   */\n  toString?: () => string\n}\n\n/**\n * WeakMap to store the scope associated with each scoped store\n */\nexport const storeScopeMap = new WeakMap<Store, Scope>()\n\nexport type AtomDefault = readonly [AnyWritableAtom, unknown]\n\nexport type WithOriginal<T extends AnyAtom> = T & {\n  originalAtom: T\n}\n\ntype Mutable<T> = { -readonly [P in keyof T]: T[P] }\n\nexport type StoreHooks = Mutable<INTERNAL_StoreHooks>\n\nexport type StoreHookForAtoms = NonNullable<StoreHooks['c']>\n\nexport type WeakSetForAtoms = ChangedAtoms\n\nexport type WeakMapForAtoms = {\n  get(atom: AnyAtom): any\n  set(atom: AnyAtom, value: any): void\n} & (\n  | { has(atom: AnyAtom): boolean; delete(atom: AnyAtom): void }\n  | Record<never, never>\n)\n","import type { AnyAtom, AnyWritableAtom } from './types'\n\nexport function isEqualSize(\n  aIter: Iterable<unknown>,\n  bIter: Iterable<unknown>\n) {\n  const a = new Set(aIter)\n  const b = new Set(bIter)\n  return (\n    aIter === bIter || (a.size === b.size && Array.from(a).every(b.has.bind(b)))\n  )\n}\n\nexport function toNameString(this: { name: string }) {\n  return this.name\n}\n\nexport function isWritableAtom(atom: AnyAtom): atom is AnyWritableAtom {\n  return 'write' in atom\n}\n","export const __DEV__ =\n  typeof import.meta !== 'undefined' &&\n  import.meta.env !== undefined &&\n  import.meta.env.MODE === 'development'\n    ? true\n    : process.env.NODE_ENV !== 'production'\n","import type { Atom, WritableAtom } from 'jotai'\nimport { atom as createAtom } from 'jotai'\nimport {\n  INTERNAL_buildStoreRev2 as buildStore,\n  INTERNAL_getBuildingBlocksRev2 as getBuildingBlocks,\n} from 'jotai/vanilla/internals'\nimport type {\n  INTERNAL_AtomState as AtomState,\n  INTERNAL_AtomStateMap as AtomStateMap,\n  INTERNAL_BuildingBlocks as BuildingBlocks,\n  INTERNAL_EnsureAtomState as EnsureAtomState,\n  INTERNAL_Mounted as Mounted,\n  INTERNAL_Store as Store,\n} from 'jotai/vanilla/internals'\nimport { __DEV__ } from '../env'\nimport type {\n  AnyAtom,\n  AnyAtomFamily,\n  AnyWritableAtom,\n  Scope,\n  ScopedStore,\n  StoreHookForAtoms,\n  StoreHooks,\n  WeakMapForAtoms,\n  WeakSetForAtoms,\n  WithOriginal,\n} from '../types'\nimport { storeScopeMap } from '../types'\nimport { isWritableAtom, toNameString } from '../utils'\n\nconst globalScopeKey: { name?: string } = {}\nif (__DEV__) {\n  globalScopeKey.name = 'unscoped'\n  globalScopeKey.toString = toNameString\n}\n\ntype GlobalScopeKey = typeof globalScopeKey\n\nexport function createScope({\n  atoms = [],\n  atomFamilies = [],\n  parentStore,\n  name: scopeName,\n}: {\n  atoms?: Iterable<AnyAtom>\n  atomFamilies?: Iterable<AnyAtomFamily>\n  parentStore: Store | ScopedStore\n  name?: string\n}): ScopedStore {\n  const atomsSet = new Set(atoms)\n  const atomFamilySet = new Set(atomFamilies)\n  const parentScope = storeScopeMap.get(parentStore)\n  // Get the base store - either from parent scope or use parentStore as base\n  const baseStore = parentScope?.baseStore ?? parentStore\n\n  const explicit = new WeakMap<AnyAtom, [AnyAtom, Scope?]>()\n  const implicit = new WeakMap<AnyAtom, [AnyAtom, Scope?]>()\n  type ScopeMap = WeakMap<AnyAtom, [AnyAtom, Scope?]>\n  const inherited = new WeakMap<Scope | GlobalScopeKey, ScopeMap>()\n\n  const currentScope: Scope = {\n    getAtom,\n    baseStore,\n    cleanup() {\n      for (const cleanupFamilyListeners of cleanupFamiliesSet) {\n        cleanupFamilyListeners()\n      }\n    },\n    prepareWriteAtom(atom, originalAtom, implicitScope, writeScope) {\n      if (\n        originalAtom.read === defaultRead &&\n        isWritableAtom(originalAtom) &&\n        isWritableAtom(atom) &&\n        originalAtom.write !== defaultWrite &&\n        currentScope !== implicitScope\n      ) {\n        // atom is writable with init and holds a value\n        // we need to preserve the value, so we don't want to copy the atom\n        // instead, we need to override write until the write is finished\n        const { write } = originalAtom\n        atom.write = createScopedWrite(\n          originalAtom.write.bind(\n            originalAtom\n          ) as (typeof originalAtom)['write'],\n          implicitScope,\n          writeScope\n        )\n        return () => {\n          atom.write = write\n        }\n      }\n      return undefined\n    },\n  }\n  const scopedStore = createPatchedStore(currentScope)\n  storeScopeMap.set(scopedStore, currentScope)\n\n  if (scopeName && __DEV__) {\n    currentScope.name = scopeName\n    currentScope.toString = toNameString\n  }\n\n  // populate explicitly scoped atoms\n  for (const atom of atomsSet) {\n    explicit.set(atom, [cloneAtom(atom, currentScope), currentScope])\n  }\n\n  const cleanupFamiliesSet = new Set<() => void>()\n  for (const atomFamily of atomFamilySet) {\n    for (const param of atomFamily.getParams()) {\n      const atom = atomFamily(param)\n      if (!explicit.has(atom)) {\n        explicit.set(atom, [cloneAtom(atom, currentScope), currentScope])\n      }\n    }\n    const cleanupFamily = atomFamily.unstable_listen((e) => {\n      if (e.type === 'CREATE' && !explicit.has(e.atom)) {\n        explicit.set(e.atom, [cloneAtom(e.atom, currentScope), currentScope])\n      } else if (!atomsSet.has(e.atom)) {\n        explicit.delete(e.atom)\n      }\n    })\n    cleanupFamiliesSet.add(cleanupFamily)\n  }\n\n  return scopedStore\n\n  /**\n   * Returns a scoped atom from the original atom.\n   * @param atom\n   * @param implicitScope the atom is implicitly scoped in the provided scope\n   * @returns the scoped atom and the scope of the atom\n   */\n  function getAtom<T extends AnyAtom>(\n    atom: T,\n    implicitScope?: Scope\n  ): [T, Scope?] {\n    if (explicit.has(atom)) {\n      return explicit.get(atom) as [T, Scope]\n    }\n    if (implicitScope === currentScope) {\n      // dependencies of explicitly scoped atoms are implicitly scoped\n      // implicitly scoped atoms are only accessed by implicit and explicit scoped atoms\n      if (!implicit.has(atom)) {\n        implicit.set(atom, [cloneAtom(atom, implicitScope), implicitScope])\n      }\n      return implicit.get(atom) as [T, Scope]\n    }\n    const scopeKey = implicitScope ?? globalScopeKey\n    if (parentScope) {\n      // inherited atoms are copied so they can access scoped atoms\n      // but they are not explicitly scoped\n      // dependencies of inherited atoms first check if they are explicitly scoped\n      // otherwise they use their original scope's atom\n      if (!inherited.get(scopeKey)?.has(atom)) {\n        const [ancestorAtom, explicitScope] = parentScope.getAtom(\n          atom,\n          implicitScope\n        )\n        setInheritedAtom(\n          inheritAtom(ancestorAtom, atom, explicitScope),\n          atom,\n          implicitScope,\n          explicitScope\n        )\n      }\n      return inherited.get(scopeKey)!.get(atom) as [T, Scope]\n    }\n    if (!inherited.get(scopeKey)?.has(atom)) {\n      // non-primitive atoms may need to access scoped atoms\n      // so we need to create a copy of the atom\n      setInheritedAtom(inheritAtom(atom, atom), atom)\n    }\n    return inherited.get(scopeKey)!.get(atom) as [T, Scope?]\n  }\n\n  function setInheritedAtom<T extends AnyAtom>(\n    scopedAtom: T,\n    originalAtom: T,\n    implicitScope?: Scope,\n    explicitScope?: Scope\n  ) {\n    const scopeKey = implicitScope ?? globalScopeKey\n    if (!inherited.has(scopeKey)) {\n      inherited.set(scopeKey, new WeakMap())\n    }\n    inherited.get(scopeKey)!.set(\n      originalAtom,\n      [\n        scopedAtom, //\n        explicitScope,\n      ].filter(Boolean) as [T, Scope?]\n    )\n  }\n\n  /** @returns a copy of the atom for derived atoms or the original atom for primitive and writable atoms */\n  function inheritAtom<T>(\n    atom: Atom<T>,\n    originalAtom: Atom<T>,\n    implicitScope?: Scope\n  ) {\n    if (originalAtom.read !== defaultRead) {\n      return cloneAtom(originalAtom, implicitScope)\n    }\n    return atom\n  }\n\n  /** @returns a scoped copy of the atom */\n  function cloneAtom<T>(originalAtom: Atom<T>, implicitScope?: Scope) {\n    // avoid reading `init` to preserve lazy initialization\n    const propDesc = Object.getOwnPropertyDescriptors(originalAtom)\n    Object.keys(propDesc)\n      .filter((k) => ['read', 'write', 'debugLabel'].includes(k))\n      .forEach((k) => (propDesc[k].configurable = true))\n    const atomProto = Object.getPrototypeOf(originalAtom)\n    const scopedAtom: WithOriginal<Atom<T>> = Object.create(atomProto, propDesc)\n    scopedAtom.originalAtom = originalAtom\n\n    if (scopedAtom.read !== defaultRead) {\n      scopedAtom.read = createScopedRead<typeof scopedAtom>(\n        originalAtom.read.bind(originalAtom),\n        implicitScope\n      )\n    }\n\n    if (\n      isWritableAtom(scopedAtom) &&\n      isWritableAtom(originalAtom) &&\n      scopedAtom.write !== defaultWrite\n    ) {\n      scopedAtom.write = createScopedWrite(\n        originalAtom.write.bind(originalAtom),\n        implicitScope\n      )\n    }\n    if (__DEV__) {\n      Object.defineProperty(scopedAtom, 'debugLabel', {\n        get() {\n          return `${originalAtom.debugLabel}@${currentScope.name}`\n        },\n        configurable: true,\n        enumerable: true,\n      })\n    }\n\n    return scopedAtom\n  }\n\n  function createScopedRead<T extends Atom<unknown>>(\n    read: T['read'],\n    implicitScope?: Scope\n  ): T['read'] {\n    return function scopedRead(get, opts) {\n      return read(\n        function scopedGet(a) {\n          const [scopedAtom] = getAtom(a, implicitScope)\n          return get(scopedAtom)\n        }, //\n        opts\n      )\n    }\n  }\n\n  function createScopedWrite<T extends AnyWritableAtom>(\n    write: T['write'],\n    implicitScope?: Scope,\n    writeScope = implicitScope\n  ): T['write'] {\n    return function scopedWrite(get, set, ...args) {\n      return write(\n        function scopedGet(a) {\n          const [scopedAtom] = getAtom(a, implicitScope)\n          return get(scopedAtom)\n        },\n        function scopedSet(a, ...v) {\n          const [scopedAtom] = getAtom(a, implicitScope)\n          const restore = currentScope.prepareWriteAtom(\n            scopedAtom,\n            a,\n            implicitScope,\n            writeScope\n          )\n          try {\n            return set(scopedAtom, ...v)\n          } finally {\n            restore?.()\n          }\n        },\n        ...args\n      )\n    }\n  }\n}\n\nconst { read: defaultRead, write: defaultWrite } = createAtom<unknown>(null)\n\n/** @returns a patched store that intercepts atom access to apply the scope */\nfunction createPatchedStore(scope: Scope): ScopedStore {\n  const storeState: BuildingBlocks = [...getBuildingBlocks(scope.baseStore)]\n  const storeGet = storeState[21]\n  const storeSet = storeState[22]\n  const storeSub = storeState[23]\n  const alreadyPatched: StoreHooks = {}\n\n  storeState[9] = (_: Store, atom: AnyAtom) =>\n    atom.unstable_onInit?.(scopedStore)\n  storeState[21] = patchStoreFn(storeGet)\n  storeState[22] = scopedSet\n  storeState[23] = patchStoreFn(storeSub)\n  storeState[24] = ([...buildingBlocks]) => {\n    const patchedBuildingBlocks: BuildingBlocks = [\n      patchWeakMap(buildingBlocks[0], patchGetAtomState), // atomStateMap\n      patchWeakMap(buildingBlocks[1], patchGetMounted), // mountedMap\n      patchWeakMap(buildingBlocks[2]), // invalidatedAtoms\n      patchSet(buildingBlocks[3]), // changedAtoms\n      buildingBlocks[4], // mountCallbacks\n      buildingBlocks[5], // unmountCallbacks\n      patchStoreHooks(buildingBlocks[6]), // storeHooks\n      patchStoreFn(buildingBlocks[7]), // atomRead\n      patchStoreFn(buildingBlocks[8]), // atomWrite\n      buildingBlocks[9], // atomOnInit\n      patchStoreFn(buildingBlocks[10]), // atomOnMount\n      patchStoreFn(\n        buildingBlocks[11], // ensureAtomState\n        (fn) => patchEnsureAtomState(patchedBuildingBlocks[0], fn)\n      ),\n      buildingBlocks[12], // flushCallbacks\n      buildingBlocks[13], // recomputeInvalidatedAtoms\n      patchStoreFn(buildingBlocks[14]), // readAtomState\n      patchStoreFn(buildingBlocks[15]), // invalidateDependents\n      patchStoreFn(buildingBlocks[16]), // writeAtomState\n      patchStoreFn(buildingBlocks[17]), // mountDependencies\n      patchStoreFn(buildingBlocks[18]), // mountAtom\n      patchStoreFn(buildingBlocks[19]), // unmountAtom\n      patchStoreFn(buildingBlocks[20]), // setAtomStateValueOrPromise\n      patchStoreFn(buildingBlocks[21]), // getAtom\n      patchStoreFn(buildingBlocks[22]), // setAtom\n      patchStoreFn(buildingBlocks[23]), // subAtom\n      undefined, // enhanceBuildingBlocks\n    ]\n    return patchedBuildingBlocks\n  }\n  const scopedStore = buildStore(...storeState)\n  return scopedStore\n\n  // ---------------------------------------------------------------------------------\n\n  function patchGetAtomState<T extends BuildingBlocks[0]['get']>(fn: T) {\n    const patchedASM = new WeakMap<AnyAtom, AtomState>()\n    return function patchedGetAtomState(atom) {\n      let patchedAtomState = patchedASM.get(atom)\n      if (patchedAtomState) {\n        return patchedAtomState\n      }\n      const atomState = fn(atom)\n      if (!atomState) {\n        return undefined\n      }\n      patchedAtomState = {\n        ...atomState,\n        d: patchWeakMap(atomState.d, function patchGetDependency(fn) {\n          return (k) => fn(scope.getAtom(k)[0])\n        }),\n        p: patchSet(atomState.p),\n        get n() {\n          return atomState.n\n        },\n        set n(v) {\n          atomState.n = v\n        },\n        get v() {\n          return atomState.v\n        },\n        set v(v) {\n          atomState.v = v\n        },\n        get e() {\n          return atomState.e\n        },\n        set e(v) {\n          atomState.e = v\n        },\n      } as AtomState\n      patchedASM.set(atom, patchedAtomState)\n      return patchedAtomState\n    } as T\n  }\n\n  function patchGetMounted<T extends BuildingBlocks[1]['get']>(fn: T) {\n    const patchedMM = new WeakMap<AnyAtom, Mounted>()\n    return function patchedGetMounted(atom: AnyAtom) {\n      let patchedMounted = patchedMM.get(atom)\n      if (patchedMounted) {\n        return patchedMounted\n      }\n      const mounted = fn(atom)\n      if (!mounted) {\n        return undefined\n      }\n      patchedMounted = {\n        ...mounted,\n        d: patchSet(mounted.d),\n        t: patchSet(mounted.t),\n        get u() {\n          return mounted.u\n        },\n        set u(v) {\n          mounted.u = v\n        },\n      } as Mounted\n      patchedMM.set(atom, patchedMounted)\n      return mounted\n    } as T\n  }\n\n  function patchEnsureAtomState(patchedASM: AtomStateMap, fn: EnsureAtomState) {\n    return function patchedEnsureAtomState(store, atom) {\n      const patchedAtomState = patchedASM.get(atom)\n      if (patchedAtomState) {\n        return patchedAtomState\n      }\n      patchedASM.set(atom, fn(store, atom))\n      return patchedASM.get(atom)\n    } as EnsureAtomState\n  }\n\n  function scopedSet<Value, Args extends any[], Result>(\n    store: Store,\n    atom: WritableAtom<Value, Args, Result>,\n    ...args: Args\n  ) {\n    const [scopedAtom, implicitScope] = scope.getAtom(atom)\n    const restore = scope.prepareWriteAtom(\n      scopedAtom,\n      atom,\n      implicitScope,\n      scope\n    )\n    try {\n      return storeSet(store, scopedAtom, ...args)\n    } finally {\n      restore?.()\n    }\n  }\n\n  function patchAtomFn<T extends (...args: any[]) => any>(\n    fn: T,\n    patch?: (fn: T) => T\n  ) {\n    return function scopedAtomFn(atom, ...args) {\n      const [scopedAtom] = scope.getAtom(atom)\n      const f = patch ? patch(fn) : fn\n      return f(scopedAtom, ...args)\n    } as T\n  }\n\n  function patchStoreFn<T extends (...args: any[]) => any>(\n    fn: T,\n    patch?: (fn: T) => T\n  ) {\n    return function scopedStoreFn(store, atom, ...args) {\n      const [scopedAtom] = scope.getAtom(atom)\n      const f = patch ? patch(fn) : fn\n      return f(store, scopedAtom, ...args)\n    } as T\n  }\n\n  function patchWeakMap<T extends WeakMapForAtoms>(\n    wm: T,\n    patch?: (fn: T['get']) => T['get']\n  ): T {\n    const patchedWm: any = {\n      get: patchAtomFn(wm.get.bind(wm), patch),\n      set: patchAtomFn(wm.set.bind(wm)),\n    }\n    if ('has' in wm) {\n      patchedWm.has = patchAtomFn(wm.has.bind(wm))\n    }\n    if ('delete' in wm) {\n      patchedWm.delete = patchAtomFn(wm.delete.bind(wm))\n    }\n    return patchedWm\n  }\n\n  function patchSet(s: WeakSetForAtoms) {\n    return {\n      get size() {\n        return s.size\n      },\n      add: patchAtomFn(s.add.bind(s)),\n      has: patchAtomFn(s.has.bind(s)),\n      clear: s.clear.bind(s),\n      forEach: (cb) => s.forEach(patchAtomFn(cb)),\n      *[Symbol.iterator](): IterableIterator<AnyAtom> {\n        for (const atom of s) yield scope.getAtom(atom)[0]\n      },\n    } as WeakSetForAtoms\n  }\n\n  function patchStoreHook(fn: StoreHookForAtoms | undefined) {\n    if (!fn) {\n      return undefined\n    }\n    const storeHook = patchAtomFn(fn)\n    storeHook.add = function patchAdd(atom, callback) {\n      if (atom === undefined) {\n        return fn.add(undefined, callback)\n      }\n      const [scopedAtom] = scope.getAtom(atom)\n      return fn.add(scopedAtom, callback as () => void)\n    }\n    return storeHook\n  }\n\n  function patchStoreHooks(storeHooks: StoreHooks) {\n    const patchedStoreHooks = {\n      get r() {\n        return (alreadyPatched.r ??= patchStoreHook(storeHooks.r))\n      },\n      set r(v) {\n        storeHooks.r = v!\n      },\n      get c() {\n        return (alreadyPatched.c ??= patchStoreHook(storeHooks.c))\n      },\n      set c(v) {\n        storeHooks.c = v!\n      },\n      get m() {\n        return (alreadyPatched.m ??= patchStoreHook(storeHooks.m))\n      },\n      set m(v) {\n        storeHooks.m = v!\n      },\n      get u() {\n        return (alreadyPatched.u ??= patchStoreHook(storeHooks.u))\n      },\n      set u(v) {\n        storeHooks.u = v!\n      },\n      get f() {\n        return storeHooks.f\n      },\n      set f(v) {\n        storeHooks.f = v\n      },\n    }\n    return Object.assign(patchedStoreHooks, storeHooks)\n  }\n}\n","import type { PropsWithChildren } from 'react'\nimport { createElement, useEffect, useState } from 'react'\nimport { Provider, useStore } from 'jotai/react'\nimport { useHydrateAtoms } from 'jotai/utils'\nimport { INTERNAL_Store as Store } from 'jotai/vanilla/internals'\nimport type { AnyAtom, AnyAtomFamily, AtomDefault, ScopedStore } from '../types'\nimport { storeScopeMap } from '../types'\nimport { isEqualSize } from '../utils'\nimport { createScope } from './scope'\n\ntype BaseProps = PropsWithChildren<{\n  atoms?: Iterable<AnyAtom | AtomDefault>\n  atomFamilies?: Iterable<AnyAtomFamily>\n  name?: string\n}>\n\ntype ProvidedScope = PropsWithChildren<{ scope: ScopedStore }>\n\nexport function ScopeProvider(\n  props: {\n    atoms: Iterable<AnyAtom | AtomDefault>\n  } & BaseProps\n): React.JSX.Element\n\nexport function ScopeProvider(\n  props: {\n    atomFamilies: Iterable<AnyAtomFamily>\n  } & BaseProps\n): React.JSX.Element\n\nexport function ScopeProvider(\n  props: PropsWithChildren<{ scope: ScopedStore }>\n): React.JSX.Element\n\nexport function ScopeProvider(props: BaseProps | ProvidedScope) {\n  const {\n    atoms: atomsOrTuples = [],\n    atomFamilies = [],\n    children,\n    scope: providedScope,\n    name,\n  } = props as BaseProps & ProvidedScope\n  const parentStore: Store = useStore()\n  const atoms = Array.from(atomsOrTuples, (a) => (Array.isArray(a) ? a[0] : a))\n\n  function initialize() {\n    return [\n      providedScope ?? createScope({ atoms, atomFamilies, parentStore, name }),\n      function hasChanged(current: {\n        parentStore: Store\n        atoms: Iterable<AnyAtom | AtomDefault>\n        atomFamilies: Iterable<AnyAtomFamily>\n        providedScope: Store | undefined\n      }) {\n        return (\n          parentStore !== current.parentStore ||\n          !isEqualSize(atoms, current.atoms) ||\n          !isEqualSize(atomFamilies, current.atomFamilies) ||\n          providedScope !== current.providedScope\n        )\n      },\n    ] as const\n  }\n\n  const [[store, hasChanged], setState] = useState(initialize)\n  if (hasChanged({ atoms, atomFamilies, parentStore, providedScope })) {\n    storeScopeMap.get(store)?.cleanup()\n    setState(initialize)\n  }\n  useHydrateAtoms(\n    Array.from(atomsOrTuples).filter(Array.isArray) as AtomDefault[],\n    { store }\n  )\n  useEffect(() => storeScopeMap.get(store)?.cleanup, [store])\n  return createElement(Provider, { store }, children)\n}\n"],"names":["createIsolation","StoreContext","createContext","Provider","store","initialValues","children","storeRef","useRef","createStore","useHydrateAtoms","createElement","useStore","options","useContext","useStoreOrig","anAtom","useAtomOrig","useAtomValueOrig","useSetAtomOrig","storeScopeMap","isEqualSize","aIter","bIter","a","b","toNameString","isWritableAtom","atom","__DEV__","globalScopeKey","createScope","atoms","atomFamilies","parentStore","scopeName","atomsSet","atomFamilySet","parentScope","baseStore","explicit","implicit","inherited","currentScope","getAtom","cleanupFamilyListeners","cleanupFamiliesSet","originalAtom","implicitScope","writeScope","defaultRead","defaultWrite","write","createScopedWrite","scopedStore","createPatchedStore","cloneAtom","atomFamily","param","cleanupFamily","e","scopeKey","_a","ancestorAtom","explicitScope","setInheritedAtom","inheritAtom","_b","scopedAtom","propDesc","k","atomProto","createScopedRead","read","get","opts","set","args","v","restore","createAtom","scope","storeState","getBuildingBlocks","storeGet","storeSet","storeSub","alreadyPatched","_","patchStoreFn","scopedSet","patchedBuildingBlocks","patchWeakMap","buildingBlocks","patchGetAtomState","patchGetMounted","patchSet","patchStoreHooks","fn","patchEnsureAtomState","buildStore","patchedASM","patchedAtomState","atomState","patchedMM","patchedMounted","mounted","patchAtomFn","patch","wm","patchedWm","s","cb","patchStoreHook","storeHook","callback","storeHooks","ScopeProvider","props","atomsOrTuples","providedScope","name","initialize","current","hasChanged","setState","useState","useEffect"],"mappings":"6QAyBO,SAASA,GAAyC,CACjD,MAAAC,EAAeC,gBAA4B,IAAI,EAErD,SAASC,EAAS,CAChB,MAAAC,EACA,cAAAC,EAAgB,CAAC,EACjB,SAAAC,CAAA,EAKC,CACK,MAAAC,EAAWC,SAAOJ,CAAK,EACzB,OAACG,EAAS,UACZA,EAAS,QAAUE,cAAY,GAEjCC,EAAAA,gBAAgBL,EAAsB,CAAE,MAAOE,EAAS,QAAS,EAC1DI,EAAA,cAAcV,EAAa,SAAU,CAC1C,MAAOM,EAAS,QAChB,SAAAD,CAAA,CACD,CAAA,CAGG,MAAAM,EAAaC,GAAkB,CAC7B,MAAAT,EAAQU,aAAWb,CAAY,EACrC,GAAI,CAACG,EAAa,MAAA,IAAI,MAAM,uCAAuC,EACnE,OAAOW,WAAa,CAAE,MAAAX,EAAO,GAAGS,EAAS,CAC3C,EAiBA,MAAO,CAAE,SAAAV,EAAU,SAAAS,EAAU,QAfZ,CAACI,EAAaH,IAAkB,CAC/C,MAAMT,EAAQQ,EAAS,EACvB,OAAOK,UAAYD,EAAQ,CAAE,MAAAZ,EAAO,GAAGS,EAAS,CAClD,EAYsC,aAVhB,CAACG,EAAaH,IAAkB,CACpD,MAAMT,EAAQQ,EAAS,EACvB,OAAOM,eAAiBF,EAAQ,CAAE,MAAAZ,EAAO,GAAGS,EAAS,CACvD,EAOoD,WALhC,CAACG,EAAaH,IAAkB,CAClD,MAAMT,EAAQQ,EAAS,EACvB,OAAOO,aAAeH,EAAQ,CAAE,MAAAZ,EAAO,GAAGS,EAAS,CACrD,CAE+D,CACjE,CCVa,MAAAO,MAAoB,QC1DjB,SAAAC,EACdC,EACAC,EACA,CACM,MAAAC,EAAI,IAAI,IAAIF,CAAK,EACjBG,EAAI,IAAI,IAAIF,CAAK,EACvB,OACED,IAAUC,GAAUC,EAAE,OAASC,EAAE,MAAQ,MAAM,KAAKD,CAAC,EAAE,MAAMC,EAAE,IAAI,KAAKA,CAAC,CAAC,CAE9E,CAEO,SAASC,GAAqC,CACnD,OAAO,KAAK,IACd,CAEO,SAASC,EAAeC,EAAwC,CACrE,MAAO,UAAWA,CACpB,CCnBa,MAAAC,EAKP,QAAQ,IAAI,WAAa,aCyBzBC,EAAoC,CAAC,EACvCD,IACFC,EAAe,KAAO,WACtBA,EAAe,SAAWJ,GAKrB,SAASK,EAAY,CAC1B,MAAAC,EAAQ,CAAC,EACT,aAAAC,EAAe,CAAC,EAChB,YAAAC,EACA,KAAMC,CACR,EAKgB,CACR,MAAAC,EAAW,IAAI,IAAIJ,CAAK,EACxBK,EAAgB,IAAI,IAAIJ,CAAY,EACpCK,EAAclB,EAAc,IAAIc,CAAW,EAE3CK,GAAYD,GAAA,YAAAA,EAAa,YAAaJ,EAEtCM,MAAe,QACfC,MAAe,QAEfC,MAAgB,QAEhBC,EAAsB,CAC1B,QAAAC,EACA,UAAAL,EACA,SAAU,CACR,UAAWM,KAA0BC,EACZD,EAAA,CAE3B,EACA,iBAAiBjB,EAAMmB,EAAcC,EAAeC,EAAY,CAC9D,GACEF,EAAa,OAASG,GACtBvB,EAAeoB,CAAY,GAC3BpB,EAAeC,CAAI,GACnBmB,EAAa,QAAUI,GACvBR,IAAiBK,EACjB,CAIM,KAAA,CAAE,MAAAI,GAAUL,EAClB,OAAAnB,EAAK,MAAQyB,EACXN,EAAa,MAAM,KACjBA,CACF,EACAC,EACAC,CACF,EACO,IAAM,CACXrB,EAAK,MAAQwB,CACf,CAAA,CAEK,CAEX,EACME,EAAcC,EAAmBZ,CAAY,EACrCvB,EAAA,IAAIkC,EAAaX,CAAY,EAEvCR,GAAaN,IACfc,EAAa,KAAOR,EACpBQ,EAAa,SAAWjB,GAI1B,UAAWE,KAAQQ,EACRI,EAAA,IAAIZ,EAAM,CAAC4B,EAAU5B,EAAMe,CAAY,EAAGA,CAAY,CAAC,EAG5D,MAAAG,MAAyB,IAC/B,UAAWW,KAAcpB,EAAe,CAC3B,UAAAqB,KAASD,EAAW,YAAa,CACpC,MAAA7B,EAAO6B,EAAWC,CAAK,EACxBlB,EAAS,IAAIZ,CAAI,GACXY,EAAA,IAAIZ,EAAM,CAAC4B,EAAU5B,EAAMe,CAAY,EAAGA,CAAY,CAAC,CAClE,CAEF,MAAMgB,EAAgBF,EAAW,gBAAiBG,GAAM,CAClDA,EAAE,OAAS,UAAY,CAACpB,EAAS,IAAIoB,EAAE,IAAI,EACpCpB,EAAA,IAAIoB,EAAE,KAAM,CAACJ,EAAUI,EAAE,KAAMjB,CAAY,EAAGA,CAAY,CAAC,EAC1DP,EAAS,IAAIwB,EAAE,IAAI,GACpBpB,EAAA,OAAOoB,EAAE,IAAI,CACxB,CACD,EACDd,EAAmB,IAAIa,CAAa,CAAA,CAG/B,OAAAL,EAQE,SAAAV,EACPhB,EACAoB,EACa,SACT,GAAAR,EAAS,IAAIZ,CAAI,EACZ,OAAAY,EAAS,IAAIZ,CAAI,EAE1B,GAAIoB,IAAkBL,EAGpB,OAAKF,EAAS,IAAIb,CAAI,GACXa,EAAA,IAAIb,EAAM,CAAC4B,EAAU5B,EAAMoB,CAAa,EAAGA,CAAa,CAAC,EAE7DP,EAAS,IAAIb,CAAI,EAE1B,MAAMiC,EAAWb,GAAiBlB,EAClC,GAAIQ,EAAa,CAKf,GAAI,GAACwB,EAAApB,EAAU,IAAImB,CAAQ,IAAtB,MAAAC,EAAyB,IAAIlC,IAAO,CACvC,KAAM,CAACmC,EAAcC,CAAa,EAAI1B,EAAY,QAChDV,EACAoB,CACF,EACAiB,EACEC,EAAYH,EAAcnC,EAAMoC,CAAa,EAC7CpC,EACAoB,EACAgB,CACF,CAAA,CAEF,OAAOtB,EAAU,IAAImB,CAAQ,EAAG,IAAIjC,CAAI,CAAA,CAE1C,OAAKuC,EAAAzB,EAAU,IAAImB,CAAQ,IAAtB,MAAAM,EAAyB,IAAIvC,IAGhCqC,EAAiBC,EAAYtC,EAAMA,CAAI,EAAGA,CAAI,EAEzCc,EAAU,IAAImB,CAAQ,EAAG,IAAIjC,CAAI,CAAA,CAG1C,SAASqC,EACPG,EACArB,EACAC,EACAgB,EACA,CACA,MAAMH,EAAWb,GAAiBlB,EAC7BY,EAAU,IAAImB,CAAQ,GACzBnB,EAAU,IAAImB,EAAc,IAAA,OAAS,EAE7BnB,EAAA,IAAImB,CAAQ,EAAG,IACvBd,EACA,CACEqB,EACAJ,CACF,EAAE,OAAO,OAAO,CAClB,CAAA,CAIO,SAAAE,EACPtC,EACAmB,EACAC,EACA,CACI,OAAAD,EAAa,OAASG,EACjBM,EAAUT,EAAcC,CAAa,EAEvCpB,CAAA,CAIA,SAAA4B,EAAaT,EAAuBC,EAAuB,CAE5D,MAAAqB,EAAW,OAAO,0BAA0BtB,CAAY,EACvD,OAAA,KAAKsB,CAAQ,EACjB,OAAQC,GAAM,CAAC,OAAQ,QAAS,YAAY,EAAE,SAASA,CAAC,CAAC,EACzD,QAASA,GAAOD,EAASC,CAAC,EAAE,aAAe,EAAK,EAC7C,MAAAC,EAAY,OAAO,eAAexB,CAAY,EAC9CqB,EAAoC,OAAO,OAAOG,EAAWF,CAAQ,EAC3E,OAAAD,EAAW,aAAerB,EAEtBqB,EAAW,OAASlB,IACtBkB,EAAW,KAAOI,EAChBzB,EAAa,KAAK,KAAKA,CAAY,EACnCC,CACF,GAIArB,EAAeyC,CAAU,GACzBzC,EAAeoB,CAAY,GAC3BqB,EAAW,QAAUjB,IAErBiB,EAAW,MAAQf,EACjBN,EAAa,MAAM,KAAKA,CAAY,EACpCC,CACF,GAEEnB,GACK,OAAA,eAAeuC,EAAY,aAAc,CAC9C,KAAM,CACJ,MAAO,GAAGrB,EAAa,UAAU,IAAIJ,EAAa,IAAI,EACxD,EACA,aAAc,GACd,WAAY,EAAA,CACb,EAGIyB,CAAA,CAGA,SAAAI,EACPC,EACAzB,EACW,CACJ,OAAA,SAAoB0B,EAAKC,EAAM,CAC7B,OAAAF,EACL,SAAmBjD,EAAG,CACpB,KAAM,CAAC4C,CAAU,EAAIxB,EAAQpB,EAAGwB,CAAa,EAC7C,OAAO0B,EAAIN,CAAU,CACvB,EACAO,CACF,CACF,CAAA,CAGF,SAAStB,EACPD,EACAJ,EACAC,EAAaD,EACD,CACZ,OAAO,SAAqB0B,EAAKE,KAAQC,EAAM,CACtC,OAAAzB,EACL,SAAmB5B,EAAG,CACpB,KAAM,CAAC4C,CAAU,EAAIxB,EAAQpB,EAAGwB,CAAa,EAC7C,OAAO0B,EAAIN,CAAU,CACvB,EACA,SAAmB5C,KAAMsD,EAAG,CAC1B,KAAM,CAACV,CAAU,EAAIxB,EAAQpB,EAAGwB,CAAa,EACvC+B,EAAUpC,EAAa,iBAC3ByB,EACA5C,EACAwB,EACAC,CACF,EACI,GAAA,CACK,OAAA2B,EAAIR,EAAY,GAAGU,CAAC,CAAA,QAC3B,CACUC,GAAA,MAAAA,GAAA,CAEd,EACA,GAAGF,CACL,CACF,CAAA,CAEJ,CAEA,KAAM,CAAE,KAAM3B,EAAa,MAAOC,CAAa,EAAI6B,OAAoB,IAAI,EAG3E,SAASzB,EAAmB0B,EAA2B,CACrD,MAAMC,EAA6B,CAAC,GAAGC,EAAkB,+BAAAF,EAAM,SAAS,CAAC,EACnEG,EAAWF,EAAW,EAAE,EACxBG,EAAWH,EAAW,EAAE,EACxBI,EAAWJ,EAAW,EAAE,EACxBK,EAA6B,CAAC,EAEpCL,EAAW,CAAC,EAAI,CAACM,EAAU5D,WACzB,OAAAkC,EAAAlC,EAAK,kBAAL,YAAAkC,EAAA,KAAAlC,EAAuB0B,IACd4B,EAAA,EAAE,EAAIO,EAAaL,CAAQ,EACtCF,EAAW,EAAE,EAAIQ,EACNR,EAAA,EAAE,EAAIO,EAAaH,CAAQ,EACtCJ,EAAW,EAAE,EAAI,CAAC,KAAkB,IAAM,CACxC,MAAMS,EAAwC,CAC5CC,EAAaC,EAAe,CAAC,EAAGC,CAAiB,EACjDF,EAAaC,EAAe,CAAC,EAAGE,CAAe,EAC/CH,EAAaC,EAAe,CAAC,CAAC,EAC9BG,EAASH,EAAe,CAAC,CAAC,EAC1BA,EAAe,CAAC,EAChBA,EAAe,CAAC,EAChBI,EAAgBJ,EAAe,CAAC,CAAC,EACjCJ,EAAaI,EAAe,CAAC,CAAC,EAC9BJ,EAAaI,EAAe,CAAC,CAAC,EAC9BA,EAAe,CAAC,EAChBJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EACEI,EAAe,EAAE,EAChBK,GAAOC,EAAqBR,EAAsB,CAAC,EAAGO,CAAE,CAC3D,EACAL,EAAe,EAAE,EACjBA,EAAe,EAAE,EACjBJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EAAaI,EAAe,EAAE,CAAC,EAC/BJ,EAAaI,EAAe,EAAE,CAAC,EAC/B,MACF,EACO,OAAAF,CACT,EACM,MAAArC,EAAc8C,0BAAW,GAAGlB,CAAU,EACrC,OAAA5B,EAIP,SAASwC,EAAsDI,EAAO,CAC9D,MAAAG,MAAiB,QAChB,OAAA,SAA6BzE,EAAM,CACpC,IAAA0E,EAAmBD,EAAW,IAAIzE,CAAI,EAC1C,GAAI0E,EACK,OAAAA,EAEH,MAAAC,EAAYL,EAAGtE,CAAI,EACzB,GAAK2E,EAGc,OAAAD,EAAA,CACjB,GAAGC,EACH,EAAGX,EAAaW,EAAU,EAAG,SAA4BL,EAAI,CACpD,OAAC5B,GAAM4B,EAAGjB,EAAM,QAAQX,CAAC,EAAE,CAAC,CAAC,CAAA,CACrC,EACD,EAAG0B,EAASO,EAAU,CAAC,EACvB,IAAI,GAAI,CACN,OAAOA,EAAU,CACnB,EACA,IAAI,EAAEzB,EAAG,CACPyB,EAAU,EAAIzB,CAChB,EACA,IAAI,GAAI,CACN,OAAOyB,EAAU,CACnB,EACA,IAAI,EAAEzB,EAAG,CACPyB,EAAU,EAAIzB,CAChB,EACA,IAAI,GAAI,CACN,OAAOyB,EAAU,CACnB,EACA,IAAI,EAAEzB,EAAG,CACPyB,EAAU,EAAIzB,CAAA,CAElB,EACWuB,EAAA,IAAIzE,EAAM0E,CAAgB,EAC9BA,CACT,CAAA,CAGF,SAASP,EAAoDG,EAAO,CAC5D,MAAAM,MAAgB,QACf,OAAA,SAA2B5E,EAAe,CAC3C,IAAA6E,EAAiBD,EAAU,IAAI5E,CAAI,EACvC,GAAI6E,EACK,OAAAA,EAEH,MAAAC,EAAUR,EAAGtE,CAAI,EACvB,GAAK8E,EAGY,OAAAD,EAAA,CACf,GAAGC,EACH,EAAGV,EAASU,EAAQ,CAAC,EACrB,EAAGV,EAASU,EAAQ,CAAC,EACrB,IAAI,GAAI,CACN,OAAOA,EAAQ,CACjB,EACA,IAAI,EAAE5B,EAAG,CACP4B,EAAQ,EAAI5B,CAAA,CAEhB,EACU0B,EAAA,IAAI5E,EAAM6E,CAAc,EAC3BC,CACT,CAAA,CAGO,SAAAP,EAAqBE,EAA0BH,EAAqB,CACpE,OAAA,SAAgC9F,EAAOwB,EAAM,CAC5C,MAAA0E,EAAmBD,EAAW,IAAIzE,CAAI,EAC5C,OAAI0E,IAGJD,EAAW,IAAIzE,EAAMsE,EAAG9F,EAAOwB,CAAI,CAAC,EAC7ByE,EAAW,IAAIzE,CAAI,EAC5B,CAAA,CAGO,SAAA8D,EACPtF,EACAwB,KACGiD,EACH,CACA,KAAM,CAACT,EAAYpB,CAAa,EAAIiC,EAAM,QAAQrD,CAAI,EAChDmD,EAAUE,EAAM,iBACpBb,EACAxC,EACAoB,EACAiC,CACF,EACI,GAAA,CACF,OAAOI,EAASjF,EAAOgE,EAAY,GAAGS,CAAI,CAAA,QAC1C,CACUE,GAAA,MAAAA,GAAA,CACZ,CAGO,SAAA4B,EACPT,EACAU,EACA,CACO,OAAA,SAAsBhF,KAASiD,EAAM,CAC1C,KAAM,CAACT,CAAU,EAAIa,EAAM,QAAQrD,CAAI,EAEhC,OADGgF,EAAQA,EAAMV,CAAE,EAAIA,GACrB9B,EAAY,GAAGS,CAAI,CAC9B,CAAA,CAGO,SAAAY,EACPS,EACAU,EACA,CACA,OAAO,SAAuBxG,EAAOwB,KAASiD,EAAM,CAClD,KAAM,CAACT,CAAU,EAAIa,EAAM,QAAQrD,CAAI,EAEvC,OADUgF,EAAQA,EAAMV,CAAE,EAAIA,GACrB9F,EAAOgE,EAAY,GAAGS,CAAI,CACrC,CAAA,CAGO,SAAAe,EACPiB,EACAD,EACG,CACH,MAAME,EAAiB,CACrB,IAAKH,EAAYE,EAAG,IAAI,KAAKA,CAAE,EAAGD,CAAK,EACvC,IAAKD,EAAYE,EAAG,IAAI,KAAKA,CAAE,CAAC,CAClC,EACA,MAAI,QAASA,IACXC,EAAU,IAAMH,EAAYE,EAAG,IAAI,KAAKA,CAAE,CAAC,GAEzC,WAAYA,IACdC,EAAU,OAASH,EAAYE,EAAG,OAAO,KAAKA,CAAE,CAAC,GAE5CC,CAAA,CAGT,SAASd,EAASe,EAAoB,CAC7B,MAAA,CACL,IAAI,MAAO,CACT,OAAOA,EAAE,IACX,EACA,IAAKJ,EAAYI,EAAE,IAAI,KAAKA,CAAC,CAAC,EAC9B,IAAKJ,EAAYI,EAAE,IAAI,KAAKA,CAAC,CAAC,EAC9B,MAAOA,EAAE,MAAM,KAAKA,CAAC,EACrB,QAAUC,GAAOD,EAAE,QAAQJ,EAAYK,CAAE,CAAC,EAC1C,EAAE,OAAO,QAAQ,GAA+B,CAC9C,UAAWpF,KAAQmF,EAAG,MAAM9B,EAAM,QAAQrD,CAAI,EAAE,CAAC,CAAA,CAErD,CAAA,CAGF,SAASqF,EAAef,EAAmC,CACzD,GAAI,CAACA,EACI,OAEH,MAAAgB,EAAYP,EAAYT,CAAE,EAChC,OAAAgB,EAAU,IAAM,SAAkBtF,EAAMuF,EAAU,CAChD,GAAIvF,IAAS,OACJ,OAAAsE,EAAG,IAAI,OAAWiB,CAAQ,EAEnC,KAAM,CAAC/C,CAAU,EAAIa,EAAM,QAAQrD,CAAI,EAChC,OAAAsE,EAAG,IAAI9B,EAAY+C,CAAsB,CAClD,EACOD,CAAA,CAGT,SAASjB,EAAgBmB,EAAwB,CAiCxC,OAAA,OAAO,OAhCY,CACxB,IAAI,GAAI,CACN,OAAQ7B,EAAe,IAAfA,EAAe,EAAM0B,EAAeG,EAAW,CAAC,EAC1D,EACA,IAAI,EAAEtC,EAAG,CACPsC,EAAW,EAAItC,CACjB,EACA,IAAI,GAAI,CACN,OAAQS,EAAe,IAAfA,EAAe,EAAM0B,EAAeG,EAAW,CAAC,EAC1D,EACA,IAAI,EAAEtC,EAAG,CACPsC,EAAW,EAAItC,CACjB,EACA,IAAI,GAAI,CACN,OAAQS,EAAe,IAAfA,EAAe,EAAM0B,EAAeG,EAAW,CAAC,EAC1D,EACA,IAAI,EAAEtC,EAAG,CACPsC,EAAW,EAAItC,CACjB,EACA,IAAI,GAAI,CACN,OAAQS,EAAe,IAAfA,EAAe,EAAM0B,EAAeG,EAAW,CAAC,EAC1D,EACA,IAAI,EAAEtC,EAAG,CACPsC,EAAW,EAAItC,CACjB,EACA,IAAI,GAAI,CACN,OAAOsC,EAAW,CACpB,EACA,IAAI,EAAEtC,EAAG,CACPsC,EAAW,EAAItC,CAAA,CAEnB,EACwCsC,CAAU,CAAA,CAEtD,CCngBO,SAASC,EAAcC,EAAkC,OACxD,KAAA,CACJ,MAAOC,EAAgB,CAAC,EACxB,aAAAtF,EAAe,CAAC,EAChB,SAAA3B,EACA,MAAOkH,EACP,KAAAC,CAAA,EACEH,EACEpF,EAAqBtB,EAAAA,SAAS,EAC9BoB,EAAQ,MAAM,KAAKuF,EAAgB/F,GAAO,MAAM,QAAQA,CAAC,EAAIA,EAAE,CAAC,EAAIA,CAAE,EAE5E,SAASkG,GAAa,CACb,MAAA,CACLF,GAAiBzF,EAAY,CAAE,MAAAC,EAAO,aAAAC,EAAc,YAAAC,EAAa,KAAAuF,EAAM,EACvE,SAAoBE,EAKjB,CACD,OACEzF,IAAgByF,EAAQ,aACxB,CAACtG,EAAYW,EAAO2F,EAAQ,KAAK,GACjC,CAACtG,EAAYY,EAAc0F,EAAQ,YAAY,GAC/CH,IAAkBG,EAAQ,aAAA,CAGhC,CAAA,CAGI,KAAA,CAAC,CAACvH,EAAOwH,CAAU,EAAGC,CAAQ,EAAIC,WAASJ,CAAU,EAC3D,OAAIE,EAAW,CAAE,MAAA5F,EAAO,aAAAC,EAAc,YAAAC,EAAa,cAAAsF,CAAA,CAAe,KAClD1D,EAAA1C,EAAA,IAAIhB,CAAK,IAAT,MAAA0D,EAAY,UAC1B+D,EAASH,CAAU,GAErBhH,EAAA,gBACE,MAAM,KAAK6G,CAAa,EAAE,OAAO,MAAM,OAAO,EAC9C,CAAE,MAAAnH,CAAM,CACV,EACU2H,EAAA,UAAA,IAAM,OAAA,OAAAjE,EAAA1C,EAAc,IAAIhB,CAAK,IAAvB,YAAA0D,EAA0B,SAAS,CAAC1D,CAAK,CAAC,EACnDO,EAAc,cAAAR,EAAA,SAAU,CAAE,MAAAC,CAAA,EAASE,CAAQ,CACpD"}