coldwired 0.18.0

package/dist/turbo-stream.mjs

@@ -0,0 +1,72 @@
+import { _ as invariant, h as isValidActionName } from "./actions-k0j8z15o.mjs";
+import { z as parseHTMLFragment } from "./utils-C2S0wWJJ.mjs";
+//#region src/turbo-stream.ts
+async function renderTurboStream(actions, stream) {
+	actions.applyActions([...parseHTMLFragment(stream, actions.element.ownerDocument).children].map(parseTurboStream));
+	await actions.ready();
+}
+function parseTurboStream(stream) {
+	invariant(stream.tagName == "TURBO-STREAM", "[turbo-stream] element must be a <turbo-stream>");
+	const action = parseActionName(stream);
+	if (action == "refresh") return {
+		action,
+		targets: ""
+	};
+	const delay = parseDelay(stream);
+	const pin = parsePin(stream);
+	const targets = parseTargets(stream);
+	const fragment = parseTemplate(stream);
+	switch (action) {
+		case "after":
+		case "before":
+		case "update":
+		case "replace":
+		case "append":
+		case "prepend":
+			invariant(fragment, "[turbo-stream] template is required");
+			return {
+				action,
+				delay,
+				pin,
+				targets,
+				fragment
+			};
+		default: return {
+			action,
+			delay,
+			pin,
+			targets
+		};
+	}
+}
+function parseActionName(stream) {
+	const actionName = stream.getAttribute("action");
+	invariant(isValidActionName(actionName), `[actions] action "${actionName}" is not supported`);
+	return actionName;
+}
+function parsePin(stream) {
+	const pin = stream.getAttribute("pin");
+	if (pin == "" || pin == "true") return true;
+	else if (pin == "last") return "last";
+}
+function parseDelay(stream) {
+	const delay = stream.getAttribute("delay");
+	if (delay) return parseInt(delay);
+}
+function parseTargets(stream) {
+	const target = stream.getAttribute("target");
+	const targets = stream.getAttribute("targets");
+	invariant(targets || target, "[turbo-stream] \"target\" or \"targets\" attributes are required");
+	if (targets) return targets;
+	return `#${target}`;
+}
+function parseTemplate(stream) {
+	const templateElement = stream.firstElementChild;
+	if (!templateElement) return;
+	invariant(templateElement instanceof HTMLTemplateElement, "[turbo-stream] first child element must be a <template> element");
+	const templateContent = templateElement.content;
+	templateContent.normalize();
+	return templateContent;
+}
+//#endregion
+export { parseTurboStream, renderTurboStream };

package/dist/utils-C2S0wWJJ.mjs

