@hedystia/view 2.1.0

package/dist/types.d.mts

@@ -0,0 +1,185 @@
+import { JSX } from "./jsx.mjs";
+
+//#region src/types.d.ts
+/**
+ * Function that returns a value of type T - used for reactive accessors
+ */
+type Accessor<T> = () => T;
+/**
+ * Mutable reactive signal holding a value of type T
+ */
+interface Signal<T> {
+  /** @internal */
+  _value: T;
+  /** @internal */
+  _observers: Computation<any>[] | null;
+  /** @internal */
+  _observerSlots: number[] | null;
+  /** @internal */
+  _comparator?: (prev: T, next: T) => boolean;
+}
+/**
+ * Read-only derived reactive signal computed from other signals
+ */
+interface Computed<T> {
+  /** @internal */
+  _value: T;
+  /** @internal */
+  _fn: () => T;
+  /** @internal */
+  _observers: Computation<any>[] | null;
+  /** @internal */
+  _observerSlots: number[] | null;
+  /** @internal */
+  _sources: Signal<any>[] | null;
+  /** @internal */
+  _sourceSlots: number[] | null;
+  /** @internal */
+  _comparator?: (prev: T, next: T) => boolean;
+  /** @internal */
+  _state: 0 | 1 | 2;
+  /** Call to get the current value */
+  (): T;
+}
+/**
+ * Union type for reading signal values
+ */
+type ReadonlySignal<T> = Signal<T> | Computed<T>;
+/**
+ * Internal computation node in the reactive graph
+ */
+interface Computation<T> {
+  /** @internal */
+  _fn: EffectFunction<T>;
+  /** @internal */
+  _value: T | undefined;
+  /** @internal */
+  _sources: Signal<any>[] | null;
+  /** @internal */
+  _sourceSlots: number[] | null;
+  /** @internal */
+  _observers: Computation<any>[] | null;
+  /** @internal */
+  _observerSlots: number[] | null;
+  /** @internal */
+  _owner: Owner | null;
+  /** @internal */
+  _cleanups: (() => void)[] | null;
+  /** @internal */
+  _context: any | null;
+  /** @internal */
+  _suspense: SuspenseContextType | null;
+  /** @internal */
+  _user: boolean;
+  /** @internal */
+  _pure: boolean;
+  /** @internal */
+  _state: 0 | 1 | 2;
+  /** @internal */
+  _updatedAt: number | null;
+}
+/**
+ * Reactive owner/context node
+ */
+interface Owner {
+  /** @internal */
+  _owned: Computation<any>[] | null;
+  /** @internal */
+  _cleanups: (() => void)[] | null;
+  /** @internal */
+  _owner: Owner | null;
+  /** @internal */
+  _context: any | null;
+}
+/**
+ * Effect function type for computations
+ */
+type EffectFunction<T> = (prev?: T) => T;
+/**
+ * Options for creating a signal
+ */
+interface SignalOptions<T> {
+  equals?: false | ((prev: T, next: T) => boolean);
+  name?: string;
+}
+/**
+ * Component function type
+ */
+type Component<P extends Record<string, any> = {}> = (props: P) => JSX.Element;
+/**
+ * Component that accepts children
+ */
+type ParentComponent<P extends Record<string, any> = {}> = Component<P & {
+  children?: JSX.Children;
+}>;
+/**
+ * Component that requires children
+ */
+type FlowComponent<P extends Record<string, any> = {}, C = JSX.Children> = Component<P & {
+  children: C;
+}>;
+/**
+ * Context object for provider/consumer pattern
+ */
+interface Context<T> {
+  _id: symbol;
+  _defaultValue: T | undefined;
+  Provider: Component<{
+    value: T;
+    children: JSX.Element;
+  }>;
+}
+/**
+ * Suspense context type for error boundaries and suspense
+ */
+interface SuspenseContextType {
+  increment: () => void;
+  decrement: () => void;
+  resolved: boolean;
+}
+/**
+ * Resource object returned by load()
+ */
+interface Resource<T> {
+  (): T | undefined;
+  readonly state: Signal<"unresolved" | "pending" | "ready" | "refreshing" | "errored">;
+  readonly loading: Signal<boolean>;
+  readonly error: Signal<Error | undefined>;
+  readonly data: Signal<T | undefined>;
+  readonly ready: boolean;
+}
+/**
+ * Action object for mutations
+ */
+interface Action<T, A> {
+  (args: A): Promise<T>;
+  run: (args: A) => Promise<T>;
+  readonly loading: Signal<boolean>;
+  readonly error: Signal<Error | undefined>;
+  readonly data: Signal<T | undefined>;
+}
+/**
+ * Style properties type
+ */
+type StyleProps = Record<string, string | number | Accessor<string | number> | undefined>;
+/**
+ * Computed style object
+ */
+type ComputedStyle<T extends StyleProps> = () => T;
+/**
+ * Store value types
+ */
+type StoreValue = string | number | boolean | null | undefined | object | StoreValue[];
+/**
+ * Store node type for nested access
+ */
+type StoreNode<T> = T extends object ? Record<keyof T, StoreNode<T[keyof T]>> : Signal<T>;
+/**
+ * Store object
+ */
+interface Store<T extends Record<string, StoreValue>> {
+  [key: string]: StoreNode<T[string]>;
+}
+//#endregion
+export { Accessor, Action, Component, Computed, ComputedStyle, Context, FlowComponent, Owner, ParentComponent, ReadonlySignal, Resource, Signal, SignalOptions, Store, StoreNode, StoreValue, StyleProps };
+//# sourceMappingURL=types.d.mts.map

