@tanstack/redact 0.0.1

package/dist/react/element.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/react/element.ts"],
+  "sourcesContent": ["import {\n  REACT_ELEMENT_TYPE,\n  REACT_LEGACY_ELEMENT_TYPE,\n  REACT_FRAGMENT_TYPE,\n  type ReactElement,\n  type ReactNode,\n} from '../core'\n\nexport const Fragment = REACT_FRAGMENT_TYPE as unknown as (props: {\n  children?: ReactNode\n}) => ReactElement\n\nconst RESERVED_PROPS: Record<string, 1> = { key: 1, ref: 1, __self: 1, __source: 1 }\n\nexport function createElement(\n  type: any,\n  config: Record<string, any> | null,\n  ...children: ReactNode[]\n): ReactElement {\n  let key: string | null = null\n  let ref: any = null\n  const props: Record<string, any> = {}\n\n  if (config != null) {\n    if (config.key !== undefined && config.key !== null) key = '' + config.key\n    if (config.ref !== undefined) ref = config.ref\n    for (const k in config) {\n      if (!RESERVED_PROPS[k] && Object.prototype.hasOwnProperty.call(config, k)) {\n        props[k] = config[k]\n      }\n    }\n  }\n\n  if (children.length === 1) props.children = children[0]\n  else if (children.length > 1) props.children = children\n\n  if (type && type.defaultProps) {\n    const dp = type.defaultProps\n    for (const k in dp) {\n      if (props[k] === undefined) props[k] = dp[k]\n    }\n  }\n\n  return { $$typeof: REACT_ELEMENT_TYPE, type, key, ref, props }\n}\n\nexport function cloneElement(\n  element: ReactElement,\n  config: Record<string, any> | null,\n  ...children: ReactNode[]\n): ReactElement {\n  let key = element.key\n  let ref = element.ref\n  const props = { ...element.props }\n\n  if (config != null) {\n    if (config.ref !== undefined) ref = config.ref\n    if (config.key !== undefined) key = '' + config.key\n    const defaultProps = element.type?.defaultProps\n    for (const k in config) {\n      if (RESERVED_PROPS[k] || !Object.prototype.hasOwnProperty.call(config, k)) continue\n      props[k] = config[k] === undefined && defaultProps ? defaultProps[k] : config[k]\n    }\n  }\n\n  if (children.length === 1) props.children = children[0]\n  else if (children.length > 1) props.children = children\n\n  return { $$typeof: REACT_ELEMENT_TYPE, type: element.type, key, ref, props }\n}\n\nexport function isValidElement(obj: any): obj is ReactElement {\n  if (typeof obj !== 'object' || obj === null) return false\n  const t = obj.$$typeof\n  return t === REACT_ELEMENT_TYPE || t === REACT_LEGACY_ELEMENT_TYPE\n}\n\nexport function createRef<T = any>() {\n  return { current: null as T | null }\n}\n"],
+  "mappings": ";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AAEA,IAAM,WAAW;AAIxB,IAAM,iBAAoC,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,UAAU,EAAE;AAE5E,SAAS,cACd,MACA,WACG,UACW;AACd,MAAI,MAAqB;AACzB,MAAI,MAAW;AACf,QAAM,QAA6B,CAAC;AAEpC,MAAI,UAAU,MAAM;AAClB,QAAI,OAAO,QAAQ,UAAa,OAAO,QAAQ,KAAM,OAAM,KAAK,OAAO;AACvE,QAAI,OAAO,QAAQ,OAAW,OAAM,OAAO;AAC3C,eAAW,KAAK,QAAQ;AACtB,UAAI,CAAC,eAAe,CAAC,KAAK,OAAO,UAAU,eAAe,KAAK,QAAQ,CAAC,GAAG;AACzE,cAAM,CAAC,IAAI,OAAO,CAAC;AAAA,MACrB;AAAA,IACF;AAAA,EACF;AAEA,MAAI,SAAS,WAAW,EAAG,OAAM,WAAW,SAAS,CAAC;AAAA,WAC7C,SAAS,SAAS,EAAG,OAAM,WAAW;AAE/C,MAAI,QAAQ,KAAK,cAAc;AAC7B,UAAM,KAAK,KAAK;AAChB,eAAW,KAAK,IAAI;AAClB,UAAI,MAAM,CAAC,MAAM,OAAW,OAAM,CAAC,IAAI,GAAG,CAAC;AAAA,IAC7C;AAAA,EACF;AAEA,SAAO,EAAE,UAAU,oBAAoB,MAAM,KAAK,KAAK,MAAM;AAC/D;AAEO,SAAS,aACd,SACA,WACG,UACW;AACd,MAAI,MAAM,QAAQ;AAClB,MAAI,MAAM,QAAQ;AAClB,QAAM,QAAQ,EAAE,GAAG,QAAQ,MAAM;AAEjC,MAAI,UAAU,MAAM;AAClB,QAAI,OAAO,QAAQ,OAAW,OAAM,OAAO;AAC3C,QAAI,OAAO,QAAQ,OAAW,OAAM,KAAK,OAAO;AAChD,UAAM,eAAe,QAAQ,MAAM;AACnC,eAAW,KAAK,QAAQ;AACtB,UAAI,eAAe,CAAC,KAAK,CAAC,OAAO,UAAU,eAAe,KAAK,QAAQ,CAAC,EAAG;AAC3E,YAAM,CAAC,IAAI,OAAO,CAAC,MAAM,UAAa,eAAe,aAAa,CAAC,IAAI,OAAO,CAAC;AAAA,IACjF;AAAA,EACF;AAEA,MAAI,SAAS,WAAW,EAAG,OAAM,WAAW,SAAS,CAAC;AAAA,WAC7C,SAAS,SAAS,EAAG,OAAM,WAAW;AAE/C,SAAO,EAAE,UAAU,oBAAoB,MAAM,QAAQ,MAAM,KAAK,KAAK,MAAM;AAC7E;AAEO,SAAS,eAAe,KAA+B;AAC5D,MAAI,OAAO,QAAQ,YAAY,QAAQ,KAAM,QAAO;AACpD,QAAM,IAAI,IAAI;AACd,SAAO,MAAM,sBAAsB,MAAM;AAC3C;AAEO,SAAS,YAAqB;AACnC,SAAO,EAAE,SAAS,KAAiB;AACrC;",
+  "names": []
+}