@@ -0,0 +1,350 @@
+//#region node_modules/just-debounce-it/index.mjs
+var functionDebounce = debounce$1;
+function debounce$1(fn, wait, callFirst) {
+	var timeout = null;
+	var debouncedFn = null;
+	var clear = function() {
+		if (timeout) {
+			clearTimeout(timeout);
+			debouncedFn = null;
+			timeout = null;
+		}
+	};
+	var flush = function() {
+		var call = debouncedFn;
+		clear();
+		if (call) call();
+	};
+	var debounceWrapper = function() {
+		if (!wait) return fn.apply(this, arguments);
+		var context = this;
+		var args = arguments;
+		var callNow = callFirst && !timeout;
+		clear();
+		debouncedFn = function() {
+			fn.apply(context, args);
+		};
+		timeout = setTimeout(function() {
+			timeout = null;
+			if (!callNow) {
+				var call = debouncedFn;
+				debouncedFn = null;
+				return call();
+			}
+		}, wait);
+		if (callNow) return debouncedFn();
+	};
+	debounceWrapper.cancel = clear;
+	debounceWrapper.flush = flush;
+	return debounceWrapper;
+}
+//#endregion
+//#region node_modules/just-throttle/index.mjs
+var functionThrottle = throttle$1;
+function throttle$1(fn, interval, options) {
+	var timeoutId = null;
+	var throttledFn = null;
+	var leading = options && options.leading;
+	var trailing = options && options.trailing;
+	if (leading == null) leading = true;
+	if (trailing == null) trailing = !leading;
+	if (leading == true) trailing = false;
+	var cancel = function() {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+	};
+	var flush = function() {
+		var call = throttledFn;
+		cancel();
+		if (call) call();
+	};
+	var throttleWrapper = function() {
+		var callNow = leading && !timeoutId;
+		var context = this;
+		var args = arguments;
+		throttledFn = function() {
+			return fn.apply(context, args);
+		};
+		if (!timeoutId) timeoutId = setTimeout(function() {
+			timeoutId = null;
+			if (trailing) return throttledFn();
+		}, interval);
+		if (callNow) {
+			callNow = false;
+			return throttledFn();
+		}
+	};
+	throttleWrapper.cancel = cancel;
+	throttleWrapper.flush = flush;
+	return throttleWrapper;
+}
+//#endregion
+//#region src/utils.ts
+function expandURL(locatable) {
+	return new URL(locatable.toString(), document.baseURI);
+}
+function relativeURL(url) {
+	return `${url.pathname}${url.search}`;
+}
+function dispatch(eventName, { target, cancelable, detail } = {}) {
+	const event = new CustomEvent(eventName, {
+		cancelable,
+		bubbles: true,
+		detail
+	});
+	if (target && target.isConnected) target.dispatchEvent(event);
+	else document.documentElement.dispatchEvent(event);
+	return event;
+}
+const DEFAULT_INTERVAL = 500;
+function debounce(target, callback, interval) {
+	let fn = debounced.get(target);
+	if (!fn) {
+		if (interval != 0) {
+			fn = functionDebounce(callback, interval ?? DEFAULT_INTERVAL);
+			debounced.set(target, fn);
+		}
+	}
+	(fn ?? callback)();
+}
+const debounced = /* @__PURE__ */ new WeakMap();
+function cancelDebounce(target) {
+	debounced.get(target)?.cancel();
+}
+function throttle(target, callback, interval) {
+	let fn = throttled.get(target);
+	if (!fn) {
+		if (interval != 0) {
+			fn = functionThrottle(callback, interval ?? DEFAULT_INTERVAL);
+			throttled.set(target, fn);
+		}
+	}
+	(fn ?? callback)();
+}
+const throttled = /* @__PURE__ */ new WeakMap();
+function cancelThrottle(target) {
+	throttled.get(target)?.cancel();
+}
+function parseIntWithDefault(value, defaultValue = 0) {
+	return value ? parseInt(value) : defaultValue;
+}
+function isElement(node) {
+	return isNode(node) && node.nodeType == Node.ELEMENT_NODE;
+}
+function isHTMLElement(node) {
+	return isElement(node) && "style" in node;
+}
+function isButtonElement(node) {
+	return isElement(node) && node.tagName == "BUTTON";
+}
+function isAnchorElement(node) {
+	return isElement(node) && node.tagName == "A";
+}
+function isLinkElement(node) {
+	return isElement(node) && node.tagName == "LINK";
+}
+function isFormElement(node) {
+	return isElement(node) && node.tagName == "FORM";
+}
+function isSubmitterElement(node) {
+	return isButtonElement(node) || isInputElement(node);
+}
+function isInputElement(node) {
+	return isElement(node) && node.tagName == "INPUT";
+}
+function isFormInputElement(node) {
+	return isElement(node) && [
+		"INPUT",
+		"TEXTAREA",
+		"SELECT"
+	].includes(node.tagName);
+}
+function isTextAreaElement(node) {
+	return isElement(node) && node.tagName == "TEXTAREA";
+}
+function isSelectElement(node) {
+	return isElement(node) && node.tagName == "SELECT";
+}
+function isFormOptionElement(node) {
+	return isElement(node) && node.tagName == "OPTION";
+}
+function isDateInputElement(node) {
+	return isInputElement(node) && isDateType(node.type);
+}
+function isNumberInputElement(node) {
+	return isInputElement(node) && node.type == "number";
+}
+function isCheckboxInputElement(node) {
+	return isInputElement(node) && node.type == "checkbox";
+}
+function isRadioInputElement(node) {
+	return isInputElement(node) && node.type == "radio";
+}
+function isRangeInputElement(node) {
+	return isInputElement(node) && node.type == "range";
+}
+function isColorInputElement(node) {
+	return isInputElement(node) && node.type == "color";
+}
+function isFileInputElement(node) {
+	return isInputElement(node) && node.type == "file";
+}
+function isHiddenInputElement(node) {
+	return isInputElement(node) && node.type == "hidden";
+}
+function isTextInputElement(node) {
+	return isTextAreaElement(node) || isInputElement(node) && isTextType(node.type);
+}
+function isInputableElement(node) {
+	return isTextAreaElement(node) || isInputElement(node) && isInputableType(node.type);
+}
+function isChangeableElement(node) {
+	return isSelectElement(node) || isInputElement(node) && isChangeableType(node.type);
+}
+function isElementOrText(node) {
+	return isNode(node) && (node.nodeType == Node.TEXT_NODE || node.nodeType == Node.ELEMENT_NODE);
+}
+function isNode(node) {
+	return !!node && "nodeType" in node;
+}
+function isFocused(element) {
+	return element.ownerDocument.activeElement == element;
+}
+function focusElement(element) {
+	if ("focus" in element && typeof element.focus == "function") {
+		element.focus();
+		if (isInputableElement(element)) try {
+			element.setSelectionRange(element.value.length, element.value.length);
+		} catch {}
+	}
+}
+function focusNextElement(element, options) {
+	const activeElement = element.ownerDocument.activeElement;
+	if (activeElement && (element == activeElement || element.contains(activeElement))) {
+		const nextFocusedElement = getNextFocusableElement(element, activeElement, options);
+		if (nextFocusedElement) focusElement(nextFocusedElement);
+	}
+}
+function parseHTMLDocument(html) {
+	return new DOMParser().parseFromString(html, "text/html");
+}
+function parseHTMLFragment(html, ownerDocument) {
+	const template = ownerDocument.createElement("template");
+	template.innerHTML = html;
+	const fragment = template.content;
+	fragment.normalize();
+	return fragment;
+}
+function domReady() {
+	return new Promise((resolve) => {
+		if (document.readyState == "loading") document.addEventListener("DOMContentLoaded", () => resolve(), { once: true });
+		else resolve();
+	});
+}
+function nextAnimationFrame() {
+	return new Promise((resolve) => requestAnimationFrame(() => resolve()));
+}
+var AbortError = class extends Error {};
+function wait(delay, signal) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(resolve, delay);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			reject(new AbortError("Aborted"));
+		}, { once: true });
+	});
+}
+function groupBy(array, predicat) {
+	return array.reduce((map, entry) => {
+		const key = predicat(entry);
+		const entries = map.get(key);
+		if (!entries) map.set(key, [entry]);
+		else entries.push(entry);
+		return map;
+	}, /* @__PURE__ */ new Map());
+}
+function partition(array, predicat) {
+	return array.reduce((parts, entry) => {
+		if (predicat(entry)) parts[0].push(entry);
+		else parts[1].push(entry);
+		return parts;
+	}, [[], []]);
+}
+function getNextFocusableElement(element, activeElement, options) {
+	const focusDirectionAttribute = options?.focusDirectionAttribute;
+	const focusGroupAttribute = options?.focusGroupAttribute;
+	const focusDirection = focusDirectionAttribute ? element.closest(`[${focusDirectionAttribute}]`)?.getAttribute(focusDirectionAttribute) : "prev";
+	const focusGroupElement = focusGroupAttribute ? element.closest(`[${focusGroupAttribute}]`) : null;
+	return (focusGroupElement ? getNextFocusableElementInGroup(focusGroupElement, element, activeElement, focusDirection == "next" ? "next" : "prev") : null) || getNextFocusableElementInGroup(element.ownerDocument.body, element, activeElement, focusDirection == "next" ? "next" : "prev");
+}
+function getNextFocusableElementInGroup(focusGroupElement, element, activeElement, direction = "prev") {
+	const focusable = getKeyboardFocusableElements(focusGroupElement, element, activeElement);
+	const index = focusable.indexOf(activeElement);
+	if (focusable.length < 2) return null;
+	const lastIndex = focusable.length - 1;
+	const prevIndex = index != 0 ? index - 1 : index + 1;
+	const nextIndex = index != lastIndex ? index + 1 : index - 1;
+	if (direction == "prev") return focusable.at(prevIndex) ?? focusable.at(nextIndex) ?? null;
+	return focusable.at(nextIndex) ?? focusable.at(prevIndex) ?? null;
+}
+function getKeyboardFocusableElements(element, elementToRemove, activeElement) {
+	return [...element.querySelectorAll("a[href], button:not(:disabled), input:not(:disabled), textarea:not(:disabled), select:not(:disabled), details, [tabindex]:not([tabindex=\"-1\"])")].filter((element) => element == activeElement || !element.closest("[aria-hidden], [hidden]") && !elementToRemove.contains(element));
+}
+const TEXT_TYPES = [
+	"text",
+	"search",
+	"url",
+	"tel",
+	"password",
+	"email"
+];
+function isTextType(type) {
+	return TEXT_TYPES.includes(type);
+}
+const DATE_TYPES = [
+	"date",
+	"datetime-local",
+	"month",
+	"week",
+	"time"
+];
+function isDateType(type) {
+	return DATE_TYPES.includes(type);
+}
+const INPUTABLE_TYPES = [
+	...TEXT_TYPES,
+	...DATE_TYPES,
+	"number"
+];
+function isInputableType(type) {
+	return INPUTABLE_TYPES.includes(type);
+}
+const CHANGEABLE_TYPES = [
+	"checkbox",
+	"radio",
+	"range",
+	"file",
+	"color"
+];
+function isChangeableType(type) {
+	return CHANGEABLE_TYPES.includes(type);
+}
+function matchInputElement(node, matcher, options) {
+	if (isFormInputElement(node) && !options?.disabled && node.disabled) return;
+	if (isInputableElement(node)) if (matcher.text && isTextInputElement(node)) matcher.text(node);
+	else if (matcher.date && isDateInputElement(node)) matcher.date(node);
+	else if (matcher.number && isNumberInputElement(node)) matcher.number(node);
+	else matcher.inputable?.(node);
+	else if (isChangeableElement(node)) if (matcher.select && isSelectElement(node)) matcher.select(node);
+	else if (matcher.checkbox && isCheckboxInputElement(node)) matcher.checkbox(node);
+	else if (matcher.radio && isRadioInputElement(node)) matcher.radio(node);
+	else if (matcher.range && isRangeInputElement(node)) matcher.range(node);
+	else if (matcher.file && isFileInputElement(node)) matcher.file(node);
+	else if (matcher.color && isColorInputElement(node)) matcher.color(node);
+	else matcher.changeable?.(node);
+	else if (isHiddenInputElement(node)) matcher.hidden?.(node);
+}
+//#endregion
+export { isRadioInputElement as A, parseIntWithDefault as B, isFormOptionElement as C, isInputableElement as D, isInputElement as E, isTextInputElement as F, relativeURL as H, matchInputElement as I, nextAnimationFrame as L, isSelectElement as M, isSubmitterElement as N, isLinkElement as O, isTextAreaElement as P, parseHTMLDocument as R, isFormInputElement as S, isHiddenInputElement as T, throttle as U, partition as V, wait as W, isElement as _, dispatch as a, isFocused as b, focusElement as c, isAnchorElement as d, isButtonElement as f, isDateInputElement as g, isColorInputElement as h, debounce as i, isRangeInputElement as j, isNumberInputElement as k, focusNextElement as l, isCheckboxInputElement as m, cancelDebounce as n, domReady as o, isChangeableElement as p, cancelThrottle as r, expandURL as s, AbortError as t, groupBy as u, isElementOrText as v, isHTMLElement as w, isFormElement as x, isFileInputElement as y, parseHTMLFragment as z };

