@akashjs/runtime 0.2.6 → 0.2.7

package/dist/tweened.d.cts

@@ -0,0 +1,59 @@
+/**
+ * Tweened values — smooth interpolation between states.
+ *
+ * Unlike signals that update instantly, tweened values animate
+ * smoothly from old to new over a duration.
+ *
+ * ```ts
+ * const progress = tweened(0, { duration: 400 });
+ * progress.set(100); // smoothly animates 0 → 100 over 400ms
+ * progress();        // intermediate values during animation
+ *
+ * const color = tweened('#ff0000', { duration: 300, interpolate: lerpColor });
+ * ```
+ */
+type Interpolator<T> = (from: T, to: T, t: number) => T;
+type EasingFn = (t: number) => number;
+interface TweenedOptions<T> {
+    /** Duration in ms (default: 400) */
+    duration?: number;
+    /** Easing function (default: cubicOut) */
+    easing?: EasingFn;
+    /** Custom interpolation function */
+    interpolate?: Interpolator<T>;
+    /** Delay before animation starts */
+    delay?: number;
+}
+interface TweenedSignal<T> {
+    /** Read current (animated) value */
+    (): T;
+    /** Set new target — animates from current to new */
+    set(value: T, opts?: Partial<TweenedOptions<T>>): Promise<void>;
+    /** Set immediately without animation */
+    setImmediate(value: T): void;
+    /** Current target value */
+    target: () => T;
+}
+declare const easings: {
+    readonly linear: (t: number) => number;
+    readonly cubicIn: (t: number) => number;
+    readonly cubicOut: (t: number) => number;
+    readonly cubicInOut: (t: number) => number;
+    readonly quadIn: (t: number) => number;
+    readonly quadOut: (t: number) => number;
+    readonly quintOut: (t: number) => number;
+    readonly bounceOut: (t: number) => number;
+    readonly elasticOut: (t: number) => number;
+};
+/**
+ * Create a tweened signal that animates between values.
+ *
+ * ```ts
+ * const count = tweened(0, { duration: 300, easing: easings.cubicOut });
+ * count.set(100); // smoothly goes 0 → 100
+ * count();        // current interpolated value
+ * ```
+ */
+declare function tweened<T>(initialValue: T, options?: TweenedOptions<T>): TweenedSignal<T>;
+
+export { type EasingFn, type Interpolator, type TweenedOptions, type TweenedSignal, easings, tweened };

package/dist/tweened.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Tweened values — smooth interpolation between states.
+ *
+ * Unlike signals that update instantly, tweened values animate
+ * smoothly from old to new over a duration.
+ *
+ * ```ts
+ * const progress = tweened(0, { duration: 400 });
+ * progress.set(100); // smoothly animates 0 → 100 over 400ms
+ * progress();        // intermediate values during animation
+ *
+ * const color = tweened('#ff0000', { duration: 300, interpolate: lerpColor });
+ * ```
+ */
+type Interpolator<T> = (from: T, to: T, t: number) => T;
+type EasingFn = (t: number) => number;
+interface TweenedOptions<T> {
+    /** Duration in ms (default: 400) */
+    duration?: number;
+    /** Easing function (default: cubicOut) */
+    easing?: EasingFn;
+    /** Custom interpolation function */
+    interpolate?: Interpolator<T>;
+    /** Delay before animation starts */
+    delay?: number;
+}
+interface TweenedSignal<T> {
+    /** Read current (animated) value */
+    (): T;
+    /** Set new target — animates from current to new */
+    set(value: T, opts?: Partial<TweenedOptions<T>>): Promise<void>;
+    /** Set immediately without animation */
+    setImmediate(value: T): void;
+    /** Current target value */
+    target: () => T;
+}
+declare const easings: {
+    readonly linear: (t: number) => number;
+    readonly cubicIn: (t: number) => number;
+    readonly cubicOut: (t: number) => number;
+    readonly cubicInOut: (t: number) => number;
+    readonly quadIn: (t: number) => number;
+    readonly quadOut: (t: number) => number;
+    readonly quintOut: (t: number) => number;
+    readonly bounceOut: (t: number) => number;
+    readonly elasticOut: (t: number) => number;
+};
+/**
+ * Create a tweened signal that animates between values.
+ *
+ * ```ts
+ * const count = tweened(0, { duration: 300, easing: easings.cubicOut });
+ * count.set(100); // smoothly goes 0 → 100
+ * count();        // current interpolated value
+ * ```
+ */
+declare function tweened<T>(initialValue: T, options?: TweenedOptions<T>): TweenedSignal<T>;
+
+export { type EasingFn, type Interpolator, type TweenedOptions, type TweenedSignal, easings, tweened };