package/dist/react/hooks.d.ts

@@ -0,0 +1,37 @@
+import type { Dispatch, SetStateAction, EffectCallback, DependencyList } from '../core';
+import type { Context } from './context';
+export declare function useState<S>(initial: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
+export declare function useReducer<S, A>(reducer: (s: S, a: A) => S, initial: any, init?: (a: any) => S): [S, Dispatch<A>];
+export declare function useEffect(create: EffectCallback, deps?: DependencyList): void;
+export declare function useLayoutEffect(create: EffectCallback, deps?: DependencyList): void;
+export declare function useInsertionEffect(create: EffectCallback, deps?: DependencyList): void;
+export declare function useRef<T>(initial: T): {
+    current: T;
+};
+export declare function useRef<T>(initial: T | null): {
+    current: T | null;
+};
+export declare function useRef<T = undefined>(): {
+    current: T | undefined;
+};
+export declare function useMemo<T>(factory: () => T, deps?: DependencyList): T;
+export declare function useCallback<T extends Function>(fn: T, deps?: DependencyList): T;
+export declare function useContext<T>(ctx: Context<T>): T;
+export declare function useImperativeHandle<T>(ref: any, factory: () => T, deps?: DependencyList): void;
+export declare function useDebugValue<T>(value: T, formatter?: (v: T) => any): void;
+export declare function useId(): string;
+export declare function useTransition(): [boolean, (fn: () => void) => void];
+export declare function useDeferredValue<T>(v: T): T;
+export declare function useSyncExternalStore<T>(subscribe: (cb: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T): T;
+export declare function use<T>(resource: any): T;
+export declare function startTransition(fn: () => void): void;
+export declare function useActionState<S, P>(_action: (state: Awaited<S>, payload: P) => S | Promise<S>, initial: Awaited<S>): [Awaited<S>, (payload: P) => void, boolean];
+export declare function useFormStatus(): {
+    pending: boolean;
+    data: any;
+    method: any;
+    action: any;
+};
+export declare function useOptimistic<S, A = S>(state: S, _updateFn?: (s: S, a: A) => S): [S, (action: A) => void];
+export declare function useEffectEvent<Args extends unknown[], Return>(fn: (...args: Args) => Return): (...args: Args) => Return;
+export declare function useSyncExternalStoreWithSelector<Snapshot, Selection>(subscribe: (cb: () => void) => () => void, getSnapshot: () => Snapshot, getServerSnapshot: (() => Snapshot) | undefined, selector: (snapshot: Snapshot) => Selection, isEqual?: (a: Selection, b: Selection) => boolean): Selection;

package/dist/react/hooks.js

@@ -0,0 +1,146 @@
+// packages/redact/src/react/hooks.ts
+import { getDispatcher } from "./shared-internals";
+function useState(initial) {
+  return getDispatcher().useState(initial);
+}
+function useReducer(reducer, initial, init) {
+  return getDispatcher().useReducer(reducer, initial, init);
+}
+function useEffect(create, deps) {
+  getDispatcher().useEffect(create, deps);
+}
+function useLayoutEffect(create, deps) {
+  getDispatcher().useLayoutEffect(create, deps);
+}
+function useInsertionEffect(create, deps) {
+  getDispatcher().useInsertionEffect(create, deps);
+}
+function useRef(initial) {
+  return getDispatcher().useRef(initial);
+}
+function useMemo(factory, deps) {
+  return getDispatcher().useMemo(factory, deps);
+}
+function useCallback(fn, deps) {
+  return getDispatcher().useCallback(fn, deps);
+}
+function useContext(ctx) {
+  return getDispatcher().useContext(ctx);
+}
+function useImperativeHandle(ref, factory, deps) {
+  getDispatcher().useImperativeHandle(ref, factory, deps);
+}
+function useDebugValue(value, formatter) {
+  getDispatcher().useDebugValue(value, formatter);
+}
+function useId() {
+  return getDispatcher().useId();
+}
+function useTransition() {
+  return getDispatcher().useTransition();
+}
+function useDeferredValue(v) {
+  return getDispatcher().useDeferredValue(v);
+}
+function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  return getDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+function use(resource) {
+  return getDispatcher().use(resource);
+}
+function startTransition(fn) {
+  fn();
+}
+function useActionState(_action, initial) {
+  return [initial, () => {
+  }, false];
+}
+function useFormStatus() {
+  return { pending: false, data: null, method: null, action: null };
+}
+function useOptimistic(state, _updateFn) {
+  return [state, () => {
+  }];
+}
+function useEffectEvent(fn) {
+  const ref = useRef(fn);
+  useInsertionEffect(() => {
+    ref.current = fn;
+  });
+  return useCallback(
+    ((...args) => ref.current(...args)),
+    []
+  );
+}
+function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+  const instRef = useRef(null);
+  let inst;
+  if (instRef.current === null) {
+    inst = { hasValue: false, value: null };
+    instRef.current = inst;
+  } else {
+    inst = instRef.current;
+  }
+  const [getSelection, getServerSelection] = useMemo(() => {
+    let hasMemo = false;
+    let memoizedSnapshot;
+    let memoizedSelection;
+    const memoizedSelector = (nextSnapshot) => {
+      if (!hasMemo) {
+        hasMemo = true;
+        memoizedSnapshot = nextSnapshot;
+        const nextSelection2 = selector(nextSnapshot);
+        if (isEqual !== void 0 && inst.hasValue) {
+          const currentSelection = inst.value;
+          if (isEqual(currentSelection, nextSelection2)) {
+            memoizedSelection = currentSelection;
+            return currentSelection;
+          }
+        }
+        memoizedSelection = nextSelection2;
+        return nextSelection2;
+      }
+      const prevSnapshot = memoizedSnapshot;
+      const prevSelection = memoizedSelection;
+      if (Object.is(prevSnapshot, nextSnapshot)) return prevSelection;
+      const nextSelection = selector(nextSnapshot);
+      if (isEqual !== void 0 && isEqual(prevSelection, nextSelection)) return prevSelection;
+      memoizedSnapshot = nextSnapshot;
+      memoizedSelection = nextSelection;
+      return nextSelection;
+    };
+    const get = () => memoizedSelector(getSnapshot());
+    const getServer = getServerSnapshot === void 0 ? void 0 : () => memoizedSelector(getServerSnapshot());
+    return [get, getServer];
+  }, [getSnapshot, getServerSnapshot, selector, isEqual]);
+  const value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
+  useDebugValue(value);
+  inst.hasValue = true;
+  inst.value = value;
+  return value;
+}
+export {
+  startTransition,
+  use,
+  useActionState,
+  useCallback,
+  useContext,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useEffectEvent,
+  useFormStatus,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useOptimistic,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useSyncExternalStoreWithSelector,
+  useTransition
+};
+//# sourceMappingURL=hooks.js.map

package/dist/react/hooks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/react/hooks.ts"],
+  "sourcesContent": ["import type {\n  Dispatch,\n  SetStateAction,\n  EffectCallback,\n  DependencyList,\n} from '../core'\nimport type { Context } from './context'\nimport { getDispatcher } from './shared-internals'\n\nexport function useState<S>(initial: S | (() => S)): [S, Dispatch<SetStateAction<S>>] {\n  return getDispatcher().useState(initial)\n}\n\nexport function useReducer<S, A>(\n  reducer: (s: S, a: A) => S,\n  initial: any,\n  init?: (a: any) => S,\n): [S, Dispatch<A>] {\n  return getDispatcher().useReducer(reducer, initial, init)\n}\n\nexport function useEffect(create: EffectCallback, deps?: DependencyList): void {\n  getDispatcher().useEffect(create, deps)\n}\n\nexport function useLayoutEffect(create: EffectCallback, deps?: DependencyList): void {\n  getDispatcher().useLayoutEffect(create, deps)\n}\n\nexport function useInsertionEffect(create: EffectCallback, deps?: DependencyList): void {\n  getDispatcher().useInsertionEffect(create, deps)\n}\n\nexport function useRef<T>(initial: T): { current: T }\nexport function useRef<T>(initial: T | null): { current: T | null }\nexport function useRef<T = undefined>(): { current: T | undefined }\nexport function useRef(initial?: any): { current: any } {\n  return getDispatcher().useRef(initial)\n}\n\nexport function useMemo<T>(factory: () => T, deps?: DependencyList): T {\n  return getDispatcher().useMemo(factory, deps)\n}\n\nexport function useCallback<T extends Function>(fn: T, deps?: DependencyList): T {\n  return getDispatcher().useCallback(fn, deps)\n}\n\nexport function useContext<T>(ctx: Context<T>): T {\n  return getDispatcher().useContext(ctx)\n}\n\nexport function useImperativeHandle<T>(\n  ref: any,\n  factory: () => T,\n  deps?: DependencyList,\n): void {\n  getDispatcher().useImperativeHandle(ref, factory, deps)\n}\n\nexport function useDebugValue<T>(value: T, formatter?: (v: T) => any): void {\n  getDispatcher().useDebugValue(value, formatter)\n}\n\nexport function useId(): string {\n  return getDispatcher().useId()\n}\n\nexport function useTransition(): [boolean, (fn: () => void) => void] {\n  return getDispatcher().useTransition()\n}\n\nexport function useDeferredValue<T>(v: T): T {\n  return getDispatcher().useDeferredValue(v)\n}\n\nexport function useSyncExternalStore<T>(\n  subscribe: (cb: () => void) => () => void,\n  getSnapshot: () => T,\n  getServerSnapshot?: () => T,\n): T {\n  return getDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)\n}\n\nexport function use<T>(resource: any): T {\n  return getDispatcher().use(resource)\n}\n\nexport function startTransition(fn: () => void): void {\n  fn()\n}\n\nexport function useActionState<S, P>(\n  _action: (state: Awaited<S>, payload: P) => S | Promise<S>,\n  initial: Awaited<S>,\n): [Awaited<S>, (payload: P) => void, boolean] {\n  return [initial, () => {}, false]\n}\n\nexport function useFormStatus() {\n  return { pending: false, data: null, method: null, action: null }\n}\n\nexport function useOptimistic<S, A = S>(\n  state: S,\n  _updateFn?: (s: S, a: A) => S,\n): [S, (action: A) => void] {\n  return [state, () => {}]\n}\n\n// Composed hook \u2014 returns a stable callback that always invokes the latest\n// `fn`. The ref is updated in useInsertionEffect so any useLayoutEffect /\n// useEffect reading ref.current in the next commit sees the fresh function.\nexport function useEffectEvent<Args extends unknown[], Return>(\n  fn: (...args: Args) => Return,\n): (...args: Args) => Return {\n  const ref = useRef(fn)\n  useInsertionEffect(() => {\n    ref.current = fn\n  })\n  return useCallback(\n    ((...args: Args) => ref.current(...args)) as (...args: Args) => Return,\n    [],\n  )\n}\n\n// `useSyncExternalStoreWithSelector` \u2014 provided here so consumers (like\n// @tanstack/react-store) that historically import from\n// `use-sync-external-store/shim/with-selector` can be aliased to this\n// package via the @tanstack/redact/vite plugin. The CJS shim is unsuitable\n// for Cloudflare Workers (it does `var React = require('react')` which\n// fails in workerd). Implementation matches React's reference impl \u2014\n// selector + isEqual gate to avoid re-renders when the selected slice is\n// unchanged across snapshots.\nexport function useSyncExternalStoreWithSelector<Snapshot, Selection>(\n  subscribe: (cb: () => void) => () => void,\n  getSnapshot: () => Snapshot,\n  getServerSnapshot: (() => Snapshot) | undefined,\n  selector: (snapshot: Snapshot) => Selection,\n  isEqual?: (a: Selection, b: Selection) => boolean,\n): Selection {\n  const instRef = useRef<{ hasValue: boolean; value: Selection | null } | null>(null)\n  let inst: { hasValue: boolean; value: Selection | null }\n  if (instRef.current === null) {\n    inst = { hasValue: false, value: null }\n    instRef.current = inst\n  } else {\n    inst = instRef.current\n  }\n\n  const [getSelection, getServerSelection] = useMemo(() => {\n    let hasMemo = false\n    let memoizedSnapshot: Snapshot\n    let memoizedSelection: Selection\n    const memoizedSelector = (nextSnapshot: Snapshot): Selection => {\n      if (!hasMemo) {\n        hasMemo = true\n        memoizedSnapshot = nextSnapshot\n        const nextSelection = selector(nextSnapshot)\n        if (isEqual !== undefined && inst.hasValue) {\n          const currentSelection = inst.value as Selection\n          if (isEqual(currentSelection, nextSelection)) {\n            memoizedSelection = currentSelection\n            return currentSelection\n          }\n        }\n        memoizedSelection = nextSelection\n        return nextSelection\n      }\n      const prevSnapshot: Snapshot = memoizedSnapshot\n      const prevSelection: Selection = memoizedSelection\n      if (Object.is(prevSnapshot, nextSnapshot)) return prevSelection\n      const nextSelection = selector(nextSnapshot)\n      if (isEqual !== undefined && isEqual(prevSelection, nextSelection)) return prevSelection\n      memoizedSnapshot = nextSnapshot\n      memoizedSelection = nextSelection\n      return nextSelection\n    }\n    const get = () => memoizedSelector(getSnapshot())\n    const getServer =\n      getServerSnapshot === undefined ? undefined : () => memoizedSelector(getServerSnapshot())\n    return [get, getServer] as const\n  }, [getSnapshot, getServerSnapshot, selector, isEqual])\n\n  const value = useSyncExternalStore(subscribe, getSelection, getServerSelection)\n  useDebugValue(value)\n  inst.hasValue = true\n  inst.value = value\n  return value\n}\n"],
+  "mappings": ";AAOA,SAAS,qBAAqB;AAEvB,SAAS,SAAY,SAA0D;AACpF,SAAO,cAAc,EAAE,SAAS,OAAO;AACzC;AAEO,SAAS,WACd,SACA,SACA,MACkB;AAClB,SAAO,cAAc,EAAE,WAAW,SAAS,SAAS,IAAI;AAC1D;AAEO,SAAS,UAAU,QAAwB,MAA6B;AAC7E,gBAAc,EAAE,UAAU,QAAQ,IAAI;AACxC;AAEO,SAAS,gBAAgB,QAAwB,MAA6B;AACnF,gBAAc,EAAE,gBAAgB,QAAQ,IAAI;AAC9C;AAEO,SAAS,mBAAmB,QAAwB,MAA6B;AACtF,gBAAc,EAAE,mBAAmB,QAAQ,IAAI;AACjD;AAKO,SAAS,OAAO,SAAiC;AACtD,SAAO,cAAc,EAAE,OAAO,OAAO;AACvC;AAEO,SAAS,QAAW,SAAkB,MAA0B;AACrE,SAAO,cAAc,EAAE,QAAQ,SAAS,IAAI;AAC9C;AAEO,SAAS,YAAgC,IAAO,MAA0B;AAC/E,SAAO,cAAc,EAAE,YAAY,IAAI,IAAI;AAC7C;AAEO,SAAS,WAAc,KAAoB;AAChD,SAAO,cAAc,EAAE,WAAW,GAAG;AACvC;AAEO,SAAS,oBACd,KACA,SACA,MACM;AACN,gBAAc,EAAE,oBAAoB,KAAK,SAAS,IAAI;AACxD;AAEO,SAAS,cAAiB,OAAU,WAAiC;AAC1E,gBAAc,EAAE,cAAc,OAAO,SAAS;AAChD;AAEO,SAAS,QAAgB;AAC9B,SAAO,cAAc,EAAE,MAAM;AAC/B;AAEO,SAAS,gBAAqD;AACnE,SAAO,cAAc,EAAE,cAAc;AACvC;AAEO,SAAS,iBAAoB,GAAS;AAC3C,SAAO,cAAc,EAAE,iBAAiB,CAAC;AAC3C;AAEO,SAAS,qBACd,WACA,aACA,mBACG;AACH,SAAO,cAAc,EAAE,qBAAqB,WAAW,aAAa,iBAAiB;AACvF;AAEO,SAAS,IAAO,UAAkB;AACvC,SAAO,cAAc,EAAE,IAAI,QAAQ;AACrC;AAEO,SAAS,gBAAgB,IAAsB;AACpD,KAAG;AACL;AAEO,SAAS,eACd,SACA,SAC6C;AAC7C,SAAO,CAAC,SAAS,MAAM;AAAA,EAAC,GAAG,KAAK;AAClC;AAEO,SAAS,gBAAgB;AAC9B,SAAO,EAAE,SAAS,OAAO,MAAM,MAAM,QAAQ,MAAM,QAAQ,KAAK;AAClE;AAEO,SAAS,cACd,OACA,WAC0B;AAC1B,SAAO,CAAC,OAAO,MAAM;AAAA,EAAC,CAAC;AACzB;AAKO,SAAS,eACd,IAC2B;AAC3B,QAAM,MAAM,OAAO,EAAE;AACrB,qBAAmB,MAAM;AACvB,QAAI,UAAU;AAAA,EAChB,CAAC;AACD,SAAO;AAAA,KACJ,IAAI,SAAe,IAAI,QAAQ,GAAG,IAAI;AAAA,IACvC,CAAC;AAAA,EACH;AACF;AAUO,SAAS,iCACd,WACA,aACA,mBACA,UACA,SACW;AACX,QAAM,UAAU,OAA8D,IAAI;AAClF,MAAI;AACJ,MAAI,QAAQ,YAAY,MAAM;AAC5B,WAAO,EAAE,UAAU,OAAO,OAAO,KAAK;AACtC,YAAQ,UAAU;AAAA,EACpB,OAAO;AACL,WAAO,QAAQ;AAAA,EACjB;AAEA,QAAM,CAAC,cAAc,kBAAkB,IAAI,QAAQ,MAAM;AACvD,QAAI,UAAU;AACd,QAAI;AACJ,QAAI;AACJ,UAAM,mBAAmB,CAAC,iBAAsC;AAC9D,UAAI,CAAC,SAAS;AACZ,kBAAU;AACV,2BAAmB;AACnB,cAAMA,iBAAgB,SAAS,YAAY;AAC3C,YAAI,YAAY,UAAa,KAAK,UAAU;AAC1C,gBAAM,mBAAmB,KAAK;AAC9B,cAAI,QAAQ,kBAAkBA,cAAa,GAAG;AAC5C,gCAAoB;AACpB,mBAAO;AAAA,UACT;AAAA,QACF;AACA,4BAAoBA;AACpB,eAAOA;AAAA,MACT;AACA,YAAM,eAAyB;AAC/B,YAAM,gBAA2B;AACjC,UAAI,OAAO,GAAG,cAAc,YAAY,EAAG,QAAO;AAClD,YAAM,gBAAgB,SAAS,YAAY;AAC3C,UAAI,YAAY,UAAa,QAAQ,eAAe,aAAa,EAAG,QAAO;AAC3E,yBAAmB;AACnB,0BAAoB;AACpB,aAAO;AAAA,IACT;AACA,UAAM,MAAM,MAAM,iBAAiB,YAAY,CAAC;AAChD,UAAM,YACJ,sBAAsB,SAAY,SAAY,MAAM,iBAAiB,kBAAkB,CAAC;AAC1F,WAAO,CAAC,KAAK,SAAS;AAAA,EACxB,GAAG,CAAC,aAAa,mBAAmB,UAAU,OAAO,CAAC;AAEtD,QAAM,QAAQ,qBAAqB,WAAW,cAAc,kBAAkB;AAC9E,gBAAc,KAAK;AACnB,OAAK,WAAW;AAChB,OAAK,QAAQ;AACb,SAAO;AACT;",
+  "names": ["nextSelection"]
+}