package/dist/utils.d.mts

@@ -0,0 +1,80 @@
+//#region src/utils.d.ts
+type Locatable = URL | string;
+declare function expandURL(locatable: Locatable): URL;
+declare function relativeURL(url: URL): string;
+type DispatchOptions<T> = {
+  target: EventTarget & {
+    isConnected?: boolean;
+  };
+  cancelable: boolean;
+  detail: T;
+};
+declare function dispatch<T>(eventName: string, {
+  target,
+  cancelable,
+  detail
+}?: Partial<DispatchOptions<T>>): CustomEvent<T>;
+declare function debounce(target: Element, callback: () => void, interval?: number): void;
+declare function cancelDebounce(target: Element): void;
+declare function throttle(target: Element, callback: () => void, interval?: number): void;
+declare function cancelThrottle(target: Element): void;
+declare function parseIntWithDefault(value: string | null, defaultValue?: number): number;
+type HTMLSubmitterElement = HTMLInputElement | HTMLButtonElement;
+declare function isElement(node: unknown): node is Element;
+declare function isHTMLElement(node: unknown): node is HTMLElement;
+declare function isButtonElement(node: unknown): node is HTMLButtonElement;
+declare function isAnchorElement(node: unknown): node is HTMLAnchorElement;
+declare function isLinkElement(node: unknown): node is HTMLLinkElement;
+declare function isFormElement(node: unknown): node is HTMLFormElement;
+declare function isSubmitterElement(node: unknown): node is HTMLSubmitterElement;
+declare function isInputElement(node: unknown): node is HTMLInputElement;
+declare function isFormInputElement(node: unknown): node is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+declare function isTextAreaElement(node: unknown): node is HTMLTextAreaElement;
+declare function isSelectElement(node: unknown): node is HTMLSelectElement;
+declare function isFormOptionElement(node: unknown): node is HTMLOptionElement;
+declare function isDateInputElement(node: unknown): node is HTMLInputElement;
+declare function isNumberInputElement(node: unknown): node is HTMLInputElement;
+declare function isCheckboxInputElement(node: unknown): node is HTMLInputElement;
+declare function isRadioInputElement(node: unknown): node is HTMLInputElement;
+declare function isRangeInputElement(node: unknown): node is HTMLInputElement;
+declare function isColorInputElement(node: unknown): node is HTMLInputElement;
+declare function isFileInputElement(node: unknown): node is HTMLInputElement;
+declare function isHiddenInputElement(node: unknown): node is HTMLInputElement;
+declare function isTextInputElement(node: unknown): node is HTMLInputElement | HTMLTextAreaElement;
+declare function isInputableElement(node: unknown): node is HTMLInputElement | HTMLTextAreaElement;
+declare function isChangeableElement(node: unknown): node is HTMLInputElement | HTMLSelectElement;
+declare function isElementOrText(node: unknown): node is Element | Text;
+declare function isFocused(element: Element): boolean;
+declare function focusElement(element: Element): void;
+type FocusNextOptions = {
+  focusGroupAttribute?: string;
+  focusDirectionAttribute?: string;
+};
+declare function focusNextElement(element: Element, options?: FocusNextOptions): void;
+declare function parseHTMLDocument(html: string): Document;
+declare function parseHTMLFragment(html: string, ownerDocument: Document): DocumentFragment;
+declare function domReady(): Promise<void>;
+declare function nextAnimationFrame(): Promise<void>;
+declare class AbortError extends Error {}
+declare function wait(delay: number, signal?: AbortSignal): Promise<void>;
+declare function groupBy<T, K>(array: T[], predicat: (entry: T) => K): Map<K, T[]>;
+declare function partition<T>(array: T[], predicat: (entry: T) => boolean): [yes: T[], no: T[]];
+type InputMatcher<T extends HTMLElement = HTMLInputElement> = (element: T) => void;
+declare function matchInputElement(node: unknown, matcher: {
+  inputable?: InputMatcher<HTMLInputElement | HTMLTextAreaElement>;
+  changeable?: InputMatcher<HTMLInputElement | HTMLSelectElement>;
+  text?: InputMatcher<HTMLInputElement | HTMLTextAreaElement>;
+  select?: InputMatcher<HTMLSelectElement>;
+  date?: InputMatcher;
+  number?: InputMatcher;
+  checkbox?: InputMatcher;
+  radio?: InputMatcher;
+  range?: InputMatcher;
+  file?: InputMatcher;
+  color?: InputMatcher;
+  hidden?: InputMatcher;
+}, options?: {
+  disabled?: boolean;
+}): void;
+//#endregion
+export { AbortError, DispatchOptions, FocusNextOptions, HTMLSubmitterElement, Locatable, cancelDebounce, cancelThrottle, debounce, dispatch, domReady, expandURL, focusElement, focusNextElement, groupBy, isAnchorElement, isButtonElement, isChangeableElement, isCheckboxInputElement, isColorInputElement, isDateInputElement, isElement, isElementOrText, isFileInputElement, isFocused, isFormElement, isFormInputElement, isFormOptionElement, isHTMLElement, isHiddenInputElement, isInputElement, isInputableElement, isLinkElement, isNumberInputElement, isRadioInputElement, isRangeInputElement, isSelectElement, isSubmitterElement, isTextAreaElement, isTextInputElement, matchInputElement, nextAnimationFrame, parseHTMLDocument, parseHTMLFragment, parseIntWithDefault, partition, relativeURL, throttle, wait };

