@askrjs/askr 0.0.51 → 0.0.52

package/dist/renderer/intrinsic-blueprint-analysis.js

@@ -0,0 +1,202 @@
+import { _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { extractKey, tagNamesEqualIgnoreCase } from "./utils.js";
+import { applyScalarPropValue } from "./attributes.js";
+import { isFragmentVNode } from "./child-shape.js";
+//#region src/renderer/intrinsic-blueprint-analysis.ts
+function getVNodeChildren(vnode) {
+	return vnode.props?.children ?? vnode.children;
+}
+function getDirectReactiveCompute(value) {
+	if (typeof value === "function") return value;
+	if (Array.isArray(value)) return value.length === 1 ? getDirectReactiveCompute(value[0]) : null;
+	if (typeof value === "object" && value !== null && isFragmentVNode(value)) return getDirectReactiveCompute(getVNodeChildren(value));
+	return null;
+}
+const ownerBlueprints = /* @__PURE__ */ new WeakMap();
+function getBlueprintKey(parentNamespace) {
+	return parentNamespace ?? "";
+}
+function getBlueprint(owner, ownerDocument, parentNamespace) {
+	return ownerBlueprints.get(owner)?.get(ownerDocument)?.get(getBlueprintKey(parentNamespace));
+}
+function cacheBlueprint(owner, ownerDocument, parentNamespace, blueprint) {
+	let byDocument = ownerBlueprints.get(owner);
+	if (!byDocument) {
+		byDocument = /* @__PURE__ */ new WeakMap();
+		ownerBlueprints.set(owner, byDocument);
+	}
+	let byNamespace = byDocument.get(ownerDocument);
+	if (!byNamespace) {
+		byNamespace = /* @__PURE__ */ new Map();
+		byDocument.set(ownerDocument, byNamespace);
+	}
+	const key = getBlueprintKey(parentNamespace);
+	if (!byNamespace.has(key)) byNamespace.set(key, blueprint);
+}
+function isBlueprintKeyProp(key) {
+	return key === "key" || key === "data-key" || key === "data-askr-key-kind";
+}
+function classifyProp(value, key) {
+	if (key === "ref") return { kind: "ref" };
+	if (key.startsWith("on") && key.length > 2) return typeof value === "function" ? { kind: "event" } : null;
+	if (typeof value === "function") return { kind: "reactive" };
+	if (value === void 0 || value === null || value === false) return { kind: "empty" };
+	if (typeof value === "object") return null;
+	return {
+		kind: "static",
+		value
+	};
+}
+function collectReactiveSlotShapes(value, slots) {
+	if (Array.isArray(value)) {
+		for (const child of value) if (!collectReactiveSlotShapes(child, slots)) return false;
+		return true;
+	}
+	if (value === null || value === void 0 || value === false) return true;
+	if (typeof value === "function") {
+		slots.push({ kind: "dynamic" });
+		return true;
+	}
+	if (typeof value === "string" || typeof value === "number") {
+		slots.push({
+			kind: "static",
+			value: String(value)
+		});
+		return true;
+	}
+	if (typeof value === "object" && value !== null && isFragmentVNode(value)) return collectReactiveSlotShapes(getVNodeChildren(value), slots);
+	return false;
+}
+function collectStaticVNodeChildren(value, children) {
+	if (Array.isArray(value)) {
+		for (const child of value) if (!collectStaticVNodeChildren(child, children)) return false;
+		return true;
+	}
+	if (value === null || value === void 0 || typeof value === "boolean") return true;
+	if (typeof value === "string" || typeof value === "number") {
+		children.push(String(value));
+		return true;
+	}
+	if (_isDOMElement(value)) {
+		if (typeof value.type === "string") {
+			children.push(value);
+			return true;
+		}
+		if (typeof value.type === "symbol" && isFragmentVNode(value)) return collectStaticVNodeChildren(getVNodeChildren(value), children);
+	}
+	return false;
+}
+function buildElementShape(template, vnode) {
+	if (typeof vnode.type !== "string" || !tagNamesEqualIgnoreCase(template.tagName, vnode.type)) return null;
+	const props = vnode.props ?? {};
+	const propShapes = Object.create(null);
+	let propCount = 0;
+	for (const key in props) {
+		if (key === "children" || isBlueprintKeyProp(key)) continue;
+		const propShape = classifyProp(props[key], key);
+		if (!propShape) return null;
+		propShapes[key] = propShape;
+		propCount += 1;
+		if (propShape.kind === "reactive") applyScalarPropValue(template, key, null, vnode.type);
+	}
+	if (extractKey(vnode) !== void 0) template.removeAttribute("data-key");
+	const children = vnode.props?.children ?? vnode.children;
+	const reactiveSlots = [];
+	if (collectReactiveSlotShapes(children, reactiveSlots)) {
+		if (reactiveSlots.some((slot) => slot.kind === "dynamic")) {
+			if (template.childNodes.length !== reactiveSlots.length) return null;
+			for (let index = 0; index < reactiveSlots.length; index += 1) {
+				const child = template.childNodes[index];
+				const slot = reactiveSlots[index];
+				if (!child || child.nodeType !== Node.TEXT_NODE) return null;
+				if (slot.kind === "static" && child.data !== slot.value) return null;
+				if (slot.kind === "dynamic") child.data = "";
+			}
+			return {
+				tagName: vnode.type,
+				namespaceURI: template.namespaceURI,
+				propCount,
+				props: propShapes,
+				children: {
+					kind: "reactive",
+					slots: reactiveSlots
+				}
+			};
+		}
+	}
+	const staticChildren = [];
+	if (!collectStaticVNodeChildren(children, staticChildren)) return null;
+	if (template.childNodes.length !== staticChildren.length) return null;
+	const childShapes = [];
+	for (let index = 0; index < staticChildren.length; index += 1) {
+		const child = staticChildren[index];
+		const templateChild = template.childNodes[index];
+		if (typeof child === "string") {
+			if (templateChild.nodeType !== Node.TEXT_NODE || templateChild.data !== child) return null;
+			childShapes.push({
+				kind: "text",
+				value: child
+			});
+			continue;
+		}
+		if (!(templateChild instanceof Element)) return null;
+		const shape = buildElementShape(templateChild, child);
+		if (!shape) return null;
+		childShapes.push({
+			kind: "element",
+			shape
+		});
+	}
+	return {
+		tagName: vnode.type,
+		namespaceURI: template.namespaceURI,
+		propCount,
+		props: propShapes,
+		children: {
+			kind: "static",
+			slots: childShapes
+		}
+	};
+}
+function buildBlueprint(element, vnode) {
+	const template = element.cloneNode(true);
+	const shape = buildElementShape(template, vnode);
+	return shape ? {
+		template,
+		shape,
+		elementCount: countBlueprintElements(shape)
+	} : null;
+}
+function countBlueprintElements(shape) {
+	if (shape.children.kind === "reactive") return 1;
+	return 1 + shape.children.slots.reduce((count, slot) => count + (slot.kind === "element" ? countBlueprintElements(slot.shape) : 0), 0);
+}
+function matchPropShape(expected, value, key) {
+	switch (expected.kind) {
+		case "ref": return key === "ref";
+		case "event": return key.startsWith("on") && key.length > 2 && typeof value === "function";
+		case "reactive": return !(key.startsWith("on") && key.length > 2) && typeof value === "function";
+		case "empty": return value === void 0 || value === null || value === false;
+		case "static": return typeof value !== "object" && Object.is(value, expected.value);
+	}
+}
+function matchReactiveSlots(value, slots, startIndex) {
+	if (Array.isArray(value)) {
+		let index = startIndex;
+		for (const child of value) {
+			index = matchReactiveSlots(child, slots, index);
+			if (index < 0) return -1;
+		}
+		return index;
+	}
+	if (value === null || value === void 0 || value === false) return startIndex;
+	const slot = slots[startIndex];
+	if (!slot) return -1;
+	if (typeof value === "function") return slot.kind === "dynamic" ? startIndex + 1 : -1;
+	if (typeof value === "string" || typeof value === "number") return slot.kind === "static" && slot.value === String(value) ? startIndex + 1 : -1;
+	if (typeof value === "object" && value !== null && isFragmentVNode(value)) return matchReactiveSlots(getVNodeChildren(value), slots, startIndex);
+	return -1;
+}
+//#endregion
+export { buildBlueprint, cacheBlueprint, getBlueprint, getDirectReactiveCompute, getVNodeChildren, isBlueprintKeyProp, matchPropShape, matchReactiveSlots };

package/dist/renderer/intrinsic-blueprint-bindings.js

@@ -0,0 +1,152 @@
+import { getRuntimeEnv } from "../common/env.js";
+import { logger } from "../common/logger.js";
+import { incrementPerfMetric } from "../runtime/perf-metrics.js";
+import "../runtime/dev-namespace.js";
+import { createOwnedFineGrainedEffect } from "../runtime/effect.js";
+import "../runtime/index.js";
+import { REACTIVE_CHILDREN_KEY, setDirectElementReactivePropCleanup, setFreshElementReactivePropCleanup, teardownNodeSubtree } from "./cleanup.js";
+import "./env.js";
+import { applyScalarPropValue } from "./attributes.js";
+import { normalizeOwnedReactiveTextValue } from "./reactive-child-sources.js";
+import { createReactiveScalarChildCleanupEntry, syncReactiveScalarChild } from "./reactive-children.js";
+import { applyFreshElementBindings, createReactivePropCleanupEntry } from "./prop-bindings.js";
+const EMPTY_CLASS_TOKENS = [];
+var BlueprintBinding = class {
+	constructor(kind, element, compute, propName, tagName, textNode) {
+		this.kind = kind;
+		this.element = element;
+		this.propName = propName;
+		this.tagName = tagName;
+		this.textNode = textNode;
+		this.active = true;
+		this.group = null;
+		this.lastClassTokens = null;
+		this.hasValue = false;
+		this.lastValue = void 0;
+		this.nextValue = void 0;
+		this.compute = compute;
+	}
+	get fnRef() {
+		return this.compute;
+	}
+	set fnRef(nextValue) {
+		this.compute = nextValue;
+	}
+	get groupedScalar() {
+		return this.kind === "text";
+	}
+	cleanup() {
+		if (this.group) cleanupGroupedBinding(this.group, this);
+	}
+	updateFn(nextValue) {
+		if (this.group) updateGroupedBinding(this.group, this, nextValue);
+	}
+	restoreFn(nextValue) {
+		const group = this.group;
+		if (this.kind === "text") return createReactiveScalarChildCleanupEntry(this.element, [{
+			kind: "dynamic",
+			compute: nextValue
+		}], group.host);
+		return createReactivePropCleanupEntry(this.element, this.propName, nextValue, this.tagName);
+	}
+};
+function commitBlueprintBinding(binding, value, host) {
+	const previousValue = binding.lastValue;
+	if (binding.hasValue && Object.is(previousValue, value)) return;
+	if (!binding.hasValue && binding.kind === "text" && binding.textNode) {
+		const normalized = normalizeOwnedReactiveTextValue(value);
+		if (normalized !== null) {
+			if (binding.textNode.data !== normalized) binding.textNode.data = normalized;
+			binding.lastValue = value;
+			binding.hasValue = true;
+			return;
+		}
+	}
+	if (binding.kind === "prop") {
+		incrementPerfMetric("reactivePropReevaluations");
+		if (!binding.hasValue && (binding.propName === "class" || binding.propName === "className") && (value === "" || value === void 0 || value === null || value === false)) binding.lastClassTokens = EMPTY_CLASS_TOKENS;
+		else applyScalarPropValue(binding.element, binding.propName, value, binding.tagName, binding.hasValue ? previousValue : void 0, binding);
+	} else {
+		const normalized = normalizeOwnedReactiveTextValue(value);
+		if (normalized === null) {
+			binding.textNode = null;
+			host.updateElementChildren(binding.element, value);
+		} else {
+			let textNode = binding.textNode;
+			if (!textNode || binding.element.firstChild !== textNode || binding.element.lastChild !== textNode) {
+				host.updateElementChildren(binding.element, normalized);
+				textNode = binding.element.childNodes.length === 1 && binding.element.firstChild?.nodeType === Node.TEXT_NODE ? binding.element.firstChild : null;
+				binding.textNode = textNode;
+			}
+			if (textNode && textNode.data !== normalized) textNode.data = normalized;
+		}
+	}
+	binding.lastValue = value;
+	binding.hasValue = true;
+}
+function updateGroupedBinding(group, binding, nextValue) {
+	if (!binding.active || !group.effect) return;
+	if (binding.kind === "text") {
+		const nextSlot = nextValue[0];
+		const nextCompute = typeof nextValue === "function" ? nextValue : nextSlot?.kind === "dynamic" ? nextSlot.compute : null;
+		if (!nextCompute) return;
+		binding.compute = nextCompute;
+	} else binding.compute = nextValue;
+	group.effect.flush();
+}
+function cleanupGroupedBinding(group, binding) {
+	if (!binding.active) return;
+	binding.active = false;
+	group.activeCount -= 1;
+	if (group.activeCount === 0) {
+		group.effect?.cleanup();
+		group.effect = null;
+	}
+}
+function computeBlueprintBindings() {
+	const group = this._owner;
+	for (const binding of group.bindings) if (binding.active) binding.nextValue = binding.compute();
+	return group.bindings;
+}
+function commitBlueprintBindings(_bindings, _previousBindings) {
+	const group = this._owner;
+	for (const binding of group.bindings) if (binding.active) commitBlueprintBinding(binding, binding.nextValue, group.host);
+}
+function blueprintBindingsChanged(_previousBindings, _nextBindings) {
+	return false;
+}
+function reportBlueprintBindingError(error) {
+	if (getRuntimeEnv().NODE_ENV !== "production") logger.warn("[Askr] Blueprint reactive update failed:", error);
+}
+function mountBlueprintBindingGroup(bindings, host) {
+	if (bindings.length === 0) return;
+	const group = {
+		_coalesceForItemReads: true,
+		bindings,
+		activeCount: bindings.length,
+		effect: null,
+		host
+	};
+	group.effect = createOwnedFineGrainedEffect("reactive", computeBlueprintBindings, commitBlueprintBindings, blueprintBindingsChanged, reportBlueprintBindingError, group);
+	let previousElement = null;
+	for (const binding of bindings) {
+		binding.group = group;
+		const bindingKey = binding.kind === "text" ? REACTIVE_CHILDREN_KEY : binding.propName;
+		if (binding.element === previousElement) setDirectElementReactivePropCleanup(binding.element, bindingKey, binding);
+		else {
+			setFreshElementReactivePropCleanup(binding.element, bindingKey, binding);
+			previousElement = binding.element;
+		}
+	}
+}
+function publishPreparedBlueprintBindings(element, props) {
+	applyFreshElementBindings(element, props);
+}
+function cleanupBlueprintElement(element) {
+	teardownNodeSubtree(element);
+}
+function syncPreparedBlueprintChild(element, value, host) {
+	return syncReactiveScalarChild(element, value, host);
+}
+//#endregion
+export { BlueprintBinding, cleanupBlueprintElement, mountBlueprintBindingGroup, publishPreparedBlueprintBindings, syncPreparedBlueprintChild };

package/dist/renderer/intrinsic-blueprint-materialization.js

@@ -0,0 +1,100 @@
+import { _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { isBenchMetricScopeActive, recordBenchCounter } from "../runtime/for-bench.js";
+import "../runtime/index.js";
+import { materializeFreshKey } from "./attributes.js";
+import { isFragmentVNode } from "./child-shape.js";
+import { getDirectReactiveCompute, getVNodeChildren, isBlueprintKeyProp, matchPropShape, matchReactiveSlots } from "./intrinsic-blueprint-analysis.js";
+import { BlueprintBinding, cleanupBlueprintElement, mountBlueprintBindingGroup, publishPreparedBlueprintBindings, syncPreparedBlueprintChild } from "./intrinsic-blueprint-bindings.js";
+//#region src/renderer/intrinsic-blueprint-materialization.ts
+const BLUEPRINT_PUBLISH_BINDINGS = 0;
+const BLUEPRINT_SYNC_REACTIVE_CHILD = 1;
+function prepareElementBlueprint(element, vnode, shape, bindings, deferred) {
+	const vnodeType = vnode.type;
+	if (typeof vnodeType !== "string" || shape.tagName !== vnodeType && shape.tagName.toLowerCase() !== vnodeType.toLowerCase()) return false;
+	const props = vnode.props ?? {};
+	let propCount = 0;
+	let shouldPublishBindings = false;
+	for (const key in props) {
+		if (key === "children" || isBlueprintKeyProp(key)) continue;
+		const expected = shape.props[key];
+		if (!expected || !matchPropShape(expected, props[key], key)) return false;
+		propCount += 1;
+		if (expected.kind === "reactive") bindings.push(new BlueprintBinding("prop", element, props[key], key, vnodeType, null));
+		else if (expected.kind === "event" || expected.kind === "ref") shouldPublishBindings = true;
+	}
+	if (propCount !== shape.propCount) return false;
+	materializeFreshKey(element, vnode, props);
+	if (shouldPublishBindings) deferred.push(BLUEPRINT_PUBLISH_BINDINGS, element, props);
+	const children = vnode.props?.children ?? vnode.children;
+	if (shape.children.kind === "reactive") {
+		if (shape.children.slots.length === 1 && shape.children.slots[0]?.kind === "dynamic") {
+			const compute = getDirectReactiveCompute(children);
+			const textNode = element.firstChild;
+			if (compute) {
+				bindings.push(new BlueprintBinding("text", element, compute, null, null, textNode));
+				return true;
+			}
+		}
+		if (matchReactiveSlots(children, shape.children.slots, 0) !== shape.children.slots.length) return false;
+		deferred.push(BLUEPRINT_SYNC_REACTIVE_CHILD, element, children);
+		return true;
+	}
+	if (shape.children.slots.length === 0 && (children === null || children === void 0 || typeof children === "boolean")) return true;
+	const staticSlot = shape.children.slots.length === 1 ? shape.children.slots[0] : void 0;
+	if (staticSlot?.kind === "element" && _isDOMElement(children) && typeof children.type === "string") {
+		const childNode = element.firstChild;
+		if (!(childNode instanceof Element)) return false;
+		return prepareElementBlueprint(childNode, children, staticSlot.shape, bindings, deferred);
+	}
+	return prepareStaticSlots(element, children, shape.children.slots, 0, bindings, deferred) === shape.children.slots.length;
+}
+function prepareStaticSlots(element, value, slots, startIndex, bindings, deferred) {
+	if (Array.isArray(value)) {
+		let index = startIndex;
+		for (const child of value) {
+			index = prepareStaticSlots(element, child, slots, index, bindings, deferred);
+			if (index < 0) return -1;
+		}
+		return index;
+	}
+	if (value === null || value === void 0 || typeof value === "boolean") return startIndex;
+	const slot = slots[startIndex];
+	const childNode = element.childNodes[startIndex];
+	if (typeof value === "string" || typeof value === "number") return slot?.kind === "text" && slot.value === String(value) ? startIndex + 1 : -1;
+	if (!_isDOMElement(value)) return -1;
+	if (typeof value.type === "symbol") return isFragmentVNode(value) ? prepareStaticSlots(element, getVNodeChildren(value), slots, startIndex, bindings, deferred) : -1;
+	if (slot?.kind === "element" && childNode !== void 0) return prepareElementBlueprint(childNode, value, slot.shape, bindings, deferred) ? startIndex + 1 : -1;
+	return -1;
+}
+function publishPreparedBlueprint(deferred, host) {
+	for (let index = 0; index < deferred.length; index += 3) {
+		const operation = deferred[index];
+		const element = deferred[index + 1];
+		const value = deferred[index + 2];
+		if (operation === BLUEPRINT_PUBLISH_BINDINGS) publishPreparedBlueprintBindings(element, value);
+		else if (!syncPreparedBlueprintChild(element, value, host)) throw new Error("[askr] Component blueprint reactive shape changed.");
+	}
+}
+function instantiateBlueprint(blueprint, vnode, host) {
+	const element = blueprint.template.cloneNode(true);
+	const bindings = [];
+	const deferred = [];
+	if (!prepareElementBlueprint(element, vnode, blueprint.shape, bindings, deferred)) return null;
+	try {
+		publishPreparedBlueprint(deferred, host);
+		mountBlueprintBindingGroup(bindings, host);
+		if (isBenchMetricScopeActive("coldCreate")) {
+			recordBenchCounter("domNodesCreated", blueprint.elementCount);
+			recordBenchCounter("reactivePropsMounted", bindings.reduce((count, binding) => count + (binding.kind === "prop" ? 1 : 0), 0));
+		}
+		return element;
+	} catch (error) {
+		try {
+			cleanupBlueprintElement(element);
+		} catch {}
+		throw error;
+	}
+}
+//#endregion
+export { instantiateBlueprint, prepareElementBlueprint };

package/dist/renderer/intrinsic-blueprint.js

@@ -0,0 +1,30 @@
+import { _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { buildBlueprint, cacheBlueprint, getBlueprint } from "./intrinsic-blueprint-analysis.js";
+import { instantiateBlueprint } from "./intrinsic-blueprint-materialization.js";
+//#region src/renderer/intrinsic-blueprint.ts
+/**
+* Stable renderer facade for the intrinsic blueprint fast path.
+*
+* Analysis, materialization, and grouped binding publication intentionally
+* live behind this small adapter so callers do not depend on their internal
+* representations.
+*/
+function createResultNodeWithBlueprint(owner, result, parentNamespace, createNormally, host) {
+	if (!_isDOMElement(result) || typeof result.type !== "string") return createNormally();
+	const cached = getBlueprint(owner, document, parentNamespace);
+	if (cached) {
+		const instantiated = instantiateBlueprint(cached, result, host);
+		if (instantiated) return instantiated;
+	}
+	const node = createNormally();
+	if (!(node instanceof Element) || cached) return node;
+	const blueprint = buildBlueprint(node, result);
+	if (blueprint) cacheBlueprint(owner, node.ownerDocument, parentNamespace, blueprint);
+	return node;
+}
+function createComponentResultNodeWithBlueprint(component, result, parentNamespace, createNormally, host) {
+	return createResultNodeWithBlueprint(component, result, parentNamespace, createNormally, host);
+}
+//#endregion
+export { createComponentResultNodeWithBlueprint, createResultNodeWithBlueprint };

package/dist/renderer/intrinsic-hydration-adoption.js

@@ -0,0 +1,66 @@
+import { _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { extractKey, parseEventProp, tagNamesEqualIgnoreCase } from "./utils.js";
+import { hasMatchingStaticPropsIgnoringEvents } from "./attributes.js";
+import { runRetainedElementUpdate } from "./retained-element-rollback.js";
+import { applyMatchingElementBindings, hasAnyElementBindingState } from "./prop-bindings.js";
+//#region src/renderer/intrinsic-hydration-adoption.ts
+let hydrationAdoptionDepth = 0;
+function withIntrinsicHydrationAdoption(work) {
+	hydrationAdoptionDepth += 1;
+	try {
+		return work();
+	} finally {
+		hydrationAdoptionDepth -= 1;
+	}
+}
+function getDirectVNodeChildren(vnode) {
+	const children = vnode.props?.children ?? vnode.children;
+	if (children === null || children === void 0 || children === false) return [];
+	return Array.isArray(children) ? children : [children];
+}
+function canAdoptMatchingIntrinsicSubtree(element, vnode) {
+	if (typeof vnode.type !== "string" || !tagNamesEqualIgnoreCase(element.tagName, vnode.type) || hasAnyElementBindingState(element) || extractKey(vnode) !== void 0) return false;
+	const props = vnode.props || {};
+	if (!hasMatchingStaticPropsIgnoringEvents(element, props, vnode.type)) return false;
+	for (const key in props) {
+		const value = props[key];
+		const eventProp = parseEventProp(key);
+		if (eventProp && typeof value !== "function") return false;
+		if (!eventProp && key !== "ref" && typeof value === "function") return false;
+	}
+	const children = getDirectVNodeChildren(vnode);
+	if (element.childNodes.length !== children.length) return false;
+	for (let index = 0; index < children.length; index += 1) {
+		const child = children[index];
+		const current = element.childNodes[index];
+		if (typeof child === "string" || typeof child === "number") {
+			if (current.nodeType !== 3 || current.data !== String(child)) return false;
+			continue;
+		}
+		if (!_isDOMElement(child) || typeof child.type !== "string" || !(current instanceof Element) || extractKey(child) !== void 0 || !canAdoptMatchingIntrinsicSubtree(current, child)) return false;
+	}
+	return true;
+}
+function adoptMatchingIntrinsicSubtree(element, vnode) {
+	const props = vnode.props || {};
+	let hasBindings = Object.prototype.hasOwnProperty.call(props, "ref");
+	for (const key in props) if (parseEventProp(key)) {
+		hasBindings = true;
+		break;
+	}
+	if (hasBindings) runRetainedElementUpdate(element, () => void 0, () => applyMatchingElementBindings(element, props), void 0, true);
+	const children = getDirectVNodeChildren(vnode);
+	for (let index = 0; index < children.length; index += 1) {
+		const child = children[index];
+		if (_isDOMElement(child)) adoptMatchingIntrinsicSubtree(element.childNodes[index], child);
+	}
+}
+function tryAdoptMatchingIntrinsicSubtree(element, vnode) {
+	if (hydrationAdoptionDepth === 0) return false;
+	if (!canAdoptMatchingIntrinsicSubtree(element, vnode)) return false;
+	adoptMatchingIntrinsicSubtree(element, vnode);
+	return true;
+}
+//#endregion
+export { tryAdoptMatchingIntrinsicSubtree, withIntrinsicHydrationAdoption };

package/dist/renderer/keyed-children.js

@@ -1,4 +1,4 @@
-import { extractKey } from "./utils.js";
+import { extractKey, getMaterializedKey } from "./utils.js";
 //#region src/renderer/keyed-children.ts
 function extractKeyedVnodes(newChildren) {
 	const keyedVnodes = [];
@@ -16,17 +16,11 @@ function buildDOMKeyMap(parent) {
 	const keyMap = /* @__PURE__ */ new Map();
 	try {
 		for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {
-			const k = el.getAttribute("data-key");
-			if (k !== null) {
-				keyMap.set(k, el);
-				const n = Number(k);
-				if (!Number.isNaN(n)) keyMap.set(n, el);
-			}
+			const key = getMaterializedKey(el);
+			if (key !== void 0) keyMap.set(key, el);
 		}
 	} catch {}
 	return keyMap;
 }
 //#endregion
 export { buildDOMKeyMap, extractKeyedVnodes };
-
-//# sourceMappingURL=keyed-children.js.map

package/dist/renderer/keyed.js

@@ -1,4 +1,4 @@
-import { buildKeyMapFromChildren, hasPropChanged, isIgnoredForPropChanges } from "./utils.js";
+import { buildKeyMapFromChildren, getMaterializedKey, hasPropChanged, isIgnoredForPropChanges } from "./utils.js";
 import { extractKeyedVnodes } from "./keyed-children.js";
 //#region src/renderer/keyed.ts
 const keyedElements = /* @__PURE__ */ new WeakMap();
@@ -52,6 +52,9 @@ function computeLISLength(positions) {
 	}
 	return tails.length;
 }
+function keyToken(key) {
+	return `${typeof key}:${String(key)}`;
+}
 function collectCurrentKeyOrder(parent, oldKeyMap) {
 	const currentKeys = [];
 	if (oldKeyMap && oldKeyMap.size > 0) {
@@ -60,8 +63,7 @@ function collectCurrentKeyOrder(parent, oldKeyMap) {
 		for (const [key, el] of oldKeyMap) {
 			if (el === lastElement) continue;
 			lastElement = el;
-			const normalizedKey = String(key);
-			currentKeys.push(normalizedKey);
+			currentKeys.push(keyToken(key));
 			keyCount++;
 		}
 		if (keyCount > 0) return {
@@ -72,9 +74,9 @@ function collectCurrentKeyOrder(parent, oldKeyMap) {
 	let keyCount = 0;
 	try {
 		for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {
-			const keyAttr = el.getAttribute("data-key");
-			if (keyAttr === null) continue;
-			currentKeys.push(keyAttr);
+			const key = getMaterializedKey(el);
+			if (key === void 0) continue;
+			currentKeys.push(keyToken(key));
 			keyCount++;
 		}
 	} catch {}
@@ -125,7 +127,7 @@ function planKeyedReorderFastPath(parent, keyedVnodes, totalChildren, oldKeyMap)
 	};
 	const { keyCount: currentKeyCount, currentKeys } = collectCurrentKeyOrder(parent, oldKeyMap);
 	let moveCount = 0;
-	for (let i = 0; i < totalKeyed; i++) if (currentKeys[i] !== String(keyedVnodes[i].key)) moveCount++;
+	for (let i = 0; i < totalKeyed; i++) if (currentKeys[i] !== keyToken(keyedVnodes[i].key)) moveCount++;
 	const cheapMoveTrigger = shouldEvaluateShape && currentKeyCount > 0 && moveCount > Math.max(64, Math.floor(totalKeyed * .1));
 	let lisTrigger = false;
 	let lisLen = 0;
@@ -133,7 +135,7 @@ function planKeyedReorderFastPath(parent, keyedVnodes, totalChildren, oldKeyMap)
 		const indexByKey = /* @__PURE__ */ new Map();
 		for (let i = 0; i < currentKeys.length; i++) indexByKey.set(currentKeys[i], i);
 		const positions = Array(totalKeyed).fill(-1);
-		for (let i = 0; i < totalKeyed; i++) positions[i] = indexByKey.get(String(keyedVnodes[i].key)) ?? -1;
+		for (let i = 0; i < totalKeyed; i++) positions[i] = indexByKey.get(keyToken(keyedVnodes[i].key)) ?? -1;
 		lisLen = computeLISLength(positions);
 		lisTrigger = lisLen < Math.floor(totalKeyed * .5);
 	}
@@ -163,5 +165,3 @@ function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
 }
 //#endregion
 export { _reconcilerRecordedParents, getKeyMapForElement, isKeyedReorderFastPathEligible, keyedElements, planKeyedReorderFastPath, populateKeyMapForElement };
-
-//# sourceMappingURL=keyed.js.map

package/dist/renderer/namespaces.js

@@ -19,5 +19,3 @@ function canReuseIntrinsicElementInNamespace(existing, type, parentNamespace) {
 }
 //#endregion
 export { SVG_NAMESPACE, canReuseIntrinsicElementInNamespace, createElementForNamespace, getParentNamespace, resolveChildNamespace };
-
-//# sourceMappingURL=namespaces.js.map