eclipsa 0.1.0 → 0.1.2

package/package.json

@@ -1,4 +1,70 @@
 {
-    "name": "eclipsa",
-    "version": "0.1.0"
-}
+  "name": "eclipsa",
+  "version": "0.1.2",
+  "homepage": "https://github.com/pnsk-lab/eclipsa",
+  "bugs": {
+    "url": "https://github.com/pnsk-lab/eclipsa/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pnsk-lab/eclipsa.git",
+    "directory": "packages/eclipsa"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./mod.d.mts",
+      "import": "./mod.mjs"
+    },
+    "./atom": {
+      "types": "./atom/mod.d.mts",
+      "import": "./atom/mod.mjs"
+    },
+    "./web-utils": {
+      "types": "./web-utils/mod.d.mts",
+      "import": "./web-utils/mod.mjs"
+    },
+    "./vite": {
+      "types": "./vite/mod.d.mts",
+      "import": "./vite/mod.mjs"
+    },
+    "./jsx-runtime": {
+      "types": "./jsx/jsx-runtime.d.mts",
+      "import": "./jsx/jsx-runtime.mjs"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./jsx/jsx-dev-runtime.d.mts",
+      "import": "./jsx/jsx-dev-runtime.mjs"
+    },
+    "./jsx": {
+      "types": "./jsx/mod.d.mts",
+      "import": "./jsx/mod.mjs"
+    },
+    "./internal": {
+      "types": "./core/internal.d.mts",
+      "import": "./core/internal.mjs"
+    },
+    "./client": {
+      "types": "./core/client/mod.d.mts",
+      "import": "./core/client/mod.mjs"
+    },
+    "./dev-client": {
+      "types": "./core/dev-client/mod.d.mts",
+      "import": "./core/dev-client/mod.mjs"
+    },
+    "./prod-client": {
+      "types": "./core/prod-client/mod.d.mts",
+      "import": "./core/prod-client/mod.mjs"
+    }
+  },
+  "dependencies": {
+    "@eclipsa/optimizer": "^0.1.2",
+    "fast-glob": "^3.3.2",
+    "hono": "^4.6.4"
+  },
+  "peerDependencies": {
+    "vite": "*"
+  },
+  "private": false
+}

package/resume-hmr-BRDojQNp.mjs

@@ -0,0 +1,6 @@
+//#region core/resume-hmr.ts
+const RESUME_HMR_EVENT = "eclipsa:resume-update";
+//#endregion
+export { RESUME_HMR_EVENT as t };
+
+//# sourceMappingURL=resume-hmr-BRDojQNp.mjs.map

package/resume-hmr-BRDojQNp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-hmr-BRDojQNp.mjs","names":[],"sources":["../core/resume-hmr.ts"],"sourcesContent":["export const RESUME_HMR_EVENT = 'eclipsa:resume-update'\n\nexport interface ResumeHmrUpdatePayload {\n  fileUrl: string\n  fullReload: boolean\n  rerenderComponentSymbols: string[]\n  rerenderOwnerSymbols: string[]\n  symbolUrlReplacements: Record<string, string>\n}\n"],"mappings":";AAAA,MAAa,mBAAmB"}

package/signal-CosyYdtA.d.mts

@@ -0,0 +1,22 @@
+//#region core/signal.d.ts
+interface Signal<T> {
+  value: T;
+}
+interface SignalFactory {
+  <T>(value: T): Signal<T>;
+  <T>(value?: T | undefined): Signal<T | undefined>;
+  computed<T>(value: () => T | Promise<T>, dependencies?: WatchDependency[]): Signal<T>;
+}
+type WatchDependency<T = unknown> = Signal<T> | (() => T);
+declare const signal: SignalFactory;
+declare const useSignal: SignalFactory;
+declare const effect: (fn: () => void) => void;
+declare const onCleanup: (fn: () => void) => void;
+declare const onMount: (fn: () => void) => void;
+declare const onVisible: (fn: () => void) => void;
+declare const useWatch: (fn: () => void, dependencies?: WatchDependency[]) => void;
+declare const useComputed: <T>(fn: () => T | Promise<T>, dependencies?: WatchDependency[]) => Signal<T>;
+declare const useComputed$: <T>(fn: () => T | Promise<T>, dependencies?: WatchDependency[]) => Signal<T>;
+//#endregion
+export { onMount as a, useComputed as c, useWatch as d, onCleanup as i, useComputed$ as l, WatchDependency as n, onVisible as o, effect as r, signal as s, Signal as t, useSignal as u };
+//# sourceMappingURL=signal-CosyYdtA.d.mts.map

package/signal-D1WmFjmJ.mjs

