@askrjs/askr 0.3.0 → 0.4.0

package/dist/browser-activity-CB8e-V4f.js

@@ -0,0 +1,220 @@
+import { S as queueTask, d as recordUndo, v as effectScheduler, w as Computation } from "./instance-BAnfmXOR.js";
+import { c as onCommit, d as reportLifecycleError, f as withOwner, i as currentComponent, o as hookSlot } from "./hooks-BimKStr4.js";
+import { t as isRouteActivityActive } from "./route-activity-CNJfpwx-.js";
+//#region src/core/api/lifecycle.ts
+/**
+* Component lifecycle hooks: work that starts after a render commits and
+* ends with the component. Each is a no-op outside a component render and
+* never starts on the server.
+*/
+/** Run `fn` once after the component's first commit; a returned function is its cleanup. */
+function task(fn) {
+	const instance = currentComponent();
+	if (!instance) return;
+	const slot = hookSlot(instance, "task", () => ({
+		started: false,
+		fn
+	}));
+	if (slot.started || instance.server) return;
+	const previous = slot.fn;
+	slot.fn = fn;
+	recordUndo(() => {
+		slot.fn = previous;
+	});
+	onCommit(instance, () => {
+		if (slot.started) return;
+		slot.started = true;
+		try {
+			return withOwner(instance, slot.fn);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	});
+}
+/** Snapshot `fn()` now and return a thunk that yields that value later. */
+function capture(fn) {
+	const value = fn();
+	return () => value;
+}
+function sameValues(previous, next) {
+	if (Array.isArray(previous) && Array.isArray(next)) {
+		if (previous.length !== next.length) return false;
+		return previous.every((value, index) => Object.is(value, next[index]));
+	}
+	return Object.is(previous, next);
+}
+function stopGeneration(slot) {
+	const controller = slot.controller;
+	slot.controller = null;
+	if (controller && !controller.signal.aborted) controller.abort();
+	const cleanup = slot.cleanup;
+	slot.cleanup = null;
+	cleanup?.();
+}
+function observe(instance, slot, value, previous) {
+	stopGeneration(slot);
+	const controller = new AbortController();
+	slot.controller = controller;
+	const initial = !slot.observed;
+	slot.observed = true;
+	let result;
+	try {
+		result = withOwner(instance, () => slot.callback(value, {
+			initial,
+			previous,
+			signal: controller.signal
+		}));
+	} catch (error) {
+		reportLifecycleError(instance, error);
+		return;
+	}
+	if (typeof result === "function") slot.cleanup = result;
+	else if (result && typeof result.then === "function") Promise.resolve(result).catch((error) => {
+		if (!controller.signal.aborted) reportLifecycleError(instance, error);
+	});
+}
+function startWatch(instance, slot) {
+	if (slot.effect) {
+		slot.effect.invalidate();
+		return;
+	}
+	const effect = new Computation(instance, () => {
+		let value;
+		try {
+			const values = slot.sources.map((source) => source());
+			value = values.length === 1 ? values[0] : values;
+		} catch (error) {
+			reportLifecycleError(instance, error);
+			return;
+		}
+		if (slot.version > 0 && sameValues(slot.value, value)) return;
+		slot.value = value;
+		const version = ++slot.version;
+		queueTask(() => {
+			if (instance.disposed || version !== slot.version) return;
+			const previous = slot.deliveredValue;
+			slot.deliveredValue = value;
+			observe(instance, slot, value, previous);
+		});
+	}, effectScheduler("post", instance.depth, () => {
+		reportLifecycleError(instance, /* @__PURE__ */ new Error("[Askr] reactive cycle in watch(): the source changed in its own callback."));
+	}, 48), null);
+	slot.effect = effect;
+	instance.onCleanup(() => {
+		stopGeneration(slot);
+		slot.effect = null;
+	});
+	effect.run();
+}
+function watch(sourceOrSources, callback) {
+	const instance = currentComponent();
+	if (!instance) return;
+	const sources = Array.isArray(sourceOrSources) ? sourceOrSources : [sourceOrSources];
+	const slot = hookSlot(instance, "watch", () => ({
+		sources,
+		callback,
+		effect: null,
+		controller: null,
+		cleanup: null,
+		observed: false,
+		value: void 0,
+		deliveredValue: void 0,
+		version: 0
+	}));
+	if (instance.server) return;
+	onCommit(instance, () => {
+		slot.sources = sources;
+		slot.callback = callback;
+		startWatch(instance, slot);
+	});
+}
+function predicatesOf(when) {
+	if (!when) return [];
+	return typeof when === "function" ? [when] : when;
+}
+/** Run `fn` every `intervalMs` while the component lives and `options.when` passes. */
+function timer(intervalMs, fn, options) {
+	const instance = currentComponent();
+	if (!instance) return;
+	const slot = hookSlot(instance, "timer", () => ({
+		id: null,
+		intervalMs: null,
+		callback: fn,
+		predicates: predicatesOf(options?.when)
+	}));
+	if (instance.server) return;
+	const predicates = predicatesOf(options?.when);
+	onCommit(instance, () => {
+		slot.callback = fn;
+		slot.predicates = predicates;
+		if (slot.id !== null && slot.intervalMs === intervalMs) return;
+		const first = slot.id === null && slot.intervalMs === null;
+		if (slot.id !== null) clearInterval(slot.id);
+		slot.intervalMs = intervalMs;
+		slot.id = setInterval(() => {
+			if (slot.predicates.every((predicate) => predicate())) slot.callback();
+		}, intervalMs);
+		if (first) instance.onCleanup(() => {
+			if (slot.id !== null) clearInterval(slot.id);
+			slot.id = null;
+		});
+	});
+}
+/** An {@link ActivityPredicate} that is true while the current route matches. */
+function routeActive(pathOrPaths) {
+	return () => isRouteActivityActive(pathOrPaths);
+}
+function sameOptions(a, b) {
+	if (a === b) return true;
+	if (typeof a !== "object" || typeof b !== "object" || !a || !b) return false;
+	return a.capture === b.capture && a.once === b.once && a.passive === b.passive && a.signal === b.signal;
+}
+/** Attach an event listener to `target` for the component's lifetime. */
+function on(target, event, handler, options) {
+	const instance = currentComponent();
+	if (!instance) return;
+	const slot = hookSlot(instance, "on", () => {
+		const created = {
+			target: null,
+			event,
+			options: void 0,
+			handler,
+			attached: false,
+			listener: ((evt) => {
+				created.handler.call(created.target, evt);
+			})
+		};
+		return created;
+	});
+	if (instance.server) return;
+	onCommit(instance, () => {
+		slot.handler = handler;
+		const resolved = typeof target === "function" ? target() ?? null : target;
+		if (slot.attached && slot.target === resolved && slot.event === event && sameOptions(slot.options, options)) return;
+		const first = !slot.attached && slot.target === null;
+		if (slot.attached && slot.target) slot.target.removeEventListener(slot.event, slot.listener, slot.options);
+		slot.attached = false;
+		slot.target = resolved;
+		slot.event = event;
+		slot.options = options;
+		if (resolved) {
+			resolved.addEventListener(event, slot.listener, options);
+			slot.attached = true;
+		}
+		if (first) instance.onCleanup(() => {
+			if (slot.attached && slot.target) slot.target.removeEventListener(slot.event, slot.listener, slot.options);
+			slot.attached = false;
+		});
+	});
+}
+//#endregion
+//#region src/resources/browser-activity.ts
+/** Activity gates retain their permissive server defaults. */
+function documentVisible() {
+	return () => typeof document === "undefined" || document.visibilityState !== "hidden";
+}
+function windowFocused() {
+	return () => typeof document === "undefined" || typeof document.hasFocus !== "function" || document.hasFocus();
+}
+//#endregion
+export { routeActive as a, watch as c, on as i, windowFocused as n, task as o, capture as r, timer as s, documentVisible as t };

package/dist/components/index.d.ts

@@ -2,6 +2,12 @@ import { VNode } from '../core.js';
 import { JSXElement, Props } from '../elements.js';
 type ErrorBoundaryContent = VNode | readonly VNode[];
 type ErrorBoundaryFallbackValue = ErrorBoundaryContent | Node;
+/** A child of an {@link ErrorBoundary}; a raw DOM `Node` is not a child. */
+type ErrorBoundaryChild =
+  | VNode
+  | JSXElement
+  | (() => unknown)
+  | readonly ErrorBoundaryChild[];
 /** Renders a fallback for the caught error; call `reset` to retry the children. */
 type ErrorBoundaryFallbackRender = (
   error: unknown,
@@ -9,7 +15,8 @@ type ErrorBoundaryFallbackRender = (
 ) => ErrorBoundaryFallbackValue;
 /** Props for {@link ErrorBoundary}. */
 interface ErrorBoundaryProps extends Props {
-  children?: ErrorBoundaryContent;
+  /** Boundary content: nodes, elements, function children, or a list of them. */
+  children?: ErrorBoundaryChild;
   /** Static fallback content, or a render function receiving the error and a reset callback. */
   fallback?: ErrorBoundaryFallbackValue | ErrorBoundaryFallbackRender;
   /** Called with the caught error when the boundary trips. */

package/dist/components/index.js

@@ -1,44 +1,2 @@
-import { f as getCurrentComponentInstance } from "../scope-Cq_iYbTR.js";
-import { t as __ERROR_BOUNDARY__ } from "../vnode-D24p6IW2.js";
-import { t as ELEMENT_TYPE } from "../jsx-DRS-qjiN.js";
-//#region src/components/error-boundary.tsx
-function ensureBoundaryState(instance, resetKey) {
-	const boundaryState = instance.errorBoundaryState ?? (instance.errorBoundaryState = {
-		error: null,
-		resetKey,
-		notified: false
-	});
-	if (!Object.is(boundaryState.resetKey, resetKey)) {
-		boundaryState.error = null;
-		boundaryState.resetKey = resetKey;
-		boundaryState.notified = false;
-	}
-	return boundaryState;
-}
-function createBoundaryVNode(instance, props) {
-	const key = typeof props.key === "symbol" ? null : props.key ?? null;
-	return {
-		$$typeof: ELEMENT_TYPE,
-		type: __ERROR_BOUNDARY__,
-		props: {
-			children: props.children,
-			fallback: props.fallback,
-			onError: props.onError,
-			resetKey: props.resetKey
-		},
-		key,
-		__instance: instance
-	};
-}
-/**
-* Creates a boundary for descendant mount and post-mount render/commit errors,
-* including content materialized through a portal host.
-*/
-function ErrorBoundary(props) {
-	const instance = getCurrentComponentInstance();
-	if (!instance) throw new Error("[Askr] ErrorBoundary() can only be used during component render execution.");
-	ensureBoundaryState(instance, props.resetKey);
-	return createBoundaryVNode(instance, props);
-}
-//#endregion
+import { t as ErrorBoundary } from "../error-boundary-Bpwofwps.js";
 export { ErrorBoundary };

package/dist/{aria-hKjThHcp.js → compose-ref-DWzdbxsD.js}

@@ -25,6 +25,8 @@ function noop() {}
 *
 * Deterministic props merging.
 * - For non-handlers: `base` overwrites `injected`.
+* - A `base` value of `undefined` means "not provided" and never overwrites an
+*   `injected` value; pass `null` to clear an injected prop explicitly.
 * - For handlers present in both: handlers are composed with `injected` running
 *   first; it may call `preventDefault()` to suppress the `base` handler.
 *
@@ -42,15 +44,24 @@ function noop() {}
 *    Injected handler runs first, base handler second.
 *    This allows injected handlers to prevent default.
 *
-* 4. Return Type
-*    Returns intersection type (TInjected & TBase) for type safety.
+* 4. Undefined Means Absent
+*    A `base` key whose value is `undefined` does not override `injected`.
+*    Forwarding an optional prop that was not supplied
+*    (`onClick={props.onClick}`) must not wipe injected behaviour or ARIA.
+*    `null` is an explicit value and still overrides (base wins).
+*
+* 5. Return Type
+*    Returns MergedProps<TBase, TInjected>: base value types win unless they
+*    may be undefined, in which case the injected type is included.
 */
 function isEventHandlerKey(key) {
 	return key.startsWith("on");
 }
 /**
 * Merge `base` props over `injected` props: non-handler keys in `base` win,
-* and matching event handlers are composed (`injected` runs first).
+* and matching event handlers are composed (`injected` runs first). `base`
+* values that are `undefined` are treated as absent and never overwrite an
+* injected value; use `null` to clear one explicitly.
 */
 function mergeProps(base, injected) {
 	const baseKeys = Object.keys(base);
@@ -59,6 +70,7 @@ function mergeProps(base, injected) {
 	for (const key of baseKeys) {
 		const baseValue = base[key];
 		const injectedValue = injected[key];
+		if (baseValue === void 0 && Object.prototype.hasOwnProperty.call(out, key)) continue;
 		if (isEventHandlerKey(key) && typeof baseValue === "function" && typeof injectedValue === "function") {
 			out[key] = composeHandlers(injectedValue, baseValue);
 			continue;
@@ -85,4 +97,29 @@ function ariaSelected(selected) {
 	return selected === void 0 ? {} : { "aria-selected": String(selected) };
 }
 //#endregion
-export { composeHandlers as a, mergeProps as i, ariaExpanded as n, ariaSelected as r, ariaDisabled as t };
+//#region src/foundations/utilities/compose-ref.ts
+/** Write `value` to a {@link Ref}, ignoring failures on readonly object refs. */
+function setRef(ref, value) {
+	if (!ref) return;
+	if (typeof ref === "function") {
+		ref(value);
+		return;
+	}
+	try {
+		ref.current = value;
+	} catch {}
+}
+/** Combine multiple refs into one callback ref that writes to all of them. */
+function composeRefs(...refs) {
+	return (value) => {
+		const errors = [];
+		for (const ref of refs) try {
+			setRef(ref, value);
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw new AggregateError(errors, "Composed ref callbacks failed");
+	};
+}
+//#endregion
+export { ariaSelected as a, ariaExpanded as i, setRef as n, mergeProps as o, ariaDisabled as r, composeHandlers as s, composeRefs as t };

package/dist/control/index.d.ts

@@ -6,6 +6,7 @@ import {
   Match,
   MatchProps,
   ForProps,
+  ForGetterProps,
   Case,
 } from '../core.js';
 export {
@@ -13,6 +14,7 @@ export {
   type CaseProps,
   For,
   type ForProps,
+  type ForGetterProps,
   Match,
   type MatchProps,
   Show,

package/dist/control/index.js

@@ -1,2 +1,2 @@
-import { i as For, n as Match, r as Show, t as Case } from "../control-BR_mrX__.js";
+import { i as Show, n as For, r as Match, t as Case } from "../control-nfpT2fbK.js";
 export { Case, For, Match, Show };

package/dist/control-nfpT2fbK.js

@@ -0,0 +1,209 @@
+import { F as logger, I as isDevelopmentEnvironment, T as Signal, d as recordUndo, h as isRendering } from "./instance-BAnfmXOR.js";
+import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
+import { c as onCommit, i as currentComponent, o as hookSlot } from "./hooks-BimKStr4.js";
+//#region src/core/api/control.ts
+/**
+* Control flow as ordinary components.
+*
+* `Show`, `Case`, and `For` are element types like any other component: they
+* render lazily in their own lifetime, read their sources in their own
+* render, and never claim hook slots in the component that uses them. A
+* branch is wrapped in a keyed fragment so switching branches replaces the
+* branch's lifetime instead of patching one branch's DOM into another's.
+*/
+function element(type, props, key = null) {
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type,
+		props,
+		key
+	};
+}
+function branch(key, children) {
+	return element(Fragment, { children }, key);
+}
+function resolve(value) {
+	return typeof value === "function" ? value() : value;
+}
+function isPresent(value) {
+	return value !== null && value !== void 0 && value !== false;
+}
+/** Render `children` while `when` is truthy, otherwise `fallback`. */
+function Show(props) {
+	const value = resolve(props.when);
+	if (value) return branch("show:when", typeof props.children === "function" ? props.children(value) : props.children);
+	return isPresent(props.fallback) ? branch("show:fallback", props.fallback) : null;
+}
+/** Declares one branch of a {@link Case}; only valid as its direct child. */
+function Match(_props) {
+	throw new Error("[askr] <Match> may only be used as a direct child of <Case>.");
+}
+function flatten(children, out = []) {
+	if (Array.isArray(children)) for (const child of children) flatten(child, out);
+	else if (isPresent(children)) out.push(children);
+	return out;
+}
+/** Render the first {@link Match} whose `when` is truthy, else `fallback`. */
+function Case(props) {
+	const children = flatten(props.children);
+	for (let index = 0; index < children.length; index++) {
+		const child = children[index];
+		if (typeof child !== "object" || child === null || child.type !== Match) throw new Error("[askr] <Case> only accepts <Match> children.");
+	}
+	for (let index = 0; index < children.length; index++) {
+		const child = children[index];
+		const matchProps = child.props;
+		if (!resolve(matchProps.when)) continue;
+		return branch(child.key == null ? `match:${index}` : `match:${index}:${typeof child.key}:${String(child.key)}`, resolve(matchProps.children));
+	}
+	return isPresent(props.fallback) ? branch("case:fallback", props.fallback) : null;
+}
+/** One list row: re-renders only when its item or the row callback changes. */
+function ForRow(props) {
+	return props.render(props.row.readItem(), props.row.readIndex);
+}
+function recordRowUndo(undo) {
+	if (isRendering() && !currentComponent()?.server) recordUndo(undo);
+}
+function createRow(index, item) {
+	const indexSource = new Signal(index);
+	const source = new Signal(item);
+	const overlay = /* @__PURE__ */ new Map();
+	const deleted = /* @__PURE__ */ new Set();
+	/** One signal per property a reader has read through the proxy. */
+	const properties = /* @__PURE__ */ new Map();
+	let proxy = null;
+	const readProperty = (key) => {
+		let property = properties.get(key);
+		if (!property) {
+			property = new Signal(Reflect.get(source.peek(), key));
+			properties.set(key, property);
+			recordRowUndo(() => properties.delete(key));
+		}
+		return property.read();
+	};
+	return {
+		index: indexSource,
+		readIndex: () => indexSource.read(),
+		source,
+		readItem: () => {
+			const item = source.peek();
+			if (typeof item !== "object" || item === null || Array.isArray(item)) return item;
+			if (proxy) return proxy;
+			proxy = new Proxy({}, {
+				get(_target, key) {
+					if (deleted.has(key)) return void 0;
+					const own = overlay.get(key);
+					if (own) return own.get ? own.get.call(proxy) : own.value;
+					return readProperty(key);
+				},
+				set(_target, key, value) {
+					const previous = overlay.get(key);
+					if (!previous && typeof key !== "symbol" && isDevelopmentEnvironment() && key in Object(source.peek())) logger.warn(`[Askr] Assigning to "${String(key)}" on a <For> item shadows a property from the source data - it will not update when the source item changes and does not trigger a re-render. Use a different property name for cached/derived per-row values, or a state() cell for values that should be reactive.`);
+					const wasDeleted = deleted.delete(key);
+					overlay.set(key, {
+						value,
+						writable: true,
+						enumerable: true,
+						configurable: true
+					});
+					recordRowUndo(() => {
+						if (previous) overlay.set(key, previous);
+						else overlay.delete(key);
+						if (wasDeleted) deleted.add(key);
+					});
+					return true;
+				},
+				has(_target, key) {
+					return !deleted.has(key) && (overlay.has(key) || Reflect.has(source.read(), key));
+				},
+				ownKeys() {
+					return [...overlay.keys(), ...Reflect.ownKeys(source.read()).filter((key) => !overlay.has(key) && !deleted.has(key))];
+				},
+				getOwnPropertyDescriptor(_target, key) {
+					if (deleted.has(key)) return void 0;
+					const descriptor = overlay.get(key) ?? Reflect.getOwnPropertyDescriptor(source.read(), key);
+					return descriptor ? {
+						...descriptor,
+						configurable: true
+					} : void 0;
+				},
+				getPrototypeOf() {
+					return Reflect.getPrototypeOf(source.read());
+				},
+				deleteProperty(_target, key) {
+					const previous = overlay.get(key);
+					const wasDeleted = deleted.has(key);
+					overlay.delete(key);
+					deleted.add(key);
+					recordRowUndo(() => {
+						if (previous) overlay.set(key, previous);
+						if (!wasDeleted) deleted.delete(key);
+					});
+					return true;
+				}
+			});
+			return proxy;
+		},
+		writeItem(item) {
+			const previousItem = source.peek();
+			if (!source.write(item)) return;
+			recordRowUndo(() => {
+				source.write(previousItem);
+			});
+			if (typeof item !== "object" || item === null) return;
+			for (const [key, property] of properties) {
+				const previous = property.peek();
+				if (property.write(Reflect.get(item, key))) recordRowUndo(() => {
+					property.write(previous);
+				});
+			}
+		}
+	};
+}
+function validateKey(key, index) {
+	if (key === null || key === void 0) throw new Error(`[askr] Invalid For key detected at index ${index}: ${String(key)}. Keys should be stable, non-null, and unique within a For list.`);
+}
+function For(props) {
+	const by = props.by;
+	if (!by && props.byIndex !== true) throw new Error("[Askr] <For> requires a stable `by` key function or `byIndex={true}`.");
+	if (by && props.byIndex) throw new Error("[Askr] <For> accepts `by` or `byIndex`, not both.");
+	const instance = currentComponent();
+	const rows = instance ? hookSlot(instance, "for", () => /* @__PURE__ */ new Map()) : /* @__PURE__ */ new Map();
+	const items = resolve(props.each) ?? [];
+	if (items.length === 0) {
+		if (instance) onCommit(instance, () => rows.clear());
+		return isPresent(props.fallback) ? branch("for:fallback", props.fallback) : null;
+	}
+	const output = [];
+	const live = /* @__PURE__ */ new Set();
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index];
+		const key = by ? by(item, index) : index;
+		validateKey(key, index);
+		if (live.has(key)) throw new Error(`[askr] Duplicate For key detected: ${String(key)}. Keys should be stable, non-null, and unique within a For list.`);
+		let row = rows.get(key);
+		if (!row) {
+			row = createRow(index, item);
+			rows.set(key, row);
+			recordRowUndo(() => rows.delete(key));
+		} else {
+			const indexSource = row.index;
+			const previous = indexSource.peek();
+			if (indexSource.write(index)) recordRowUndo(() => indexSource.write(previous));
+			row.writeItem(item);
+		}
+		live.add(key);
+		output.push(element(ForRow, {
+			item,
+			row,
+			render: props.children
+		}, key));
+	}
+	if (instance) onCommit(instance, () => {
+		for (const key of rows.keys()) if (!live.has(key)) rows.delete(key);
+	});
+	return output;
+}
+//#endregion
+export { Show as i, For as n, Match as r, Case as t };

package/dist/core.d.ts

@@ -1,4 +1,7 @@
-/** Compatibility re-export surface for maintained domain contracts. */
+/**
+ * Aggregates the maintained domain contracts in `domains/` so entrypoint
+ * declarations can import them from one module. Not a package subpath.
+ */
 import './jsx-globals.js';
 export {
   selector,
@@ -113,14 +116,6 @@ export {
 } from './domains/routing.js';
 export { getSignal } from './domains/component.js';
 export { scheduleEventHandler } from './domains/scheduler.js';
-export {
-  RuntimeKeyedReorderDecision,
-  getDefaultRuntime,
-  RuntimeRendererHost,
-  AskrRuntime,
-  AskrRuntimeOptions,
-  createRuntime,
-} from './domains/renderer.js';
 export {
   Show,
   ShowProps,
@@ -129,6 +124,7 @@ export {
   Match,
   MatchProps,
   ForProps,
+  ForGetterProps,
   Case,
 } from './domains/control.js';
 export {

package/dist/csp-nonce-DwGw1A6Q.js

@@ -0,0 +1,35 @@
+import { n as isScopeReadable, r as readScope, t as defineScope } from "./scope-CwpVSHVf.js";
+//#region src/csp-nonce.ts
+/** Lexical scope carrying the CSP nonce for the current render, if any. */
+const CspNonceScope = defineScope(void 0);
+/**
+* Read the CSP nonce for the current render from {@link CspNonceScope}.
+*
+* @returns The active nonce, or `undefined` when called outside of a
+* component render or when no nonce was configured.
+*/
+function cspNonce() {
+	return isScopeReadable() ? readScope(CspNonceScope) : void 0;
+}
+function validateCspNonce(value) {
+	if (value === void 0) return void 0;
+	const invalid = () => {
+		throw new TypeError("CSP nonce must be valid base64 or base64url encoding at least 16 bytes.");
+	};
+	if (value.length === 0 || !/^[A-Za-z0-9+/_-]+={0,2}$/.test(value) || value.length % 4 === 1 || /=/.test(value.slice(0, -2))) invalid();
+	const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+	let end = normalized.length;
+	while (end > 0 && normalized[end - 1] === "=") end--;
+	const unpadded = normalized.slice(0, end);
+	const padded = unpadded.padEnd(Math.ceil(unpadded.length / 4) * 4, "=");
+	let decoded = "";
+	try {
+		decoded = atob(padded);
+	} catch {
+		invalid();
+	}
+	if (decoded.length < 16) invalid();
+	return value;
+}
+//#endregion
+export { cspNonce as n, validateCspNonce as r, CspNonceScope as t };

package/dist/data/index.js

@@ -1,4 +1,4 @@
-import { i as getDefaultDataRuntime, t as createDataRuntime } from "../data-runtime-CxoY98lX.js";
-import { c as createMutation, d as queryScope, l as invalidate, n as createQuery, t as createQueryCollection, u as invalidateOnInterval } from "../data-2edW0jhF.js";
-import { a as hydrateDataRuntime, i as dehydrateDataRuntime, n as defineQuery, o as prefetchQuery, r as defineServerQueries, s as serveQuery, t as createQueryPrefetchContext } from "../query-registry-LrYpQsDJ.js";
+import { a as hydrateDataRuntime, i as dehydrateDataRuntime, n as defineQuery, o as prefetchQuery, r as defineServerQueries, s as serveQuery, t as createQueryPrefetchContext } from "../query-registry-WMCN0BJL.js";
+import { a as getDefaultDataRuntime, t as createDataRuntime } from "../data-runtime-C1bFAlba.js";
+import { c as createMutation, d as queryScope, l as invalidate, n as createQuery, t as createQueryCollection, u as invalidateOnInterval } from "../data-BCwClJiF.js";
 export { createDataRuntime, createMutation, createQuery, createQueryCollection, createQueryPrefetchContext, defineQuery, defineServerQueries, dehydrateDataRuntime, getDefaultDataRuntime, hydrateDataRuntime, invalidate, invalidateOnInterval, prefetchQuery, queryScope, serveQuery };