package/dist/utils/index.cjs

@@ -0,0 +1,34 @@
+//#region src/utils/index.ts
+/**
+* Internal utilities for @hedystia/view
+*/
+/**
+* Equality comparison function for signals
+*/
+function equalFn(a, b) {
+	return a === b;
+}
+/**
+* Creates a shallow clone of an object
+*/
+function shallowClone(obj) {
+	const target = {};
+	for (const key in obj) if (Object.hasOwn(obj, key)) target[key] = obj[key];
+	return target;
+}
+/**
+* Merges two style objects, with the second taking precedence
+*/
+function mergeStyles(base, override) {
+	const result = shallowClone(base);
+	for (const key in override) if (Object.hasOwn(override, key)) {
+		const value = override[key];
+		if (value !== void 0) result[key] = value;
+	}
+	return result;
+}
+//#endregion
+exports.equalFn = equalFn;
+exports.mergeStyles = mergeStyles;
+
+//# sourceMappingURL=index.cjs.map

package/dist/utils/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":["/**\n * Internal utilities for @hedystia/view\n */\n\n/**\n * Equality comparison function for signals\n */\nexport function equalFn<T>(a: T, b: T): boolean {\n  return a === b;\n}\n\n/**\n * Creates a shallow clone of an object\n */\nexport function shallowClone<T extends object>(obj: T): T {\n  const target = {} as any;\n  for (const key in obj) {\n    if (Object.hasOwn(obj, key)) {\n      target[key] = obj[key];\n    }\n  }\n  return target;\n}\n\n/**\n * Merges two style objects, with the second taking precedence\n */\nexport function mergeStyles(\n  base: Record<string, any>,\n  override: Record<string, any>,\n): Record<string, any> {\n  const result = shallowClone(base);\n  for (const key in override) {\n    if (Object.hasOwn(override, key)) {\n      const value = override[key];\n      if (value !== undefined) {\n        result[key] = value;\n      }\n    }\n  }\n  return result;\n}\n\n/**\n * Checks if a value is a function\n */\nexport function isFunction(value: unknown): value is Function {\n  return typeof value === \"function\";\n}\n\n/**\n * Checks if a value is an object (not null)\n */\nexport function isObject(value: unknown): value is object {\n  return typeof value === \"object\" && value !== null;\n}\n\n/**\n * No-op function\n */\nexport function noop(): void {}\n"],"mappings":";;;;;;;AAOA,SAAgB,QAAW,GAAM,GAAe;AAC9C,QAAO,MAAM;;;;;AAMf,SAAgB,aAA+B,KAAW;CACxD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,OAAO,IAChB,KAAI,OAAO,OAAO,KAAK,IAAI,CACzB,QAAO,OAAO,IAAI;AAGtB,QAAO;;;;;AAMT,SAAgB,YACd,MACA,UACqB;CACrB,MAAM,SAAS,aAAa,KAAK;AACjC,MAAK,MAAM,OAAO,SAChB,KAAI,OAAO,OAAO,UAAU,IAAI,EAAE;EAChC,MAAM,QAAQ,SAAS;AACvB,MAAI,UAAU,KAAA,EACZ,QAAO,OAAO;;AAIpB,QAAO"}

