irisout 0.2.1

package/dist/jsx.d.ts

@@ -0,0 +1,132 @@
+// authored .jsx 向けの型検査基盤(ROADMAP.md 次のアクション10)。
+//
+// このコンパイラは .jsx を @babel/parser で直接解析するだけで、JSX を
+// createElement 相当のランタイム呼び出しへ変換しない(docs/architecture.md
+// コンパイルパイプライン参照)。したがって JSX.Element は実行時に何かを
+// 表す型ではなく、TS の型検査を素通りさせるためのプレースホルダー型
+// (TS公式の「カスタムJSX」パターン、React非依存)。
+//
+// 属性名は意図的に緩くしている: 共通属性(key/use/onXxxハンドラ/children)
+// のみ明示的に型付けし、それ以外は string キーの index signature で
+// 受ける。コンパイラ自身が host 属性名をホワイトリスト化していない
+// (M4静的host属性・ADR-0012動的host属性はchecked/valueの特別扱い以外
+// 任意の属性名をsetAttributeへ通す)ため、型を先に厳しくすると
+// aria-*/data-* のような正当な属性を誤検出してしまう。
+// 詳細は openspec/specs/authored-jsx-type-checking/spec.md 参照。
+//
+// 重要: 型が通ることと実行時に compile() が受理することは別軸のまま。
+// 型はコンパイラの scope limit 判定を代替しない(例: リストアイテム内の
+// use= は型上も実行時も要素・リストアイテム・条件分岐ブランチで受理されるが、
+// 字句スコープ外のsignal参照など、STATUS.md のscope limitは別に適用される。
+
+// イベントの実体はブラウザ標準のまま維持し、直接addEventListenerされる
+// currentTargetだけを属性が書かれた要素へ絞る。targetは子要素になり得るため
+// EventTarget | nullから変更しない(ADR-0009 UNRESOLVED(09)の解消)。
+type IrisElementEvent<EventType extends Event, El extends Element> = EventType & {
+  readonly currentTarget: El
+}
+
+type IrisEventHandler<EventType extends Event, El extends Element> = (
+  event: IrisElementEvent<EventType, El>,
+) => void
+
+// 任意のonXxxを受理する既存契約を維持しつつ、既知属性の関数型が
+// テンプレートリテラル型の索引シグネチャにも代入できるようにする。
+// 未知のイベント名では個別のイベント型を保証しない。
+type IrisAnyEventHandler<El extends Element> =
+  | IrisEventHandler<Event, El>
+  | IrisEventHandler<FocusEvent, El>
+  | IrisEventHandler<InputEvent, El>
+  | IrisEventHandler<KeyboardEvent, El>
+  | IrisEventHandler<MouseEvent, El>
+
+type IrisKnownEventAttributes<El extends Element> = {
+  onBlur?: IrisEventHandler<FocusEvent, El>
+  onChange?: IrisEventHandler<Event, El>
+  onClick?: IrisEventHandler<MouseEvent, El>
+  onDblClick?: IrisEventHandler<MouseEvent, El>
+  onInput?: IrisEventHandler<InputEvent, El>
+  onKeyDown?: IrisEventHandler<KeyboardEvent, El>
+}
+
+// mount 時に1回呼ばれ、関数返り値は従来どおり「更新のたびに呼ばれる
+// 再描画クロージャ」として配線される。object 形式は更新クロージャと
+// unmount 時だけ呼ぶ destroy を明示できる(ADR-0011/ADR-0022)。
+type IrisUseActionResult = (() => void) | { update?: () => void; destroy?: () => void }
+// biome-ignore lint/suspicious/noConfusingVoidType: 「返り値なし」を`void`で表す意図的な設計(`undefined`への機械的置換はしない)
+type IrisUseAction<El extends Element> = (el: El) => void | IrisUseActionResult
+
+type IrisCommonAttributes<El extends Element> = IrisKnownEventAttributes<El> & {
+  use?: IrisUseAction<El>
+  children?: unknown
+  // onXxx パターンの未知のイベント処理属性も関数に限って受理する。
+  [handler: `on${string}`]: IrisAnyEventHandler<El> | undefined
+  // それ以外の属性名(aria-*/data-* 含む)は緩く受ける(design.md Decision 3)。
+  [attr: string]: unknown
+}
+
+type IrisSvgAttributes<El extends SVGElement> = IrisCommonAttributes<El> & {
+  // 名前空間属性はSVGの初期HTMLで使う静的な参照に限る。動的な値は
+  // compiler側のscope limitで拒否する。
+  'xlink:href'?: string
+  'xml:space'?: string
+  'xmlns:xlink'?: string
+}
+
+interface IrisSignal<T> {
+  (): T
+  (next: T | ((previous: T) => T)): T
+}
+
+declare function signal<T>(initial: T): IrisSignal<T>
+declare function derived<T>(compute: () => T): () => T
+declare function render(element: JSX.Element): void
+// componentのmount/hydrate完了後に一度だけ呼ばれ、返り値のcleanupは
+// instanceのunmount時に一度だけ呼ばれる。構造unit内ではunit factoryが所有する。
+// biome-ignore lint/suspicious/noConfusingVoidType: callbackの「返り値なし」を表す
+declare function onMount(callback: () => void | (() => void)): void
+// root componentの依存signal/derivedが変わるたびに再実行され、前回の返り値の
+// cleanupは再実行前とinstanceのunmount時に呼ばれる。compilerのscope limitに
+// よる制約(signal書き込み禁止・root動きゾーン専用)は型宣言の代替ではない。
+// biome-ignore lint/suspicious/noConfusingVoidType: callbackの「返り値なし」を表す
+declare function effect(callback: () => void | (() => void)): void
+
+interface IrisContext<T> {
+  readonly __irisoutContextType?: T
+}
+interface IrisAsyncContext<T> extends IrisContext<PromiseLike<T>> {}
+declare function createContext<T>(defaultValue: T): IrisContext<T>
+// 非同期contextはPromiseLike<T>を値として静的置換する。compilerはawait、Suspense、
+// schedulerを暗黙に追加せず、解決後の処理はauthorがthen/await可能な動きゾーンで行う。
+declare function createAsyncContext<T>(defaultValue: PromiseLike<T>): IrisAsyncContext<T>
+declare function provideContext<T>(context: IrisContext<T>, value: T): void
+declare function useContext<T>(context: IrisContext<T>): T
+
+declare namespace JSX {
+  // 同一ファイル内合成(ADR-0014)のコンポーネントは`render()`を内部で
+  // 呼ぶだけで値を返さない(推論される返り値型は`void`)。TSのJSX
+  // コンポーネントチェックは「タグの返り値がJSX.Elementに代入可能か」を
+  // 見るため、`void`も許容しておかないと同一ファイル内合成コンポーネントの
+  // JSXタグ使用が軒並み型エラーになる。`undefined`への置換は不可
+  // (「返り値なし関数」の推論型は`void`であって`undefined`ではないため、
+  // 置換すると同一ファイル内合成コンポーネントの型エラーが復活する)。
+  // biome-ignore lint/suspicious/noConfusingVoidType: 上記の理由で意図的
+  type Element = void | object
+  interface ElementChildrenAttribute {
+    children: unknown
+  }
+  // `key`はReactと同じくintrinsic要素・コンポーネント両方のJSXタグに
+  // 無条件で乗る特別な属性(ADR-0005 factory closureのリストアイテム識別、
+  // DOM属性ではない)。コンポーネント側は各自のprops型にkeyを含めなくて
+  // 済むよう、ここで一括宣言する(TS公式のIntrinsicAttributesパターン)。
+  interface IntrinsicAttributes {
+    key?: string | number
+  }
+  type IntrinsicElements = {
+    [K in keyof HTMLElementTagNameMap]: IrisCommonAttributes<HTMLElementTagNameMap[K]>
+  } & {
+    [K in Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>]: IrisSvgAttributes<
+      SVGElementTagNameMap[K]
+    >
+  }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,77 @@
+type DeclId = string;
+type DeclKind = 'signal' | 'derived';
+export interface ListItemState {
+    readonly listId: string;
+    readonly itemId: unknown;
+    readonly bindings: Map<string, unknown>;
+}
+export interface ListItemHandle<T = unknown> {
+    el: Element;
+    /** 複雑なネスト構造向けの互換経路。通常のList itemは共有updaterを使う。 */
+    update?(next: T): void;
+    /** DOMへ接続された後に、このitemが所有するactionを初期化する。 */
+    mount?(): void;
+    /** itemと子unitの所有資源を解放する。複数回呼び出しても安全であること。 */
+    destroy?(): void;
+}
+export interface DomRange {
+    readonly start: Comment;
+    readonly end: Comment;
+}
+export type UseActionUpdate = () => void;
+export type UseActionDestroy = () => void;
+export type UseActionResult = void | UseActionUpdate | {
+    update?: UseActionUpdate;
+    destroy?: UseActionDestroy;
+};
+export interface NormalizedUseActionResult {
+    update?: UseActionUpdate;
+    destroy?: UseActionDestroy;
+}
+export declare function normalizeUseActionResult(value: unknown, actionId: string): NormalizedUseActionResult;
+export type ListItemUpdater<T> = (handle: ListItemHandle<T>, next: T) => void;
+interface ListRecord<T> {
+    state: ListItemState;
+    handle: ListItemHandle<T>;
+}
+export interface ListRuntime<T> {
+    readonly listId: string;
+    readonly items: Map<unknown, ListRecord<T>>;
+}
+export declare function createListRuntime<T = unknown>(listId: string): ListRuntime<T>;
+export declare function updateListBinding(item: ListItemState, bindingId: string, value: unknown): boolean;
+export declare function updateListItem<T>(runtime: ListRuntime<T>, itemId: unknown, next: T, update?: ListItemUpdater<T>): void;
+export declare function reconcileList<T>(runtime: ListRuntime<T>, container: Element | DomRange | undefined, values: readonly T[], keyOf: (value: T) => unknown, create: (value: T, state: ListItemState) => ListItemHandle<T>, update?: ListItemUpdater<T>): void;
+export declare function reconcileListWithLifecycle<T>(runtime: ListRuntime<T>, container: Element | DomRange | undefined, values: readonly T[], keyOf: (value: T) => unknown, create: (value: T, state: ListItemState) => ListItemHandle<T>, update?: ListItemUpdater<T>, mountItems?: boolean): void;
+export declare function mountListRuntime<T>(runtime: ListRuntime<T>): void;
+export declare function destroyListRuntime<T>(runtime: ListRuntime<T>): void;
+export declare const registry: Map<string, {
+    kind: DeclKind;
+}>;
+export interface SignalAccessor<T> {
+    (): T;
+    (next: T | ((previous: T) => T)): T;
+}
+export declare function signal<T>(initial: T, declId?: DeclId): SignalAccessor<T>;
+export interface SharedSignal<T> {
+    (): T;
+    (next: T | ((previous: T) => T)): T;
+    subscribe(listener: () => void): () => void;
+}
+export declare function sharedSignal<T>(initial: T): SharedSignal<T>;
+export declare function derived<T>(compute: () => T, declId?: DeclId): () => T;
+export declare function hydrate(container: Element, expectedIds?: readonly string[]): {
+    markers: Map<string, Element>;
+};
+export declare function mount(container: Element, html: string, expectedIds?: readonly string[]): {
+    markers: Map<string, Element>;
+};
+export declare function hydrateWithRanges(container: Element, expectedIds?: readonly string[], expectedRangeIds?: readonly string[]): {
+    markers: Map<string, Element>;
+    ranges: Map<string, DomRange>;
+};
+export declare function mountWithRanges(container: Element, html: string, expectedIds?: readonly string[], expectedRangeIds?: readonly string[]): {
+    markers: Map<string, Element>;
+    ranges: Map<string, DomRange>;
+};
+export {};

package/dist/runtime.js

@@ -0,0 +1,286 @@
+//#region packages/runtime/src/index.ts
+function e(e, t) {
+	if (e === void 0) return {};
+	if (typeof e == "function") return { update: e };
+	if (typeof e != "object" || !e || Array.isArray(e)) throw Error(`use action ${t} must return void, a zero-argument update function, or { update?, destroy? }`);
+	let n = e;
+	for (let e of Object.keys(n)) if (e !== "update" && e !== "destroy") throw Error(`use action ${t} returned an unsupported property: ${e}`);
+	if (n.update !== void 0 && typeof n.update != "function") throw Error(`use action ${t}.update must be a function when provided`);
+	if (n.destroy !== void 0 && typeof n.destroy != "function") throw Error(`use action ${t}.destroy must be a function when provided`);
+	return {
+		update: n.update,
+		destroy: n.destroy
+	};
+}
+function t(e) {
+	return {
+		listId: e,
+		items: /* @__PURE__ */ new Map()
+	};
+}
+function n(e, t, n) {
+	if (e.bindings.has(t)) {
+		let r = e.bindings.get(t);
+		if (Object.is(r, n)) return !1;
+	}
+	return e.bindings.set(t, n), !0;
+}
+function r(e, t, n, r) {
+	let i = e.items.get(t);
+	if (!i) throw Error(`updateListItem: unknown item ${String(t)} in list ${e.listId}`);
+	if (r) r(i.handle, n);
+	else if (i.handle.update) i.handle.update(n);
+	else throw Error(`updateListItem: no updater for item ${String(t)} in list ${e.listId}`);
+}
+function i(e, t, n, r) {
+	if (r && n.length > 0) {
+		let r = e.ownerDocument;
+		if (r) {
+			let i = r.createDocumentFragment();
+			for (let e of n) i.append(e.handle.el);
+			e.insertBefore(i, t);
+			return;
+		}
+	}
+	let i = null;
+	for (let r = n.length - 1; r >= 0; r--) {
+		let a = n[r].handle.el;
+		(a.parentNode !== e || a.nextSibling !== (i ?? t)) && e.insertBefore(a, i ?? t), i = a;
+	}
+}
+function a(e, t, n, r, a, o) {
+	let s = e.items.size === 0, c = [];
+	if (s) for (let t of n) {
+		let n = r(t);
+		if (e.items.get(n) !== void 0) throw Error(`reconcileList: duplicate key ${String(n)} in list ${e.listId}`);
+		let i = {
+			listId: e.listId,
+			itemId: n,
+			bindings: /* @__PURE__ */ new Map()
+		}, o = {
+			state: i,
+			handle: a(t, i)
+		};
+		e.items.set(n, o), c.push(o);
+	}
+	else {
+		let t = /* @__PURE__ */ new Set();
+		for (let i of n) {
+			let n = r(i);
+			if (t.has(n)) throw Error(`reconcileList: duplicate key ${String(n)} in list ${e.listId}`);
+			t.add(n);
+			let s = e.items.get(n);
+			if (s) {
+				if (o) o(s.handle, i);
+				else if (s.handle.update) s.handle.update(i);
+				else throw Error(`reconcileList: no updater for item ${String(n)} in list ${e.listId}`);
+			} else {
+				let t = {
+					listId: e.listId,
+					itemId: n,
+					bindings: /* @__PURE__ */ new Map()
+				}, r = {
+					state: t,
+					handle: a(i, t)
+				};
+				e.items.set(n, r), c.push(r);
+				continue;
+			}
+			c.push(s);
+		}
+		for (let [n, r] of e.items) t.has(n) || (r.handle.el.remove(), e.items.delete(n));
+	}
+	if (!t) return;
+	let u = l(t) ? t.start.parentNode : t;
+	u && i(u, l(t) ? t.end : null, c, s && c.length > 0);
+}
+function o(e, t, n, r, a, o, s = !0) {
+	let c = e.items.size === 0, u = c ? null : /* @__PURE__ */ new Set(), d = [], f = [], p = (t) => {
+		let n = t;
+		for (let t = f.length - 1; t >= 0; t--) {
+			let r = f[t];
+			try {
+				r.handle.destroy?.();
+			} catch (e) {
+				n ??= e;
+			}
+			try {
+				r.handle.el.remove();
+			} catch (e) {
+				n ??= e;
+			}
+			e.items.get(r.state.itemId) === r && e.items.delete(r.state.itemId);
+		}
+		throw n;
+	};
+	try {
+		for (let t of n) {
+			let n = r(t), i = e.items.get(n);
+			if (u ? u.has(n) : i !== void 0) throw Error("reconcileList: duplicate key " + String(n) + " in list " + e.listId);
+			if (u?.add(n), i) {
+				if (o) o(i.handle, t);
+				else if (i.handle.update) i.handle.update(t);
+				else throw Error("reconcileList: no updater for item " + String(n) + " in list " + e.listId);
+			} else {
+				let r = {
+					listId: e.listId,
+					itemId: n,
+					bindings: /* @__PURE__ */ new Map()
+				};
+				i = {
+					state: r,
+					handle: a(t, r)
+				}, e.items.set(n, i), f.push(i);
+			}
+			d.push(i);
+		}
+	} catch (e) {
+		p(e);
+	}
+	let m, h = c ? [] : [...e.items].filter(([e]) => !u.has(e));
+	for (let t = h.length - 1; t >= 0; t--) {
+		let [n, r] = h[t];
+		try {
+			r.handle.destroy?.();
+		} catch (e) {
+			m ??= e;
+		}
+		try {
+			r.handle.el.remove();
+		} catch (e) {
+			m ??= e;
+		}
+		e.items.delete(n);
+	}
+	let g = null, _;
+	if (t && (g = l(t) ? t.start.parentNode : t, g)) {
+		let e = l(t) ? t.end : null;
+		try {
+			i(g, e, d, c && f.length > 0);
+		} catch (e) {
+			m ??= e, _ ??= e;
+		}
+	}
+	if (_ && f.length > 0 && p(m ?? _), s) {
+		g || f.length > 0 && p(m ?? /* @__PURE__ */ Error("reconcileList: range is detached"));
+		for (let t of f) if (e.items.has(t.state.itemId) && t.handle.el.parentNode === g) try {
+			t.handle.mount?.();
+		} catch (e) {
+			p(m ?? e);
+		}
+	}
+	if (m) throw m;
+}
+function s(e) {
+	try {
+		for (let t of e.items.values()) t.handle.mount?.();
+	} catch (t) {
+		let n = t;
+		try {
+			c(e);
+		} catch (e) {
+			n ??= e;
+		}
+		throw n;
+	}
+}
+function c(e) {
+	let t, n = [...e.items.values()];
+	for (let e = n.length - 1; e >= 0; e--) {
+		let r = n[e];
+		try {
+			r.handle.destroy?.();
+		} catch (e) {
+			t ??= e;
+		}
+		try {
+			r.handle.el.remove();
+		} catch (e) {
+			t ??= e;
+		}
+	}
+	if (e.items.clear(), t) throw t;
+}
+function l(e) {
+	return !("nodeType" in e);
+}
+var u = /* @__PURE__ */ new Map();
+function d(e, t) {
+	let n = e;
+	function r(...e) {
+		if (e.length === 0) return n;
+		let t = e[0];
+		return n = typeof t == "function" ? t(n) : t, n;
+	}
+	return t && u.set(t, { kind: "signal" }), r;
+}
+function f(e) {
+	let t = e, n = /* @__PURE__ */ new Set(), r = ((...e) => {
+		if (e.length === 0) return t;
+		let r = e[0];
+		t = typeof r == "function" ? r(t) : r;
+		for (let e of Array.from(n)) e();
+		return t;
+	});
+	return r.subscribe = (e) => {
+		n.add(e);
+		let t = !0;
+		return () => {
+			t && (t = !1, n.delete(e));
+		};
+	}, r;
+}
+function p(e, t) {
+	return t && u.set(t, { kind: "derived" }), e;
+}
+function m(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	if (v(e, n), t) {
+		let e = t.filter((e) => !n.has(e));
+		if (e.length > 0) throw Error(`hydrate: missing marker(s): ${e.join(", ")} — initial HTML does not match compiled output`);
+	}
+	return { markers: n };
+}
+function h(e, t, n) {
+	return e.innerHTML = t, m(e, n);
+}
+function g(e, t, n) {
+	let { markers: r } = m(e, t), i = /* @__PURE__ */ new Map();
+	if (n && y(e, i), n) {
+		let e = n.filter((e) => !i.has(e));
+		if (e.length > 0) throw Error(`hydrate: missing range anchor(s): ${e.join(", ")} — initial HTML does not match compiled output`);
+	}
+	return {
+		markers: r,
+		ranges: i
+	};
+}
+function _(e, t, n, r) {
+	return e.innerHTML = t, g(e, n, r);
+}
+function v(e, t) {
+	let n = e.getAttribute("data-iris-id");
+	n && t.set(n, e);
+	for (let n of e.children) v(n, t);
+}
+function y(e, t) {
+	let n = /* @__PURE__ */ new Map(), r = (e) => {
+		for (let i = e.firstChild; i; i = i.nextSibling) {
+			if (i.nodeType === 8) {
+				let e = i.data;
+				if (e.startsWith("irisout:start:")) n.set(e.slice(14), i);
+				else if (e.startsWith("irisout:end:")) {
+					let r = e.slice(12), a = n.get(r);
+					a && a.parentNode === i.parentNode && t.set(r, {
+						start: a,
+						end: i
+					});
+				}
+			}
+			r(i);
+		}
+	};
+	r(e);
+}
+//#endregion
+export { t as createListRuntime, p as derived, c as destroyListRuntime, m as hydrate, g as hydrateWithRanges, h as mount, s as mountListRuntime, _ as mountWithRanges, e as normalizeUseActionResult, a as reconcileList, o as reconcileListWithLifecycle, u as registry, f as sharedSignal, d as signal, n as updateListBinding, r as updateListItem };

package/dist/state.js

@@ -0,0 +1,46 @@
+//#region packages/compiler/src/compiler/state.ts
+var e = (e) => e, t = (e) => e, n = (e) => e;
+function r(e, t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set()) {
+	return {
+		source: e,
+		supportNames: n,
+		transformedNodes: t,
+		declIdByKey: /* @__PURE__ */ new Map(),
+		declKind: /* @__PURE__ */ new Map(),
+		declOutputName: /* @__PURE__ */ new Map(),
+		derivedDeps: /* @__PURE__ */ new Map(),
+		derivedRecompute: /* @__PURE__ */ new Map(),
+		collectionKeyRendered: /* @__PURE__ */ new Map(),
+		usedOutputNames: /* @__PURE__ */ new Set(),
+		markers: [],
+		markerDeps: /* @__PURE__ */ new Map(),
+		handlers: [],
+		actions: [],
+		mounts: [],
+		effects: [],
+		contexts: /* @__PURE__ */ new Map(),
+		contextIdByKey: /* @__PURE__ */ new Map(),
+		contextValues: /* @__PURE__ */ new Map(),
+		attrBindings: [],
+		markerCounter: 0,
+		instanceCounter: 0,
+		movementFns: /* @__PURE__ */ new Map(),
+		trackedFns: /* @__PURE__ */ new Map(),
+		localDeclIds: /* @__PURE__ */ new Set(),
+		sharedDecls: [],
+		sharedDeclIdByBindingKey: /* @__PURE__ */ new Map(),
+		sharedDeclIds: /* @__PURE__ */ new Set(),
+		usedSharedDeclIds: /* @__PURE__ */ new Set()
+	};
+}
+var i = (e, t, n) => `${e}:${t}:${n}`;
+function a(e) {
+	return t(`m${e.markerCounter++}`);
+}
+function o(e, t, n) {
+	let r = t, i = 1;
+	for (; e.usedOutputNames.has(r);) r = `${t}$${i++}`;
+	return e.usedOutputNames.add(r), e.declOutputName.set(n, r), r;
+}
+//#endregion
+export { o as assignOutputName, r as createCompilerState, i as declKey, a as nextMarkerId, n as toContextId, e as toDeclId, t as toMarkerId };

package/dist/vite.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from 'vite-plus';
+export interface IrisoutPluginOptions {
+    /** Viteのrootから解決する入口。絶対pathも受け付ける。 */
+    entry: string;
+    /** 初期HTMLを埋め込む場所とhydrate対象を示すCSS selector。 */
+    container?: string;
+    /** index.html内で初期HTMLを置き換える文字列。 */
+    htmlMarker?: string;
+    /** main.jsからimportする仮想module名。 */
+    virtualModuleId?: string;
+}
+/**
+ * authored JSXをcompileProject()で生成し、Viteの標準module graphへ渡す連携。
+ * compilerの実行はビルド時と入口・依存のHMR時だけで、ブラウザへはhydrate用の
+ * 生成moduleと初期HTMLを渡す。
+ */
+export declare function irisout(options: IrisoutPluginOptions): Plugin;
+export default irisout;

package/dist/vite.js

@@ -0,0 +1,67 @@
+import e from "node:path";
+import { compileProject as t } from "./index.js";
+//#region packages/vite-plugin/src/index.ts
+var n = "virtual:irisout-entry", r = "<!--irisout-html-->", i = "#app";
+function a(t) {
+	return e.normalize(e.resolve(t));
+}
+function o(o) {
+	let s = o.virtualModuleId ?? n, c = o.htmlMarker ?? r, l = o.container ?? i, u = process.cwd(), d = a(e.resolve(u, o.entry)), f = e.join(u, `.irisout-${encodeURIComponent(s)}.js`), p = null, m = /* @__PURE__ */ new Set(), h = () => {
+		let e = t(d);
+		return p = e, m = new Set(e.dependencies.map(a)), e;
+	}, g = () => p ?? h(), _ = (e) => {
+		for (let t of m) e(t);
+	}, v = () => {
+		if (l === "#app") return "hydrateComponent(document.getElementById('app'));";
+		let e = JSON.stringify(l), t = JSON.stringify(`irisout hydrate container not found: ${l}`);
+		return [
+			`const __irisout_container__ = document.querySelector(${e});`,
+			`if (!__irisout_container__) throw new Error(${t});`,
+			"hydrateComponent(__irisout_container__);"
+		].join("\n");
+	};
+	return {
+		name: "irisout",
+		configResolved(t) {
+			u = t.root, d = a(e.resolve(u, o.entry)), f = e.join(u, `.irisout-${encodeURIComponent(s)}.js`), p = null, m = /* @__PURE__ */ new Set();
+		},
+		buildStart() {
+			h(), _((e) => this.addWatchFile(e));
+		},
+		configureServer(e) {
+			let t = g();
+			e.watcher.add([...t.dependencies]);
+		},
+		resolveId(e) {
+			return e === s ? f : null;
+		},
+		load(e) {
+			if (e !== f) return null;
+			let t = g();
+			return {
+				code: `${t.code}\n${v()}`,
+				map: t.map
+			};
+		},
+		transformIndexHtml(e) {
+			return e.includes(c) ? e.replaceAll(c, g().initialHtml) : e;
+		},
+		async handleHotUpdate(e) {
+			let t = a(e.file);
+			if (m.size === 0 && g(), !m.has(t)) return;
+			let n = p;
+			try {
+				let t = h();
+				e.server.watcher.add([...t.dependencies]);
+			} catch (e) {
+				throw p = n, e;
+			}
+			return e.server.ws.send({
+				type: "full-reload",
+				path: "*"
+			}), [];
+		}
+	};
+}
+//#endregion
+export { o as default, o as irisout };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "irisout",
+  "version": "0.2.1",
+  "license": "Apache-2.0",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./diagnostics": {
+      "types": "./dist/diagnostics.d.ts",
+      "import": "./dist/diagnostics.js"
+    },
+    "./state": {
+      "types": "./dist/compiler/state.d.ts",
+      "import": "./dist/state.js"
+    },
+    "./jsx": "./dist/jsx.d.ts"
+  },
+  "peerDependencies": {
+    "vite-plus": ">=0.3.0"
+  }
+}