pudui 0.0.0

package/dist/core-Cypb6mR9.d.mts

@@ -0,0 +1,434 @@
+//#region src/core/vnode.d.ts
+/**
+ * Returns its children without adding a wrapper element.
+ *
+ * This is the fragment implementation used by the JSX runtimes.
+ *
+ * @param props Fragment props.
+ * @returns The fragment children, or `null` when no children were provided.
+ *
+ * @example
+ * ```tsx
+ * <>
+ *   <title>Dashboard</title>
+ *   <meta name="description" content="Operations dashboard" />
+ * </>
+ * ```
+ */
+declare function Fragment(props: {
+  children?: Child;
+}): Child;
+/**
+ * Renders trusted HTML without escaping.
+ *
+ * Prefer normal JSX children whenever possible. Raw HTML is intended for HTML
+ * that has already been sanitized or generated by a trusted renderer.
+ *
+ * @param props Raw HTML props.
+ * @returns A raw child that renders its HTML verbatim.
+ *
+ * @example
+ * ```tsx
+ * <Raw>{"<span data-source=\"cms\">Published</span>"}</Raw>
+ * ```
+ */
+declare function Raw(props: RawProps): RawChild;
+/**
+ * Creates a Pudui child using the classic JSX factory shape.
+ *
+ * Most applications use JSX and do not call this directly. It is exported for
+ * explicit factory configuration and low-level integrations.
+ *
+ * @param type Intrinsic tag name, component factory, {@link Fragment}, or {@link Raw}.
+ * @param rawProps Props to pass to the render target.
+ * @param children Children supplied after the props argument.
+ * @returns A renderable child value.
+ *
+ * @example
+ * ```tsx
+ * const child = createElement("button", { type: "button" }, "Save");
+ * ```
+ */
+declare function createElement<Props extends AnyProps>(type: ElementType<Props>, rawProps?: (Props & IntrinsicElementProps) | null, ...children: Child[]): Child;
+/**
+ * Creates a Pudui child using the automatic JSX runtime shape.
+ *
+ * This function is called by compilers configured for
+ * `jsxImportSource: "pudui"`.
+ *
+ * @param type Intrinsic tag name, component factory, {@link Fragment}, or {@link Raw}.
+ * @param props Props supplied by the JSX transform.
+ * @param key Optional key supplied by the JSX transform.
+ * @returns A renderable child value.
+ */
+declare function jsx<Props extends AnyProps>(type: ElementType<Props>, props?: (Props & IntrinsicElementProps) | null, key?: Key): Child;
+/**
+ * Development JSX runtime entry compatible with React's `jsxDEV` call shape.
+ */
+declare const jsxDEV: <Props extends AnyProps>(type: ElementType<Props>, props?: (Props & IntrinsicElementProps) | null, key?: Key, _isStaticChildren?: boolean, _source?: unknown, _self?: unknown) => Child;
+/**
+ * Checks whether a value is a Pudui virtual node.
+ *
+ * @param value Value to inspect.
+ * @returns `true` when the value is a virtual node created by Pudui's JSX runtime.
+ */
+declare function isVNode(value: unknown): value is VNode;
+//#endregion
+//#region src/core/component.d.ts
+/**
+ * Stateful unit of rendering in Pudui.
+ *
+ * Components own their render function, mount callbacks, child component
+ * instances, and update scheduling. Create components from JSX factories and
+ * call {@link update} when internal state changes.
+ *
+ * @example
+ * ```tsx
+ * import { Component, event } from "pudui";
+ *
+ * export function Counter() {
+ *   let count = 0;
+ *   const counter = new Component({
+ *     render() {
+ *       return <button ref={event("click", () => { count++; counter.update(); })}>{count}</button>;
+ *     },
+ *   });
+ *
+ *   return counter;
+ * }
+ * ```
+ */
+declare class Component<Props extends AnyProps = AnyProps> {
+  /**
+   * Creates a component from render options.
+   *
+   * @param options Render, error, and hydration options for this component.
+   */
+  constructor(options: ComponentOptions<Props>);
+  /**
+   * Queues a callback to run after the component's first browser mount.
+   *
+   * If the component is already mounted, the callback is ignored.
+   *
+   * @param callback Function to run after the initial mount commits.
+   */
+  mount(callback: MountCallback): void;
+  /**
+   * Schedules this component to rerender.
+   *
+   * Multiple updates in the same turn are batched. The optional callback runs
+   * after the update commits, unless the root has been unmounted.
+   *
+   * @param callback Function to run after the update commits.
+   */
+  update(callback?: UpdateCallback): void;
+}
+/**
+ * Checks whether a value is a Pudui component instance.
+ *
+ * @param value Value to inspect.
+ * @returns `true` when the value is a {@link Component}.
+ */
+declare function isComponent(value: unknown): value is Component;
+//#endregion
+//#region src/core.d.ts
+/**
+ * Stable identity used to reconcile siblings across renders.
+ *
+ * @example
+ * ```tsx
+ * items.map((item) => <li key={item.id}>{item.name}</li>);
+ * ```
+ */
+type Key = string | number;
+/**
+ * A child value that intentionally renders no markup.
+ *
+ * Empty children are useful for conditional JSX where one branch should
+ * disappear without leaving a text node.
+ *
+ * @example
+ * ```tsx
+ * <nav>{isSignedIn && <a href="/account">Account</a>}</nav>
+ * ```
+ */
+type EmptyChild = boolean | null | undefined;
+/**
+ * A scalar value that renders as escaped text.
+ *
+ * @example
+ * ```tsx
+ * <span>{messageCount}</span>
+ * ```
+ */
+type PrimitiveChild = string | number | bigint;
+/**
+ * Trusted HTML that should be inserted without escaping.
+ *
+ * Create raw children with the {@link Raw} component instead of constructing
+ * this object by hand.
+ *
+ * @example
+ * ```tsx
+ * <Raw>{"<strong>Already escaped upstream</strong>"}</Raw>
+ * ```
+ */
+type RawChild = {
+  readonly r: true;
+  readonly h: string;
+};
+/**
+ * Props accepted by {@link Raw}.
+ */
+type RawProps = {
+  /**
+   * Trusted HTML to render verbatim.
+   */
+  children?: string;
+};
+/**
+ * Callback that runs after a scheduled component update commits.
+ */
+type UpdateCallback = (this: void) => void;
+/**
+ * The public instance contract shared by stateful Pudui components.
+ */
+type ComponentInstance = {
+  /**
+   * Schedules the component to rerender.
+   *
+   * @param callback Function to run after the update commits.
+   */
+  update(callback?: UpdateCallback): void;
+};
+/**
+ * Any value that can be rendered by Pudui.
+ *
+ * Children may be nested arrays. Pudui flattens arrays and drops empty
+ * children during rendering.
+ *
+ * @example
+ * ```tsx
+ * const title: Child = ["Hello ", <strong>world</strong>];
+ * ```
+ */
+type Child = ComponentInstance | EmptyChild | PrimitiveChild | RawChild | VNode | readonly Child[];
+/**
+ * Base constraint for component props.
+ */
+type AnyProps = object;
+/**
+ * A component factory that receives its initial props.
+ *
+ * @example
+ * ```tsx
+ * const Counter: ComponentFactoryWithProps<{ start: number }> = (props) =>
+ *   new Component({ render: () => <button>{props.start}</button> });
+ * ```
+ */
+type ComponentFactoryWithProps<Props extends AnyProps = AnyProps> = (initialProps: Readonly<Props>) => Component<Props>;
+/**
+ * A component factory that does not require initial props.
+ */
+type ComponentFactoryWithoutProps<Props extends AnyProps = AnyProps> = () => Component<Props>;
+/**
+ * A function component constructor used as a JSX tag.
+ */
+type ComponentFactory<Props extends AnyProps = AnyProps> = ComponentFactoryWithProps<Props> | ComponentFactoryWithoutProps<Props>;
+/**
+ * A JSX tag target: either an intrinsic element name or a component factory.
+ */
+type RenderableType<Props extends AnyProps = AnyProps> = string | ComponentFactory<Props>;
+/**
+ * Assets that should be preloaded before hydrating a component boundary.
+ */
+type PreloadMetadata = {
+  /**
+   * JavaScript module URLs to emit as module preload links.
+   */
+  modulePreloads?: readonly string[];
+  /**
+   * Stylesheet URLs to emit as preload links.
+   */
+  stylePreloads?: readonly string[];
+};
+/**
+ * Resolves build-time hydration metadata into preloadable assets.
+ *
+ * Return `null` or `undefined` when the metadata cannot be resolved.
+ */
+type PreloadResolver = (meta: unknown) => PreloadMetadata | null | undefined;
+/**
+ * Any value that can appear in the JSX tag position.
+ */
+type ElementType<Props extends AnyProps = AnyProps> = RenderableType<Props> | typeof Fragment | typeof Raw;
+/**
+ * Object form for a JSX `style` prop.
+ *
+ * Values are serialized as CSS declarations, and `null` or `undefined` values
+ * are skipped.
+ *
+ * @example
+ * ```tsx
+ * <button style={{ backgroundColor: "black", opacity: disabled ? 0.5 : 1 }} />
+ * ```
+ */
+type StyleValue = Record<string, number | string | null | undefined>;
+/**
+ * Escaped hatch for setting an element's `innerHTML`.
+ *
+ * Prefer regular children. Use this only for trusted HTML.
+ *
+ * @example
+ * ```tsx
+ * <div dangerouslySetInnerHTML={{ __html: trustedHtml }} />
+ * ```
+ */
+type DangerouslySetInnerHTML = {
+  __html: string;
+};
+/**
+ * Cleanup returned by a ref callback.
+ */
+type RefCleanup = () => void;
+/**
+ * Callback ref invoked when an element is connected.
+ *
+ * Return a cleanup to run when the element is removed or replaced.
+ *
+ * @example
+ * ```tsx
+ * <input ref={(input) => {
+ *   input.focus();
+ *   return () => console.log("input removed");
+ * }} />
+ * ```
+ */
+type RefCallback<ElementType = Element> = (element: ElementType) => void | RefCleanup;
+/**
+ * A ref callback or a nested list of ref callbacks.
+ */
+type RefValue<ElementType = Element> = RefCallback<ElementType> | readonly RefValue<ElementType>[];
+/**
+ * Callback queued with {@link Component.mount}.
+ */
+type MountCallback = (this: void) => void;
+type UnsupportedEventAttributes = { [Name in `on${string}`]?: never };
+/**
+ * Props accepted by intrinsic JSX elements.
+ *
+ * Event attributes such as `onClick` are intentionally unsupported. Use the
+ * {@link event} helper from `pudui` with a `ref` when wiring DOM events.
+ *
+ * @example
+ * ```tsx
+ * <button class="primary" ref={event("click", onClick)}>Save</button>
+ * ```
+ */
+type IntrinsicElementProps<ElementType = Element> = UnsupportedEventAttributes & {
+  /**
+   * Element children.
+   */
+  children?: Child;
+  /**
+   * HTML class attribute.
+   */
+  class?: string;
+  /**
+   * Alias for the HTML class attribute.
+   */
+  className?: string;
+  /**
+   * Trusted HTML to set as element contents.
+   */
+  dangerouslySetInnerHTML?: DangerouslySetInnerHTML;
+  /**
+   * Stable identity for component and element reconciliation.
+   */
+  key?: Key;
+  /**
+   * Ref callback or callbacks for the rendered element.
+   */
+  ref?: RefValue<ElementType>;
+  /**
+   * Object-form inline style declarations.
+   */
+  style?: StyleValue;
+  [name: string]: unknown;
+};
+/**
+ * Infers a component's declared props when JSX type checking a tag.
+ */
+type ComponentPropsFor<Type, Props> = Type extends ((...args: readonly unknown[]) => Component<infer ComponentProps extends AnyProps>) ? ComponentProps : Props;
+/**
+ * Intrinsic JSX element map for HTML, SVG, and MathML tag names.
+ */
+type IntrinsicElementsByTagName = { [TagName in keyof HTMLElementTagNameMap]: IntrinsicElementProps<HTMLElementTagNameMap[TagName]> } & { [TagName in Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>]: IntrinsicElementProps<SVGElementTagNameMap[TagName]> } & { [TagName in Exclude<keyof MathMLElementTagNameMap, keyof HTMLElementTagNameMap | keyof SVGElementTagNameMap>]: IntrinsicElementProps<MathMLElementTagNameMap[TagName]> };
+/**
+ * Options used to construct a {@link Component}.
+ *
+ * @example
+ * ```tsx
+ * const component = new Component({
+ *   render: () => <p>Hello</p>,
+ * });
+ * ```
+ */
+type ComponentOptions<Props extends AnyProps> = {
+  /**
+   * Renders fallback content when {@link render} throws.
+   *
+   * @param props Current component props.
+   * @param reason The thrown error or rejection reason.
+   * @returns Fallback child content.
+   */
+  error?(this: void, props: Readonly<Props>, reason: unknown): Child;
+  /**
+   * Metadata consumed by the hydration macros and Vite runtime.
+   */
+  hydrate?: unknown;
+  /**
+   * Renders the component's current child tree.
+   *
+   * @param props Current component props.
+   * @returns Child content for this render pass.
+   */
+  render(this: void, props: Readonly<Props>): Child;
+};
+/**
+ * Virtual node produced by JSX for host elements and component tags.
+ */
+type VNode<Props extends AnyProps = AnyProps> = {
+  /**
+   * Host tag name or component factory.
+   */
+  readonly type: RenderableType<Props>;
+  /**
+   * Props captured for the render target.
+   */
+  readonly props: Readonly<Props & IntrinsicElementProps>;
+  /**
+   * Optional reconciliation key.
+   */
+  readonly key?: Key;
+};
+declare global {
+  namespace JSX {
+    type Element = Child;
+    interface ElementChildrenAttribute {
+      children: unknown;
+    }
+    type LibraryManagedAttributes<ComponentType, Props> = ComponentPropsFor<ComponentType, Props>;
+    interface IntrinsicAttributes {
+      key?: Key;
+    }
+    interface IntrinsicElements extends IntrinsicElementsByTagName {
+      [elementName: string]: IntrinsicElementProps<any>;
+    }
+  }
+}
+/**
+ * Internal marker range and props for a server-rendered hydration boundary.
+ */
+//#endregion
+export { Fragment as A, RefValue as C, VNode as D, UpdateCallback as E, jsxDEV as F, createElement as M, isVNode as N, Component as O, jsx as P, RefCleanup as S, StyleValue as T, PreloadResolver as _, ComponentFactoryWithoutProps as a, RawProps as b, ComponentPropsFor as c, EmptyChild as d, IntrinsicElementProps as f, PreloadMetadata as g, MountCallback as h, ComponentFactoryWithProps as i, Raw as j, isComponent as k, DangerouslySetInnerHTML as l, Key as m, Child as n, ComponentInstance as o, IntrinsicElementsByTagName as p, ComponentFactory as r, ComponentOptions as s, AnyProps as t, ElementType as u, PrimitiveChild as v, RenderableType as w, RefCallback as x, RawChild as y };

