@depup/jotai 2.18.0-depup.0

package/esm/babel/preset.mjs

@@ -0,0 +1,179 @@
+import '@babel/core';
+import _templateBuilder from '@babel/template';
+
+function isAtom(t, callee, customAtomNames = []) {
+  const atomNames = [...atomFunctionNames, ...customAtomNames];
+  if (t.isIdentifier(callee) && atomNames.includes(callee.name)) {
+    return true;
+  }
+  if (t.isMemberExpression(callee)) {
+    const { property } = callee;
+    if (t.isIdentifier(property) && atomNames.includes(property.name)) {
+      return true;
+    }
+  }
+  return false;
+}
+const atomFunctionNames = [
+  // Core
+  "atom",
+  "atomFamily",
+  "atomWithDefault",
+  "atomWithObservable",
+  "atomWithReducer",
+  "atomWithReset",
+  "atomWithStorage",
+  "freezeAtom",
+  "loadable",
+  "selectAtom",
+  "splitAtom",
+  "unwrap",
+  // jotai-xstate
+  "atomWithMachine",
+  // jotai-immer
+  "atomWithImmer",
+  // jotai-valtio
+  "atomWithProxy",
+  // jotai-trpc + jotai-relay
+  "atomWithQuery",
+  "atomWithMutation",
+  "atomWithSubscription",
+  // jotai-redux + jotai-zustand
+  "atomWithStore",
+  // jotai-location
+  "atomWithHash",
+  "atomWithLocation",
+  // jotai-optics
+  "focusAtom",
+  // jotai-form
+  "atomWithValidate",
+  "validateAtoms",
+  // jotai-cache
+  "atomWithCache",
+  // jotai-recoil
+  "atomWithRecoilValue"
+];
+
+const templateBuilder$1 = _templateBuilder.default || _templateBuilder;
+function debugLabelPlugin({ types: t }, options) {
+  console.warn(
+    "[DEPRECATED] jotai/babel/plugin-debug-label is deprecated and will be removed in v3.\nPlease use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel"
+  );
+  return {
+    visitor: {
+      ExportDefaultDeclaration(nodePath, state) {
+        const { node } = nodePath;
+        if (t.isCallExpression(node.declaration) && isAtom(t, node.declaration.callee, options == null ? void 0 : options.customAtomNames)) {
+          const filename = (state.filename || "unknown").replace(/\.\w+$/, "");
+          let displayName = filename.split("/").pop();
+          if (displayName === "index") {
+            displayName = filename.slice(0, -"/index".length).split("/").pop() || "unknown";
+          }
+          const buildExport = templateBuilder$1(`
+          const %%atomIdentifier%% = %%atom%%;
+          export default %%atomIdentifier%%
+          `);
+          const ast = buildExport({
+            atomIdentifier: t.identifier(displayName),
+            atom: node.declaration
+          });
+          nodePath.replaceWithMultiple(ast);
+        }
+      },
+      VariableDeclarator(path) {
+        if (t.isIdentifier(path.node.id) && t.isCallExpression(path.node.init) && isAtom(t, path.node.init.callee, options == null ? void 0 : options.customAtomNames)) {
+          path.parentPath.insertAfter(
+            t.expressionStatement(
+              t.assignmentExpression(
+                "=",
+                t.memberExpression(
+                  t.identifier(path.node.id.name),
+                  t.identifier("debugLabel")
+                ),
+                t.stringLiteral(path.node.id.name)
+              )
+            )
+          );
+        }
+      }
+    }
+  };
+}
+
+const templateBuilder = _templateBuilder.default || _templateBuilder;
+function reactRefreshPlugin({ types: t }, options) {
+  console.warn(
+    "[DEPRECATED] jotai/babel/plugin-react-refresh is deprecated and will be removed in v3.\nPlease use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel"
+  );
+  return {
+    pre({ opts }) {
+      if (!opts.filename) {
+        throw new Error("Filename must be available");
+      }
+    },
+    visitor: {
+      Program: {
+        exit(path) {
+          const jotaiAtomCache = templateBuilder(`
+          globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {
+            cache: new Map(),
+            get(name, inst) { 
+              if (this.cache.has(name)) {
+                return this.cache.get(name)
+              }
+              this.cache.set(name, inst)
+              return inst
+            },
+          }`)();
+          path.unshiftContainer("body", jotaiAtomCache);
+        }
+      },
+      ExportDefaultDeclaration(nodePath, state) {
+        const { node } = nodePath;
+        if (t.isCallExpression(node.declaration) && isAtom(t, node.declaration.callee, options == null ? void 0 : options.customAtomNames)) {
+          const filename = state.filename || "unknown";
+          const atomKey = `${filename}/defaultExport`;
+          const buildExport = templateBuilder(
+            `export default globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)`
+          );
+          const ast = buildExport({
+            atomKey: t.stringLiteral(atomKey),
+            atom: node.declaration
+          });
+          nodePath.replaceWith(ast);
+        }
+      },
+      VariableDeclarator(nodePath, state) {
+        var _a, _b;
+        if (t.isIdentifier(nodePath.node.id) && t.isCallExpression(nodePath.node.init) && isAtom(t, nodePath.node.init.callee, options == null ? void 0 : options.customAtomNames) && // Make sure atom declaration is in module scope
+        (((_a = nodePath.parentPath.parentPath) == null ? void 0 : _a.isProgram()) || ((_b = nodePath.parentPath.parentPath) == null ? void 0 : _b.isExportNamedDeclaration()))) {
+          const filename = state.filename || "unknown";
+          const atomKey = `${filename}/${nodePath.node.id.name}`;
+          const buildAtomDeclaration = templateBuilder(
+            `const %%atomIdentifier%% = globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)`
+          );
+          const ast = buildAtomDeclaration({
+            atomIdentifier: t.identifier(nodePath.node.id.name),
+            atomKey: t.stringLiteral(atomKey),
+            atom: nodePath.node.init
+          });
+          nodePath.parentPath.replaceWith(ast);
+        }
+      }
+    }
+  };
+}
+
+function jotaiPreset(_, options) {
+  console.warn(
+    "[DEPRECATED] jotai/babel/preset is deprecated and will be removed in v3.\nPlease use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel"
+  );
+  return {
+    plugins: [
+      [debugLabelPlugin, options],
+      [reactRefreshPlugin, options]
+    ]
+  };
+}
+
+export { jotaiPreset as default };

