@elurjs/core 3.6.1 → 3.7.0-beta.0

package/dist/lib/elur/next-2/component.d.ts

@@ -0,0 +1,283 @@
+/**
+ * Elur "next" — kernel unificado de componentes (experimental).
+ *
+ * Implementa A.6–A.9 del PLAN_TECNICO_ELUR_NEXT sobre el ownership de
+ * `./reactivity.ts`:
+ *  - Una sola `ComponentInstance` para clases y funciones (adaptadores).
+ *  - Máquina de estados (A.7): created → initializing → rendering →
+ *    pending-mount → mounted → disposing → disposed (o failed).
+ *  - Mount transaccional (A.9): cualquier fallo dispara rollback —
+ *    cleanups registrados, owner reactivo disposed, DOM insertado removido.
+ *  - `unmount()` idempotente (A.2.10).
+ *  - `onMount` corre DESPUÉS del commit DOM (A.2.9).
+ *  - Todo lo creado en setup/render pertenece al owner de la instancia y
+ *    muere con unmount (A.2.1 — no más effects huérfanos).
+ *
+ * Las invocaciones implementan `ELUR_RENDER_PROTOCOL.mountDom`, así el
+ * renderer existente las monta sin saber que son componentes.
+ */
+import { Owner, Signal, type Disposable, type OwnerLike } from "./reactivity.js";
+import { type ElurComponent, type ComponentController } from "../lifecycle.js";
+import { ELUR_RENDER_PROTOCOL, type DomProtocolContext } from "../template/types.js";
+export type ComponentState = "created" | "initializing" | "rendering" | "pending-mount" | "mounted" | "deactivated" | "disposing" | "disposed" | "failed";
+/** Fase del lifecycle donde ocurrió el error. */
+export type ErrorPhase = "setup" | "init" | "render" | "hydrate" | "mount" | "effect" | "activate" | "deactivate" | "cleanup" | "unmount";
+/** Información estructurada del error (A.16). */
+export interface ComponentErrorInfo {
+    phase: ErrorPhase;
+    /** Instancia donde ocurrió el error (no la boundary que lo maneja). */
+    component: ComponentInstance;
+    cause: unknown;
+}
+/** Resolución de una boundary (A.16). */
+export type ErrorResolution = {
+    handled: false;
+} | {
+    handled: true;
+    fallback?: Renderable;
+} | {
+    handled: true;
+    retry: true;
+};
+export interface ComponentHooks {
+    /** Tras el commit DOM. Puede devolver cleanup (corre en unmount). */
+    onMount?: () => (() => void) | void;
+    /** Antes de remover el DOM. */
+    onUnmount?: () => void;
+    /**
+     * Boundary de errores (A.16): recibe info estructurada; el error burbujea
+     * por la cadena de instancias hasta una boundary que devuelva handled.
+     * `void` = manejado sin más.
+     */
+    onError?: (info: ComponentErrorInfo) => ErrorResolution | void;
+    /** A.17: tras setup durante SSR — nunca en cliente. */
+    onServerRender?: () => void;
+}
+/** Contexto que recibe el setup de un componente funcional. */
+export interface SetupCtx {
+    onMount(fn: () => (() => void) | void): void;
+    onUnmount(fn: () => void): void;
+    onError(fn: (info: ComponentErrorInfo) => ErrorResolution | void): void;
+    /** A.17: hook server-side — corre tras setup durante SSR, nunca en cliente. */
+    onServerRender(fn: () => void): void;
+    /** Owner de la instancia — para runWithOwner/getOwner manual. */
+    readonly owner: OwnerLike;
+    /** Señal interna de una prop (A.13) — para acceso reactivo explícito. */
+    propSignal<K extends string>(key: K): Signal<unknown> | undefined;
+    /**
+     * A.14: renderiza el contenido de un slot (lazy — corre el render del
+     * slot bajo el owner del padre que lo declaró). `"default"` por defecto.
+     */
+    slot(name?: string): unknown;
+    /** A.14: slots declarados en la invocación. */
+    readonly slots: Record<string, Slot> | undefined;
+}
+interface RenderableValue {
+    _render(parent: Node, before: Node | null): () => void;
+}
+/** Renderable común: cualquier cosa montable en un binding. */
+export type Renderable = ElurComponent | ComponentInvocation<unknown> | Slot | {
+    _render(parent: Node, before: Node | null): () => void;
+} | string | number | bigint | false | null | undefined | Renderable[];
+/**
+ * Slot lazy y marcado (A.14): el contenido se renderiza bajo el owner del
+ * padre que LO DECLARÓ (contexto léxico), aunque se monte dentro del
+ * componente consumidor.
+ */
+export interface Slot {
+    readonly __isElurSlot: true;
+    /** Owner capturado en el punto de declaración (contexto léxico). */
+    readonly owner: OwnerLike | null;
+    render(): unknown;
+}
+export declare function slot(render: () => unknown): Slot;
+export declare function isElurSlot(v: unknown): v is Slot;
+export declare class ComponentInstance implements Disposable {
+    readonly id: number;
+    readonly kind: "class" | "function";
+    state: ComponentState;
+    /** Owner reactivo de la instancia — todo lo creado dentro muere con él. */
+    readonly owner: Owner;
+    /** Instancia padre (owner activo cuando se creó esta instancia). */
+    parent: ComponentInstance | null;
+    hooks: ComponentHooks;
+    renderable: RenderableValue | null;
+    /** A.12: frame de provide/inject propio de la instancia — permanente. */
+    readonly context: Map<unknown, unknown>;
+    private _inst;
+    private _invocation;
+    private _renderCleanup;
+    private _mountCleanups;
+    /** A.13: señales internas por prop + objeto live pasado al setup. */
+    private _propSignals;
+    private _liveProps;
+    /** A.16: fase actual del lifecycle — para el ComponentErrorInfo. */
+    private _phase;
+    /** A.16: posición de montaje — para renderizar fallback de boundary. */
+    private _mountParent;
+    private _mountBefore;
+    /** A.3.8: nodos DOM de la instancia — para detach/attach. */
+    private _domNodes;
+    /** A.21: controllers de ciclo de vida (Lit-style). */
+    private _controllers;
+    constructor(source: ElurComponent | ComponentInvocation<any>);
+    /**
+     * Mount transaccional (A.9). Cualquier fase que falle → rollback completo:
+     * owner disposed, cleanups corridos, DOM insertado removido, state=failed.
+     *
+     * Opciones:
+     *  - `ctxSnapshot`: contexto capturado en el punto de declaración
+     *    (mounts dentro de effects dinámicos heredan provide/inject).
+     *  - `deferOnMount`: recibe una función `fire()` que corre onMount; el
+     *    caller decide cuándo invocarla (fragments aún no insertados).
+     */
+    mount(parent: Node, before: Node | null, opts?: {
+        ctxSnapshot?: Map<unknown, unknown>[];
+        deferOnMount?: (fire: () => void) => void;
+        /** Valores a proveer en el frame de contexto de la instancia (A.12). */
+        provides?: Iterable<readonly [unknown, unknown]>;
+        /**
+         * A.14: owner del declarante — para contenido de slots, el owner padre
+         * es el del padre que declaró el contenido, no el del punto de montaje.
+         */
+        declOwner?: OwnerLike | null;
+    }): void;
+    /** A.21: registra un controller — sus hooks corren bajo este owner. */
+    addController(c: ComponentController): void;
+    /**
+     * A.3.8: saca el DOM de la instancia SIN disponer nada — effects, signals
+     * y contexto siguen vivos (página cached, Suspense, transición). No-op si
+     * no está montado.
+     */
+    detach(): void;
+    /**
+     * A.3.8: reinserta el DOM de una instancia detached en la posición original
+     * (o en parent/before dados). No-op si no está deactivated.
+     */
+    attach(parent?: Node, before?: Node | null): void;
+    /** Idempotente (A.2.10): disponer dos veces es seguro. */
+    unmount(): void;
+    dispose(): void;
+    /** @internal — corre onMount una vez; no-op si ya no está montado. */
+    _runOnMount(): void;
+    /**
+     * @internal A.16: intenta manejar el error con el boundary propio.
+     * `null` = este nodo no tiene boundary — seguir subiendo.
+     */
+    _handleError(info: ComponentErrorInfo): ErrorResolution | null;
+    /** A.16: errores de teardown — se reportan a la cadena; si nadie los maneja quedan registrados. */
+    private _reportSwallowed;
+    /** A.16: renderiza el fallback de una boundary en la posición del componente. */
+    private _renderFallback;
+    /** Camina la cadena de owners hasta la instancia registrada más cercana. */
+    private _resolveParent;
+    private _rollback;
+    private _makeSetupCtx;
+    /** Fases initializing+rendering: setup/onInit + render → this.renderable. */
+    private _initBody;
+    /** Corre `body` dentro del frame de contexto (snapshot o frame nuevo). */
+    private _withScope;
+    /**
+     * A.18 — hidratación: setup/onInit + render una sola vez, luego adopta el
+     * DOM SSR via ctx.render (que activa bindings dentro del owner de la
+     * instancia). En mismatch: rollback de la activación + remount por el mismo
+     * kernel REUSANDO el renderable — setup/onInit no se duplica.
+     */
+    _hydrate(ctx: {
+        parent: Node;
+        bounds: {
+            start: Comment;
+            end: Comment;
+        } | null;
+        render(value: unknown): unknown;
+        /** "throw" propaga el mismatch en vez de remontar (HydrateOptions). */
+        mismatch?: "throw" | "warn-remount" | "remount";
+    }): void;
+    /**
+     * A.17 — SSR: setup/onInit + onServerRender + serializar el renderable.
+     * NO corre onMount/onUnmount; el owner server-side se dispone al final
+     * (mata effects/computeds creados en setup).
+     */
+    _renderServer(sctx: {
+        markers?: boolean;
+        render(value: unknown, options?: {
+            markers?: boolean;
+        }): string | Promise<string>;
+    }): Promise<string>;
+    /**
+     * A.13 — crea el objeto LiveProps: propiedades readonly respaldadas por
+     * signals. OJO: destructurar props en setup crea snapshots no reactivos.
+     */
+    private _initProps;
+    /**
+     * A.13/A.15 — true si `inv` es la misma definición con la misma key:
+     * entonces el runtime debe actualizar props, no recrear el setup.
+     */
+    matches(inv: ComponentInvocation<any>): boolean;
+    /**
+     * A.13 — actualiza props sin recrear setup: escribe cada signal de prop.
+     * Props nuevas se añaden; props desaparecidas quedan en undefined.
+     */
+    updateProps(props: unknown): void;
+}
+/**
+ * A.16: burbujeo de errores por la cadena de instancias (padres reales del
+ * árbol de componentes). Devuelve la primera resolución manejada; si nadie
+ * maneja el error, `{ handled: false }` y el caller decide (re-lanzar o
+ * registrar).
+ */
+export declare function reportError(from: ComponentInstance, info: ComponentErrorInfo): ErrorResolution;
+/** Envuelve un ElurComponent de clase en el kernel unificado. */
+export declare function adaptClassComponent(inst: ElurComponent): ComponentInstance;
+export interface ComponentDefinition<P> {
+    (props?: P, slots?: Record<string, Slot>): ComponentInvocation<P>;
+    readonly setup: (props: P | undefined, ctx: SetupCtx) => unknown;
+    readonly _isComponentDefinition: true;
+}
+/** Invocación marcada: `Counter({ initial: 10 })` NO ejecuta setup — monta después. */
+export declare class ComponentInvocation<P> {
+    readonly [ELUR_RENDER_PROTOCOL]: {
+        mountDom: (ctx: DomProtocolContext) => (() => void);
+        renderServer: (sctx: {
+            markers?: boolean;
+            render(value: unknown, options?: {
+                markers?: boolean;
+            }): string | Promise<string>;
+        }) => Promise<string>;
+        hydrateDom: (ctx: {
+            parent: Node;
+            bounds: {
+                start: Comment;
+                end: Comment;
+            } | null;
+            render(value: unknown): unknown;
+        }) => (() => void);
+    };
+    readonly definition: ComponentDefinition<P>;
+    readonly props: P | undefined;
+    /** A.14: slots declarados en la llamada — `Card(props, { default: slot(...) })`. */
+    readonly slots: Record<string, Slot> | undefined;
+    constructor(definition: ComponentDefinition<P>, props: P | undefined, slots?: Record<string, Slot>);
+}
+export declare function isComponentInvocation(v: unknown): v is ComponentInvocation<any>;
+/**
+ * @internal — registra un frame de contexto para un owner raíz (mount de
+ * template con router, roots de app, etc).
+ */
+export declare function _registerContextOwner(owner: OwnerLike, context: Map<unknown, unknown>): void;
+/**
+ * Define un componente funcional de primera clase (A.5):
+ * `Counter(props)` retorna una invocación marcada; el runtime ejecuta el
+ * setup cuando monta la invocación.
+ */
+export declare function defineComponent<P = Record<string, never>>(setup: (props: P | undefined, ctx: SetupCtx) => unknown): ComponentDefinition<P>;
+/**
+ * Monta un componente (clase o invocación funcional) en `container` y
+ * devuelve el handle con `unmount()`. Todo el árbol reactivo muere con el
+ * unmount — sin fugas de effects/computeds.
+ */
+export declare function mountComponent(value: ElurComponent | ComponentInvocation<any>, container: Element): {
+    unmount(): void;
+    instance: ComponentInstance;
+};
+export {};

