@monimesl/dot-dash 0.1.0-alpha.2 → 0.1.0-alpha.23

package/dist/index.js

@@ -1,27 +1,638 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { HostError, callHost } from "@monimesl/dot-core";
+import { DEFAULT_DASH_API_VERSION, HostError, HostError as DashError, HostError as HostError$1, callHost, createHostRequest, offersDashApiVersion } from "@monimesl/dot-core";
+//#region src/api-versions.ts
+const DASH_API_VERSION = "1.0";
+const DASH_API_SINCE = {
+	"account.readProfile": "1.0",
+	"contacts.pickPhone": "1.0",
+	"crypto.hmac": "1.0",
+	"crypto.randomBytes": "1.0",
+	"crypto.randomUUID": "1.0",
+	"crypto.sha256": "1.0",
+	"crypto.sha512": "1.0",
+	"dot.close": "1.0",
+	"media.pickFile": "1.0",
+	"media.pickPhoto": "1.0",
+	"media.scanCode": "1.0",
+	"network.http.download": "1.0",
+	"network.http.request": "1.0",
+	"network.http.upload": "1.0",
+	"network.status": "1.0",
+	"storage.cache.clear": "1.0",
+	"storage.cache.exists": "1.0",
+	"storage.cache.get": "1.0",
+	"storage.cache.keys": "1.0",
+	"storage.cache.remove": "1.0",
+	"storage.cache.set": "1.0",
+	"storage.file.copy": "1.0",
+	"storage.file.createFolder": "1.0",
+	"storage.file.list": "1.0",
+	"storage.file.move": "1.0",
+	"storage.file.open": "1.0",
+	"storage.file.read": "1.0",
+	"storage.file.remove": "1.0",
+	"storage.file.save": "1.0",
+	"storage.file.stat": "1.0",
+	"storage.file.usage": "1.0",
+	"storage.file.write": "1.0",
+	"storage.secret.clear": "1.0",
+	"storage.secret.get": "1.0",
+	"storage.secret.remove": "1.0",
+	"storage.secret.set": "1.0",
+	"system.brightness": "1.0",
+	"system.copyText": "1.0",
+	"system.delay": "1.0",
+	"system.dial": "1.0",
+	"system.info": "1.0",
+	"system.keepAwake": "1.0",
+	"system.openUrl": "1.0",
+	"system.share": "1.0",
+	"system.torch": "1.0",
+	"system.vibrate": "1.0",
+	"ui.alert": "1.0",
+	"ui.pickDate": "1.0",
+	"ui.pickTime": "1.0"
+};
+let hostApiVersions = [DEFAULT_DASH_API_VERSION];
+let dotMinApiVersion;
+const checkedFeatures = /* @__PURE__ */ new Set();
+const warnedFeatures = /* @__PURE__ */ new Set();
+function useHostDashApiVersions(versions) {
+	hostApiVersions = versions;
+}
+function warnAboveDashApiVersion(minApiVersion) {
+	dotMinApiVersion = minApiVersion;
+}
+/**
+* Whether the Dash the dot runs in has `feature`: a call, such as "contacts.pickPhone", or a field
+* added to a call later. Check it before using one that's newer than the dot's minApiVersion.
+* @since 1.0
+*/
+function supports(feature) {
+	checkedFeatures.add(feature);
+	const since = sinceOf(feature);
+	return since !== void 0 && offersDashApiVersion(hostApiVersions, since);
+}
+function warnIfNewerThanDot(method, params) {
+	if (dotMinApiVersion === void 0) return;
+	const callName = method.replace(/^dash\./, "");
+	for (const feature of [callName, ...fieldsSent(callName, params)]) {
+		const since = sinceOf(feature);
+		if (since === void 0) continue;
+		if (checkedFeatures.has(feature) || warnedFeatures.has(feature)) continue;
+		if (offersDashApiVersion([dotMinApiVersion], since)) continue;
+		warnedFeatures.add(feature);
+		console.warn(`dash.${feature} came in Dash API ${since}, but this dot's minApiVersion is ${dotMinApiVersion}, so older Dash doesn't have it. Raise "minApiVersion" in dot.json, or check dash.supports('${feature}') first.`);
+	}
+}
+function sinceOf(feature) {
+	const table = DASH_API_SINCE;
+	return Object.hasOwn(table, feature) ? table[feature] : void 0;
+}
+function fieldsSent(callName, params) {
+	if (typeof params !== "object" || params === null) return [];
+	return Object.keys(params).map((field) => `${callName}.${field}`).filter((feature) => sinceOf(feature) !== void 0);
+}
+//#endregion
 //#region src/call.ts
 function call(method, params, options = {}) {
+	warnIfNewerThanDot(method, params);
 	return callHost(method, params, options);
 }
 //#endregion
