@vizejs/composable 0.426.3 → 0.428.0

package/dist/use-cookie.d.mts

@@ -0,0 +1,196 @@
+import { InjectionKey, Ref, ShallowRef } from "vue";
+
+//#region src/use-cookie.d.ts
+/** `SameSite` attribute values. */
+type CookieSameSite = "lax" | "strict" | "none";
+/** Attributes written with a cookie (RFC 6265bis). */
+interface CookieAttributes {
+  /**
+   * `Path` attribute.
+   *
+   * @default "/" when written by {@link useCookie}; omitted by {@link serializeCookie}
+   */
+  readonly path?: string;
+  /**
+   * `Domain` attribute.
+   *
+   * @default omitted (host-only cookie)
+   */
+  readonly domain?: string;
+  /**
+   * `Max-Age` in integer seconds; `0` or less expires the cookie.
+   *
+   * @default omitted (session cookie)
+   */
+  readonly maxAge?: number;
+  /**
+   * `Expires` date.
+   *
+   * @default omitted (session cookie)
+   */
+  readonly expires?: Date;
+  /**
+   * `SameSite` policy. `"none"` requires `secure`.
+   *
+   * @default omitted (browser default, usually lax)
+   */
+  readonly sameSite?: CookieSameSite;
+  /**
+   * `Secure` flag.
+   *
+   * @default false
+   */
+  readonly secure?: boolean;
+  /**
+   * `HttpOnly` flag. Only honored by server adapters: browsers ignore
+   * cookies with this flag written through `document.cookie`.
+   *
+   * @default false
+   */
+  readonly httpOnly?: boolean;
+  /**
+   * `Partitioned` flag (CHIPS). Requires `secure`.
+   *
+   * @default false
+   */
+  readonly partitioned?: boolean;
+}
+/**
+ * Parse a `Cookie` request header (or `document.cookie`) into name/value
+ * pairs. Values are percent-decoded; the first occurrence of a name wins,
+ * matching how browsers order more specific cookies first. Pure and
+ * SSR-safe.
+ *
+ * @param header Raw header value.
+ * @returns Cookie values by name.
+ */
+declare function parseCookieHeader(header: string): Record<string, string>;
+/**
+ * Serialize one cookie as a `Set-Cookie` header value (also accepted by
+ * `document.cookie`). The value is percent-encoded so any string is safe.
+ *
+ * @param name Cookie name; must be an RFC 6265 token.
+ * @param value Unencoded cookie value.
+ * @param attributes Cookie attributes.
+ * @default attributes {}
+ * @throws {TypeError} `[VIZE_COMPOSE_COOKIE_INVALID_NAME]`,
+ * `[VIZE_COMPOSE_COOKIE_INVALID_DOMAIN]`, `[VIZE_COMPOSE_COOKIE_INVALID_PATH]`,
+ * or `[VIZE_COMPOSE_COOKIE_REQUIRES_SECURE]` for malformed attributes.
+ * @throws {RangeError} `[VIZE_COMPOSE_COOKIE_INVALID_MAX_AGE]` or
+ * `[VIZE_COMPOSE_COOKIE_INVALID_EXPIRES]` for invalid lifetimes.
+ * @returns The serialized cookie.
+ */
+declare function serializeCookie(name: string, value: string, attributes?: CookieAttributes): string;
+/**
+ * Request/response bridge used by {@link useCookie}.
+ *
+ * On the server, `read` returns the incoming `Cookie` header and `write`
+ * appends a `Set-Cookie` header to the response. In the browser the default
+ * adapter reads and writes `document.cookie`.
+ */
+interface CookieAdapter {
+  /** Return the current `Cookie` header (`name=value; …`). */
+  readonly read: () => string;
+  /** Persist one serialized cookie (a `Set-Cookie` header value). */
+  readonly write: (setCookie: string) => void;
+}
+/** Injection key for an app- or subtree-wide {@link CookieAdapter}. */
+declare const COOKIE_ADAPTER_KEY: InjectionKey<CookieAdapter>;
+/**
+ * Provide a {@link CookieAdapter} to descendant components (for example the
+ * request/response pair of a server render). Must be called during setup;
+ * use `app.provide(COOKIE_ADAPTER_KEY, adapter)` for a whole app.
+ *
+ * @param adapter Adapter used by descendants' {@link useCookie} calls.
+ */
+declare function provideCookieAdapter(adapter: CookieAdapter): void;
+/** Converts a cookie value to and from its string form. */
+interface CookieSerializer<Value> {
+  /** Decode the percent-decoded cookie value. Throwing selects the default. */
+  readonly read: (raw: string) => Value;
+  /** Encode a value; the result is percent-encoded when written. */
+  readonly write: (value: Value) => string;
+}
+/** Stable failure codes reported by {@link useCookie}. */
+type CookieErrorCode = "read-failed" | "invalid-value" | "write-failed";
+/** Failure observed while synchronizing a cookie. */
+interface CookieFailure {
+  /** Which synchronization step failed. */
+  readonly code: CookieErrorCode;
+  /** Cookie name involved in the failure. */
+  readonly name: string;
+  /** Exact thrown value, or the rejected candidate for `"invalid-value"`. */
+  readonly cause: unknown;
+}
+/** Options for {@link useCookie}. */
+interface UseCookieOptions<Value> extends CookieAttributes {
+  /**
+   * Value used when the cookie is absent or unreadable. Also selects the
+   * serializer: strings are stored raw, everything else as JSON.
+   *
+   * @default undefined (the state is `string | undefined`)
+   */
+  readonly default?: Value;
+  /**
+   * Explicit serializer.
+   *
+   * @default raw strings for string defaults, JSON otherwise
+   */
+  readonly serializer?: CookieSerializer<Value>;
+  /**
+   * Validation hook applied to every decoded value.
+   *
+   * @default a check that the value has the default's kind
+   */
+  readonly validate?: (candidate: unknown) => candidate is Value;
+  /**
+   * Request/response adapter. Takes precedence over an injected adapter.
+   *
+   * @default the injected adapter, else `document.cookie` in browsers
+   */
+  readonly adapter?: CookieAdapter | null;
+  /**
+   * Observe failures. Failures never throw out of the composable.
+   *
+   * @default undefined
+   */
+  readonly onError?: (failure: CookieFailure) => void;
+}
+/** Reactive state and controls returned by {@link useCookie}. */
+interface CookieControls<Value> {
+  /** Writable cookie value; assignments write the cookie. */
+  readonly state: Ref<Value>;
+  /**
+   * Whether an adapter is attached. With the implicit `document.cookie`
+   * adapter inside a component it stays `false` until mounted, matching a
+   * server render without an adapter.
+   */
+  readonly supported: Readonly<Ref<boolean>>;
+  /** Most recent failure, cleared by the next success. */
+  readonly error: Readonly<ShallowRef<CookieFailure | undefined>>;
+  /** Re-read the cookie from the adapter. */
+  readonly refresh: () => void;
+  /** Expire the cookie and restore the default value. */
+  readonly remove: () => void;
+}
+/**
+ * Read and write one cookie with a typed default.
+ *
+ * @typeParam Value Cookie value type, inferred from `default`.
+ * @param name Cookie name.
+ * @param options Default, serializer, validation, attributes, and adapter.
+ * @returns The typed cookie value and its controls.
+ */
+declare function useCookie<Value>(name: string, options: UseCookieOptions<Value> & {
+  readonly default: Value;
+}): CookieControls<Value>;
+/**
+ * Read and write one raw string cookie; absent cookies are `undefined`.
+ *
+ * @param name Cookie name.
+ * @param options Attributes and adapter.
+ * @returns The cookie string and its controls.
+ */
+declare function useCookie(name: string, options?: UseCookieOptions<string>): CookieControls<string | undefined>;
+//#endregion
+export { COOKIE_ADAPTER_KEY, CookieAdapter, CookieAttributes, CookieControls, CookieErrorCode, CookieFailure, CookieSameSite, CookieSerializer, UseCookieOptions, parseCookieHeader, provideCookieAdapter, serializeCookie, useCookie };

