Upload folder using huggingface_hub (part 49)

tools/ui/node_modules/runed/dist/utilities/use-event-listener/use-event-listener.svelte.d.ts

@@ -0,0 +1,54 @@
+import type { MaybeGetter } from "../../internal/types.js";
+export type EventHandler<TEvent extends Event, TTarget extends EventTarget> = (this: TTarget, event: TEvent & {
+    currentTarget: TTarget;
+}) => unknown;
+/**
+ * Adds an event listener to the specified target element for the given event(s), and returns a function to remove it.
+ * @param target The target element to add the event listener to.
+ * @param event The event(s) to listen for.
+ * @param handler The function to be called when the event is triggered.
+ * @param options An optional object that specifies characteristics about the event listener.
+ *
+ * @see {@link https://runed.dev/docs/utilities/use-event-listener}
+ */
+export declare function useEventListener<TEvent extends keyof WindowEventMap>(target: MaybeGetter<Window | null | undefined>, event: MaybeGetter<TEvent | TEvent[]>, handler: EventHandler<WindowEventMap[TEvent], Window>, options?: AddEventListenerOptions): void;
+/**
+ * Adds an event listener to the specified target element for the given event(s), and returns a function to remove it.
+ * @param target The target element to add the event listener to.
+ * @param event The event(s) to listen for.
+ * @param handler The function to be called when the event is triggered.
+ * @param options An optional object that specifies characteristics about the event listener.
+ *
+ * @see {@link https://runed.dev/docs/utilities/use-event-listener}
+ */
+export declare function useEventListener<TEvent extends keyof DocumentEventMap>(target: MaybeGetter<Document | null | undefined>, event: MaybeGetter<TEvent | TEvent[]>, handler: EventHandler<DocumentEventMap[TEvent], Document>, options?: AddEventListenerOptions): void;
+/**
+ * Adds an event listener to the specified target element for the given event(s), and returns a function to remove it.
+ * @param target The target element to add the event listener to.
+ * @param event The event(s) to listen for.
+ * @param handler The function to be called when the event is triggered.
+ * @param options An optional object that specifies characteristics about the event listener.
+ *
+ * @see {@link https://runed.dev/docs/utilities/use-event-listener}
+ */
+export declare function useEventListener<TElement extends HTMLElement, TEvent extends keyof HTMLElementEventMap>(target: MaybeGetter<TElement | null | undefined>, event: MaybeGetter<TEvent | TEvent[]>, handler: EventHandler<HTMLElementEventMap[TEvent], TElement>, options?: AddEventListenerOptions): void;
+/**
+ * Adds an event listener to the specified target element for the given event(s), and returns a function to remove it.
+ * @param target The target element to add the event listener to.
+ * @param event The event(s) to listen for.
+ * @param handler The function to be called when the event is triggered.
+ * @param options An optional object that specifies characteristics about the event listener.
+ *
+ * @see {@link https://runed.dev/docs/utilities/use-event-listener}
+ */
+export declare function useEventListener<TEvent extends keyof MediaQueryListEventMap>(target: MaybeGetter<MediaQueryList | null | undefined>, event: MaybeGetter<TEvent | TEvent[]>, handler: EventHandler<MediaQueryListEventMap[TEvent], MediaQueryList>, options?: AddEventListenerOptions): void;
+/**
+ * Adds an event listener to the specified target element for the given event(s), and returns a function to remove it.
+ * @param target The target element to add the event listener to.
+ * @param event The event(s) to listen for.
+ * @param handler The function to be called when the event is triggered.
+ * @param options An optional object that specifies characteristics about the event listener.
+ *
+ * @see {@link https://runed.dev/docs/utilities/use-event-listener}
+ */
+export declare function useEventListener(target: MaybeGetter<EventTarget | null | undefined>, event: MaybeGetter<string | string[]>, handler: EventListener, options?: AddEventListenerOptions): void;

tools/ui/node_modules/runed/dist/utilities/use-event-listener/use-event-listener.svelte.js

@@ -0,0 +1,18 @@
+import { extract } from "../extract/extract.svelte.js";
+import { on } from "svelte/events";
+export function useEventListener(_target, _events, handler, options) {
+    $effect(() => {
+        const target = extract(_target);
+        if (target == null)
+            return;
+        const events = extract(_events);
+        if (Array.isArray(events)) {
+            for (const event of events) {
+                $effect(() => on(target, event, handler, options));
+            }
+        }
+        else {
+            return on(target, events, handler, options);
+        }
+    });
+}

tools/ui/node_modules/runed/dist/utilities/use-geolocation/index.d.ts

@@ -0,0 +1 @@
+export * from "./use-geolocation.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-geolocation/index.js

@@ -0,0 +1 @@
+export * from "./use-geolocation.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-geolocation/use-geolocation.svelte.d.ts

@@ -0,0 +1,27 @@
+import { type ConfigurableNavigator } from "../../internal/configurable-globals.js";
+export type UseGeolocationOptions = Partial<PositionOptions> & {
+    /**
+     * Whether to start the watcher immediately upon creation. If set to `false`, the watcher
+     * will only start tracking the position when `resume()` is called.
+     *
+     * @defaultValue true
+     */
+    immediate?: boolean;
+} & ConfigurableNavigator;
+export type UseGeolocationPosition = Omit<GeolocationPosition, "toJSON" | "coords"> & {
+    coords: Omit<GeolocationPosition["coords"], "toJSON">;
+};
+export type UseGeolocationReturn = {
+    readonly isSupported: boolean;
+    readonly position: UseGeolocationPosition;
+    readonly error: GeolocationPositionError | null;
+    readonly isPaused: boolean;
+    resume: () => void;
+    pause: () => void;
+};
+/**
+ * Reactive access to the browser's [Geolocation API](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation_API).
+ *
+ * @see https://runed.dev/docs/utilities/use-geolocation
+ */
+export declare function useGeolocation(options?: UseGeolocationOptions): UseGeolocationReturn;

tools/ui/node_modules/runed/dist/utilities/use-geolocation/use-geolocation.svelte.js

@@ -0,0 +1,71 @@
+import { defaultNavigator, } from "../../internal/configurable-globals.js";
+/**
+ * Reactive access to the browser's [Geolocation API](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation_API).
+ *
+ * @see https://runed.dev/docs/utilities/use-geolocation
+ */
+export function useGeolocation(options = {}) {
+    const { enableHighAccuracy = true, maximumAge = 30000, timeout = 27000, immediate = true, navigator = defaultNavigator, } = options;
+    const isSupported = Boolean(navigator);
+    let error = $state.raw(null);
+    let position = $state({
+        timestamp: 0,
+        coords: {
+            accuracy: 0,
+            latitude: Number.POSITIVE_INFINITY,
+            longitude: Number.POSITIVE_INFINITY,
+            altitude: null,
+            altitudeAccuracy: null,
+            heading: null,
+            speed: null,
+        },
+    });
+    let isPaused = $state(false);
+    function updatePosition(_position) {
+        error = null;
+        position.timestamp = _position.timestamp;
+        position.coords.accuracy = _position.coords.accuracy;
+        position.coords.altitude = _position.coords.altitude;
+        position.coords.altitudeAccuracy = _position.coords.altitudeAccuracy;
+        position.coords.heading = _position.coords.heading;
+        position.coords.latitude = _position.coords.latitude;
+        position.coords.longitude = _position.coords.longitude;
+        position.coords.speed = _position.coords.speed;
+    }
+    let watcher;
+    function resume() {
+        if (!navigator)
+            return;
+        watcher = navigator.geolocation.watchPosition(updatePosition, (err) => (error = err), {
+            enableHighAccuracy,
+            maximumAge,
+            timeout,
+        });
+        isPaused = false;
+    }
+    function pause() {
+        if (watcher && navigator) {
+            navigator.geolocation.clearWatch(watcher);
+        }
+        isPaused = true;
+    }
+    $effect(() => {
+        if (immediate)
+            resume();
+        return () => pause();
+    });
+    return {
+        get isSupported() {
+            return isSupported;
+        },
+        position,
+        get error() {
+            return error;
+        },
+        get isPaused() {
+            return isPaused;
+        },
+        resume,
+        pause,
+    };
+}

tools/ui/node_modules/runed/dist/utilities/use-intersection-observer/index.d.ts

@@ -0,0 +1 @@
+export * from "./use-intersection-observer.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-intersection-observer/index.js

@@ -0,0 +1 @@
+export * from "./use-intersection-observer.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-intersection-observer/use-intersection-observer.svelte.d.ts

@@ -0,0 +1,28 @@
+import type { MaybeElementGetter, MaybeGetter } from "../../internal/types.js";
+import { type ConfigurableWindow } from "../../internal/configurable-globals.js";
+export interface UseIntersectionObserverOptions extends Omit<IntersectionObserverInit, "root">, ConfigurableWindow {
+    /**
+     * Whether to start the observer immediately upon creation. If set to `false`, the observer
+     * will only start observing when `resume()` is called.
+     *
+     * @defaultValue true
+     */
+    immediate?: boolean;
+    /**
+     * The root document/element to use as the bounding box for the intersection.
+     */
+    root?: MaybeElementGetter;
+}
+/**
+ * Watch for intersection changes of a target element.
+ *
+ * @see https://runed.dev/docs/utilities/useIntersectionObserver
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver IntersectionObserver MDN
+ */
+export declare function useIntersectionObserver(target: MaybeGetter<HTMLElement | HTMLElement[] | null | undefined>, callback: IntersectionObserverCallback, options?: UseIntersectionObserverOptions): {
+    readonly isActive: boolean;
+    stop: () => void;
+    pause(): void;
+    resume(): void;
+};
+export type UseIntersectionObserverReturn = ReturnType<typeof useIntersectionObserver>;

tools/ui/node_modules/runed/dist/utilities/use-intersection-observer/use-intersection-observer.svelte.js

@@ -0,0 +1,49 @@
+import { extract } from "../extract/extract.svelte.js";
+import { get } from "../../internal/utils/get.js";
+import { defaultWindow } from "../../internal/configurable-globals.js";
+/**
+ * Watch for intersection changes of a target element.
+ *
+ * @see https://runed.dev/docs/utilities/useIntersectionObserver
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver IntersectionObserver MDN
+ */
+export function useIntersectionObserver(target, callback, options = {}) {
+    const { root, rootMargin = "0px", threshold = 0.1, immediate = true, window = defaultWindow, } = options;
+    let isActive = $state(immediate);
+    let observer;
+    const targets = $derived.by(() => {
+        const value = extract(target);
+        return new Set(value ? (Array.isArray(value) ? value : [value]) : []);
+    });
+    const stop = $effect.root(() => {
+        $effect(() => {
+            if (!targets.size || !isActive || !window)
+                return;
+            observer = new window.IntersectionObserver(callback, {
+                rootMargin,
+                root: get(root),
+                threshold,
+            });
+            for (const el of targets)
+                observer.observe(el);
+            return () => {
+                observer?.disconnect();
+            };
+        });
+    });
+    $effect(() => {
+        return stop;
+    });
+    return {
+        get isActive() {
+            return isActive;
+        },
+        stop,
+        pause() {
+            isActive = false;
+        },
+        resume() {
+            isActive = true;
+        },
+    };
+}

tools/ui/node_modules/runed/dist/utilities/use-interval/index.d.ts

@@ -0,0 +1 @@
+export * from "./use-interval.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-interval/index.js

@@ -0,0 +1 @@
+export * from "./use-interval.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-interval/use-interval.svelte.d.ts

@@ -0,0 +1,51 @@
+import type { MaybeGetter } from "../../internal/types.js";
+export type UseIntervalOptions = {
+    /**
+     * Start the timer immediately
+     *
+     * @default true
+     */
+    immediate?: boolean;
+    /**
+     * Execute the callback immediately after calling `resume`
+     *
+     * @default false
+     */
+    immediateCallback?: boolean;
+    /**
+     * Callback to execute on every interval tick, receives the current counter value
+     */
+    callback?: (count: number) => void;
+};
+export type UseIntervalReturn = {
+    /**
+     * Pause the interval
+     */
+    pause: () => void;
+    /**
+     * Resume the interval
+     */
+    resume: () => void;
+    /**
+     * Reset the counter to 0
+     */
+    reset: () => void;
+    /**
+     * Whether the interval is currently active
+     */
+    readonly isActive: boolean;
+    /**
+     * The current counter value
+     */
+    readonly counter: number;
+};
+/**
+ * Wrapper for `setInterval` with controls for pausing and resuming.
+ *
+ * @see https://runed.dev/docs/utilities/use-interval
+ *
+ * @param delay - The interval in milliseconds between executions
+ * @param options - Configuration options
+ * @returns Object with pause, resume, reset methods, counter and isActive state
+ */
+export declare function useInterval(delay: MaybeGetter<number>, options?: UseIntervalOptions): UseIntervalReturn;

tools/ui/node_modules/runed/dist/utilities/use-interval/use-interval.svelte.js