@@ -0,0 +1,108 @@
+import { A as createWatch, D as createOnVisible, E as createOnMount, N as getRuntimeContainer, P as getRuntimeSignalId, T as createOnCleanup, V as readAsyncSignalSnapshot, dt as useRuntimeSignal, gn as isPendingSignalError, hn as createPendingSignalError, k as createStandaloneRuntimeSignal, pt as writeAsyncSignalSnapshot, w as createEffect } from "./action-DstcBFEm.mjs";
+//#region core/signal.ts
+const isPromiseLike = (value) => !!value && typeof value === "object" && "then" in value && typeof value.then === "function";
+const isComputedSnapshot = (value) => !!value && typeof value === "object" && value.__e_async_computed === true;
+const createComputedSnapshot = (snapshot) => ({
+	__e_async_computed: true,
+	...snapshot
+});
+const createComputedSignalFactory = (createBaseSignal) => (fn, dependencies) => {
+	const state = createBaseSignal(createComputedSnapshot({ status: "pending" }));
+	const runtimeContainer = getRuntimeContainer();
+	const signalId = getRuntimeSignalId(state);
+	const seededSnapshot = signalId !== null ? readAsyncSignalSnapshot(signalId, runtimeContainer) : void 0;
+	let useSeededSnapshot = !!seededSnapshot && seededSnapshot.status !== "pending";
+	let version = 0;
+	createEffect(() => {
+		if (useSeededSnapshot && seededSnapshot) {
+			useSeededSnapshot = false;
+			state.value = seededSnapshot;
+			if (signalId !== null) writeAsyncSignalSnapshot(signalId, seededSnapshot, runtimeContainer);
+			return;
+		}
+		const currentVersion = ++version;
+		try {
+			const nextValue = fn();
+			if (isPromiseLike(nextValue)) {
+				const pending = createComputedSnapshot({
+					promise: nextValue,
+					status: "pending"
+				});
+				state.value = pending;
+				if (signalId !== null) writeAsyncSignalSnapshot(signalId, pending, runtimeContainer);
+				nextValue.then((resolved) => {
+					if (currentVersion !== version) return;
+					const completed = createComputedSnapshot({
+						status: "resolved",
+						value: resolved
+					});
+					state.value = completed;
+					if (signalId !== null) writeAsyncSignalSnapshot(signalId, completed, runtimeContainer);
+				}, (error) => {
+					if (currentVersion !== version) return;
+					const failed = createComputedSnapshot({
+						error,
+						status: "rejected"
+					});
+					state.value = failed;
+					if (signalId !== null) writeAsyncSignalSnapshot(signalId, failed, runtimeContainer);
+				});
+				return;
+			}
+			const resolved = createComputedSnapshot({
+				status: "resolved",
+				value: nextValue
+			});
+			state.value = resolved;
+			if (signalId !== null) writeAsyncSignalSnapshot(signalId, resolved, runtimeContainer);
+		} catch (error) {
+			if (isPendingSignalError(error)) {
+				const pending = createComputedSnapshot({
+					promise: error.promise,
+					status: "pending"
+				});
+				state.value = pending;
+				if (signalId !== null) writeAsyncSignalSnapshot(signalId, pending, runtimeContainer);
+				return;
+			}
+			const failed = createComputedSnapshot({
+				error,
+				status: "rejected"
+			});
+			state.value = failed;
+			if (signalId !== null) writeAsyncSignalSnapshot(signalId, failed, runtimeContainer);
+		}
+	}, dependencies ? {
+		dependencies,
+		errorLabel: "useComputed",
+		untracked: true
+	} : void 0);
+	const handle = {};
+	Object.defineProperty(handle, "value", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const snapshot = state.value;
+			if (!isComputedSnapshot(snapshot)) return snapshot;
+			if (snapshot.status === "pending") throw createPendingSignalError(snapshot.promise ?? Promise.resolve(void 0));
+			if (snapshot.status === "rejected") throw snapshot.error;
+			return snapshot.value;
+		}
+	});
+	return handle;
+};
+const signal = ((value) => createStandaloneRuntimeSignal(value));
+const useSignal = ((value) => useRuntimeSignal(value));
+signal.computed = createComputedSignalFactory((value) => createStandaloneRuntimeSignal(value));
+useSignal.computed = createComputedSignalFactory((value) => useRuntimeSignal(value));
+const effect = (fn) => createEffect(fn);
+const onCleanup = (fn) => createOnCleanup(fn);
+const onMount = (fn) => createOnMount(fn);
+const onVisible = (fn) => createOnVisible(fn);
+const useWatch = (fn, dependencies) => createWatch(fn, dependencies);
+const useComputed = (fn, dependencies) => useSignal.computed(fn, dependencies);
+const useComputed$ = useComputed;
+//#endregion
+export { signal as a, useSignal as c, onVisible as i, useWatch as l, onCleanup as n, useComputed as o, onMount as r, useComputed$ as s, effect as t };
+
+//# sourceMappingURL=signal-D1WmFjmJ.mjs.map