package/dist/tweened.js

@@ -0,0 +1,2 @@
+export{a as easings,b as tweened}from'./chunk-T2RVAQEU.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=tweened.js.map
+//# sourceMappingURL=tweened.js.map

package/dist/tweened.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"tweened.js"}

package/dist/types-DjZCk1xT.d.cts

@@ -0,0 +1,4 @@
+/** Represents any renderable node in AkashJS */
+type AkashNode = Node | string | number | boolean | null | undefined | AkashNode[];
+
+export type { AkashNode as A };

package/dist/types-DjZCk1xT.d.ts

@@ -0,0 +1,4 @@
+/** Represents any renderable node in AkashJS */
+type AkashNode = Node | string | number | boolean | null | undefined | AkashNode[];
+
+export type { AkashNode as A };

package/dist/view-transition.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkDP7G45QM_cjs=require('./chunk-DP7G45QM.cjs');Object.defineProperty(exports,"assignTransitionName",{enumerable:true,get:function(){return chunkDP7G45QM_cjs.d}});Object.defineProperty(exports,"startViewTransition",{enumerable:true,get:function(){return chunkDP7G45QM_cjs.b}});Object.defineProperty(exports,"supportsViewTransitions",{enumerable:true,get:function(){return chunkDP7G45QM_cjs.a}});Object.defineProperty(exports,"viewTransitionCSS",{enumerable:true,get:function(){return chunkDP7G45QM_cjs.c}});//# sourceMappingURL=view-transition.cjs.map
+//# sourceMappingURL=view-transition.cjs.map

package/dist/view-transition.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"view-transition.cjs"}

package/dist/view-transition.d.cts

@@ -0,0 +1,80 @@
+/**
+ * View Transitions API integration.
+ *
+ * Wraps the browser's native View Transitions API for smooth
+ * page transitions. Falls back gracefully when not supported.
+ *
+ * ```ts
+ * // With router
+ * const router = createRouter(routes);
+ * enableViewTransitions(router);
+ *
+ * // Manual
+ * await startViewTransition(() => {
+ *   updateDOM();
+ * });
+ * ```
+ */
+interface ViewTransitionOptions {
+    /** CSS class to add to the document during transition */
+    className?: string;
+    /** Callback before the transition starts */
+    onBefore?: () => void;
+    /** Callback after the transition completes */
+    onAfter?: () => void;
+    /** Fallback behavior when API is not supported (default: 'instant') */
+    fallback?: 'instant' | 'fade' | 'none';
+}
+interface ViewTransition {
+    /** Promise that resolves when transition animation is complete */
+    finished: Promise<void>;
+    /** Promise that resolves when the DOM update callback has run */
+    updateCallbackDone: Promise<void>;
+    /** Promise that resolves when the transition is ready to animate */
+    ready: Promise<void>;
+    /** Skip the transition animation */
+    skipTransition(): void;
+}
+/**
+ * Check if the View Transitions API is supported.
+ */
+declare function supportsViewTransitions(): boolean;
+/**
+ * Start a view transition with the native API, falling back
+ * to instant DOM update when not supported.
+ *
+ * ```ts
+ * await startViewTransition(() => {
+ *   container.innerHTML = newContent;
+ * });
+ * ```
+ */
+declare function startViewTransition(updateCallback: () => void | Promise<void>, options?: ViewTransitionOptions): ViewTransition;
+/**
+ * Generate CSS for customizing view transitions.
+ *
+ * ```ts
+ * const css = viewTransitionCSS({
+ *   duration: '0.3s',
+ *   oldAnimation: 'slide-out-left',
+ *   newAnimation: 'slide-in-right',
+ * });
+ * ```
+ */
+declare function viewTransitionCSS(config?: {
+    duration?: string;
+    easing?: string;
+    oldAnimation?: string;
+    newAnimation?: string;
+}): string;
+/**
+ * Assign a view-transition-name to an element for per-element transitions.
+ *
+ * ```ts
+ * assignTransitionName(headerEl, 'page-header');
+ * assignTransitionName(contentEl, 'page-content');
+ * ```
+ */
+declare function assignTransitionName(el: HTMLElement, name: string): void;
+
+export { type ViewTransition, type ViewTransitionOptions, assignTransitionName, startViewTransition, supportsViewTransitions, viewTransitionCSS };

