@zaly/tui 0.0.4 → 0.0.6

package/dist/widgets/markdown.mjs

@@ -1,124 +1,2 @@
-import { S as unwrap, r as createAsync, w as useContext, y as signal } from "../reactive-f7NpAi69.mjs";
-import { t as Node } from "../node-BZ7f6HzU.mjs";
-import { calcLayout, expandTabs, formatText } from "../text.mjs";
-import { textContent } from "./text.mjs";
-import { t as RenderContext } from "../render-DxVLqqB9.mjs";
-import { t as codeToAnsi } from "../shiki-BrjVUkeh.mjs";
-import { n as shikiWorker } from "../client-D6C_uczF.mjs";
-import { hasColors } from "@zaly/shared/env";
-//#region src/widgets/markdown.ts
-var Markdown = class extends Node {
-	images = /* @__PURE__ */ new Map();
-	#renderer;
-	#code = /* @__PURE__ */ new Map();
-	#update = signal(0);
-	#gen = 0;
-	#worker;
-	#images;
-	constructor(state) {
-		super(state);
-		const context = useContext(RenderContext);
-		this.#images = context?.images;
-		this.#worker = createAsync(async () => {
-			const update = this.#update.get();
-			const todo = [...this.#code.values()].filter((c) => c.gen === this.#gen && !c.result);
-			if (!todo.length) return update;
-			await Promise.all(todo.map(async (req) => {
-				req.ac ??= new AbortController();
-				req.inflight ??= codeToAnsi(req.code, req.lang, {
-					signal: req.ac.signal,
-					theme: req.theme
-				});
-				try {
-					req.result = await req.inflight;
-				} catch (error) {
-					if (req.ac.signal.aborted) {
-						if (this.#code.get(req.key) === req) this.#code.delete(req.key);
-					} else throw error;
-				}
-			}));
-			return update + 1;
-		}, { initialValue: 0 });
-	}
-	/** Find a highlighted result for a prefix of `code` in the cache. This
-	* handles streaming updates where the full code block isn't available yet
-	* and prevents flashing un-highlighted text on each update. */
-	#streamingHighlight(code, lang, theme) {
-		let ret;
-		for (const c of this.#code.values()) {
-			if (!c.result || c.lang !== lang || c.theme !== theme) continue;
-			if (code.startsWith(c.code) && c.code.length > (ret?.code.length ?? 0)) ret = c;
-		}
-		if (ret) ret.gen = this.#gen;
-		return ret?.result ? ret.result + code.slice(ret.code.length) : code;
-	}
-	#highlight(code, lang, theme) {
-		if (!lang) return code;
-		const key = shikiWorker.key({
-			code,
-			lang,
-			theme
-		});
-		const ret = this.#code.get(key);
-		if (ret) ret.gen = this.#gen;
-		if (ret?.result) return ret.result;
-		else if (!ret) this.#code.set(key, {
-			code,
-			gen: this.#gen,
-			key,
-			lang,
-			theme
-		});
-		return this.#streamingHighlight(code, lang, theme);
-	}
-	async _render(ctx) {
-		if (!this.#renderer) {
-			const { MarkdownRenderer } = await import("../renderer-CdLCkJB-.mjs").then((n) => n.n);
-			this.#renderer = new MarkdownRenderer({
-				...this.state.options,
-				parent: this
-			});
-		}
-		let source = await textContent(this.state.content, ctx);
-		source = expandTabs(source);
-		let formatted;
-		if (!hasColors) formatted = this.#renderer.normalizeEol(source, source);
-		else {
-			this.#gen++;
-			formatted = await this.#renderer.render(source, {
-				...ctx,
-				highlight: (code, lang) => this.#highlight(code, lang, ctx.style.theme.shiki),
-				images: unwrap(this.#images) ?? true
-			});
-			for (const [k, c] of this.#code.entries()) if (c.gen !== this.#gen) {
-				c.ac?.abort();
-				if (c.result !== void 0) this.#code.delete(k);
-			}
-			if (this.#code.values().some((c) => !c.inflight)) {
-				this.#update.set(this.#gen);
-				this.#worker();
-			}
-		}
-		return formatText(formatted, {
-			indent: true,
-			style: this.state.style ? ctx.style.add(this.state.style) : void 0,
-			width: ctx.width,
-			wrap: this.state.wrap,
-			wrapBg: true
-		});
-	}
-	async layout(ctx) {
-		return calcLayout(await textContent(this.state.content, ctx));
-	}
-};
-function markdown(first, style) {
-	if (typeof first === "string" || typeof first === "function") return new Markdown({
-		content: first,
-		...style
-	});
-	return new Markdown(first);
-}
-//#endregion
+import { n as markdown, t as Markdown } from "../markdown-CTlPe5ks.mjs";
 export { Markdown, markdown };