package/dist/react/index.d.ts

@@ -0,0 +1,76 @@
+export { createElement, cloneElement, isValidElement, createRef, Fragment } from './element';
+export { useState, useReducer, useEffect, useLayoutEffect, useInsertionEffect, useRef, useMemo, useCallback, useContext, useImperativeHandle, useDebugValue, useId, useTransition, useDeferredValue, useSyncExternalStore, useSyncExternalStoreWithSelector, use, useActionState, useFormStatus, useOptimistic, useEffectEvent, startTransition, } from './hooks';
+export { createContext, REACT_CONTEXT_TYPE, REACT_PROVIDER_TYPE, REACT_CONSUMER_TYPE, type Context, type ProviderExoticComponent, type ConsumerExoticComponent, } from './context';
+export { Component, PureComponent } from './class';
+export { memo, forwardRef, lazy, REACT_MEMO_TYPE, REACT_FORWARD_REF_TYPE, REACT_LAZY_TYPE, } from './memo';
+export { Suspense, StrictMode, Profiler, REACT_SUSPENSE_TYPE, REACT_STRICT_MODE_TYPE, REACT_PROFILER_TYPE, } from './suspense';
+export { REACT_PORTAL_TYPE } from './portal';
+export { Children } from './children';
+export { ReactSharedInternals } from './shared-internals';
+export declare const cache: <T extends Function>(fn: T) => T;
+export declare const act: (fn: () => any) => Promise<void>;
+export declare function taintUniqueValue(_msg: string, _lifetime: any, _value: any): void;
+export declare function taintObjectReference(_msg: string, _object: any): void;
+export declare const version = "19.2.3";
+import { createElement, cloneElement, isValidElement, createRef } from './element';
+import { useState, useReducer, useEffect, useLayoutEffect, useInsertionEffect, useRef, useMemo, useCallback, useContext, useImperativeHandle, useDebugValue, useId, useTransition, useDeferredValue, useSyncExternalStore, use, useActionState, useFormStatus, useOptimistic, useEffectEvent, startTransition } from './hooks';
+import { createContext } from './context';
+import { Component, PureComponent } from './class';
+import { memo, forwardRef, lazy } from './memo';
+declare const _default: {
+    createElement: typeof createElement;
+    cloneElement: typeof cloneElement;
+    isValidElement: typeof isValidElement;
+    createRef: typeof createRef;
+    Fragment: (props: {
+        children?: import("../core").ReactNode;
+    }) => import("../core").ReactElement;
+    useState: typeof useState;
+    useReducer: typeof useReducer;
+    useEffect: typeof useEffect;
+    useLayoutEffect: typeof useLayoutEffect;
+    useInsertionEffect: typeof useInsertionEffect;
+    useRef: typeof useRef;
+    useMemo: typeof useMemo;
+    useCallback: typeof useCallback;
+    useContext: typeof useContext;
+    useImperativeHandle: typeof useImperativeHandle;
+    useDebugValue: typeof useDebugValue;
+    useId: typeof useId;
+    useTransition: typeof useTransition;
+    useDeferredValue: typeof useDeferredValue;
+    useSyncExternalStore: typeof useSyncExternalStore;
+    use: typeof use;
+    useActionState: typeof useActionState;
+    useFormStatus: typeof useFormStatus;
+    useOptimistic: typeof useOptimistic;
+    useEffectEvent: typeof useEffectEvent;
+    startTransition: typeof startTransition;
+    createContext: typeof createContext;
+    Component: typeof Component;
+    PureComponent: typeof PureComponent;
+    memo: typeof memo;
+    forwardRef: typeof forwardRef;
+    lazy: typeof lazy;
+    Suspense: (props: {
+        children?: any;
+        fallback?: any;
+    }) => any;
+    StrictMode: (props: {
+        children?: any;
+    }) => any;
+    Profiler: (props: {
+        id: string;
+        onRender?: any;
+        children?: any;
+    }) => any;
+    Children: {
+        map(children: import("../core").ReactNode, fn: (child: import("../core").ReactNode, index: number) => any): any[] | null;
+        forEach(children: import("../core").ReactNode, fn: (child: import("../core").ReactNode, index: number) => void): void;
+        count(children: import("../core").ReactNode): number;
+        toArray(children: import("../core").ReactNode): any[];
+        only(children: import("../core").ReactNode): import("../core").ReactElement;
+    };
+    version: string;
+};
+export default _default;