package/esm/babel/utils.d.mts

@@ -0,0 +1,5 @@
+import { types } from '@babel/core';
+export interface PluginOptions {
+    customAtomNames?: string[];
+}
+export declare function isAtom(t: typeof types, callee: babel.types.Expression | babel.types.V8IntrinsicIdentifier, customAtomNames?: PluginOptions['customAtomNames']): boolean;

package/esm/index.d.mts

@@ -0,0 +1,2 @@
+export * from 'jotai/vanilla';
+export * from 'jotai/react';

package/esm/index.mjs

@@ -0,0 +1,2 @@
+export * from 'jotai/vanilla';
+export * from 'jotai/react';

package/esm/react/Provider.d.mts

@@ -0,0 +1,16 @@
+import type { FunctionComponent, ReactElement, ReactNode } from 'react';
+import { createStore } from 'jotai/vanilla';
+type Store = ReturnType<typeof createStore>;
+type Options = {
+    store?: Store;
+};
+export declare function useStore(options?: Options): Store;
+export declare function Provider({ children, store, }: {
+    children?: ReactNode;
+    store?: Store;
+}): ReactElement<{
+    value: Store | undefined;
+}, FunctionComponent<{
+    value: Store;
+}>>;
+export {};

package/esm/react/useAtom.d.mts

