@askrjs/askr 0.0.69 → 0.0.71

package/dist/ssr/index.js

@@ -1,3 +1,3 @@
 import { u as SSRDataMissingError } from "../render-context-Clw3rFiO.js";
-import { a as renderResolvedToStringSync, c as createRenderContext, d as withRenderContextAsync, i as renderRouteRequestToString, l as getRenderContext, n as renderToString, o as renderToStringSync, r as renderRouteRequest, s as resolveRequest, t as renderToStream, u as withRenderContext } from "../ssr-vE-KUgDV.js";
+import { a as renderResolvedToStringSync, c as createRenderContext, d as withRenderContextAsync, i as renderRouteRequestToString, l as getRenderContext, n as renderToString, o as renderToStringSync, r as renderRouteRequest, s as resolveRequest, t as renderToStream, u as withRenderContext } from "../ssr-BSUA9Y64.js";
 export { SSRDataMissingError, createRenderContext, getRenderContext, renderResolvedToStringSync, renderRouteRequest, renderRouteRequestToString, renderToStream, renderToString, renderToStringSync, resolveRequest, withRenderContext, withRenderContextAsync };

package/dist/{ssr-vE-KUgDV.js → ssr-BSUA9Y64.js}

@@ -7,15 +7,15 @@ import { f as getCurrentComponentInstance, w as setCurrentComponentInstance } fr
 import { t as cleanupComponent } from "./component-cleanup-1ZFoLLHt.js";
 import { p as isPromiseLike } from "./lifecycle-batch-COgl8jMS.js";
 import { g as evaluateShowState, h as evaluateCaseState, i as evaluateForState, o as rollbackForStateTransaction, r as commitForStateTransaction } from "./for-internal-BtK9Htl0.js";
-import { _ as isPageRenderEnvelope, g as isEmptyPageRenderEnvelope, h as createPageRenderEnvelope, i as isDeferred, l as createRouteRegistry, m as resolveRouteRequest, t as DEFERRED_BOUNDARY } from "./deferred-zHtUheIQ.js";
+import { _ as isPageRenderEnvelope, g as isEmptyPageRenderEnvelope, h as createPageRenderEnvelope, i as isDeferred, l as createRouteRegistry, m as resolveRouteRequest, t as DEFERRED_BOUNDARY } from "./deferred-Cr58yIQD.js";
 import { c as stopRenderPhase$1, o as startRenderPhase$1, t as configureRenderContextProvider, u as SSRDataMissingError } from "./render-context-Clw3rFiO.js";
-import { a as disposeDefaultPortalScope, t as DefaultPortal } from "./portal-D7TC986A.js";
-import { t as getPublicAttributeName } from "./attr-names-CjhzmHOn.js";
-import { r as validateCspNonce, t as CspNonceScope } from "./csp-nonce-HGZ0vbqT.js";
-import { t as createDataRuntime } from "./data-runtime-SJ1BSUvk.js";
-import { c as withTelemetry, i as dehydrateDataRuntime, t as createQueryPrefetchContext } from "./query-registry-CQIT4mXr.js";
-import { a as resolveRouteFromRoutes, t as _resolveRouteMatchFromRoutes } from "./route-matching-DLBWDeXX.js";
-import { a as route } from "./authoring-uaJ556aG.js";
+import { a as resolveRouteFromRoutes, t as _resolveRouteMatchFromRoutes } from "./route-matching-M-f1VQRu.js";
+import { a as disposeDefaultPortalScope, o as SSR_PORTAL_HOST, t as DefaultPortal } from "./portal-wY3j0vvp.js";
+import { n as getPublicAttributeName, t as sanitizeCssValue } from "./css-BuPaTOfe.js";
+import { a as isSafeHref, r as validateCspNonce, t as CspNonceScope } from "./csp-nonce-CwSRP3Jl.js";
+import { t as createDataRuntime } from "./data-runtime-rpV6-3XW.js";
+import { c as withTelemetry, i as dehydrateDataRuntime, t as createQueryPrefetchContext } from "./query-registry-Bu_cuMch.js";
+import { a as route } from "./authoring-CXmUcaCe.js";
 import { n as renderDocument, t as SSR_RENDER_DATA_ATTR } from "./ssr-CbQO5xd3.js";
 //#region src/ssr/escape.ts
 /**
@@ -42,51 +42,6 @@ const VOID_ELEMENTS = /* @__PURE__ */ new Set([
 ]);
 const escapeCache = /* @__PURE__ */ new Map();
 const MAX_CACHE_SIZE = 256;