package/signal-D1WmFjmJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-D1WmFjmJ.mjs","names":[],"sources":["../core/signal.ts"],"sourcesContent":["import {\n  createStandaloneRuntimeSignal,\n  createEffect,\n  createOnCleanup,\n  createOnMount,\n  createOnVisible,\n  createWatch,\n  getRuntimeContainer,\n  getRuntimeSignalId,\n  readAsyncSignalSnapshot,\n  useRuntimeSignal,\n  writeAsyncSignalSnapshot,\n} from './runtime.ts'\nimport { createPendingSignalError, isPendingSignalError } from './suspense.ts'\n\nexport interface Signal<T> {\n  value: T\n}\n\ninterface SignalFactory {\n  <T>(value: T): Signal<T>\n  <T>(value?: T | undefined): Signal<T | undefined>\n  computed<T>(value: () => T | Promise<T>, dependencies?: WatchDependency[]): Signal<T>\n}\n\ninterface ComputedSnapshot<T> {\n  __e_async_computed: true\n  error?: unknown\n  promise?: Promise<T>\n  status: 'pending' | 'rejected' | 'resolved'\n  value?: T\n}\n\nexport type WatchDependency<T = unknown> = Signal<T> | (() => T)\n\nconst isPromiseLike = <T>(value: unknown): value is Promise<T> =>\n  !!value && typeof value === 'object' && 'then' in value && typeof value.then === 'function'\n\nconst isComputedSnapshot = <T>(value: unknown): value is ComputedSnapshot<T> =>\n  !!value && typeof value === 'object' && (value as ComputedSnapshot<T>).__e_async_computed === true\n\nconst createComputedSnapshot = <T>(\n  snapshot: Omit<ComputedSnapshot<T>, '__e_async_computed'>,\n): ComputedSnapshot<T> => ({\n  __e_async_computed: true,\n  ...snapshot,\n})\n\nconst createComputedSignalFactory =\n  (createBaseSignal: <T>(value: T) => Signal<T>): SignalFactory['computed'] =>\n  <T>(fn: () => T | Promise<T>, dependencies?: WatchDependency[]) => {\n    const state = createBaseSignal<ComputedSnapshot<T>>(\n      createComputedSnapshot({\n        status: 'pending',\n      }),\n    )\n    const runtimeContainer = getRuntimeContainer()\n    const signalId = getRuntimeSignalId(state)\n    const seededSnapshot =\n      signalId !== null\n        ? (readAsyncSignalSnapshot(signalId, runtimeContainer) as ComputedSnapshot<T> | undefined)\n        : undefined\n    let useSeededSnapshot = !!seededSnapshot && seededSnapshot.status !== 'pending'\n    let version = 0\n\n    createEffect(\n      () => {\n        if (useSeededSnapshot && seededSnapshot) {\n          useSeededSnapshot = false\n          state.value = seededSnapshot\n          if (signalId !== null) {\n            writeAsyncSignalSnapshot(signalId, seededSnapshot, runtimeContainer)\n          }\n          return\n        }\n\n        const currentVersion = ++version\n        try {\n          const nextValue = fn()\n          if (isPromiseLike<T>(nextValue)) {\n            const pending = createComputedSnapshot<T>({\n              promise: nextValue,\n              status: 'pending',\n            })\n            state.value = pending\n            if (signalId !== null) {\n              writeAsyncSignalSnapshot(signalId, pending, runtimeContainer)\n            }\n            nextValue.then(\n              (resolved) => {\n                if (currentVersion !== version) {\n                  return\n                }\n                const completed = createComputedSnapshot<T>({\n                  status: 'resolved',\n                  value: resolved,\n                })\n                state.value = completed\n                if (signalId !== null) {\n                  writeAsyncSignalSnapshot(signalId, completed, runtimeContainer)\n                }\n              },\n              (error) => {\n                if (currentVersion !== version) {\n                  return\n                }\n                const failed = createComputedSnapshot<T>({\n                  error,\n                  status: 'rejected',\n                })\n                state.value = failed\n                if (signalId !== null) {\n                  writeAsyncSignalSnapshot(signalId, failed, runtimeContainer)\n                }\n              },\n            )\n            return\n          }\n\n          const resolved = createComputedSnapshot<T>({\n            status: 'resolved',\n            value: nextValue,\n          })\n          state.value = resolved\n          if (signalId !== null) {\n            writeAsyncSignalSnapshot(signalId, resolved, runtimeContainer)\n          }\n        } catch (error) {\n          if (isPendingSignalError(error)) {\n            const pending = createComputedSnapshot<T>({\n              promise: error.promise as Promise<T>,\n              status: 'pending',\n            })\n            state.value = pending\n            if (signalId !== null) {\n              writeAsyncSignalSnapshot(signalId, pending, runtimeContainer)\n            }\n            return\n          }\n          const failed = createComputedSnapshot<T>({\n            error,\n            status: 'rejected',\n          })\n          state.value = failed\n          if (signalId !== null) {\n            writeAsyncSignalSnapshot(signalId, failed, runtimeContainer)\n          }\n        }\n      },\n      dependencies\n        ? {\n            dependencies,\n            errorLabel: 'useComputed',\n            untracked: true,\n          }\n        : undefined,\n    )\n\n    const handle = {} as Signal<T>\n    Object.defineProperty(handle, 'value', {\n      configurable: true,\n      enumerable: true,\n      get() {\n        const snapshot = state.value\n        if (!isComputedSnapshot<T>(snapshot)) {\n          return snapshot as T\n        }\n        if (snapshot.status === 'pending') {\n          throw createPendingSignalError(snapshot.promise ?? Promise.resolve(undefined))\n        }\n        if (snapshot.status === 'rejected') {\n          throw snapshot.error\n        }\n        return snapshot.value as T\n      },\n    })\n    return handle\n  }\n\nexport const signal = ((value) => createStandaloneRuntimeSignal(value)) as SignalFactory\n\nexport const useSignal = ((value) => useRuntimeSignal(value)) as SignalFactory\n\nsignal.computed = createComputedSignalFactory((value) => createStandaloneRuntimeSignal(value))\nuseSignal.computed = createComputedSignalFactory((value) => useRuntimeSignal(value))\n\nexport const effect = (fn: () => void) => createEffect(fn)\nexport const onCleanup = (fn: () => void) => createOnCleanup(fn)\nexport const onMount = (fn: () => void) => createOnMount(fn)\nexport const onVisible = (fn: () => void) => createOnVisible(fn)\nexport const useWatch = (fn: () => void, dependencies?: WatchDependency[]) =>\n  createWatch(fn, dependencies)\n\nexport const useComputed = <T>(fn: () => T | Promise<T>, dependencies?: WatchDependency[]) =>\n  useSignal.computed(fn, dependencies)\nexport const useComputed$ = useComputed\n"],"mappings":"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"}

