{"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 { AnyWritableAtom, Store } 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, createStore } from 'jotai/vanilla'\nimport type { INTERNAL_getBuildingBlocksRev1 as INTERNAL_getBuildingBlocks } from 'jotai/vanilla/internals'\nimport type { AtomFamily } from 'jotai/vanilla/utils/atomFamily'\n\nexport type Store = ReturnType<typeof createStore>\n\nexport type ScopedStore = Store & {\n  [SCOPE]: Scope\n  [ORIGINAL_BUILDING_BLOCKS]: BuildingBlocks\n}\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   * @debug\n   */\n  name?: string\n\n  /**\n   * @debug\n   */\n  toString?: () => string\n}\n\nexport const SCOPE = Symbol('scope')\n\nexport const ORIGINAL_BUILDING_BLOCKS = Symbol('originalBuildingBlocks')\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] }\nexport type BuildingBlocks = Mutable<\n  ReturnType<typeof INTERNAL_getBuildingBlocks>\n>\nexport type StoreHooks = Mutable<BuildingBlocks[6]>\nexport type StoreHookForAtoms = NonNullable<StoreHooks['c']>\nexport type WeakSetForAtoms = Mutable<BuildingBlocks[3]>\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 { INTERNAL_getBuildingBlocksRev1 as INTERNAL_getBuildingBlocks } from 'jotai/vanilla/internals'\nimport {\n  AnyAtom,\n  AnyWritableAtom,\n  BuildingBlocks,\n  ORIGINAL_BUILDING_BLOCKS,\n  ScopedStore,\n  Store,\n} from './types'\n\nexport function isEqualSet(a: Set<unknown>, b: Set<unknown>) {\n  return a === b || (a.size === b.size && Array.from(a).every(b.has.bind(b)))\n}\n\nexport function getBaseStoreState(store: Store | ScopedStore) {\n  const buildingBlocks =\n    ORIGINAL_BUILDING_BLOCKS in store\n      ? store[ORIGINAL_BUILDING_BLOCKS]\n      : INTERNAL_getBuildingBlocks(store)\n  return buildingBlocks.slice(0, 6) as BuildingBlocks\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, type WritableAtom, atom as createAtom } from 'jotai'\nimport {\n  INTERNAL_buildStoreRev1 as INTERNAL_buildStore,\n  INTERNAL_getBuildingBlocksRev1 as INTERNAL_getBuildingBlocks,\n} from 'jotai/vanilla/internals'\nimport { __DEV__ } from '../env'\nimport type {\n  AnyAtom,\n  AnyAtomFamily,\n  AnyWritableAtom,\n  BuildingBlocks,\n  Scope,\n  ScopedStore,\n  Store,\n  StoreHookForAtoms,\n  StoreHooks,\n  WeakMapForAtoms,\n  WeakSetForAtoms,\n  WithOriginal,\n} from '../types'\nimport { ORIGINAL_BUILDING_BLOCKS, SCOPE } from '../types'\nimport { getBaseStoreState, 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  atomSet = new Set(),\n  atomFamilySet = new Set(),\n  parentStore,\n  name: scopeName,\n}: {\n  atomSet?: Set<AnyAtom>\n  atomFamilySet?: Set<AnyAtomFamily>\n  parentStore: Store | ScopedStore\n  name?: string\n}): ScopedStore {\n  const parentScope = SCOPE in parentStore ? parentStore[SCOPE] : undefined\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    cleanup() {\n      for (const cleanup of cleanupFamiliesSet) {\n        cleanup()\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\n  if (scopeName && __DEV__) {\n    currentScope.name = scopeName\n    currentScope.toString = toNameString\n  }\n\n  // populate explicitly scoped atoms\n  for (const atom of atomSet) {\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 (!atomSet.has(e.atom)) {\n        explicit.delete(e.atom)\n      }\n    })\n    cleanupFamiliesSet.add(cleanupFamily)\n  }\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  /**\n   * @returns a copy of the atom for derived atoms or the original atom for primitive and writable atoms\n   */\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  /**\n   * @returns a scoped copy of the atom\n   */\n  function cloneAtom<T>(originalAtom: Atom<T>, implicitScope?: Scope) {\n    // avoid reading `init` to preserve lazy initialization\n    const propertyDescriptors = Object.getOwnPropertyDescriptors(originalAtom)\n    Object.entries(propertyDescriptors)\n      .filter(([k]) => ['read', 'write', 'debugLabel'].includes(k))\n      .forEach(([, v]) => (v.configurable = true))\n    const scopedAtom: WithOriginal<Atom<T>> = Object.create(\n      Object.getPrototypeOf(originalAtom),\n      propertyDescriptors\n    )\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  const scopedStore = createPatchedStore(parentStore, currentScope)\n  return scopedStore\n}\n\nconst { read: defaultRead, write: defaultWrite } = createAtom<unknown>(null)\n\n/**\n * @returns a patched store that intercepts get and set calls to apply the scope\n */\nfunction createPatchedStore(parentStore: Store, scope: Scope): ScopedStore {\n  const storeState = getBaseStoreState(parentStore)\n  const internalStoreHooks: StoreHooks = {}\n  storeState[6] = internalStoreHooks\n  storeState[9] = (atom: AnyAtom) => atom.unstable_onInit?.(scopedStore)\n  const scopedStore = INTERNAL_buildStore(...storeState)\n  const prototypeBuildingBlocks = INTERNAL_getBuildingBlocks(scopedStore)\n  const buildingBlocks = [...prototypeBuildingBlocks] as BuildingBlocks\n\n  function toScopedAtomFn<T extends AnyAtom | AnyWritableAtom>(\n    fn: (atom: T, ...args: any[]) => any\n  ) {\n    return (atom: AnyAtom, ...args: any[]) => {\n      const [scopedAtom] = scope.getAtom(atom)\n      return fn(scopedAtom as T, ...args)\n    }\n  }\n\n  function patchWeakMap<T extends WeakMapForAtoms>(wm: T): T {\n    const patchedWm: any = {\n      get: toScopedAtomFn(wm.get.bind(wm)),\n      set: toScopedAtomFn(wm.set.bind(wm)),\n    }\n    if ('has' in wm) {\n      patchedWm.has = toScopedAtomFn(wm.has.bind(wm))\n    }\n    if ('delete' in wm) {\n      patchedWm.delete = toScopedAtomFn(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: toScopedAtomFn(s.add.bind(s)),\n      has: toScopedAtomFn(s.has.bind(s)),\n      clear: s.clear.bind(s),\n      forEach: (cb) => s.forEach(toScopedAtomFn(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 = toScopedAtomFn(fn) as typeof fn\n    storeHook.add = (atom, callback) => {\n      if (atom === undefined) {\n        return fn.add(undefined, callback)\n      }\n      return fn.add(scope.getAtom(atom)[0], callback as () => void)\n    }\n    return storeHook\n  }\n\n  const storeHooks: StoreHooks = {\n    get c() {\n      return patchStoreHook(internalStoreHooks.c)\n    },\n    set c(v) {\n      internalStoreHooks.c = v\n    },\n    get m() {\n      return patchStoreHook(internalStoreHooks.m)\n    },\n    set m(v) {\n      internalStoreHooks.m = v\n    },\n    get u() {\n      return patchStoreHook(internalStoreHooks.u)\n    },\n    set u(v) {\n      internalStoreHooks.u = v\n    },\n    get f() {\n      return internalStoreHooks.f\n    },\n    set f(v) {\n      internalStoreHooks.f = v\n    },\n  }\n\n  const scopedBuildingBlock: BuildingBlocks = [\n    patchWeakMap(buildingBlocks[0]), // atomStateMap\n    patchWeakMap(buildingBlocks[1]), // mountedMap\n    patchWeakMap(buildingBlocks[2]), // invalidatedAtoms\n    patchSet(buildingBlocks[3]), // changedAtoms\n    buildingBlocks[4], // mountCallbacks\n    buildingBlocks[5], // unmountCallbacks\n    storeHooks, // storeHooks\n    toScopedAtomFn(buildingBlocks[7]), // atomRead\n    toScopedAtomFn(buildingBlocks[8]), // atomWrite\n    buildingBlocks[9], // atomOnInit\n    toScopedAtomFn(buildingBlocks[10]), // atomOnMount\n    toScopedAtomFn(buildingBlocks[11]), // ensureAtomState\n    buildingBlocks[12], // flushCallbacks\n    buildingBlocks[13], // recomputeInvalidatedAtoms\n    toScopedAtomFn(buildingBlocks[14]), // readAtomState\n    toScopedAtomFn(buildingBlocks[15]), // invalidateDependents\n    toScopedAtomFn(buildingBlocks[16]), // writeAtomState\n    toScopedAtomFn(buildingBlocks[17]), // mountDependencies\n    toScopedAtomFn(buildingBlocks[18]), // mountAtom\n    toScopedAtomFn(buildingBlocks[19]), // unmountAtom\n  ]\n  Object.assign(prototypeBuildingBlocks, scopedBuildingBlock)\n\n  const { get, set, sub } = scopedStore\n\n  return Object.assign(scopedStore, {\n    get(atom) {\n      const [scopedAtom] = scope.getAtom(atom)\n      return get(scopedAtom)\n    },\n    set<Value, Args extends any[], Result>(\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 set(scopedAtom, ...args)\n      } finally {\n        restore?.()\n      }\n    },\n    sub(atom, callback) {\n      const [scopedAtom] = scope.getAtom(atom)\n      return sub(scopedAtom, callback)\n    },\n    [SCOPE]: scope,\n    [ORIGINAL_BUILDING_BLOCKS]: buildingBlocks as BuildingBlocks,\n  } as ScopedStore)\n}\n","import {\n  type PropsWithChildren,\n  createElement,\n  useEffect,\n  useState,\n} from 'react'\nimport { Provider, useStore } from 'jotai/react'\nimport { useHydrateAtoms } from 'jotai/utils'\nimport {\n  type AnyAtom,\n  type AnyAtomFamily,\n  type AtomDefault,\n  SCOPE,\n  ScopedStore,\n  type Store,\n} from '../types'\nimport { isEqualSet } 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<{\n  scope: ScopedStore\n}>\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: scopeName,\n  } = props as BaseProps & ProvidedScope\n  const parentStore: Store | ScopedStore = useStore()\n  const atoms = Array.from(atomsOrTuples, (a) => (Array.isArray(a) ? a[0] : a))\n  const atomSet = new Set(atoms)\n  const atomFamilySet = new Set(atomFamilies)\n\n  function initialize() {\n    return {\n      scope:\n        providedScope ??\n        createScope({\n          atomSet,\n          atomFamilySet,\n          parentStore,\n          name: scopeName,\n        }),\n      hasChanged(current: {\n        parentStore: Store | ScopedStore\n        atomSet: Set<AnyAtom>\n        atomFamilySet: Set<AnyAtomFamily>\n        providedScope: ScopedStore | undefined\n      }) {\n        return (\n          parentStore !== current.parentStore ||\n          !isEqualSet(atomSet, current.atomSet) ||\n          !isEqualSet(atomFamilySet, current.atomFamilySet) ||\n          providedScope !== current.providedScope\n        )\n      },\n    }\n  }\n\n  const [state, setState] = useState(initialize)\n  const { hasChanged, scope } = state\n  if (hasChanged({ atomSet, atomFamilySet, parentStore, providedScope })) {\n    scope[SCOPE].cleanup()\n    setState(initialize)\n  }\n  useHydrateAtoms(\n    Array.from(atomsOrTuples).filter(Array.isArray) as AtomDefault[],\n    { store: scope }\n  )\n  useEffect(() => scope[SCOPE].cleanup, [scope])\n  return createElement(Provider, { store: scope }, children)\n}\n"],"names":["createIsolation","StoreContext","createContext","Provider","store","initialValues","children","storeRef","useRef","createStore","useHydrateAtoms","createElement","useStore","options","useContext","useStoreOrig","anAtom","useAtomOrig","useAtomValueOrig","useSetAtomOrig","SCOPE","ORIGINAL_BUILDING_BLOCKS","isEqualSet","b","getBaseStoreState","INTERNAL_getBuildingBlocks","toNameString","isWritableAtom","atom","__DEV__","globalScopeKey","createScope","atomSet","atomFamilySet","parentStore","scopeName","parentScope","explicit","implicit","inherited","currentScope","getAtom","cleanup","cleanupFamiliesSet","originalAtom","implicitScope","writeScope","defaultRead","defaultWrite","write","createScopedWrite","cloneAtom","atomFamily","param","cleanupFamily","e","scopeKey","_a","ancestorAtom","explicitScope","setInheritedAtom","inheritAtom","_b","scopedAtom","propertyDescriptors","k","v","createScopedRead","read","get","opts","a","set","args","restore","createPatchedStore","createAtom","scope","storeState","internalStoreHooks","scopedStore","INTERNAL_buildStore","prototypeBuildingBlocks","buildingBlocks","toScopedAtomFn","fn","patchWeakMap","wm","patchedWm","patchSet","s","cb","patchStoreHook","storeHook","callback","storeHooks","scopedBuildingBlock","sub","ScopeProvider","props","atomsOrTuples","atomFamilies","providedScope","atoms","initialize","current","state","setState","useState","hasChanged","useEffect"],"mappings":"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"}