+//#region src/account/index.ts
+var account_exports = /* @__PURE__ */ __exportAll({ readProfile: () => readProfile });
+/**
+* The person signed in to Dash: their full name, and a token that names them in this dot. Needs the
+* `account` permission. Rejects with `invalid` for a nonce that's empty or longer than 128
+* characters, and with `failed` when no one is signed in.
+* @since 1.0
+*/
+function readProfile(options, callOptions) {
+	return call("dash.account.readProfile", { nonce: options.nonce }, callOptions);
+}
+//#endregion
+//#region src/contacts/pick-phone.ts
+/**
+* Shows the phone's contacts so the person chooses one phone number, such as who to send money to.
+* Needs the `contacts` permission. The dot sees only the chosen contact. Rejects with `cancelled` if
+* the person closes it.
+* @since 1.0
+*/
+function pickPhone(callOptions) {
+	return call("dash.contacts.pickPhone", {}, callOptions);
+}
+//#endregion
+//#region src/contacts/index.ts
+var contacts_exports = /* @__PURE__ */ __exportAll({ pickPhone: () => pickPhone });
+//#endregion
+//#region src/crypto/index.ts
+var crypto_exports = /* @__PURE__ */ __exportAll({
+	hmac: () => hmac,
+	randomBytes: () => randomBytes,
+	randomUUID: () => randomUUID,
+	sha256: () => sha256,
+	sha512: () => sha512
+});
+/** @since 1.0 */
+function sha256(data, options = {}, callOptions) {
+	return call("dash.crypto.sha256", wireInput(data, options), callOptions);
+}
+/** @since 1.0 */
+function sha512(data, options = {}, callOptions) {
+	return call("dash.crypto.sha512", wireInput(data, options), callOptions);
+}
+/**
+* Signs `data` with `key`, as HMAC-SHA256 or HMAC-SHA512.
+* @since 1.0
+*/
+function hmac(algorithm, key, data, options = {}, callOptions) {
+	const wireKey = valueAndEncoding(key);
+	return call("dash.crypto.hmac", {
+		...wireInput(data, options),
+		algorithm,
+		key: wireKey.value,
+		keyEncoding: wireKey.encoding
+	}, callOptions);
+}
+/**
+* `count` secure random bytes, from 1 to 1024, such as for a nonce.
+* @since 1.0
+*/
+function randomBytes(count, options = {}, callOptions) {
+	return call("dash.crypto.randomBytes", {
+		count,
+		as: outputEncoding(options)
+	}, callOptions);
+}
+/**
+* A random version 4 UUID, such as "3f0e5c3a-6d1b-4c8e-9a2f-1b7d4e6a9c05".
+* @since 1.0
+*/
+function randomUUID(callOptions) {
+	return call("dash.crypto.randomUUID", {}, callOptions);
+}
+function wireInput(data, options) {
+	const { value, encoding } = valueAndEncoding(data);
+	return {
+		data: value,
+		dataEncoding: encoding,
+		as: outputEncoding(options)
+	};
+}
+function outputEncoding(options) {
+	return options.as ?? "hex";
+}
+function valueAndEncoding(input) {
+	if (typeof input === "string") return {
+		value: input,
+		encoding: "text"
+	};
+	return {
+		value: input.base64,
+		encoding: "base64"
+	};
+}
+//#endregion
+//#region src/dot/index.ts
+var dot_exports = /* @__PURE__ */ __exportAll({ close: () => close });
+/**
+* Closes the dot, as going back from its first page does. Calls still running are cancelled.
+* @since 1.0
+*/
+function close(callOptions) {
+	return call("dash.dot.close", {}, callOptions);
+}
+//#endregion
+//#region src/media/pick-file.ts
+/**
+* Lets the person choose a file from their phone, of at most 25 MB. Needs the `files` permission.
+* Rejects with `cancelled` if they close the picker, and with `invalid` for a larger file. Like a
+* download, it lasts until the dot closes, so `dash.storage.file.save` it to keep it.
+* @since 1.0
+*/
+function pickFile(options = {}, callOptions) {
+	const params = {};
+	if (options.types) params.types = options.types;
+	return call("dash.media.pickFile", params, callOptions);
+}
+//#endregion
+//#region src/media/pick-photo.ts
+/**
+* Lets the person choose a photo or take one. Resolves with it as a JPEG of at most 2048 pixels on its
+* longest side, without its location or other details. Rejects with `cancelled` if they close the
+* picker, and with `unsupported` on a device without a camera. Save it with `dash.storage.file.save`
+* to keep it after the dot closes.
+* @since 1.0
+*/
+function pickPhoto(options, callOptions) {
+	return call("dash.media.pickPhoto", { source: options.source }, callOptions);
+}
+//#endregion
+//#region src/media/scan-code.ts
+/**
+* Opens Dash's scanner until it reads a QR code. Needs the `camera` permission. Rejects with
+* `cancelled` if the person closes it, and with `unsupported` where Dash has no scanner.
+* @since 1.0
+*/
+function scanCode(callOptions) {
+	return call("dash.media.scanCode", {}, callOptions);
+}
+//#endregion
+//#region src/media/index.ts
+var media_exports = /* @__PURE__ */ __exportAll({
+	pickFile: () => pickFile,
+	pickPhoto: () => pickPhoto,
+	scanCode: () => scanCode
+});
+//#endregion
+//#region src/network/http.ts
+var http_exports = /* @__PURE__ */ __exportAll({
+	download: () => download,
+	request: () => request,
+	upload: () => upload
+});
+/**
+* Like fetch, resolves with any response, even a 404. An object body is sent as JSON.
+* @since 1.0
+*/
+function request(options, callOptions) {
+	const { as: readAs, ...request } = options;
+	return readBody(call("dash.network.http.request", wireRequest(request, readAs), callOptions), readAs);
+}
+/**
+* Saves a 2xx response's body, up to 256 MB, to a temporary file.
+* @since 1.0
+*/
+function download(options, callOptions) {
+	return call("dash.network.http.download", wireRequest(options), callOptions);
+}
+/**
+* Sends the dot's files as a multipart form.
+* @since 1.0
+*/
+function upload(options, callOptions) {
+	const { as: readAs, ...request } = options;
+	const files = request.files.map((upload) => ({
+		...upload,
+		file: upload.file.id
+	}));
+	const params = {
+		...request,
+		files
+	};
+	if (readAs === "json") params.headers = withDefaultHeader(request.headers, "Accept", "application/json");
+	return readBody(call("dash.network.http.upload", params, callOptions), readAs);
+}
+function wireRequest(request, readAs) {
+	let headers = request.headers;
+	let body;
+	if (readAs === "json") headers = withDefaultHeader(headers, "Accept", "application/json");
+	if (typeof request.body === "string") body = request.body;
+	else if (request.body !== void 0) {
+		headers = withDefaultHeader(headers, "Content-Type", "application/json");
+		body = JSON.stringify(request.body);
+	}
+	return {
+		...request,
+		headers,
+		body
+	};
+}
+function withDefaultHeader(headers, name, value) {
+	if (headers === void 0) return { [name]: value };
+	const lowerName = name.toLowerCase();
+	if (Object.keys(headers).some((existing) => existing.toLowerCase() === lowerName)) return headers;
+	return {
+		...headers,
+		[name]: value
+	};
+}
+function readBody(response, readAs) {
+	if (readAs !== "json") return response;
+	const parsed = response.then((result) => ({
+		...result,
+		body: parseJson(result)
+	}));
+	return createHostRequest(parsed, () => response.cancel());
+}
+function parseJson({ status, statusText, body }) {
+	try {
+		return JSON.parse(body);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new HostError$1("failed", `The response (${status} ${statusText}) isn't JSON: ${message}`);
+	}
+}
+//#endregion
+//#region src/network/status.ts
+/**
+* Whether the phone is online now, and how. It can still be online without reaching a server.
+* @since 1.0
+*/
+function status(callOptions) {
+	return call("dash.network.status", {}, callOptions);
+}
+//#endregion
+//#region src/network/index.ts
+var network_exports = /* @__PURE__ */ __exportAll({
+	http: () => http_exports,
+	status: () => status
+});
+//#endregion
+//#region src/storage/cache.ts
+var cache_exports = /* @__PURE__ */ __exportAll({
+	clear: () => clear$1,
+	exists: () => exists,
+	get: () => get$1,
+	keys: () => keys,
+	remove: () => remove$2,
+	set: () => set$1
+});
+/**
+* Resolves with null for a missing or expired key.
+* @since 1.0
+*/
+function get$1(key, callOptions) {
+	return call("dash.storage.cache.get", { key }, callOptions);
+}
+/** @since 1.0 */
+function set$1(key, value, options = {}, callOptions) {
+	return call("dash.storage.cache.set", {
+		key,
+		value,
+		...options
+	}, callOptions);
+}
+/** @since 1.0 */
+function remove$2(key, callOptions) {
+	return call("dash.storage.cache.remove", { key }, callOptions);
+}
+/** @since 1.0 */
+function exists(key, callOptions) {
+	return call("dash.storage.cache.exists", { key }, callOptions);
+}
+/**
+* The keys, sorted.
+* @since 1.0
+*/
+function keys(callOptions) {
+	return call("dash.storage.cache.keys", {}, callOptions);
+}
+/** @since 1.0 */
+function clear$1(callOptions) {
+	return call("dash.storage.cache.clear", {}, callOptions);
+}
+//#endregion
+//#region src/storage/file.ts
+var file_exports = /* @__PURE__ */ __exportAll({
+	copy: () => copy,
+	createFolder: () => createFolder,
+	list: () => list,
+	move: () => move,
+	open: () => open,
+	read: () => read,
+	remove: () => remove$1,
+	save: () => save,
+	stat: () => stat,
+	usage: () => usage,
+	write: () => write
+});
+/**
+* Reads a file of up to 5 MB.
+* @since 1.0
+*/
+function read(path, options = {}, callOptions) {
+	return call("dash.storage.file.read", {
+		path,
+		...options
+	}, callOptions);
+}
+/**
+* Creates any missing folders above the file.
+* @since 1.0
+*/
+function write(path, data, options = {}, callOptions) {
+	return call("dash.storage.file.write", {
+		path,
+		data,
+		...options
+	}, callOptions);
+}
+/** @since 1.0 */
+function stat(path, callOptions) {
+	return call("dash.storage.file.stat", { path }, callOptions);
+}
+/**
+* Sorted by path.
+* @since 1.0
+*/
+function list(path = "", options = {}, callOptions) {
+	return call("dash.storage.file.list", {
+		path,
+		...options
+	}, callOptions);
+}
+/** @since 1.0 */
+function createFolder(path, callOptions) {
+	return call("dash.storage.file.createFolder", { path }, callOptions);
+}
+/** @since 1.0 */
+function move(from, to, options = {}, callOptions) {
+	return call("dash.storage.file.move", {
+		from,
+		to,
+		...options
+	}, callOptions);
+}
+/** @since 1.0 */
+function copy(from, to, options = {}, callOptions) {
+	return call("dash.storage.file.copy", {
+		from,
+		to,
+		...options
+	}, callOptions);
+}
+/**
+* Removing a folder that isn't empty needs `recursive`.
+* @since 1.0
+*/
+function remove$1(path, options = {}, callOptions) {
+	return call("dash.storage.file.remove", {
+		path,
+		...options
+	}, callOptions);
+}
+/**
+* Keeps a temporary file, such as a download, at `path`.
+* @since 1.0
+*/
+function save(file, path, options = {}, callOptions) {
+	return call("dash.storage.file.save", {
+		file: file.id,
+		path,
+		...options
+	}, callOptions);
+}
+/**
+* A stored file as a DotFile, to show with its `url` or send with `http.upload`.
+* @since 1.0
+*/
+function open(path, callOptions) {
+	return call("dash.storage.file.open", { path }, callOptions);
+}
+/** @since 1.0 */
+function usage(callOptions) {
+	return call("dash.storage.file.usage", {}, callOptions);
+}
+//#endregion
+//#region src/storage/secret.ts
+var secret_exports = /* @__PURE__ */ __exportAll({
+	clear: () => clear,
+	get: () => get,
+	remove: () => remove,
+	set: () => set
+});
+/** @since 1.0 */
+function get(key, callOptions) {
+	return call("dash.storage.secret.get", { key }, callOptions);
+}
+/** @since 1.0 */
+function set(key, value, callOptions) {
+	return call("dash.storage.secret.set", {
+		key,
+		value
+	}, callOptions);
+}
+/** @since 1.0 */
+function remove(key, callOptions) {
+	return call("dash.storage.secret.remove", { key }, callOptions);
+}
+/** @since 1.0 */
+function clear(callOptions) {
+	return call("dash.storage.secret.clear", {}, callOptions);
+}
+//#endregion
+//#region src/storage/index.ts
+var storage_exports = /* @__PURE__ */ __exportAll({
+	cache: () => cache_exports,
+	file: () => file_exports,
+	secret: () => secret_exports
+});
+//#endregion
+//#region src/system/clipboard.ts
+/** @since 1.0 */
+function copyText(text, callOptions) {
+	return call("dash.system.copyText", { text }, callOptions);
+}
+//#endregion
+//#region src/system/delay.ts
+/**
+* Resolves after `milliseconds`. The host keeps the time, since a dot's logic has no timers.
+* @since 1.0
+*/
+function delay(milliseconds, callOptions) {
+	return call("dash.system.delay", { milliseconds }, callOptions);
+}
+//#endregion
+//#region src/system/dial.ts
+/**
+* Opens the phone's dialer with `number` ready, such as "+232 76 123456" or a USSD code such as
+* "*715#". The person taps Call. Spaces and dashes are fine; anything else but digits, +, * and #
+* rejects with `invalid`.
+* @since 1.0
+*/
+function dial(number, callOptions) {
+	return call("dash.system.dial", { number }, callOptions);
+}
+//#endregion
 //#region src/system/haptics.ts