package/dist/react/index.js

@@ -0,0 +1,187 @@
+// packages/redact/src/react/index.ts
+import { createElement, cloneElement, isValidElement, createRef, Fragment } from "./element";
+import {
+  useState,
+  useReducer,
+  useEffect,
+  useLayoutEffect,
+  useInsertionEffect,
+  useRef,
+  useMemo,
+  useCallback,
+  useContext,
+  useImperativeHandle,
+  useDebugValue,
+  useId,
+  useTransition,
+  useDeferredValue,
+  useSyncExternalStore,
+  useSyncExternalStoreWithSelector,
+  use,
+  useActionState,
+  useFormStatus,
+  useOptimistic,
+  useEffectEvent,
+  startTransition
+} from "./hooks";
+import {
+  createContext,
+  REACT_CONTEXT_TYPE,
+  REACT_PROVIDER_TYPE,
+  REACT_CONSUMER_TYPE
+} from "./context";
+import { Component, PureComponent } from "./class";
+import {
+  memo,
+  forwardRef,
+  lazy,
+  REACT_MEMO_TYPE,
+  REACT_FORWARD_REF_TYPE,
+  REACT_LAZY_TYPE
+} from "./memo";
+import {
+  Suspense,
+  StrictMode,
+  Profiler,
+  REACT_SUSPENSE_TYPE,
+  REACT_STRICT_MODE_TYPE,
+  REACT_PROFILER_TYPE
+} from "./suspense";
+import { REACT_PORTAL_TYPE } from "./portal";
+import { Children } from "./children";
+import { ReactSharedInternals } from "./shared-internals";
+import { createElement as createElement2, cloneElement as cloneElement2, isValidElement as isValidElement2, createRef as createRef2, Fragment as Fragment2 } from "./element";
+import {
+  useState as useState2,
+  useReducer as useReducer2,
+  useEffect as useEffect2,
+  useLayoutEffect as useLayoutEffect2,
+  useInsertionEffect as useInsertionEffect2,
+  useRef as useRef2,
+  useMemo as useMemo2,
+  useCallback as useCallback2,
+  useContext as useContext2,
+  useImperativeHandle as useImperativeHandle2,
+  useDebugValue as useDebugValue2,
+  useId as useId2,
+  useTransition as useTransition2,
+  useDeferredValue as useDeferredValue2,
+  useSyncExternalStore as useSyncExternalStore2,
+  use as use2,
+  useActionState as useActionState2,
+  useFormStatus as useFormStatus2,
+  useOptimistic as useOptimistic2,
+  useEffectEvent as useEffectEvent2,
+  startTransition as startTransition2
+} from "./hooks";
+import { createContext as createContext2 } from "./context";
+import { Component as Component2, PureComponent as PureComponent2 } from "./class";
+import { memo as memo2, forwardRef as forwardRef2, lazy as lazy2 } from "./memo";
+import { Suspense as Suspense2, StrictMode as StrictMode2, Profiler as Profiler2 } from "./suspense";
+import { Children as Children2 } from "./children";
+var cache = (fn) => fn;
+var act = async (fn) => {
+  const r = fn();
+  if (r && typeof r.then === "function") await r;
+};
+function taintUniqueValue(_msg, _lifetime, _value) {
+}
+function taintObjectReference(_msg, _object) {
+}
+var version = "19.2.3";
+var react_default = {
+  createElement: createElement2,
+  cloneElement: cloneElement2,
+  isValidElement: isValidElement2,
+  createRef: createRef2,
+  Fragment: Fragment2,
+  useState: useState2,
+  useReducer: useReducer2,
+  useEffect: useEffect2,
+  useLayoutEffect: useLayoutEffect2,
+  useInsertionEffect: useInsertionEffect2,
+  useRef: useRef2,
+  useMemo: useMemo2,
+  useCallback: useCallback2,
+  useContext: useContext2,
+  useImperativeHandle: useImperativeHandle2,
+  useDebugValue: useDebugValue2,
+  useId: useId2,
+  useTransition: useTransition2,
+  useDeferredValue: useDeferredValue2,
+  useSyncExternalStore: useSyncExternalStore2,
+  use: use2,
+  useActionState: useActionState2,
+  useFormStatus: useFormStatus2,
+  useOptimistic: useOptimistic2,
+  useEffectEvent: useEffectEvent2,
+  startTransition: startTransition2,
+  createContext: createContext2,
+  Component: Component2,
+  PureComponent: PureComponent2,
+  memo: memo2,
+  forwardRef: forwardRef2,
+  lazy: lazy2,
+  Suspense: Suspense2,
+  StrictMode: StrictMode2,
+  Profiler: Profiler2,
+  Children: Children2,
+  version: "19.2.3"
+};
+export {
+  Children,
+  Component,
+  Fragment,
+  Profiler,
+  PureComponent,
+  REACT_CONSUMER_TYPE,
+  REACT_CONTEXT_TYPE,
+  REACT_FORWARD_REF_TYPE,
+  REACT_LAZY_TYPE,
+  REACT_MEMO_TYPE,
+  REACT_PORTAL_TYPE,
+  REACT_PROFILER_TYPE,
+  REACT_PROVIDER_TYPE,
+  REACT_STRICT_MODE_TYPE,
+  REACT_SUSPENSE_TYPE,
+  ReactSharedInternals,
+  StrictMode,
+  Suspense,
+  act,
+  cache,
+  cloneElement,
+  createContext,
+  createElement,
+  createRef,
+  react_default as default,
+  forwardRef,
+  isValidElement,
+  lazy,
+  memo,
+  startTransition,
+  taintObjectReference,
+  taintUniqueValue,
+  use,
+  useActionState,
+  useCallback,
+  useContext,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useEffectEvent,
+  useFormStatus,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useOptimistic,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useSyncExternalStoreWithSelector,
+  useTransition,
+  version
+};
+//# sourceMappingURL=index.js.map