package/dist/utils/index.mjs

@@ -0,0 +1,33 @@
+//#region src/utils/index.ts
+/**
+* Internal utilities for @hedystia/view
+*/
+/**
+* Equality comparison function for signals
+*/
+function equalFn(a, b) {
+	return a === b;
+}
+/**
+* Creates a shallow clone of an object
+*/
+function shallowClone(obj) {
+	const target = {};
+	for (const key in obj) if (Object.hasOwn(obj, key)) target[key] = obj[key];
+	return target;
+}
+/**
+* Merges two style objects, with the second taking precedence
+*/
+function mergeStyles(base, override) {
+	const result = shallowClone(base);
+	for (const key in override) if (Object.hasOwn(override, key)) {
+		const value = override[key];
+		if (value !== void 0) result[key] = value;
+	}
+	return result;
+}
+//#endregion
+export { equalFn, mergeStyles };
+
+//# sourceMappingURL=index.mjs.map

package/dist/utils/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":["/**\n * Internal utilities for @hedystia/view\n */\n\n/**\n * Equality comparison function for signals\n */\nexport function equalFn<T>(a: T, b: T): boolean {\n  return a === b;\n}\n\n/**\n * Creates a shallow clone of an object\n */\nexport function shallowClone<T extends object>(obj: T): T {\n  const target = {} as any;\n  for (const key in obj) {\n    if (Object.hasOwn(obj, key)) {\n      target[key] = obj[key];\n    }\n  }\n  return target;\n}\n\n/**\n * Merges two style objects, with the second taking precedence\n */\nexport function mergeStyles(\n  base: Record<string, any>,\n  override: Record<string, any>,\n): Record<string, any> {\n  const result = shallowClone(base);\n  for (const key in override) {\n    if (Object.hasOwn(override, key)) {\n      const value = override[key];\n      if (value !== undefined) {\n        result[key] = value;\n      }\n    }\n  }\n  return result;\n}\n\n/**\n * Checks if a value is a function\n */\nexport function isFunction(value: unknown): value is Function {\n  return typeof value === \"function\";\n}\n\n/**\n * Checks if a value is an object (not null)\n */\nexport function isObject(value: unknown): value is object {\n  return typeof value === \"object\" && value !== null;\n}\n\n/**\n * No-op function\n */\nexport function noop(): void {}\n"],"mappings":";;;;;;;AAOA,SAAgB,QAAW,GAAM,GAAe;AAC9C,QAAO,MAAM;;;;;AAMf,SAAgB,aAA+B,KAAW;CACxD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,OAAO,IAChB,KAAI,OAAO,OAAO,KAAK,IAAI,CACzB,QAAO,OAAO,IAAI;AAGtB,QAAO;;;;;AAMT,SAAgB,YACd,MACA,UACqB;CACrB,MAAM,SAAS,aAAa,KAAK;AACjC,MAAK,MAAM,OAAO,SAChB,KAAI,OAAO,OAAO,UAAU,IAAI,EAAE;EAChC,MAAM,QAAQ,SAAS;AACvB,MAAI,UAAU,KAAA,EACZ,QAAO,OAAO;;AAIpB,QAAO"}

package/dist/watch/watcher.cjs

