@vizejs/composable 0.426.3 → 0.427.0

package/dist/use-web-authn.mjs

@@ -0,0 +1,323 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { computed, hasInjectionContext, readonly, ref, shallowRef, toValue, unref, watchPostEffect } from "vue";
+//#region src/use-web-authn.ts
+const transports = [
+	"usb",
+	"nfc",
+	"ble",
+	"hybrid",
+	"internal"
+];
+function isTransport(value) {
+	return transports.includes(value);
+}
+function isAttachment(value) {
+	return value === "platform" || value === "cross-platform";
+}
+/**
+* Encode bytes as unpadded base64url.
+*
+* @param bytes Buffer or view to encode.
+* @returns Base64url text without `=` padding.
+*/
+function encodeBase64Url(bytes) {
+	const view = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let binary = "";
+	for (const byte of view) binary += String.fromCharCode(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+}
+/**
+* Decode base64url (padded or unpadded) into bytes.
+*
+* @param text Base64url text.
+* @throws `TypeError` tagged `VIZE_COMPOSE_WEBAUTHN_INVALID_BASE64URL` for malformed input.
+* @returns Decoded bytes.
+*/
+function decodeBase64Url(text) {
+	const body = text.replace(/=+$/u, "");
+	if (!/^[\w-]*$/u.test(body) || body.length % 4 === 1) throw new TypeError(`[VIZE_COMPOSE_WEBAUTHN_INVALID_BASE64URL] invalid base64url input`);
+	const binary = atob(body.replaceAll("-", "+").replaceAll("_", "/"));
+	const bytes = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+	return bytes;
+}
+function parseDescriptors(list) {
+	return list.map((descriptor) => ({
+		type: descriptor.type,
+		id: decodeBase64Url(descriptor.id),
+		...descriptor.transports ? { transports: [...descriptor.transports] } : {}
+	}));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parsePrfValues(value) {
+	if (!isRecord(value)) return value;
+	return {
+		...value,
+		...typeof value.first === "string" ? { first: decodeBase64Url(value.first) } : {},
+		...typeof value.second === "string" ? { second: decodeBase64Url(value.second) } : {}
+	};
+}
+function parseExtensions(extensions) {
+	const prf = extensions.prf;
+	if (!isRecord(prf)) return { ...extensions };
+	const byCredential = prf.evalByCredential;
+	return {
+		...extensions,
+		prf: {
+			...prf,
+			...prf.eval === void 0 ? {} : { eval: parsePrfValues(prf.eval) },
+			...isRecord(byCredential) ? { evalByCredential: Object.fromEntries(Object.entries(byCredential).map(([id, values]) => [id, parsePrfValues(values)])) } : {}
+		}
+	};
+}
+function serializeExtensionValue(value) {
+	if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return encodeBase64Url(value);
+	if (Array.isArray(value)) return value.map(serializeExtensionValue);
+	if (isRecord(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, serializeExtensionValue(entry)]));
+	return value;
+}
+function serializeExtensions(results) {
+	return serializeExtensionValue(results);
+}
+/**
+* Convert server creation-options JSON into binary options for `create`.
+*
+* @param json Options with base64url `challenge`, `user.id`, and credential ids.
+* @throws `TypeError` tagged `VIZE_COMPOSE_WEBAUTHN_INVALID_BASE64URL` for malformed fields.
+* @returns Binary creation options.
+*/
+function parseCreationOptionsFromJSON(json) {
+	const { excludeCredentials, authenticatorSelection, hints, extensions, ...rest } = json;
+	return {
+		...rest,
+		rp: { ...json.rp },
+		user: {
+			...json.user,
+			id: decodeBase64Url(json.user.id)
+		},
+		challenge: decodeBase64Url(json.challenge),
+		pubKeyCredParams: json.pubKeyCredParams.map((parameter) => ({ ...parameter })),
+		...excludeCredentials ? { excludeCredentials: parseDescriptors(excludeCredentials) } : {},
+		...authenticatorSelection ? { authenticatorSelection: { ...authenticatorSelection } } : {},
+		...hints ? { hints: [...hints] } : {},
+		...extensions ? { extensions: parseExtensions(extensions) } : {}
+	};
+}
+/**
+* Convert server request-options JSON into binary options for `get`.
+*
+* @param json Options with base64url `challenge` and credential ids.
+* @throws `TypeError` tagged `VIZE_COMPOSE_WEBAUTHN_INVALID_BASE64URL` for malformed fields.
+* @returns Binary request options.
+*/
+function parseRequestOptionsFromJSON(json) {
+	const { allowCredentials, hints, extensions, ...rest } = json;
+	return {
+		...rest,
+		challenge: decodeBase64Url(json.challenge),
+		...allowCredentials ? { allowCredentials: parseDescriptors(allowCredentials) } : {},
+		...hints ? { hints: [...hints] } : {},
+		...extensions ? { extensions: parseExtensions(extensions) } : {}
+	};
+}
+/**
+* Serialize a registration credential into JSON-safe base64url fields.
+*
+* @param credential Credential resolved by `create`.
+* @returns Server-ready registration response.
+*/
+function serializeRegistrationCredential(credential) {
+	const { response } = credential;
+	const publicKey = response.getPublicKey?.() ?? null;
+	const authenticatorData = response.getAuthenticatorData?.();
+	const algorithm = response.getPublicKeyAlgorithm?.();
+	const known = response.getTransports?.().filter(isTransport);
+	return {
+		id: credential.id,
+		rawId: encodeBase64Url(credential.rawId),
+		type: "public-key",
+		...isAttachment(credential.authenticatorAttachment) ? { authenticatorAttachment: credential.authenticatorAttachment } : {},
+		clientExtensionResults: serializeExtensions(credential.getClientExtensionResults()),
+		response: {
+			clientDataJSON: encodeBase64Url(response.clientDataJSON),
+			attestationObject: encodeBase64Url(response.attestationObject),
+			...known ? { transports: known } : {},
+			...publicKey ? { publicKey: encodeBase64Url(publicKey) } : {},
+			...algorithm === void 0 ? {} : { publicKeyAlgorithm: algorithm },
+			...authenticatorData ? { authenticatorData: encodeBase64Url(authenticatorData) } : {}
+		}
+	};
+}
+/**
+* Serialize an authentication credential into JSON-safe base64url fields.
+*
+* @param credential Credential resolved by `get`.
+* @returns Server-ready authentication response.
+*/
+function serializeAuthenticationCredential(credential) {
+	const { response } = credential;
+	return {
+		id: credential.id,
+		rawId: encodeBase64Url(credential.rawId),
+		type: "public-key",
+		...isAttachment(credential.authenticatorAttachment) ? { authenticatorAttachment: credential.authenticatorAttachment } : {},
+		clientExtensionResults: serializeExtensions(credential.getClientExtensionResults()),
+		response: {
+			clientDataJSON: encodeBase64Url(response.clientDataJSON),
+			authenticatorData: encodeBase64Url(response.authenticatorData),
+			signature: encodeBase64Url(response.signature),
+			...response.userHandle ? { userHandle: encodeBase64Url(response.userHandle) } : {}
+		}
+	};
+}
+function hasResponseField(value, field) {
+	if (typeof value !== "object" || value === null || !("response" in value)) return false;
+	const { response } = value;
+	return typeof response === "object" && response !== null && field in response;
+}
+function isRegistrationCredential(value) {
+	return hasResponseField(value, "attestationObject");
+}
+function isAuthenticationCredential(value) {
+	return hasResponseField(value, "signature");
+}
+function isStatics(candidate) {
+	return typeof candidate === "function";
+}
+function browserStatics() {
+	if (typeof window === "undefined") return void 0;
+	const candidate = Reflect.get(window, "PublicKeyCredential");
+	return isStatics(candidate) ? candidate : void 0;
+}
+function browserCredentials() {
+	if (browserStatics() === void 0) return void 0;
+	const container = window.navigator.credentials;
+	if (!container) return void 0;
+	return {
+		create: (options) => container.create(options),
+		get: (options) => container.get(options)
+	};
+}
+function isJSONOptions(input) {
+	return typeof input.challenge === "string";
+}
+function errorName(error) {
+	return typeof error === "object" && error !== null && "name" in error ? error.name : void 0;
+}
+/**
+* Register and authenticate passkeys with the Web Authentication API.
+*
+* `create` and `get` accept binary options or server JSON, run one ceremony
+* at a time (starting one aborts the previous), and resolve to a
+* discriminated {@link WebAuthnResult}. Use the exported pure helpers to
+* serialize results for the server. A pending ceremony is aborted when the
+* owning reactive scope stops; outside a scope call `abort()`.
+*
+* Server rendering: nothing is requested, `supported` and `pending` are false.
+*
+* @example
+* ```ts
+* const webAuthn = useWebAuthn();
+* const result = await webAuthn.get(await fetchJSON("/login/options"));
+* if (result.status === "success") await post(serializeAuthenticationCredential(result.credential));
+* ```
+*
+* @param options Capability hosts.
+* @default options {}
+* @returns Ceremony state and actions.
+*/
+function useWebAuthn(options = {}) {
+	const pending = ref(false);
+	const error = shallowRef(void 0);
+	let controller;
+	const hydrated = shallowRef(!hasInjectionContext());
+	if (!hydrated.value) watchPostEffect(() => {
+		hydrated.value = true;
+	});
+	const resolveCredentials = () => !hydrated.value ? void 0 : options.credentials === void 0 ? browserCredentials() : toValue(options.credentials) ?? void 0;
+	const resolveStatics = () => !hydrated.value ? void 0 : options.publicKeyCredential === void 0 ? browserStatics() : unref(options.publicKeyCredential) ?? void 0;
+	const abort = (reason) => {
+		const current = controller;
+		controller = void 0;
+		pending.value = false;
+		current?.abort(reason);
+	};
+	const run = async (ceremony, invoke, guard) => {
+		const host = resolveCredentials();
+		if (!host) return {
+			status: "unsupported",
+			error: void 0
+		};
+		abort();
+		const own = new AbortController();
+		controller = own;
+		const external = ceremony.signal;
+		const forward = () => own.abort(external?.reason);
+		if (external?.aborted) forward();
+		else external?.addEventListener("abort", forward, { once: true });
+		pending.value = true;
+		error.value = void 0;
+		try {
+			const value = await invoke(host, {
+				signal: own.signal,
+				...ceremony.mediation ? { mediation: ceremony.mediation } : {}
+			});
+			if (own.signal.aborted) return {
+				status: "aborted",
+				error: own.signal.reason
+			};
+			if (!guard(value)) throw new TypeError("[VIZE_COMPOSE_WEBAUTHN_NO_CREDENTIAL] no credential");
+			return {
+				status: "success",
+				credential: value
+			};
+		} catch (cause) {
+			if (own.signal.aborted || errorName(cause) === "AbortError") return {
+				status: "aborted",
+				error: cause
+			};
+			error.value = cause;
+			return {
+				status: errorName(cause) === "NotAllowedError" ? "not-allowed" : "failed",
+				error: cause
+			};
+		} finally {
+			external?.removeEventListener("abort", forward);
+			if (controller === own) {
+				controller = void 0;
+				pending.value = false;
+			}
+		}
+	};
+	const create = (input, ceremony = {}) => run(ceremony, (host, request) => host.create({
+		...request,
+		publicKey: isJSONOptions(input) ? parseCreationOptionsFromJSON(input) : input
+	}), isRegistrationCredential);
+	const get = (input, ceremony = {}) => run(ceremony, (host, request) => host.get({
+		...request,
+		publicKey: isJSONOptions(input) ? parseRequestOptionsFromJSON(input) : input
+	}), isAuthenticationCredential);
+	const check = async (key) => {
+		const statics = resolveStatics();
+		try {
+			return await statics?.[key]?.call(statics) === true;
+		} catch {
+			return false;
+		}
+	};
+	tryOnScopeDispose(() => abort());
+	return {
+		supported: computed(() => resolveCredentials() !== void 0),
+		pending: readonly(pending),
+		error: readonly(error),
+		create,
+		get,
+		abort,
+		isUserVerifyingPlatformAuthenticatorAvailable: () => check("isUserVerifyingPlatformAuthenticatorAvailable"),
+		isConditionalMediationAvailable: () => check("isConditionalMediationAvailable")
+	};
+}
+//#endregion
+export { decodeBase64Url, encodeBase64Url, parseCreationOptionsFromJSON, parseRequestOptionsFromJSON, serializeAuthenticationCredential, serializeRegistrationCredential, useWebAuthn };

package/dist/use-web-locks.d.mts

@@ -0,0 +1,180 @@
+import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
+
+//#region src/use-web-locks.d.ts
+/** Lock modes defined by the Web Locks API. */
+type WebLockMode = "exclusive" | "shared";
+/** Granted lock handed to a request callback. */
+interface WebLockLike {
+  /** Lock name. */
+  readonly name: string;
+  /** Granted mode. */
+  readonly mode: WebLockMode;
+}
+/** One entry of a lock manager snapshot. */
+interface WebLockInfo {
+  /** Lock name. */
+  readonly name?: string | undefined;
+  /** Requested or granted mode. */
+  readonly mode?: WebLockMode | undefined;
+  /** Identifier of the client holding or requesting the lock. */
+  readonly clientId?: string | undefined;
+}
+/** Snapshot returned by {@link WebLocksControls.query}. */
+interface WebLocksSnapshot {
+  /** Locks currently held by any client of the origin. */
+  readonly held: readonly WebLockInfo[];
+  /** Requests currently waiting for a lock. */
+  readonly pending: readonly WebLockInfo[];
+}
+/** Options forwarded to `LockManager.request`. */
+interface WebLockManagerRequestOptions {
+  /** Requested mode. */
+  readonly mode: WebLockMode;
+  /**
+   * Only grant the lock when it is immediately available.
+   *
+   * @default false
+   */
+  readonly ifAvailable?: boolean;
+  /**
+   * Release any held lock of the same name and grant this request.
+   *
+   * @default false
+   */
+  readonly steal?: boolean;
+  /**
+   * Abort the request while it is pending.
+   *
+   * @default undefined
+   */
+  readonly signal?: AbortSignal;
+}
+/** Minimal `LockManager` (`navigator.locks`) consumed by {@link useWebLocks}. */
+interface LockManagerLike {
+  /** Request a lock and run `callback` while it is held. */
+  request(name: string, options: WebLockManagerRequestOptions, callback: (lock: WebLockLike | null) => unknown): Promise<unknown>;
+  /** Snapshot the origin's held and pending locks. */
+  query(): Promise<{
+    /** Held locks. */readonly held?: readonly WebLockInfo[] | undefined; /** Pending requests. */
+    readonly pending?: readonly WebLockInfo[] | undefined;
+  }>;
+}
+/** Options for {@link useWebLocks}. */
+interface UseWebLocksOptions {
+  /**
+   * Lock manager for alternate runtimes and tests.
+   *
+   * @default window.navigator.locks when it exists
+   */
+  readonly locks?: MaybeRefOrGetter<LockManagerLike | null | undefined>;
+}
+/** Per-request options for {@link WebLocksControls.request}. */
+interface WebLockRequestOptions {
+  /**
+   * Requested mode.
+   *
+   * @default "exclusive"
+   */
+  readonly mode?: WebLockMode;
+  /**
+   * Resolve with `{ acquired: false }` instead of waiting when the lock is busy.
+   *
+   * @default false
+   */
+  readonly ifAvailable?: boolean;
+  /**
+   * Preempt any holder of the lock (exclusive mode only).
+   *
+   * @default false
+   */
+  readonly steal?: boolean;
+  /**
+   * Abort the request while it is still pending.
+   *
+   * @default undefined
+   */
+  readonly signal?: AbortSignal;
+}
+/** Outcome of an `ifAvailable` request. */
+type WebLockAttempt<Value> = {
+  /** The lock was granted and the callback ran. */readonly acquired: true; /** Callback result. */
+  readonly value: Value;
+} | {
+  /** The lock was busy; the callback did not run. */readonly acquired: false;
+};
+/** Request function exposed by {@link WebLocksControls}. */
+interface WebLockRequest {
+  /**
+   * Request a lock that is only granted when immediately available.
+   *
+   * @param name Lock name.
+   * @param callback Work to run while the lock is held.
+   * @param options Request options with `ifAvailable: true`.
+   * @returns The callback result, or `{ acquired: false }` when busy.
+   */
+  <Value>(name: string, callback: (lock: WebLockLike) => Value | PromiseLike<Value>, options: WebLockRequestOptions & {
+    readonly ifAvailable: true;
+  }): Promise<WebLockAttempt<Value>>;
+  /**
+   * Request a lock and run `callback` while it is held.
+   *
+   * @param name Lock name.
+   * @param callback Work to run while the lock is held.
+   * @param options Mode, steal and abort options.
+   * @returns The callback result.
+   */
+  <Value>(name: string, callback: (lock: WebLockLike) => Value | PromiseLike<Value>, options?: WebLockRequestOptions & {
+    readonly ifAvailable?: false;
+  }): Promise<Value>;
+}
+/** Reactive state and actions returned by {@link useWebLocks}. */
+interface WebLocksControls {
+  /** Whether the Web Locks API is available. */
+  readonly supported: ComputedRef<boolean>;
+  /** Names of locks requested through this composable that are currently held. */
+  readonly held: Readonly<Ref<readonly string[]>>;
+  /** Names of locks requested through this composable that are still waiting. */
+  readonly pending: Readonly<Ref<readonly string[]>>;
+  /** Most recent request failure (including aborts), cleared by the next grant. */
+  readonly error: Readonly<ShallowRef<unknown>>;
+  /**
+   * Request a lock. Rejects with a tagged `TypeError` for invalid option
+   * combinations, a tagged `Error` when unsupported, the host's `AbortError`
+   * when aborted, or the callback's rejection.
+   */
+  readonly request: WebLockRequest;
+  /**
+   * Snapshot the origin's locks.
+   *
+   * @returns Held and pending locks; empty lists when unsupported or on failure.
+   */
+  readonly query: () => Promise<WebLocksSnapshot>;
+}
+/**
+ * Coordinate work across tabs and workers with the Web Locks API.
+ *
+ * `request` runs the callback while the named lock is held and resolves with
+ * its result; with `ifAvailable` it resolves with a discriminated
+ * `{ acquired }` outcome instead of waiting. `held` and `pending` track the
+ * lock names requested through this composable. Requests still waiting when
+ * the owning reactive scope stops are aborted; locks already held are
+ * released when their callbacks settle. Outside a scope, pass a `signal` to
+ * own cancellation.
+ *
+ * Server rendering: nothing is requested, `supported` is false and the name
+ * lists are empty.
+ *
+ * @example
+ * ```ts
+ * const locks = useWebLocks();
+ * await locks.request("sync", async () => syncOutbox());
+ * const attempt = await locks.request("leader", runLeader, { ifAvailable: true });
+ * ```
+ *
+ * @param options Lock manager override.
+ * @default options {}
+ * @returns Lock state and actions.
+ */
+declare function useWebLocks(options?: UseWebLocksOptions): WebLocksControls;
+//#endregion
+export { LockManagerLike, UseWebLocksOptions, WebLockAttempt, WebLockInfo, WebLockLike, WebLockManagerRequestOptions, WebLockMode, WebLockRequest, WebLockRequestOptions, WebLocksControls, WebLocksSnapshot, useWebLocks };

package/dist/use-web-locks.mjs

@@ -0,0 +1,136 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { computed, hasInjectionContext, readonly, ref, shallowRef, toValue, watchPostEffect } from "vue";
+//#region src/use-web-locks.ts
+function browserLocks() {
+	if (typeof window === "undefined") return void 0;
+	const { navigator } = window;
+	return "locks" in navigator && navigator.locks ? navigator.locks : void 0;
+}
+function without(names, name) {
+	const index = names.indexOf(name);
+	return index === -1 ? names : [...names.slice(0, index), ...names.slice(index + 1)];
+}
+/**
+* Coordinate work across tabs and workers with the Web Locks API.
+*
+* `request` runs the callback while the named lock is held and resolves with
+* its result; with `ifAvailable` it resolves with a discriminated
+* `{ acquired }` outcome instead of waiting. `held` and `pending` track the
+* lock names requested through this composable. Requests still waiting when
+* the owning reactive scope stops are aborted; locks already held are
+* released when their callbacks settle. Outside a scope, pass a `signal` to
+* own cancellation.
+*
+* Server rendering: nothing is requested, `supported` is false and the name
+* lists are empty.
+*
+* @example
+* ```ts
+* const locks = useWebLocks();
+* await locks.request("sync", async () => syncOutbox());
+* const attempt = await locks.request("leader", runLeader, { ifAvailable: true });
+* ```
+*
+* @param options Lock manager override.
+* @default options {}
+* @returns Lock state and actions.
+*/
+function useWebLocks(options = {}) {
+	const held = ref([]);
+	const pending = ref([]);
+	const error = shallowRef(void 0);
+	const controllers = /* @__PURE__ */ new Set();
+	const hydrated = shallowRef(!hasInjectionContext());
+	if (!hydrated.value) watchPostEffect(() => {
+		hydrated.value = true;
+	});
+	const resolveLocks = () => !hydrated.value ? void 0 : options.locks === void 0 ? browserLocks() : toValue(options.locks) ?? void 0;
+	const run = async (name, callback, requestOptions = {}) => {
+		const { mode = "exclusive", ifAvailable = false, steal = false, signal } = requestOptions;
+		if (ifAvailable && steal || steal && mode === "shared" || signal && (ifAvailable || steal)) throw new TypeError("[VIZE_COMPOSE_WEB_LOCKS_INVALID_OPTIONS] steal cannot be combined with ifAvailable, shared mode or signal, and signal cannot be combined with ifAvailable.");
+		const locks = resolveLocks();
+		if (!locks) throw new Error("[VIZE_COMPOSE_WEB_LOCKS_UNSUPPORTED] The Web Locks API is not available.");
+		const controller = ifAvailable || steal ? void 0 : new AbortController();
+		const forwardAbort = () => controller?.abort(signal?.reason);
+		if (controller) {
+			if (signal?.aborted) forwardAbort();
+			else signal?.addEventListener("abort", forwardAbort, { once: true });
+			controllers.add(controller);
+		}
+		pending.value = [...pending.value, name];
+		let granted = false;
+		const managerOptions = controller ? {
+			mode,
+			signal: controller.signal
+		} : {
+			mode,
+			ifAvailable,
+			steal
+		};
+		let outcome = { acquired: false };
+		try {
+			await locks.request(name, managerOptions, async (lock) => {
+				pending.value = without(pending.value, name);
+				if (controller) controllers.delete(controller);
+				if (!lock) return;
+				granted = true;
+				error.value = void 0;
+				held.value = [...held.value, name];
+				try {
+					outcome = {
+						acquired: true,
+						value: await callback(lock)
+					};
+				} finally {
+					held.value = without(held.value, name);
+				}
+			});
+			return outcome;
+		} catch (cause) {
+			error.value = cause;
+			throw cause;
+		} finally {
+			if (!granted) pending.value = without(pending.value, name);
+			if (controller) controllers.delete(controller);
+			signal?.removeEventListener("abort", forwardAbort);
+		}
+	};
+	const request = ((name, callback, requestOptions) => {
+		const attempt = run(name, callback, requestOptions);
+		return requestOptions?.ifAvailable ? attempt : attempt.then((outcome) => outcome.acquired ? outcome.value : void 0);
+	});
+	const query = async () => {
+		const locks = resolveLocks();
+		if (!locks) return {
+			held: [],
+			pending: []
+		};
+		try {
+			const snapshot = await locks.query();
+			return {
+				held: snapshot.held ?? [],
+				pending: snapshot.pending ?? []
+			};
+		} catch (cause) {
+			error.value = cause;
+			return {
+				held: [],
+				pending: []
+			};
+		}
+	};
+	tryOnScopeDispose(() => {
+		for (const controller of controllers) controller.abort(new DOMException("The owning scope was disposed.", "AbortError"));
+		controllers.clear();
+	});
+	return {
+		supported: computed(() => resolveLocks() !== void 0),
+		held: readonly(held),
+		pending: readonly(pending),
+		error: readonly(error),
+		request,
+		query
+	};
+}
+//#endregion
+export { useWebLocks };