package/dist/react/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/react/index.ts"],
+  "sourcesContent": ["export { createElement, cloneElement, isValidElement, createRef, Fragment } from './element'\nexport {\n  useState,\n  useReducer,\n  useEffect,\n  useLayoutEffect,\n  useInsertionEffect,\n  useRef,\n  useMemo,\n  useCallback,\n  useContext,\n  useImperativeHandle,\n  useDebugValue,\n  useId,\n  useTransition,\n  useDeferredValue,\n  useSyncExternalStore,\n  useSyncExternalStoreWithSelector,\n  use,\n  useActionState,\n  useFormStatus,\n  useOptimistic,\n  useEffectEvent,\n  startTransition,\n} from './hooks'\nexport {\n  createContext,\n  REACT_CONTEXT_TYPE,\n  REACT_PROVIDER_TYPE,\n  REACT_CONSUMER_TYPE,\n  type Context,\n  type ProviderExoticComponent,\n  type ConsumerExoticComponent,\n} from './context'\nexport { Component, PureComponent } from './class'\nexport {\n  memo, forwardRef, lazy,\n  REACT_MEMO_TYPE,\n  REACT_FORWARD_REF_TYPE,\n  REACT_LAZY_TYPE,\n} from './memo'\nexport {\n  Suspense, StrictMode, Profiler,\n  REACT_SUSPENSE_TYPE,\n  REACT_STRICT_MODE_TYPE,\n  REACT_PROFILER_TYPE,\n} from './suspense'\nexport { REACT_PORTAL_TYPE } from './portal'\nexport { Children } from './children'\nexport { ReactSharedInternals } from './shared-internals'\n\n// Stub exports\nexport const cache = <T extends Function>(fn: T): T => fn\nexport const act = async (fn: () => any) => {\n  const r = fn()\n  if (r && typeof r.then === 'function') await r\n}\nexport function taintUniqueValue(_msg: string, _lifetime: any, _value: any): void {}\nexport function taintObjectReference(_msg: string, _object: any): void {}\n\nexport const version = '19.2.3'\n\n// Default export for `import React from 'react'` usage\nimport { createElement, cloneElement, isValidElement, createRef, Fragment } from './element'\nimport {\n  useState,\n  useReducer,\n  useEffect,\n  useLayoutEffect,\n  useInsertionEffect,\n  useRef,\n  useMemo,\n  useCallback,\n  useContext,\n  useImperativeHandle,\n  useDebugValue,\n  useId,\n  useTransition,\n  useDeferredValue,\n  useSyncExternalStore,\n  use,\n  useActionState,\n  useFormStatus,\n  useOptimistic,\n  useEffectEvent,\n  startTransition,\n} from './hooks'\nimport { createContext } from './context'\nimport { Component, PureComponent } from './class'\nimport { memo, forwardRef, lazy } from './memo'\nimport { Suspense, StrictMode, Profiler } from './suspense'\nimport { Children } from './children'\n\nexport default {\n  createElement,\n  cloneElement,\n  isValidElement,\n  createRef,\n  Fragment,\n  useState,\n  useReducer,\n  useEffect,\n  useLayoutEffect,\n  useInsertionEffect,\n  useRef,\n  useMemo,\n  useCallback,\n  useContext,\n  useImperativeHandle,\n  useDebugValue,\n  useId,\n  useTransition,\n  useDeferredValue,\n  useSyncExternalStore,\n  use,\n  useActionState,\n  useFormStatus,\n  useOptimistic,\n  useEffectEvent,\n  startTransition,\n  createContext,\n  Component,\n  PureComponent,\n  memo,\n  forwardRef,\n  lazy,\n  Suspense,\n  StrictMode,\n  Profiler,\n  Children,\n  version: '19.2.3',\n}\n"],
+  "mappings": "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",
+  "names": ["createElement", "cloneElement", "isValidElement", "createRef", "Fragment", "useState", "useReducer", "useEffect", "useLayoutEffect", "useInsertionEffect", "useRef", "useMemo", "useCallback", "useContext", "useImperativeHandle", "useDebugValue", "useId", "useTransition", "useDeferredValue", "useSyncExternalStore", "use", "useActionState", "useFormStatus", "useOptimistic", "useEffectEvent", "startTransition", "createContext", "Component", "PureComponent", "memo", "forwardRef", "lazy", "Suspense", "StrictMode", "Profiler", "Children"]
+}