@@ -0,0 +1,13 @@
+import type { Atom, ExtractAtomArgs, ExtractAtomResult, ExtractAtomValue, PrimitiveAtom, SetStateAction, WritableAtom } from 'jotai/vanilla';
+import { useAtomValue } from './useAtomValue.mjs';
+type SetAtom<Args extends unknown[], Result> = (...args: Args) => Result;
+type Options = Parameters<typeof useAtomValue>[1];
+export declare function useAtom<Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, options?: Options): [Awaited<Value>, SetAtom<Args, Result>];
+export declare function useAtom<Value>(atom: PrimitiveAtom<Value>, options?: Options): [Awaited<Value>, SetAtom<[SetStateAction<Value>], void>];
+export declare function useAtom<Value>(atom: Atom<Value>, options?: Options): [Awaited<Value>, never];
+export declare function useAtom<AtomType extends WritableAtom<unknown, never[], unknown>>(atom: AtomType, options?: Options): [
+    Awaited<ExtractAtomValue<AtomType>>,
+    SetAtom<ExtractAtomArgs<AtomType>, ExtractAtomResult<AtomType>>
+];
+export declare function useAtom<AtomType extends Atom<unknown>>(atom: AtomType, options?: Options): [Awaited<ExtractAtomValue<AtomType>>, never];
+export {};

package/esm/react/useAtomValue.d.mts

@@ -0,0 +1,9 @@
+import type { Atom, ExtractAtomValue } from 'jotai/vanilla';
+import { useStore } from './Provider.mjs';
+type Options = Parameters<typeof useStore>[0] & {
+    delay?: number;
+    unstable_promiseStatus?: boolean;
+};
+export declare function useAtomValue<Value>(atom: Atom<Value>, options?: Options): Awaited<Value>;
+export declare function useAtomValue<AtomType extends Atom<unknown>>(atom: AtomType, options?: Options): Awaited<ExtractAtomValue<AtomType>>;
+export {};

package/esm/react/useSetAtom.d.mts

@@ -0,0 +1,7 @@
+import type { ExtractAtomArgs, ExtractAtomResult, WritableAtom } from 'jotai/vanilla';
+import { useStore } from './Provider.mjs';
+type SetAtom<Args extends unknown[], Result> = (...args: Args) => Result;
+type Options = Parameters<typeof useStore>[0];
+export declare function useSetAtom<Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, options?: Options): SetAtom<Args, Result>;
+export declare function useSetAtom<AtomType extends WritableAtom<unknown, never[], unknown>>(atom: AtomType, options?: Options): SetAtom<ExtractAtomArgs<AtomType>, ExtractAtomResult<AtomType>>;
+export {};

package/esm/react/utils/useAtomCallback.d.mts

@@ -0,0 +1,5 @@
+import { useSetAtom } from 'jotai/react';
+import type { Getter, Setter } from 'jotai/vanilla';
+type Options = Parameters<typeof useSetAtom>[1];
+export declare function useAtomCallback<Result, Args extends unknown[]>(callback: (get: Getter, set: Setter, ...arg: Args) => Result, options?: Options): (...args: Args) => Result;
+export {};

package/esm/react/utils/useHydrateAtoms.d.mts

@@ -0,0 +1,14 @@
+import { useStore } from 'jotai/react';
+import { type WritableAtom } from 'jotai/vanilla';
+type Options = Parameters<typeof useStore>[0] & {
+    dangerouslyForceHydrate?: boolean;
+};
+type AnyWritableAtom = WritableAtom<any, any[], any>;
+type InferAtomTuples<T> = {
+    [K in keyof T]: T[K] extends readonly [infer A, ...infer Rest] ? A extends WritableAtom<unknown, infer Args, unknown> ? Rest extends Args ? readonly [A, ...Rest] : never : T[K] : never;
+};
+export type INTERNAL_InferAtomTuples<T> = InferAtomTuples<T>;
+export declare function useHydrateAtoms<T extends (readonly [AnyWritableAtom, ...unknown[]])[]>(values: InferAtomTuples<T>, options?: Options): void;
+export declare function useHydrateAtoms<T extends Map<AnyWritableAtom, unknown>>(values: T, options?: Options): void;
+export declare function useHydrateAtoms<T extends Iterable<readonly [AnyWritableAtom, ...unknown[]]>>(values: InferAtomTuples<T>, options?: Options): void;
+export {};

package/esm/react/utils/useReducerAtom.d.mts