package/dist/view-transition.d.ts

@@ -0,0 +1,80 @@
+/**
+ * View Transitions API integration.
+ *
+ * Wraps the browser's native View Transitions API for smooth
+ * page transitions. Falls back gracefully when not supported.
+ *
+ * ```ts
+ * // With router
+ * const router = createRouter(routes);
+ * enableViewTransitions(router);
+ *
+ * // Manual
+ * await startViewTransition(() => {
+ *   updateDOM();
+ * });
+ * ```
+ */
+interface ViewTransitionOptions {
+    /** CSS class to add to the document during transition */
+    className?: string;
+    /** Callback before the transition starts */
+    onBefore?: () => void;
+    /** Callback after the transition completes */
+    onAfter?: () => void;
+    /** Fallback behavior when API is not supported (default: 'instant') */
+    fallback?: 'instant' | 'fade' | 'none';
+}
+interface ViewTransition {
+    /** Promise that resolves when transition animation is complete */
+    finished: Promise<void>;
+    /** Promise that resolves when the DOM update callback has run */
+    updateCallbackDone: Promise<void>;
+    /** Promise that resolves when the transition is ready to animate */
+    ready: Promise<void>;
+    /** Skip the transition animation */
+    skipTransition(): void;
+}
+/**
+ * Check if the View Transitions API is supported.
+ */
+declare function supportsViewTransitions(): boolean;
+/**
+ * Start a view transition with the native API, falling back
+ * to instant DOM update when not supported.
+ *
+ * ```ts
+ * await startViewTransition(() => {
+ *   container.innerHTML = newContent;
+ * });
+ * ```
+ */
+declare function startViewTransition(updateCallback: () => void | Promise<void>, options?: ViewTransitionOptions): ViewTransition;
+/**
+ * Generate CSS for customizing view transitions.
+ *
+ * ```ts
+ * const css = viewTransitionCSS({
+ *   duration: '0.3s',
+ *   oldAnimation: 'slide-out-left',
+ *   newAnimation: 'slide-in-right',
+ * });
+ * ```
+ */
+declare function viewTransitionCSS(config?: {
+    duration?: string;
+    easing?: string;
+    oldAnimation?: string;
+    newAnimation?: string;
+}): string;
+/**
+ * Assign a view-transition-name to an element for per-element transitions.
+ *
+ * ```ts
+ * assignTransitionName(headerEl, 'page-header');
+ * assignTransitionName(contentEl, 'page-content');
+ * ```
+ */
+declare function assignTransitionName(el: HTMLElement, name: string): void;
+
+export { type ViewTransition, type ViewTransitionOptions, assignTransitionName, startViewTransition, supportsViewTransitions, viewTransitionCSS };

package/dist/view-transition.js

@@ -0,0 +1,2 @@
+export{d as assignTransitionName,b as startViewTransition,a as supportsViewTransitions,c as viewTransitionCSS}from'./chunk-WLSXJU2N.js';//# sourceMappingURL=view-transition.js.map
+//# sourceMappingURL=view-transition.js.map

package/dist/view-transition.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"view-transition.js"}

package/dist/virtual-list.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkDHFVVFZF_cjs=require('./chunk-DHFVVFZF.cjs');require('./chunk-XWVNLE2W.cjs'),require('./chunk-IQGSDFBI.cjs'),require('./chunk-PPNEAFKE.cjs'),require('./chunk-WOZWFMOK.cjs'),require('./chunk-XPLIEN2G.cjs');Object.defineProperty(exports,"VirtualFor",{enumerable:true,get:function(){return chunkDHFVVFZF_cjs.c}});Object.defineProperty(exports,"calculateRange",{enumerable:true,get:function(){return chunkDHFVVFZF_cjs.a}});Object.defineProperty(exports,"useVirtualList",{enumerable:true,get:function(){return chunkDHFVVFZF_cjs.b}});//# sourceMappingURL=virtual-list.cjs.map
+//# sourceMappingURL=virtual-list.cjs.map