package/dist/react/jsx-runtime.d.ts

@@ -0,0 +1,5 @@
+import { type ReactElement } from '../core';
+export { Fragment } from './element';
+export declare function jsx(type: any, props: any, key?: any): ReactElement;
+export declare const jsxs: typeof jsx;
+export declare const jsxDEV: typeof jsx;

package/dist/react/jsx-runtime.js

@@ -0,0 +1,21 @@
+// packages/redact/src/react/jsx-runtime.ts
+import { REACT_ELEMENT_TYPE } from "../core";
+import { Fragment } from "./element";
+function jsx(type, props, key) {
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type,
+    key: key == null ? null : "" + key,
+    ref: props?.ref ?? null,
+    props
+  };
+}
+var jsxs = jsx;
+var jsxDEV = jsx;
+export {
+  Fragment,
+  jsx,
+  jsxDEV,
+  jsxs
+};
+//# sourceMappingURL=jsx-runtime.js.map

package/dist/react/jsx-runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/react/jsx-runtime.ts"],
+  "sourcesContent": ["import { REACT_ELEMENT_TYPE, type ReactElement } from '../core'\n\nexport { Fragment } from './element'\n\nexport function jsx(type: any, props: any, key?: any): ReactElement {\n  return {\n    $$typeof: REACT_ELEMENT_TYPE,\n    type,\n    key: key == null ? null : '' + key,\n    ref: props?.ref ?? null,\n    props,\n  }\n}\n\nexport const jsxs = jsx\nexport const jsxDEV = jsx\n"],
+  "mappings": ";AAAA,SAAS,0BAA6C;AAEtD,SAAS,gBAAgB;AAElB,SAAS,IAAI,MAAW,OAAY,KAAyB;AAClE,SAAO;AAAA,IACL,UAAU;AAAA,IACV;AAAA,IACA,KAAK,OAAO,OAAO,OAAO,KAAK;AAAA,IAC/B,KAAK,OAAO,OAAO;AAAA,IACnB;AAAA,EACF;AACF;AAEO,IAAM,OAAO;AACb,IAAM,SAAS;",
+  "names": []
+}