package/dist/hmr-runtime.d.mts

@@ -0,0 +1,99 @@
+import { O as Component, i as ComponentFactoryWithProps, s as ComponentOptions, t as AnyProps } from "./core-Cypb6mR9.mjs";
+
+//#region src/hmr-runtime.d.ts
+/**
+ * Mutable state cell preserved across compatible HMR updates.
+ */
+type RefreshCell<Value> = {
+  /**
+   * Current cell value.
+   */
+  value: Value;
+};
+/**
+ * Component options that can be replaced during HMR.
+ */
+type RefreshComponentOptions<Props extends AnyProps> = Pick<ComponentOptions<Props>, "error" | "hydrate" | "render">;
+/**
+ * Utilities passed to a transformed component setup function.
+ */
+type RefreshContext<Props extends AnyProps> = {
+  /**
+   * Reads or initializes a state cell that can survive hot updates.
+   *
+   * @param key Stable key for this cell within the component.
+   * @param initialize Function used to create the cell value the first time.
+   * @returns The preserved refresh cell.
+   */
+  cell<Value>(key: string, initialize: () => Value): RefreshCell<Value>;
+  /**
+   * Creates or updates the component instance for this refresh record.
+   *
+   * @param options Component options for the current module version.
+   * @returns The component instance associated with the refresh record.
+   */
+  component<ComponentProps extends AnyProps = Props>(options: RefreshComponentOptions<ComponentProps>): Component<ComponentProps>;
+};
+/**
+ * Setup function generated by the HMR transform for a component factory.
+ */
+type RefreshSetup<Props extends AnyProps> = (refresh: RefreshContext<Props>, initialProps: Readonly<Props>) => Component<Props>;
+type HmrImportMeta = {
+  hot?: {
+    data: Record<string, unknown>;
+    invalidate?(message?: string): void;
+  };
+};
+type RefreshVersion<Props extends AnyProps> = {
+  setup: RefreshSetup<Props>;
+  signature: string;
+};
+type RefreshInstance<Props extends AnyProps> = {
+  cells: Map<string, RefreshCell<unknown>>;
+  component?: Component<AnyProps>;
+  initialProps: Readonly<Props>;
+  lastProps?: Readonly<AnyProps>;
+  options?: RefreshComponentOptions<AnyProps>;
+};
+type RefreshFactory<Props extends AnyProps> = ComponentFactoryWithProps<Props> & {
+  [recordProperty]?: RefreshRecord<Props>;
+};
+type RefreshRecord<Props extends AnyProps> = RefreshVersion<Props> & {
+  exported: boolean;
+  exportName: string;
+  factory: RefreshFactory<Props>;
+  instances: Set<RefreshInstance<Props>>;
+  pending?: RefreshVersion<Props>;
+  pendingExported?: boolean;
+};
+type RegisterOptions = {
+  exported?: boolean;
+};
+declare const recordProperty = "__puduiHmrRecord";
+/**
+ * Registers a component factory with the Pudui HMR runtime.
+ *
+ * This is emitted by the HMR transform. Application code should normally use
+ * the Vite plugin rather than calling it directly.
+ *
+ * @param importMeta Module `import.meta` object.
+ * @param id Stable module identifier.
+ * @param exportName Name of the export being registered.
+ * @param signature Signature for the component's preserved state shape.
+ * @param setup Setup function for the current module version.
+ * @param options Registration options.
+ * @returns A component factory that keeps its refresh record across updates.
+ */
+declare function register<Props extends AnyProps>(importMeta: HmrImportMeta, id: string, exportName: string, signature: string, setup: RefreshSetup<Props>, options?: RegisterOptions): RefreshFactory<Props>;
+/**
+ * Accepts a hot module update and refreshes registered components.
+ *
+ * If an export changed shape in a way Pudui cannot refresh safely, the runtime
+ * asks Vite to invalidate the module instead.
+ *
+ * @param importMeta Module `import.meta` object for the updated module.
+ * @param nextModule The next module namespace provided by Vite HMR.
+ */
+declare function accept(importMeta: HmrImportMeta, nextModule: unknown): void;
+//#endregion
+export { RefreshCell, RefreshComponentOptions, RefreshContext, RefreshSetup, accept, register };

