@depup/hono 4.12.8-depup.0

package/dist/cjs/jsx/context.js

@@ -0,0 +1,62 @@
+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);
+var context_exports = {};
+__export(context_exports, {
+  createContext: () => createContext,
+  globalContexts: () => globalContexts,
+  useContext: () => useContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_html = require("../helper/html");
+var import_base = require("./base");
+var import_constants = require("./constants");
+var import_context = require("./dom/context");
+const globalContexts = [];
+const createContext = (defaultValue) => {
+  const values = [defaultValue];
+  const context = ((props) => {
+    values.push(props.value);
+    let string;
+    try {
+      string = props.children ? (Array.isArray(props.children) ? new import_base.JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
+    } catch (e) {
+      values.pop();
+      throw e;
+    }
+    if (string instanceof Promise) {
+      return string.finally(() => values.pop()).then((resString) => (0, import_html.raw)(resString, resString.callbacks));
+    } else {
+      values.pop();
+      return (0, import_html.raw)(string);
+    }
+  });
+  context.values = values;
+  context.Provider = context;
+  context[import_constants.DOM_RENDERER] = (0, import_context.createContextProviderFunction)(values);
+  globalContexts.push(context);
+  return context;
+};
+const useContext = (context) => {
+  return context.values.at(-1);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContext,
+  globalContexts,
+  useContext
+});

package/dist/cjs/jsx/dom/client.js

@@ -0,0 +1,76 @@
+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);
+var client_exports = {};
+__export(client_exports, {
+  createRoot: () => createRoot,
+  default: () => client_default,
+  hydrateRoot: () => hydrateRoot
+});
+module.exports = __toCommonJS(client_exports);
+var import_hooks = require("../hooks");
+var import_render = require("./render");
+const createRoot = (element, options = {}) => {
+  let setJsxNode = (
+    // unmounted
+    void 0
+  );
+  if (Object.keys(options).length > 0) {
+    console.warn("createRoot options are not supported yet");
+  }
+  return {
+    render(jsxNode) {
+      if (setJsxNode === null) {
+        throw new Error("Cannot update an unmounted root");
+      }
+      if (setJsxNode) {
+        setJsxNode(jsxNode);
+      } else {
+        (0, import_render.renderNode)(
+          (0, import_render.buildNode)({
+            tag: () => {
+              const [_jsxNode, _setJsxNode] = (0, import_hooks.useState)(jsxNode);
+              setJsxNode = _setJsxNode;
+              return _jsxNode;
+            },
+            props: {}
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          }),
+          element
+        );
+      }
+    },
+    unmount() {
+      setJsxNode?.(null);
+      setJsxNode = null;
+    }
+  };
+};
+const hydrateRoot = (element, reactNode, options = {}) => {
+  const root = createRoot(element, options);
+  root.render(reactNode);
+  return root;
+};
+var client_default = {
+  createRoot,
+  hydrateRoot
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRoot,
+  hydrateRoot
+});

package/dist/cjs/jsx/dom/components.js

@@ -0,0 +1,55 @@
+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);
+var components_exports = {};
+__export(components_exports, {
+  ErrorBoundary: () => ErrorBoundary,
+  Suspense: () => Suspense
+});
+module.exports = __toCommonJS(components_exports);
+var import_constants = require("../constants");
+var import_jsx_runtime = require("./jsx-runtime");
+const ErrorBoundary = (({ children, fallback, fallbackRender, onError }) => {
+  const res = (0, import_jsx_runtime.Fragment)({ children });
+  res[import_constants.DOM_ERROR_HANDLER] = (err) => {
+    if (err instanceof Promise) {
+      throw err;
+    }
+    onError?.(err);
+    return fallbackRender?.(err) || fallback;
+  };
+  return res;
+});
+const Suspense = (({
+  children,
+  fallback
+}) => {
+  const res = (0, import_jsx_runtime.Fragment)({ children });
+  res[import_constants.DOM_ERROR_HANDLER] = (err, retry) => {
+    if (!(err instanceof Promise)) {
+      throw err;
+    }
+    err.finally(retry);
+    return fallback;
+  };
+  return res;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorBoundary,
+  Suspense
+});

package/dist/cjs/jsx/dom/context.js