package/dist/react/memo.d.ts

@@ -0,0 +1,29 @@
+export declare const REACT_MEMO_TYPE: unique symbol;
+export declare const REACT_FORWARD_REF_TYPE: unique symbol;
+export declare const REACT_LAZY_TYPE: unique symbol;
+export declare function memo<P>(type: (props: P) => any, areEqual?: (prev: Readonly<P>, next: Readonly<P>) => boolean): {
+    $$typeof: symbol;
+    type: (props: P) => any;
+    compare: (prev: Readonly<P>, next: Readonly<P>) => boolean;
+};
+export declare function forwardRef<R, P = {}>(render: (props: P, ref: {
+    current: R | null;
+} | ((r: R | null) => void) | null) => any): {
+    $$typeof: symbol;
+    render: (props: P, ref: {
+        current: R | null;
+    } | ((r: R | null) => void) | null) => any;
+};
+export declare function lazy<T extends {
+    default: any;
+}>(ctor: () => Promise<T>): {
+    $$typeof: symbol;
+    _payload: {
+        status: -1 | 0 | 1 | 2;
+        result: any;
+    };
+    _init: (p: {
+        status: -1 | 0 | 1 | 2;
+        result: any;
+    }) => any;
+};

package/dist/react/memo.js

@@ -0,0 +1,47 @@
+// packages/redact/src/react/memo.ts
+var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+function memo(type, areEqual) {
+  return { $$typeof: REACT_MEMO_TYPE, type, compare: areEqual ?? null };
+}
+function forwardRef(render) {
+  return { $$typeof: REACT_FORWARD_REF_TYPE, render };
+}
+function lazy(ctor) {
+  const payload = {
+    status: -1,
+    result: void 0
+  };
+  return {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: payload,
+    _init: (p) => {
+      if (p.status === 1) return p.result;
+      if (p.status === 2) throw p.result;
+      if (p.status === 0) throw p.result;
+      const thenable = ctor().then(
+        (mod) => {
+          p.status = 1;
+          p.result = mod.default;
+        },
+        (err) => {
+          p.status = 2;
+          p.result = err;
+        }
+      );
+      p.status = 0;
+      p.result = thenable;
+      throw thenable;
+    }
+  };
+}
+export {
+  REACT_FORWARD_REF_TYPE,
+  REACT_LAZY_TYPE,
+  REACT_MEMO_TYPE,
+  forwardRef,
+  lazy,
+  memo
+};
+//# sourceMappingURL=memo.js.map

