@tanstack/redact 0.0.1

package/dist/dom/reconcile.js

@@ -0,0 +1,795 @@
+// packages/redact/src/dom/reconcile.ts
+import {
+  FiberTag,
+  createFiber,
+  REACT_ELEMENT_TYPE,
+  REACT_LEGACY_ELEMENT_TYPE,
+  REACT_FRAGMENT_TYPE
+} from "../core";
+import {
+  ReactSharedInternals,
+  REACT_LAZY_TYPE,
+  REACT_STRICT_MODE_TYPE,
+  REACT_PROFILER_TYPE
+} from "../react";
+import { createHostNode, setProp } from "./dom";
+import { makeDispatcher } from "./dispatcher";
+import {
+  adoptHostDom,
+  adoptTextDom,
+  setHydrationCursor,
+  getHydrationCursor,
+  clearHydrationCursor,
+  findHostParent as findHydrationHost
+} from "./features/hydration";
+var currentRoot = null;
+var flushing = false;
+var isBatching = false;
+var pendingRoots = /* @__PURE__ */ new Set();
+var forceRerenderingFiber = null;
+function scheduleUpdate(fiber) {
+  if (fiber.unmounted) return;
+  const root = findRoot(fiber);
+  if (!root) return;
+  root.pending.add(fiber);
+  fiber.dirty = true;
+  pendingRoots.add(root);
+  if (isBatching) return;
+  if (!root.scheduled) {
+    root.scheduled = true;
+    queueMicrotask(flushPending);
+  }
+}
+function flushSyncWork(fn) {
+  const wasBatching = isBatching;
+  isBatching = true;
+  try {
+    fn();
+  } finally {
+    isBatching = wasBatching;
+  }
+  flushPending();
+}
+function batchedUpdates(fn) {
+  const wasBatching = isBatching;
+  isBatching = true;
+  try {
+    return fn();
+  } finally {
+    isBatching = wasBatching;
+    if (!wasBatching) flushPending();
+  }
+}
+function flushPending() {
+  if (flushing) return;
+  flushing = true;
+  try {
+    let guard = 0;
+    while (pendingRoots.size > 0) {
+      if (++guard > 50) {
+        throw new Error("flushPending exceeded 50 iterations \u2014 suspected infinite update loop.");
+      }
+      const roots = [...pendingRoots];
+      pendingRoots.clear();
+      for (const root of roots) {
+        root.scheduled = false;
+        const pending = [...root.pending];
+        root.pending.clear();
+        pending.sort((a, b) => fiberDepth(a) - fiberDepth(b));
+        for (const fiber of pending) {
+          rerenderFiber(fiber, root);
+        }
+        runEffects(root);
+      }
+    }
+  } finally {
+    flushing = false;
+  }
+}
+function fiberDepth(fiber) {
+  let d = 0;
+  let p = fiber.parent;
+  while (p) {
+    d++;
+    p = p.parent;
+  }
+  return d;
+}
+function findRoot(fiber) {
+  let f = fiber;
+  while (f) {
+    if (f.root) return f.root;
+    f = f.parent;
+  }
+  return null;
+}
+function renderRoot(root, children) {
+  const rootFiber = root.current;
+  rootFiber.pendingProps = { children };
+  currentRoot = root;
+  try {
+    reconcileChildren(rootFiber, childrenToArray(children), root.container, null);
+    rootFiber.memoizedProps = rootFiber.pendingProps;
+    rootFiber.dirty = false;
+  } finally {
+    currentRoot = null;
+  }
+  runEffects(root);
+}
+function rerenderFiber(fiber, root) {
+  if (!fiber.dirty) return;
+  if (fiber.unmounted) return;
+  fiber.dirty = false;
+  currentRoot = root;
+  const resumeHydration = fiber.memoizedState && fiber.memoizedState._pendingHydration === true;
+  const prevHydrating = root.hydrating;
+  if (resumeHydration) {
+    delete fiber.memoizedState._pendingHydration;
+    root.hydrating = true;
+  }
+  const prevForcing = forceRerenderingFiber;
+  forceRerenderingFiber = fiber;
+  try {
+    renderFiber(fiber, getHostParent(fiber), getAnchor(fiber));
+  } finally {
+    forceRerenderingFiber = prevForcing;
+    if (resumeHydration) {
+      root.hydrating = prevHydrating;
+      clearHydrationCursor(fiber);
+    }
+    currentRoot = null;
+  }
+}
+function isTextChild(child) {
+  return child.$$typeof === void 0;
+}
+function childrenToArray(children) {
+  const out = [];
+  pushChildren(children, out);
+  return out;
+}
+function pushChildren(node, out) {
+  if (node == null || typeof node === "boolean") return;
+  if (typeof node === "string" || typeof node === "number") {
+    if (node === "") return;
+    out.push({ _text: "" + node });
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) pushChildren(node[i], out);
+    return;
+  }
+  if (isIterable(node)) {
+    for (const item of node) pushChildren(item, out);
+    return;
+  }
+  if (typeof node === "object") {
+    const t = node.$$typeof;
+    if (ACCEPTED_ELEMENT_MARKERS.has(t)) {
+      out.push(node);
+      return;
+    }
+    if (t === REACT_LAZY_TYPE) {
+      const lazy = node;
+      const resolved = lazy._init(lazy._payload);
+      pushChildren(resolved, out);
+      return;
+    }
+  }
+}
+function isIterable(obj) {
+  return obj != null && typeof obj !== "string" && typeof obj[Symbol.iterator] === "function";
+}
+function sameType(fiber, child) {
+  if (!child) return false;
+  if (isTextChild(child)) return fiber.tag === FiberTag.Text;
+  return fiber.type === child.type && sameKey(fiber.key, child.key);
+}
+function sameKey(a, b) {
+  return (a ?? null) === (b ?? null);
+}
+function fiberFromChild(child, parent) {
+  if (!child) return createFiber(FiberTag.Fragment, null, null);
+  if (isTextChild(child)) {
+    const f2 = createFiber(FiberTag.Text, null, null);
+    f2.pendingProps = child._text;
+    f2.parent = parent;
+    return f2;
+  }
+  const type = child.type;
+  let tag = FiberTag.Host;
+  const marker = type && type.$$typeof;
+  if (typeof type === "string") tag = FiberTag.Host;
+  else if (type === REACT_FRAGMENT_TYPE) tag = FiberTag.Fragment;
+  else if (type === REACT_STRICT_MODE_TYPE || type === REACT_PROFILER_TYPE) tag = FiberTag.Fragment;
+  else {
+    let matched = null;
+    for (const m of TYPE_MATCHERS) {
+      matched = m(type, marker);
+      if (matched !== null) break;
+    }
+    if (matched !== null) tag = matched;
+    else if (typeof type === "function") {
+      tag = type.prototype && type.prototype.isReactComponent ? FiberTag.Class : FiberTag.Function;
+    }
+  }
+  const f = createFiber(tag, type, child.key ?? null);
+  f.ref = child.ref ?? null;
+  f.pendingProps = child.props;
+  f.parent = parent;
+  return f;
+}
+function reconcileChildren(parent, newChildren, domParent, anchor) {
+  const existing = collectChildren(parent);
+  const keyed = /* @__PURE__ */ new Map();
+  for (const f of existing) {
+    if (f.key != null) keyed.set("k" + f.key, f);
+  }
+  let prevNewFiber = null;
+  const claimed = /* @__PURE__ */ new Set();
+  let structurallyChanged = false;
+  let existingIdx = 0;
+  let unkeyedOld = 0;
+  for (const f of existing) if (f.key == null) unkeyedOld++;
+  let unkeyedNew = 0;
+  for (const c of newChildren) if (c != null) unkeyedNew++;
+  let budget = unkeyedNew - unkeyedOld;
+  for (let i = 0; i < newChildren.length; i++) {
+    const child = newChildren[i];
+    if (child == null) continue;
+    let match = null;
+    if (child && typeof child === "object" && !isTextChild(child) && child.key != null) {
+      const k = "k" + child.key;
+      const m = keyed.get(k);
+      if (m && m.type === child.type) {
+        match = m;
+        keyed.delete(k);
+      }
+    }
+    if (!match) {
+      while (existingIdx < existing.length) {
+        const cand = existing[existingIdx];
+        if (claimed.has(cand) || cand.key != null) {
+          existingIdx++;
+          continue;
+        }
+        if (sameType(cand, child)) {
+          match = cand;
+          existingIdx++;
+          break;
+        }
+        if (budget > 0) {
+          break;
+        }
+        existingIdx++;
+        budget++;
+      }
+    }
+    if (match && existing[i] !== match) structurallyChanged = true;
+    let fiber;
+    if (match) {
+      claimed.add(match);
+      fiber = match;
+      if (isTextChild(child)) {
+        fiber.pendingProps = child._text;
+      } else {
+        fiber.type = child.type;
+        fiber.pendingProps = child.props;
+        fiber.ref = child.ref ?? null;
+      }
+    } else {
+      fiber = fiberFromChild(child, parent);
+      structurallyChanged = true;
+      if (budget > 0) budget--;
+    }
+    fiber.parent = parent;
+    fiber.sibling = null;
+    if (prevNewFiber) prevNewFiber.sibling = fiber;
+    else parent.child = fiber;
+    prevNewFiber = fiber;
+    renderFiber(fiber, domParent, anchor);
+  }
+  if (!prevNewFiber) parent.child = null;
+  else prevNewFiber.sibling = null;
+  const parentIsHeadHost = parent.tag === FiberTag.Host && typeof parent.type === "string" && parent.type.toLowerCase() === "head";
+  if (!parentIsHeadHost) {
+    for (const f of existing) {
+      if (!claimed.has(f)) {
+        unmountFiber(f, domParent);
+        structurallyChanged = true;
+      }
+    }
+    for (const f of keyed.values()) {
+      if (!claimed.has(f)) {
+        unmountFiber(f, domParent);
+        structurallyChanged = true;
+      }
+    }
+  }
+  const parentIsHead = domParent.nodeType === 1 && domParent.tagName.toLowerCase() === "head";
+  if (structurallyChanged && !currentRoot?.hydrating && !parentIsHead) {
+    placeChildrenInOrder(parent, domParent, anchor);
+  }
+}
+function placeChildrenInOrder(parent, domParent, anchor) {
+  const doms = [];
+  let c = parent.child;
+  while (c) {
+    collectHostDoms(c, doms);
+    c = c.sibling;
+  }
+  if (doms.length > 0) {
+    let current = doms[0];
+    let inOrder = current.parentNode === domParent;
+    for (let i = 1; inOrder && i < doms.length; i++) {
+      current = current.nextSibling;
+      while (current && !doms.includes(current)) {
+        current = current.nextSibling;
+      }
+      if (current !== doms[i]) inOrder = false;
+    }
+    if (inOrder) return;
+  }
+  for (let i = doms.length - 1; i >= 0; i--) {
+    const d = doms[i];
+    const targetNext = i + 1 < doms.length ? doms[i + 1] : anchor;
+    if (d.parentNode !== domParent || d.nextSibling !== targetNext) {
+      domParent.insertBefore(d, targetNext);
+    }
+  }
+}
+function collectHostDoms(fiber, out) {
+  if (fiber.tag === FiberTag.Host || fiber.tag === FiberTag.Text) {
+    if (fiber.dom) out.push(fiber.dom);
+    return;
+  }
+  if (fiber.tag === FiberTag.Portal) return;
+  let c = fiber.child;
+  while (c) {
+    collectHostDoms(c, out);
+    c = c.sibling;
+  }
+}
+function collectChildren(parent) {
+  const out = [];
+  let c = parent.child;
+  while (c) {
+    out.push(c);
+    c = c.sibling;
+  }
+  return out;
+}
+var RENDERERS = new Array(13);
+var ACCEPTED_ELEMENT_MARKERS = /* @__PURE__ */ new Set([
+  REACT_ELEMENT_TYPE,
+  REACT_LEGACY_ELEMENT_TYPE
+]);
+var TYPE_MATCHERS = [];
+function registerRenderer(tag, fn) {
+  RENDERERS[tag] = fn;
+}
+function registerTypeMatcher(m) {
+  TYPE_MATCHERS.push(m);
+}
+function registerElementMarker(sym) {
+  ACCEPTED_ELEMENT_MARKERS.add(sym);
+}
+function getCurrentRoot() {
+  return currentRoot;
+}
+function withCurrentRoot(root, fn) {
+  const prev = currentRoot;
+  currentRoot = root;
+  try {
+    return fn();
+  } finally {
+    currentRoot = prev;
+  }
+}
+function getForceRerenderingFiber() {
+  return forceRerenderingFiber;
+}
+registerRenderer(FiberTag.Text, renderText);
+registerRenderer(FiberTag.Host, renderHost);
+registerRenderer(FiberTag.Function, renderFunction);
+registerRenderer(FiberTag.Fragment, renderFragment);
+function renderFiber(fiber, domParent, anchor) {
+  const fn = RENDERERS[fiber.tag];
+  if (fn) fn(fiber, domParent, anchor);
+}
+function renderText(fiber, domParent, anchor) {
+  const text = fiber.pendingProps;
+  if (!fiber.dom) {
+    const hydrated = currentRoot?.hydrating ? adoptTextDom(fiber, fiber.parent, text) : false;
+    if (!hydrated) {
+      fiber.dom = document.createTextNode(text);
+      insertInto(domParent, fiber.dom, anchor);
+    }
+  } else if (fiber.dom.data !== text) {
+    ;
+    fiber.dom.data = text;
+  }
+  fiber.memoizedProps = text;
+}
+function renderHost(fiber, domParent, anchor) {
+  const props = fiber.pendingProps ?? {};
+  const prev = fiber.memoizedProps ?? {};
+  const type = fiber.type;
+  const isSvg = type === "svg" || domParent.namespaceURI === "http://www.w3.org/2000/svg";
+  const isSelect = type === "select";
+  const deferredSelectValue = isSelect && (props.value !== void 0 || props.defaultValue !== void 0) ? props.value !== void 0 ? props.value : props.defaultValue : void 0;
+  if (!fiber.dom) {
+    const hydrated = currentRoot?.hydrating ? adoptHostDom(fiber, fiber.parent) : false;
+    if (!hydrated) {
+      fiber.dom = createHostNode(type, isSvg);
+      for (const k in props) {
+        if (isSelect && (k === "value" || k === "defaultValue")) continue;
+        if (isEventProp(k)) continue;
+        setProp(fiber.dom, k, props[k], void 0, isSvg);
+      }
+      for (const k in props) {
+        if (!isEventProp(k)) continue;
+        setProp(fiber.dom, k, props[k], void 0, isSvg);
+      }
+      insertInto(domParent, fiber.dom, anchor);
+    }
+    attachRef(fiber, fiber.dom);
+  } else {
+    const el = fiber.dom;
+    for (const k in prev) {
+      if (!(k in props)) setProp(el, k, void 0, prev[k], isSvg);
+    }
+    for (const k in props) {
+      if (isSelect && (k === "value" || k === "defaultValue")) continue;
+      if (isEventProp(k)) continue;
+      if (prev[k] !== props[k]) setProp(el, k, props[k], prev[k], isSvg);
+    }
+    for (const k in props) {
+      if (!isEventProp(k)) continue;
+      if (prev[k] !== props[k]) setProp(el, k, props[k], prev[k], isSvg);
+    }
+    if (prev !== props) syncRefIfChanged(fiber, fiber.dom);
+  }
+  reconcileChildren(fiber, childrenToArray(props.children), fiber.dom, null);
+  if (currentRoot?.hydrating) {
+    const parentTag = fiber.type.toLowerCase();
+    if (parentTag !== "head" && parentTag !== "html") {
+      const cursor = getHydrationCursor(fiber);
+      if (cursor) {
+        const leftover = cursor.remaining().filter(
+          (n) => n.nodeType === 1 || n.nodeType === 3
+        );
+        if (leftover.length > 0 && currentRoot.onRecoverableError) {
+          currentRoot.onRecoverableError(
+            new Error(
+              `Hydration mismatch: server rendered ${leftover.length} extra ${leftover.length === 1 ? "node" : "nodes"} inside <${parentTag}> that the client tree did not.`
+            )
+          );
+          for (const n of leftover) n.parentNode?.removeChild(n);
+        }
+      }
+    }
+  }
+  if (isSelect && deferredSelectValue !== void 0) {
+    const select = fiber.dom;
+    if (Array.isArray(deferredSelectValue)) {
+      const asStrings = deferredSelectValue.map((v) => "" + v);
+      for (const opt of Array.from(select.options)) {
+        opt.selected = asStrings.includes(opt.value);
+      }
+    } else {
+      select.value = "" + deferredSelectValue;
+    }
+  }
+  fiber.memoizedProps = props;
+}
+function renderFunction(fiber, domParent, anchor) {
+  const prevDispatcher = ReactSharedInternals.H;
+  const prevFiber = ReactSharedInternals.currentFiber;
+  const prevHook = ReactSharedInternals.currentHook;
+  const prevIndex = ReactSharedInternals.hookIndex;
+  ReactSharedInternals.H = makeDispatcher();
+  ReactSharedInternals.currentFiber = fiber;
+  ReactSharedInternals.currentHook = null;
+  ReactSharedInternals.hookIndex = 0;
+  let rendered;
+  let deferredForHydration = false;
+  try {
+    rendered = fiber.type(fiber.pendingProps ?? {});
+  } catch (e) {
+    if (isThenable(e)) {
+      if (currentRoot?.hydrating) {
+        const hostParent = findHydrationHost(fiber);
+        const inheritedCursor = getHydrationCursor(hostParent);
+        if (inheritedCursor) {
+          setHydrationCursor(fiber, inheritedCursor);
+        }
+        fiber.memoizedState = {
+          ...fiber.memoizedState ?? {},
+          _pendingHydration: true
+        };
+        let sus = fiber.parent;
+        while (sus && sus.tag !== FiberTag.Suspense) sus = sus.parent;
+        if (sus && sus.memoizedState) {
+          ;
+          sus.memoizedState._awaitingLazyHydration = true;
+        }
+        const clearAwait = () => {
+          if (sus && sus.memoizedState) {
+            ;
+            sus.memoizedState._awaitingLazyHydration = false;
+          }
+          scheduleUpdate(fiber);
+        };
+        e.then(clearAwait, clearAwait);
+        deferredForHydration = true;
+      } else {
+        CAPABILITIES.handleSuspended(fiber, e);
+        rendered = null;
+      }
+    } else {
+      handleErrorInRender(fiber, e);
+      return;
+    }
+  } finally {
+    ReactSharedInternals.H = prevDispatcher;
+    ReactSharedInternals.currentFiber = prevFiber;
+    ReactSharedInternals.currentHook = prevHook;
+    ReactSharedInternals.hookIndex = prevIndex;
+  }
+  if (deferredForHydration) return;
+  reconcileChildren(fiber, childrenToArray(rendered), domParent, anchor);
+  fiber.memoizedProps = fiber.pendingProps;
+}
+function renderFragment(fiber, domParent, anchor) {
+  const props = fiber.pendingProps ?? {};
+  reconcileChildren(fiber, childrenToArray(props.children), domParent, anchor);
+  fiber.memoizedProps = props;
+}
+function defaultHandleSuspended(fiber, thenable) {
+  thenable.then(
+    () => scheduleUpdate(fiber),
+    () => scheduleUpdate(fiber)
+  );
+}
+var CAPABILITIES = {
+  handleSuspended: defaultHandleSuspended,
+  readContext: defaultReadContext
+};
+function installCapability(name, fn) {
+  CAPABILITIES[name] = fn;
+}
+function handleSuspended(fiber, thenable) {
+  CAPABILITIES.handleSuspended(fiber, thenable);
+}
+function handleErrorInRender(fiber, err) {
+  let f = fiber.parent;
+  while (f) {
+    if (f.tag === FiberTag.Class) {
+      const Ctor = f.type;
+      const instance = f.stateNode;
+      if (Ctor.getDerivedStateFromError) {
+        const update = Ctor.getDerivedStateFromError(err);
+        instance.state = { ...instance.state, ...update };
+      }
+      if (instance.componentDidCatch) {
+        try {
+          instance.componentDidCatch(err, { componentStack: "" });
+        } catch {
+        }
+      }
+      scheduleUpdate(f);
+      return;
+    }
+    f = f.parent;
+  }
+  if (currentRoot?.onUncaughtError) currentRoot.onUncaughtError(err);
+  else throw err;
+}
+function isThenable(x) {
+  return x != null && typeof x.then === "function";
+}
+function unmountFiber(fiber, domParent) {
+  fiber.unmounted = true;
+  let c = fiber.child;
+  while (c) {
+    const next = c.sibling;
+    unmountFiber(c, fiber.tag === FiberTag.Host ? fiber.dom : domParent);
+    c = next;
+  }
+  fiber.child = null;
+  if (fiber.cleanups) {
+    for (const cleanup of fiber.cleanups) {
+      try {
+        cleanup();
+      } catch (e) {
+        if (currentRoot?.onRecoverableError) currentRoot.onRecoverableError(e);
+      }
+    }
+    fiber.cleanups = null;
+  }
+  if (fiber.tag === FiberTag.Class && fiber.stateNode?.componentWillUnmount) {
+    try {
+      fiber.stateNode.componentWillUnmount();
+    } catch (e) {
+      if (currentRoot?.onRecoverableError) currentRoot.onRecoverableError(e);
+    }
+    fiber.stateNode._fiber = null;
+    fiber.stateNode._enqueueUpdate = null;
+    fiber.stateNode._forceUpdate = null;
+  }
+  if (fiber.ref) detachRef(fiber.ref);
+  if (fiber.tag === FiberTag.Host && fiber.dom && fiber.dom.parentNode) {
+    fiber.dom.parentNode.removeChild(fiber.dom);
+  } else if (fiber.tag === FiberTag.Text && fiber.dom && fiber.dom.parentNode) {
+    fiber.dom.parentNode.removeChild(fiber.dom);
+  }
+}
+function unmountAllChildren(parent, domParent) {
+  let c = parent.child;
+  while (c) {
+    const next = c.sibling;
+    unmountFiber(c, domParent);
+    c = next;
+  }
+  parent.child = null;
+}
+function insertInto(parent, node, anchor) {
+  if (anchor && anchor.parentNode === parent) {
+    parent.insertBefore(node, anchor);
+  } else {
+    parent.appendChild(node);
+  }
+}
+function getHostParent(fiber) {
+  let p = fiber.parent;
+  while (p) {
+    if (p.tag === FiberTag.Host) return p.dom;
+    if (p.tag === FiberTag.Root)
+      return p.stateNode || p.dom || p.root?.container;
+    if (p.tag === FiberTag.Portal) {
+      const props = p.pendingProps ?? p.memoizedProps;
+      return props?.container || p.stateNode || p.dom || p.root?.container;
+    }
+    p = p.parent;
+  }
+  throw new Error("No host parent found.");
+}
+function getAnchor(fiber) {
+  let f = fiber.sibling;
+  while (f) {
+    const d = firstDomNode(f);
+    if (d) return d;
+    f = f.sibling;
+  }
+  let p = fiber.parent;
+  while (p && p.tag !== FiberTag.Host && p.tag !== FiberTag.Root && p.tag !== FiberTag.Portal) {
+    if (p.sibling) {
+      const d = firstDomNode(p.sibling);
+      if (d) return d;
+    }
+    p = p.parent;
+  }
+  return null;
+}
+function firstDomNode(fiber) {
+  if (fiber.tag === FiberTag.Host || fiber.tag === FiberTag.Text) return fiber.dom;
+  let c = fiber.child;
+  while (c) {
+    const d = firstDomNode(c);
+    if (d) return d;
+    c = c.sibling;
+  }
+  return null;
+}
+function readContext(fiber, ctx) {
+  return CAPABILITIES.readContext(fiber, ctx);
+}
+function defaultReadContext(_fiber, ctx) {
+  return ctx._currentValue;
+}
+function attachRef(fiber, value) {
+  const ref = fiber.ref ?? (fiber.pendingProps?.ref ?? null);
+  if (!ref) return;
+  if (typeof ref === "function") {
+    const cleanup = ref(value);
+    if (typeof cleanup === "function") {
+      fiber.cleanups ||= [];
+      fiber.cleanups.push(cleanup);
+    } else {
+      fiber.cleanups ||= [];
+      fiber.cleanups.push(() => ref(null));
+    }
+  } else {
+    ref.current = value;
+  }
+}
+function syncRefIfChanged(fiber, value) {
+  const ref = fiber.ref ?? (fiber.pendingProps?.ref ?? null);
+  if (!ref) return;
+  if (typeof ref === "object" && ref.current !== value) ref.current = value;
+}
+function detachRef(ref) {
+  if (typeof ref === "function") {
+    try {
+      ref(null);
+    } catch {
+    }
+  } else if (ref && typeof ref === "object") {
+    ref.current = null;
+  }
+}
+var pendingEffects = [];
+var pendingLayoutEffects = [];
+var pendingLifecycles = [];
+function enqueueEffect(fiber, effect) {
+  if (effect.tag === "layout" || effect.tag === "insertion") {
+    pendingLayoutEffects.push({ fiber, effect });
+  } else {
+    pendingEffects.push({ fiber, effect });
+  }
+}
+function scheduleLifecycle(fiber, fn) {
+  pendingLifecycles.push({ fiber, fn });
+}
+function runEffects(root) {
+  while (pendingLayoutEffects.length) {
+    const { fiber, effect } = pendingLayoutEffects.shift();
+    runEffect(fiber, effect, root);
+  }
+  while (pendingLifecycles.length) {
+    const { fn } = pendingLifecycles.shift();
+    try {
+      fn();
+    } catch (e) {
+      if (root.onCaughtError) root.onCaughtError(e);
+    }
+  }
+  if (pendingEffects.length) {
+    const batch = pendingEffects.splice(0);
+    queueMicrotask(() => {
+      for (const { fiber, effect } of batch) runEffect(fiber, effect, root);
+    });
+  }
+}
+function runEffect(fiber, effect, root) {
+  try {
+    const cleanup = effect.create();
+    effect.destroy = typeof cleanup === "function" ? cleanup : void 0;
+    if (effect.destroy) {
+      fiber.cleanups ||= [];
+      fiber.cleanups.push(effect.destroy);
+    }
+  } catch (e) {
+    if (root.onCaughtError) root.onCaughtError(e);
+  }
+}
+function isEventProp(name) {
+  return name.length > 2 && name.charCodeAt(0) === 111 && name.charCodeAt(1) === 110 && name.charCodeAt(2) >= 65;
+}
+export {
+  batchedUpdates,
+  childrenToArray,
+  enqueueEffect,
+  findRoot,
+  flushSyncWork,
+  getCurrentRoot,
+  getForceRerenderingFiber,
+  handleErrorInRender,
+  handleSuspended,
+  installCapability,
+  isThenable,
+  readContext,
+  reconcileChildren,
+  registerElementMarker,
+  registerRenderer,
+  registerTypeMatcher,
+  renderFiber,
+  renderRoot,
+  runEffects,
+  scheduleLifecycle,
+  scheduleUpdate,
+  unmountAllChildren,
+  withCurrentRoot
+};
+//# sourceMappingURL=reconcile.js.map