@@ -0,0 +1,14 @@
+import { useAtom } from 'jotai/react';
+import type { PrimitiveAtom } from 'jotai/vanilla';
+type Options = Parameters<typeof useAtom>[1];
+/**
+ * @deprecated please use a recipe instead
+ * https://github.com/pmndrs/jotai/pull/2467
+ */
+export declare function useReducerAtom<Value, Action>(anAtom: PrimitiveAtom<Value>, reducer: (v: Value, a?: Action) => Value, options?: Options): [Value, (action?: Action) => void];
+/**
+ * @deprecated please use a recipe instead
+ * https://github.com/pmndrs/jotai/pull/2467
+ */
+export declare function useReducerAtom<Value, Action>(anAtom: PrimitiveAtom<Value>, reducer: (v: Value, a: Action) => Value, options?: Options): [Value, (action: Action) => void];
+export {};

package/esm/react/utils/useResetAtom.d.mts

@@ -0,0 +1,6 @@
+import { useSetAtom } from 'jotai/react';
+import { RESET } from 'jotai/vanilla/utils';
+import type { WritableAtom } from 'jotai/vanilla';
+type Options = Parameters<typeof useSetAtom>[1];
+export declare function useResetAtom<T>(anAtom: WritableAtom<unknown, [typeof RESET], T>, options?: Options): () => T;
+export {};

package/esm/react/utils.d.mts

@@ -0,0 +1,4 @@
+export { useResetAtom } from './utils/useResetAtom.mjs';
+export { useReducerAtom } from './utils/useReducerAtom.mjs';
+export { useAtomCallback } from './utils/useAtomCallback.mjs';
+export { useHydrateAtoms } from './utils/useHydrateAtoms.mjs';

package/esm/react/utils.mjs

@@ -0,0 +1,57 @@
+'use client';
+import { useCallback, useMemo } from 'react';
+import { useSetAtom, useAtom, useStore } from 'jotai/react';
+import { RESET } from 'jotai/vanilla/utils';
+import { atom } from 'jotai/vanilla';
+
+function useResetAtom(anAtom, options) {
+  const setAtom = useSetAtom(anAtom, options);
+  const resetAtom = useCallback(() => setAtom(RESET), [setAtom]);
+  return resetAtom;
+}
+
+function useReducerAtom(anAtom, reducer, options) {
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
+    console.warn(
+      "[DEPRECATED] useReducerAtom is deprecated and will be removed in the future. Please create your own version using the recipe. https://github.com/pmndrs/jotai/pull/2467"
+    );
+  }
+  const [state, setState] = useAtom(anAtom, options);
+  const dispatch = useCallback(
+    (action) => {
+      setState((prev) => reducer(prev, action));
+    },
+    [setState, reducer]
+  );
+  return [state, dispatch];
+}
+
+function useAtomCallback(callback, options) {
+  const anAtom = useMemo(
+    () => atom(null, (get, set, ...args) => callback(get, set, ...args)),
+    [callback]
+  );
+  return useSetAtom(anAtom, options);
+}
+
+const hydratedMap = /* @__PURE__ */ new WeakMap();
+function useHydrateAtoms(values, options) {
+  const store = useStore(options);
+  const hydratedSet = getHydratedSet(store);
+  for (const [atom, ...args] of values) {
+    if (!hydratedSet.has(atom) || (options == null ? void 0 : options.dangerouslyForceHydrate)) {
+      hydratedSet.add(atom);
+      store.set(atom, ...args);
+    }
+  }
+}
+const getHydratedSet = (store) => {
+  let hydratedSet = hydratedMap.get(store);
+  if (!hydratedSet) {
+    hydratedSet = /* @__PURE__ */ new WeakSet();
+    hydratedMap.set(store, hydratedSet);
+  }
+  return hydratedSet;
+};
+
+export { useAtomCallback, useHydrateAtoms, useReducerAtom, useResetAtom };

package/esm/react.d.mts

@@ -0,0 +1,4 @@
+export { Provider, useStore } from './react/Provider.mjs';
+export { useAtomValue } from './react/useAtomValue.mjs';
+export { useSetAtom } from './react/useSetAtom.mjs';
+export { useAtom } from './react/useAtom.mjs';