package/dist/hmr-runtime.mjs

@@ -0,0 +1,177 @@
+import { t as Component } from "./component-D3kwgmef.mjs";
+//#region src/hmr-runtime.ts
+const globalRegistryKey = "__puduiHmrRegistry";
+const moduleDataKey = "__puduiHmr";
+const recordProperty = "__puduiHmrRecord";
+/**
+* Registers a component factory with the Pudui HMR runtime.
+*
+* This is emitted by the HMR transform. Application code should normally use
+* the Vite plugin rather than calling it directly.
+*
+* @param importMeta Module `import.meta` object.
+* @param id Stable module identifier.
+* @param exportName Name of the export being registered.
+* @param signature Signature for the component's preserved state shape.
+* @param setup Setup function for the current module version.
+* @param options Registration options.
+* @returns A component factory that keeps its refresh record across updates.
+*/
+function register(importMeta, id, exportName, signature, setup, options = {}) {
+	const moduleData = ensureModuleData(importMeta, id);
+	const registryKey = recordKey(id, exportName);
+	const exported = options.exported ?? true;
+	let record = moduleData?.records.get(exportName) ?? refreshRegistry().get(registryKey);
+	if (record === void 0) {
+		record = createRecord(exportName, signature, setup, exported);
+		refreshRegistry().set(registryKey, record);
+	} else if (importMeta.hot) {
+		record.pending = {
+			setup,
+			signature
+		};
+		record.pendingExported = exported;
+	} else {
+		record.exported = exported;
+		replaceRecord(record, {
+			setup,
+			signature
+		});
+	}
+	moduleData?.records.set(exportName, record);
+	return record.factory;
+}
+/**
+* Accepts a hot module update and refreshes registered components.
+*
+* If an export changed shape in a way Pudui cannot refresh safely, the runtime
+* asks Vite to invalidate the module instead.
+*
+* @param importMeta Module `import.meta` object for the updated module.
+* @param nextModule The next module namespace provided by Vite HMR.
+*/
+function accept(importMeta, nextModule) {
+	const moduleData = readModuleData(importMeta);
+	if (moduleData === void 0) return;
+	if (!isObject(nextModule)) {
+		invalidate(importMeta, `Unable to refresh ${moduleData.id}.`);
+		return;
+	}
+	const updates = [];
+	for (const [exportName, record] of moduleData.records) {
+		const nextVersion = record.exported ? readRecord(nextModule[exportName])?.pending : record.pending;
+		if (nextVersion === void 0) {
+			invalidate(importMeta, `Unable to refresh ${moduleData.id} because export "${exportName}" changed shape.`);
+			return;
+		}
+		updates.push(() => {
+			record.exported = record.pendingExported ?? record.exported;
+			replaceRecord(record, nextVersion);
+		});
+	}
+	for (const update of updates) update();
+}
+function createRecord(exportName, signature, setup, exported) {
+	let record;
+	const factory = ((initialProps) => {
+		const props = initialProps ?? {};
+		const instance = {
+			cells: /* @__PURE__ */ new Map(),
+			initialProps: props
+		};
+		const component = record.setup(createRefreshContext(instance), props);
+		if (component !== instance.component) throw new TypeError("Refresh setup must return the Component created through refresh.component().");
+		record.instances.add(instance);
+		return component;
+	});
+	record = {
+		exported,
+		exportName,
+		factory,
+		instances: /* @__PURE__ */ new Set(),
+		setup,
+		signature
+	};
+	Object.defineProperty(factory, recordProperty, { value: record });
+	return record;
+}
+function replaceRecord(record, next) {
+	const preserveCells = next.signature === record.signature;
+	record.pending = void 0;
+	record.pendingExported = void 0;
+	record.setup = next.setup;
+	record.signature = next.signature;
+	for (const instance of record.instances) {
+		if (!preserveCells) instance.cells.clear();
+		if (record.setup(createRefreshContext(instance), instance.lastProps ?? instance.initialProps) !== instance.component) throw new TypeError("Refresh setup must return the Component created through refresh.component().");
+		instance.component?.update();
+	}
+}
+function createRefreshContext(instance) {
+	return {
+		cell(key, initialize) {
+			const existing = instance.cells.get(key);
+			if (existing !== void 0) return existing;
+			const cell = { value: initialize() };
+			instance.cells.set(key, cell);
+			return cell;
+		},
+		component(options) {
+			const typedOptions = options;
+			instance.options = typedOptions;
+			if (instance.component !== void 0) return instance.component;
+			const component = new Component({
+				error(props, reason) {
+					instance.lastProps = props;
+					if (instance.options?.error === void 0) throw reason;
+					return instance.options.error(props, reason);
+				},
+				hydrate: typedOptions.hydrate,
+				render(props) {
+					instance.lastProps = props;
+					return instance.options?.render(props) ?? null;
+				}
+			});
+			instance.component = component;
+			return component;
+		}
+	};
+}
+function ensureModuleData(importMeta, id) {
+	if (!importMeta.hot) return;
+	const existing = importMeta.hot.data[moduleDataKey];
+	if (isModuleData(existing) && existing.id === id) return existing;
+	const moduleData = {
+		id,
+		records: /* @__PURE__ */ new Map()
+	};
+	importMeta.hot.data[moduleDataKey] = moduleData;
+	return moduleData;
+}
+function readModuleData(importMeta) {
+	const value = importMeta.hot?.data[moduleDataKey];
+	return isModuleData(value) ? value : void 0;
+}
+function isModuleData(value) {
+	return isObject(value) && typeof value.id === "string" && value.records instanceof Map;
+}
+function readRecord(value) {
+	if (typeof value !== "function") return;
+	return value[recordProperty];
+}
+function refreshRegistry() {
+	const root = globalThis;
+	root[globalRegistryKey] ??= /* @__PURE__ */ new Map();
+	return root[globalRegistryKey];
+}
+function recordKey(id, exportName) {
+	return `${id}\u0000${exportName}`;
+}
+function invalidate(importMeta, message) {
+	importMeta.hot?.invalidate?.(message);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+export { accept, register };