package/snapshot-BG0kq9wt.mjs

@@ -0,0 +1,39 @@
+//#region core/snapshot.ts
+const SNAPSHOT_STATE_KEY = Symbol.for("eclipsa.snapshot-state");
+const getCurrentSnapshotState = () => {
+	return globalThis[SNAPSHOT_STATE_KEY] ?? null;
+};
+const setCurrentSnapshotState = (state) => {
+	globalThis[SNAPSHOT_STATE_KEY] = state;
+};
+const withSignalSnapshot = (values, fn) => {
+	const previous = getCurrentSnapshotState();
+	const state = {
+		readers: [],
+		cursor: 0,
+		values
+	};
+	setCurrentSnapshotState(state);
+	try {
+		return {
+			result: fn(),
+			values: values ?? state.readers.map((reader) => reader.read())
+		};
+	} finally {
+		setCurrentSnapshotState(previous);
+	}
+};
+const consumeSnapshotValue = (fallback) => {
+	const state = getCurrentSnapshotState();
+	if (!state) return fallback;
+	const index = state.cursor++;
+	if (state.values && index < state.values.length) return state.values[index];
+	return fallback;
+};
+const registerSnapshotSignal = (reader) => {
+	getCurrentSnapshotState()?.readers.push(reader);
+};
+//#endregion
+export { registerSnapshotSignal as n, withSignalSnapshot as r, consumeSnapshotValue as t };
+
+//# sourceMappingURL=snapshot-BG0kq9wt.mjs.map