@@ -0,0 +1,71 @@
+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);
+var context_exports = {};
+__export(context_exports, {
+  createContext: () => createContext,
+  createContextProviderFunction: () => createContextProviderFunction
+});
+module.exports = __toCommonJS(context_exports);
+var import_constants = require("../constants");
+var import_context = require("../context");
+var import_utils = require("./utils");
+const createContextProviderFunction = (values) => ({ value, children }) => {
+  if (!children) {
+    return void 0;
+  }
+  const props = {
+    children: [
+      {
+        tag: (0, import_utils.setInternalTagFlag)(() => {
+          values.push(value);
+        }),
+        props: {}
+      }
+    ]
+  };
+  if (Array.isArray(children)) {
+    props.children.push(...children.flat());
+  } else {
+    props.children.push(children);
+  }
+  props.children.push({
+    tag: (0, import_utils.setInternalTagFlag)(() => {
+      values.pop();
+    }),
+    props: {}
+  });
+  const res = { tag: "", props, type: "" };
+  res[import_constants.DOM_ERROR_HANDLER] = (err) => {
+    values.pop();
+    throw err;
+  };
+  return res;
+};
+const createContext = (defaultValue) => {
+  const values = [defaultValue];
+  const context = createContextProviderFunction(values);
+  context.values = values;
+  context.Provider = context;
+  import_context.globalContexts.push(context);
+  return context;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContext,
+  createContextProviderFunction
+});

package/dist/cjs/jsx/dom/css.js

@@ -0,0 +1,161 @@
+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);
+var css_exports = {};
+__export(css_exports, {
+  Style: () => Style,
+  createCssContext: () => createCssContext,
+  createCssJsxDomObjects: () => createCssJsxDomObjects,
+  css: () => css,
+  cx: () => cx,
+  keyframes: () => keyframes,
+  rawCssString: () => import_common2.rawCssString,
+  viewTransition: () => viewTransition
+});
+module.exports = __toCommonJS(css_exports);
+var import_common = require("../../helper/css/common");
+var import_common2 = require("../../helper/css/common");
+const splitRule = (rule) => {
+  const result = [];
+  let startPos = 0;
+  let depth = 0;
+  for (let i = 0, len = rule.length; i < len; i++) {
+    const char = rule[i];
+    if (char === "'" || char === '"') {
+      const quote = char;
+      i++;
+      for (; i < len; i++) {
+        if (rule[i] === "\\") {
+          i++;
+          continue;
+        }
+        if (rule[i] === quote) {
+          break;
+        }
+      }
+      continue;
+    }
+    if (char === "{") {
+      depth++;
+      continue;
+    }
+    if (char === "}") {
+      depth--;
+      if (depth === 0) {
+        result.push(rule.slice(startPos, i + 1));
+        startPos = i + 1;
+      }
+      continue;
+    }
+  }
+  return result;
+};
+const createCssJsxDomObjects = ({ id }) => {
+  let styleSheet = void 0;
+  const findStyleSheet = () => {
+    if (!styleSheet) {
+      styleSheet = document.querySelector(`style#${id}`)?.sheet;
+      if (styleSheet) {
+        ;
+        styleSheet.addedStyles = /* @__PURE__ */ new Set();
+      }
+    }
+    return styleSheet ? [styleSheet, styleSheet.addedStyles] : [];
+  };
+  const insertRule = (className, styleString) => {
+    const [sheet, addedStyles] = findStyleSheet();
+    if (!sheet || !addedStyles) {
+      Promise.resolve().then(() => {
+        if (!findStyleSheet()[0]) {
+          throw new Error("style sheet not found");
+        }
+        insertRule(className, styleString);
+      });
+      return;
+    }
+    if (!addedStyles.has(className)) {
+      addedStyles.add(className);
+      (className.startsWith(import_common.PSEUDO_GLOBAL_SELECTOR) ? splitRule(styleString) : [`${className[0] === "@" ? "" : "."}${className}{${styleString}}`]).forEach((rule) => {
+        sheet.insertRule(rule, sheet.cssRules.length);
+      });
+    }
+  };
+  const cssObject = {
+    toString() {
+      const selector = this[import_common.SELECTOR];
+      insertRule(selector, this[import_common.STYLE_STRING]);
+      this[import_common.SELECTORS].forEach(({ [import_common.CLASS_NAME]: className, [import_common.STYLE_STRING]: styleString }) => {
+        insertRule(className, styleString);
+      });
+      return this[import_common.CLASS_NAME];
+    }
+  };
+  const Style2 = ({ children, nonce }) => ({
+    tag: "style",
+    props: {
+      id,
+      nonce,
+      children: children && (Array.isArray(children) ? children : [children]).map(
+        (c) => c[import_common.STYLE_STRING]
+      )
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  });
+  return [cssObject, Style2];
+};
+const createCssContext = ({ id }) => {
+  const [cssObject, Style2] = createCssJsxDomObjects({ id });
+  const newCssClassNameObject = (cssClassName) => {
+    cssClassName.toString = cssObject.toString;
+    return cssClassName;
+  };
+  const css2 = (strings, ...values) => {
+    return newCssClassNameObject((0, import_common.cssCommon)(strings, values));
+  };
+  const cx2 = (...args) => {
+    args = (0, import_common.cxCommon)(args);
+    return css2(Array(args.length).fill(""), ...args);
+  };
+  const keyframes2 = import_common.keyframesCommon;
+  const viewTransition2 = ((strings, ...values) => {
+    return newCssClassNameObject((0, import_common.viewTransitionCommon)(strings, values));
+  });
+  return {
+    css: css2,
+    cx: cx2,
+    keyframes: keyframes2,
+    viewTransition: viewTransition2,
+    Style: Style2
+  };
+};
+const defaultContext = createCssContext({ id: import_common.DEFAULT_STYLE_ID });
+const css = defaultContext.css;
+const cx = defaultContext.cx;
+const keyframes = defaultContext.keyframes;
+const viewTransition = defaultContext.viewTransition;
+const Style = defaultContext.Style;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Style,
+  createCssContext,
+  createCssJsxDomObjects,
+  css,
+  cx,
+  keyframes,
+  rawCssString,
+  viewTransition
+});