@@ -0,0 +1,71 @@
+const require_signal = require("../signal/signal.cjs");
+//#region src/watch/watcher.ts
+/**
+* Watchers and reactive effects for @hedystia/view
+*
+* Provides effect tracking and reactive subscriptions.
+*/
+/**
+* Create a reactive effect that runs when dependencies change
+*/
+function on(track, run) {
+	let cleanup;
+	let prevValue;
+	let hasRun = false;
+	let stopped = false;
+	const computation = {
+		_fn: () => {
+			if (stopped) return;
+			const value = track();
+			require_signal.untrack(() => {
+				if (cleanup) {
+					cleanup();
+					cleanup = void 0;
+				}
+				const result = run(value, hasRun ? prevValue : value);
+				if (typeof result === "function") cleanup = result;
+			});
+			prevValue = value;
+			hasRun = true;
+		},
+		_value: void 0,
+		_sources: null,
+		_sourceSlots: null,
+		_observers: null,
+		_observerSlots: null,
+		_owner: require_signal.Owner,
+		_cleanups: null,
+		_context: null,
+		_suspense: null,
+		_user: true,
+		_pure: false,
+		_state: 0,
+		_updatedAt: null
+	};
+	require_signal.runComputation(computation);
+	return () => {
+		stopped = true;
+		require_signal.cleanupSources(computation);
+		if (cleanup) {
+			cleanup();
+			cleanup = void 0;
+		}
+	};
+}
+/**
+* Create a one-time effect that runs once and disposes
+*/
+function once(track, run) {
+	let hasRun = false;
+	return on(track, (value) => {
+		if (!hasRun) {
+			hasRun = true;
+			run(value);
+		}
+	});
+}
+//#endregion
+exports.on = on;
+exports.once = once;
+
+//# sourceMappingURL=watcher.cjs.map

package/dist/watch/watcher.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.cjs","names":["Owner"],"sources":["../../src/watch/watcher.ts"],"sourcesContent":["/**\n * Watchers and reactive effects for @hedystia/view\n *\n * Provides effect tracking and reactive subscriptions.\n */\n\nimport { cleanupSources, Owner, runComputation, untrack } from \"../signal\";\nimport type { Computation } from \"../types\";\n\n/**\n * Create a reactive effect that runs when dependencies change\n */\nexport function on<T>(track: () => T, run: (value: T, prev: T) => any | (() => void)): () => void {\n  let cleanup: (() => void) | undefined;\n  let prevValue: T | undefined;\n  let hasRun = false;\n  let stopped = false;\n\n  const computation: Computation<any> = {\n    _fn: () => {\n      if (stopped) {\n        return undefined;\n      }\n\n      // Track dependencies from the track function\n      const value = track();\n\n      // Run callback untracked so reads inside run() don't become dependencies\n      untrack(() => {\n        if (cleanup) {\n          cleanup();\n          cleanup = undefined;\n        }\n\n        const result = run(value, hasRun ? prevValue! : value);\n        if (typeof result === \"function\") {\n          cleanup = result;\n        }\n      });\n\n      prevValue = value;\n      hasRun = true;\n      return undefined;\n    },\n    _value: undefined,\n    _sources: null,\n    _sourceSlots: null,\n    _observers: null,\n    _observerSlots: null,\n    _owner: Owner,\n    _cleanups: null,\n    _context: null,\n    _suspense: null,\n    _user: true,\n    _pure: false,\n    _state: 0,\n    _updatedAt: null,\n  };\n\n  // Run initial execution with proper Listener tracking\n  runComputation(computation);\n\n  return () => {\n    stopped = true;\n    cleanupSources(computation);\n    if (cleanup) {\n      cleanup();\n      cleanup = undefined;\n    }\n  };\n}\n\n/**\n * Create a one-time effect that runs once and disposes\n */\nexport function once<T>(track: () => T, run: (value: T) => void): () => void {\n  let hasRun = false;\n  return on(track, (value) => {\n    if (!hasRun) {\n      hasRun = true;\n      run(value);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;AAYA,SAAgB,GAAM,OAAgB,KAA4D;CAChG,IAAI;CACJ,IAAI;CACJ,IAAI,SAAS;CACb,IAAI,UAAU;CAEd,MAAM,cAAgC;EACpC,WAAW;AACT,OAAI,QACF;GAIF,MAAM,QAAQ,OAAO;AAGrB,kBAAA,cAAc;AACZ,QAAI,SAAS;AACX,cAAS;AACT,eAAU,KAAA;;IAGZ,MAAM,SAAS,IAAI,OAAO,SAAS,YAAa,MAAM;AACtD,QAAI,OAAO,WAAW,WACpB,WAAU;KAEZ;AAEF,eAAY;AACZ,YAAS;;EAGX,QAAQ,KAAA;EACR,UAAU;EACV,cAAc;EACd,YAAY;EACZ,gBAAgB;EAChB,QAAQA,eAAAA;EACR,WAAW;EACX,UAAU;EACV,WAAW;EACX,OAAO;EACP,OAAO;EACP,QAAQ;EACR,YAAY;EACb;AAGD,gBAAA,eAAe,YAAY;AAE3B,cAAa;AACX,YAAU;AACV,iBAAA,eAAe,YAAY;AAC3B,MAAI,SAAS;AACX,YAAS;AACT,aAAU,KAAA;;;;;;;AAQhB,SAAgB,KAAQ,OAAgB,KAAqC;CAC3E,IAAI,SAAS;AACb,QAAO,GAAG,QAAQ,UAAU;AAC1B,MAAI,CAAC,QAAQ;AACX,YAAS;AACT,OAAI,MAAM;;GAEZ"}

