hadars 0.1.16 → 0.1.18

package/dist/slim-react/index.cjs

@@ -0,0 +1,874 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/slim-react/index.ts
+var slim_react_exports = {};
+__export(slim_react_exports, {
+  Children: () => Children,
+  Component: () => Component,
+  FRAGMENT_TYPE: () => FRAGMENT_TYPE,
+  Fragment: () => Fragment,
+  PureComponent: () => PureComponent,
+  SLIM_ELEMENT: () => SLIM_ELEMENT,
+  SUSPENSE_TYPE: () => SUSPENSE_TYPE,
+  Suspense: () => Suspense,
+  cloneElement: () => cloneElement,
+  createContext: () => createContext,
+  createElement: () => createElement,
+  default: () => slim_react_default,
+  forwardRef: () => forwardRef,
+  isValidElement: () => isValidElement,
+  jsx: () => jsx,
+  jsxDEV: () => jsx,
+  jsxs: () => jsx,
+  lazy: () => lazy,
+  memo: () => memo,
+  renderToReadableStream: () => renderToStream,
+  renderToStream: () => renderToStream,
+  renderToString: () => renderToString,
+  startTransition: () => startTransition,
+  use: () => use,
+  useActionState: () => useActionState,
+  useCallback: () => useCallback,
+  useContext: () => useContext,
+  useDebugValue: () => useDebugValue,
+  useDeferredValue: () => useDeferredValue,
+  useEffect: () => useEffect,
+  useFormStatus: () => useFormStatus,
+  useId: () => useId,
+  useImperativeHandle: () => useImperativeHandle,
+  useInsertionEffect: () => useInsertionEffect,
+  useLayoutEffect: () => useLayoutEffect,
+  useMemo: () => useMemo,
+  useOptimistic: () => useOptimistic,
+  useReducer: () => useReducer,
+  useRef: () => useRef,
+  useState: () => useState,
+  useSyncExternalStore: () => useSyncExternalStore,
+  useTransition: () => useTransition
+});
+module.exports = __toCommonJS(slim_react_exports);
+
+// src/slim-react/types.ts
+var SLIM_ELEMENT = Symbol.for("react.element");
+var FRAGMENT_TYPE = Symbol.for("react.fragment");
+var SUSPENSE_TYPE = Symbol.for("react.suspense");
+
+// src/slim-react/jsx.ts
+var Fragment = FRAGMENT_TYPE;
+function jsx(type, props, key) {
+  return {
+    $$typeof: SLIM_ELEMENT,
+    type,
+    props: props || {},
+    key: key ?? (props?.key ?? null)
+  };
+}
+function createElement(type, props, ...children) {
+  const normalizedProps = { ...props || {} };
+  if (children.length === 1) {
+    normalizedProps.children = children[0];
+  } else if (children.length > 1) {
+    normalizedProps.children = children;
+  }
+  const key = normalizedProps.key ?? null;
+  delete normalizedProps.key;
+  return {
+    $$typeof: SLIM_ELEMENT,
+    type,
+    props: normalizedProps,
+    key
+  };
+}
+
+// src/slim-react/renderContext.ts
+var GLOBAL_KEY = "__slimReactRenderState";
+var EMPTY = { id: 0, overflow: "", bits: 0 };
+function s() {
+  const g = globalThis;
+  if (!g[GLOBAL_KEY]) {
+    g[GLOBAL_KEY] = { currentTreeContext: { ...EMPTY }, localIdCounter: 0, idPrefix: "" };
+  }
+  return g[GLOBAL_KEY];
+}
+function resetRenderState() {
+  const st = s();
+  st.currentTreeContext = { ...EMPTY };
+  st.localIdCounter = 0;
+}
+function pushTreeContext(totalChildren, index) {
+  const st = s();
+  const saved = { ...st.currentTreeContext };
+  const pendingBits = 32 - Math.clz32(totalChildren);
+  const slot = index + 1;
+  const totalBits = st.currentTreeContext.bits + pendingBits;
+  if (totalBits <= 30) {
+    st.currentTreeContext = {
+      id: st.currentTreeContext.id << pendingBits | slot,
+      overflow: st.currentTreeContext.overflow,
+      bits: totalBits
+    };
+  } else {
+    let newOverflow = st.currentTreeContext.overflow;
+    if (st.currentTreeContext.bits > 0)
+      newOverflow += st.currentTreeContext.id.toString(32);
+    st.currentTreeContext = { id: 1 << pendingBits | slot, overflow: newOverflow, bits: pendingBits };
+  }
+  return saved;
+}
+function popTreeContext(saved) {
+  s().currentTreeContext = saved;
+}
+function pushComponentScope() {
+  const st = s();
+  const saved = st.localIdCounter;
+  st.localIdCounter = 0;
+  return saved;
+}
+function popComponentScope(saved) {
+  s().localIdCounter = saved;
+}
+function snapshotContext() {
+  const st = s();
+  return { tree: { ...st.currentTreeContext }, localId: st.localIdCounter };
+}
+function restoreContext(snap) {
+  const st = s();
+  st.currentTreeContext = { ...snap.tree };
+  st.localIdCounter = snap.localId;
+}
+function getTreeId() {
+  const { id, overflow, bits } = s().currentTreeContext;
+  return bits > 0 ? overflow + id.toString(32) : overflow;
+}
+function makeId() {
+  const st = s();
+  const treeId = getTreeId();
+  const n = st.localIdCounter++;
+  let id = ":" + st.idPrefix + "R";
+  if (treeId.length > 0)
+    id += treeId;
+  id += ":";
+  if (n > 0)
+    id += "H" + n.toString(32) + ":";
+  return id;
+}
+
+// src/slim-react/hooks.ts
+function useState(initialState) {
+  const value = typeof initialState === "function" ? initialState() : initialState;
+  return [value, () => {
+  }];
+}
+function useReducer(_reducer, initialState) {
+  return [initialState, () => {
+  }];
+}
+function useEffect(_effect, _deps) {
+}
+function useLayoutEffect(_effect, _deps) {
+}
+function useInsertionEffect(_effect, _deps) {
+}
+function useRef(initialValue) {
+  return { current: initialValue };
+}
+function useMemo(factory, _deps) {
+  return factory();
+}
+function useCallback(callback, _deps) {
+  return callback;
+}
+function useId() {
+  return makeId();
+}
+function useDebugValue(_value, _format) {
+}
+function useImperativeHandle(_ref, _createHandle, _deps) {
+}
+function useSyncExternalStore(_subscribe, getSnapshot, getServerSnapshot) {
+  return (getServerSnapshot || getSnapshot)();
+}
+function useTransition() {
+  return [false, (cb) => cb()];
+}
+function useDeferredValue(value) {
+  return value;
+}
+function useOptimistic(passthrough) {
+  return [passthrough, () => {
+  }];
+}
+function useFormStatus() {
+  return { pending: false, data: null, method: null, action: null };
+}
+function useActionState(_action, initialState, _permalink) {
+  return [initialState, () => {
+  }, false];
+}
+function use(usable) {
+  if (typeof usable === "object" && usable !== null && "_currentValue" in usable) {
+    return usable._currentValue;
+  }
+  const promise = usable;
+  if (promise.status === "fulfilled")
+    return promise.value;
+  if (promise.status === "rejected")
+    throw promise.reason;
+  throw promise;
+}
+function startTransition(callback) {
+  callback();
+}
+
+// src/slim-react/context.ts
+function createContext(defaultValue) {
+  const context = {
+    _currentValue: defaultValue,
+    Provider: null,
+    Consumer: null
+  };
+  const Provider = function ContextProvider({
+    children
+  }) {
+    return children ?? null;
+  };
+  Provider._context = context;
+  context.Provider = Provider;
+  context.Consumer = ({ children }) => {
+    return children(
+      context._currentValue
+    );
+  };
+  return context;
+}
+
+// src/slim-react/render.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function styleObjectToString(style) {
+  return Object.entries(style).map(([key, value]) => {
+    const cssKey = key.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+    return `${cssKey}:${value}`;
+  }).join(";");
+}
+var SVG_ATTR_MAP = {
+  // Presentation / geometry
+  accentHeight: "accent-height",
+  alignmentBaseline: "alignment-baseline",
+  arabicForm: "arabic-form",
+  baselineShift: "baseline-shift",
+  capHeight: "cap-height",
+  clipPath: "clip-path",
+  clipRule: "clip-rule",
+  colorInterpolation: "color-interpolation",
+  colorInterpolationFilters: "color-interpolation-filters",
+  colorProfile: "color-profile",
+  dominantBaseline: "dominant-baseline",
+  enableBackground: "enable-background",
+  fillOpacity: "fill-opacity",
+  fillRule: "fill-rule",
+  floodColor: "flood-color",
+  floodOpacity: "flood-opacity",
+  fontFamily: "font-family",
+  fontSize: "font-size",
+  fontSizeAdjust: "font-size-adjust",
+  fontStretch: "font-stretch",
+  fontStyle: "font-style",
+  fontVariant: "font-variant",
+  fontWeight: "font-weight",
+  glyphName: "glyph-name",
+  glyphOrientationHorizontal: "glyph-orientation-horizontal",
+  glyphOrientationVertical: "glyph-orientation-vertical",
+  horizAdvX: "horiz-adv-x",
+  horizOriginX: "horiz-origin-x",
+  imageRendering: "image-rendering",
+  letterSpacing: "letter-spacing",
+  lightingColor: "lighting-color",
+  markerEnd: "marker-end",
+  markerMid: "marker-mid",
+  markerStart: "marker-start",
+  overlinePosition: "overline-position",
+  overlineThickness: "overline-thickness",
+  paintOrder: "paint-order",
+  panose1: "panose-1",
+  pointerEvents: "pointer-events",
+  renderingIntent: "rendering-intent",
+  shapeRendering: "shape-rendering",
+  stopColor: "stop-color",
+  stopOpacity: "stop-opacity",
+  strikethroughPosition: "strikethrough-position",
+  strikethroughThickness: "strikethrough-thickness",
+  strokeDasharray: "stroke-dasharray",
+  strokeDashoffset: "stroke-dashoffset",
+  strokeLinecap: "stroke-linecap",
+  strokeLinejoin: "stroke-linejoin",
+  strokeMiterlimit: "stroke-miterlimit",
+  strokeOpacity: "stroke-opacity",
+  strokeWidth: "stroke-width",
+  textAnchor: "text-anchor",
+  textDecoration: "text-decoration",
+  textRendering: "text-rendering",
+  underlinePosition: "underline-position",
+  underlineThickness: "underline-thickness",
+  unicodeBidi: "unicode-bidi",
+  unicodeRange: "unicode-range",
+  unitsPerEm: "units-per-em",
+  vAlphabetic: "v-alphabetic",
+  vHanging: "v-hanging",
+  vIdeographic: "v-ideographic",
+  vMathematical: "v-mathematical",
+  vertAdvY: "vert-adv-y",
+  vertOriginX: "vert-origin-x",
+  vertOriginY: "vert-origin-y",
+  wordSpacing: "word-spacing",
+  writingMode: "writing-mode",
+  xHeight: "x-height",
+  // Namespace-prefixed
+  xlinkActuate: "xlink:actuate",
+  xlinkArcrole: "xlink:arcrole",
+  xlinkHref: "xlink:href",
+  xlinkRole: "xlink:role",
+  xlinkShow: "xlink:show",
+  xlinkTitle: "xlink:title",
+  xlinkType: "xlink:type",
+  xmlBase: "xml:base",
+  xmlLang: "xml:lang",
+  xmlSpace: "xml:space",
+  xmlns: "xmlns",
+  xmlnsXlink: "xmlns:xlink",
+  // Filter / lighting
+  baseFrequency: "baseFrequency",
+  colorInterpolation_filters: "color-interpolation-filters",
+  diffuseConstant: "diffuseConstant",
+  edgeMode: "edgeMode",
+  filterUnits: "filterUnits",
+  gradientTransform: "gradientTransform",
+  gradientUnits: "gradientUnits",
+  kernelMatrix: "kernelMatrix",
+  kernelUnitLength: "kernelUnitLength",
+  lengthAdjust: "lengthAdjust",
+  limitingConeAngle: "limitingConeAngle",
+  markerHeight: "markerHeight",
+  markerWidth: "markerWidth",
+  maskContentUnits: "maskContentUnits",
+  maskUnits: "maskUnits",
+  numOctaves: "numOctaves",
+  pathLength: "pathLength",
+  patternContentUnits: "patternContentUnits",
+  patternTransform: "patternTransform",
+  patternUnits: "patternUnits",
+  pointsAtX: "pointsAtX",
+  pointsAtY: "pointsAtY",
+  pointsAtZ: "pointsAtZ",
+  preserveAspectRatio: "preserveAspectRatio",
+  primitiveUnits: "primitiveUnits",
+  refX: "refX",
+  refY: "refY",
+  repeatCount: "repeatCount",
+  repeatDur: "repeatDur",
+  specularConstant: "specularConstant",
+  specularExponent: "specularExponent",
+  spreadMethod: "spreadMethod",
+  startOffset: "startOffset",
+  stdDeviation: "stdDeviation",
+  stitchTiles: "stitchTiles",
+  surfaceScale: "surfaceScale",
+  systemLanguage: "systemLanguage",
+  tableValues: "tableValues",
+  targetX: "targetX",
+  targetY: "targetY",
+  textLength: "textLength",
+  viewBox: "viewBox",
+  xChannelSelector: "xChannelSelector",
+  yChannelSelector: "yChannelSelector"
+};
+function renderAttributes(props, isSvg) {
+  let attrs = "";
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children" || key === "key" || key === "ref" || key === "dangerouslySetInnerHTML")
+      continue;
+    if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase())
+      continue;
+    let attrName;
+    if (isSvg && key in SVG_ATTR_MAP) {
+      attrName = SVG_ATTR_MAP[key];
+    } else {
+      attrName = key === "className" ? "class" : key === "htmlFor" ? "for" : key === "tabIndex" ? "tabindex" : key;
+    }
+    if (value === false || value == null)
+      continue;
+    if (value === true) {
+      attrs += ` ${attrName}`;
+      continue;
+    }
+    if (key === "style" && typeof value === "object") {
+      attrs += ` style="${escapeAttr(styleObjectToString(value))}"`;
+      continue;
+    }
+    attrs += ` ${attrName}="${escapeAttr(String(value))}"`;
+  }
+  return attrs;
+}
+var BufferWriter = class {
+  chunks = [];
+  write(chunk) {
+    this.chunks.push(chunk);
+  }
+  flush(target) {
+    for (const c of this.chunks)
+      target.write(c);
+  }
+};
+function renderNode(node, writer, isSvg = false) {
+  if (node == null || typeof node === "boolean")
+    return;
+  if (typeof node === "string") {
+    writer.write(escapeHtml(node));
+    return;
+  }
+  if (typeof node === "number") {
+    writer.write(String(node));
+    return;
+  }
+  if (Array.isArray(node)) {
+    return renderChildArray(node, writer, isSvg);
+  }
+  if (typeof node === "object" && node !== null && Symbol.iterator in node && !("$$typeof" in node)) {
+    return renderChildArray(
+      Array.from(node),
+      writer,
+      isSvg
+    );
+  }
+  if (typeof node === "object" && node !== null && "$$typeof" in node && node.$$typeof === SLIM_ELEMENT) {
+    const element = node;
+    const { type, props } = element;
+    if (type === FRAGMENT_TYPE) {
+      return renderChildren(props.children, writer, isSvg);
+    }
+    if (type === SUSPENSE_TYPE) {
+      return renderSuspense(props, writer, isSvg);
+    }
+    if (typeof type === "function") {
+      return renderComponent(type, props, writer, isSvg);
+    }
+    if (typeof type === "string") {
+      return renderHostElement(type, props, writer, isSvg);
+    }
+  }
+}
+function renderHostElement(tag, props, writer, isSvg) {
+  const enteringSvg = tag === "svg";
+  const childSvg = isSvg || enteringSvg;
+  const effectiveProps = enteringSvg && !props.xmlns ? { xmlns: "http://www.w3.org/2000/svg", ...props } : props;
+  writer.write(`<${tag}${renderAttributes(effectiveProps, childSvg)}>`);
+  const childContext = tag === "foreignObject" ? false : childSvg;
+  let inner = void 0;
+  if (props.dangerouslySetInnerHTML) {
+    writer.write(props.dangerouslySetInnerHTML.__html);
+  } else {
+    inner = renderChildren(props.children, writer, childContext);
+  }
+  if (inner && typeof inner.then === "function") {
+    return inner.then(() => {
+      if (!VOID_ELEMENTS.has(tag))
+        writer.write(`</${tag}>`);
+    });
+  }
+  if (!VOID_ELEMENTS.has(tag))
+    writer.write(`</${tag}>`);
+}
+var REACT_MEMO = Symbol.for("react.memo");
+var REACT_FORWARD_REF = Symbol.for("react.forward_ref");
+var REACT_PROVIDER = Symbol.for("react.provider");
+var REACT_CONTEXT = Symbol.for("react.context");
+function renderComponent(type, props, writer, isSvg) {
+  const typeOf = type?.$$typeof;
+  if (typeOf === REACT_MEMO) {
+    return renderNode(
+      { $$typeof: SLIM_ELEMENT, type: type.type, props, key: null },
+      writer,
+      isSvg
+    );
+  }
+  if (typeOf === REACT_FORWARD_REF) {
+    return renderComponent(type.render, props, writer, isSvg);
+  }
+  const isProvider = "_context" in type || typeOf === REACT_PROVIDER || typeOf === REACT_CONTEXT && "value" in props;
+  let prevCtxValue;
+  let ctx;
+  if (isProvider) {
+    ctx = type._context ?? type;
+    prevCtxValue = ctx._currentValue;
+    ctx._currentValue = props.value;
+  }
+  const savedScope = pushComponentScope();
+  let result;
+  try {
+    if (type.prototype && typeof type.prototype.render === "function") {
+      const instance = new type(props);
+      result = instance.render();
+    } else {
+      result = type(props);
+    }
+  } catch (e) {
+    popComponentScope(savedScope);
+    if (isProvider)
+      ctx._currentValue = prevCtxValue;
+    throw e;
+  }
+  const finish = () => {
+    popComponentScope(savedScope);
+    if (isProvider)
+      ctx._currentValue = prevCtxValue;
+  };
+  if (result instanceof Promise) {
+    return result.then((resolved) => {
+      const r2 = renderNode(resolved, writer, isSvg);
+      if (r2 && typeof r2.then === "function") {
+        return r2.then(finish);
+      }
+      finish();
+    });
+  }
+  const r = renderNode(result, writer, isSvg);
+  if (r && typeof r.then === "function") {
+    return r.then(finish);
+  }
+  finish();
+}
+function isTextLike(node) {
+  return typeof node === "string" || typeof node === "number";
+}
+function renderChildArray(children, writer, isSvg) {
+  const totalChildren = children.length;
+  for (let i = 0; i < totalChildren; i++) {
+    if (i > 0 && isTextLike(children[i]) && isTextLike(children[i - 1])) {
+      writer.write("<!-- -->");
+    }
+    const savedTree = pushTreeContext(totalChildren, i);
+    const r = renderNode(children[i], writer, isSvg);
+    if (r && typeof r.then === "function") {
+      return r.then(() => {
+        popTreeContext(savedTree);
+        return renderChildArrayFrom(children, i + 1, writer, isSvg);
+      });
+    }
+    popTreeContext(savedTree);
+  }
+}
+function renderChildArrayFrom(children, startIndex, writer, isSvg) {
+  const totalChildren = children.length;
+  for (let i = startIndex; i < totalChildren; i++) {
+    if (i > 0 && isTextLike(children[i]) && isTextLike(children[i - 1])) {
+      writer.write("<!-- -->");
+    }
+    const savedTree = pushTreeContext(totalChildren, i);
+    const r = renderNode(children[i], writer, isSvg);
+    if (r && typeof r.then === "function") {
+      return r.then(() => {
+        popTreeContext(savedTree);
+        return renderChildArrayFrom(children, i + 1, writer, isSvg);
+      });
+    }
+    popTreeContext(savedTree);
+  }
+}
+function renderChildren(children, writer, isSvg = false) {
+  if (children == null)
+    return;
+  if (Array.isArray(children)) {
+    return renderChildArray(children, writer, isSvg);
+  }
+  return renderNode(children, writer, isSvg);
+}
+var MAX_SUSPENSE_RETRIES = 25;
+async function renderSuspense(props, writer, isSvg = false) {
+  const { children, fallback } = props;
+  let attempts = 0;
+  const snap = snapshotContext();
+  while (attempts < MAX_SUSPENSE_RETRIES) {
+    restoreContext(snap);
+    try {
+      const buffer = new BufferWriter();
+      const r = renderNode(children, buffer, isSvg);
+      if (r && typeof r.then === "function") {
+        await r;
+      }
+      writer.write("<!--$-->");
+      buffer.flush(writer);
+      writer.write("<!--/$-->");
+      return;
+    } catch (error) {
+      if (error && typeof error.then === "function") {
+        await error;
+        attempts++;
+      } else {
+        throw error;
+      }
+    }
+  }
+  restoreContext(snap);
+  writer.write("<!--$?-->");
+  if (fallback) {
+    const r = renderNode(fallback, writer, isSvg);
+    if (r && typeof r.then === "function")
+      await r;
+  }
+  writer.write("<!--/$-->");
+}
+function renderToStream(element) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      resetRenderState();
+      const writer = {
+        write(chunk) {
+          controller.enqueue(encoder.encode(chunk));
+        }
+      };
+      try {
+        const r = renderNode(element, writer);
+        if (r && typeof r.then === "function")
+          await r;
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+}
+async function renderToString(element) {
+  for (let attempt = 0; attempt < MAX_SUSPENSE_RETRIES; attempt++) {
+    resetRenderState();
+    const chunks = [];
+    const writer = { write(c) {
+      chunks.push(c);
+    } };
+    try {
+      const r = renderNode(element, writer);
+      if (r && typeof r.then === "function")
+        await r;
+      return chunks.join("");
+    } catch (error) {
+      if (error && typeof error.then === "function") {
+        await error;
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error("[slim-react] renderToString exceeded maximum retries");
+}
+
+// src/slim-react/index.ts
+function useContext(context) {
+  return context._currentValue;
+}
+var Suspense = SUSPENSE_TYPE;
+function isValidElement(obj) {
+  return typeof obj === "object" && obj !== null && obj.$$typeof === SLIM_ELEMENT;
+}
+function cloneElement(element, overrideProps, ...children) {
+  return {
+    $$typeof: SLIM_ELEMENT,
+    type: element.type,
+    props: {
+      ...element.props,
+      ...overrideProps,
+      ...children.length === 1 ? { children: children[0] } : children.length > 1 ? { children } : {}
+    },
+    key: overrideProps?.key ?? element.key
+  };
+}
+function forwardRef(render) {
+  const component = (props) => render(props, props.ref ?? null);
+  component.displayName = render.displayName || render.name || "ForwardRef";
+  return component;
+}
+function memo(component) {
+  return component;
+}
+function lazy(factory) {
+  let resolved = null;
+  let promise = null;
+  return function LazyComponent(props) {
+    if (resolved)
+      return resolved(props);
+    if (!promise) {
+      promise = factory().then((mod) => {
+        resolved = mod.default;
+      });
+    }
+    throw promise;
+  };
+}
+function toFlatArray(children) {
+  if (children == null || typeof children === "boolean")
+    return [];
+  if (Array.isArray(children))
+    return children.flatMap(toFlatArray);
+  return [children];
+}
+var Children = {
+  map(children, fn) {
+    return toFlatArray(children).map((child, i) => fn(child, i));
+  },
+  forEach(children, fn) {
+    toFlatArray(children).forEach((child, i) => fn(child, i));
+  },
+  count(children) {
+    return toFlatArray(children).length;
+  },
+  only(children) {
+    const arr = toFlatArray(children);
+    if (arr.length !== 1)
+      throw new Error("Children.only expected one child");
+    return arr[0];
+  },
+  toArray: toFlatArray
+};
+var Component = class {
+  props;
+  state;
+  context;
+  constructor(props) {
+    this.props = props;
+    this.state = {};
+  }
+  setState(_partial) {
+  }
+  forceUpdate() {
+  }
+  render() {
+    return null;
+  }
+};
+var PureComponent = class extends Component {
+};
+var React = {
+  // Hooks
+  useState,
+  useReducer,
+  useEffect,
+  useLayoutEffect,
+  useInsertionEffect,
+  useRef,
+  useMemo,
+  useCallback,
+  useId,
+  useDebugValue,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useTransition,
+  useDeferredValue,
+  useOptimistic,
+  useFormStatus,
+  useActionState,
+  use,
+  startTransition,
+  // Context
+  createContext,
+  useContext,
+  // Elements
+  createElement,
+  cloneElement,
+  isValidElement,
+  forwardRef,
+  memo,
+  lazy,
+  Fragment,
+  Suspense,
+  // Compat
+  Children,
+  Component,
+  PureComponent,
+  // Rendering
+  renderToStream,
+  renderToString,
+  renderToReadableStream: renderToStream,
+  // Version stub
+  version: "19.0.0-slim"
+};
+var slim_react_default = React;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Children,
+  Component,
+  FRAGMENT_TYPE,
+  Fragment,
+  PureComponent,
+  SLIM_ELEMENT,
+  SUSPENSE_TYPE,
+  Suspense,
+  cloneElement,
+  createContext,
+  createElement,
+  forwardRef,
+  isValidElement,
+  jsx,
+  jsxDEV,
+  jsxs,
+  lazy,
+  memo,
+  renderToReadableStream,
+  renderToStream,
+  renderToString,
+  startTransition,
+  use,
+  useActionState,
+  useCallback,
+  useContext,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useFormStatus,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useOptimistic,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition
+});