-
-//# sourceMappingURL=markdown.mjs.map

package/dist/widgets/overlay.mjs

@@ -1,18 +1,2 @@
-import { n as box } from "../box-DyaByEiG.mjs";
-//#region src/widgets/overlay.ts
-function overlay(state, ...children) {
-	const node = box({
-		visible: false,
-		...state
-	}, ...children);
-	node.withActions({ "overlay.close": {
-		desc: "Close overlay",
-		fn: () => node.state.removeOnClose ?? true ? node.ctx?.overlay.remove(node) : node.hide(),
-		keys: ["esc", "ctrl-c"]
-	} });
-	return node;
-}
-//#endregion
+import { t as overlay } from "../overlay-9xNgsuuy.mjs";
 export { overlay };
-
-//# sourceMappingURL=overlay.mjs.map

package/dist/widgets/picker.mjs

@@ -1,2 +1,2 @@
-import { t as picker } from "../picker-ndVVt6qF.mjs";
+import { t as picker } from "../picker-cH-rc7-X.mjs";
 export { picker };

package/dist/widgets/select.mjs

@@ -1,195 +1,2 @@
-import { S as unwrap, f as effect } from "../reactive-f7NpAi69.mjs";
-import { t as Node } from "../node-BZ7f6HzU.mjs";
-import { n as resolveSize } from "../size-D8JogYLy.mjs";
-import { fitAnsi, stringWidth } from "@zaly/shared/ansi";
-//#region src/widgets/select.ts
-/**
-* Selectable list. Items are rendered one per row with an active-row
-* highlight; navigation actions (`next`, `prev`, `first`, `last`,
-* `accept`, `complete`, `cancel`) live on `this.actions`, same pattern as
-* `Input`.
-*
-* Used standalone for simple lists and as the underlying list primitive for
-* `picker`, `tree`, and `autocomplete`. Doesn't open/close itself — callers
-* control visibility via `state.visible`.
-*/
-var Select = class Select extends Node {
-	static type = "select";
-	type = Select.type;
-	actions = {
-		"select.accept": () => {
-			const items = this.#items;
-			if (items.length === 0) return;
-			this.emit("accept", { item: items[this.active] });
-		},
-		"select.close": () => {
-			this.emit("close");
-		},
-		"select.complete": () => {
-			const items = this.#items;
-			if (items.length === 0) return;
-			this.emit("complete", { item: items[this.active] });
-		},
-		"select.first": () => {
-			if (this.#items.length === 0) return;
-			this.active = 0;
-		},
-		"select.last": () => {
-			const n = this.#items.length;
-			if (n === 0) return;
-			this.active = n - 1;
-		},
-		"select.next": () => {
-			if (this.#items.length === 0) return;
-			this.active += this.#direction;
-		},
-		"select.page-down": () => {
-			if (this.#items.length === 0) return;
-			const page = Math.max(this.pageSize - 1, 1);
-			this.state.active = this.#clamp(this.active + this.#direction * page);
-		},
-		"select.page-up": () => {
-			if (this.#items.length === 0) return;
-			const page = Math.max(this.pageSize - 1, 1);
-			this.state.active = this.#clamp(this.active - this.#direction * page);
-		},
-		"select.prev": () => {
-			if (this.#items.length === 0) return;
-			this.active -= this.#direction;
-		}
-	};
-	/** Top of the currently-rendered window, in absolute item indices.
-	*  Updated per render using the pin-until-leave rule: stays put
-	*  while `active` remains in `[start, start + visible)`, slides just
-	*  enough to re-admit it otherwise. */
-	#windowStart = 0;
-	constructor(initial) {
-		super({
-			active: 0,
-			...initial
-		});
-		let active = this.item;
-		effect(() => {
-			const next = this.item;
-			if (next === active) return;
-			active = next;
-			this.emit("changed", {
-				active: this.active,
-				item: next
-			});
-		});
-	}
-	get #direction() {
-		return this.state.reverse ? -1 : 1;
-	}
-	get #items() {
-		return unwrap(this.state.items);
-	}
-	#clamp(i) {
-		const n = this.#items.length;
-		return n === 0 ? 0 : Math.max(0, Math.min(n - 1, i));
-	}
-	set active(i) {
-		const n = this.#items.length;
-		this.state.active = n === 0 ? 0 : (i % n + n) % n;
-	}
-	get active() {
-		const a = this.state.active ?? 0;
-		const n = this.#items.length;
-		if (n === 0) return 0;
-		return Math.max(0, Math.min(n - 1, a));
-	}
-	bind(node) {
-		let n;
-		const getn = () => n = node instanceof Node ? node : node();
-		this.on("mount", () => getn().addActionTarget(this));
-		this.on("unmount", () => n?.removeActionTarget(this));
-		if (this.mounted) getn().addActionTarget(this);
-		return this;
-	}
-	get count() {
-		return this.#items.length;
-	}
-	get pageSize() {
-		return unwrap(this.state.maxHeight) ?? Math.max(this.#items.length, 1);
-	}
-	get item() {
-		return this.#items[this.active];
-	}
-	_render(ctx) {
-		const items = this.#items;
-		if (items.length === 0) return [];
-		const width = resolveSize(this.state.width ?? "fill", ctx.width) ?? ctx.width;
-		const active = this.active;
-		const height = Math.min(this.pageSize, items.length);
-		if (height === 0) return [];
-		let start = this.#windowStart;
-		if (active < start) start = active;
-		else if (active >= start + height) start = active - height + 1;
-		start = Math.max(0, Math.min(Math.max(0, items.length - height), start));
-		this.#windowStart = start;
-		const visible = items.slice(start, start + height);
-		const renderer = this.renderer;
-		const rows = [];
-		for (let i = start; i < start + height; i++) {
-			const item = items[i];
-			let row = renderer(item, {
-				...ctx,
-				active: i === active,
-				items,
-				visible
-			}).replace(/\n/g, " ");
-			row = fitAnsi(row, width);
-			rows.push(i === active ? ctx.style.optionActive(row) : row);
-		}
-		if (this.state.reverse) rows.reverse();
-		if (this.state.counter ?? items.length > height) {
-			const label = `(${items.length === 0 ? 0 : active + 1}/${items.length}${this.state.more ? "+" : ""})`;
-			rows.push(ctx.style.gutter(fitAnsi(label, width)));
-		}
-		return rows;
-	}
-	get renderer() {
-		return unwrap(this.state.render) ?? this.defaultRenderer();
-	}
-	extendRenderer(fn) {
-		const prev = this.renderer;
-		this.state.render = fn(prev);
-		return this;
-	}
-	defaultRenderer() {
-		let visible = [];
-		let labelWidth = 0;
-		const update = (ctx) => {
-			if (ctx.visible === visible) return;
-			visible = ctx.visible;
-			if (!visible.some((i) => i.desc)) return labelWidth = ctx.width;
-			labelWidth = this.state.labelWidth ?? 0;
-			labelWidth ||= visible.map(itemLabel).reduce((max, label) => Math.max(max, stringWidth(label)), 0);
-			labelWidth = Math.min(labelWidth, Math.floor(ctx.width / 2));
-		};
-		return (item, ctx) => {
-			update(ctx);
-			const label = fitAnsi(itemLabel(item), labelWidth);
-			if (!item.desc) return ctx.style.optionName(label);
-			const desc = fitAnsi(item.desc ?? "", Math.max(0, ctx.width - labelWidth - 2));
-			return `${ctx.style.optionName(label)}  ${ctx.style.optionDesc(desc)}`;
-		};
-	}
-};
-const itemLabel = (item) => (item.name ?? item.text).replace(/\s+/g, " ").trim();
-/**
-* Factory for a selectable list.
-*
-* ```ts
-* const s = select({ items: [{ text: "/help" }, { text: "/quit" }] })
-* s.on("accept", ({ item }) => console.log("picked", item.text))
-* ```
-*/
-function select(state) {
-	return new Select(state);
-}
-//#endregion
+import { n as select, t as Select } from "../select-m7NE6Rwa.mjs";
 export { Select, select };
-
-//# sourceMappingURL=select.mjs.map

package/dist/widgets/show.mjs

@@ -1,85 +1,2 @@
-import { C as useActiveOwner, E as withOwner, S as unwrap, x as untrack } from "../reactive-f7NpAi69.mjs";
-import { t as Node } from "../node-BZ7f6HzU.mjs";
-//#region src/widgets/show.ts
-/** Conditional fragment backing `show()`. Branches are created lazily:
-* a `use` factory only runs the first time its condition wins. Once
-* created, the branch remains mounted and owned; inactive branches simply
-* don't participate in layout/rendering and contribute zero rows.
-*
-* Lazy factories run under the owner captured at `show()` creation time,
-* so context reads behave as if the branch had been constructed eagerly.
-*/
-var Show = class extends Node {
-	#state = [];
-	#owner = useActiveOwner();
-	constructor(spec) {
-		super({});
-		let fallback = false;
-		for (const s of spec) {
-			if (fallback) throw new Error("Show: `fallback` must be the final argument");
-			if (typeof s === "function") {
-				this.#state.push({
-					use: s,
-					when: true
-				});
-				fallback = true;
-			} else this.#state.push(s);
-		}
-	}
-	#nodes(s, use) {
-		if (s.children) return s.children;
-		const create = () => untrack(use);
-		const nodes = this.#owner ? withOwner(this.#owner, create) : create();
-		s.children = Array.isArray(nodes) ? nodes : [nodes];
-		for (const c of s.children) this.add(c);
-		return s.children;
-	}
-	layoutChildren() {
-		for (const s of this.#state) {
-			const matches = unwrap(s.when);
-			if (s.use === void 0) {
-				if (!matches) return [];
-				continue;
-			} else if (!matches) continue;
-			return this.#nodes(s, s.use);
-		}
-		return [];
-	}
-	/** Standalone-render fallback. Box parents go through
-	*  `layoutChildren` and bypass this; only fires when `Show` sits
-	*  outside a layout container (root, overlay, etc.). */
-	async _render(ctx) {
-		const targets = this.layoutChildren();
-		return (await Promise.all(targets.map((c) => c.render(ctx)))).flat();
-	}
-};
-/** Lazy conditional rendering.
-*
-* Specs are evaluated from left to right:
-* - `{ when }` is a guard. When false, rendering stops with no rows; when
-*   true, evaluation continues.
-* - `{ when, use }` is a conditional branch. The first branch whose
-*   condition is truthy is rendered.
-* - A final bare factory is the fallback branch and must be the last
-*   argument.
-*
-* Branch factories are lazy and run at most once. Created branches stay
-* mounted across toggles, preserving state, effects, and async resources.
-*
-* ```ts
-* show({ when: isLoading }, () => spinner({ color: "accent" }))
-*
-* show(
-*   { when: full },
-*   { when: isError, use: () => errorView() },
-*   () => resultView()
-* )
-* ```
-*/
-function show(...spec) {
-	return new Show(spec);
-}
-//#endregion
+import { t as show } from "../show-DR2x1YFc.mjs";
 export { show };