package/dist/utils.mjs

@@ -0,0 +1,2 @@
+import { A as isRadioInputElement, B as parseIntWithDefault, C as isFormOptionElement, D as isInputableElement, E as isInputElement, F as isTextInputElement, H as relativeURL, I as matchInputElement, L as nextAnimationFrame, M as isSelectElement, N as isSubmitterElement, O as isLinkElement, P as isTextAreaElement, R as parseHTMLDocument, S as isFormInputElement, T as isHiddenInputElement, U as throttle, V as partition, W as wait, _ as isElement, a as dispatch, b as isFocused, c as focusElement, d as isAnchorElement, f as isButtonElement, g as isDateInputElement, h as isColorInputElement, i as debounce, j as isRangeInputElement, k as isNumberInputElement, l as focusNextElement, m as isCheckboxInputElement, n as cancelDebounce, o as domReady, p as isChangeableElement, r as cancelThrottle, s as expandURL, t as AbortError, u as groupBy, v as isElementOrText, w as isHTMLElement, x as isFormElement, y as isFileInputElement, z as parseHTMLFragment } from "./utils-C2S0wWJJ.mjs";
+export { AbortError, cancelDebounce, cancelThrottle, debounce, dispatch, domReady, expandURL, focusElement, focusNextElement, groupBy, isAnchorElement, isButtonElement, isChangeableElement, isCheckboxInputElement, isColorInputElement, isDateInputElement, isElement, isElementOrText, isFileInputElement, isFocused, isFormElement, isFormInputElement, isFormOptionElement, isHTMLElement, isHiddenInputElement, isInputElement, isInputableElement, isLinkElement, isNumberInputElement, isRadioInputElement, isRangeInputElement, isSelectElement, isSubmitterElement, isTextAreaElement, isTextInputElement, matchInputElement, nextAnimationFrame, parseHTMLDocument, parseHTMLFragment, parseIntWithDefault, partition, relativeURL, throttle, wait };

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "coldwired",
+  "version": "0.18.0",
+  "description": "DOM manipulation actions based on morphdom",
+  "homepage": "https://github.com/tchak/coldwired#readme",
+  "bugs": {
+    "url": "https://github.com/tchak/coldwired/issues"
+  },
+  "license": "MIT",
+  "author": "Paul Chavard <pro@paul.chavard.net>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tchak/coldwired.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./actions": "./dist/actions.mjs",
+    "./react": "./dist/react.mjs",
+    "./turbo-stream": "./dist/turbo-stream.mjs",
+    "./utils": "./dist/utils.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check",
+    "prepublishOnly": "vp run build"
+  },
+  "dependencies": {
+    "html-entities": "^2.6.0",
+    "morphdom": "^2.7.8",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/core": "^0.18.2",
+    "@testing-library/dom": "^10.4.1",
+    "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@typescript/native-preview": "7.0.0-dev.20260328.1",
+    "bumpp": "^11.0.1",
+    "just-debounce-it": "^3.2.0",
+    "just-throttle": "^4.2.0",
+    "playwright": "^1.59.1",
+    "publint": "^0.3.18",
+    "react-aria-components": "^1.16.0",
+    "react-error-boundary": "^6.1.1",
+    "tiny-invariant": "^1.3.3",
+    "typescript": "^6.0.2",
+    "vite-plus": "^0.1.14",
+    "zod": "^4.3.6"
+  },
+  "overrides": {
+    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+  },
+  "packageManager": "bun@1.3.11",
+  "inlinedDependencies": {
+    "just-debounce-it": "3.2.0",
+    "just-throttle": "4.2.0",
+    "react-error-boundary": "6.1.1",
+    "tiny-invariant": "1.3.3"
+  }
+}