@@ -0,0 +1,61 @@
+import { extract } from "../extract/index.js";
+import { watch } from "../watch/watch.svelte.js";
+/**
+ * Wrapper for `setInterval` with controls for pausing and resuming.
+ *
+ * @see https://runed.dev/docs/utilities/use-interval
+ *
+ * @param delay - The interval in milliseconds between executions
+ * @param options - Configuration options
+ * @returns Object with pause, resume, reset methods, counter and isActive state
+ */
+export function useInterval(delay, options = {}) {
+    const { immediate = true, immediateCallback = false, callback } = options;
+    let intervalId = $state(null);
+    let counter = $state(0);
+    const delay$ = $derived(extract(delay));
+    const isActive = $derived(intervalId !== null);
+    function runCallback() {
+        counter++;
+        callback?.(counter);
+    }
+    function createInterval() {
+        intervalId = setInterval(runCallback, delay$);
+    }
+    const pause = () => {
+        if (intervalId === null)
+            return;
+        clearInterval(intervalId);
+        intervalId = null;
+    };
+    const resume = () => {
+        if (intervalId !== null)
+            return;
+        if (immediateCallback)
+            runCallback();
+        createInterval();
+    };
+    if (immediate) {
+        resume();
+    }
+    // Sync interval's delay with the prop
+    watch(() => delay$, () => {
+        if (!isActive)
+            return;
+        pause();
+        createInterval();
+    });
+    // Cleanup on disposal
+    $effect(() => pause);
+    return {
+        pause,
+        resume,
+        reset: () => (counter = 0),
+        get isActive() {
+            return isActive;
+        },
+        get counter() {
+            return counter;
+        },
+    };
+}

tools/ui/node_modules/runed/dist/utilities/use-mutation-observer/index.d.ts

@@ -0,0 +1 @@
+export * from "./use-mutation-observer.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-mutation-observer/index.js

@@ -0,0 +1 @@
+export * from "./use-mutation-observer.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-mutation-observer/use-mutation-observer.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { MaybeGetter } from "../../internal/types.js";
+import { type ConfigurableWindow } from "../../internal/configurable-globals.js";
+export interface UseMutationObserverOptions extends MutationObserverInit, ConfigurableWindow {
+}
+/**
+ * Watch for changes being made to the DOM tree.
+ *
+ * @see https://runed.dev/docs/utilities/useMutationObserver
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver MutationObserver MDN
+ */
+export declare function useMutationObserver(target: MaybeGetter<HTMLElement | HTMLElement[] | null | undefined>, callback: MutationCallback, options?: UseMutationObserverOptions): {
+    stop: () => void;
+    takeRecords(): MutationRecord[] | undefined;
+};
+export type UseMutationObserverReturn = ReturnType<typeof useMutationObserver>;

tools/ui/node_modules/runed/dist/utilities/use-mutation-observer/use-mutation-observer.svelte.js

@@ -0,0 +1,38 @@
+import { extract } from "../extract/extract.svelte.js";
+import { defaultWindow } from "../../internal/configurable-globals.js";
+/**
+ * Watch for changes being made to the DOM tree.
+ *
+ * @see https://runed.dev/docs/utilities/useMutationObserver
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver MutationObserver MDN
+ */
+export function useMutationObserver(target, callback, options = {}) {
+    const { window = defaultWindow } = options;
+    let observer;
+    const targets = $derived.by(() => {
+        const value = extract(target);
+        return new Set(value ? (Array.isArray(value) ? value : [value]) : []);
+    });
+    const stop = $effect.root(() => {
+        $effect(() => {
+            if (!targets.size || !window)
+                return;
+            observer = new window.MutationObserver(callback);
+            for (const el of targets)
+                observer.observe(el, options);
+            return () => {
+                observer?.disconnect();
+                observer = undefined;
+            };
+        });
+    });
+    $effect(() => {
+        return stop;
+    });
+    return {
+        stop,
+        takeRecords() {
+            return observer?.takeRecords();
+        },
+    };
+}

tools/ui/node_modules/runed/dist/utilities/use-resize-observer/index.d.ts

@@ -0,0 +1 @@
+export { useResizeObserver } from "./use-resize-observer.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-resize-observer/index.js

@@ -0,0 +1 @@
+export { useResizeObserver } from "./use-resize-observer.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-resize-observer/use-resize-observer.svelte.d.ts

@@ -0,0 +1,39 @@
+import type { MaybeGetter } from "../../internal/types.js";
+import { type ConfigurableWindow } from "../../internal/configurable-globals.js";
+export interface ResizeObserverSize {
+    readonly inlineSize: number;
+    readonly blockSize: number;
+}
+export interface ResizeObserverEntry {
+    readonly target: Element;
+    readonly contentRect: DOMRectReadOnly;
+    readonly borderBoxSize?: ReadonlyArray<ResizeObserverSize>;
+    readonly contentBoxSize?: ReadonlyArray<ResizeObserverSize>;
+    readonly devicePixelContentBoxSize?: ReadonlyArray<ResizeObserverSize>;
+}
+export type ResizeObserverCallback = (entries: ReadonlyArray<ResizeObserverEntry>, observer: ResizeObserver) => void;
+export interface UseResizeObserverOptions extends ConfigurableWindow {
+    /**
+     * Sets which box model the observer will observe changes to. Possible values
+     * are `content-box` (the default), `border-box` and `device-pixel-content-box`.
+     *
+     * @default 'content-box'
+     */
+    box?: ResizeObserverBoxOptions;
+}
+declare class ResizeObserver {
+    constructor(callback: ResizeObserverCallback);
+    disconnect(): void;
+    observe(target: Element, options?: UseResizeObserverOptions): void;
+    unobserve(target: Element): void;
+}
+/**
+ * Reports changes to the dimensions of an Element's content or the border-box
+ *
+ * @see https://runed.dev/docs/utilities/useResizeObserver
+ */
+export declare function useResizeObserver(target: MaybeGetter<HTMLElement | HTMLElement[] | null | undefined>, callback: ResizeObserverCallback, options?: UseResizeObserverOptions): {
+    stop: () => void;
+};
+export type UseResizeObserverReturn = ReturnType<typeof useResizeObserver>;
+export {};

tools/ui/node_modules/runed/dist/utilities/use-resize-observer/use-resize-observer.svelte.js

@@ -0,0 +1,34 @@
+import { extract } from "../extract/extract.svelte.js";
+import { defaultWindow } from "../../internal/configurable-globals.js";
+/**
+ * Reports changes to the dimensions of an Element's content or the border-box
+ *
+ * @see https://runed.dev/docs/utilities/useResizeObserver
+ */
+export function useResizeObserver(target, callback, options = {}) {
+    const { window = defaultWindow } = options;
+    let observer;
+    const targets = $derived.by(() => {
+        const value = extract(target);
+        return new Set(value ? (Array.isArray(value) ? value : [value]) : []);
+    });
+    const stop = $effect.root(() => {
+        $effect(() => {
+            if (!targets.size || !window)
+                return;
+            observer = new window.ResizeObserver(callback);
+            for (const el of targets)
+                observer.observe(el, options);
+            return () => {
+                observer?.disconnect();
+                observer = undefined;
+            };
+        });
+    });
+    $effect(() => {
+        return stop;
+    });
+    return {
+        stop,
+    };
+}

tools/ui/node_modules/runed/dist/utilities/use-search-params/index.d.ts

@@ -0,0 +1,2 @@
+export { useSearchParams, createSearchParamsSchema, validateSearchParams, } from "./use-search-params.svelte.js";
+export type { SearchParamsOptions, StandardSchemaV1, SchemaTypeConfig, ReturnUseSearchParams, } from "./use-search-params.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-search-params/index.js

@@ -0,0 +1 @@
+export { useSearchParams, createSearchParamsSchema, validateSearchParams, } from "./use-search-params.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-search-params/use-search-params.svelte.d.ts

