@askrjs/askr 0.0.52 → 0.0.53

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

@@ -1,202 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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,26 +0,0 @@
-import { extractKey, getMaterializedKey } from "./utils.js";
-//#region src/renderer/keyed-children.ts
-function extractKeyedVnodes(newChildren) {
-	const keyedVnodes = [];
-	for (let i = 0; i < newChildren.length; i++) {
-		const child = newChildren[i];
-		const key = extractKey(child);
-		if (key !== void 0) keyedVnodes.push({
-			key,
-			vnode: child
-		});
-	}
-	return keyedVnodes;
-}
-function buildDOMKeyMap(parent) {
-	const keyMap = /* @__PURE__ */ new Map();
-	try {
-		for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {
-			const key = getMaterializedKey(el);
-			if (key !== void 0) keyMap.set(key, el);
-		}
-	} catch {}
-	return keyMap;
-}
-//#endregion
-export { buildDOMKeyMap, extractKeyedVnodes };