package/esm/react.mjs

@@ -0,0 +1,182 @@
+'use client';
+import React, { createContext, useContext, useRef, createElement, useReducer, useEffect, useDebugValue, useCallback } from 'react';
+import { getDefaultStore, createStore } from 'jotai/vanilla';
+import { INTERNAL_getBuildingBlocksRev2 } from 'jotai/vanilla/internals';
+
+const StoreContext = createContext(
+  void 0
+);
+function useStore(options) {
+  const store = useContext(StoreContext);
+  return (options == null ? void 0 : options.store) || store || getDefaultStore();
+}
+function Provider({
+  children,
+  store
+}) {
+  const storeRef = useRef(null);
+  if (store) {
+    return createElement(StoreContext.Provider, { value: store }, children);
+  }
+  if (storeRef.current === null) {
+    storeRef.current = createStore();
+  }
+  return createElement(
+    StoreContext.Provider,
+    {
+      // TODO: If this is not a false positive, consider using useState instead of useRef like https://github.com/pmndrs/jotai/pull/2771
+      // eslint-disable-next-line react-hooks/refs
+      value: storeRef.current
+    },
+    children
+  );
+}
+
+const isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
+const attachPromiseStatus = (promise) => {
+  if (!promise.status) {
+    promise.status = "pending";
+    promise.then(
+      (v) => {
+        promise.status = "fulfilled";
+        promise.value = v;
+      },
+      (e) => {
+        promise.status = "rejected";
+        promise.reason = e;
+      }
+    );
+  }
+};
+const use = React.use || // A shim for older React versions
+((promise) => {
+  if (promise.status === "pending") {
+    throw promise;
+  } else if (promise.status === "fulfilled") {
+    return promise.value;
+  } else if (promise.status === "rejected") {
+    throw promise.reason;
+  } else {
+    attachPromiseStatus(promise);
+    throw promise;
+  }
+});
+const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
+const createContinuablePromise = (store, promise, getValue) => {
+  const buildingBlocks = INTERNAL_getBuildingBlocksRev2(store);
+  const registerAbortHandler = buildingBlocks[26];
+  let continuablePromise = continuablePromiseMap.get(promise);
+  if (!continuablePromise) {
+    continuablePromise = new Promise((resolve, reject) => {
+      let curr = promise;
+      const onFulfilled = (me) => (v) => {
+        if (curr === me) {
+          resolve(v);
+        }
+      };
+      const onRejected = (me) => (e) => {
+        if (curr === me) {
+          reject(e);
+        }
+      };
+      const onAbort = () => {
+        try {
+          const nextValue = getValue();
+          if (isPromiseLike(nextValue)) {
+            continuablePromiseMap.set(nextValue, continuablePromise);
+            curr = nextValue;
+            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
+            registerAbortHandler(store, nextValue, onAbort);
+          } else {
+            resolve(nextValue);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      };
+      promise.then(onFulfilled(promise), onRejected(promise));
+      registerAbortHandler(store, promise, onAbort);
+    });
+    continuablePromiseMap.set(promise, continuablePromise);
+  }
+  return continuablePromise;
+};
+function useAtomValue(atom, options) {
+  const { delay, unstable_promiseStatus: promiseStatus = !React.use } = options || {};
+  const store = useStore(options);
+  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer(
+    (prev) => {
+      const nextValue = store.get(atom);
+      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
+        return prev;
+      }
+      return [nextValue, store, atom];
+    },
+    void 0,
+    () => [store.get(atom), store, atom]
+  );
+  let value = valueFromReducer;
+  if (storeFromReducer !== store || atomFromReducer !== atom) {
+    rerender();
+    value = store.get(atom);
+  }
+  useEffect(() => {
+    const unsub = store.sub(atom, () => {
+      if (promiseStatus) {
+        try {
+          const value2 = store.get(atom);
+          if (isPromiseLike(value2)) {
+            attachPromiseStatus(
+              createContinuablePromise(store, value2, () => store.get(atom))
+            );
+          }
+        } catch (e) {
+        }
+      }
+      if (typeof delay === "number") {
+        setTimeout(rerender, delay);
+        return;
+      }
+      rerender();
+    });
+    rerender();
+    return unsub;
+  }, [store, atom, delay, promiseStatus]);
+  useDebugValue(value);
+  if (isPromiseLike(value)) {
+    const promise = createContinuablePromise(
+      store,
+      value,
+      () => store.get(atom)
+    );
+    if (promiseStatus) {
+      attachPromiseStatus(promise);
+    }
+    return use(promise);
+  }
+  return value;
+}
+
+function useSetAtom(atom, options) {
+  const store = useStore(options);
+  const setAtom = useCallback(
+    (...args) => {
+      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("write" in atom)) {
+        throw new Error("not writable atom");
+      }
+      return store.set(atom, ...args);
+    },
+    [store, atom]
+  );
+  return setAtom;
+}
+
+function useAtom(atom, options) {
+  return [
+    useAtomValue(atom, options),
+    // We do wrong type assertion here, which results in throwing an error.
+    useSetAtom(atom, options)
+  ];
+}
+
+export { Provider, useAtom, useAtomValue, useSetAtom, useStore };