package/dist/use-cookie.mjs

@@ -0,0 +1,259 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { useMounted } from "./use-mounted.mjs";
+import { computed, hasInjectionContext, inject, provide, shallowRef, watch } from "vue";
+//#region src/use-cookie.ts
+const TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const DOMAIN = /^\.?[0-9A-Za-z]([0-9A-Za-z-]*[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]*[0-9A-Za-z])?)*$/;
+const UNSAFE_PATH = /[\u0000-\u001f\u007f;]/;
+function decode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Parse a `Cookie` request header (or `document.cookie`) into name/value
+* pairs. Values are percent-decoded; the first occurrence of a name wins,
+* matching how browsers order more specific cookies first. Pure and
+* SSR-safe.
+*
+* @param header Raw header value.
+* @returns Cookie values by name.
+*/
+function parseCookieHeader(header) {
+	const cookies = /* @__PURE__ */ new Map();
+	for (const part of header.split(";")) {
+		const separator = part.indexOf("=");
+		if (separator === -1) continue;
+		const name = part.slice(0, separator).trim();
+		if (name === "" || cookies.has(name)) continue;
+		let value = part.slice(separator + 1).trim();
+		if (value.length >= 2 && value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+		cookies.set(name, decode(value));
+	}
+	return Object.fromEntries(cookies);
+}
+/**
+* Serialize one cookie as a `Set-Cookie` header value (also accepted by
+* `document.cookie`). The value is percent-encoded so any string is safe.
+*
+* @param name Cookie name; must be an RFC 6265 token.
+* @param value Unencoded cookie value.
+* @param attributes Cookie attributes.
+* @default attributes {}
+* @throws {TypeError} `[VIZE_COMPOSE_COOKIE_INVALID_NAME]`,
+* `[VIZE_COMPOSE_COOKIE_INVALID_DOMAIN]`, `[VIZE_COMPOSE_COOKIE_INVALID_PATH]`,
+* or `[VIZE_COMPOSE_COOKIE_REQUIRES_SECURE]` for malformed attributes.
+* @throws {RangeError} `[VIZE_COMPOSE_COOKIE_INVALID_MAX_AGE]` or
+* `[VIZE_COMPOSE_COOKIE_INVALID_EXPIRES]` for invalid lifetimes.
+* @returns The serialized cookie.
+*/
+function serializeCookie(name, value, attributes = {}) {
+	if (!TOKEN.test(name)) throw new TypeError(`[VIZE_COMPOSE_COOKIE_INVALID_NAME] cookie names must be RFC 6265 tokens; received ${JSON.stringify(name)}`);
+	let cookie = `${name}=${encodeURIComponent(value)}`;
+	if (attributes.maxAge !== void 0) {
+		if (!Number.isSafeInteger(attributes.maxAge)) throw new RangeError(`[VIZE_COMPOSE_COOKIE_INVALID_MAX_AGE] maxAge must be an integer number of seconds; received ${String(attributes.maxAge)}`);
+		cookie += `; Max-Age=${String(attributes.maxAge)}`;
+	}
+	if (attributes.expires !== void 0) {
+		if (Number.isNaN(attributes.expires.getTime())) throw new RangeError("[VIZE_COMPOSE_COOKIE_INVALID_EXPIRES] expires must be a valid Date");
+		cookie += `; Expires=${attributes.expires.toUTCString()}`;
+	}
+	if (attributes.domain !== void 0) {
+		if (!DOMAIN.test(attributes.domain)) throw new TypeError(`[VIZE_COMPOSE_COOKIE_INVALID_DOMAIN] invalid cookie domain ${JSON.stringify(attributes.domain)}`);
+		cookie += `; Domain=${attributes.domain}`;
+	}
+	if (attributes.path !== void 0) {
+		if (UNSAFE_PATH.test(attributes.path)) throw new TypeError(`[VIZE_COMPOSE_COOKIE_INVALID_PATH] cookie paths cannot contain ';' or control characters; received ${JSON.stringify(attributes.path)}`);
+		cookie += `; Path=${attributes.path}`;
+	}
+	const secure = attributes.secure ?? false;
+	if ((attributes.sameSite === "none" || attributes.partitioned === true) && !secure) throw new TypeError("[VIZE_COMPOSE_COOKIE_REQUIRES_SECURE] SameSite=None and Partitioned cookies must be Secure");
+	if (attributes.sameSite !== void 0) {
+		const sameSite = attributes.sameSite;
+		cookie += `; SameSite=${sameSite === "lax" ? "Lax" : sameSite === "strict" ? "Strict" : "None"}`;
+	}
+	if (secure) cookie += "; Secure";
+	if (attributes.httpOnly === true) cookie += "; HttpOnly";
+	if (attributes.partitioned === true) cookie += "; Partitioned";
+	return cookie;
+}
+/** Injection key for an app- or subtree-wide {@link CookieAdapter}. */
+const COOKIE_ADAPTER_KEY = Symbol("vize:cookie-adapter");
+/**
+* Provide a {@link CookieAdapter} to descendant components (for example the
+* request/response pair of a server render). Must be called during setup;
+* use `app.provide(COOKIE_ADAPTER_KEY, adapter)` for a whole app.
+*
+* @param adapter Adapter used by descendants' {@link useCookie} calls.
+*/
+function provideCookieAdapter(adapter) {
+	provide(COOKIE_ADAPTER_KEY, adapter);
+}
+function browserAdapter() {
+	if (typeof window === "undefined") return void 0;
+	const document = window.document;
+	return {
+		read: () => document.cookie,
+		write: (setCookie) => {
+			document.cookie = setCookie;
+		}
+	};
+}
+function sameKind(defaults, candidate) {
+	if (defaults === null || defaults === void 0) return true;
+	if (Array.isArray(defaults)) return Array.isArray(candidate);
+	if (typeof defaults === "object") return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+	return typeof candidate === typeof defaults;
+}
+const rawCodec = {
+	read: (raw) => raw,
+	write: (value) => String(value)
+};
+const jsonCodec = {
+	read: (raw) => JSON.parse(raw),
+	write: (value) => JSON.stringify(value)
+};
+/**
+* Synchronize a typed reactive value with one cookie, on the server and in
+* the browser.
+*
+* The adapter is resolved from `options.adapter`, then from
+* {@link COOKIE_ADAPTER_KEY} (see {@link provideCookieAdapter}), then from
+* `document.cookie` in browsers. During a server render with an adapter the
+* value comes from the request `Cookie` header and assignments emit
+* `Set-Cookie` headers through `adapter.write`, so server and client render
+* the same value and hydrate without a mismatch. Without any adapter (plain
+* SSR) the default is used and nothing is written.
+*
+* String defaults are stored raw; other defaults as JSON checked by
+* `validate` (by default: same kind as the default). Assigning `undefined`
+* (or calling `remove`) expires the cookie. Cookies are written with
+* `Path=/` unless `path` is given. Failures never throw; they are exposed
+* through `error` and `onError`. The write watcher stops with the owning
+* reactive scope.
+*
+* @example
+* ```ts
+* // server entry: app.provide(COOKIE_ADAPTER_KEY, { read: () => req.headers.cookie ?? "",
+* //   write: (value) => res.appendHeader("Set-Cookie", value) });
+* const { state: locale } = useCookie("locale", { default: "en", maxAge: 31_536_000 });
+* ```
+*
+* @param name Cookie name (an RFC 6265 token).
+* @param options Default, serializer, validation, attributes, and adapter.
+* @default options {}
+* @returns The synchronized value and its controls.
+*/
+function useCookie(name, options = {}) {
+	const injected = hasInjectionContext() ? inject(COOKIE_ADAPTER_KEY, void 0) : void 0;
+	const adapter = options.adapter === void 0 ? injected ?? browserAdapter() : options.adapter ?? void 0;
+	const fallback = options.default;
+	const codec = options.serializer ?? (fallback === void 0 || typeof fallback === "string" ? rawCodec : jsonCodec);
+	const validate = options.validate ?? ((candidate) => sameKind(fallback, candidate));
+	const state = shallowRef(fallback);
+	const error = shallowRef(void 0);
+	const mounted = options.adapter === void 0 && injected === void 0 && hasInjectionContext() ? useMounted() : void 0;
+	const supported = computed(() => (mounted?.value ?? true) && adapter !== void 0);
+	const attributes = {
+		path: "/",
+		...options.domain === void 0 ? {} : { domain: options.domain },
+		...options.path === void 0 ? {} : { path: options.path },
+		...options.maxAge === void 0 ? {} : { maxAge: options.maxAge },
+		...options.expires === void 0 ? {} : { expires: options.expires },
+		...options.sameSite === void 0 ? {} : { sameSite: options.sameSite },
+		...options.secure === void 0 ? {} : { secure: options.secure },
+		...options.httpOnly === void 0 ? {} : { httpOnly: options.httpOnly },
+		...options.partitioned === void 0 ? {} : { partitioned: options.partitioned }
+	};
+	let syncedRaw;
+	const fail = (code, cause) => {
+		const failure = {
+			code,
+			name,
+			cause
+		};
+		error.value = failure;
+		options.onError?.(failure);
+	};
+	let applying = false;
+	const assign = (value, raw) => {
+		syncedRaw = raw;
+		applying = true;
+		try {
+			state.value = value;
+		} finally {
+			applying = false;
+		}
+	};
+	const refresh = () => {
+		if (adapter === void 0) return;
+		let raw;
+		try {
+			raw = parseCookieHeader(adapter.read())[name];
+		} catch (cause) {
+			fail("read-failed", cause);
+			return;
+		}
+		if (raw === void 0) {
+			assign(fallback, void 0);
+			return;
+		}
+		let candidate;
+		try {
+			candidate = codec.read(raw);
+		} catch (cause) {
+			fail("read-failed", cause);
+			assign(fallback, raw);
+			return;
+		}
+		if (!validate(candidate)) {
+			fail("invalid-value", candidate);
+			assign(fallback, raw);
+			return;
+		}
+		error.value = void 0;
+		assign(candidate, raw);
+	};
+	const writeCookie = (value) => {
+		if (adapter === void 0) return;
+		try {
+			if (value === void 0) {
+				adapter.write(serializeCookie(name, "", {
+					...attributes,
+					maxAge: 0,
+					expires: /* @__PURE__ */ new Date(0)
+				}));
+				syncedRaw = void 0;
+			} else {
+				const raw = codec.write(value);
+				if (raw === syncedRaw) return;
+				adapter.write(serializeCookie(name, raw, attributes));
+				syncedRaw = raw;
+			}
+		} catch (cause) {
+			fail("write-failed", cause);
+			return;
+		}
+		error.value = void 0;
+	};
+	refresh();
+	const stopWrite = watch(state, (value) => {
+		if (!applying) writeCookie(value);
+	}, { flush: "sync" });
+	const remove = () => {
+		writeCookie(void 0);
+		assign(fallback, void 0);
+	};
+	tryOnScopeDispose(stopWrite);
+	return {
+		state,
+		supported,
+		error,
+		refresh,
+		remove
+	};
+}
+//#endregion
+export { COOKIE_ADAPTER_KEY, parseCookieHeader, provideCookieAdapter, serializeCookie, useCookie };

package/dist/use-countdown.d.mts

@@ -0,0 +1,85 @@
+import { n as IntervalScheduler, r as PausableControls } from "./use-interval-BA55gTHT.mjs";
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/use-countdown.d.ts
+/** Options for {@link useCountdown}. */
+interface UseCountdownOptions {
+  /**
+   * Milliseconds between two decrements. Reactive.
+   *
+   * @default 1000
+   */
+  readonly intervalMs?: MaybeRefOrGetter<number>;
+  /**
+   * Start counting down as soon as the composable is created.
+   *
+   * @default false
+   */
+  readonly immediate?: boolean;
+  /**
+   * Invoked after every decrement with the remaining count.
+   *
+   * @default undefined
+   */
+  readonly onTick?: (remaining: number) => void;
+  /**
+   * Invoked once when the count reaches zero.
+   *
+   * @default undefined
+   */
+  readonly onComplete?: () => void;
+  /**
+   * Starts host timers when no browser `window` is available.
+   *
+   * @default false
+   */
+  readonly runOnServer?: boolean;
+  /**
+   * Repeating timer host.
+   *
+   * @default globalThis timer functions
+   */
+  readonly scheduler?: IntervalScheduler;
+}
+/** State and controls returned by {@link useCountdown}. */
+interface CountdownControls extends PausableControls {
+  /** Remaining whole ticks; never negative. */
+  readonly remaining: Readonly<ShallowRef<number>>;
+  /** Whether the countdown reached zero. */
+  readonly isComplete: ComputedRef<boolean>;
+  /**
+   * Reset to `count` (default: the initial count) and start ticking.
+   *
+   * @param count Replacement starting count.
+   */
+  readonly start: (count?: number) => void;
+  /** Pause and reset to `count` (default: the initial count). */
+  readonly reset: (count?: number) => void;
+  /** Pause and jump to zero without firing `onComplete`. */
+  readonly stop: () => void;
+}
+/**
+ * Count down from a number of ticks to zero.
+ *
+ * Builds on {@link useIntervalFn}: pause/resume keep the remaining count,
+ * `start` and `reset` restore it, and the timer pauses itself at zero after
+ * calling `onComplete`. The initial count is reactive only for later
+ * `start()`/`reset()` calls without an argument. Server rendering is
+ * hydration-stable (no timer, remaining stays at the initial count).
+ *
+ * @example
+ * ```ts
+ * const { remaining, start } = useCountdown(60, { onComplete: resendAvailable });
+ * start();
+ * ```
+ *
+ * @param initialCount Reactive starting count in ticks.
+ * @param options Cadence, callbacks, and scheduler policy.
+ * @default options {}
+ * @throws `RangeError` tagged `VIZE_COMPOSE_COUNTDOWN_INVALID_COUNT` when a
+ * count is negative or not finite.
+ * @returns Remaining count, completion flag, and controls.
+ */
+declare function useCountdown(initialCount: MaybeRefOrGetter<number>, options?: UseCountdownOptions): CountdownControls;
+//#endregion
+export { CountdownControls, UseCountdownOptions, useCountdown };

package/dist/use-countdown.mjs

@@ -0,0 +1,74 @@
+import { useIntervalFn } from "./use-interval.mjs";
+import { computed, shallowRef, toValue } from "vue";
+//#region src/use-countdown.ts
+function resolveCount(value) {
+	if (!Number.isFinite(value) || value < 0) throw new RangeError(`[VIZE_COMPOSE_COUNTDOWN_INVALID_COUNT] count must be finite and at least zero; received ${String(value)}`);
+	return Math.trunc(value);
+}
+/**
+* Count down from a number of ticks to zero.
+*
+* Builds on {@link useIntervalFn}: pause/resume keep the remaining count,
+* `start` and `reset` restore it, and the timer pauses itself at zero after
+* calling `onComplete`. The initial count is reactive only for later
+* `start()`/`reset()` calls without an argument. Server rendering is
+* hydration-stable (no timer, remaining stays at the initial count).
+*
+* @example
+* ```ts
+* const { remaining, start } = useCountdown(60, { onComplete: resendAvailable });
+* start();
+* ```
+*
+* @param initialCount Reactive starting count in ticks.
+* @param options Cadence, callbacks, and scheduler policy.
+* @default options {}
+* @throws `RangeError` tagged `VIZE_COMPOSE_COUNTDOWN_INVALID_COUNT` when a
+* count is negative or not finite.
+* @returns Remaining count, completion flag, and controls.
+*/
+function useCountdown(initialCount, options = {}) {
+	const remaining = shallowRef(resolveCount(toValue(initialCount)));
+	const isComplete = computed(() => remaining.value === 0);
+	const interval = useIntervalFn(() => {
+		if (remaining.value === 0) return;
+		remaining.value -= 1;
+		options.onTick?.(remaining.value);
+		if (remaining.value === 0) {
+			interval.pause();
+			options.onComplete?.();
+		}
+	}, options.intervalMs ?? 1e3, {
+		immediate: false,
+		runOnServer: options.runOnServer ?? false,
+		...options.scheduler === void 0 ? {} : { scheduler: options.scheduler }
+	});
+	const reset = (count) => {
+		interval.pause();
+		remaining.value = resolveCount(count ?? toValue(initialCount));
+	};
+	const start = (count) => {
+		reset(count);
+		if (remaining.value > 0) interval.resume();
+	};
+	const stop = () => {
+		interval.pause();
+		remaining.value = 0;
+	};
+	const resume = () => {
+		if (remaining.value > 0) interval.resume();
+	};
+	if ((options.immediate ?? false) && remaining.value > 0) interval.resume();
+	return {
+		isActive: interval.isActive,
+		pause: interval.pause,
+		resume,
+		remaining,
+		isComplete,
+		start,
+		reset,
+		stop
+	};
+}
+//#endregion
+export { useCountdown };