-const CSS_UNSAFE_RE = /[{}<>\\]/g;
-const CSS_URI_SCHEME_RE = /(?:^|[\s(,])([a-z][a-z0-9+.-]*):/i;
-const CSS_FUNCTION_NAME_RE = /([a-z-][a-z0-9-]*)\s*\(/gi;
-const CSS_ALLOWED_FUNCTIONS = /* @__PURE__ */ new Set([
-	"var",
-	"calc",
-	"min",
-	"max",
-	"clamp",
-	"rgb",
-	"rgba",
-	"hsl",
-	"hsla",
-	"lab",
-	"lch",
-	"oklab",
-	"oklch",
-	"color",
-	"color-mix",
-	"translate",
-	"translatex",
-	"translatey",
-	"translatez",
-	"scale",
-	"scalex",
-	"scaley",
-	"scalez",
-	"rotate",
-	"rotatex",
-	"rotatey",
-	"rotatez",
-	"skew",
-	"skewx",
-	"skewy",
-	"matrix",
-	"matrix3d",
-	"linear-gradient",
-	"radial-gradient",
-	"conic-gradient",
-	"repeating-linear-gradient",
-	"repeating-radial-gradient",
-	"repeating-conic-gradient",
-	"cubic-bezier",
-	"steps"
-]);
 const STYLE_PROP_CACHE = /* @__PURE__ */ new Map();
 const MAX_STYLE_PROP_CACHE_SIZE = 512;
 function toKebabCached(prop) {
@@ -178,19 +133,7 @@ function escapeAttr(value) {
 	return lastIndex === 0 ? value : escaped + value.slice(lastIndex);
 }
 /**
-* Escape CSS value to prevent injection attacks.
-* Removes characters that could break out of CSS context.
-*/
-function escapeCssValue(value) {
-	const str = String(value);
-	if (CSS_URI_SCHEME_RE.test(str)) return "";
-	if (str.includes("(")) {
-		for (const match of str.matchAll(CSS_FUNCTION_NAME_RE)) if (!CSS_ALLOWED_FUNCTIONS.has(match[1].toLowerCase())) return "";
-	}
-	return str.replace(CSS_UNSAFE_RE, "");
-}
-/**
-* Convert style object to CSS string with value escaping
+* Convert a style object to a CSS string, omitting unsafe values.
 * Optimized to avoid Object.entries allocation
 */
 function styleObjToCss(value) {
@@ -201,7 +144,7 @@ function styleObjToCss(value) {
 		const v = styleObj[k];
 		if (v === null || v === void 0 || v === false) continue;
 		const prop = toKebabCached(k);
-		const safeValue = escapeCssValue(String(v));
+		const safeValue = sanitizeCssValue(String(v));
 		if (safeValue) result += `${prop}:${safeValue};`;
 	}
 	return result || null;
@@ -264,6 +207,10 @@ function createRenderContext(seed = 12345, opts = {}) {
 		renderData: envelope,
 		hydrationData: envelope,
 		deferredBoundaries: [],
+		ssrPortals: {
+			slots: /* @__PURE__ */ new Map(),
+			nextHostId: 0
+		},
 		cspNonce: opts.cspNonce
 	};
 }
@@ -310,13 +257,7 @@ async function getAsyncRenderContextAccessor() {
 async function withRenderContextAsync(ctx, fn) {
 	const accessor = await getAsyncRenderContextAccessor();
 	if (accessor) return accessor.run(ctx, () => Promise.resolve(fn()));
-	const previous = fallbackStack;
-	fallbackStack = ctx;
-	try {
-		return await fn();
-	} finally {
-		fallbackStack = previous;
-	}
+	throw new Error(FALLBACK_ASYNC_CONTEXT_ERROR);
 }
 /**
 * Get the current render context.
@@ -833,6 +774,7 @@ function renderAttrsDirect(props, sink) {
 		}
 		if (value === false || value === null || value === void 0) continue;
 		const strValue = String(value);
+		if (attrName.toLowerCase() === "href" && !isSafeHref(strValue)) continue;
 		sink.write(" ");
 		sink.write(attrName);
 		sink.write("=\"");
@@ -867,6 +809,7 @@ function renderAttrs(props, opts) {
 		else if (value === false || value === null || value === void 0) continue;
 		else {
 			const strValue = String(value);
+			if (attrName.toLowerCase() === "href" && !isSafeHref(strValue)) continue;
 			attrParts.push(` ${attrName}="${getEscapedAttrValue(strValue)}"`);
 		}
 	}
@@ -969,6 +912,47 @@ function renderRenderableSync(value, ctx) {
 	if (value && typeof value === "object" && "type" in value) return renderNodeSync(value, ctx);
 	return "";
 }
+function resolveSSRPortals(html, ctx) {
+	let resolved = html;
+	const renderedHosts = /* @__PURE__ */ new Set();
+	for (;;) {
+		let foundHost = false;
+		for (const slot of ctx.ssrPortals.slots.values()) {
+			const explicitHosts = slot.hosts.filter((host) => !host.automatic);
+			const activeHosts = explicitHosts.length > 0 ? new Set(explicitHosts.map((host) => host.token)) : new Set(slot.hosts.map((host) => host.token));
+			for (const host of slot.hosts) {
+				if (renderedHosts.has(host.token)) continue;
+				foundHost = true;
+				const content = activeHosts.has(host.token) && slot.hasValue ? renderRenderableSync(slot.value, ctx) : "";
+				resolved = resolved.replace(host.token, () => content);
+				renderedHosts.add(host.token);
+			}
+		}
+		if (!foundHost) return resolved;
+	}
+}
+var SSRPortalSink = class {
+	constructor(sink) {
+		this.sink = sink;
+		this.bufferedChunks = null;
+	}
+	write(html) {
+		if (!html) return;
+		if (this.bufferedChunks) {
+			this.bufferedChunks.push(html);
+			return;
+		}
+		this.sink.write(html);
+	}
+	writePortalHost(token) {
+		this.bufferedChunks ??= [];
+		this.bufferedChunks.push(token);
+	}
+	flush(ctx) {
+		if (!this.bufferedChunks) return;
+		this.sink.write(resolveSSRPortals(this.bufferedChunks.join(""), ctx));
+	}
+};
 function renderChildSync(child, ctx) {
 	return renderRenderableSync(child, ctx);
 }
@@ -1037,6 +1021,7 @@ function renderNodeSync(node, ctx) {
 	const { type, props } = node;
 	if (typeof type === "function") return renderRenderableSync(inheritRenderableKey(node, executeComponentSync(type, props, ctx, getVNodeContextFrame(node) ?? null)), ctx);
 	if (typeof type === "symbol") {
+		if (type === SSR_PORTAL_HOST) return String(props?.token ?? "");
 		if (type === Fragment) return renderChildrenSync(getRenderableChildren(node), ctx);
 		if (type === __CONTROL_BOUNDARY__) return renderControlChildrenSync(node, ctx);
 		if (type === DEFERRED_BOUNDARY) return renderDeferredBoundarySync(node, ctx);
@@ -1076,6 +1061,13 @@ function renderNodeSyncToSink(node, sink, ctx) {
 		return;
 	}
 	if (typeof type === "symbol") {
+		if (type === SSR_PORTAL_HOST) {
+			const token = String(props?.token ?? "");
+			const portalSink = sink;
+			if (portalSink.writePortalHost) portalSink.writePortalHost(token);
+			else sink.write(token);
+			return;
+		}
 		if (type === Fragment) {
 			renderChildrenSyncToSink(getRenderableChildren(node), sink, ctx);
 			return;
@@ -1182,9 +1174,8 @@ function renderToStringSync(component, props, options) {
 			if (!node) throw new Error("renderToStringSync: wrapped component returned empty");
 			const sink = new StringSink();
 			renderNodeSyncToSink(node, sink, ctx);
-			sink.write(serializeHydrationRenderData(ctx.hydrationData ?? void 0, ctx.dataRuntime));
 			sink.end();
-			return sink.toString();
+			return resolveSSRPortals(sink.toString(), ctx) + serializeHydrationRenderData(ctx.hydrationData ?? void 0, ctx.dataRuntime);
 		} finally {
 			try {
 				stopRenderPhase();
@@ -1199,10 +1190,13 @@ function renderSSRRouteAppToSink(input) {
 	withRenderContext(ctx, () => {
 		startRenderPhase(ctx.renderData);
 		try {
-			renderRenderableSyncToSink(executeComponentSync(ctx.cspNonce === void 0 ? route.handler : () => CspNonceScope({
+			const app = executeComponentSync(ctx.cspNonce === void 0 ? route.handler : () => CspNonceScope({
 				value: ctx.cspNonce,
 				children: () => route.handler(params)
-			}), params, ctx), sink, ctx);
+			}), params, ctx);
+			const appSink = new SSRPortalSink(sink);
+			renderRenderableSyncToSink(wrapWithDefaultPortal(app), appSink, ctx);
+			appSink.flush(ctx);
 			if (ctx.deferredBoundaries.length === 0) sink.write(serializeHydrationRenderData(ctx.hydrationData ?? data, ctx.dataRuntime));
 		} finally {
 			try {

package/dist/testing/index.d.ts

@@ -1,5 +1,38 @@
+import { s as ComponentFunction } from "../control-DO-iBEtV.js";
 import { C as Query, k as QueryStaleReason } from "../index-Bki2rqcr.js";
-import { N as RouteRegistry, x as RouteMatch } from "../router-C0XQA62W.js";
+import { N as RouteRegistry, p as RouteAuthOptions, x as RouteMatch } from "../router-C3vENhUh.js";
+//#region src/testing/render.d.ts
+interface RenderOptions {
+  /**
+   * Existing element to own for the duration of the render. When omitted, the
+   * harness appends a managed `<div>` to `document.body`.
+   */
+  container?: HTMLElement;
+  /** Surface lifecycle cleanup errors during unmount. */
+  cleanupStrict?: boolean;
+}
+interface RouteRenderOptions extends RenderOptions {
+  registry: RouteRegistry;
+  /** Initial path, query, and hash for the routed render. */
+  url?: string;
+  auth?: RouteAuthOptions;
+}
+type DispatchEventInit = EventInit | UIEventInit | FocusEventInit | MouseEventInit | WheelEventInit | KeyboardEventInit | InputEventInit | CompositionEventInit | PointerEventInit | TouchEventInit | DragEventInit;
+interface RenderResult {
+  readonly container: HTMLElement;
+  readonly root: HTMLElement;
+  flush(): void;
+  dispatch(target: EventTarget, event: Event | string, init?: DispatchEventInit): boolean;
+  unmount(): void;
+  cleanup(): void;
+}
+declare function flush(): void;
+declare function dispatch(target: EventTarget, event: Event | string, init?: DispatchEventInit): boolean;
+declare function cleanup(target: RenderResult | HTMLElement): void;
+declare function render(component: ComponentFunction, options?: RenderOptions): RenderResult;
+declare function mount(component: ComponentFunction, options?: RenderOptions): RenderResult;
+declare function renderRoute(options: RouteRenderOptions): Promise<RenderResult>;
+//#endregion
 //#region src/testing/index.d.ts
 type MockRefresh = () => void | Promise<void>;
 interface MockQueryOptions {
@@ -47,4 +80,4 @@ declare function createInvalidationRecorder(): InvalidationRecorder;
 declare function matchRoute(path: string, options: MatchRouteOptions): RouteMatch | null;
 declare function getRouteWarnings(options: MatchRouteOptions): RoutePatternWarning[];
 //#endregion
-export { InvalidationRecord, InvalidationRecorder, MockQueryOptions, MockRefresh, RoutePatternWarning, createInvalidationRecorder, getRouteWarnings, matchRoute, mockQuery, queryState };
+export { InvalidationRecord, InvalidationRecorder, MockQueryOptions, MockRefresh, type RenderOptions, type RenderResult, RoutePatternWarning, type RouteRenderOptions, cleanup, createInvalidationRecorder, dispatch, flush, getRouteWarnings, matchRoute, mockQuery, mount, queryState, render, renderRoute };

package/dist/testing/index.js

@@ -1,5 +1,184 @@
-import { t as addInvalidationListener } from "../invalidation-listeners-Des3AHYs.js";
-import { r as computeRouteActivityMatches } from "../route-matching-DLBWDeXX.js";
+import { r as flushRuntimeScheduler } from "../access-ePqdQqkV.js";
+import { r as computeRouteActivityMatches } from "../route-matching-M-f1VQRu.js";
+import { l as addInvalidationListener } from "../data-runtime-rpV6-3XW.js";
+import { a as cleanupApp, r as createSPA, t as createIsland } from "../boot-DIKbEA4Y.js";
+//#region src/testing/render.ts
+const renderStates = /* @__PURE__ */ new WeakMap();
+const eventConstructorNames = {
+	auxclick: ["MouseEvent"],
+	click: ["MouseEvent"],
+	contextmenu: ["MouseEvent"],
+	dblclick: ["MouseEvent"],
+	mousedown: ["MouseEvent"],
+	mouseenter: ["MouseEvent"],
+	mouseleave: ["MouseEvent"],
+	mousemove: ["MouseEvent"],
+	mouseout: ["MouseEvent"],
+	mouseover: ["MouseEvent"],
+	mouseup: ["MouseEvent"],
+	pointercancel: ["PointerEvent", "MouseEvent"],
+	pointerdown: ["PointerEvent", "MouseEvent"],
+	pointerenter: ["PointerEvent", "MouseEvent"],
+	pointerleave: ["PointerEvent", "MouseEvent"],
+	pointermove: ["PointerEvent", "MouseEvent"],
+	pointerout: ["PointerEvent", "MouseEvent"],
+	pointerover: ["PointerEvent", "MouseEvent"],
+	pointerup: ["PointerEvent", "MouseEvent"],
+	keydown: ["KeyboardEvent"],
+	keypress: ["KeyboardEvent"],
+	keyup: ["KeyboardEvent"],
+	blur: ["FocusEvent"],
+	focus: ["FocusEvent"],
+	focusin: ["FocusEvent"],
+	focusout: ["FocusEvent"],
+	beforeinput: ["InputEvent"],
+	input: ["InputEvent"],
+	compositionend: ["CompositionEvent"],
+	compositionstart: ["CompositionEvent"],
+	compositionupdate: ["CompositionEvent"],
+	drag: ["DragEvent", "MouseEvent"],
+	dragend: ["DragEvent", "MouseEvent"],
+	dragenter: ["DragEvent", "MouseEvent"],
+	dragleave: ["DragEvent", "MouseEvent"],
+	dragover: ["DragEvent", "MouseEvent"],
+	dragstart: ["DragEvent", "MouseEvent"],
+	drop: ["DragEvent", "MouseEvent"],
+	touchcancel: ["TouchEvent"],
+	touchend: ["TouchEvent"],
+	touchmove: ["TouchEvent"],
+	touchstart: ["TouchEvent"],
+	wheel: ["WheelEvent", "MouseEvent"]
+};
+function requireDocument() {
+	if (typeof document === "undefined" || typeof document.createElement !== "function" || !document.body) throw new Error("@askrjs/askr/testing render requires a DOM environment. Configure Vitest with environment: \"jsdom\".");
+	return document;
+}
+function requireWindow() {
+	if (typeof window === "undefined" || !window.location || !window.history || typeof window.history.replaceState !== "function") throw new Error("@askrjs/askr/testing renderRoute requires a browser-like DOM environment. Configure Vitest with environment: \"jsdom\".");
+	return window;
+}
+function prepareContainer(options) {
+	const currentDocument = requireDocument();
+	const managed = options?.container === void 0;
+	const providedContainer = options?.container;
+	if (providedContainer !== void 0 && (!providedContainer || providedContainer.nodeType !== 1 || typeof providedContainer.querySelector !== "function" || typeof providedContainer.replaceChildren !== "function")) throw new TypeError("@askrjs/askr/testing render options.container must be an HTMLElement.");
+	const container = providedContainer ?? currentDocument.createElement("div");
+	if (renderStates.get(container)?.active) throw new Error("@askrjs/askr/testing cannot render into a container that already has an active render.");
+	if (managed) {
+		container.setAttribute("data-askr-testing-root", "");
+		currentDocument.body.appendChild(container);
+	}
+	const state = {
+		active: true,
+		managed
+	};
+	renderStates.set(container, state);
+	return {
+		container,
+		state
+	};
+}
+function getBaseEventConstructor(target) {
+	if (typeof Element !== "undefined" && target instanceof Element) return target.ownerDocument.defaultView?.Event ?? Event;
+	return Event;
+}
+function getEventConstructor(target, type) {
+	const realm = (typeof Element !== "undefined" && target instanceof Element ? target.ownerDocument.defaultView : typeof window !== "undefined" ? window : void 0) ?? globalThis;
+	for (const name of eventConstructorNames[type] ?? []) {
+		const constructor = realm[name];
+		if (typeof constructor === "function") return constructor;
+	}
+	return getBaseEventConstructor(target);
+}
+function isEventForTarget(target, value) {
+	if (value instanceof getBaseEventConstructor(target)) return true;
+	return typeof Event !== "undefined" && value instanceof Event;
+}
+function flush() {
+	flushRuntimeScheduler();
+}
+function dispatch(target, event, init = {}) {
+	if (!target || typeof target.dispatchEvent !== "function") throw new TypeError("@askrjs/askr/testing dispatch requires an EventTarget.");
+	if (typeof event !== "string" && !isEventForTarget(target, event)) throw new TypeError("@askrjs/askr/testing dispatch requires an Event instance or event type string.");
+	const dispatchedEvent = typeof event === "string" ? new (getEventConstructor(target, event))(event, {
+		bubbles: true,
+		cancelable: true,
+		...init
+	}) : event;
+	return target.dispatchEvent(dispatchedEvent);
+}
+function cleanupContainer(container) {
+	const state = renderStates.get(container);
+	if (!state?.active) return;
+	state.active = false;
+	try {
+		cleanupApp(container);
+	} finally {
+		container.replaceChildren();
+		if (state.managed) container.remove();
+		if (state.restoreHistory && state.restoreUrl) state.restoreHistory.replaceState({}, "", state.restoreUrl);
+		renderStates.delete(container);
+	}
+}
+function isRenderResult(target) {
+	return "container" in target && "cleanup" in target;
+}
+function cleanup(target) {
+	cleanupContainer(isRenderResult(target) ? target.container : target);
+}
+function createRenderResult(container) {
+	return {
+		container,
+		root: container,
+		flush,
+		dispatch,
+		unmount: () => cleanupContainer(container),
+		cleanup: () => cleanupContainer(container)
+	};
+}
+function render(component, options) {
+	if (typeof component !== "function") throw new TypeError("@askrjs/askr/testing render requires a component function.");
+	const { container } = prepareContainer(options);
+	try {
+		createIsland({
+			root: container,
+			component,
+			cleanupStrict: options?.cleanupStrict
+		});
+		flush();
+		return createRenderResult(container);
+	} catch (error) {
+		cleanupContainer(container);
+		throw error;
+	}
+}
+function mount(component, options) {
+	return render(component, options);
+}
+async function renderRoute(options) {
+	if (!options?.registry) throw new TypeError("@askrjs/askr/testing renderRoute requires a route registry.");
+	const currentWindow = requireWindow();
+	const { container, state } = prepareContainer(options);
+	try {
+		if (options.url !== void 0) {
+			state.restoreHistory = currentWindow.history;
+			state.restoreUrl = `${currentWindow.location.pathname}${currentWindow.location.search}${currentWindow.location.hash}`;
+			currentWindow.history.replaceState({}, "", options.url);
+		}
+		await createSPA({
+			root: container,
+			registry: options.registry,
+			auth: options.auth,
+			cleanupStrict: options.cleanupStrict
+		});
+		flush();
+		return createRenderResult(container);
+	} catch (error) {
+		cleanupContainer(container);
+		throw error;
+	}
+}
+//#endregion
 //#region src/testing/index.ts
 function normalizeRefresh(options) {
 	return async () => {
@@ -163,4 +342,4 @@ function getRouteWarnings(options) {
 	});
 }
 //#endregion
-export { createInvalidationRecorder, getRouteWarnings, matchRoute, mockQuery, queryState };
+export { cleanup, createInvalidationRecorder, dispatch, flush, getRouteWarnings, matchRoute, mockQuery, mount, queryState, render, renderRoute };

package/dist/{verify-hydration-ChyEiBAn.js → verify-hydration-CVSGv6Vs.js}

@@ -1,5 +1,5 @@
 import { t as SSR_RENDER_DATA_ATTR } from "./ssr-CbQO5xd3.js";
-import { a as renderResolvedToStringSync } from "./ssr-vE-KUgDV.js";
+import { a as renderResolvedToStringSync } from "./ssr-BSUA9Y64.js";
 //#region src/ssr/verify-hydration.ts
 function normalizeHydrationHtml(html) {
 	const template = document.createElement("template");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askrjs/askr",
-  "version": "0.0.69",
+  "version": "0.0.71",
   "description": "Actor-backed deterministic UI framework",
   "keywords": [
     "askr",
@@ -23,6 +23,7 @@
     "url": "git+https://github.com/askrjs/askr.git"
   },
   "files": [
+    "capabilities.json",
     "dist/**/*.js",
     "dist/**/*.d.ts"
   ],
@@ -113,7 +114,8 @@
       "types": "./dist/jsx-dev-runtime.d.ts",
       "import": "./dist/jsx-dev-runtime.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./capabilities.json": "./capabilities.json"
   },
   "publishConfig": {
     "access": "public"

package/dist/attr-names-CjhzmHOn.js

@@ -1,15 +0,0 @@
-//#region src/common/attr-names.ts
-const PUBLIC_ATTRIBUTE_NAME_MAP = {
-	className: "class",
-	htmlFor: "for",
-	strokeWidth: "stroke-width",
-	strokeLinecap: "stroke-linecap",
-	strokeLinejoin: "stroke-linejoin",
-	fillRule: "fill-rule",
-	clipRule: "clip-rule"
-};
-function getPublicAttributeName(propName) {
-	return PUBLIC_ATTRIBUTE_NAME_MAP[propName] ?? propName;
-}
-//#endregion
-export { getPublicAttributeName as t };

package/dist/component-scope-CvPba6O6.d.ts

@@ -1,12 +0,0 @@
-//#region src/runtime/component-scope.d.ts
-/**
- * Get the abort signal for the current component.
- *
- * The signal is guaranteed to be aborted when:
- * - Component unmounts
- * - Navigation occurs (different route)
- * - Parent is destroyed
- */
-declare function getSignal(): AbortSignal;
-//#endregion
-export { getSignal as t };

package/dist/invalidation-listeners-Des3AHYs.js

@@ -1,13 +0,0 @@
-//#region src/data/invalidation-listeners.ts
-const invalidationListeners = /* @__PURE__ */ new Set();
-function addInvalidationListener(listener) {
-	invalidationListeners.add(listener);
-	return () => {
-		invalidationListeners.delete(listener);
-	};
-}
-function emitInvalidation(event) {
-	for (const listener of invalidationListeners) listener(event);
-}
-//#endregion
-export { emitInvalidation as n, addInvalidationListener as t };

package/dist/jsx-runtime-X2SX2y8V.d.ts

@@ -1,2 +0,0 @@
-import "./types-DEhT-Nrv.js";
-import "./jsx-runtime-aYZ8zb4q.js";