-
-//# sourceMappingURL=show.mjs.map

package/dist/widgets/text.mjs

@@ -1,32 +1,2 @@
-import { S as unwrap } from "../reactive-f7NpAi69.mjs";
-import { t as Node } from "../node-BZ7f6HzU.mjs";
-import { calcLayout, formatText } from "../text.mjs";
-//#region src/widgets/text.ts
-var Text = class extends Node {
-	async _render(ctx) {
-		return formatText(await textContent(this.state.content, ctx), {
-			style: ctx.style.add(this.state),
-			width: ctx.width,
-			wrap: this.state.wrap
-		});
-	}
-	async layout(ctx) {
-		return calcLayout(await textContent(this.state.content, ctx), { wrap: this.state.wrap });
-	}
-};
-async function textContent(content, ctx) {
-	if (content === void 0) return;
-	const raw = unwrap(content);
-	return unwrap(typeof raw === "string" ? raw : await raw(ctx));
-}
-function text(first, style) {
-	if (typeof first === "string" || typeof first === "function") return new Text({
-		content: first,
-		...style
-	});
-	return new Text(first);
-}
-//#endregion
+import { n as text, r as textContent, t as Text } from "../text-DILrol9j.mjs";
 export { Text, text, textContent };
-
-//# sourceMappingURL=text.mjs.map