package/dist/watch/watcher.d.cts

@@ -0,0 +1,17 @@
+//#region src/watch/watcher.d.ts
+/**
+ * Watchers and reactive effects for @hedystia/view
+ *
+ * Provides effect tracking and reactive subscriptions.
+ */
+/**
+ * Create a reactive effect that runs when dependencies change
+ */
+declare function on<T>(track: () => T, run: (value: T, prev: T) => any | (() => void)): () => void;
+/**
+ * Create a one-time effect that runs once and disposes
+ */
+declare function once<T>(track: () => T, run: (value: T) => void): () => void;
+//#endregion
+export { on, once };
+//# sourceMappingURL=watcher.d.cts.map

package/dist/watch/watcher.d.mts

@@ -0,0 +1,17 @@
+//#region src/watch/watcher.d.ts
+/**
+ * Watchers and reactive effects for @hedystia/view
+ *
+ * Provides effect tracking and reactive subscriptions.
+ */
+/**
+ * Create a reactive effect that runs when dependencies change
+ */
+declare function on<T>(track: () => T, run: (value: T, prev: T) => any | (() => void)): () => void;
+/**
+ * Create a one-time effect that runs once and disposes
+ */
+declare function once<T>(track: () => T, run: (value: T) => void): () => void;
+//#endregion
+export { on, once };
+//# sourceMappingURL=watcher.d.mts.map

package/dist/watch/watcher.mjs

@@ -0,0 +1,70 @@
+import { Owner, cleanupSources, runComputation, untrack } from "../signal/signal.mjs";
+//#region src/watch/watcher.ts
+/**
+* Watchers and reactive effects for @hedystia/view
+*
+* Provides effect tracking and reactive subscriptions.
+*/
+/**
+* Create a reactive effect that runs when dependencies change
+*/
+function on(track, run) {
+	let cleanup;
+	let prevValue;
+	let hasRun = false;
+	let stopped = false;
+	const computation = {
+		_fn: () => {
+			if (stopped) return;
+			const value = track();
+			untrack(() => {
+				if (cleanup) {
+					cleanup();
+					cleanup = void 0;
+				}
+				const result = run(value, hasRun ? prevValue : value);
+				if (typeof result === "function") cleanup = result;
+			});
+			prevValue = value;
+			hasRun = true;
+		},
+		_value: void 0,
+		_sources: null,
+		_sourceSlots: null,
+		_observers: null,
+		_observerSlots: null,
+		_owner: Owner,
+		_cleanups: null,
+		_context: null,
+		_suspense: null,
+		_user: true,
+		_pure: false,
+		_state: 0,
+		_updatedAt: null
+	};
+	runComputation(computation);
+	return () => {
+		stopped = true;
+		cleanupSources(computation);
+		if (cleanup) {
+			cleanup();
+			cleanup = void 0;
+		}
+	};
+}
+/**
+* Create a one-time effect that runs once and disposes
+*/
+function once(track, run) {
+	let hasRun = false;
+	return on(track, (value) => {
+		if (!hasRun) {
+			hasRun = true;
+			run(value);
+		}
+	});
+}
+//#endregion
+export { on, once };
+
+//# sourceMappingURL=watcher.mjs.map