package/dist/virtual-list.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"virtual-list.cjs"}

package/dist/virtual-list.d.cts

@@ -0,0 +1,67 @@
+import { C as Component } from './component-CxlupKuc.cjs';
+import { A as AkashNode } from './types-DjZCk1xT.cjs';
+import { R as ReadonlySignal } from './signals-DionyGGY.cjs';
+
+interface VirtualForProps<T> {
+    /** Array of items */
+    each: T[];
+    /** Key function for reconciliation */
+    key: (item: T) => unknown;
+    /** Fixed height per item in pixels */
+    itemHeight: number;
+    /** Container height in pixels (default: auto-detect from parent) */
+    containerHeight?: number;
+    /** Number of extra items to render above/below viewport */
+    overscan?: number;
+    /** Render function for each item */
+    children: (item: T, index: number) => AkashNode;
+}
+interface VirtualRange {
+    /** First visible index */
+    start: number;
+    /** Last visible index (exclusive) */
+    end: number;
+    /** Total content height in pixels */
+    totalHeight: number;
+    /** Offset of the first rendered item */
+    offsetTop: number;
+}
+/**
+ * Calculate the visible range given scroll position and dimensions.
+ */
+declare function calculateRange(scrollTopOrOpts: number | {
+    scrollTop: number;
+    containerHeight: number;
+    itemHeight: number;
+    totalItems: number;
+    overscan?: number;
+}, containerHeight?: number, itemHeight?: number, totalItems?: number, overscan?: number): VirtualRange;
+/**
+ * Low-level virtual list composable for custom implementations.
+ *
+ * ```ts
+ * const { containerRef, range, visibleItems } = useVirtualList({
+ *   items: () => allItems(),
+ *   itemHeight: 40,
+ *   overscan: 5,
+ * });
+ * ```
+ */
+declare function useVirtualList<T>(options: {
+    items: () => T[];
+    itemHeight: number;
+    containerHeight?: number;
+    overscan?: number;
+}): {
+    range: ReadonlySignal<VirtualRange>;
+    visibleItems: ReadonlySignal<{
+        item: T;
+        index: number;
+    }[]>;
+    onScroll: (e: Event) => void;
+    setContainerHeight: (height: number) => void;
+    scrollTop: ReadonlySignal<number>;
+};
+declare const VirtualFor: Component<VirtualForProps<any>>;
+
+export { VirtualFor, type VirtualForProps, type VirtualRange, calculateRange, useVirtualList };

package/dist/virtual-list.d.ts

@@ -0,0 +1,67 @@
+import { C as Component } from './component-CPVtkASo.js';
+import { A as AkashNode } from './types-DjZCk1xT.js';
+import { R as ReadonlySignal } from './signals-DionyGGY.js';
+
+interface VirtualForProps<T> {
+    /** Array of items */
+    each: T[];
+    /** Key function for reconciliation */
+    key: (item: T) => unknown;
+    /** Fixed height per item in pixels */
+    itemHeight: number;
+    /** Container height in pixels (default: auto-detect from parent) */
+    containerHeight?: number;
+    /** Number of extra items to render above/below viewport */
+    overscan?: number;
+    /** Render function for each item */
+    children: (item: T, index: number) => AkashNode;
+}
+interface VirtualRange {
+    /** First visible index */
+    start: number;
+    /** Last visible index (exclusive) */
+    end: number;
+    /** Total content height in pixels */
+    totalHeight: number;
+    /** Offset of the first rendered item */
+    offsetTop: number;
+}
+/**
+ * Calculate the visible range given scroll position and dimensions.
+ */
+declare function calculateRange(scrollTopOrOpts: number | {
+    scrollTop: number;
+    containerHeight: number;
+    itemHeight: number;
+    totalItems: number;
+    overscan?: number;
+}, containerHeight?: number, itemHeight?: number, totalItems?: number, overscan?: number): VirtualRange;
+/**
+ * Low-level virtual list composable for custom implementations.
+ *
+ * ```ts
+ * const { containerRef, range, visibleItems } = useVirtualList({
+ *   items: () => allItems(),
+ *   itemHeight: 40,
+ *   overscan: 5,
+ * });
+ * ```
+ */
+declare function useVirtualList<T>(options: {
+    items: () => T[];
+    itemHeight: number;
+    containerHeight?: number;
+    overscan?: number;
+}): {
+    range: ReadonlySignal<VirtualRange>;
+    visibleItems: ReadonlySignal<{
+        item: T;
+        index: number;
+    }[]>;
+    onScroll: (e: Event) => void;
+    setContainerHeight: (height: number) => void;
+    scrollTop: ReadonlySignal<number>;
+};
+declare const VirtualFor: Component<VirtualForProps<any>>;
+
+export { VirtualFor, type VirtualForProps, type VirtualRange, calculateRange, useVirtualList };