package/dist/widgets/tree.mjs

@@ -1,73 +1,2 @@
-import { S as unwrap, h as memo } from "../reactive-f7NpAi69.mjs";
-import { widget } from "./widget.mjs";
-import { select } from "./select.mjs";
-import { stringWidth } from "@zaly/shared/ansi";
-//#region src/widgets/tree.ts
-const icons = {
-	last: "╰─",
-	middle: "├─",
-	vertical: "│ "
-};
-var Tree = class {
-	root;
-	nodes = /* @__PURE__ */ new Map();
-	items = [];
-	constructor(root) {
-		this.root = root;
-		this.#build(root, void 0, true);
-	}
-	#build(item, parent, last) {
-		this.nodes.set(item, {
-			last,
-			parent
-		});
-		this.items.push(item);
-		const children = item.children ?? [];
-		for (let c = 0; c < children.length; c++) {
-			const child = children[c];
-			this.#build(child, item, c === children.length - 1);
-		}
-	}
-	node(item) {
-		return this.nodes.get(item);
-	}
-};
-const tree = widget((props) => {
-	const builder = memo(() => new Tree(unwrap(props.tree)));
-	const items = memo(() => props.root === true ? builder().items : builder().items.slice(1));
-	const activeFn = typeof props.active === "function" ? props.active : (i) => i === props.active;
-	const active = props.active ? items().findIndex((i) => activeFn(i)) : -1;
-	const ret = select({
-		...props,
-		active: active === -1 ? 0 : active,
-		items
-	});
-	ret.extendRenderer((prev) => (item, ctx) => {
-		const t = builder();
-		const path = [];
-		const s = ctx.style;
-		const itemNode = t.node(item);
-		let n = t.node(item);
-		while (n?.parent) {
-			if (props.root !== true && n.parent === props.tree) break;
-			let icon = "";
-			if (n !== itemNode) icon = n.last ? "  " : icons.vertical;
-			else icon = n.last ? icons.last : icons.middle;
-			path.unshift(icon);
-			n = t.node(n.parent);
-		}
-		const prefix = path.join("");
-		const prefixWidth = stringWidth(prefix);
-		const text = prev(item, {
-			...ctx,
-			prefixWidth,
-			width: ctx.width - prefixWidth
-		}).replace(/\s/g, " ");
-		return `${s.gutter(prefix)}${text}`;
-	});
-	return Object.assign(ret, { items });
-});
-//#endregion
+import { t as tree } from "../tree-Bo1afYhe.mjs";
 export { tree };