package/esm/utils.d.mts

@@ -0,0 +1,2 @@
+export * from 'jotai/vanilla/utils';
+export * from 'jotai/react/utils';

package/esm/utils.mjs

@@ -0,0 +1,2 @@
+export * from 'jotai/vanilla/utils';
+export * from 'jotai/react/utils';

package/esm/vanilla/atom.d.mts

@@ -0,0 +1,47 @@
+import type { Store } from './store.mjs';
+type Getter = <Value>(atom: Atom<Value>) => Value;
+type Setter = <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+type SetAtom<Args extends unknown[], Result> = <A extends Args>(...args: A) => Result;
+/**
+ * setSelf is for internal use only and subject to change without notice.
+ */
+type Read<Value, SetSelf = never> = (get: Getter, options: {
+    readonly signal: AbortSignal;
+    readonly setSelf: SetSelf;
+}) => Value;
+type Write<Args extends unknown[], Result> = (get: Getter, set: Setter, ...args: Args) => Result;
+type WithInitialValue<Value> = {
+    init: Value;
+};
+type OnUnmount = () => void;
+type OnMount<Args extends unknown[], Result> = <S extends SetAtom<Args, Result>>(setAtom: S) => OnUnmount | void;
+export interface Atom<Value> {
+    toString: () => string;
+    read: Read<Value>;
+    debugLabel?: string;
+    /**
+     * To ONLY be used by Jotai libraries to mark atoms as private. Subject to change.
+     * @private
+     */
+    debugPrivate?: boolean;
+    /**
+     * Fires after atom is referenced by the store for the first time
+     * This is an internal API and subject to change without notice.
+     */
+    INTERNAL_onInit?: (store: Store) => void;
+}
+export interface WritableAtom<Value, Args extends unknown[], Result> extends Atom<Value> {
+    read: Read<Value, SetAtom<Args, unknown>>;
+    write: Write<Args, Result>;
+    onMount?: OnMount<Args, Result>;
+}
+type SetStateAction<Value> = Value | ((prev: Value) => Value);
+export type PrimitiveAtom<Value> = WritableAtom<Value, [
+    SetStateAction<Value>
+], void>;
+export declare function atom<Value, Args extends unknown[], Result>(read: Read<Value, SetAtom<Args, unknown>>, write: Write<Args, Result>): WritableAtom<Value, Args, Result>;
+export declare function atom<Value>(read: Read<Value>): Atom<Value>;
+export declare function atom<Value, Args extends unknown[], Result>(initialValue: Value, write: Write<Args, Result>): WritableAtom<Value, Args, Result> & WithInitialValue<Value>;
+export declare function atom<Value>(): PrimitiveAtom<Value | undefined> & WithInitialValue<Value | undefined>;
+export declare function atom<Value>(initialValue: Value): PrimitiveAtom<Value> & WithInitialValue<Value>;
+export {};