@rectify-dev/core 2.0.0

package/dist/index.cjs

@@ -0,0 +1,1444 @@
+'use strict';
+
+var chunkS5YX7TXF_cjs = require('./chunk-S5YX7TXF.cjs');
+
+// ../rectify-dom-binding/src/events/RectifyEventRegistry.ts
+var allNativeEvents = /* @__PURE__ */ new Set();
+var nativeEventToRectifyName = /* @__PURE__ */ new Map();
+function registerDirectEvent(registrationName, dependencies) {
+  for (let i = 0; i < dependencies.length; i++) {
+    const dependency = dependencies[i];
+    allNativeEvents.add(dependency);
+    if (!nativeEventToRectifyName.has(dependency)) {
+      nativeEventToRectifyName.set(dependency, registrationName);
+    }
+  }
+}
+chunkS5YX7TXF_cjs.__name(registerDirectEvent, "registerDirectEvent");
+function registerNativeEvent() {
+  registerDirectEvent("onClick", ["click"]);
+  registerDirectEvent("onDoubleClick", ["dblclick"]);
+  registerDirectEvent("onMouseDown", ["mousedown"]);
+  registerDirectEvent("onMouseUp", ["mouseup"]);
+  registerDirectEvent("onMouseMove", ["mousemove"]);
+  registerDirectEvent("onMouseEnter", ["mouseenter"]);
+  registerDirectEvent("onMouseLeave", ["mouseleave"]);
+  registerDirectEvent("onContextMenu", ["contextmenu"]);
+  registerDirectEvent("onKeyDown", ["keydown"]);
+  registerDirectEvent("onKeyUp", ["keyup"]);
+  registerDirectEvent("onKeyPress", ["keypress"]);
+  registerDirectEvent("onInput", ["input"]);
+  registerDirectEvent("onChange", ["change"]);
+  registerDirectEvent("onSubmit", ["submit"]);
+  registerDirectEvent("onReset", ["reset"]);
+  registerDirectEvent("onFocus", ["focus"]);
+  registerDirectEvent("onBlur", ["blur"]);
+  registerDirectEvent("onCopy", ["copy"]);
+  registerDirectEvent("onCut", ["cut"]);
+  registerDirectEvent("onPaste", ["paste"]);
+  registerDirectEvent("onTouchStart", ["touchstart"]);
+  registerDirectEvent("onTouchMove", ["touchmove"]);
+  registerDirectEvent("onTouchEnd", ["touchend"]);
+  registerDirectEvent("onTouchCancel", ["touchcancel"]);
+  registerDirectEvent("onScroll", ["scroll"]);
+  registerDirectEvent("onWheel", ["wheel"]);
+  registerDirectEvent("onDrag", ["drag"]);
+  registerDirectEvent("onDragStart", ["dragstart"]);
+  registerDirectEvent("onDragEnd", ["dragend"]);
+  registerDirectEvent("onDragEnter", ["dragenter"]);
+  registerDirectEvent("onDragLeave", ["dragleave"]);
+  registerDirectEvent("onDragOver", ["dragover"]);
+  registerDirectEvent("onDrop", ["drop"]);
+}
+chunkS5YX7TXF_cjs.__name(registerNativeEvent, "registerNativeEvent");
+
+// ../rectify-dom-binding/src/events/__main.ts
+var main = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  registerNativeEvent();
+}, "main");
+main();
+
+// ../rectify-dom-binding/src/clients/RectifyDomComponentTree.ts
+var randomKey = Math.random().toString(36).slice(2);
+var internalContainerInstanceKey = "__rectifyContainer$" + randomKey;
+var internalInstanceKey = "__rectifyFiber$" + randomKey;
+var internalEventHandlerListenersKey = "__rectifyListeners$" + randomKey;
+function markContainerAsRoot(hostRoot, node) {
+  node[internalContainerInstanceKey] = hostRoot;
+}
+chunkS5YX7TXF_cjs.__name(markContainerAsRoot, "markContainerAsRoot");
+function unmarkContainerAsRoot(node) {
+  node[internalContainerInstanceKey] = null;
+}
+chunkS5YX7TXF_cjs.__name(unmarkContainerAsRoot, "unmarkContainerAsRoot");
+var precacheFiberNode = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber, node) => {
+  if (!node) return;
+  node[internalInstanceKey] = fiber;
+}, "precacheFiberNode");
+var getFiberNodeCached = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((node) => {
+  if (!node) return null;
+  return node[internalInstanceKey] || null;
+}, "getFiberNodeCached");
+function setEventHandlerListeners(scope, listeners) {
+  if (!scope) return;
+  scope[internalEventHandlerListenersKey] = listeners;
+}
+chunkS5YX7TXF_cjs.__name(setEventHandlerListeners, "setEventHandlerListeners");
+function getEventHandlerListeners(scope) {
+  if (!scope) return null;
+  return scope[internalEventHandlerListenersKey] || null;
+}
+chunkS5YX7TXF_cjs.__name(getEventHandlerListeners, "getEventHandlerListeners");
+
+// ../rectify-dom-binding/src/events/SyntheticEvent.ts
+var _SyntheticEvent = class _SyntheticEvent {
+  constructor(nativeEvent) {
+    this.currentTarget = null;
+    this.propagationStopped = false;
+    this.target = nativeEvent.target;
+    this.nativeEvent = nativeEvent;
+  }
+  stopPropagation() {
+    this.propagationStopped = true;
+    this.nativeEvent.stopPropagation();
+  }
+  isPropagationStopped() {
+    return this.propagationStopped;
+  }
+};
+chunkS5YX7TXF_cjs.__name(_SyntheticEvent, "SyntheticEvent");
+var SyntheticEvent = _SyntheticEvent;
+var SyntheticEvent_default = SyntheticEvent;
+
+// ../rectify-dom-binding/src/events/RectifyEventPriority.ts
+var _set = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+}, "_set");
+var _reset = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+}, "_reset");
+var injectEventPriorityCallbacks = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((set, reset) => {
+  _set = set;
+  _reset = reset;
+}, "injectEventPriorityCallbacks");
+var setEventPriority = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((priority) => _set(priority), "setEventPriority");
+var resetEventPriority = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => _reset(), "resetEventPriority");
+var INPUT_LANE = 2;
+
+// ../rectify-dom-binding/src/events/RectifyDomEventListener.ts
+var createEventListenerWrapper = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((targetContainer, domEventName) => {
+  return dispatchEvent.bind(null, domEventName, targetContainer);
+}, "createEventListenerWrapper");
+var getEventTarget = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((nativeEvent) => {
+  return nativeEvent.target || nativeEvent.srcElement;
+}, "getEventTarget");
+var dispatchEvent = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((domEventName, targetContainer, nativeEvent) => {
+  const targetNode = getEventTarget(nativeEvent);
+  const targetFiber = getFiberNodeCached(targetNode);
+  if (!targetFiber) return;
+  const syntheticEvent = new SyntheticEvent_default(nativeEvent);
+  const path = [];
+  let fiber = targetFiber;
+  while (fiber) {
+    path.push(fiber);
+    if (fiber.stateNode === targetContainer) {
+      break;
+    }
+    fiber = fiber.return;
+  }
+  for (const currFiber of path) {
+    if (syntheticEvent.isPropagationStopped()) break;
+    const eventHandlerMap = getEventHandlerListeners(
+      currFiber.stateNode
+    );
+    if (!eventHandlerMap) continue;
+    const rectifyName = nativeEventToRectifyName.get(domEventName);
+    if (!rectifyName) continue;
+    const handler = eventHandlerMap.get(rectifyName);
+    if (!chunkS5YX7TXF_cjs.isFunction(handler)) continue;
+    syntheticEvent.currentTarget = currFiber.stateNode;
+    setEventPriority(INPUT_LANE);
+    try {
+      handler(syntheticEvent);
+    } finally {
+      resetEventPriority();
+    }
+  }
+  syntheticEvent.currentTarget = null;
+}, "dispatchEvent");
+
+// ../rectify-dom-binding/src/events/RectifyEventListener.ts
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, true);
+  return listener;
+}
+chunkS5YX7TXF_cjs.__name(addEventCaptureListener, "addEventCaptureListener");
+
+// ../rectify-dom-binding/src/events/RectifyEvent.ts
+var listeningMarker = "_rectifyEventListening$" + Math.random().toString(36).slice(2);
+var listenToAllEventSupported = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((dom) => {
+  if (dom[listeningMarker]) return;
+  dom[listeningMarker] = true;
+  allNativeEvents.forEach(
+    (domEventName) => listenToNativeEvent(domEventName, dom)
+  );
+}, "listenToAllEventSupported");
+var listenToNativeEvent = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((domEventName, target) => {
+  const listener = createEventListenerWrapper(target, domEventName);
+  addEventCaptureListener(target, domEventName, listener);
+}, "listenToNativeEvent");
+
+// ../rectify-dom-binding/src/clients/RectifyDomProperties.ts
+var isEvent = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((k) => k.startsWith("on"), "isEvent");
+var isProperty = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((k) => k !== "children" && k !== "ref" && !isEvent(k), "isProperty");
+var unitlessProperties = /* @__PURE__ */ new Set([
+  "zIndex",
+  "opacity",
+  "fontWeight",
+  "lineHeight",
+  "flex",
+  "flexGrow",
+  "flexShrink"
+]);
+function convertStyleObjectToString(styleObj) {
+  return Object.entries(styleObj).map(([key, value]) => {
+    const cssKey = key.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+    let cssValue = value;
+    if (typeof value === "number" && !unitlessProperties.has(key)) {
+      cssValue = `${value}px`;
+    }
+    return `${cssKey}:${cssValue}`;
+  }).join("; ");
+}
+chunkS5YX7TXF_cjs.__name(convertStyleObjectToString, "convertStyleObjectToString");
+var applyPropsToDom = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((node, prevProps = {}, nextProps = {}) => {
+  const element = node;
+  const eventNode = getEventHandlerListeners(element) || /* @__PURE__ */ new Map();
+  for (const k in prevProps) {
+    if (isEvent(k) && !(k in nextProps)) {
+      eventNode.delete(k);
+    }
+    if (isProperty(k) && !(k in nextProps)) {
+      element[k] = "";
+      element.removeAttribute(k);
+    }
+  }
+  for (const k in nextProps) {
+    if (k === "children" || k === "ref") continue;
+    if (isEvent(k)) {
+      if (prevProps?.[k] !== nextProps?.[k]) {
+        eventNode.set(k, nextProps[k]);
+      }
+    } else if (k === "style") {
+      element.setAttribute("style", convertStyleObjectToString(nextProps[k]));
+    } else {
+      const v = nextProps[k];
+      if (k === "className") element.setAttribute("class", v ?? "");
+      else if (v === false || v === null || v === void 0)
+        element.removeAttribute(k);
+      else element.setAttribute(k, String(v));
+    }
+  }
+  setEventHandlerListeners(element, eventNode);
+}, "applyPropsToDom");
+
+// ../rectify-reconciler/src/RectifyFiberFlags.ts
+var NoFlags = 0;
+var PlacementFlag = 1 << 0;
+var UpdateFlag = 1 << 1;
+var DeletionFlag = 1 << 2;
+var MoveFlag = 1 << 3;
+
+// ../rectify-reconciler/src/RectifyFiberLanes.ts
+var NoLanes = 0;
+var SyncLane = 1;
+var InputLane = 2;
+var DefaultLane = 4;
+var TransitionLane = 8;
+var IdleLane = 16;
+
+// ../rectify-reconciler/src/RectifyFiberWorkTags.ts
+var FunctionComponent = /* @__PURE__ */ Symbol.for("rectify.function_component");
+var HostComponent = /* @__PURE__ */ Symbol.for("rectify.host_component");
+var HostText = /* @__PURE__ */ Symbol.for("rectify.host_text");
+var HostRoot = /* @__PURE__ */ Symbol.for("rectify.host_root");
+var FragmentComponent = /* @__PURE__ */ Symbol.for("rectify.fragment_component");
+var ContextProvider = /* @__PURE__ */ Symbol.for("rectify.context_provider");
+var MemoComponent = /* @__PURE__ */ Symbol.for("rectify.memo_component");
+
+// ../rectify-reconciler/src/RectifyFiberService.ts
+var addFlagToFiber = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber, flag) => {
+  if (hasFlagOnFiber(fiber, flag)) return;
+  fiber.flags |= flag;
+}, "addFlagToFiber");
+var removeFlagFromFiber = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber, flag) => {
+  if (!hasFlagOnFiber(fiber, flag)) return;
+  fiber.flags &= ~flag;
+}, "removeFlagFromFiber");
+var hasFlagOnFiber = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber, flag) => {
+  if (!fiber) return false;
+  return (fiber.flags & flag) !== 0;
+}, "hasFlagOnFiber");
+var getFiberTagFromElement = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((element) => {
+  switch (element.$$typeof) {
+    case chunkS5YX7TXF_cjs.RECTIFY_ELEMENT_TYPE:
+      if (chunkS5YX7TXF_cjs.isFunction(element.type) && element.type?._context === element.type) {
+        return ContextProvider;
+      }
+      if (chunkS5YX7TXF_cjs.isFunction(element.type) && element.type?._isMemo === true) {
+        return MemoComponent;
+      }
+      return chunkS5YX7TXF_cjs.isFunction(element.type) ? FunctionComponent : HostComponent;
+    case chunkS5YX7TXF_cjs.RECTIFY_TEXT_TYPE:
+      return HostText;
+    case chunkS5YX7TXF_cjs.RECTIFY_FRAGMENT_TYPE:
+      return FragmentComponent;
+    default:
+      return null;
+  }
+}, "getFiberTagFromElement");
+var createDomElementFromFiber = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  switch (fiber.workTag) {
+    case HostText:
+      return document.createTextNode(fiber.pendingProps);
+    default:
+      return document.createElement(fiber.type);
+  }
+}, "createDomElementFromFiber");
+var getParentDom = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  if (fiber.workTag === HostRoot)
+    return fiber.stateNode;
+  let p = fiber.return;
+  while (p) {
+    if (p.workTag === HostComponent) return p.stateNode;
+    if (p.workTag === HostRoot) return p.stateNode;
+    p = p.return;
+  }
+  throw new Error("No parent DOM found.");
+}, "getParentDom");
+function findFirstHostNode(fiber) {
+  if (fiber.workTag === HostComponent || fiber.workTag === HostText) {
+    return fiber.stateNode;
+  }
+  let child = fiber.child;
+  while (child) {
+    const found = findFirstHostNode(child);
+    if (found) return found;
+    child = child.sibling;
+  }
+  return null;
+}
+chunkS5YX7TXF_cjs.__name(findFirstHostNode, "findFirstHostNode");
+function getHostSibling(fiber) {
+  let sibling = fiber.sibling;
+  while (sibling) {
+    const node = findFirstHostNode(sibling);
+    if (node) return node;
+    sibling = sibling.sibling;
+  }
+  return null;
+}
+chunkS5YX7TXF_cjs.__name(getHostSibling, "getHostSibling");
+var hasPropsChanged = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((prevProps, nextProps) => {
+  const CHILDREN_KEY = "children";
+  const REF_KEY = "ref";
+  if (chunkS5YX7TXF_cjs.isPlainObject(prevProps) && chunkS5YX7TXF_cjs.isPlainObject(nextProps)) {
+    return !chunkS5YX7TXF_cjs.shallowEqual(
+      chunkS5YX7TXF_cjs.omit(prevProps, [CHILDREN_KEY, REF_KEY]),
+      chunkS5YX7TXF_cjs.omit(nextProps, [CHILDREN_KEY, REF_KEY])
+    );
+  }
+  return prevProps !== nextProps;
+}, "hasPropsChanged");
+
+// ../rectify-reconciler/src/RectifyFiber.ts
+var createFiber = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((workTag, pendingProps, key = null) => {
+  return {
+    index: 0,
+    key,
+    workTag,
+    type: null,
+    pendingProps,
+    memoizedProps: null,
+    child: null,
+    sibling: null,
+    return: null,
+    stateNode: null,
+    deletions: null,
+    alternate: null,
+    lanes: NoLanes,
+    childLanes: NoLanes,
+    subtreeFlags: NoFlags,
+    flags: NoFlags,
+    memoizedState: null
+  };
+}, "createFiber");
+var createHostRootFiber = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((containerDom) => {
+  const root = createFiber(HostRoot, null);
+  root.stateNode = containerDom;
+  return {
+    containerDom,
+    root,
+    pendingLanes: NoLanes,
+    children: null
+  };
+}, "createHostRootFiber");
+var createWorkInProgress = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((current, pendingProps) => {
+  let wip = current.alternate;
+  if (!wip) {
+    wip = createFiber(current.workTag, pendingProps, current.key);
+    wip.type = current.type;
+    wip.stateNode = current.stateNode;
+    wip.alternate = current;
+    current.alternate = wip;
+  } else {
+    wip.pendingProps = pendingProps;
+    wip.deletions = null;
+  }
+  wip.memoizedProps = current.memoizedProps;
+  wip.memoizedState = current.memoizedState;
+  wip.return = current.return;
+  wip.child = current.child;
+  wip.sibling = current.sibling;
+  wip.flags = NoFlags;
+  wip.subtreeFlags = NoFlags;
+  wip.lanes = current.lanes;
+  wip.childLanes = current.childLanes;
+  return wip;
+}, "createWorkInProgress");
+var createFiberFromRectifyElement = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((element) => {
+  const tag = getFiberTagFromElement(element) ?? HostComponent;
+  return createFiber(tag, element.props, element.key);
+}, "createFiberFromRectifyElement");
+
+// ../rectify-reconciler/src/RectifyFiberInstance.ts
+var instance = {
+  fiberRoot: null
+};
+var setScheduledFiberRoot = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiberRoot) => {
+  instance.fiberRoot = fiberRoot;
+}, "setScheduledFiberRoot");
+var getScheduledFiberRoot = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  return instance.fiberRoot;
+}, "getScheduledFiberRoot");
+
+// ../rectify-hook/src/RectifyHookRenderingFiber.ts
+var instance2 = {
+  fiberRendering: null,
+  hookIndex: 0,
+  scheduleRerender: null
+};
+var getFiberRendering = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => instance2.fiberRendering, "getFiberRendering");
+var setFiberRendering = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  instance2.fiberRendering = fiber;
+}, "setFiberRendering");
+var getHookIndex = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => instance2.hookIndex, "getHookIndex");
+var setHookIndex = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((index) => {
+  instance2.hookIndex = index;
+}, "setHookIndex");
+var nextHookIndex = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  instance2.hookIndex += 1;
+}, "nextHookIndex");
+var setScheduleRerender = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fn) => {
+  instance2.scheduleRerender = fn;
+}, "setScheduleRerender");
+var scheduleRerender = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  instance2.scheduleRerender?.(fiber);
+}, "scheduleRerender");
+var getHookSlot = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber, hookIndex) => {
+  let hook = fiber.memoizedState;
+  let prevHook = null;
+  for (let i = 0; i < hookIndex; i++) {
+    prevHook = hook;
+    hook = hook?.next ?? null;
+  }
+  return { hook, prevHook };
+}, "getHookSlot");
+var attachHook = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber, newHook, prevHook) => {
+  if (prevHook) prevHook.next = newHook;
+  else fiber.memoizedState = newHook;
+}, "attachHook");
+
+// ../rectify-hook/src/RectifyHook.ts
+var prepareToUseHooks = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => {
+  setFiberRendering(wip);
+  setHookIndex(0);
+}, "prepareToUseHooks");
+var finishUsingHooks = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  setFiberRendering(null);
+}, "finishUsingHooks");
+var withHooks = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip, Component) => {
+  const NewComponent = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((props) => {
+    prepareToUseHooks(wip);
+    const result = Component(props);
+    finishUsingHooks();
+    return result;
+  }, "NewComponent");
+  return NewComponent;
+}, "withHooks");
+
+// ../rectify-hook/src/RectifyHookUseState.ts
+var getInitialState = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((initialState) => chunkS5YX7TXF_cjs.isFunction(initialState) ? initialState() : initialState, "getInitialState");
+var getState = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((update, prevState) => chunkS5YX7TXF_cjs.isFunction(update) ? update(prevState) : update, "getState");
+function useState(initialState) {
+  const fiber = getFiberRendering();
+  if (!fiber) {
+    throw new Error("useState must be used within a function component.");
+  }
+  const hookIndex = getHookIndex();
+  nextHookIndex();
+  let state = fiber.memoizedState;
+  let prevHook = null;
+  for (let i = 0; i < hookIndex; i++) {
+    prevHook = state;
+    state = state?.next ?? null;
+  }
+  if (!state) {
+    state = {
+      memoizedState: getInitialState(initialState),
+      queue: null,
+      next: null
+    };
+    if (prevHook) {
+      prevHook.next = state;
+    } else {
+      fiber.memoizedState = state;
+    }
+  }
+  let update = state.queue;
+  while (update) {
+    state.memoizedState = getState(update.action, state.memoizedState);
+    update = update.next;
+  }
+  state.queue = null;
+  const dispatcher = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((updater) => {
+    const update2 = { action: updater, next: null };
+    if (!state.queue) {
+      state.queue = update2;
+    } else {
+      let last = state.queue;
+      while (last.next) {
+        last = last.next;
+      }
+      last.next = update2;
+    }
+    scheduleRerender(fiber);
+  }, "dispatcher");
+  return [state.memoizedState, dispatcher];
+}
+chunkS5YX7TXF_cjs.__name(useState, "useState");
+var RectifyHookUseState_default = useState;
+
+// ../rectify-hook/src/RectifyHookDeps.ts
+var depsChanged = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((prev, next) => {
+  if (!prev || !next) return true;
+  if (prev.length !== next.length) return true;
+  return next.some((dep, i) => !Object.is(dep, prev[i]));
+}, "depsChanged");
+
+// ../rectify-hook/src/RectifyHookUseEffect.ts
+var pendingEffects = [];
+var pendingCleanups = [];
+function useEffect(create, deps) {
+  const fiber = getFiberRendering();
+  if (!fiber) {
+    throw new Error("useEffect must be used within a function component.");
+  }
+  const hookIndex = getHookIndex();
+  nextHookIndex();
+  const { hook, prevHook } = getHookSlot(fiber, hookIndex);
+  if (!hook) {
+    const effectState = { create, deps, cleanup: void 0 };
+    const newHook = { memoizedState: effectState, queue: null, next: null };
+    attachHook(fiber, newHook, prevHook);
+    pendingEffects.push(effectState);
+  } else {
+    const prev = hook.memoizedState;
+    if (depsChanged(prev.deps, deps)) {
+      pendingCleanups.push(prev);
+      const effectState = { create, deps, cleanup: void 0 };
+      hook.memoizedState = effectState;
+      pendingEffects.push(effectState);
+    }
+  }
+}
+chunkS5YX7TXF_cjs.__name(useEffect, "useEffect");
+var flushEffectCleanups = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  for (const effect of pendingCleanups.splice(0)) {
+    effect.cleanup?.();
+  }
+}, "flushEffectCleanups");
+var flushEffects = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  for (const effect of pendingEffects.splice(0)) {
+    const cleanup = effect.create();
+    if (typeof cleanup === "function") {
+      effect.cleanup = cleanup;
+    }
+  }
+}, "flushEffects");
+var runEffectCleanups = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  let hook = fiber.memoizedState;
+  while (hook) {
+    const state = hook.memoizedState;
+    if (state !== null && typeof state.create === "function") {
+      state.cleanup?.();
+    }
+    hook = hook.next;
+  }
+}, "runEffectCleanups");
+var RectifyHookUseEffect_default = useEffect;
+
+// ../rectify-hook/src/RectifyHookUseLayoutEffect.ts
+var pendingLayoutEffects = [];
+var pendingLayoutCleanups = [];
+function useLayoutEffect(create, deps) {
+  const fiber = getFiberRendering();
+  if (!fiber) {
+    throw new Error("useLayoutEffect must be used within a function component.");
+  }
+  const hookIndex = getHookIndex();
+  nextHookIndex();
+  const { hook, prevHook } = getHookSlot(fiber, hookIndex);
+  if (!hook) {
+    const effectState = { create, deps, cleanup: void 0 };
+    const newHook = { memoizedState: effectState, queue: null, next: null };
+    attachHook(fiber, newHook, prevHook);
+    pendingLayoutEffects.push(effectState);
+  } else {
+    const prev = hook.memoizedState;
+    if (depsChanged(prev.deps, deps)) {
+      pendingLayoutCleanups.push(prev);
+      const effectState = { create, deps, cleanup: void 0 };
+      hook.memoizedState = effectState;
+      pendingLayoutEffects.push(effectState);
+    }
+  }
+}
+chunkS5YX7TXF_cjs.__name(useLayoutEffect, "useLayoutEffect");
+var flushLayoutEffectCleanups = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  for (const effect of pendingLayoutCleanups.splice(0)) {
+    effect.cleanup?.();
+  }
+}, "flushLayoutEffectCleanups");
+var flushLayoutEffects = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  for (const effect of pendingLayoutEffects.splice(0)) {
+    const cleanup = effect.create();
+    if (typeof cleanup === "function") {
+      effect.cleanup = cleanup;
+    }
+  }
+}, "flushLayoutEffects");
+var RectifyHookUseLayoutEffect_default = useLayoutEffect;
+
+// ../rectify-hook/src/RectifyHookUseRef.ts
+function useRef(initialValue) {
+  const fiber = getFiberRendering();
+  if (!fiber) {
+    throw new Error("useRef must be used within a function component.");
+  }
+  const hookIndex = getHookIndex();
+  nextHookIndex();
+  let hook = fiber.memoizedState;
+  let prevHook = null;
+  for (let i = 0; i < hookIndex; i++) {
+    prevHook = hook;
+    hook = hook?.next ?? null;
+  }
+  if (!hook) {
+    const ref = { current: initialValue };
+    const newHook = { memoizedState: ref, queue: null, next: null };
+    if (prevHook) {
+      prevHook.next = newHook;
+    } else {
+      fiber.memoizedState = newHook;
+    }
+    return ref;
+  }
+  return hook.memoizedState;
+}
+chunkS5YX7TXF_cjs.__name(useRef, "useRef");
+var RectifyHookUseRef_default = useRef;
+
+// ../rectify-hook/src/RectifyHookUseMemo.ts
+function useMemo(factory, deps) {
+  const fiber = getFiberRendering();
+  if (!fiber) {
+    throw new Error("useMemo must be used within a function component.");
+  }
+  const hookIndex = getHookIndex();
+  nextHookIndex();
+  let hook = fiber.memoizedState;
+  let prevHook = null;
+  for (let i = 0; i < hookIndex; i++) {
+    prevHook = hook;
+    hook = hook?.next ?? null;
+  }
+  if (!hook) {
+    const state = { value: factory(), deps };
+    const newHook = { memoizedState: state, queue: null, next: null };
+    if (prevHook) {
+      prevHook.next = newHook;
+    } else {
+      fiber.memoizedState = newHook;
+    }
+    return state.value;
+  }
+  const prev = hook.memoizedState;
+  if (depsChanged(prev.deps, deps)) {
+    const state = { value: factory(), deps };
+    hook.memoizedState = state;
+    return state.value;
+  }
+  return prev.value;
+}
+chunkS5YX7TXF_cjs.__name(useMemo, "useMemo");
+var RectifyHookUseMemo_default = useMemo;
+
+// ../rectify-hook/src/RectifyHookUseCallback.ts
+function useCallback(callback, deps) {
+  return RectifyHookUseMemo_default(() => callback, deps);
+}
+chunkS5YX7TXF_cjs.__name(useCallback, "useCallback");
+var RectifyHookUseCallback_default = useCallback;
+
+// ../rectify-hook/src/RectifyHookContext.ts
+var markFiberDirtyFn = null;
+var setMarkFiberDirty = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fn) => {
+  markFiberDirtyFn = fn;
+}, "setMarkFiberDirty");
+var fiberSubscriptions = /* @__PURE__ */ new WeakMap();
+function createContext(defaultValue) {
+  function ProviderFn(_props) {
+    return null;
+  }
+  chunkS5YX7TXF_cjs.__name(ProviderFn, "ProviderFn");
+  const context = ProviderFn;
+  context._context = context;
+  context._defaultValue = defaultValue;
+  context._subscribers = /* @__PURE__ */ new Set();
+  context.Provider = context;
+  return context;
+}
+chunkS5YX7TXF_cjs.__name(createContext, "createContext");
+function useContext(context) {
+  const fiber = getFiberRendering();
+  if (!fiber) {
+    throw new Error("useContext must be used within a function component.");
+  }
+  let ancestor = fiber.return;
+  while (ancestor) {
+    if (ancestor.type?._context === context) {
+      if (fiber.alternate) {
+        context._subscribers.delete(fiber.alternate);
+        const altSet = fiberSubscriptions.get(fiber.alternate);
+        if (altSet) {
+          altSet.delete(context);
+          if (altSet.size === 0) fiberSubscriptions.delete(fiber.alternate);
+        }
+      }
+      context._subscribers.add(fiber);
+      let ctxSet = fiberSubscriptions.get(fiber);
+      if (!ctxSet) {
+        ctxSet = /* @__PURE__ */ new Set();
+        fiberSubscriptions.set(fiber, ctxSet);
+      }
+      ctxSet.add(context);
+      return ancestor.pendingProps.value;
+    }
+    ancestor = ancestor.return;
+  }
+  return context._defaultValue;
+}
+chunkS5YX7TXF_cjs.__name(useContext, "useContext");
+function notifyContextConsumers(context) {
+  if (!markFiberDirtyFn) return;
+  for (const subscriber of context._subscribers) {
+    markFiberDirtyFn(subscriber);
+  }
+}
+chunkS5YX7TXF_cjs.__name(notifyContextConsumers, "notifyContextConsumers");
+function clearContextSubscriptions(fiber) {
+  const ctxSet = fiberSubscriptions.get(fiber);
+  if (!ctxSet) return;
+  for (const context of ctxSet) {
+    context._subscribers.delete(fiber);
+  }
+  fiberSubscriptions.delete(fiber);
+}
+chunkS5YX7TXF_cjs.__name(clearContextSubscriptions, "clearContextSubscriptions");
+
+// ../rectify-reconciler/src/RectifyFiberRenderPriority.ts
+var currentEventPriority = DefaultLane;
+var setCurrentEventPriority = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((lane) => {
+  currentEventPriority = lane;
+}, "setCurrentEventPriority");
+var resetCurrentEventPriority = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  currentEventPriority = DefaultLane;
+}, "resetCurrentEventPriority");
+var requestUpdateLane = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => currentEventPriority, "requestUpdateLane");
+var currentRenderingLanes = SyncLane;
+var setCurrentRenderingLanes = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((lanes) => {
+  currentRenderingLanes = lanes;
+}, "setCurrentRenderingLanes");
+var getCurrentLanePriority = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => currentRenderingLanes, "getCurrentLanePriority");
+
+// ../rectify-reconciler/src/RectifyFiberScheduler.ts
+var FRAME_BUDGET_MS = 5;
+var frameStart = 0;
+var shouldYield = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => performance.now() - frameStart > FRAME_BUDGET_MS, "shouldYield");
+var doWork = null;
+var setWorkCallback = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((cb) => {
+  doWork = cb;
+}, "setWorkCallback");
+var resumeCursor = null;
+var setResumeCursor = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  resumeCursor = fiber;
+}, "setResumeCursor");
+var getResumeCursor = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => resumeCursor, "getResumeCursor");
+var clearResumeCursor = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  resumeCursor = null;
+}, "clearResumeCursor");
+var pendingLanes = NoLanes;
+var scheduleRenderLane = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((lane) => {
+  pendingLanes |= lane;
+  if (lane & (SyncLane | InputLane)) {
+    scheduleMicrotask();
+  } else if (lane & DefaultLane) {
+    scheduleMessageTask();
+  } else if (lane & TransitionLane) {
+    scheduleTimeout();
+  } else if (lane & IdleLane) {
+    scheduleIdle();
+  }
+}, "scheduleRenderLane");
+var flush = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((mask) => {
+  const lanes = pendingLanes & mask;
+  if (!lanes) return;
+  pendingLanes &= ~lanes;
+  frameStart = performance.now();
+  doWork?.(lanes);
+}, "flush");
+var MICROTASK_MASK = SyncLane | InputLane;
+var microtaskScheduled = false;
+var scheduleMicrotask = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  if (microtaskScheduled) return;
+  microtaskScheduled = true;
+  queueMicrotask(() => {
+    microtaskScheduled = false;
+    flush(MICROTASK_MASK);
+  });
+}, "scheduleMicrotask");
+var DEFAULT_MASK = DefaultLane;
+var mc = new MessageChannel();
+var mcScheduled = false;
+mc.port1.onmessage = () => {
+  mcScheduled = false;
+  flush(DEFAULT_MASK);
+};
+var scheduleMessageTask = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  if (mcScheduled) return;
+  mcScheduled = true;
+  mc.port2.postMessage(null);
+}, "scheduleMessageTask");
+var TRANSITION_MASK = TransitionLane;
+var timeoutHandle = null;
+var scheduleTimeout = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  if (timeoutHandle !== null) return;
+  timeoutHandle = setTimeout(() => {
+    timeoutHandle = null;
+    flush(TRANSITION_MASK);
+  }, 0);
+}, "scheduleTimeout");
+var IDLE_MASK = IdleLane;
+var idleHandle = null;
+var scheduleIdle = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  if (idleHandle !== null) return;
+  const run = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+    idleHandle = null;
+    flush(IDLE_MASK);
+  }, "run");
+  if (typeof requestIdleCallback !== "undefined") {
+    idleHandle = requestIdleCallback(run, { timeout: 300 });
+  } else {
+    idleHandle = setTimeout(run, 300);
+  }
+}, "scheduleIdle");
+
+// ../rectify-reconciler/src/RectifyFiberWorkLoop.ts
+var swapCurrentForWip = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((current, wip) => {
+  const parent = wip.return;
+  if (!parent) return;
+  if (parent.child === current) {
+    parent.child = wip;
+    return;
+  }
+  let prevSibling = parent.child;
+  while (prevSibling && prevSibling.sibling !== current) {
+    prevSibling = prevSibling.sibling;
+  }
+  if (prevSibling) prevSibling.sibling = wip;
+}, "swapCurrentForWip");
+var workLoop = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wipRoot) => {
+  let workInProgress = wipRoot;
+  while (workInProgress) {
+    const next = beginWork(workInProgress);
+    if (next) {
+      workInProgress = next;
+    } else {
+      workInProgress = completeUnitOfWork(workInProgress, wipRoot);
+    }
+  }
+}, "workLoop");
+var workLoopConcurrent = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wipRoot) => {
+  let workInProgress = getResumeCursor() ?? wipRoot;
+  clearResumeCursor();
+  while (workInProgress && !shouldYield()) {
+    const next = beginWork(workInProgress);
+    if (next) {
+      workInProgress = next;
+    } else {
+      workInProgress = completeUnitOfWork(workInProgress, wipRoot);
+    }
+  }
+  if (workInProgress !== null) {
+    setResumeCursor(workInProgress);
+    return false;
+  }
+  return true;
+}, "workLoopConcurrent");
+var workLoopOnFiberLanes = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wipRoot, renderLanes) => {
+  if (wipRoot.lanes & renderLanes) {
+    const wip = createWorkInProgress(wipRoot, wipRoot.pendingProps);
+    swapCurrentForWip(wipRoot, wip);
+    const isSync = !!(renderLanes & (SyncLane | InputLane));
+    let completed;
+    if (isSync) {
+      workLoop(wip);
+      completed = true;
+    } else {
+      completed = workLoopConcurrent(wip);
+    }
+    if (completed) bubbleFlagsToRoot(wip);
+    return completed;
+  }
+  if (wipRoot.childLanes & renderLanes) {
+    let child = wipRoot.child;
+    while (child) {
+      const done = workLoopOnFiberLanes(child, renderLanes);
+      if (!done) return false;
+      child = child.sibling;
+    }
+  }
+  return true;
+}, "workLoopOnFiberLanes");
+var cloneChildFibers = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => {
+  const currentChild = wip.alternate?.child ?? null;
+  if (!currentChild) {
+    wip.child = null;
+    return null;
+  }
+  let oldChild = currentChild;
+  let prevNewChild = null;
+  while (oldChild) {
+    const newChild = createWorkInProgress(oldChild, oldChild.pendingProps);
+    newChild.return = wip;
+    if (!prevNewChild) {
+      wip.child = newChild;
+    } else {
+      prevNewChild.sibling = newChild;
+    }
+    prevNewChild = newChild;
+    oldChild = oldChild.sibling;
+  }
+  if (prevNewChild) prevNewChild.sibling = null;
+  return wip.child;
+}, "cloneChildFibers");
+var hasNoPendingWork = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => !(wip.lanes & getCurrentLanePriority()), "hasNoPendingWork");
+var isUpdate = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => wip.alternate !== null, "isUpdate");
+var renderFunctionComponent = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip, Component) => {
+  const ComponentWithHooks = withHooks(wip, Component);
+  const children = ComponentWithHooks(wip.pendingProps);
+  reconcileChildren(wip, children);
+}, "renderFunctionComponent");
+var getProviderContext = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => wip.type._context, "getProviderContext");
+var beginWork = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => {
+  switch (wip.workTag) {
+    case MemoComponent: {
+      const memo2 = wip.type;
+      const render = memo2._render;
+      if (!chunkS5YX7TXF_cjs.isFunction(render)) break;
+      if (isUpdate(wip) && hasNoPendingWork(wip)) {
+        const equal = memo2._compare ? memo2._compare(wip.memoizedProps, wip.pendingProps) : chunkS5YX7TXF_cjs.shallowEqual(wip.memoizedProps, wip.pendingProps);
+        if (equal) return cloneChildFibers(wip);
+      }
+      renderFunctionComponent(wip, render);
+      break;
+    }
+    case FunctionComponent: {
+      const Component = wip.type;
+      if (!chunkS5YX7TXF_cjs.isFunction(Component)) break;
+      if (isUpdate(wip) && hasNoPendingWork(wip) && chunkS5YX7TXF_cjs.shallowEqual(wip.memoizedProps, wip.pendingProps)) {
+        return cloneChildFibers(wip);
+      }
+      renderFunctionComponent(wip, Component);
+      break;
+    }
+    case FragmentComponent:
+    case HostRoot:
+    case HostComponent: {
+      reconcileChildren(wip, wip.pendingProps?.children);
+      break;
+    }
+    case ContextProvider: {
+      if (isUpdate(wip) && hasNoPendingWork(wip) && Object.is(wip.alternate.memoizedProps?.value, wip.pendingProps?.value)) {
+        return cloneChildFibers(wip);
+      }
+      reconcileChildren(wip, wip.pendingProps?.children);
+      if (isUpdate(wip)) {
+        const prevValue = wip.alternate.memoizedProps?.value;
+        const nextValue = wip.pendingProps?.value;
+        if (!Object.is(prevValue, nextValue)) {
+          notifyContextConsumers(getProviderContext(wip));
+        }
+      }
+      break;
+    }
+  }
+  return wip.child;
+}, "beginWork");
+var completeUnitOfWork = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((unit, stopAt) => {
+  let completed = unit;
+  while (completed) {
+    bubbleProperties(completed);
+    if (completed === stopAt) {
+      return null;
+    }
+    if (completed.sibling) {
+      return completed.sibling;
+    }
+    completed = completed.return;
+  }
+  return null;
+}, "completeUnitOfWork");
+var bubbleFlagsToRoot = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => {
+  let current = wip;
+  let parent = current.return;
+  while (parent) {
+    parent.subtreeFlags |= current.flags | current.subtreeFlags;
+    parent.childLanes |= current.lanes | current.childLanes;
+    current = parent;
+    parent = parent.return;
+  }
+}, "bubbleFlagsToRoot");
+var bubbleProperties = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => {
+  wip.lanes &= ~getCurrentLanePriority();
+  let subtreeFlags = NoFlags;
+  let childLanes = NoLanes;
+  let child = wip.child;
+  while (child) {
+    subtreeFlags |= child.flags | child.subtreeFlags;
+    childLanes |= child.lanes | child.childLanes;
+    child.return = wip;
+    child = child.sibling;
+  }
+  wip.subtreeFlags = subtreeFlags;
+  wip.childLanes = childLanes;
+}, "bubbleProperties");
+var reuseOrCreate = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((oldFiber, element, wip) => {
+  const newFiber = createWorkInProgress(oldFiber, element.props);
+  if (hasPropsChanged(oldFiber.memoizedProps, element.props)) {
+    addFlagToFiber(newFiber, UpdateFlag);
+  }
+  newFiber.return = wip;
+  return newFiber;
+}, "reuseOrCreate");
+var createAndPlace = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((element, wip) => {
+  const newFiber = createFiberFromRectifyElement(element);
+  newFiber.type = element.type;
+  addFlagToFiber(newFiber, PlacementFlag);
+  newFiber.return = wip;
+  return newFiber;
+}, "createAndPlace");
+var appendFiber = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber, prev, index, wip) => {
+  fiber.index = index;
+  if (!prev) wip.child = fiber;
+  else prev.sibling = fiber;
+  return fiber;
+}, "appendFiber");
+var buildOldFiberMap = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((firstRemaining, startIndex) => {
+  const map = /* @__PURE__ */ new Map();
+  let fiber = firstRemaining;
+  let i = startIndex;
+  while (fiber) {
+    map.set(fiber.key ?? i, fiber);
+    fiber = fiber.sibling;
+    i++;
+  }
+  return map;
+}, "buildOldFiberMap");
+var reconcileSequential = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((state, firstOldFiber) => {
+  let oldFiber = firstOldFiber;
+  let i = 0;
+  for (; i < state.newElements.length; i++) {
+    const element = state.newElements[i];
+    const { key: elementKey = null, type: elementType } = element;
+    if (!oldFiber) break;
+    if (oldFiber.key !== elementKey) break;
+    if (oldFiber.type === elementType) {
+      state.prev = appendFiber(reuseOrCreate(oldFiber, element, state.wip), state.prev, state.index++, state.wip);
+    } else {
+      addFlagToFiber(oldFiber, DeletionFlag);
+      state.deletions.push(oldFiber);
+      state.prev = appendFiber(createAndPlace(element, state.wip), state.prev, state.index++, state.wip);
+    }
+    oldFiber = oldFiber.sibling;
+  }
+  return { stoppedAt: i, oldFiber };
+}, "reconcileSequential");
+var reconcileKeyed = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((state, startAt, remainingOldFiber) => {
+  const oldFiberMap = buildOldFiberMap(remainingOldFiber, startAt);
+  let lastPlacedIndex = 0;
+  for (let i = startAt; i < state.newElements.length; i++) {
+    const element = state.newElements[i];
+    const { key: elementKey = null, type: elementType } = element;
+    const mapKey = elementKey ?? i;
+    const matched = oldFiberMap.get(mapKey) ?? null;
+    if (matched && matched.type === elementType) {
+      oldFiberMap.delete(mapKey);
+      const newFiber = reuseOrCreate(matched, element, state.wip);
+      if (matched.index < lastPlacedIndex) {
+        addFlagToFiber(newFiber, MoveFlag);
+      } else {
+        lastPlacedIndex = matched.index;
+      }
+      state.prev = appendFiber(newFiber, state.prev, state.index++, state.wip);
+    } else {
+      state.prev = appendFiber(createAndPlace(element, state.wip), state.prev, state.index++, state.wip);
+    }
+  }
+  for (const orphan of oldFiberMap.values()) {
+    addFlagToFiber(orphan, DeletionFlag);
+    state.deletions.push(orphan);
+  }
+}, "reconcileKeyed");
+var toChildArray = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((children) => {
+  if (children == null || typeof children === "boolean") return [];
+  if (chunkS5YX7TXF_cjs.isArray(children)) return children;
+  return [children];
+}, "toChildArray");
+var reconcileChildren = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip, children) => {
+  const newElements = toChildArray(children).map(chunkS5YX7TXF_cjs.createElementFromRectifyNode).filter(chunkS5YX7TXF_cjs.isValidRectifyElement);
+  const state = { wip, newElements, deletions: [], prev: null, index: 0 };
+  const firstOldFiber = wip.alternate?.child ?? null;
+  const { stoppedAt, oldFiber } = reconcileSequential(state, firstOldFiber);
+  if (stoppedAt < newElements.length) {
+    reconcileKeyed(state, stoppedAt, oldFiber);
+  } else {
+    let leftover = oldFiber;
+    while (leftover) {
+      addFlagToFiber(leftover, DeletionFlag);
+      state.deletions.push(leftover);
+      leftover = leftover.sibling;
+    }
+  }
+  if (state.prev) state.prev.sibling = null;
+  if (state.deletions.length) wip.deletions = state.deletions;
+}, "reconcileChildren");
+
+// ../rectify-reconciler/src/RectifyFiberCommitWork.ts
+var MutationMask = PlacementFlag | UpdateFlag | MoveFlag;
+var commitWork = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((finishedWork) => {
+  if (finishedWork.deletions?.length) {
+    finishedWork.deletions.forEach(removeHostTree);
+    finishedWork.deletions = null;
+  }
+  if (finishedWork.flags & MutationMask) {
+    commitMutation(finishedWork);
+    syncMemoizedProps(finishedWork);
+  }
+  if (finishedWork.subtreeFlags & MutationMask) {
+    let child = finishedWork.child;
+    while (child) {
+      commitWork(child);
+      child = child.sibling;
+    }
+  }
+  finishedWork.flags = NoFlags;
+  finishedWork.subtreeFlags = NoFlags;
+}, "commitWork");
+var syncMemoizedProps = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => {
+  wip.memoizedProps = wip.pendingProps;
+}, "syncMemoizedProps");
+var attachRef = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => {
+  const ref = wip.pendingProps?.ref;
+  if (ref && typeof ref === "object" && "current" in ref) {
+    ref.current = wip.stateNode;
+  }
+}, "attachRef");
+var detachRef = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  const ref = fiber.memoizedProps?.ref;
+  if (ref && typeof ref === "object" && "current" in ref) {
+    ref.current = null;
+  }
+}, "detachRef");
+var insertIntoParent = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip, node) => {
+  const parentDom = getParentDom(wip);
+  const before = getHostSibling(wip) ?? (wip.return ? getHostSibling(wip.return) : null);
+  if (before) parentDom.insertBefore(node, before);
+  else parentDom.appendChild(node);
+}, "insertIntoParent");
+var placeNode = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip, node) => {
+  insertIntoParent(wip, node);
+  precacheFiberNode(wip, node);
+  attachRef(wip);
+}, "placeNode");
+var commitMutation = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((childFiber) => {
+  switch (childFiber.workTag) {
+    case HostComponent:
+      commitMutationHostComponent(childFiber);
+      break;
+    case HostText:
+      commitMutationHostText(childFiber);
+      break;
+  }
+}, "commitMutation");
+var commitMutationHostComponent = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => {
+  if (!wip.stateNode) {
+    const node = createDomElementFromFiber(wip);
+    precacheFiberNode(wip, node);
+    applyPropsToDom(node, wip.memoizedProps, wip.pendingProps);
+    wip.stateNode = node;
+  }
+  if (hasFlagOnFiber(wip, PlacementFlag)) {
+    placeNode(wip, wip.stateNode);
+    removeFlagFromFiber(wip, PlacementFlag);
+  }
+  if (hasFlagOnFiber(wip, MoveFlag)) {
+    wip.stateNode.remove();
+    placeNode(wip, wip.stateNode);
+    removeFlagFromFiber(wip, MoveFlag);
+  }
+  if (hasFlagOnFiber(wip, UpdateFlag)) {
+    applyPropsToDom(wip.stateNode, wip.memoizedProps, wip.pendingProps);
+    precacheFiberNode(wip, wip.stateNode);
+    attachRef(wip);
+    removeFlagFromFiber(wip, UpdateFlag);
+  }
+}, "commitMutationHostComponent");
+var commitMutationHostText = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((wip) => {
+  if (!wip.stateNode) {
+    const node = createDomElementFromFiber(wip);
+    precacheFiberNode(wip, node);
+    wip.stateNode = node;
+  }
+  if (hasFlagOnFiber(wip, PlacementFlag)) {
+    placeNode(wip, wip.stateNode);
+    removeFlagFromFiber(wip, PlacementFlag);
+  }
+  if (hasFlagOnFiber(wip, MoveFlag)) {
+    wip.stateNode.remove();
+    placeNode(wip, wip.stateNode);
+    removeFlagFromFiber(wip, MoveFlag);
+  }
+  if (hasFlagOnFiber(wip, UpdateFlag)) {
+    if (wip.memoizedProps !== wip.pendingProps) {
+      wip.stateNode.nodeValue = String(wip.pendingProps);
+    }
+    precacheFiberNode(wip, wip.stateNode);
+    removeFlagFromFiber(wip, UpdateFlag);
+  }
+}, "commitMutationHostText");
+var removeHostTree = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  if (fiber.memoizedState) {
+    runEffectCleanups(fiber);
+  }
+  clearContextSubscriptions(fiber);
+  if (fiber.workTag === HostComponent || fiber.workTag === HostText) {
+    detachRef(fiber);
+    fiber.stateNode?.remove();
+  }
+  let child = fiber.child;
+  while (child) {
+    removeHostTree(child);
+    child = child.sibling;
+  }
+}, "removeHostTree");
+
+// ../rectify-reconciler/src/RectifyFiberConcurrentUpdate.ts
+var instance3 = {
+  head: null,
+  tail: null
+};
+var enqueueUpdate = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((update) => {
+  update.next = null;
+  if (instance3.tail === null) {
+    instance3.head = update;
+    instance3.tail = update;
+    return;
+  }
+  instance3.tail.next = update;
+  instance3.tail = update;
+}, "enqueueUpdate");
+var dequeueUpdate = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  const first = instance3.head;
+  if (first === null) {
+    return null;
+  }
+  instance3.head = first.next;
+  if (instance3.head === null) {
+    instance3.tail = null;
+  }
+  first.next = null;
+  return first;
+}, "dequeueUpdate");
+var hasUpdate = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => instance3.head !== null, "hasUpdate");
+
+// ../rectify-reconciler/src/RectifyFiberReconciler.ts
+injectEventPriorityCallbacks(
+  setCurrentEventPriority,
+  resetCurrentEventPriority
+);
+var isFlushingLayoutEffects = false;
+var performWork = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((lanes) => {
+  const fiberRoot = getScheduledFiberRoot();
+  if (!fiberRoot) return;
+  if (!getResumeCursor()) flushPendingUpdates();
+  setCurrentRenderingLanes(lanes);
+  const completed = workLoopOnFiberLanes(fiberRoot.root, lanes);
+  if (!completed) {
+    scheduleRenderLane(lanes);
+    return;
+  }
+  clearResumeCursor();
+  commitWork(fiberRoot.root);
+  markContainerAsRoot(fiberRoot.root, fiberRoot.containerDom);
+  flushLayoutPhase(fiberRoot);
+  schedulePassiveEffects();
+}, "performWork");
+setWorkCallback(performWork);
+var onScheduleRerender = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  const lane = isFlushingLayoutEffects ? SyncLane : requestUpdateLane();
+  enqueueUpdate({ lanes: lane, fiber, next: null });
+  if (!isFlushingLayoutEffects) {
+    scheduleRenderLane(lane);
+  }
+}, "onScheduleRerender");
+var onMarkFiberDirty = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiber) => {
+  const lane = getCurrentLanePriority();
+  fiber.lanes |= lane;
+  const wip = fiber.alternate;
+  if (!wip) return;
+  wip.lanes |= lane;
+  let parent = wip.return;
+  while (parent) {
+    if ((parent.childLanes & lane) === lane) break;
+    parent.childLanes |= lane;
+    parent = parent.return;
+  }
+}, "onMarkFiberDirty");
+setScheduleRerender(onScheduleRerender);
+setMarkFiberDirty(onMarkFiberDirty);
+var createContainer = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((container) => {
+  return createHostRootFiber(container);
+}, "createContainer");
+var updateContainer = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((children, fiberRoot) => {
+  fiberRoot.children = children;
+  setScheduledFiberRoot(fiberRoot);
+  const wipRoot = createWorkInProgress(fiberRoot.root, { children });
+  setCurrentRenderingLanes(SyncLane);
+  workLoop(wipRoot);
+  commitWork(wipRoot);
+  fiberRoot.root = wipRoot;
+  markContainerAsRoot(wipRoot, fiberRoot.containerDom);
+  setScheduledFiberRoot(fiberRoot);
+  flushLayoutPhase(fiberRoot);
+  schedulePassiveEffects();
+}, "updateContainer");
+var passiveChannel = new MessageChannel();
+var schedulePassiveEffects = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  passiveChannel.port1.onmessage = () => {
+    flushEffectCleanups();
+    flushEffects();
+  };
+  passiveChannel.port2.postMessage(null);
+}, "schedulePassiveEffects");
+var flushLayoutPhase = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((fiberRoot) => {
+  while (true) {
+    isFlushingLayoutEffects = true;
+    flushLayoutEffectCleanups();
+    flushLayoutEffects();
+    isFlushingLayoutEffects = false;
+    if (!hasUpdate()) break;
+    flushPendingUpdates();
+    setCurrentRenderingLanes(SyncLane);
+    const completed = workLoopOnFiberLanes(fiberRoot.root, SyncLane);
+    if (!completed) break;
+    clearResumeCursor();
+    commitWork(fiberRoot.root);
+    markContainerAsRoot(fiberRoot.root, fiberRoot.containerDom);
+  }
+}, "flushLayoutPhase");
+var flushPendingUpdates = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+  let update = dequeueUpdate();
+  while (update) {
+    propagateLaneToAncestors(update);
+    update = dequeueUpdate();
+  }
+}, "flushPendingUpdates");
+var propagateLaneToAncestors = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((updateQueue) => {
+  const lane = updateQueue.lanes;
+  let fiber = updateQueue.fiber;
+  fiber.lanes |= lane;
+  if (fiber.alternate) fiber.alternate.lanes |= lane;
+  fiber = fiber.return;
+  while (fiber) {
+    fiber.childLanes |= lane;
+    if (fiber.alternate) fiber.alternate.childLanes |= lane;
+    fiber = fiber.return;
+  }
+}, "propagateLaneToAncestors");
+
+// ../rectify-dom/src/RectifyDomRoot.ts
+var createRoot = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((container) => {
+  const hostRoot = createContainer(container);
+  markContainerAsRoot(hostRoot.root, container);
+  listenToAllEventSupported(container);
+  return {
+    render: /* @__PURE__ */ chunkS5YX7TXF_cjs.__name((node) => {
+      updateContainer(node, hostRoot);
+    }, "render"),
+    unmount: /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(() => {
+      unmarkContainerAsRoot(container);
+    }, "unmount")
+  };
+}, "createRoot");
+
+// src/RectifyMemo.ts
+function memo(Component, compare) {
+  const wrapper = /* @__PURE__ */ chunkS5YX7TXF_cjs.__name(((_props) => null), "wrapper");
+  wrapper._isMemo = true;
+  wrapper._render = Component;
+  wrapper._compare = compare ?? null;
+  return wrapper;
+}
+chunkS5YX7TXF_cjs.__name(memo, "memo");
+
+Object.defineProperty(exports, "Fragment", {
+  enumerable: true,
+  get: function () { return chunkS5YX7TXF_cjs.Fragment; }
+});
+Object.defineProperty(exports, "jsx", {
+  enumerable: true,
+  get: function () { return chunkS5YX7TXF_cjs.jsx; }
+});
+exports.SyntheticEvent = SyntheticEvent_default;
+exports.createContext = createContext;
+exports.createRoot = createRoot;
+exports.memo = memo;
+exports.useCallback = RectifyHookUseCallback_default;
+exports.useContext = useContext;
+exports.useEffect = RectifyHookUseEffect_default;
+exports.useLayoutEffect = RectifyHookUseLayoutEffect_default;
+exports.useMemo = RectifyHookUseMemo_default;
+exports.useRef = RectifyHookUseRef_default;
+exports.useState = RectifyHookUseState_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map