-
-//# sourceMappingURL=tree.mjs.map

package/dist/widgets/widget.d.mts

@@ -1,49 +1,2 @@
-import { p as Node } from "../queries-DH3bj74K.mjs";
-//#region src/widgets/widget.d.ts
-type Props = Record<string, unknown>;
-/**
- * A widget factory: takes some args, returns a `Node`.
- *
- * The default `A = never[]` makes the *bare* `Widget` the universal
- * "any widget" type — the `(...args: never[]) => Node` idiom. Every
- * concrete factory (zero-arg, `state + ...children`, single-props) is
- * assignable to it, so it works both as the `widget()` constraint and
- * as a stored value type (`details?: Widget`, invoked zero-arg). Supply
- * `A` explicitly for a precise signature: `Widget<[State<LogState>]>`.
- */
-type Widget<A extends unknown[] = never[], N extends Node = Node> = (...args: A) => N;
-/**
- * Type helper for declaring widgets — runtime identity, just `return fn`.
- *
- * Three things it earns:
- *   1. Inference at the declaration site: TS infers `S` from the function
- *      parameter and enforces it on every call site.
- *   2. A consistent grep target: every component reads as
- *      `export const foo = widget((props) => …)`.
- *   3. A future seam for instrumentation, lifecycle wrappers, devtools.
- *
- * The factory body runs **once** at construction. Reactive content lives
- * in leaf thunks (`text(({ style }) => …)`), not by re-running the body
- * — this is the Solid model, not React's. `ctx` is therefore unavailable
- * inside the factory; reach for it inside leaf thunks where it belongs.
- *
- * ```ts
- * const status = widget((props: { level: "ok" | "warn"; msg: string }) =>
- *   text(({ style }) => `${style.bold[props.level]("●")} ${style.dim(props.msg)}`),
- * )
- *
- * status({ level: "ok", msg: "all systems nominal" })
- * ```
- */
-/**
- * Call-site args derived from `S`:
- *   - If `S` declares `children`, `children` is injected from rest args;
- *     state at the call site has `children` omitted, then `...children`.
- *   - Otherwise, no rest is allowed.
- *   - Either way, the state arg is optional when every field of the
- *     resolved state is optional (so bare `widget()` works).
- */
-declare function widget<T extends Widget>(fn: T): T;
-//#endregion
-export { Props, Widget, widget };
-//# sourceMappingURL=widget.d.mts.map
+import { n as Widget, r as widget, t as Props } from "../widget-M7jD8Rgg.mjs";
+export { Props, Widget, widget };