package/dist/virtual-list.js

@@ -0,0 +1,2 @@
+export{c as VirtualFor,a as calculateRange,b as useVirtualList}from'./chunk-Q6S7SUOM.js';import'./chunk-KE7BJTCD.js';import'./chunk-VUMMC2P5.js';import'./chunk-AOFLE33X.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=virtual-list.js.map
+//# sourceMappingURL=virtual-list.js.map

package/dist/virtual-list.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"virtual-list.js"}

package/dist/watch.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkV2JDKH3W_cjs=require('./chunk-V2JDKH3W.cjs');require('./chunk-WOZWFMOK.cjs'),require('./chunk-XPLIEN2G.cjs');Object.defineProperty(exports,"watch",{enumerable:true,get:function(){return chunkV2JDKH3W_cjs.a}});Object.defineProperty(exports,"watchDebounced",{enumerable:true,get:function(){return chunkV2JDKH3W_cjs.c}});Object.defineProperty(exports,"watchOnce",{enumerable:true,get:function(){return chunkV2JDKH3W_cjs.b}});//# sourceMappingURL=watch.cjs.map
+//# sourceMappingURL=watch.cjs.map

package/dist/watch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"watch.cjs"}

package/dist/watch.d.cts

@@ -0,0 +1,70 @@
+/**
+ * watch() — react to signal changes with old/new values.
+ *
+ * Unlike effect() which just re-runs, watch() gives you the previous
+ * and current value so you can react to *what changed*.
+ *
+ * ```ts
+ * const count = signal(0);
+ * watch(count, (newVal, oldVal) => {
+ *   console.log(`Changed from ${oldVal} to ${newVal}`);
+ * });
+ *
+ * // With options:
+ * watch(count, callback, { immediate: true, once: true });
+ *
+ * // Multiple sources:
+ * watch([count, name], ([newCount, newName], [oldCount, oldName]) => { ... });
+ * ```
+ */
+interface WatchOptions {
+    /** Run callback immediately with current value (default: false) */
+    immediate?: boolean;
+    /** Only fire once, then auto-dispose (default: false) */
+    once?: boolean;
+    /** Debounce callback in ms */
+    debounce?: number;
+    /** Deep comparison for objects (default: false) */
+    deep?: boolean;
+}
+type WatchSource<T> = () => T;
+type WatchCallback<T> = (newValue: T, oldValue: T | undefined) => void;
+type WatchArrayCallback<T extends unknown[]> = (newValues: T, oldValues: (T[number] | undefined)[]) => void;
+/**
+ * Watch a reactive source and call back with old + new values.
+ *
+ * ```ts
+ * const dispose = watch(count, (newVal, oldVal) => {
+ *   analytics.track('count_changed', { from: oldVal, to: newVal });
+ * });
+ * ```
+ */
+declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void;
+/**
+ * Watch multiple sources.
+ */
+declare function watch<T extends unknown[]>(sources: {
+    [K in keyof T]: WatchSource<T[K]>;
+}, callback: WatchArrayCallback<T>, options?: WatchOptions): () => void;
+/**
+ * Watch a source once, then auto-dispose.
+ *
+ * ```ts
+ * watchOnce(isReady, (ready) => {
+ *   if (ready) initApp();
+ * });
+ * ```
+ */
+declare function watchOnce<T>(source: WatchSource<T>, callback: WatchCallback<T>): () => void;
+/**
+ * Watch with built-in debounce.
+ *
+ * ```ts
+ * watchDebounced(searchInput, (query) => {
+ *   fetchResults(query);
+ * }, 300);
+ * ```
+ */
+declare function watchDebounced<T>(source: WatchSource<T>, callback: WatchCallback<T>, ms: number): () => void;
+
+export { type WatchArrayCallback, type WatchCallback, type WatchOptions, type WatchSource, watch, watchDebounced, watchOnce };