package/dist/cjs/jsx/dom/hooks/index.js

@@ -0,0 +1,74 @@
+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);
+var hooks_exports = {};
+__export(hooks_exports, {
+  FormContext: () => FormContext,
+  registerAction: () => registerAction,
+  useActionState: () => useActionState,
+  useFormStatus: () => useFormStatus,
+  useOptimistic: () => useOptimistic
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_constants = require("../../constants");
+var import_context = require("../../context");
+var import_hooks = require("../../hooks");
+var import_context2 = require("../context");
+const FormContext = (0, import_context2.createContext)({
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+});
+const actions = /* @__PURE__ */ new Set();
+const registerAction = (action) => {
+  actions.add(action);
+  action.finally(() => actions.delete(action));
+};
+const useFormStatus = () => {
+  return (0, import_context.useContext)(FormContext);
+};
+const useOptimistic = (state, updateState) => {
+  const [optimisticState, setOptimisticState] = (0, import_hooks.useState)(state);
+  if (actions.size > 0) {
+    Promise.all(actions).finally(() => {
+      setOptimisticState(state);
+    });
+  } else {
+    setOptimisticState(state);
+  }
+  const cb = (0, import_hooks.useCallback)((newData) => {
+    setOptimisticState((currentState) => updateState(currentState, newData));
+  }, []);
+  return [optimisticState, cb];
+};
+const useActionState = (fn, initialState, permalink) => {
+  const [state, setState] = (0, import_hooks.useState)(initialState);
+  const actionState = async (data) => {
+    setState(await fn(state, data));
+  };
+  actionState[import_constants.PERMALINK] = permalink;
+  return [state, actionState];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormContext,
+  registerAction,
+  useActionState,
+  useFormStatus,
+  useOptimistic
+});

package/dist/cjs/jsx/dom/index.js

@@ -0,0 +1,181 @@
+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);
+var dom_exports = {};
+__export(dom_exports, {
+  Children: () => import_children.Children,
+  ErrorBoundary: () => import_components.ErrorBoundary,
+  Fragment: () => import_jsx_runtime.Fragment,
+  StrictMode: () => import_jsx_runtime.Fragment,
+  Suspense: () => import_components.Suspense,
+  cloneElement: () => cloneElement,
+  createContext: () => import_context2.createContext,
+  createElement: () => createElement,
+  createPortal: () => import_render.createPortal,
+  createRef: () => import_hooks.createRef,
+  default: () => dom_default,
+  flushSync: () => import_render.flushSync,
+  forwardRef: () => import_hooks.forwardRef,
+  isValidElement: () => import_base.isValidElement,
+  jsx: () => createElement,
+  memo: () => memo,
+  render: () => import_render2.render,
+  startTransition: () => import_hooks.startTransition,
+  startViewTransition: () => import_hooks.startViewTransition,
+  use: () => import_hooks.use,
+  useActionState: () => import_hooks2.useActionState,
+  useCallback: () => import_hooks.useCallback,
+  useContext: () => import_context.useContext,
+  useDebugValue: () => import_hooks.useDebugValue,
+  useDeferredValue: () => import_hooks.useDeferredValue,
+  useEffect: () => import_hooks.useEffect,
+  useFormStatus: () => import_hooks2.useFormStatus,
+  useId: () => import_hooks.useId,
+  useImperativeHandle: () => import_hooks.useImperativeHandle,
+  useInsertionEffect: () => import_hooks.useInsertionEffect,
+  useLayoutEffect: () => import_hooks.useLayoutEffect,
+  useMemo: () => import_hooks.useMemo,
+  useOptimistic: () => import_hooks2.useOptimistic,
+  useReducer: () => import_hooks.useReducer,
+  useRef: () => import_hooks.useRef,
+  useState: () => import_hooks.useState,
+  useSyncExternalStore: () => import_hooks.useSyncExternalStore,
+  useTransition: () => import_hooks.useTransition,
+  useViewTransition: () => import_hooks.useViewTransition,
+  version: () => import_base.reactAPICompatVersion
+});
+module.exports = __toCommonJS(dom_exports);
+var import_base = require("../base");
+var import_children = require("../children");
+var import_constants = require("../constants");
+var import_context = require("../context");
+var import_hooks = require("../hooks");
+var import_components = require("./components");
+var import_context2 = require("./context");
+var import_hooks2 = require("./hooks");
+var import_jsx_runtime = require("./jsx-runtime");
+var import_render = require("./render");
+var import_render2 = require("./render");
+const createElement = (tag, props, ...children) => {
+  const jsxProps = props ? { ...props } : {};
+  if (children.length) {
+    jsxProps.children = children.length === 1 ? children[0] : children;
+  }
+  let key = void 0;
+  if ("key" in jsxProps) {
+    key = jsxProps.key;
+    delete jsxProps.key;
+  }
+  return (0, import_jsx_runtime.jsx)(tag, jsxProps, key);
+};
+const cloneElement = (element, props, ...children) => {
+  return (0, import_jsx_runtime.jsx)(
+    element.tag,
+    {
+      ...element.props,
+      ...props,
+      children: children.length ? children : element.props.children
+    },
+    element.key
+  );
+};
+const memo = (component, propsAreEqual = import_base.shallowEqual) => {
+  const wrapper = ((props) => component(props));
+  wrapper[import_constants.DOM_MEMO] = propsAreEqual;
+  return wrapper;
+};
+var dom_default = {
+  version: import_base.reactAPICompatVersion,
+  useState: import_hooks.useState,
+  useEffect: import_hooks.useEffect,
+  useRef: import_hooks.useRef,
+  useCallback: import_hooks.useCallback,
+  use: import_hooks.use,
+  startTransition: import_hooks.startTransition,
+  useTransition: import_hooks.useTransition,
+  useDeferredValue: import_hooks.useDeferredValue,
+  startViewTransition: import_hooks.startViewTransition,
+  useViewTransition: import_hooks.useViewTransition,
+  useMemo: import_hooks.useMemo,
+  useLayoutEffect: import_hooks.useLayoutEffect,
+  useInsertionEffect: import_hooks.useInsertionEffect,
+  useReducer: import_hooks.useReducer,
+  useId: import_hooks.useId,
+  useDebugValue: import_hooks.useDebugValue,
+  createRef: import_hooks.createRef,
+  forwardRef: import_hooks.forwardRef,
+  useImperativeHandle: import_hooks.useImperativeHandle,
+  useSyncExternalStore: import_hooks.useSyncExternalStore,
+  useFormStatus: import_hooks2.useFormStatus,
+  useActionState: import_hooks2.useActionState,
+  useOptimistic: import_hooks2.useOptimistic,
+  Suspense: import_components.Suspense,
+  ErrorBoundary: import_components.ErrorBoundary,
+  createContext: import_context2.createContext,
+  useContext: import_context.useContext,
+  memo,
+  isValidElement: import_base.isValidElement,
+  createElement,
+  cloneElement,
+  Children: import_children.Children,
+  Fragment: import_jsx_runtime.Fragment,
+  StrictMode: import_jsx_runtime.Fragment,
+  flushSync: import_render.flushSync,
+  createPortal: import_render.createPortal
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Children,
+  ErrorBoundary,
+  Fragment,
+  StrictMode,
+  Suspense,
+  cloneElement,
+  createContext,
+  createElement,
+  createPortal,
+  createRef,
+  flushSync,
+  forwardRef,
+  isValidElement,
+  jsx,
+  memo,
+  render,
+  startTransition,
+  startViewTransition,
+  use,
+  useActionState,
+  useCallback,
+  useContext,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useFormStatus,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useOptimistic,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition,
+  version
+});