+/**
+* Plays a short vibration. Resolves once it's done.
+* @since 1.0
+*/
 function vibrate(options = {}, callOptions) {
 	return call("dash.system.vibrate", { style: options.style ?? "medium" }, callOptions);
 }
 //#endregion
+//#region src/system/info.ts
+/**
+* The phone and the Dash the dot runs in. It has nothing that identifies the person or the phone.
+* @since 1.0
+*/
+function info(callOptions) {
+	return call("dash.system.info", {}, callOptions);
+}
+//#endregion
+//#region src/system/open-url.ts
+/**
+* Opens an https address in the device's browser. Any other address rejects with `invalid`.
+* @since 1.0
+*/
+function openUrl(url, callOptions) {
+	return call("dash.system.openUrl", { url }, callOptions);
+}
+//#endregion
+//#region src/system/screen.ts
+/**
+* Keeps the screen from dimming and locking while the dot shows, such as while a ticket's QR code is
+* up. Dash undoes it when the dot closes.
+* @since 1.0
+*/
+function keepAwake(on, callOptions) {
+	return call("dash.system.keepAwake", { on }, callOptions);
+}
+/**
+* `max` makes the screen as bright as it goes, so a scanner can read a QR code on it, and `normal`
+* puts it back. Dash puts it back too when the dot closes or the person leaves the app.
+* @since 1.0
+*/
+function brightness(level, callOptions) {
+	return call("dash.system.brightness", { level }, callOptions);
+}
+//#endregion
+//#region src/system/share.ts
+/**
+* Opens the device's share sheet. Resolves once it shows.
+* @since 1.0
+*/
+function share(options, callOptions) {
+	const { file, ...content } = options;
+	if (file === void 0) return call("dash.system.share", content, callOptions);
+	return call("dash.system.share", {
+		...content,
+		file: file.id
+	}, callOptions);
+}
+//#endregion
 //#region src/system/torch.ts