package/dist/watch.d.ts

@@ -0,0 +1,70 @@
+/**
+ * watch() — react to signal changes with old/new values.
+ *
+ * Unlike effect() which just re-runs, watch() gives you the previous
+ * and current value so you can react to *what changed*.
+ *
+ * ```ts
+ * const count = signal(0);
+ * watch(count, (newVal, oldVal) => {
+ *   console.log(`Changed from ${oldVal} to ${newVal}`);
+ * });
+ *
+ * // With options:
+ * watch(count, callback, { immediate: true, once: true });
+ *
+ * // Multiple sources:
+ * watch([count, name], ([newCount, newName], [oldCount, oldName]) => { ... });
+ * ```
+ */
+interface WatchOptions {
+    /** Run callback immediately with current value (default: false) */
+    immediate?: boolean;
+    /** Only fire once, then auto-dispose (default: false) */
+    once?: boolean;
+    /** Debounce callback in ms */
+    debounce?: number;
+    /** Deep comparison for objects (default: false) */
+    deep?: boolean;
+}
+type WatchSource<T> = () => T;
+type WatchCallback<T> = (newValue: T, oldValue: T | undefined) => void;
+type WatchArrayCallback<T extends unknown[]> = (newValues: T, oldValues: (T[number] | undefined)[]) => void;
+/**
+ * Watch a reactive source and call back with old + new values.
+ *
+ * ```ts
+ * const dispose = watch(count, (newVal, oldVal) => {
+ *   analytics.track('count_changed', { from: oldVal, to: newVal });
+ * });
+ * ```
+ */
+declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void;
+/**
+ * Watch multiple sources.
+ */
+declare function watch<T extends unknown[]>(sources: {
+    [K in keyof T]: WatchSource<T[K]>;
+}, callback: WatchArrayCallback<T>, options?: WatchOptions): () => void;
+/**
+ * Watch a source once, then auto-dispose.
+ *
+ * ```ts
+ * watchOnce(isReady, (ready) => {
+ *   if (ready) initApp();
+ * });
+ * ```
+ */
+declare function watchOnce<T>(source: WatchSource<T>, callback: WatchCallback<T>): () => void;
+/**
+ * Watch with built-in debounce.
+ *
+ * ```ts
+ * watchDebounced(searchInput, (query) => {
+ *   fetchResults(query);
+ * }, 300);
+ * ```
+ */
+declare function watchDebounced<T>(source: WatchSource<T>, callback: WatchCallback<T>, ms: number): () => void;
+
+export { type WatchArrayCallback, type WatchCallback, type WatchOptions, type WatchSource, watch, watchDebounced, watchOnce };

package/dist/watch.js

@@ -0,0 +1,2 @@
+export{a as watch,c as watchDebounced,b as watchOnce}from'./chunk-N5APNCPB.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=watch.js.map
+//# sourceMappingURL=watch.js.map

package/dist/watch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"watch.js"}

package/dist/web-component.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkDFYXFKCH_cjs=require('./chunk-DFYXFKCH.cjs');Object.defineProperty(exports,"defineCustomElement",{enumerable:true,get:function(){return chunkDFYXFKCH_cjs.a}});Object.defineProperty(exports,"toCustomElement",{enumerable:true,get:function(){return chunkDFYXFKCH_cjs.b}});//# sourceMappingURL=web-component.cjs.map
+//# sourceMappingURL=web-component.cjs.map

package/dist/web-component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"web-component.cjs"}