@@ -0,0 +1,448 @@
+/**
+ * Configuration options for useSearchParams
+ */
+export interface SearchParamsOptions {
+    /**
+     * If true, parameters set to their default values will be shown in the URL.
+     * If false, parameters with default values will be omitted from the URL.
+     * @default false
+     */
+    showDefaults?: boolean;
+    /**
+     * The number of milliseconds to delay URL updates when parameters change.
+     * This helps avoid cluttering browser history when values change rapidly
+     * (like during typing in an input field).
+     * @default 0 (no debounce)
+     */
+    debounce?: number;
+    /**
+     * Controls whether URL updates create new browser history entries.
+     * If true (default), each update adds a new entry to the browser history.
+     * If false, updates replace the current URL without creating new history entries.
+     * @default true
+     */
+    pushHistory?: boolean;
+    /**
+     * Enable lz-string compression for all parameters.
+     * When true, all parameters are compressed into a single parameter in the URL.
+     * This helps reduce URL length and provides basic parameter obfuscation.
+     * @default false
+     */
+    compress?: boolean;
+    /**
+     * The name of the parameter used to store compressed data when compression is enabled.
+     * You can customize this to avoid conflicts with your schema parameters.
+     *
+     * For example, if your schema already uses '_data', you might want to use '_compressed'
+     * or another unique name.
+     *
+     * @default '_data'
+     */
+    compressedParamName?: string;
+    /**
+     * Controls whether to update the URL when parameters change.
+     * If `true` (default), changes to parameters will update the URL.
+     * If `false`, parameters will only be stored in memory without updating the URL.
+     *
+     * Note: When `false`, compress option will be ignored.
+     * @default true
+     */
+    updateURL?: boolean;
+    /**
+     * If `true`, the scroll position will be preserved when the URL is updated.
+     *
+     * If `false`, the scroll position will be reset to the top when the URL is updated.
+     * @default false
+     */
+    noScroll?: boolean;
+}
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<T> = SuccessResult<T> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<T> {
+        /** The typed output value. */
+        readonly value: T;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/**
+ * Core class that handles URL search parameter operations with schema validation
+ *
+ * This class provides the foundation for the useSearchParams hook. It:
+ * 1. Validates values against a schema
+ * 2. Handles type conversion between URL strings and JavaScript types
+ * 3. Updates the URL when values change
+ * 4. Maintains a cache of valid schema keys for performance
+ */
+declare class SearchParams<Schema extends StandardSchemaV1> {
+    #private;
+    /**
+     * Create a new SearchParams instance with the given schema and options
+     *
+     * @param schema A StandardSchemaV1-compatible schema
+     * @param options Configuration options
+     */
+    constructor(schema: Schema, options?: SearchParamsOptions);
+    /**
+     * Get a typed parameter value by key
+     * Retrieves the current value from the local cache, runs it through schema validation,
+     * and returns the validated, typed result
+     *
+     * @param key The parameter key to get
+     * @returns The typed value after schema validation
+     */
+    get<K extends keyof StandardSchemaV1.InferOutput<Schema>>(key: K & string): StandardSchemaV1.InferOutput<Schema>[K];
+    /**
+     * Set a parameter value and update the URL
+     * Validates the value through the schema before updating the URL
+     *
+     * @param key The parameter key to set
+     * @param value The value to set (will be type-converted and validated)
+     */
+    set<K extends keyof StandardSchemaV1.InferOutput<Schema>>(key: K & string, value: StandardSchemaV1.InferOutput<Schema>[K]): void;
+    /**
+     * Clean up resources used by this instance
+     *
+     * IMPORTANT: You only need to call this method when using the debounce option.
+     * If you're not using debounce, there's no need to call cleanup.
+     *
+     * Call this when the component unmounts to prevent memory leaks from debounce timers.
+     *
+     * @example
+     * Example in a Svelte component with Svelte 5 runes:
+     * ```svelte
+     * <script>
+     *   import { useSearchParams } from '../../hooks/useSearchParams.svelte';
+     *
+     *   // Using debounce, so we need to handle cleanup
+     *   const searchParams = useSearchParams(schema, { debounce: 300 });
+     *
+     *   // Register cleanup in a Svelte 5 effect
+     *   $effect(() => {
+     *     return () => {
+     *       // Prevent memory leaks by cleaning up debounce timer
+     *       searchParams.cleanup();
+     *     };
+     *   });
+     * </script>
+     * ```
+     */
+    cleanup(): void;
+    /**
+     * Update multiple parameters at once
+     *
+     * This is more efficient than setting multiple parameters individually
+     * because it only triggers one URL update or one in-memory store update.
+     *
+     * @param values An object containing parameter key-value pairs to update
+     */
+    update(values: Partial<StandardSchemaV1.InferOutput<Schema>>): void;
+    /**
+     * Check if a key exists in the schema
+     * This is a critical method used by the Proxy handler to determine
+     * which properties should be treated as URL parameters
+     *
+     * @param key The key to check
+     * @returns True if the key is defined in the schema
+     */
+    has(key: string): boolean;
+    /**
+     * Reset all parameters to their default values
+     *
+     * This method removes all current URL parameters or in-memory parameters
+     * and optionally sets parameters with non-default values back to their defaults.
+     *
+     * @param showDefaults Whether to show default values in the URL or in-memory store after reset.
+     *                     If not provided, uses the instance's showDefaults option.
+     */
+    reset(showDefaults?: boolean): void;
+    /**
+     * Validate a value against the schema
+     * This is the core method that enforces schema validation
+     *
+     * @param value The value to validate
+     * @returns A StandardSchemaV1.Result containing either the validated value or validation errors
+     */
+    validate(value: unknown): StandardSchemaV1.Result<StandardSchemaV1.InferOutput<Schema>>;
+}
+/**
+ * Schema type for createSearchParamsSchema
+ * Allows specifying more precise types for arrays and objects
+ */
+export type SchemaTypeConfig<ArrayType = unknown, ObjectType = unknown> = {
+    type: "string";
+    default?: string;
+} | {
+    type: "number";
+    default?: number;
+} | {
+    type: "boolean";
+    default?: boolean;
+} | {
+    type: "array";
+    default?: ArrayType[];
+    arrayType?: ArrayType;
+} | {
+    type: "object";
+    default?: ObjectType;
+    objectType?: ObjectType;
+};
+/**
+ * Creates a simple schema compatible with useSearchParams without requiring external validation libraries.
+ *
+ * This is a lightweight alternative to using full schema validation libraries like Zod, Valibot, or Arktype.
+ * Use this when you need basic type conversion and default values without adding dependencies.
+ *
+ * Limitations:
+ * - For 'array' type: supports basic arrays, but doesn't validate array items
+ * - For 'object' type: supports generic objects, but doesn't validate nested properties
+ * - No custom validation rules or transformations
+ * - No granular reactivity: nested property changes require whole-value reassignment
+ *   (e.g., params.items = [...params.items, newItem] instead of params.items.push(newItem))
+ *
+ * For complex validation needs (nested validation, refined rules, etc.), use a dedicated
+ * validation library instead.
+ *
+ * Example usage:
+ * ```
+ * const productSearchSchema = createSearchParamsSchema({
+ *   // Basic types with defaults
+ *   page: { type: 'number', default: 1 },
+ *   filter: { type: 'string', default: '' },
+ *   sort: { type: 'string', default: 'newest' },
+ *
+ *   // Array type with specific element type
+ *   tags: {
+ *     type: 'array',
+ *     default: ['new'],
+ *     arrayType: '' // Specify string[] type
+ *   },
+ *
+ *   // Object type with specific shape
+ *   config: {
+ *     type: 'object',
+ *     default: { theme: 'light' },
+ *     objectType: { theme: '' } // Specify { theme: string } type
+ *   }
+ * });
+ * ```
+ *
+ * URL storage format:
+ * - Arrays are stored as JSON strings: ?tags=["sale","featured"]
+ * - Objects are stored as JSON strings: ?config={"theme":"dark","fontSize":14}
+ * - Primitive values are stored directly: ?page=2&filter=red
+ */
+export declare function createSearchParamsSchema<T extends Record<string, SchemaTypeConfig>>(schema: T): StandardSchemaV1<unknown, {
+    [K in keyof T]: T[K] extends {
+        type: "number";
+    } ? number : T[K] extends {
+        type: "boolean";
+    } ? boolean : T[K] extends {
+        type: "array";
+        arrayType?: infer A;
+    } ? unknown extends A ? unknown[] : A[] : T[K] extends {
+        type: "object";
+        objectType?: infer O;
+    } ? unknown extends O ? Record<string, unknown> : O : string;
+}>;
+/**
+ * A utility function to extract, validate and convert URL search parameters to [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams)
+ *
+ * This function makes it easy to use the same schema validation in
+ * both client-side components (via useSearchParams) and server-side load functions.
+ * Unlike useSearchParams, this function doesn't modify the URL - it only validates
+ * parameters and returns them as a new URLSearchParams object.
+ *
+ * **Important for SvelteKit fine-grained reactivity**: This function only accesses URL parameters
+ * that are defined in your schema, ensuring that load functions only re-run when schema-defined
+ * parameters change, not when any URL parameter changes.
+ *
+ * Handles both standard URL parameters and compressed parameters (when compression is enabled).
+ *
+ * @param url The URL object from SvelteKit load function
+ * @param schema A validation schema (createSearchParamsSchema, Zod, Valibot, etc.)
+ * @param options Optional configuration (like custom compressedParamName)
+ * @returns URLSearchParams object with the validated values
+ *
+ * Example with SvelteKit page or layout load function:
+ * ```ts
+ * import { validateSearchParams } from '../../hooks/useSearchParams.svelte';
+ * import { productSchema } from './schemas';
+ *
+ * export const load = ({ url }) => {
+ *   // Get validated search params as URLSearchParams object
+ *   // Only accesses 'page', 'filter', 'sort' parameters from the URL
+ *   // Load function will only re-run when these specific parameters change
+ *   const searchParams = validateSearchParams(url, productSchema, {
+ *     compressedParamName: '_compressed'
+ *   });
+ *
+ *   // Use URLSearchParams directly with fetch
+ *   const response = await fetch(`/api/products?${searchParams.toString()}`);
+ *   return {
+ *     products: await response.json()
+ *   };
+ * };
+ * ```
+ */
+export declare function validateSearchParams<Schema extends StandardSchemaV1>(url: URL, schema: Schema, options?: {
+    compressedParamName?: string;
+}): {
+    searchParams: URLSearchParams;
+    data: StandardSchemaV1.InferOutput<Schema>;
+};
+export type ReturnUseSearchParams<T extends StandardSchemaV1> = SearchParams<T> & StandardSchemaV1.InferOutput<T> & {
+    /**
+     * Convert the current schema parameters to a URLSearchParams object
+     * This includes all values defined in the schema, regardless of their presence in the URL
+     * @returns URLSearchParams object containing all current parameter values
+     */
+    toURLSearchParams(): URLSearchParams;
+};
+/**
+ * Hook to create a reactive search params object with property access
+ *
+ * This client-side hook automatically updates the URL when parameters change.
+ * It provides type-safe access to URL search parameters through direct property access.
+ *
+ * @param schema A validation schema compatible with StandardSchemaV1
+ * @param options Configuration options that affect URL behavior
+ * @returns A reactive object for working with typed search parameters
+ *
+ * Available options:
+ * - `showDefaults` (boolean): When true, parameters with default values will be shown in the URL.
+ *   When false (default), parameters with default values will be omitted from the URL.
+ * - `debounce` (number): Milliseconds to delay URL updates when parameters change.
+ *   Useful to avoid cluttering browser history when values change rapidly (default: 0, no debounce).
+ * - `pushHistory` (boolean): Controls whether URL updates create new browser history entries.
+ *   If true (default), each update adds a new entry to the browser history.
+ *   If false, updates replace the current URL without creating new history entries.
+ * - `compress` (boolean): When true, all parameters are compressed into a single parameter
+ *   using lz-string compression. This helps reduce URL length and provides basic obfuscation (default: false).
+ *   Use validateSearchParams with the same compressedParamName option when handling compressed URLs server-side.
+ * - `compressedParamName` (string): The name of the parameter used to store compressed data
+ *   when compression is enabled. Customize this to avoid conflicts with parameters in your schema.
+ *   Default is '_data'.
+ * - `updateURL` (boolean): When true (default), the URL is updated when parameters change.
+ *   When false, only in-memory parameters are updated.
+ *
+ * Example with Zod:
+ * ```
+ * import { z } from 'zod';
+ *
+ * const productSearchSchema = z.object({
+ *   page: z.number().catch(1),
+ *   filter: z.string().catch(''),
+ *   sort: z.enum(['newest', 'oldest', 'price']).catch('newest'),
+ * });
+ *
+ * const params = useSearchParams(productSearchSchema);
+ *
+ * // Access parameters directly
+ * const page = $derived(params.page); // number (defaults to 1)
+ * const sort = $derived(params.sort); // 'newest' | 'oldest' | 'price'
+ *
+ * // Update parameters directly
+ * params.page = 2; // Updates URL to include ?page=2
+ * params.sort = 'price'; // Updates URL to include &sort=price
+ * ```
+ *
+ * Example with options:
+ * ```typescript
+ * // Show default values in URL, debounce updates by 300ms,
+ * // don't create new history entries, and compress params
+ * const params = useSearchParams(schema, {
+ *   showDefaults: true,
+ *   debounce: 300,
+ *   pushHistory: false,
+ *   compress: true,
+ *   compressedParamName: '_compressed' // Custom name to avoid conflicts
+ * });
+ *
+ * // Great for binding to input fields (updates URL without cluttering history)
+ * <input type="text" bind:value={params.search} />
+ * // Resulting URL will be something like: /?_compressed=N4IgDgTg9g...
+ * ```
+ * Example with Valibot:
+ * ```
+ * import * as v from 'valibot';
+ *
+ * const productSearchSchema = v.object({
+ *   page: v.optional(v.fallback(v.number(), 1), 1),
+ *   filter: v.optional(v.fallback(v.string(), ''), ''),
+ *   sort: v.optional(v.fallback(v.picklist(['newest', 'oldest', 'price']), 'newest'), 'newest'),
+ * });
+ *
+ * const params = useSearchParams(productSearchSchema);
+ * ``` * Example with Arktype:
+ * ```
+ * import { type } from 'arktype';
+ *
+ * const productSearchSchema = type({
+ *   page: 'number = 1',
+ *   filter: 'string = ""',
+ *   sort: '"newest" | "oldest" | "price" = "newest"',
+ * });
+ *
+ * const params = useSearchParams(productSearchSchema);
+ * ```
+ * Or with our built-in schema creator (no additional dependencies):
+ *
+ * ```
+ * const productSearchSchema = createSearchParamsSchema({
+ *   page: { type: 'number', default: 1 },
+ *   filter: { type: 'string', default: '' },
+ *   sort: { type: 'string', default: 'newest' }
+ * });
+ *
+ * const params = useSearchParams(productSearchSchema);
+ * ```
+ */
+export declare function useSearchParams<Schema extends StandardSchemaV1>(schema: Schema, options?: SearchParamsOptions): ReturnUseSearchParams<Schema>;
+export {};

tools/ui/node_modules/runed/dist/utilities/use-search-params/use-search-params.svelte.js

@@ -0,0 +1,1277 @@
+import { SvelteURLSearchParams } from "svelte/reactivity";
+import { dequal } from "dequal/lite";
+import * as lzString from "lz-string";
+import { browser, building } from "$app/environment";
+import { goto } from "$app/navigation";
+import { page } from "$app/state";
+import { IsMounted } from "../is-mounted/is-mounted.svelte.js";
+import { BROWSER } from "esm-env";
+import { untrack } from "svelte";
+/**
+ * Extract and pre-process values from URLSearchParams
+ *
+ * This is a shared utility used by both validateSearchParams and the SearchParams class
+ * to ensure consistent conversion of URL string values to JavaScript types.
+ *
+ * @param searchParams The URLSearchParams object to extract values from
+ * @param numberFields Optional set of field names that should be treated as numbers
+ * @returns An object with processed parameter values
+ * @internal
+ */
+function extractParamValues(searchParams, numberFields = new Set()) {
+    const params = {};
+    for (const [key, value] of searchParams.entries()) {
+        try {
+            // Special handling for empty arrays and objects
+            if (value === "[]") {
+                params[key] = [];
+                continue;
+            }
+            if (value === "{}") {
+                params[key] = {};
+                continue;
+            }
+            // Try to parse as JSON for complex objects/arrays
+            // This handles cases like ?obj={"foo":"bar"} or ?arr=[1,2,3]
+            if (value.startsWith("{") || value.startsWith("[")) {
+                params[key] = JSON.parse(value);
+            }
+            // Boolean values are stored as strings, convert them
+            else if (value === "true" || value === "false") {
+                params[key] = value === "true";
+            }
+            // Only convert to number if it looks numeric AND the schema expects a number
+            else if (numberFields.has(key) && value.trim() !== "" && !isNaN(Number(value))) {
+                params[key] = Number(value);
+            }
+            // Handle comma-separated values as arrays (fallback format)
+            else if (value.includes(",")) {
+                params[key] = value.split(",");
+            }
+            // Keep everything else as strings
+            else {
+                params[key] = value;
+            }
+        }
+        catch {
+            // If JSON parsing fails, treat as regular string
+            // This ensures we don't throw errors during type conversion
+            params[key] = value;
+        }
+    }
+    return params;
+}
+/**
+ * Extract schema information by validating an empty object.
+ * This consolidates multiple schema validation calls into one for efficiency.
+ * Works with any StandardSchemaV1-compatible schema (Zod, Valibot, Arktype, etc.)
+ *
+ * Note: This function expects schemas used with useSearchParams to have defaults for all fields,
+ * which is the recommended pattern since URL parameters are inherently optional.
+ *
+ * @param schema A StandardSchemaV1-compatible schema
+ * @returns Object containing schema keys, number fields, and default values
+ * @internal
+ */
+function extractSchemaInfo(schema) {
+    const validationResult = schema["~standard"].validate({});
+    if (!validationResult || !("value" in validationResult)) {
+        return { keys: [], numberFields: new Set(), defaultValues: {} };
+    }
+    const defaultValues = validationResult.value;
+    const keys = Object.keys(defaultValues);
+    const numberFields = new Set();
+    // Determine which fields are number types by checking default value types
+    for (const [key, defaultValue] of Object.entries(defaultValues)) {
+        if (typeof defaultValue === "number") {
+            numberFields.add(key);
+        }
+    }
+    return { keys, numberFields, defaultValues };
+}
+/**
+ * Extract and pre-process values from URLSearchParams, but only for keys defined in the schema.
+ * This enables SvelteKit's fine-grained reactivity by only accessing specific parameters
+ * instead of all parameters via searchParams.entries().
+ *
+ * @param searchParams The URLSearchParams object to extract values from
+ * @param schemaKeys Array of parameter keys that are defined in the schema
+ * @param numberFields Set of field names that should be treated as numbers
+ * @returns An object with processed parameter values for schema-defined keys only
+ * @internal
+ */
+function extractSelectiveParamValues(searchParams, schemaKeys, numberFields = new Set()) {
+    const params = {};
+    // Only access parameters that are defined in the schema
+    // This maintains SvelteKit's fine-grained reactivity
+    for (const key of schemaKeys) {
+        const value = searchParams.get(key);
+        if (value === null)
+            continue;
+        try {
+            if (value === "[]") {
+                params[key] = [];
+                continue;
+            }
+            if (value === "{}") {
+                params[key] = {};
+                continue;
+            }
+            // Try to parse as JSON for complex objects/arrays
+            // This handles cases like ?obj={"foo":"bar"} or ?arr=[1,2,3]
+            if (value.startsWith("{") || value.startsWith("[")) {
+                params[key] = JSON.parse(value);
+            }
+            // Boolean values are stored as strings, convert them
+            else if (value === "true" || value === "false") {
+                params[key] = value === "true";
+            }
+            // Only convert to number if it looks numeric AND the schema expects a number
+            // This handles cases like ?page=2 or ?price=19.99
+            else if (numberFields.has(key) && value.trim() !== "" && !isNaN(Number(value))) {
+                params[key] = Number(value);
+            }
+            // Handle comma-separated values as arrays (fallback format)
+            else if (value.includes(",")) {
+                params[key] = value.split(",");
+            }
+            // Keep everything else as strings
+            else {
+                params[key] = value;
+            }
+        }
+        catch {
+            // If JSON parsing fails, treat as regular string
+            // This ensures we don't throw errors during type conversion
+            params[key] = value;
+        }
+    }
+    return params;
+}
+/**
+ * Core class that handles URL search parameter operations with schema validation
+ *
+ * This class provides the foundation for the useSearchParams hook. It:
+ * 1. Validates values against a schema
+ * 2. Handles type conversion between URL strings and JavaScript types
+ * 3. Updates the URL when values change
+ * 4. Maintains a cache of valid schema keys for performance
+ */
+class SearchParams {
+    /** The schema used for validation and type conversion */
+    #schema;
+    /**
+     * A lookup object containing all valid keys from the schema
+     * Used for fast property existence checking without re-validating
+     * Format: { propertyName1: true, propertyName2: true, ... }
+     */
+    #schemaShape;
+    /**
+     * Options that configure behavior
+     */
+    #options;
+    /**
+     * Default values from the schema, used for comparison when showDefaults is false
+     */
+    #defaultValues;
+    /**
+     * Set of field names that expect number types based on schema validation
+     * Used to intelligently convert URL string values to numbers only when appropriate
+     */
+    #numberFields;
+    /**
+     * Timer ID for debouncing URL updates
+     * @private
+     */
+    #debounceTimer = null;
+    /**
+     * Local cache for immediate reads/writes
+     * Used regardless of updateURL setting to prevent input lag
+     * When updateURL is true, this cache is synced to the URL (with optional debouncing)
+     * When updateURL is false, this cache is the sole source of truth
+     * @private
+     */
+    #localCache = $state(new URLSearchParams());
+    /**
+     * Flag to track if local cache has been initialized from URL
+     * @private
+     */
+    #cacheInitialized = false;
+    /**
+     * Create a new SearchParams instance with the given schema and options
+     *
+     * @param schema A StandardSchemaV1-compatible schema
+     * @param options Configuration options
+     */
+    constructor(schema, options = {}) {
+        this.#schema = schema;
+        this.#options = {
+            showDefaults: false,
+            debounce: 0,
+            pushHistory: true,
+            compress: false,
+            compressedParamName: "_data",
+            updateURL: true,
+            noScroll: false,
+            ...options,
+        };
+        // Extract schema information (keys, number fields, defaults) in one pass
+        const schemaInfo = extractSchemaInfo(schema);
+        // Store schema shape for property checking
+        this.#schemaShape = schemaInfo.keys.reduce((acc, key) => {
+            acc[key] = true;
+            return acc;
+        }, {});
+        // Store default values and number fields
+        this.#defaultValues = { ...schemaInfo.defaultValues };
+        this.#numberFields = schemaInfo.numberFields;
+    }
+    /**
+     * Initialize the local cache from the URL on first access
+     * @private
+     */
+    #initializeCacheFromURL() {
+        if (this.#cacheInitialized)
+            return;
+        this.#cacheInitialized = true;
+        // only initialize from URL if updateURL is true and we're in browser
+        if (!this.#options.updateURL || !BROWSER || building)
+            return;
+        const urlParams = page.url.searchParams;
+        const compressedParamName = this.#options.compressedParamName || "_data";
+        // Handle compressed mode
+        if (this.#options.compress && urlParams.has(compressedParamName)) {
+            try {
+                const compressedData = urlParams.get(compressedParamName) || "";
+                const decompressed = lzString.decompressFromEncodedURIComponent(compressedData);
+                if (decompressed) {
+                    const decompressedObj = JSON.parse(decompressed);
+                    const newCache = new URLSearchParams();
+                    // populate cache with decompressed values
+                    for (const [key, value] of Object.entries(decompressedObj)) {
+                        const stringValue = this.#serializeValue(value);
+                        newCache.set(key, stringValue);
+                    }
+                    untrack(() => (this.#localCache = newCache));
+                    return;
+                }
+            }
+            catch (e) {
+                console.error("Error initializing cache from compressed URL", e);
+            }
+        }
+        // Normal mode - copy current URL params to cache
+        const newCache = new SvelteURLSearchParams();
+        for (const [key, value] of urlParams.entries()) {
+            newCache.set(key, value);
+        }
+        untrack(() => (this.#localCache = newCache));
+    }
+    /**
+     * Get a typed parameter value by key
+     * Retrieves the current value from the local cache, runs it through schema validation,
+     * and returns the validated, typed result
+     *
+     * @param key The parameter key to get
+     * @returns The typed value after schema validation
+     */
+    get(key) {
+        this.#initializeCacheFromURL();
+        return this.#getTypedValue(key);
+    }
+    /**
+     * Set a parameter value and update the URL
+     * Validates the value through the schema before updating the URL
+     *
+     * @param key The parameter key to set
+     * @param value The value to set (will be type-converted and validated)
+     */
+    set(key, value) {
+        this.#setValue(key, value);
+    }
+    /**
+     * Clean up resources used by this instance
+     *
+     * IMPORTANT: You only need to call this method when using the debounce option.
+     * If you're not using debounce, there's no need to call cleanup.
+     *
+     * Call this when the component unmounts to prevent memory leaks from debounce timers.
+     *
+     * @example
+     * Example in a Svelte component with Svelte 5 runes:
+     * ```svelte
+     * <script>
+     *   import { useSearchParams } from '../../hooks/useSearchParams.svelte';
+     *
+     *   // Using debounce, so we need to handle cleanup
+     *   const searchParams = useSearchParams(schema, { debounce: 300 });
+     *
+     *   // Register cleanup in a Svelte 5 effect
+     *   $effect(() => {
+     *     return () => {
+     *       // Prevent memory leaks by cleaning up debounce timer
+     *       searchParams.cleanup();
+     *     };
+     *   });
+     * </script>
+     * ```
+     */
+    cleanup() {
+        // Clear any debounce timer
+        if (this.#debounceTimer) {
+            clearTimeout(this.#debounceTimer);
+            this.#debounceTimer = null;
+        }
+    }
+    /**
+     * Update multiple parameters at once
+     *
+     * This is more efficient than setting multiple parameters individually
+     * because it only triggers one URL update or one in-memory store update.
+     *
+     * @param values An object containing parameter key-value pairs to update
+     */
+    update(values) {
+        this.#initializeCacheFromURL();
+        if (!values || typeof values !== "object")
+            return;
+        // Quick optimization: Filter out non-schema keys upfront
+        const filteredValues = {};
+        let anyValid = false;
+        for (const [key, value] of Object.entries(values)) {
+            if (this.has(key)) {
+                filteredValues[key] = value;
+                anyValid = true;
+            }
+        }
+        // no valid keys to update
+        if (!anyValid)
+            return;
+        // Always use local cache for immediate state
+        const paramsObject = this.#extractParamValues(this.#localCache);
+        // Check if there are any actual changes
+        let hasChanges = false;
+        for (const [key, value] of Object.entries(filteredValues)) {
+            const currentValue = paramsObject[key];
+            // Optimization: For primitives, use direct comparison; use dequal only for objects
+            const isPrimitive = typeof currentValue !== "object" &&
+                typeof value !== "object" &&
+                currentValue !== null &&
+                value !== null;
+            if (isPrimitive ? currentValue !== value : !dequal(currentValue, value)) {
+                hasChanges = true;
+                break;
+            }
+        }
+        // no changes, skip update
+        if (!hasChanges)
+            return;
+        // Create a new object with the updated values
+        const newParamsObject = { ...paramsObject, ...filteredValues };
+        // Validate against schema
+        const result = this.validate(newParamsObject);
+        if (result && "value" in result) {
+            const validatedResult = result.value;
+            // Always update local cache immediately (for instant reads)
+            const updatedCache = this.#updateParamsWithValidatedValues(this.#localCache, filteredValues, validatedResult, true // always treat as in-memory for cache updates
+            );
+            this.#localCache = updatedCache;
+            // If updateURL is true and we're in browser, sync to URL
+            if (this.#options.updateURL && BROWSER && !building) {
+                // Handle the compression mode if enabled
+                if (this.#options.compress) {
+                    this.#handleCompressedUpdate(validatedResult);
+                }
+                else {
+                    // Normal mode - update the URL
+                    // Start from the current local cache to preserve all params
+                    const urlParams = this.#updateParamsWithValidatedValues(this.#localCache, filteredValues, validatedResult, false // use URLSearchParams for URL updates
+                    );
+                    this.#navigateWithParams(urlParams);
+                }
+            }
+        }
+    }
+    /**
+     * Check if a key exists in the schema
+     * This is a critical method used by the Proxy handler to determine
+     * which properties should be treated as URL parameters
+     *
+     * @param key The key to check
+     * @returns True if the key is defined in the schema
+     */
+    has(key) {
+        return key in this.#schemaShape;
+    }
+    /**
+     * Reset all parameters to their default values
+     *
+     * This method removes all current URL parameters or in-memory parameters
+     * and optionally sets parameters with non-default values back to their defaults.
+     *
+     * @param showDefaults Whether to show default values in the URL or in-memory store after reset.
+     *                     If not provided, uses the instance's showDefaults option.
+     */
+    reset(showDefaults) {
+        this.#initializeCacheFromURL();
+        const useShowDefaults = showDefaults !== undefined ? showDefaults : this.#options.showDefaults;
+        if (useShowDefaults) {
+            // Reuse the filtered default values for both cache and URL updates
+            const validDefaultValues = {};
+            // Filter out null/undefined values
+            for (const [key, defaultValue] of Object.entries(this.#defaultValues)) {
+                if (defaultValue !== null && defaultValue !== undefined) {
+                    validDefaultValues[key] = defaultValue;
+                }
+            }
+            // Always update local cache immediately
+            const newCache = new SvelteURLSearchParams();
+            for (const [key, value] of Object.entries(validDefaultValues)) {
+                const stringValue = this.#serializeValue(value);
+                newCache.set(key, stringValue);
+            }
+            this.#localCache = newCache;
+            // If updateURL is true, sync to URL
+            if (this.#options.updateURL && BROWSER && !building) {
+                const urlParams = new URLSearchParams();
+                for (const [key, value] of Object.entries(validDefaultValues)) {
+                    const stringValue = this.#serializeValue(value);
+                    urlParams.set(key, stringValue);
+                }
+                this.#navigateWithParams(urlParams);
+            }
+        }
+        else {
+            // Not showing defaults - just clear everything
+            this.#localCache = new SvelteURLSearchParams();
+            // If updateURL is true, clear the URL
+            if (this.#options.updateURL && BROWSER && !building) {
+                goto("?", { replaceState: true, noScroll: this.#options.noScroll });
+            }
+        }
+    }
+    /**
+     * Validate a value against the schema
+     * This is the core method that enforces schema validation
+     *
+     * @param value The value to validate
+     * @returns A StandardSchemaV1.Result containing either the validated value or validation errors
+     */
+    validate(value) {
+        return this.#schema["~standard"].validate(value);
+    }
+    /**
+     * Helper method to create a new search params object
+     * Works with both URLSearchParams and SvelteURLSearchParams
+     * @private
+     */
+    #createSearchParams(base, isInMemory) {
+        if (isInMemory) {
+            // For in-memory, always return SvelteURLSearchParams
+            return new SvelteURLSearchParams(base.toString());
+        }
+        else {
+            // For URL updates, always return URLSearchParams
+            return new URLSearchParams(base.toString());
+        }
+    }
+    /**
+     * Helper method to update search params with validated values
+     * Works with both URLSearchParams and SvelteURLSearchParams
+     * @private
+     */
+    #updateParamsWithValidatedValues(searchParams, updates, validatedValues, isInMemory) {
+        const newSearchParams = this.#createSearchParams(searchParams, isInMemory);
+        for (const key of Object.keys(updates)) {
+            // Skip keys not in schema
+            if (!this.has(key))
+                continue;
+            const validatedValue = validatedValues[key];
+            // Check if the value should be omitted
+            const isDefaultValue = !this.#options.showDefaults && dequal(validatedValue, this.#defaultValues[key]);
+            if (validatedValue === undefined || validatedValue === null || isDefaultValue) {
+                newSearchParams.delete(key);
+            }
+            else {
+                const stringValue = this.#serializeValue(validatedValue);
+                newSearchParams.set(key, stringValue);
+            }
+        }
+        return newSearchParams;
+    }
+    /**
+     * Helper method to handle updates when compression is enabled
+     * @private
+     */
+    #handleCompressedUpdate(fullParamsObject) {
+        try {
+            // Convert the entire parameters object to JSON
+            const jsonData = JSON.stringify(fullParamsObject);
+            // Compress the JSON string
+            const compressed = lzString.compressToEncodedURIComponent(jsonData);
+            // Create new params with just the compressed data
+            const newSearchParams = new URLSearchParams();
+            const compressedParamName = this.#options.compressedParamName || "_data";
+            newSearchParams.set(compressedParamName, compressed);
+            // Update URL
+            this.#navigateWithParams(newSearchParams);
+        }
+        catch (e) {
+            console.error("Error compressing data, falling back to normal mode", e);
+            // Create new params with all values as fallback
+            const newSearchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(fullParamsObject)) {
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                const stringValue = this.#serializeValue(value);
+                newSearchParams.set(key, stringValue);
+            }
+            this.#navigateWithParams(newSearchParams);
+        }
+    }
+    /**
+     * Helper method to navigate with URL parameters
+     * Handles debouncing and history state
+     * @private
+     */
+    #navigateWithParams(params) {
+        const navigateToNewUrl = () => {
+            if (!BROWSER)
+                return;
+            // When pushHistory is false, use replaceState to avoid creating a browser history entry
+            const gotoOptions = !this.#options.pushHistory
+                ? { replaceState: true, keepFocus: true }
+                : { keepFocus: true };
+            goto("?" + params.toString(), { ...gotoOptions, noScroll: this.#options.noScroll });
+        };
+        // If debounce is set, delay the URL update
+        if (this.#options.debounce && this.#options.debounce > 0) {
+            // Clear any existing timer
+            if (this.#debounceTimer) {
+                clearTimeout(this.#debounceTimer);
+            }
+            // Set a new timer
+            this.#debounceTimer = setTimeout(navigateToNewUrl, this.#options.debounce);
+        }
+        else {
+            // No debounce, update immediately
+            navigateToNewUrl();
+        }
+    }
+    /**
+     * Converts a value to a URL-compatible string representation
+     * Handles arrays, objects, and primitive values
+     * @private
+     */
+    #serializeValue(value) {
+        if (Array.isArray(value)) {
+            return JSON.stringify(value);
+        }
+        else if (typeof value === "object" && value !== null) {
+            return JSON.stringify(value);
+        }
+        else {
+            return String(value);
+        }
+    }
+    #extractParamValues(searchParams) {
+        const compressedParamName = this.#options.compressedParamName || "_data";
+        // Check if we're using compression mode and have a compressed parameter
+        if (this.#options.compress && searchParams.has(compressedParamName)) {
+            try {
+                const compressedData = searchParams.get(compressedParamName) || "";
+                const decompressed = lzString.decompressFromEncodedURIComponent(compressedData);
+                if (decompressed) {
+                    try {
+                        // Parse the decompressed JSON
+                        return JSON.parse(decompressed);
+                    }
+                    catch (e) {
+                        console.error("Failed to parse decompressed data", e);
+                        return {};
+                    }
+                }
+            }
+            catch (e) {
+                console.error("Error decompressing data", e);
+            }
+            return {};
+        }
+        // If not using compression, use the normal extraction with number field detection
+        return extractParamValues(searchParams, this.#numberFields);
+    }
+    /**
+     * Get typed values from the local cache using schema validation
+     *
+     * This method:
+     * 1. Gets the current search parameters from the local cache
+     * 2. Extracts and processes parameter values
+     * 3. Validates them against the schema
+     * 4. Returns the typed value for the requested key
+     *
+     * @param key The parameter key to get
+     * @returns The typed value after validation or undefined if invalid
+     * @private
+     */
+    #getTypedValue(key) {
+        // Always read from local cache for immediate state
+        const paramsObject = this.#extractParamValues(this.#localCache);
+        const result = this.validate(paramsObject);
+        if (result instanceof Promise) {
+            throw new Error("Async validation is not supported in validateSearchParams");
+        }
+        if (result && "value" in result) {
+            return result.value[key];
+        }
+        else if (result && "issues" in result) {
+            // If validation fails, use defaults
+            const emptyResult = this.validate({});
+            const defaultValues = emptyResult && "value" in emptyResult ? emptyResult.value : {};
+            // find valid params in the paramsObject and use them, do not override all default values
+            const validParams = Object.fromEntries(Object.entries(paramsObject).filter(([key]) => !result.issues?.some((issue) => issue.path?.includes(key))));
+            return {
+                ...(typeof defaultValues === "object" && defaultValues !== null ? defaultValues : {}),
+                ...validParams,
+            }[key];
+        }
+        // If validation failed, return undefined
+        return undefined;
+    }
+    /**
+     * Set a parameter value and update the local cache and optionally the URL
+     *
+     * This method:
+     * 1. Gets the current search parameters from the local cache
+     * 2. Extracts and processes all current parameters
+     * 3. Updates the parameter with the new value
+     * 4. Validates the complete parameter object against the schema
+     * 5. Updates the local cache immediately (for instant reads)
+     * 6. Optionally updates the browser URL if updateURL is true
+     *
+     * @param key The parameter key to set
+     * @param value The value to set
+     * @private
+     */
+    #setValue(key, value) {
+        this.#initializeCacheFromURL();
+        // Optimization: Skip if the key is not in schema
+        if (!this.has(key))
+            return;
+        // Always use local cache for immediate state
+        const paramsObject = this.#extractParamValues(this.#localCache);
+        // Check if the new value is the same as the current value
+        // Optimization: For primitives, use direct comparison; use dequal only for objects
+        const currentValue = paramsObject[key];
+        const isPrimitive = typeof currentValue !== "object" &&
+            typeof value !== "object" &&
+            currentValue !== null &&
+            value !== null;
+        if (isPrimitive ? currentValue === value : dequal(currentValue, value)) {
+            // Skip the update if values are the same
+            return;
+        }
+        // Create a new object with the updated value
+        const newParamsObject = { ...paramsObject, [key]: value };
+        // Validate against schema to ensure type correctness
+        const result = this.validate(newParamsObject);
+        if (result && "value" in result) {
+            const validatedResult = result.value;
+            const updateObj = { [key]: value };
+            // Always update local cache immediately (for instant reads)
+            const updatedCache = this.#updateParamsWithValidatedValues(this.#localCache, updateObj, validatedResult, true // always treat as in-memory for cache updates
+            );
+            this.#localCache = updatedCache;
+            // If updateURL is true, sync to URL
+            if (this.#options.updateURL && BROWSER && !building) {
+                // Handle the compression mode if enabled
+                if (this.#options.compress) {
+                    this.#handleCompressedUpdate(validatedResult);
+                }
+                else {
+                    // Normal mode - update the URL
+                    // Start from the current local cache to preserve all params
+                    const urlParams = this.#updateParamsWithValidatedValues(this.#localCache, updateObj, validatedResult, false // use URLSearchParams for URL updates
+                    );
+                    this.#navigateWithParams(urlParams);
+                }
+            }
+        }
+    }
+}
+/**
+ * Creates a simple schema compatible with useSearchParams without requiring external validation libraries.
+ *
+ * This is a lightweight alternative to using full schema validation libraries like Zod, Valibot, or Arktype.
+ * Use this when you need basic type conversion and default values without adding dependencies.
+ *
+ * Limitations:
+ * - For 'array' type: supports basic arrays, but doesn't validate array items
+ * - For 'object' type: supports generic objects, but doesn't validate nested properties
+ * - No custom validation rules or transformations
+ * - No granular reactivity: nested property changes require whole-value reassignment
+ *   (e.g., params.items = [...params.items, newItem] instead of params.items.push(newItem))
+ *
+ * For complex validation needs (nested validation, refined rules, etc.), use a dedicated
+ * validation library instead.
+ *
+ * Example usage:
+ * ```
+ * const productSearchSchema = createSearchParamsSchema({
+ *   // Basic types with defaults
+ *   page: { type: 'number', default: 1 },
+ *   filter: { type: 'string', default: '' },
+ *   sort: { type: 'string', default: 'newest' },
+ *
+ *   // Array type with specific element type
+ *   tags: {
+ *     type: 'array',
+ *     default: ['new'],
+ *     arrayType: '' // Specify string[] type
+ *   },
+ *
+ *   // Object type with specific shape
+ *   config: {
+ *     type: 'object',
+ *     default: { theme: 'light' },
+ *     objectType: { theme: '' } // Specify { theme: string } type
+ *   }
+ * });
+ * ```
+ *
+ * URL storage format:
+ * - Arrays are stored as JSON strings: ?tags=["sale","featured"]
+ * - Objects are stored as JSON strings: ?config={"theme":"dark","fontSize":14}
+ * - Primitive values are stored directly: ?page=2&filter=red
+ */
+export function createSearchParamsSchema(schema) {
+    return {
+        "~standard": {
+            version: 1,
+            vendor: "",
+            validate: (input) => {
+                const output = {};
+                const issues = [];
+                // Set default values first
+                for (const [key, config] of Object.entries(schema)) {
+                    output[key] =
+                        config.default !== undefined ? config.default : null;
+                }
+                if (input && typeof input === "object") {
+                    for (const [key, config] of Object.entries(schema)) {
+                        const inputValue = input[key];
+                        if (inputValue !== undefined) {
+                            try {
+                                switch (config.type) {
+                                    case "number": {
+                                        const num = typeof inputValue === "number" ? inputValue : Number(inputValue);
+                                        if (typeof num !== "number" || !Number.isFinite(num)) {
+                                            issues.push({
+                                                message: `Invalid number for "${key}"`,
+                                                path: [key],
+                                            });
+                                        }
+                                        else {
+                                            output[key] = num;
+                                        }
+                                        break;
+                                    }
+                                    case "boolean": {
+                                        if (typeof inputValue === "boolean" ||
+                                            inputValue === "true" ||
+                                            inputValue === "false") {
+                                            output[key] =
+                                                typeof inputValue === "boolean" ? inputValue : inputValue === "true";
+                                        }
+                                        else {
+                                            issues.push({
+                                                message: `Invalid boolean for "${key}"`,
+                                                path: [key],
+                                            });
+                                        }
+                                        break;
+                                    }
+                                    case "array": {
+                                        if (Array.isArray(inputValue)) {
+                                            output[key] = inputValue;
+                                        }
+                                        else {
+                                            issues.push({
+                                                message: `Invalid array for "${key}"`,
+                                                path: [key],
+                                            });
+                                        }
+                                        break;
+                                    }
+                                    case "object": {
+                                        if (typeof inputValue === "object" &&
+                                            inputValue !== null &&
+                                            !Array.isArray(inputValue)) {
+                                            output[key] = inputValue;
+                                        }
+                                        else {
+                                            issues.push({
+                                                message: `Invalid object for "${key}"`,
+                                                path: [key],
+                                            });
+                                        }
+                                        break;
+                                    }
+                                    case "string":
+                                    default: {
+                                        output[key] = String(inputValue);
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                issues.push({
+                                    message: `Error parsing "${key}": ${e.message}`,
+                                    path: [key],
+                                });
+                            }
+                        }
+                    }
+                }
+                if (issues.length > 0) {
+                    return { issues };
+                }
+                return { value: output };
+            },
+            types: {
+                input: {},
+                output: {},
+            },
+        },
+    };
+}
+/**
+ * A utility function to extract, validate and convert URL search parameters to [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams)
+ *
+ * This function makes it easy to use the same schema validation in
+ * both client-side components (via useSearchParams) and server-side load functions.
+ * Unlike useSearchParams, this function doesn't modify the URL - it only validates
+ * parameters and returns them as a new URLSearchParams object.
+ *
+ * **Important for SvelteKit fine-grained reactivity**: This function only accesses URL parameters
+ * that are defined in your schema, ensuring that load functions only re-run when schema-defined
+ * parameters change, not when any URL parameter changes.
+ *
+ * Handles both standard URL parameters and compressed parameters (when compression is enabled).
+ *
+ * @param url The URL object from SvelteKit load function
+ * @param schema A validation schema (createSearchParamsSchema, Zod, Valibot, etc.)
+ * @param options Optional configuration (like custom compressedParamName)
+ * @returns URLSearchParams object with the validated values
+ *
+ * Example with SvelteKit page or layout load function:
+ * ```ts
+ * import { validateSearchParams } from '../../hooks/useSearchParams.svelte';
+ * import { productSchema } from './schemas';
+ *
+ * export const load = ({ url }) => {
+ *   // Get validated search params as URLSearchParams object
+ *   // Only accesses 'page', 'filter', 'sort' parameters from the URL
+ *   // Load function will only re-run when these specific parameters change
+ *   const searchParams = validateSearchParams(url, productSchema, {
+ *     compressedParamName: '_compressed'
+ *   });
+ *
+ *   // Use URLSearchParams directly with fetch
+ *   const response = await fetch(`/api/products?${searchParams.toString()}`);
+ *   return {
+ *     products: await response.json()
+ *   };
+ * };
+ * ```
+ */
+export function validateSearchParams(url, schema, options = {}) {
+    const compressedParamName = options.compressedParamName || "_data";
+    let validatedValue = {};
+    // Check if we're dealing with compressed data and handle appropriately
+    if (url.searchParams.has(compressedParamName)) {
+        try {
+            // Get and decompress the data
+            const compressedData = url.searchParams.get(compressedParamName) || "";
+            const decompressed = lzString.decompressFromEncodedURIComponent(compressedData);
+            if (decompressed) {
+                try {
+                    // Parse the decompressed JSON
+                    const decompressedObj = JSON.parse(decompressed);
+                    // Validate against schema
+                    const result = schema["~standard"].validate(decompressedObj);
+                    if (result && "value" in result) {
+                        validatedValue = result.value;
+                    }
+                    else {
+                        // Use defaults if validation fails
+                        const emptyResult = schema["~standard"].validate({});
+                        validatedValue = (emptyResult && "value" in emptyResult ? emptyResult.value : {});
+                    }
+                }
+                catch (e) {
+                    console.error("Failed to parse decompressed data", e);
+                    // Use defaults if parsing fails
+                    const emptyResult = schema["~standard"].validate({});
+                    validatedValue = (emptyResult && "value" in emptyResult ? emptyResult.value : {});
+                }
+            }
+            else {
+                // Use defaults if decompression fails
+                const emptyResult = schema["~standard"].validate({});
+                validatedValue = (emptyResult && "value" in emptyResult ? emptyResult.value : {});
+            }
+        }
+        catch (e) {
+            console.error("Error decompressing data", e);
+            // Use defaults if decompression errors
+            const emptyResult = schema["~standard"].validate({});
+            validatedValue = (emptyResult && "value" in emptyResult ? emptyResult.value : {});
+        }
+    }
+    else {
+        // Normal (uncompressed) extraction - use selective extraction for fine-grained reactivity
+        const schemaInfo = extractSchemaInfo(schema);
+        const paramsObject = extractSelectiveParamValues(url.searchParams, schemaInfo.keys, schemaInfo.numberFields);
+        // Validate the parameters against the schema
+        let result = schema["~standard"].validate(paramsObject);
+        if (result instanceof Promise) {
+            throw new Error("Async validation is not supported in validateSearchParams");
+        }
+        if (result && "value" in result) {
+            validatedValue = result.value;
+        }
+        else if (result && "issues" in result) {
+            // If validation fails, use defaults
+            const emptyResult = schema["~standard"].validate({});
+            validatedValue = (emptyResult && "value" in emptyResult ? emptyResult.value : {});
+            // find valid params in the paramsObject and use them, do not override all default values
+            const validParams = Object.fromEntries(Object.entries(paramsObject).filter(([key]) => !result.issues?.some((issue) => issue.path?.includes(key))));
+            validatedValue = { ...validatedValue, ...validParams };
+        }
+    }
+    // Create a new URLSearchParams object with the validated values
+    const newSearchParams = new URLSearchParams();
+    // Helper function to serialize values
+    const serializeValue = (value) => {
+        if (Array.isArray(value)) {
+            return JSON.stringify(value);
+        }
+        else if (typeof value === "object" && value !== null) {
+            return JSON.stringify(value);
+        }
+        else {
+            return String(value);
+        }
+    };
+    // Add each validated parameter to the URLSearchParams
+    for (const [key, value] of Object.entries(validatedValue)) {
+        if (value === undefined || value === null)
+            continue;
+        const stringValue = serializeValue(value);
+        newSearchParams.set(key, stringValue);
+    }
+    return {
+        searchParams: newSearchParams,
+        data: validatedValue,
+    };
+}
+/**
+ * Hook to create a reactive search params object with property access
+ *
+ * This client-side hook automatically updates the URL when parameters change.
+ * It provides type-safe access to URL search parameters through direct property access.
+ *
+ * @param schema A validation schema compatible with StandardSchemaV1
+ * @param options Configuration options that affect URL behavior
+ * @returns A reactive object for working with typed search parameters
+ *
+ * Available options:
+ * - `showDefaults` (boolean): When true, parameters with default values will be shown in the URL.
+ *   When false (default), parameters with default values will be omitted from the URL.
+ * - `debounce` (number): Milliseconds to delay URL updates when parameters change.
+ *   Useful to avoid cluttering browser history when values change rapidly (default: 0, no debounce).
+ * - `pushHistory` (boolean): Controls whether URL updates create new browser history entries.
+ *   If true (default), each update adds a new entry to the browser history.
+ *   If false, updates replace the current URL without creating new history entries.
+ * - `compress` (boolean): When true, all parameters are compressed into a single parameter
+ *   using lz-string compression. This helps reduce URL length and provides basic obfuscation (default: false).
+ *   Use validateSearchParams with the same compressedParamName option when handling compressed URLs server-side.
+ * - `compressedParamName` (string): The name of the parameter used to store compressed data
+ *   when compression is enabled. Customize this to avoid conflicts with parameters in your schema.
+ *   Default is '_data'.
+ * - `updateURL` (boolean): When true (default), the URL is updated when parameters change.
+ *   When false, only in-memory parameters are updated.
+ *
+ * Example with Zod:
+ * ```
+ * import { z } from 'zod';
+ *
+ * const productSearchSchema = z.object({
+ *   page: z.number().catch(1),
+ *   filter: z.string().catch(''),
+ *   sort: z.enum(['newest', 'oldest', 'price']).catch('newest'),
+ * });
+ *
+ * const params = useSearchParams(productSearchSchema);
+ *
+ * // Access parameters directly
+ * const page = $derived(params.page); // number (defaults to 1)
+ * const sort = $derived(params.sort); // 'newest' | 'oldest' | 'price'
+ *
+ * // Update parameters directly
+ * params.page = 2; // Updates URL to include ?page=2
+ * params.sort = 'price'; // Updates URL to include &sort=price
+ * ```
+ *
+ * Example with options:
+ * ```typescript
+ * // Show default values in URL, debounce updates by 300ms,
+ * // don't create new history entries, and compress params
+ * const params = useSearchParams(schema, {
+ *   showDefaults: true,
+ *   debounce: 300,
+ *   pushHistory: false,
+ *   compress: true,
+ *   compressedParamName: '_compressed' // Custom name to avoid conflicts
+ * });
+ *
+ * // Great for binding to input fields (updates URL without cluttering history)
+ * <input type="text" bind:value={params.search} />
+ * // Resulting URL will be something like: /?_compressed=N4IgDgTg9g...
+ * ```
+ * Example with Valibot:
+ * ```
+ * import * as v from 'valibot';
+ *
+ * const productSearchSchema = v.object({
+ *   page: v.optional(v.fallback(v.number(), 1), 1),
+ *   filter: v.optional(v.fallback(v.string(), ''), ''),
+ *   sort: v.optional(v.fallback(v.picklist(['newest', 'oldest', 'price']), 'newest'), 'newest'),
+ * });
+ *
+ * const params = useSearchParams(productSearchSchema);
+ * ``` * Example with Arktype:
+ * ```
+ * import { type } from 'arktype';
+ *
+ * const productSearchSchema = type({
+ *   page: 'number = 1',
+ *   filter: 'string = ""',
+ *   sort: '"newest" | "oldest" | "price" = "newest"',
+ * });
+ *
+ * const params = useSearchParams(productSearchSchema);
+ * ```
+ * Or with our built-in schema creator (no additional dependencies):
+ *
+ * ```
+ * const productSearchSchema = createSearchParamsSchema({
+ *   page: { type: 'number', default: 1 },
+ *   filter: { type: 'string', default: '' },
+ *   sort: { type: 'string', default: 'newest' }
+ * });
+ *
+ * const params = useSearchParams(productSearchSchema);
+ * ```
+ */
+export function useSearchParams(schema, options = {}) {
+    // Create the SearchParams instance to handle validation and URL updates
+    // This is the core class that implements the actual functionality
+    const searchParams = new SearchParams(schema, options);
+    // Wait for hydration to complete before executing browser-specific initialization
+    const isMounted = new IsMounted();
+    // Only run initialization logic after hydration is complete
+    $effect(() => {
+        if (!isMounted.current || !browser || building)
+            return;
+        // Remove incorrect params on initialization (only after hydration)
+        if (options.updateURL !== false) {
+            const schemaInfo = extractSchemaInfo(schema);
+            const currentParams = extractParamValues(page.url.searchParams, schemaInfo.numberFields);
+            const validationResult = schema["~standard"].validate(currentParams);
+            if (validationResult &&
+                "issues" in validationResult &&
+                Array.isArray(validationResult.issues) &&
+                validationResult.issues.length > 0) {
+                // Find all incorrect param keys
+                const invalidKeys = validationResult.issues
+                    .map((issue) => Array.isArray(issue.path) && issue.path.length > 0 ? issue.path[0] : null)
+                    .filter(Boolean);
+                if (invalidKeys.length > 0) {
+                    const newSearchParams = new URLSearchParams(page.url.searchParams.toString());
+                    for (const key of invalidKeys) {
+                        newSearchParams.delete(String(key));
+                    }
+                    goto("?" + newSearchParams.toString(), { replaceState: true });
+                }
+            }
+        }
+        // If showDefaults is true, we need to initialize the URL with all default values (only after hydration)
+        if (options.showDefaults) {
+            // Get all the schema information in one pass
+            const schemaInfo = extractSchemaInfo(schema);
+            if (schemaInfo.keys.length > 0) {
+                // If compression is enabled, use SearchParams.update() method which handles compression
+                if (options.compress) {
+                    // Call the update method with the default values to properly handle compression
+                    searchParams.update(schemaInfo.defaultValues);
+                }
+                else {
+                    // For non-compressed mode, use the original approach
+                    const currentParams = extractParamValues(page.url.searchParams, schemaInfo.numberFields);
+                    const newSearchParams = new URLSearchParams(page.url.searchParams.toString());
+                    let needsUpdate = false;
+                    // For each default value, add it to the URL if not already present
+                    for (const [key, defaultValue] of Object.entries(schemaInfo.defaultValues)) {
+                        // Skip if the parameter is already in the URL (don't override user values)
+                        if (key in currentParams)
+                            continue;
+                        needsUpdate = true;
+                        if (defaultValue === null || defaultValue === undefined) {
+                            continue;
+                        }
+                        let stringValue;
+                        if (Array.isArray(defaultValue)) {
+                            stringValue = JSON.stringify(defaultValue);
+                        }
+                        else if (typeof defaultValue === "object" && defaultValue !== null) {
+                            stringValue = JSON.stringify(defaultValue);
+                        }
+                        else {
+                            stringValue = String(defaultValue);
+                        }
+                        newSearchParams.set(key, stringValue);
+                    }
+                    // Only update the URL if we added parameters
+                    if (needsUpdate) {
+                        // Always use replaceState: true for initialization to avoid creating a new history entry
+                        // Don't use debouncing for initialization as this is a one-time operation
+                        goto("?" + newSearchParams.toString(), { replaceState: true });
+                    }
+                }
+            }
+        }
+    });
+    // Only run this logic in the browser and if debounce is enabled
+    if (browser && !building && options.debounce && options.debounce > 0) {
+        $effect(() => {
+            // This effect runs once when the hook is initialized within a component.
+            // It has no dependencies, so it doesn't re-run.
+            return () => {
+                searchParams.cleanup();
+            };
+        });
+    }
+    // Create a proxy to intercept property access/assignment
+    // This enables the direct property syntax: params.page instead of params.get('page')
+    // The proxy pattern is what makes the API feel natural and type-safe
+    //
+    // IMPORTANT LIMITATION: This proxy only provides top-level reactivity
+    // - Direct property access works: params.page, params.filter
+    // - Nested property changes require whole-object updates: params.fields = {...fields, newProp: value}
+    // - Arrays/objects are not granularly reactive: params.items[0].name = 'new' won't trigger URL updates
+    //
+    // For granular nested reactivity, you would need:
+    // 1. Recursive proxy creation for nested objects/arrays
+    // 2. Path tracking system (e.g., "fields.0.name")
+    // 3. Granular URL serialization instead of JSON
+    // 4. Complete rewrite of validation and type systems
+    // This would be a breaking change requiring a new major version
+    const handler = {
+        get: (target, prop) => {
+            // Special methods we want to expose directly with proper binding
+            if (prop === "reset") {
+                // We need to handle each method individually to satisfy TypeScript
+                return function (showDefaults) {
+                    return target.reset(showDefaults);
+                };
+            }
+            else if (prop === "update") {
+                return function (values) {
+                    return target.update(values);
+                };
+            }
+            else if (prop === "cleanup") {
+                return function () {
+                    return target.cleanup();
+                };
+            }
+            else if (prop === "toURLSearchParams") {
+                // Implementation of toURLSearchParams
+                return function () {
+                    const newSearchParams = new URLSearchParams();
+                    // Get the schema's default values + current values
+                    const validationResult = schema["~standard"].validate({});
+                    if (validationResult && "value" in validationResult) {
+                        const schemaValues = validationResult.value;
+                        // Create an object with all the values from the schema
+                        // First set the default values
+                        const allValues = { ...schemaValues };
+                        // Then override with the current values from the proxy
+                        // This ensures we get the most up-to-date values that might not yet be in the URL or in-memory store
+                        for (const key of Object.keys(schemaValues)) {
+                            // Get the current value using the proxy's access
+                            if (typeof key === "string" && target.has(key)) {
+                                const currentValue = target.get(key);
+                                if (currentValue !== undefined) {
+                                    allValues[key] = currentValue;
+                                }
+                            }
+                        }
+                        // Add each parameter to the URLSearchParams
+                        for (const [key, value] of Object.entries(allValues)) {
+                            // Skip undefined/null values
+                            if (value === undefined || value === null) {
+                                continue;
+                            }
+                            // Serialize the value
+                            let stringValue;
+                            if (Array.isArray(value)) {
+                                stringValue = JSON.stringify(value);
+                            }
+                            else if (typeof value === "object" && value !== null) {
+                                stringValue = JSON.stringify(value);
+                            }
+                            else {
+                                stringValue = String(value);
+                            }
+                            // Set the parameter
+                            newSearchParams.set(key, stringValue);
+                        }
+                    }
+                    return newSearchParams;
+                };
+            }
+            // IMPORTANT: We use the has() method to determine if this is a schema parameter
+            // This is why the has() method must be maintained
+            if (typeof prop === "string" && target.has(prop)) {
+                // Type assertion needed here because TypeScript can't infer that our runtime check
+                // with target.has() guarantees that prop is a valid key of our schema output type
+                // NOTE: This returns the raw value (object/array/primitive) without nested proxification
+                // If the value is an object or array, changes to its nested properties won't trigger
+                // URL updates automatically. Users must reassign the entire object/array to trigger updates:
+                // ❌ Won't work: params.config.theme = 'dark'
+                // ✅ Works: params.config = {...params.config, theme: 'dark'}
+                // ❌ Won't work: params.items.push(newItem)
+                // ✅ Works: params.items = [...params.items, newItem]
+                return target.get(prop);
+            }
+            return Reflect.get(target, prop);
+        },
+        set: (target, prop, value) => {
+            // Similar to get(), we use has() to determine if this is a schema parameter
+            if (typeof prop === "string" && target.has(prop)) {
+                // Same type assertion needed here to tell TypeScript that we've verified
+                // this string is a valid key in our schema through the target.has() check
+                // NOTE: This triggers a complete re-serialization of the value to the URL
+                // For objects/arrays, the entire structure is JSON-stringified and stored
+                // This is why nested property mutations don't work - they don't trigger this setter
+                // Only direct assignment to the top-level property triggers URL updates
+                target.set(prop, value);
+                return true;
+            }
+            return Reflect.set(target, prop, value);
+        },
+    };
+    return new Proxy(searchParams, handler);
+}

tools/ui/node_modules/runed/dist/utilities/use-throttle/index.d.ts

@@ -0,0 +1 @@
+export * from "./use-throttle.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-throttle/index.js

@@ -0,0 +1 @@
+export * from "./use-throttle.svelte.js";

tools/ui/node_modules/runed/dist/utilities/use-throttle/use-throttle.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { MaybeGetter } from "../../internal/types.js";
+type UseThrottleReturn<Args extends unknown[], Return> = ((this: unknown, ...args: Args) => Promise<Return>) & {
+    cancel: () => void;
+    pending: boolean;
+};
+export declare function useThrottle<Args extends unknown[], Return>(callback: (...args: Args) => Return, interval?: MaybeGetter<number>): UseThrottleReturn<Args, Return>;
+export {};

tools/ui/node_modules/runed/dist/utilities/use-throttle/use-throttle.svelte.js

@@ -0,0 +1,82 @@
+import { untrack } from "svelte";
+export function useThrottle(callback, interval = 250) {
+    let lastCall = 0;
+    let timeout = $state();
+    let resolve = null;
+    let reject = null;
+    let promise = null;
+    function reset() {
+        timeout = undefined;
+        promise = null;
+        resolve = null;
+        reject = null;
+    }
+    function throttled(...args) {
+        return untrack(() => {
+            const now = Date.now();
+            const intervalValue = typeof interval === "function" ? interval() : interval;
+            const nextAllowedTime = lastCall + intervalValue;
+            if (!promise) {
+                promise = new Promise((res, rej) => {
+                    resolve = res;
+                    reject = rej;
+                });
+            }
+            if (now < nextAllowedTime) {
+                if (!timeout) {
+                    timeout = setTimeout(async () => {
+                        try {
+                            const result = await callback.apply(this, args);
+                            resolve?.(result);
+                        }
+                        catch (error) {
+                            reject?.(error);
+                        }
+                        finally {
+                            clearTimeout(timeout);
+                            reset();
+                            lastCall = Date.now();
+                        }
+                    }, nextAllowedTime - now);
+                }
+                return promise;
+            }
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+            lastCall = now;
+            try {
+                const result = callback.apply(this, args);
+                resolve?.(result);
+            }
+            catch (error) {
+                reject?.(error);
+            }
+            finally {
+                reset();
+            }
+            return promise;
+        });
+    }
+    throttled.cancel = async () => {
+        if (timeout) {
+            if (timeout === undefined) {
+                // Wait one event loop to see if something triggered the throttled function
+                await new Promise((resolve) => setTimeout(resolve, 0));
+                if (timeout === undefined)
+                    return;
+            }
+            clearTimeout(timeout);
+            reject?.("Cancelled");
+            reset();
+        }
+    };
+    Object.defineProperty(throttled, "pending", {
+        enumerable: true,
+        get() {
+            return !!timeout;
+        },
+    });
+    return throttled;
+}

tools/ui/node_modules/runed/dist/utilities/watch/index.d.ts

@@ -0,0 +1 @@
+export * from "./watch.svelte.js";

tools/ui/node_modules/runed/dist/utilities/watch/index.js

@@ -0,0 +1 @@
+export * from "./watch.svelte.js";

tools/ui/node_modules/runed/dist/utilities/watch/watch.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { Getter } from "../../internal/types.js";
+export type WatchOptions = {
+    /**
+     * If `true`, the effect doesn't run until one of the `sources` changes.
+     *
+     * @default false
+     */
+    lazy?: boolean;
+};
+export declare function watch<T extends Array<unknown>>(sources: {
+    [K in keyof T]: Getter<T[K]>;
+}, effect: (values: T, previousValues: {
+    [K in keyof T]: T[K] | undefined;
+}) => void | VoidFunction, options?: WatchOptions): void;
+export declare function watch<T>(source: Getter<T>, effect: (value: T, previousValue: T | undefined) => void | VoidFunction, options?: WatchOptions): void;
+export declare namespace watch {
+    var pre: typeof watchPre;
+}
+declare function watchPre<T extends Array<unknown>>(sources: {
+    [K in keyof T]: Getter<T[K]>;
+}, effect: (values: T, previousValues: {
+    [K in keyof T]: T[K] | undefined;
+}) => void | VoidFunction, options?: WatchOptions): void;
+declare function watchPre<T>(source: Getter<T>, effect: (value: T, previousValue: T | undefined) => void | VoidFunction, options?: WatchOptions): void;
+export declare function watchOnce<T extends Array<unknown>>(sources: {
+    [K in keyof T]: Getter<T[K]>;
+}, effect: (values: T, previousValues: T) => void | VoidFunction): void;
+export declare function watchOnce<T>(source: Getter<T>, effect: (value: T, previousValue: T) => void | VoidFunction): void;
+export declare namespace watchOnce {
+    var pre: typeof watchOncePre;
+}
+declare function watchOncePre<T extends Array<unknown>>(sources: {
+    [K in keyof T]: Getter<T[K]>;
+}, effect: (values: T, previousValues: T) => void | VoidFunction): void;
+declare function watchOncePre<T>(source: Getter<T>, effect: (value: T, previousValue: T) => void | VoidFunction): void;
+export {};

tools/ui/node_modules/runed/dist/utilities/watch/watch.svelte.js

@@ -0,0 +1,69 @@
+import { untrack } from "svelte";
+function runEffect(flush, effect) {
+    switch (flush) {
+        case "post":
+            $effect(effect);
+            break;
+        case "pre":
+            $effect.pre(effect);
+            break;
+    }
+}
+function runWatcher(sources, flush, effect, options = {}) {
+    const { lazy = false } = options;
+    // Run the effect immediately if `lazy` is `false`.
+    let active = !lazy;
+    // On the first run, if the dependencies are an array, pass an empty array
+    // to the previous value instead of `undefined` to allow destructuring.
+    //
+    // watch(() => [a, b], ([a, b], [prevA, prevB]) => { ... });
+    let previousValues = Array.isArray(sources)
+        ? []
+        : undefined;
+    runEffect(flush, () => {
+        const values = Array.isArray(sources) ? sources.map((source) => source()) : sources();
+        if (!active) {
+            active = true;
+            previousValues = values;
+            return;
+        }
+        const cleanup = untrack(() => effect(values, previousValues));
+        previousValues = values;
+        return cleanup;
+    });
+}
+function runWatcherOnce(sources, flush, effect) {
+    const cleanupRoot = $effect.root(() => {
+        let stop = false;
+        runWatcher(sources, flush, (values, previousValues) => {
+            if (stop) {
+                cleanupRoot();
+                return;
+            }
+            // Since `lazy` is `true`, `previousValues` is always defined.
+            const cleanup = effect(values, previousValues);
+            stop = true;
+            return cleanup;
+        }, 
+        // Running the effect immediately just once makes no sense at all.
+        // That's just `onMount` with extra steps.
+        { lazy: true });
+    });
+    $effect(() => {
+        return cleanupRoot;
+    });
+}
+export function watch(sources, effect, options) {
+    runWatcher(sources, "post", effect, options);
+}
+function watchPre(sources, effect, options) {
+    runWatcher(sources, "pre", effect, options);
+}
+watch.pre = watchPre;
+export function watchOnce(source, effect) {
+    runWatcherOnce(source, "post", effect);
+}
+function watchOncePre(source, effect) {
+    runWatcherOnce(source, "pre", effect);
+}
+watchOnce.pre = watchOncePre;

tools/ui/node_modules/runed/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "runed",
+  "version": "0.35.1",
+  "type": "module",
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "keywords": [
+    "svelte",
+    "svelte5",
+    "sveltekit",
+    "svelte utilities",
+    "svelte helpers",
+    "sveltekit utilities",
+    "sveltekit helpers",
+    "svelte 5 runes",
+    "runes",
+    "typescript"
+  ],
+  "contributors": [
+    {
+      "name": "Thomas G. Lopes",
+      "url": "https://thomasglopes.com"
+    },
+    {
+      "name": "Hunter Johnston",
+      "url": "https://x.com/huntabyte"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/svecosystem/runed",
+    "directory": "packages/runed"
+  },
+  "funding": [
+    "https://github.com/sponsors/huntabyte",
+    "https://github.com/sponsors/tglide"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./kit": {
+      "types": "./dist/kit/index.d.ts",
+      "svelte": "./dist/kit/index.js",
+      "default": "./dist/kit/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "peerDependencies": {
+    "svelte": "^5.7.0",
+    "@sveltejs/kit": "^2.21.0"
+  },
+  "peerDependenciesMeta": {
+    "@sveltejs/kit": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.55.0",
+    "@sveltejs/kit": "^2.42.0",
+    "@sveltejs/package": "^2.3.0",
+    "@sveltejs/vite-plugin-svelte": "^6.2.0",
+    "@testing-library/dom": "^10.2.0",
+    "@testing-library/jest-dom": "^6.4.6",
+    "@testing-library/svelte": "^5.2.0",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/node": "^20.19.16",
+    "@vitest/browser": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
+    "jsdom": "^24.0.0",
+    "msw": "^2.7.0",
+    "playwright": "^1.55.0",
+    "publint": "^0.1.9",
+    "resize-observer-polyfill": "^1.5.1",
+    "svelte": "^5.39.3",
+    "svelte-check": "^4.3.1",
+    "tslib": "^2.4.1",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.5",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "dequal": "^2.0.3",
+    "esm-env": "^1.0.0",
+    "lz-string": "^1.5.0"
+  },
+  "scripts": {
+    "dev": "pnpm sync && pnpm watch",
+    "build": "pnpm package",
+    "package": "svelte-kit sync && svelte-package && publint",
+    "test": "vitest --run && playwright test",
+    "test:watch": "vitest --watch",
+    "test:ui": "vitest --watch --ui",
+    "test:integration": "playwright test",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "watch": "svelte-kit sync && svelte-package --watch"
+  }
+}

tools/ui/node_modules/rw/.eslintrc

@@ -0,0 +1,5 @@
+env:
+    node: true
+
+extends:
+    "eslint:recommended"

tools/ui/node_modules/rw/.npmignore

@@ -0,0 +1,3 @@
+.DS_Store
+node_modules
+test/input.txt

tools/ui/node_modules/rw/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2014-2016, Michael Bostock
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* The name Michael Bostock may not be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL MICHAEL BOSTOCK BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tools/ui/node_modules/rw/README.md

@@ -0,0 +1,120 @@
+# rw - Now stdin and stdout are files.
+
+How do you read a file from stdin? If you thought,
+
+```js
+var contents = fs.readFileSync("/dev/stdin", "utf8");
+```
+
+you’d be wrong, because Node only reads up to the size of the file reported by fs.stat rather than reading until it receives an EOF. So, if you redirect a file to your program (`cat file | program`), you’ll only read the first 65,536 bytes of your file. Oops.
+
+What about writing a file to stdout? If you thought,
+
+```js
+fs.writeFileSync("/dev/stdout", contents, "utf8");
+```
+
+you’d also be wrong, because this tries to close stdout, so you get this error:
+
+```
+Error: UNKNOWN, unknown error
+    at Object.fs.writeSync (fs.js:528:18)
+    at Object.fs.writeFileSync (fs.js:975:21)
+```
+
+(Also, this doesn’t work on Windows, because Windows doesn’t support /dev/stdout, /dev/stdin and /dev/stderr!)
+
+Shucks. So what should you do?
+
+You could use a different pattern for reading from stdin:
+
+```js
+var chunks = [];
+
+process.stdin
+    .on("data", function(chunk) { chunks.push(chunk); })
+    .on("end", function() { console.log(chunks.join("").length); })
+    .setEncoding("utf8");
+```
+
+But that’s a pain, since now your code has two different code paths for reading inputs depending on whether you’re reading a real file or stdin. And the code gets even more complex if you want to [read that file synchronously](https://github.com/mbostock/rw/blob/master/lib/rw/read-file-sync.js).
+
+You could also try a different pattern for writing to stdout:
+
+```js
+process.stdout.write(contents);
+```
+
+Or even:
+
+```js
+console.log(contents);
+```
+
+But if you try to pipe your output to `head`, you’ll get this error:
+
+```
+Error: write EPIPE
+    at errnoException (net.js:904:11)
+    at Object.afterWrite (net.js:720:19)
+```
+
+Huh.
+
+The **rw** module fixes these problems. It provides an interface just like readFile, readFileSync, writeFile and writeFileSync, but with implementations that work the way you expect on stdin and stdout. If you use these methods on files other than /dev/stdin or /dev/stdout, they simply delegate to the fs methods, so you can trust that they behave identically to the methods you’re used to.
+
+For example, now you can read stdin synchronously like so:
+
+```js
+var contents = rw.readFileSync("/dev/stdin", "utf8");
+```
+
+Or to write to stdout:
+
+```js
+rw.writeFileSync("/dev/stdout", contents, "utf8");
+```
+
+And rw automatically squashes EPIPE errors, so you can pipe the output of your program to `head` and you won’t get a spurious stack trace.
+
+To install, `npm install rw`.
+
+### Note
+
+If you want to read synchronously from stdin using [readFileSync](#readFileSync), you cannot also use process.stdin in the same program. Likewise, if you want to write synchronously to stdout or stderr using [writeFileSync](#writeFileSync), you cannot use process.stdout or process.stderr, respectively. (This includes using console.log and the like!) Failure to heed this warning may result in error: EAGAIN, resource temporarily unavailable. Unfortunately, it does not appear possible for this library to fix this issue automatically, so please use caution.
+
+Only the asynchronous methods [readFile](#readFile) and [writeFile](#writeFile) are supported on Windows. Node has no synchronous API for reading from process.[stdin](https://nodejs.org/api/process.html#process_process_stdin) or writing to process.[stdout](https://nodejs.org/api/process.html#process_process_stdout) or process.[stderr](https://nodejs.org/api/process.html#process_process_stderr), so you’re out of luck!
+
+## API Reference
+
+<a name="readFile" href="#readFile">#</a> rw.<b>readFile</b>(<i>path</i>[, <i>options</i>], <i>callback</i>)
+
+Reads the file at the specified *path* completely into memory, invoking the specified *callback* once the data is available and the file is closed. The *callback* is invoked with two arguments: the *error* that occurred during read (hopefully null), and the read data. If *options* is a string, it specifies the encoding to use, in which case the read data will be a string; otherwise *options* is an object, and may specify encoding and flag properties. This method is a drop-in replacement for [fs.readFile](https://nodejs.org/api/fs.html#fs_fs_readfile_file_options_callback) and fixes the behavior of special files such as /dev/stdin.
+
+<a name="readFileSync" href="#readFileSync">#</a> rw.<b>readFileSync</b>(<i>path</i>[, <i>options</i>])
+
+Reads the file at the specified *path* completely into memory, synchronously, returning the data. If an error occurred during read, this function throws an error instead. If *options* is a string, it specifies the encoding to use, in which case the read data will be a string; otherwise *options* is an object, and may specify encoding and flag properties. This method is a drop-in replacement for [fs.readFileSync](https://nodejs.org/api/fs.html#fs_fs_readfilesync_file_options) and fixes the behavior of special files such as /dev/stdin.
+
+<a name="writeFile" href="#writeFile">#</a> rw.<b>writeFile</b>(<i>path</i>, <i>data</i>[, <i>options</i>], <i>callback</i>)
+
+Writes the specified *data* (completely in memory) to a file at the specified *path*, invoking the specified *callback* once the data is completely written and the file is closed. The *callback* is invoked with a single argument: the *error* that occurred during write (hopefully null). If *options* is a string, it specifies the encoding to use, in which case the *data* must be a string; otherwise *options* is an object, and may specify encoding, mode and flag properties. This method is a drop-in replacement for [fs.writeFile](https://nodejs.org/api/fs.html#fs_fs_writefile_file_data_options_callback) and fixes the behavior of special files such as /dev/stdout.
+
+<a name="writeFileSync" href="#writeFileSync">#</a> rw.<b>writeFileSync</b>(<i>path</i>, <i>data</i>[, <i>options</i>])
+
+Writes the specified *data* (completely in memory) to a file at the specified *path*, synchronously, returning once the data is completely written and the file is closed. Throws an *error* if one occurs during write. If *options* is a string, it specifies the encoding to use, in which case the *data* must be a string; otherwise *options* is an object, and may specify encoding, mode and flag properties. This method is a drop-in replacement for [fs.writeFileSync](https://nodejs.org/api/fs.html#fs_fs_writefilesync_file_data_options) and fixes the behavior of special files such as /dev/stdout.
+
+<a name="dash_readFile" href="#dash_readFile">#</a> rw.dash.<b>readFile</b>(<i>path</i>[, <i>options</i>], <i>callback</i>)
+
+Equivalent to [rw.readFile](#readFile), except treats a *path* of `-` as `/dev/stdin`. Useful for command-line arguments.
+
+<a name="dash_readFileSync" href="#dash_readFileSync">#</a> rw.dash.<b>readFileSync</b>(<i>path</i>[, <i>options</i>])
+
+Equivalent to [rw.readFileSync](#readFileSync), except treats a *path* of `-` as `/dev/stdin`. Useful for command-line arguments.
+
+<a name="dash_writeFile" href="#dash_writeFile">#</a> rw.dash.<b>writeFile</b>(<i>path</i>, <i>data</i>[, <i>options</i>], <i>callback</i>)
+
+Equivalent to [rw.writeFile](#writeFile), except treats a *path* of `-` as `/dev/stdout`. Useful for command-line arguments.
+
+<a name="dash_writeFileSync" href="#dash_writeFileSync">#</a> rw.dash.<b>writeFileSync</b>(<i>path</i>, <i>data</i>[, <i>options</i>])
+
+Equivalent to [rw.writeFileSync](#writeFileSync), except treats a *path* of `-` as `/dev/stdout`. Useful for command-line arguments.

tools/ui/node_modules/rw/index.js

@@ -0,0 +1,5 @@
+exports.dash = require("./lib/rw/dash");
+exports.readFile = require("./lib/rw/read-file");
+exports.readFileSync = require("./lib/rw/read-file-sync");
+exports.writeFile = require("./lib/rw/write-file");
+exports.writeFileSync = require("./lib/rw/write-file-sync");

tools/ui/node_modules/rw/lib/rw/dash.js

@@ -0,0 +1,14 @@
+var slice = Array.prototype.slice;
+
+function dashify(method, file) {
+  return function(path) {
+    var argv = arguments;
+    if (path == "-") (argv = slice.call(argv)).splice(0, 1, file);
+    return method.apply(null, argv);
+  };
+}
+
+exports.readFile = dashify(require("./read-file"), "/dev/stdin");
+exports.readFileSync = dashify(require("./read-file-sync"), "/dev/stdin");
+exports.writeFile = dashify(require("./write-file"), "/dev/stdout");
+exports.writeFileSync = dashify(require("./write-file-sync"), "/dev/stdout");

tools/ui/node_modules/rw/lib/rw/decode.js

@@ -0,0 +1,23 @@
+module.exports = function(options) {
+  if (options) {
+    if (typeof options === "string") return encoding(options);
+    if (options.encoding !== null) return encoding(options.encoding);
+  }
+  return identity();
+};
+
+function identity() {
+  var chunks = [];
+  return {
+    push: function(chunk) { chunks.push(chunk); },
+    value: function() { return Buffer.concat(chunks); }
+  };
+}
+
+function encoding(encoding) {
+  var chunks = [];
+  return {
+    push: function(chunk) { chunks.push(chunk); },
+    value: function() { return Buffer.concat(chunks).toString(encoding); }
+  };
+}

tools/ui/node_modules/rw/lib/rw/encode.js

@@ -0,0 +1,7 @@
+module.exports = function(data, options) {
+  return typeof data === "string"
+      ? new Buffer(data, typeof options === "string" ? options
+          : options && options.encoding !== null ? options.encoding
+          : "utf8")
+      : data;
+};

tools/ui/node_modules/rw/lib/rw/read-file-sync.js

@@ -0,0 +1,29 @@
+var fs = require("fs"),
+    decode = require("./decode");
+
+module.exports = function(filename, options) {
+  if (fs.statSync(filename).isFile()) {
+    return fs.readFileSync(filename, options);
+  } else {
+    var fd = fs.openSync(filename, options && options.flag || "r"),
+        decoder = decode(options);
+
+    while (true) { // eslint-disable-line no-constant-condition
+      try {
+        var buffer = new Buffer(bufferSize),
+            bytesRead = fs.readSync(fd, buffer, 0, bufferSize);
+      } catch (e) {
+        if (e.code === "EOF") break;
+        fs.closeSync(fd);
+        throw e;
+      }
+      if (bytesRead === 0) break;
+      decoder.push(buffer.slice(0, bytesRead));
+    }
+
+    fs.closeSync(fd);
+    return decoder.value();
+  }
+};
+
+var bufferSize = 1 << 16;

tools/ui/node_modules/rw/lib/rw/read-file.js

@@ -0,0 +1,23 @@
+var fs = require("fs"),
+    decode = require("./decode");
+
+module.exports = function(path, options, callback) {
+  if (arguments.length < 3) callback = options, options = null;
+
+  switch (path) {
+    case "/dev/stdin": return readStream(process.stdin, options, callback);
+  }
+
+  fs.stat(path, function(error, stat) {
+    if (error) return callback(error);
+    if (stat.isFile()) return fs.readFile(path, options, callback);
+    readStream(fs.createReadStream(path, options ? {flags: options.flag || "r"} : {}), options, callback); // N.B. flag / flags
+  });
+};
+
+function readStream(stream, options, callback) {
+  var decoder = decode(options);
+  stream.on("error", callback);
+  stream.on("data", function(d) { decoder.push(d); });
+  stream.on("end", function() { callback(null, decoder.value()); });
+}

tools/ui/node_modules/rw/lib/rw/write-file-sync.js

@@ -0,0 +1,32 @@
+var fs = require("fs"),
+    encode = require("./encode");
+
+module.exports = function(filename, data, options) {
+  var stat;
+
+  try {
+    stat = fs.statSync(filename);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+
+  if (!stat || stat.isFile()) {
+    fs.writeFileSync(filename, data, options);
+  } else {
+    var fd = fs.openSync(filename, options && options.flag || "w"),
+        bytesWritten = 0,
+        bytesTotal = (data = encode(data, options)).length;
+
+    while (bytesWritten < bytesTotal) {
+      try {
+        bytesWritten += fs.writeSync(fd, data, bytesWritten, bytesTotal - bytesWritten, null);
+      } catch (error) {
+        if (error.code === "EPIPE") break; // ignore broken pipe, e.g., | head
+        fs.closeSync(fd);
+        throw error;
+      }
+    }
+
+    fs.closeSync(fd);
+  }
+};

tools/ui/node_modules/rw/lib/rw/write-file.js

@@ -0,0 +1,22 @@
+var fs = require("fs"),
+    encode = require("./encode");
+
+module.exports = function(path, data, options, callback) {
+  if (arguments.length < 4) callback = options, options = null;
+
+  switch (path) {
+    case "/dev/stdout": return writeStream(process.stdout, "write", data, options, callback);
+    case "/dev/stderr": return writeStream(process.stderr, "write", data, options, callback);
+  }
+
+  fs.stat(path, function(error, stat) {
+    if (error && error.code !== "ENOENT") return callback(error);
+    if (stat && stat.isFile()) return fs.writeFile(path, data, options, callback);
+    writeStream(fs.createWriteStream(path, options ? {flags: options.flag || "w"} : {}), "end", data, options, callback); // N.B. flag / flags
+  });
+};
+
+function writeStream(stream, send, data, options, callback) {
+  stream.on("error", function(error) { callback(error.code === "EPIPE" ? null : error); }); // ignore broken pipe, e.g., | head
+  stream[send](encode(data, options), function(error) { callback(error && error.code === "EPIPE" ? null : error); });
+}

tools/ui/node_modules/rw/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "rw",
+  "version": "1.3.3",
+  "description": "Now stdin and stdout are files.",
+  "keywords": [
+    "fs",
+    "readFile",
+    "writeFile",
+    "stdin",
+    "stdout"
+  ],
+  "homepage": "https://github.com/mbostock/rw",
+  "license": "BSD-3-Clause",
+  "author": {
+    "name": "Mike Bostock",
+    "url": "http://bost.ocks.org/mike"
+  },
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/mbostock/rw.git"
+  },
+  "scripts": {
+    "test": "test/run-tests && eslint index.js lib",
+    "prepublish": "npm test",
+    "postpublish": "git push && git push --tags"
+  },
+  "devDependencies": {
+    "d3-queue": "3",
+    "eslint": "3"
+  }
+}

tools/ui/node_modules/rw/test/cat-async

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+var rw = require("../").dash;
+
+rw.readFile(process.argv[2] || "-", "utf8", function(error, contents) {
+  if (error) throw error;
+  rw.writeFile("-", contents, "utf8", function(error) {
+    if (error) throw error;
+  });
+});

tools/ui/node_modules/rw/test/cat-sync

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+var rw = require("../").dash;
+
+rw.writeFileSync("-", rw.readFileSync(process.argv[2] || "-", "utf8"), "utf8");