package/dist/lib/elur/next-2/component.js

@@ -0,0 +1,340 @@
+import { Owner as e, getOwner as t, runWithOwner as n, signal as r } from "./reactivity.js";
+import { ELUR_RENDER_PROTOCOL as i, isElurTemplate as a } from "../template/types.js";
+import { _debugComponentMountEnd as o, _debugComponentMountStart as s, _debugComponentUnmount as c, isElurComponent as l } from "../../lifecycle.js";
+import { _popComponentContext as u, _pushComponentContext as d, _pushContextScopeResolver as f, _withComponentContext as p } from "../../context.js";
+//#region src/elur/next-2/component.ts
+function m(e) {
+	return a(e) ? e : null;
+}
+function h(e) {
+	return typeof e == "object" && !!e && e.__isElurSlot === !0;
+}
+var g = 1, _ = class i {
+	id = g++;
+	kind;
+	state = "created";
+	owner = new e();
+	parent = null;
+	hooks = {};
+	renderable = null;
+	context = /* @__PURE__ */ new Map();
+	_inst = null;
+	_invocation = null;
+	_renderCleanup = null;
+	_mountCleanups = null;
+	_propSignals = null;
+	_liveProps = null;
+	_phase = "setup";
+	_mountParent = null;
+	_mountBefore = null;
+	_domNodes = null;
+	_controllers = null;
+	constructor(e) {
+		l(e) ? (this.kind = "class", this._inst = e) : (this.kind = "function", this._invocation = e), this.owner.onOwnerError = (e) => v(this, {
+			phase: "effect",
+			component: this,
+			cause: e
+		}).handled;
+	}
+	mount(e, r, a) {
+		if (this.state !== "created") throw Error(`[elur-next] ComponentInstance.mount(): estado inválido "${this.state}" (una instancia montada no puede montarse otra vez).`);
+		if (S.set(this.owner, this), C.set(this.owner, this.context), this._resolveParent(), this.owner.parent = a?.declOwner === void 0 ? t() : a.declOwner, a?.provides) for (let [e, t] of a.provides) this.context.set(e, t);
+		this._mountParent = e, this._mountBefore = r;
+		let c = !l(this._inst), u = this;
+		c && s(u);
+		let d = r ? Array.prototype.indexOf.call(e.childNodes, r) : e.childNodes.length;
+		try {
+			this.state = "initializing", n(this.owner, () => this._withScope(a?.ctxSnapshot, () => {
+				if (this._initBody(), this._inst?._controllers) for (let e of this._inst._controllers) this.addController(e);
+				if (this._controllers) for (let e of this._controllers) e.hostInit?.();
+				this._phase = "mount", this.state = "pending-mount", this._renderCleanup = this.renderable._render(e, r);
+				let t = r ? Array.prototype.indexOf.call(e.childNodes, r) : e.childNodes.length;
+				this._domNodes = Array.prototype.slice.call(e.childNodes, d, t);
+			})), this.state = "mounted";
+			let t = () => this._runOnMount();
+			a?.deferOnMount ? a.deferOnMount(t) : t();
+		} catch (t) {
+			this._rollback();
+			let n = v(this, {
+				phase: this._phase,
+				component: this,
+				cause: t
+			});
+			if (!n.handled) throw t;
+			"retry" in n && n.retry ? new i(this._inst ?? this._invocation).mount(e, r, a) : "fallback" in n && n.fallback !== void 0 && this._renderFallback(n.fallback, e, r);
+		} finally {
+			c && o(u);
+		}
+	}
+	addController(e) {
+		(this._controllers ??= []).push(e);
+	}
+	detach() {
+		if (this.state !== "mounted" || !this._domNodes) return;
+		let e = document.createDocumentFragment();
+		for (let t of this._domNodes) e.appendChild(t);
+		this.state = "deactivated", this._controllers && n(this.owner, () => {
+			for (let e of this._controllers) e.hostDeactivate?.();
+		});
+	}
+	attach(e, t) {
+		if (this.state !== "deactivated" || !this._domNodes) return;
+		let r = e ?? this._mountParent, i = t === void 0 ? this._mountBefore : t;
+		if (r) {
+			for (let e of this._domNodes) r.insertBefore(e, i);
+			this.state = "mounted", this._controllers && n(this.owner, () => {
+				for (let e of this._controllers) e.hostActivate?.();
+			});
+		}
+	}
+	unmount() {
+		if (this.state !== "created" && !(this.state === "disposing" || this.state === "disposed")) {
+			if (this.state === "failed") {
+				this.state = "disposed";
+				return;
+			}
+			this.state === "deactivated" && (this._domNodes = null), this.state = "disposing", l(this._inst) || c(this);
+			try {
+				n(this.owner, () => {
+					if (this.hooks.onUnmount?.call(this._inst ?? void 0), this._inst?.onUnmount?.(), this._controllers) for (let e of this._controllers) e.hostUnmount?.();
+				});
+			} catch (e) {
+				this._reportSwallowed(e, "unmount");
+			}
+			if (this._mountCleanups) {
+				for (let e of this._mountCleanups) try {
+					e();
+				} catch (e) {
+					this._reportSwallowed(e, "cleanup");
+				}
+				this._mountCleanups = null;
+			}
+			this.owner.dispose();
+			try {
+				this._renderCleanup?.();
+			} finally {
+				this._renderCleanup = null, this.state = "disposed";
+			}
+		}
+	}
+	dispose() {
+		this.unmount();
+	}
+	_runOnMount() {
+		if (this.state === "mounted") try {
+			let e = n(this.owner, () => {
+				let e = this.kind === "class" ? this._inst.onMount?.() : this.hooks.onMount?.();
+				if (this._controllers) for (let e of this._controllers) e.hostMounted?.();
+				return e;
+			});
+			typeof e == "function" && (this._mountCleanups ??= []).push(e);
+		} catch (e) {
+			this._rollback();
+			let t = v(this, {
+				phase: "mount",
+				component: this,
+				cause: e
+			});
+			if (!t.handled) throw e;
+			"fallback" in t && t.fallback !== void 0 && this._renderFallback(t.fallback, this._mountParent, this._mountBefore);
+		}
+	}
+	_handleError(e) {
+		if (this.kind === "function" && this.hooks.onError) {
+			let t = this.hooks.onError(e);
+			return t === void 0 ? { handled: !0 } : t;
+		}
+		return this.kind === "class" && this._inst?.onError ? (this._inst.onError(e.cause), { handled: !0 }) : null;
+	}
+	_reportSwallowed(e, t) {
+		v(this, {
+			phase: t,
+			component: this,
+			cause: e
+		}).handled || console.error("[elur-next] error en " + t + ":", e);
+	}
+	_renderFallback(e, t, n) {
+		let r = m(e);
+		if (r) r._render(t, n);
+		else if (typeof e == "string" || typeof e == "number") t.insertBefore(document.createTextNode(String(e)), n);
+		else if (Array.isArray(e)) for (let r of e) this._renderFallback(r, t, n);
+		else e && new i(e).mount(t, n);
+	}
+	_resolveParent() {
+		let e = t();
+		for (; e;) {
+			let t = S.get(e);
+			if (t) {
+				this.parent = t;
+				return;
+			}
+			e = e.parent;
+		}
+	}
+	_rollback() {
+		this.owner.dispose();
+		try {
+			this._renderCleanup?.();
+		} finally {
+			this._renderCleanup = null, this.state = "failed";
+		}
+	}
+	_makeSetupCtx() {
+		let e = this;
+		return {
+			owner: this.owner,
+			onMount(t) {
+				e.hooks.onMount = t;
+			},
+			onUnmount(t) {
+				e.hooks.onUnmount = t;
+			},
+			onError(t) {
+				e.hooks.onError = t;
+			},
+			onServerRender(t) {
+				e.hooks.onServerRender = t;
+			},
+			propSignal(t) {
+				return e._propSignals?.get(t);
+			},
+			slots: this._invocation?.slots,
+			slot(t = "default") {
+				return e._invocation?.slots?.[t];
+			}
+		};
+	}
+	_initBody() {
+		if (this.kind === "class") {
+			let e = this._inst;
+			this._phase = "init", e.onInit?.(), this._phase = "render", this.state = "rendering", this.renderable = m(e.render());
+		} else {
+			let e = this._invocation, t = this._makeSetupCtx();
+			this._phase = "setup", this.state = "rendering", this.renderable = m(e.definition.setup(this._initProps(e.props), t));
+		}
+		if (!this.renderable) throw Error(`[elur-next] El componente #${this.id} no produjo un template renderizable.`);
+	}
+	_withScope(e, t) {
+		if (e) p(e, t);
+		else {
+			d();
+			try {
+				t();
+			} finally {
+				u();
+			}
+		}
+	}
+	_hydrate(e) {
+		if (this.state !== "created") throw Error(`[elur-next] _hydrate(): estado inválido "${this.state}".`);
+		S.set(this.owner, this), C.set(this.owner, this.context), this._resolveParent(), this.owner.parent = t();
+		try {
+			this.state = "initializing";
+			let t;
+			n(this.owner, () => this._withScope(void 0, () => {
+				this._initBody(), this.state = "pending-mount", t = e.render(this.renderable);
+			})), this._renderCleanup = typeof t == "function" ? t : null, this.state = "mounted", this._runOnMount();
+		} catch (t) {
+			if (e.mismatch === "throw") throw t;
+			e.mismatch !== "remount" && console.warn("[elur] Hydration mismatch en componente; remounting:", t), this.owner.dispose();
+			let r = this.renderable;
+			this.state = "initializing", n(this.owner, () => this._withScope(void 0, () => {
+				r || this._initBody(), this.state = "pending-mount", this._renderCleanup = this.renderable._render(e.parent, e.bounds?.end ?? null);
+			})), this.state = "mounted", this._runOnMount();
+		}
+	}
+	async _renderServer(e) {
+		this.state = "initializing", S.set(this.owner, this), C.set(this.owner, this.context), this._resolveParent(), this.owner.parent = t(), n(this.owner, () => this._withScope(void 0, () => {
+			this._initBody(), this.kind === "class" ? this._inst.onServerRender?.() : this.hooks.onServerRender?.();
+		}));
+		try {
+			return await e.render(this.renderable, { markers: e.markers });
+		} finally {
+			this.owner.dispose(), this.state = "disposed";
+		}
+	}
+	_initProps(e) {
+		if (this._propSignals = /* @__PURE__ */ new Map(), this._liveProps = {}, typeof e == "object" && e) for (let [t, n] of Object.entries(e)) {
+			if (t === "key") continue;
+			let e = r(n);
+			this._propSignals.set(t, e), Object.defineProperty(this._liveProps, t, {
+				enumerable: !0,
+				get: () => e.value
+			});
+		}
+		return this._liveProps;
+	}
+	matches(e) {
+		if (this.kind !== "function" || !this._invocation) return !1;
+		let t = (e) => typeof e == "object" && e ? e.key : void 0;
+		return e.definition === this._invocation.definition && t(e.props) === t(this._invocation.props);
+	}
+	updateProps(e) {
+		if (!this._propSignals || !this._liveProps) return;
+		let t = /* @__PURE__ */ new Set();
+		if (typeof e == "object" && e) for (let [n, i] of Object.entries(e)) {
+			if (n === "key") continue;
+			t.add(n);
+			let e = this._propSignals.get(n);
+			if (e) e.value = i;
+			else {
+				let e = r(i);
+				this._propSignals.set(n, e), Object.defineProperty(this._liveProps, n, {
+					enumerable: !0,
+					get: () => e.value
+				});
+			}
+		}
+		for (let e of this._propSignals.keys()) t.has(e) || (this._propSignals.get(e).value = void 0);
+	}
+};
+function v(e, t) {
+	let n = e;
+	for (; n;) {
+		let e = n._handleError(t);
+		if (e !== null) return e;
+		n = n.parent;
+	}
+	return { handled: !1 };
+}
+function y(e) {
+	return new _(e);
+}
+var b = class {
+	[i] = {
+		mountDom: (e) => {
+			let t = new _(this);
+			return t.mount(e.parent, e.before), () => t.unmount();
+		},
+		renderServer: (e) => new _(this)._renderServer(e),
+		hydrateDom: (e) => {
+			let t = new _(this);
+			return t._hydrate(e), () => t.unmount();
+		}
+	};
+	definition;
+	props;
+	slots;
+	constructor(e, t, n) {
+		this.definition = e, this.props = t, this.slots = n;
+	}
+};
+function x(e) {
+	return e instanceof b;
+}
+var S = /* @__PURE__ */ new WeakMap(), C = /* @__PURE__ */ new WeakMap();
+function w(e, t) {
+	C.set(e, t);
+}
+f(() => {
+	let e = [], n = t();
+	for (; n;) {
+		let t = C.get(n);
+		t && e.push(t), n = n.parent;
+	}
+	if (e.length !== 0) return e.reverse(), e;
+});
+//#endregion
+export { _ as ComponentInstance, w as _registerContextOwner, y as adaptClassComponent, x as isComponentInvocation, h as isElurSlot };
+
+//# sourceMappingURL=component.js.map