package/snapshot-BG0kq9wt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-BG0kq9wt.mjs","names":[],"sources":["../core/snapshot.ts"],"sourcesContent":["interface SignalReader {\n  read(): unknown\n}\n\ninterface SnapshotState {\n  readers: SignalReader[]\n  cursor: number\n  values: unknown[] | null\n}\n\nconst SNAPSHOT_STATE_KEY = Symbol.for('eclipsa.snapshot-state')\n\nconst getCurrentSnapshotState = (): SnapshotState | null => {\n  return (\n    (globalThis as unknown as Record<PropertyKey, SnapshotState | null>)[SNAPSHOT_STATE_KEY] ?? null\n  )\n}\n\nconst setCurrentSnapshotState = (state: SnapshotState | null) => {\n  ;(globalThis as unknown as Record<PropertyKey, SnapshotState | null>)[SNAPSHOT_STATE_KEY] = state\n}\n\nexport const withSignalSnapshot = <T>(\n  values: unknown[] | null,\n  fn: () => T,\n): {\n  result: T\n  values: unknown[]\n} => {\n  const previous = getCurrentSnapshotState()\n  const state: SnapshotState = {\n    readers: [],\n    cursor: 0,\n    values,\n  }\n  setCurrentSnapshotState(state)\n\n  try {\n    const result = fn()\n    return {\n      result,\n      values: values ?? state.readers.map((reader) => reader.read()),\n    }\n  } finally {\n    setCurrentSnapshotState(previous)\n  }\n}\n\nexport const consumeSnapshotValue = <T>(fallback: T): T => {\n  const state = getCurrentSnapshotState()\n  if (!state) {\n    return fallback\n  }\n\n  const index = state.cursor++\n  if (state.values && index < state.values.length) {\n    return state.values[index] as T\n  }\n\n  return fallback\n}\n\nexport const registerSnapshotSignal = (reader: SignalReader) => {\n  getCurrentSnapshotState()?.readers.push(reader)\n}\n"],"mappings":";AAUA,MAAM,qBAAqB,OAAO,IAAI,yBAAyB;AAE/D,MAAM,gCAAsD;AAC1D,QACG,WAAoE,uBAAuB;;AAIhG,MAAM,2BAA2B,UAAgC;AAC7D,YAAoE,sBAAsB;;AAG9F,MAAa,sBACX,QACA,OAIG;CACH,MAAM,WAAW,yBAAyB;CAC1C,MAAM,QAAuB;EAC3B,SAAS,EAAE;EACX,QAAQ;EACR;EACD;AACD,yBAAwB,MAAM;AAE9B,KAAI;AAEF,SAAO;GACL,QAFa,IAAI;GAGjB,QAAQ,UAAU,MAAM,QAAQ,KAAK,WAAW,OAAO,MAAM,CAAC;GAC/D;WACO;AACR,0BAAwB,SAAS;;;AAIrC,MAAa,wBAA2B,aAAmB;CACzD,MAAM,QAAQ,yBAAyB;AACvC,KAAI,CAAC,MACH,QAAO;CAGT,MAAM,QAAQ,MAAM;AACpB,KAAI,MAAM,UAAU,QAAQ,MAAM,OAAO,OACvC,QAAO,MAAM,OAAO;AAGtB,QAAO;;AAGT,MAAa,0BAA0B,WAAyB;AAC9D,0BAAyB,EAAE,QAAQ,KAAK,OAAO"}

package/types-DDeNM8UH.d.mts

@@ -0,0 +1,11 @@
+//#region core/client/types.d.ts
+interface ElemWithKey {
+  (): Insertable;
+  key?: string | symbol | number;
+  returnFn?: boolean;
+}
+type Insertable = string | number | boolean | undefined | null | Node | Insertable[] | ElemWithKey;
+type ClientElementLike = Insertable | Insertable[];
+//#endregion
+export { Insertable as n, ClientElementLike as t };
+//# sourceMappingURL=types-DDeNM8UH.d.mts.map

package/types-WOJV0N2h.d.mts