package/dist/widgets/widget.mjs

@@ -1,40 +1,2 @@
-import { o as createNode } from "../reactive-f7NpAi69.mjs";
-//#region src/widgets/widget.ts
-/**
-* Type helper for declaring widgets — runtime identity, just `return fn`.
-*
-* Three things it earns:
-*   1. Inference at the declaration site: TS infers `S` from the function
-*      parameter and enforces it on every call site.
-*   2. A consistent grep target: every component reads as
-*      `export const foo = widget((props) => …)`.
-*   3. A future seam for instrumentation, lifecycle wrappers, devtools.
-*
-* The factory body runs **once** at construction. Reactive content lives
-* in leaf thunks (`text(({ style }) => …)`), not by re-running the body
-* — this is the Solid model, not React's. `ctx` is therefore unavailable
-* inside the factory; reach for it inside leaf thunks where it belongs.
-*
-* ```ts
-* const status = widget((props: { level: "ok" | "warn"; msg: string }) =>
-*   text(({ style }) => `${style.bold[props.level]("●")} ${style.dim(props.msg)}`),
-* )
-*
-* status({ level: "ok", msg: "all systems nominal" })
-* ```
-*/
-/**
-* Call-site args derived from `S`:
-*   - If `S` declares `children`, `children` is injected from rest args;
-*     state at the call site has `children` omitted, then `...children`.
-*   - Otherwise, no rest is allowed.
-*   - Either way, the state arg is optional when every field of the
-*     resolved state is optional (so bare `widget()` works).
-*/
-function widget(fn) {
-	return ((...args) => createNode(() => fn(...args)));
-}
-//#endregion
+import { t as widget } from "../widget-BkMwhY2p.mjs";
 export { widget };
-
-//# sourceMappingURL=widget.mjs.map

package/dist/worker-BvRm4OsW.mjs

@@ -0,0 +1,2 @@
+import { t as createWorker } from "./worker-T6SdPzUH.mjs";
+export { createWorker };

package/dist/worker-T6SdPzUH.mjs

@@ -0,0 +1,52 @@
+//#region src/shiki/worker.ts
+const workerHost = {
+	onMessage: (handler) => {
+		if (typeof globalThis.addEventListener === "function") {
+			globalThis.addEventListener("message", (event) => void handler(event.data));
+			return;
+		}
+		import("node:worker_threads").then(({ parentPort }) => {
+			parentPort?.on("message", (message) => void handler(message));
+		});
+	},
+	postMessage: (message) => {
+		if (typeof globalThis.postMessage === "function") {
+			globalThis.postMessage(message);
+			return;
+		}
+		import("node:worker_threads").then(({ parentPort }) => {
+			parentPort?.postMessage(message);
+		});
+	}
+};
+async function createWorker() {
+	const scriptURL = new URL(import.meta.resolve("#shiki-worker"));
+	if (typeof globalThis.Worker === "function") {
+		const w = new Worker(scriptURL, { type: "module" });
+		w.unref?.();
+		return {
+			on: (event, handler) => {
+				if (event === "error") w.addEventListener(event, (e) => void handler(e.error ?? new Error(e.message)));
+				else w.addEventListener(event, (e) => void handler(e.data));
+				w.unref?.();
+			},
+			postMessage: (message) => w.postMessage(message),
+			terminate: () => w.terminate()
+		};
+	}
+	const { Worker: NodeWorker } = await import("node:worker_threads");
+	const worker = new NodeWorker(scriptURL);
+	worker.unref();
+	return {
+		on: (event, handler) => {
+			worker.on(event, (e) => void handler(e));
+			worker.unref();
+		},
+		postMessage: (message) => worker.postMessage(message),
+		terminate: () => void worker.terminate()
+	};
+}
+//#endregion
+export { workerHost as n, createWorker as t };
+
+//# sourceMappingURL=worker-T6SdPzUH.mjs.map