package/dist/react/memo.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/react/memo.ts"],
+  "sourcesContent": ["export const REACT_MEMO_TYPE = Symbol.for('react.memo')\nexport const REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref')\nexport const REACT_LAZY_TYPE = Symbol.for('react.lazy')\n\nexport function memo<P>(\n  type: (props: P) => any,\n  areEqual?: (prev: Readonly<P>, next: Readonly<P>) => boolean,\n) {\n  return { $$typeof: REACT_MEMO_TYPE, type, compare: areEqual ?? null }\n}\n\nexport function forwardRef<R, P = {}>(\n  render: (props: P, ref: { current: R | null } | ((r: R | null) => void) | null) => any,\n) {\n  return { $$typeof: REACT_FORWARD_REF_TYPE, render }\n}\n\nexport function lazy<T extends { default: any }>(ctor: () => Promise<T>) {\n  const payload = {\n    status: -1 as -1 | 0 | 1 | 2,\n    result: undefined as any,\n  }\n  return {\n    $$typeof: REACT_LAZY_TYPE,\n    _payload: payload,\n    _init: (p: typeof payload): any => {\n      if (p.status === 1) return p.result\n      if (p.status === 2) throw p.result\n      if (p.status === 0) throw p.result // pending promise\n      const thenable = ctor().then(\n        (mod) => {\n          p.status = 1\n          p.result = mod.default\n        },\n        (err) => {\n          p.status = 2\n          p.result = err\n        },\n      )\n      p.status = 0\n      p.result = thenable\n      throw thenable\n    },\n  }\n}\n"],
+  "mappings": ";AAAO,IAAM,kBAAkB,uBAAO,IAAI,YAAY;AAC/C,IAAM,yBAAyB,uBAAO,IAAI,mBAAmB;AAC7D,IAAM,kBAAkB,uBAAO,IAAI,YAAY;AAE/C,SAAS,KACd,MACA,UACA;AACA,SAAO,EAAE,UAAU,iBAAiB,MAAM,SAAS,YAAY,KAAK;AACtE;AAEO,SAAS,WACd,QACA;AACA,SAAO,EAAE,UAAU,wBAAwB,OAAO;AACpD;AAEO,SAAS,KAAiC,MAAwB;AACvE,QAAM,UAAU;AAAA,IACd,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AACA,SAAO;AAAA,IACL,UAAU;AAAA,IACV,UAAU;AAAA,IACV,OAAO,CAAC,MAA2B;AACjC,UAAI,EAAE,WAAW,EAAG,QAAO,EAAE;AAC7B,UAAI,EAAE,WAAW,EAAG,OAAM,EAAE;AAC5B,UAAI,EAAE,WAAW,EAAG,OAAM,EAAE;AAC5B,YAAM,WAAW,KAAK,EAAE;AAAA,QACtB,CAAC,QAAQ;AACP,YAAE,SAAS;AACX,YAAE,SAAS,IAAI;AAAA,QACjB;AAAA,QACA,CAAC,QAAQ;AACP,YAAE,SAAS;AACX,YAAE,SAAS;AAAA,QACb;AAAA,MACF;AACA,QAAE,SAAS;AACX,QAAE,SAAS;AACX,YAAM;AAAA,IACR;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/react/portal.d.ts

@@ -0,0 +1 @@
+export declare const REACT_PORTAL_TYPE: unique symbol;

package/dist/react/portal.js

@@ -0,0 +1,6 @@
+// packages/redact/src/react/portal.ts
+var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
+export {
+  REACT_PORTAL_TYPE
+};
+//# sourceMappingURL=portal.js.map

package/dist/react/portal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/react/portal.ts"],
+  "sourcesContent": ["export const REACT_PORTAL_TYPE = Symbol.for('react.portal')\n"],
+  "mappings": ";AAAO,IAAM,oBAAoB,uBAAO,IAAI,cAAc;",
+  "names": []
+}