@@ -0,0 +1,282 @@
+//#region jsx/types.d.ts
+type SupportedDelegatedEventName = 'cancel' | 'change' | 'click' | 'compositionend' | 'compositionstart' | 'input' | 'keydown' | 'submit';
+type DelegatedEventMap = {
+  cancel: Event;
+  change: Event;
+  click: MouseEvent;
+  compositionend: CompositionEvent;
+  compositionstart: CompositionEvent;
+  input: InputEvent;
+  keydown: KeyboardEvent;
+  submit: SubmitEvent;
+};
+type AttributeValue = string | number | boolean | null | undefined;
+type StyleValue = string | number | null | undefined;
+type BindTarget<T> = {
+  value: T;
+};
+type RefProp<TElement extends globalThis.Element> = {
+  value: TElement | undefined;
+};
+type DataAttributeProps = { [TName in `data-${string}`]?: AttributeValue };
+type AriaAttributeProps = { [TName in `aria-${string}`]?: AttributeValue };
+type NamespacedAttributeProps = { [TName in `${string}:${string}`]?: AttributeValue };
+type HyphenatedAttributeProps = { [TName in `${string}-${string}`]?: AttributeValue };
+type DelegatedEvent<TCurrentTarget extends globalThis.Element = globalThis.Element, TEvent extends Event = Event> = Omit<TEvent, 'currentTarget'> & {
+  readonly currentTarget: TCurrentTarget;
+};
+type EventHandler<TCurrentTarget extends globalThis.Element = globalThis.Element, TEvent extends Event = Event> = (event: DelegatedEvent<TCurrentTarget, TEvent>) => unknown;
+type DelegatedEventPropName<TName extends SupportedDelegatedEventName> = TName extends 'cancel' ? 'onCancel' : TName extends 'compositionend' ? 'onCompositionEnd' : TName extends 'compositionstart' ? 'onCompositionStart' : TName extends 'keydown' ? 'onKeyDown' : `on${Capitalize<TName>}`;
+type DelegatedEventProps<TElement extends globalThis.Element> = { [TName in SupportedDelegatedEventName as DelegatedEventPropName<TName>]?: EventHandler<TElement, DelegatedEventMap[TName]> };
+interface BaseIntrinsicElementProps<TElement extends globalThis.Element> extends AriaAttributeProps, DataAttributeProps, DelegatedEventProps<TElement> {
+  children?: unknown;
+  class?: string | undefined;
+  dangerouslySetInnerHTML?: string | null | undefined;
+  id?: string | undefined;
+  key?: string | number | symbol | null | undefined;
+  ref?: RefProp<TElement> | RefProp<globalThis.Element> | undefined;
+  role?: string | undefined;
+  slot?: string | undefined;
+  style?: string | Record<string, StyleValue> | undefined;
+  tabIndex?: number | undefined;
+  title?: string | undefined;
+}
+interface HTMLIntrinsicElementProps<TElement extends HTMLElement> extends BaseIntrinsicElementProps<TElement> {
+  accessKey?: string | undefined;
+  autoCapitalize?: string | undefined;
+  autoFocus?: boolean | undefined;
+  contentEditable?: boolean | 'inherit' | 'plaintext-only' | undefined;
+  dir?: 'auto' | 'ltr' | 'rtl' | undefined;
+  draggable?: boolean | undefined;
+  enterKeyHint?: 'done' | 'enter' | 'go' | 'next' | 'previous' | 'search' | 'send' | undefined;
+  hidden?: boolean | undefined;
+  inert?: boolean | undefined;
+  inputMode?: 'decimal' | 'email' | 'none' | 'numeric' | 'search' | 'tel' | 'text' | 'url' | undefined;
+  lang?: string | undefined;
+  spellCheck?: boolean | undefined;
+  translate?: 'no' | 'yes' | undefined;
+}
+interface SVGIntrinsicElementProps<TElement extends SVGElement> extends BaseIntrinsicElementProps<TElement>, HyphenatedAttributeProps, NamespacedAttributeProps {
+  color?: string | undefined;
+  cx?: number | string | undefined;
+  cy?: number | string | undefined;
+  d?: string | undefined;
+  fill?: string | undefined;
+  gradientTransform?: string | undefined;
+  gradientUnits?: string | undefined;
+  height?: number | string | undefined;
+  offset?: number | string | undefined;
+  opacity?: number | string | undefined;
+  points?: string | undefined;
+  preserveAspectRatio?: string | undefined;
+  r?: number | string | undefined;
+  rx?: number | string | undefined;
+  ry?: number | string | undefined;
+  stroke?: string | undefined;
+  transform?: string | undefined;
+  version?: number | string | undefined;
+  viewBox?: string | undefined;
+  width?: number | string | undefined;
+  x?: number | string | undefined;
+  x1?: number | string | undefined;
+  x2?: number | string | undefined;
+  y?: number | string | undefined;
+  y1?: number | string | undefined;
+  y2?: number | string | undefined;
+  xmlns?: string | undefined;
+}
+type ButtonType = 'button' | 'reset' | 'submit';
+type CrossOrigin = 'anonymous' | 'use-credentials';
+type FormEncType = 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'text/plain';
+type FormMethod = 'dialog' | 'get' | 'post';
+type HTMLInputType = 'button' | 'checkbox' | 'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'month' | 'number' | 'password' | 'radio' | 'range' | 'reset' | 'search' | 'submit' | 'tel' | 'text' | 'time' | 'url' | 'week';
+type Loading = 'eager' | 'lazy';
+type ReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+interface AnchorHTMLAttributes<TElement extends HTMLAnchorElement> extends HTMLIntrinsicElementProps<TElement> {
+  download?: boolean | string | undefined;
+  href?: string | undefined;
+  hreflang?: string | undefined;
+  ping?: string | undefined;
+  referrerPolicy?: ReferrerPolicy | undefined;
+  rel?: string | undefined;
+  target?: string | undefined;
+  type?: string | undefined;
+}
+interface ButtonHTMLAttributes<TElement extends HTMLButtonElement> extends HTMLIntrinsicElementProps<TElement> {
+  disabled?: boolean | undefined;
+  form?: string | undefined;
+  name?: string | undefined;
+  type?: ButtonType | undefined;
+  value?: number | string | undefined;
+}
+interface FormHTMLAttributes<TElement extends HTMLFormElement> extends HTMLIntrinsicElementProps<TElement> {
+  action?: string | undefined;
+  autoComplete?: string | undefined;
+  encType?: FormEncType | undefined;
+  method?: FormMethod | undefined;
+  name?: string | undefined;
+  noValidate?: boolean | undefined;
+  target?: string | undefined;
+}
+interface ImgHTMLAttributes<TElement extends HTMLImageElement> extends HTMLIntrinsicElementProps<TElement> {
+  alt?: string | undefined;
+  crossOrigin?: CrossOrigin | undefined;
+  decoding?: 'async' | 'auto' | 'sync' | undefined;
+  height?: number | string | undefined;
+  loading?: Loading | undefined;
+  referrerPolicy?: ReferrerPolicy | undefined;
+  sizes?: string | undefined;
+  src?: string | undefined;
+  srcSet?: string | undefined;
+  width?: number | string | undefined;
+}
+interface InputHTMLAttributes<TElement extends HTMLInputElement> extends HTMLIntrinsicElementProps<TElement> {
+  'bind:checked'?: BindTarget<boolean | undefined> | undefined;
+  'bind:value'?: BindTarget<number | readonly string[] | string | undefined> | undefined;
+  accept?: string | undefined;
+  alt?: string | undefined;
+  autoComplete?: string | undefined;
+  capture?: boolean | 'environment' | 'user' | undefined;
+  checked?: boolean | undefined;
+  disabled?: boolean | undefined;
+  form?: string | undefined;
+  list?: string | undefined;
+  max?: number | string | undefined;
+  maxLength?: number | undefined;
+  min?: number | string | undefined;
+  minLength?: number | undefined;
+  multiple?: boolean | undefined;
+  name?: string | undefined;
+  pattern?: string | undefined;
+  placeholder?: string | undefined;
+  readOnly?: boolean | undefined;
+  required?: boolean | undefined;
+  size?: number | undefined;
+  src?: string | undefined;
+  step?: number | string | undefined;
+  type?: HTMLInputType | undefined;
+  value?: number | readonly string[] | string | undefined;
+}
+interface LabelHTMLAttributes<TElement extends HTMLLabelElement> extends HTMLIntrinsicElementProps<TElement> {
+  for?: string | undefined;
+}
+interface LinkHTMLAttributes<TElement extends HTMLLinkElement> extends HTMLIntrinsicElementProps<TElement> {
+  as?: string | undefined;
+  crossOrigin?: CrossOrigin | undefined;
+  fetchPriority?: 'auto' | 'high' | 'low' | undefined;
+  href?: string | undefined;
+  hrefLang?: string | undefined;
+  integrity?: string | undefined;
+  media?: string | undefined;
+  referrerPolicy?: ReferrerPolicy | undefined;
+  rel?: string | undefined;
+  sizes?: string | undefined;
+  type?: string | undefined;
+}
+interface MetaHTMLAttributes<TElement extends HTMLMetaElement> extends HTMLIntrinsicElementProps<TElement> {
+  charset?: string | undefined;
+  content?: string | undefined;
+  httpEquiv?: string | undefined;
+  name?: string | undefined;
+}
+interface OptionHTMLAttributes<TElement extends HTMLOptionElement> extends HTMLIntrinsicElementProps<TElement> {
+  disabled?: boolean | undefined;
+  label?: string | undefined;
+  selected?: boolean | undefined;
+  value?: number | string | undefined;
+}
+interface ScriptHTMLAttributes<TElement extends HTMLScriptElement> extends HTMLIntrinsicElementProps<TElement> {
+  async?: boolean | undefined;
+  crossOrigin?: CrossOrigin | undefined;
+  defer?: boolean | undefined;
+  integrity?: string | undefined;
+  nonce?: string | undefined;
+  referrerPolicy?: ReferrerPolicy | undefined;
+  src?: string | undefined;
+  type?: string | undefined;
+}
+interface SelectHTMLAttributes<TElement extends HTMLSelectElement> extends HTMLIntrinsicElementProps<TElement> {
+  'bind:value'?: BindTarget<number | readonly string[] | string | undefined> | undefined;
+  autoComplete?: string | undefined;
+  disabled?: boolean | undefined;
+  form?: string | undefined;
+  multiple?: boolean | undefined;
+  name?: string | undefined;
+  required?: boolean | undefined;
+  size?: number | undefined;
+  value?: number | readonly string[] | string | undefined;
+}
+interface StyleHTMLAttributes<TElement extends HTMLStyleElement> extends HTMLIntrinsicElementProps<TElement> {
+  media?: string | undefined;
+  nonce?: string | undefined;
+}
+interface TextareaHTMLAttributes<TElement extends HTMLTextAreaElement> extends HTMLIntrinsicElementProps<TElement> {
+  'bind:value'?: BindTarget<number | readonly string[] | string | undefined> | undefined;
+  autoComplete?: string | undefined;
+  cols?: number | undefined;
+  disabled?: boolean | undefined;
+  form?: string | undefined;
+  maxLength?: number | undefined;
+  minLength?: number | undefined;
+  name?: string | undefined;
+  placeholder?: string | undefined;
+  readOnly?: boolean | undefined;
+  required?: boolean | undefined;
+  rows?: number | undefined;
+  value?: number | readonly string[] | string | undefined;
+  wrap?: 'hard' | 'off' | 'soft' | undefined;
+}
+type HTMLElementIntrinsicElements = Omit<{ [TTag in keyof HTMLElementTagNameMap]: HTMLIntrinsicElementProps<HTMLElementTagNameMap[TTag]> }, 'a' | 'button' | 'form' | 'img' | 'input' | 'label' | 'link' | 'meta' | 'option' | 'script' | 'select' | 'style' | 'textarea'> & {
+  a: AnchorHTMLAttributes<HTMLAnchorElement>;
+  button: ButtonHTMLAttributes<HTMLButtonElement>;
+  form: FormHTMLAttributes<HTMLFormElement>;
+  img: ImgHTMLAttributes<HTMLImageElement>;
+  input: InputHTMLAttributes<HTMLInputElement>;
+  label: LabelHTMLAttributes<HTMLLabelElement>;
+  link: LinkHTMLAttributes<HTMLLinkElement>;
+  meta: MetaHTMLAttributes<HTMLMetaElement>;
+  option: OptionHTMLAttributes<HTMLOptionElement>;
+  script: ScriptHTMLAttributes<HTMLScriptElement>;
+  select: SelectHTMLAttributes<HTMLSelectElement>;
+  style: StyleHTMLAttributes<HTMLStyleElement>;
+  textarea: TextareaHTMLAttributes<HTMLTextAreaElement>;
+};
+type SVGElementIntrinsicElements = { [TTag in keyof SVGElementTagNameMap]: SVGIntrinsicElementProps<SVGElementTagNameMap[TTag]> };
+type NamespacedIntrinsicElementProps = {
+  [name: string]: AttributeValue | undefined;
+};
+declare namespace JSX {
+  interface SSRTemplate {
+    __e_ssr_template: true;
+    strings: readonly string[];
+    values: readonly unknown[];
+  }
+  type Type = string | ((props: unknown) => Element);
+  type Childable = Element | Element[];
+  type Element = {
+    type: Type;
+    props: Record<string, unknown>;
+    key?: string | number | symbol | null;
+    isStatic: boolean;
+    metadata?: Metadata;
+  } | SSRTemplate | string | number | undefined | null | boolean | ((() => Element) & {
+    key?: string | number | symbol;
+  });
+  interface Metadata {
+    componentID?: number;
+    fileid?: string;
+  }
+  interface IntrinsicAttributes {
+    key?: string | number | symbol | null | undefined;
+  }
+  type IntrinsicElements = HTMLElementIntrinsicElements & SVGElementIntrinsicElements & {
+    [name: `${string}-${string}`]: HTMLIntrinsicElementProps<HTMLElement>;
+    [name: `${string}:${string}`]: NamespacedIntrinsicElementProps;
+  };
+  interface ElementChildrenAttribute {
+    children?: unknown;
+  }
+}
+//#endregion
+export { JSX as i, DelegatedEvent as n, EventHandler as r, BindTarget as t };
+//# sourceMappingURL=types-WOJV0N2h.d.mts.map

package/vite/mod.d.mts

@@ -0,0 +1,13 @@
+import { PluginOption } from "vite";
+
+//#region vite/options.d.ts
+type EclipsaOutputTarget = 'node' | 'ssg';
+interface EclipsaPluginOptions {
+  output?: EclipsaOutputTarget;
+}
+//#endregion
+//#region vite/mod.d.ts
+declare const eclipsa: (options?: EclipsaPluginOptions) => PluginOption;
+//#endregion
+export { type EclipsaPluginOptions, eclipsa };
+//# sourceMappingURL=mod.d.mts.map