package/dist/watch/watcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.mjs","names":[],"sources":["../../src/watch/watcher.ts"],"sourcesContent":["/**\n * Watchers and reactive effects for @hedystia/view\n *\n * Provides effect tracking and reactive subscriptions.\n */\n\nimport { cleanupSources, Owner, runComputation, untrack } from \"../signal\";\nimport type { Computation } from \"../types\";\n\n/**\n * Create a reactive effect that runs when dependencies change\n */\nexport function on<T>(track: () => T, run: (value: T, prev: T) => any | (() => void)): () => void {\n  let cleanup: (() => void) | undefined;\n  let prevValue: T | undefined;\n  let hasRun = false;\n  let stopped = false;\n\n  const computation: Computation<any> = {\n    _fn: () => {\n      if (stopped) {\n        return undefined;\n      }\n\n      // Track dependencies from the track function\n      const value = track();\n\n      // Run callback untracked so reads inside run() don't become dependencies\n      untrack(() => {\n        if (cleanup) {\n          cleanup();\n          cleanup = undefined;\n        }\n\n        const result = run(value, hasRun ? prevValue! : value);\n        if (typeof result === \"function\") {\n          cleanup = result;\n        }\n      });\n\n      prevValue = value;\n      hasRun = true;\n      return undefined;\n    },\n    _value: undefined,\n    _sources: null,\n    _sourceSlots: null,\n    _observers: null,\n    _observerSlots: null,\n    _owner: Owner,\n    _cleanups: null,\n    _context: null,\n    _suspense: null,\n    _user: true,\n    _pure: false,\n    _state: 0,\n    _updatedAt: null,\n  };\n\n  // Run initial execution with proper Listener tracking\n  runComputation(computation);\n\n  return () => {\n    stopped = true;\n    cleanupSources(computation);\n    if (cleanup) {\n      cleanup();\n      cleanup = undefined;\n    }\n  };\n}\n\n/**\n * Create a one-time effect that runs once and disposes\n */\nexport function once<T>(track: () => T, run: (value: T) => void): () => void {\n  let hasRun = false;\n  return on(track, (value) => {\n    if (!hasRun) {\n      hasRun = true;\n      run(value);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;AAYA,SAAgB,GAAM,OAAgB,KAA4D;CAChG,IAAI;CACJ,IAAI;CACJ,IAAI,SAAS;CACb,IAAI,UAAU;CAEd,MAAM,cAAgC;EACpC,WAAW;AACT,OAAI,QACF;GAIF,MAAM,QAAQ,OAAO;AAGrB,iBAAc;AACZ,QAAI,SAAS;AACX,cAAS;AACT,eAAU,KAAA;;IAGZ,MAAM,SAAS,IAAI,OAAO,SAAS,YAAa,MAAM;AACtD,QAAI,OAAO,WAAW,WACpB,WAAU;KAEZ;AAEF,eAAY;AACZ,YAAS;;EAGX,QAAQ,KAAA;EACR,UAAU;EACV,cAAc;EACd,YAAY;EACZ,gBAAgB;EAChB,QAAQ;EACR,WAAW;EACX,UAAU;EACV,WAAW;EACX,OAAO;EACP,OAAO;EACP,QAAQ;EACR,YAAY;EACb;AAGD,gBAAe,YAAY;AAE3B,cAAa;AACX,YAAU;AACV,iBAAe,YAAY;AAC3B,MAAI,SAAS;AACX,YAAS;AACT,aAAU,KAAA;;;;;;;AAQhB,SAAgB,KAAQ,OAAgB,KAAqC;CAC3E,IAAI,SAAS;AACb,QAAO,GAAG,QAAQ,UAAU;AAC1B,MAAI,CAAC,QAAQ;AACX,YAAS;AACT,OAAI,MAAM;;GAEZ"}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@hedystia/view",
+  "version": "2.1.0",
+  "description": "Reactive UI engine — fine-grained signals, no Virtual DOM, real DOM nodes",
+  "type": "commonjs",
+  "types": "./dist/index.d.cts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.cts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx-runtime.d.cts",
+      "import": "./dist/jsx-runtime.mjs",
+      "require": "./dist/jsx-runtime.cjs"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx-dev-runtime.d.cts",
+      "import": "./dist/jsx-dev-runtime.mjs",
+      "require": "./dist/jsx-dev-runtime.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsdown --config-loader unrun",
+    "release:pkg": "bun publish --provenance --access public",
+    "dev": "tsdown --watch"
+  },
+  "peerDependencies": {
+    "typescript": ">= 6.0.0"
+  }
+}