-function torch(state, callOptions) {
-	return call("dash.system.torch", { state }, callOptions);
+/**
+* Turns the torch on or off. Rejects with `unsupported` on a device without one.
+* @since 1.0
+*/
+function torch(on, callOptions) {
+	return call("dash.system.torch", { on }, callOptions);
 }
 //#endregion
 //#region src/system/index.ts
 var system_exports = /* @__PURE__ */ __exportAll({
+	brightness: () => brightness,
+	copyText: () => copyText,
+	delay: () => delay,
+	dial: () => dial,
+	info: () => info,
+	keepAwake: () => keepAwake,
+	openUrl: () => openUrl,
+	share: () => share,
 	torch: () => torch,
 	vibrate: () => vibrate
 });
 //#endregion
 //#region src/ui/dialogs.ts
+/**
+* Shows a native alert. Resolves with the action the person chose.
+* @since 1.0
+*/
 function alert(options, callOptions) {
 	const actions = options.actions ?? [{
 		id: "ok",
@@ -33,12 +644,235 @@ function alert(options, callOptions) {
 	}, callOptions);
 }
 //#endregion
+//#region src/ui/pickers.ts
+/**
+* Opens the phone's own calendar. Resolves with the chosen date, such as "2026-10-24", or rejects
+* with `cancelled` if the person closes it.
+* @since 1.0
+*/
+function pickDate(options = {}, callOptions) {
+	return call("dash.ui.pickDate", options, callOptions);
+}
+/**
+* Opens the phone's own clock. Resolves with the chosen time in 24 hours, such as "19:30", or
+* rejects with `cancelled` if the person closes it.
+* @since 1.0
+*/
+function pickTime(options = {}, callOptions) {
+	return call("dash.ui.pickTime", options, callOptions);
+}
+//#endregion
+//#region src/ui/index.ts
+var ui_exports = /* @__PURE__ */ __exportAll({
+	alert: () => alert,
+	pickDate: () => pickDate,
+	pickTime: () => pickTime
+});
+//#endregion
+//#region src/utils/encoding.ts
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const HEX_PATTERN = /^(?:[0-9a-fA-F]{2})*$/;
+const base64 = {
+	encode(text) {
+		return bytesToBase64(utf8Bytes(text));
+	},
+	decode(encoded) {
+		return utf8Text(base64ToBytes(encoded));
+	}
+};
+const hex = {
+	encode(text) {
+		return utf8Bytes(text).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+	},
+	decode(encoded) {
+		if (!HEX_PATTERN.test(encoded)) throw new Error(`"${encoded.slice(0, 20)}" isn't hex. Use pairs of 0-9 and a-f.`);
+		const bytes = [];
+		for (let index = 0; index < encoded.length; index += 2) bytes.push(parseInt(encoded.slice(index, index + 2), 16));
+		return utf8Text(bytes);
+	}
+};
+function bytesToBase64(bytes) {
+	let encoded = "";
+	for (let index = 0; index < bytes.length; index += 3) {
+		const group = bytes.slice(index, index + 3);
+		const bits = (group[0] ?? 0) << 16 | (group[1] ?? 0) << 8 | (group[2] ?? 0);
+		const sextets = [
+			bits >> 18 & 63,
+			bits >> 12 & 63,
+			bits >> 6 & 63,
+			bits & 63
+		];
+		const characterCount = group.length + 1;
+		for (const sextet of sextets.slice(0, characterCount)) encoded += BASE64_ALPHABET[sextet];
+		encoded += "=".repeat(4 - characterCount);
+	}
+	return encoded;
+}
+function base64ToBytes(encoded) {
+	if (!BASE64_PATTERN.test(encoded)) throw new Error(`"${encoded.slice(0, 20)}" isn't base64.`);
+	const bytes = [];
+	for (let index = 0; index < encoded.length; index += 4) {
+		const characters = encoded.slice(index, index + 4);
+		let bits = 0;
+		let padding = 0;
+		for (const character of characters) {
+			bits <<= 6;
+			if (character === "=") padding += 1;
+			else bits |= BASE64_ALPHABET.indexOf(character);
+		}
+		bytes.push(bits >> 16 & 255);
+		if (padding < 2) bytes.push(bits >> 8 & 255);
+		if (padding < 1) bytes.push(bits & 255);
+	}
+	return bytes;
+}
+function utf8Bytes(text) {
+	const bytes = [];
+	for (const character of text) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint < 128) bytes.push(codePoint);
+		else if (codePoint < 2048) bytes.push(192 | codePoint >> 6, 128 | codePoint & 63);
+		else if (codePoint < 65536) bytes.push(224 | codePoint >> 12, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+		else bytes.push(240 | codePoint >> 18, 128 | codePoint >> 12 & 63, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+	}
+	return bytes;
+}
+const MAX_CODE_POINT = 1114111;
+function utf8Text(bytes) {
+	let text = "";
+	let index = 0;
+	while (index < bytes.length) {
+		const first = bytes[index];
+		const length = sequenceLength(first);
+		const continuation = bytes.slice(index + 1, index + length);
+		if (length === 0 || !isCompleteContinuation(continuation, length)) {
+			text += "�";
+			index += 1;
+			continue;
+		}
+		let codePoint = firstByteBits(first, length);
+		for (const byte of continuation) codePoint = codePoint << 6 | byte & 63;
+		if (codePoint > MAX_CODE_POINT) {
+			text += "�";
+			index += 1;
+			continue;
+		}
+		text += String.fromCodePoint(codePoint);
+		index += length;
+	}
+	return text;
+}
+function sequenceLength(first) {
+	if (first < 128) return 1;
+	if (first >= 240) return 4;
+	if (first >= 224) return 3;
+	if (first >= 192) return 2;
+	return 0;
+}
+function isCompleteContinuation(continuation, length) {
+	if (continuation.length !== length - 1) return false;
+	return continuation.every((byte) => (byte & 192) === 128);
+}
+function firstByteBits(first, length) {
+	if (length === 1) return first;
+	return first & 255 >> length + 1;
+}
+//#endregion
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ __exportAll({
+	base64: () => base64,
+	hex: () => hex
+});
+//#endregion
+//#region src/tracked.ts
+function tracked(group, track) {
+	const copy = {};
+	for (const [name, member] of Object.entries(group)) if (typeof member === "function") {
+		const startCall = member;
+		copy[name] = (...args) => {
+			const result = startCall(...args);
+			if (result instanceof Promise) track(result);
+			return result;
+		};
+	} else copy[name] = tracked(member, track);
+	return copy;
+}
+//#endregion
+//#region src/errors.ts
+function isDashError(error, ...codes) {
+	if (error instanceof HostError$1) return codes.length === 0 || codes.includes(error.code);
+	return false;
+}
+function isDashCancelled(error) {
+	return isDashError(error, "cancelled");
+}
+function isDashTimeout(error) {
+	return isDashError(error, "timeout");
+}
+function isDashDenied(error) {
+	return isDashError(error, "denied");
+}
+function isDashInvalid(error) {
+	return isDashError(error, "invalid");
+}
+function isDashUnsupported(error) {
+	return isDashError(error, "unsupported");
+}
+function isDashFailed(error) {
+	return isDashError(error, "failed");
+}
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string" && error) return error;
+	return "Something went wrong. Try again.";
+}
+async function unlessCancelled(call) {
+	try {
+		return await call;
+	} catch (error) {
+		if (isDashCancelled(error)) return;
+		throw error;
+	}
+}
+//#endregion
+//#region src/latest.ts
+function latest() {
+	let running;
+	return (call) => {
+		running?.cancel();
+		running = call;
+		return call;
+	};
+}
+function debounce(milliseconds) {
+	const wait = latest();
+	return async (dash) => {
+		try {
+			await wait(dash.system.delay(milliseconds));
+			return true;
+		} catch (error) {
+			if (isDashCancelled(error)) return false;
+			throw error;
+		}
+	};
+}
+//#endregion
 //#region src/index.ts
 const dash = {
-	ui: /* @__PURE__ */ __exportAll({ alert: () => alert }),
-	system: system_exports
+	ui: ui_exports,
+	system: system_exports,
+	network: network_exports,
+	storage: storage_exports,
+	media: media_exports,
+	contacts: contacts_exports,
+	dot: dot_exports,
+	account: account_exports,
+	crypto: crypto_exports,
+	utils: utils_exports,
+	supports
 };
 //#endregion
-export { HostError, dash };
+export { DASH_API_SINCE, DASH_API_VERSION, DashError, HostError, dash, debounce, errorMessage, isDashCancelled, isDashDenied, isDashError, isDashFailed, isDashInvalid, isDashTimeout, isDashUnsupported, latest, tracked, unlessCancelled, useHostDashApiVersions, warnAboveDashApiVersion };
 
 //# sourceMappingURL=index.js.map