@camera.ui/server 2.1.12 → 2.1.13

package/dist/interface/ha/web-BjKL51lK-qwJdIpM1.js

@@ -0,0 +1,221 @@
+import { r as e } from "./dist-B7lgvbyI.js";
+//#region node_modules/@capacitor/file-transfer/dist/web-BjKL51lK.js
+var t = class extends e {
+	constructor() {
+		super(...arguments), this.lastProgressUpdate = 0, this.PROGRESS_UPDATE_INTERVAL = 100;
+	}
+	async downloadFile(e) {
+		try {
+			let t = this.buildUrl(e.url, e.params), n = new Headers(e.headers), r = {
+				method: e.method || "GET",
+				headers: n,
+				redirect: e.disableRedirects ? "manual" : "follow"
+			}, i = new AbortController(), a = e.connectTimeout || 6e4, o = setTimeout(() => i.abort(), a), s, c = 0;
+			try {
+				let n = await fetch(t, {
+					...r,
+					signal: i.signal
+				});
+				if (!n.ok) throw Error(`HTTP error: ${n.status}`);
+				if (e.progress && n.body) {
+					let t = n.body.getReader(), r = parseInt(n.headers.get("content-length") || "0", 10), i = n.headers.get("content-type") || "", a = 0, o = [];
+					for (;;) {
+						let { done: n, value: i } = await t.read();
+						if (n) break;
+						i && (o.push(i), a += i.length, this.notifyProgress(e.url, a, r, r > 0, "download"));
+					}
+					let l = new Uint8Array(a), u = 0;
+					for (let e of o) l.set(e, u), u += e.length;
+					s = new Blob([l], { type: i }), c = a, e.progress && this.notifyProgress(e.url, c, c, !0, "download", !0);
+				} else s = await n.blob(), c = s.size;
+			} finally {
+				clearTimeout(o);
+			}
+			if (await this.tryWriteToFilesystem(s, e.path)) return {
+				path: e.path,
+				blob: s
+			};
+			let l = URL.createObjectURL(s), u = document.createElement("a");
+			return u.href = l, u.download = this.extractFilename(e.path, e.url), document.body.appendChild(u), u.click(), document.body.removeChild(u), URL.revokeObjectURL(l), {
+				blob: s,
+				path: e.path
+			};
+		} catch (t) {
+			throw this.handleError(t, e.url, e.path);
+		}
+	}
+	async uploadFile(e) {
+		try {
+			let t;
+			if (e.blob) t = e.blob;
+			else {
+				let n = await this.tryReadFromFilesystem(e.path);
+				if (n) t = n;
+				else throw Error("File upload from path is not supported in web without @capacitor/filesystem plugin. Please provide a blob instead.");
+			}
+			return new Promise((n, r) => {
+				let i = new XMLHttpRequest(), a = this.buildUrl(e.url, e.params);
+				e.progress && (i.upload.onprogress = (t) => {
+					this.notifyProgress(e.url, t.loaded, t.total, t.lengthComputable, "upload");
+				}), i.onload = () => {
+					if (i.status >= 200 && i.status < 300) {
+						e.progress && this.notifyProgress(e.url, t.size, t.size, !0, "upload", !0);
+						let r = {};
+						i.getAllResponseHeaders().split("\r\n").forEach((e) => {
+							let [t, n] = e.split(": ");
+							t && n && (r[t] = n);
+						}), n({
+							bytesSent: t.size,
+							responseCode: i.status.toString(),
+							response: i.responseText,
+							headers: r
+						});
+					} else r(/* @__PURE__ */ Error(`HTTP error: ${i.status}`));
+				}, i.onerror = () => {
+					r(/* @__PURE__ */ Error("Network error occurred"));
+				}, i.open(e.method || "POST", a, !0), e.headers && Object.entries(e.headers).forEach(([e, t]) => {
+					i.setRequestHeader(e, t);
+				});
+				let o = new FormData(), s = e.fileKey || "file";
+				o.append(s, t, e.path), e.params && Object.entries(e.params).forEach(([e, t]) => {
+					Array.isArray(t) ? t.forEach((t) => o.append(e, t)) : o.append(e, t);
+				}), i.send(o);
+			});
+		} catch (t) {
+			throw this.handleError(t, e.path, e.url);
+		}
+	}
+	buildUrl(e, t) {
+		if (!t || Object.keys(t).length === 0) return e;
+		let n = new URL(e);
+		return Object.entries(t).forEach(([e, t]) => {
+			Array.isArray(t) ? t.forEach((t) => n.searchParams.append(e, t)) : n.searchParams.append(e, t);
+		}), n.toString();
+	}
+	notifyProgress(e, t, n, r, i, a = !1) {
+		let o = Date.now();
+		if (a || o - this.lastProgressUpdate >= this.PROGRESS_UPDATE_INTERVAL) {
+			let a = {
+				type: i,
+				url: e,
+				bytes: t,
+				contentLength: n,
+				lengthComputable: r
+			};
+			this.notifyListeners("progress", a), this.lastProgressUpdate = o;
+		}
+	}
+	handleError(e, t, n) {
+		return e instanceof TypeError && e.message === "Failed to fetch" ? {
+			code: "OS-PLUG-FLTR-0008",
+			message: "Failed to connect to server",
+			source: t,
+			target: n
+		} : e instanceof Error ? {
+			code: "OS-PLUG-FLTR-0011",
+			message: e.message,
+			source: t,
+			target: n
+		} : {
+			code: "OS-PLUG-FLTR-0011",
+			message: "An unknown error occurred",
+			source: t,
+			target: n
+		};
+	}
+	extractFilename(e, t) {
+		let n = e.split("?")[0].split("#")[0].split(/[/\\]/), r = n[n.length - 1];
+		if (!r.includes(".")) {
+			let e = t.split(".");
+			if (e.length > 1) {
+				let t = e[e.length - 1].split("?")[0];
+				r = `${e[e.length - 2].split("/").pop()}.${t}`;
+			}
+		}
+		return r ||= "download", r;
+	}
+	isFilesystemAvailable() {
+		try {
+			return !!globalThis?.Capacitor?.Plugins?.Filesystem;
+		} catch {
+			return !1;
+		}
+	}
+	async tryReadFromFilesystem(e) {
+		if (!this.isFilesystemAvailable()) return null;
+		try {
+			let t = window.Capacitor?.Plugins?.Filesystem;
+			if (!t) return null;
+			let n = (await t.readFile({ path: e })).data;
+			if (!n) throw Error("No data returned from Filesystem plugin");
+			let r = this.getMimeTypeFromPath(e) || "application/octet-stream", i = atob(n), a = [];
+			for (let e = 0; e < i.length; e += 512) {
+				let t = i.slice(e, e + 512), n = Array(t.length);
+				for (let e = 0; e < t.length; e++) n[e] = t.charCodeAt(e);
+				let r = new Uint8Array(n);
+				a.push(r);
+			}
+			return new Blob(a, { type: r });
+		} catch (e) {
+			return console.error("Error reading file from Filesystem:", e), null;
+		}
+	}
+	async tryWriteToFilesystem(e, t) {
+		if (!this.isFilesystemAvailable()) return !1;
+		try {
+			let n = window.Capacitor?.Plugins?.Filesystem;
+			if (!n) return !1;
+			let r = await this.blobToBase64(e);
+			if (!r) throw Error("Failed to convert blob to base64");
+			let i = t.split("/");
+			if (i.length > 1) {
+				let e = i.slice(0, -1).join("/");
+				await n.stat({ path: e }).catch(async () => {
+					await n.mkdir({
+						path: e,
+						recursive: !0
+					});
+				});
+			}
+			return await n.writeFile({
+				path: t,
+				data: r.split(",")[1],
+				recursive: !0
+			}), !0;
+		} catch (e) {
+			return console.error("Error writing file to Filesystem:", e), !1;
+		}
+	}
+	blobToBase64(e) {
+		return new Promise((t, n) => {
+			let r = new FileReader();
+			r.onload = () => t(r.result), r.onerror = () => n(/* @__PURE__ */ Error("Failed to convert blob to base64")), r.readAsDataURL(e);
+		});
+	}
+	getMimeTypeFromPath(e) {
+		let t = e.split(".").pop()?.toLowerCase();
+		return t && {
+			jpg: "image/jpeg",
+			jpeg: "image/jpeg",
+			png: "image/png",
+			gif: "image/gif",
+			pdf: "application/pdf",
+			txt: "text/plain",
+			html: "text/html",
+			htm: "text/html",
+			json: "application/json",
+			doc: "application/msword",
+			docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+			xls: "application/vnd.ms-excel",
+			xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+			zip: "application/zip",
+			mp3: "audio/mpeg",
+			mp4: "video/mp4",
+			wav: "audio/wav",
+			xml: "application/xml",
+			csv: "text/csv"
+		}[t] || null;
+	}
+};
+//#endregion
+export { t as FileTransferWeb };

package/dist/interface/ha/web-C01i9qI1.js

@@ -0,0 +1,57 @@
+import { r as e } from "./dist-B7lgvbyI.js";
+//#region node_modules/@capacitor/network/dist/esm/web.js
+function t() {
+	let e = window.navigator.connection || window.navigator.mozConnection || window.navigator.webkitConnection, t = "unknown", n = e ? e.type || e.effectiveType : null;
+	if (n && typeof n == "string") switch (n) {
+		case "bluetooth":
+		case "cellular":
+			t = "cellular";
+			break;
+		case "none":
+			t = "none";
+			break;
+		case "ethernet":
+		case "wifi":
+		case "wimax":
+			t = "wifi";
+			break;
+		case "other":
+		case "unknown":
+			t = "unknown";
+			break;
+		case "slow-2g":
+		case "2g":
+		case "3g":
+			t = "cellular";
+			break;
+		case "4g": t = "wifi";
+	}
+	return t;
+}
+var n = class extends e {
+	constructor() {
+		super(), this.handleOnline = () => {
+			let e = {
+				connected: !0,
+				connectionType: t()
+			};
+			this.notifyListeners("networkStatusChange", e);
+		}, this.handleOffline = () => {
+			this.notifyListeners("networkStatusChange", {
+				connected: !1,
+				connectionType: "none"
+			});
+		}, typeof window < "u" && (window.addEventListener("online", this.handleOnline), window.addEventListener("offline", this.handleOffline));
+	}
+	async getStatus() {
+		if (!window.navigator) throw this.unavailable("Browser does not support the Network Information API");
+		let e = window.navigator.onLine, n = t();
+		return {
+			connected: e,
+			connectionType: e ? n : "none"
+		};
+	}
+};
+new n();
+//#endregion
+export { n as NetworkWeb };

package/dist/interface/ha/web-CH3JeXWa.js

@@ -0,0 +1,211 @@
+import { r as e } from "./dist-B7lgvbyI.js";
+import { AppUpdateAvailability as t } from "./esm-BGlkcEes.js";
+//#region node_modules/@capgo/capacitor-updater/dist/esm/web.js
+var n = {
+	status: "success",
+	version: "",
+	downloaded: "1970-01-01T00:00:00.000Z",
+	id: "builtin",
+	checksum: ""
+}, r = class extends e {
+	async setStatsUrl(e) {
+		console.warn("Cannot setStatsUrl in web", e);
+	}
+	async setUpdateUrl(e) {
+		console.warn("Cannot setUpdateUrl in web", e);
+	}
+	async setChannelUrl(e) {
+		console.warn("Cannot setChannelUrl in web", e);
+	}
+	async download(e) {
+		return console.warn("Cannot download version in web", e), n;
+	}
+	async next(e) {
+		return console.warn("Cannot set next version in web", e), n;
+	}
+	async isAutoUpdateEnabled() {
+		return console.warn("Cannot get isAutoUpdateEnabled in web"), { enabled: !1 };
+	}
+	async set(e) {
+		console.warn("Cannot set active bundle in web", e);
+	}
+	async startPreviewSession(e) {
+		console.warn("Cannot start preview session in web", e);
+	}
+	async listPreviews() {
+		return console.warn("Cannot list previews in web"), {
+			previews: [],
+			currentBundle: n
+		};
+	}
+	async setPreview(e) {
+		console.warn("Cannot set preview in web", e);
+	}
+	async resetPreview() {
+		console.warn("Cannot reset preview in web");
+	}
+	async deletePreview(e) {
+		return console.warn("Cannot delete preview in web", e), {
+			removed: !1,
+			deleted: !1
+		};
+	}
+	async checkPreviewUpdate(e) {
+		throw console.warn("Cannot check preview update in web", e), this.unimplemented("Preview updates are not available on web platform");
+	}
+	async updatePreview(e) {
+		throw console.warn("Cannot update preview in web", e), this.unimplemented("Preview updates are not available on web platform");
+	}
+	async getDeviceId() {
+		return console.warn("Cannot get ID in web"), { deviceId: "default" };
+	}
+	async getBuiltinVersion() {
+		return console.warn("Cannot get version in web"), { version: "default" };
+	}
+	async getPluginVersion() {
+		return console.warn("Cannot get plugin version in web"), { version: "default" };
+	}
+	async delete(e) {
+		console.warn("Cannot delete bundle in web", e);
+	}
+	async setBundleError(e) {
+		return console.warn("Cannot setBundleError in web", e), n;
+	}
+	async list() {
+		return console.warn("Cannot list bundles in web"), { bundles: [] };
+	}
+	async reset(e) {
+		console.warn("Cannot reset version in web", e);
+	}
+	async current() {
+		return console.warn("Cannot get current bundle in web"), {
+			bundle: n,
+			native: "0.0.0"
+		};
+	}
+	async reload() {
+		console.warn("Cannot reload current bundle in web");
+	}
+	async getLatest() {
+		return console.warn("Cannot getLatest current bundle in web"), {
+			version: "0.0.0",
+			message: "Cannot getLatest current bundle in web"
+		};
+	}
+	async triggerUpdateCheck() {
+		return console.warn("Cannot triggerUpdateCheck in web"), {
+			status: "unavailable",
+			queued: !1
+		};
+	}
+	async getMissingBundleFiles(e) {
+		console.warn("Cannot inspect missing bundle files in web", { manifestLength: e.manifest?.length ?? 0 });
+		let t = e.manifest ?? [];
+		return {
+			missing: t,
+			total: t.length,
+			missingCount: t.length,
+			reusableCount: 0
+		};
+	}
+	async getBundleDownloadSize(e) {
+		return console.warn("Cannot estimate bundle download size in web", { manifestLength: e.manifest?.length ?? 0 }), {
+			totalSize: 0,
+			knownFiles: 0,
+			unknownFiles: e.manifest?.length ?? 0,
+			files: (e.manifest ?? []).map((e) => ({
+				file_name: e.file_name,
+				file_hash: e.file_hash,
+				download_url: e.download_url,
+				error: "unavailable"
+			}))
+		};
+	}
+	async setChannel(e) {
+		return console.warn("Cannot setChannel in web", e), {
+			status: "error",
+			error: "Cannot setChannel in web"
+		};
+	}
+	async unsetChannel(e) {
+		console.warn("Cannot unsetChannel in web", e);
+	}
+	async setCustomId(e) {
+		console.warn("Cannot setCustomId in web", e);
+	}
+	async getChannel() {
+		return console.warn("Cannot getChannel in web"), {
+			status: "error",
+			error: "Cannot getChannel in web"
+		};
+	}
+	async listChannels() {
+		throw console.warn("Cannot listChannels in web"), {
+			message: "Cannot listChannels in web",
+			error: "platform_not_supported"
+		};
+	}
+	async notifyAppReady() {
+		return { bundle: n };
+	}
+	async setMultiDelay(e) {
+		console.warn("Cannot setMultiDelay in web", e?.delayConditions);
+	}
+	async cancelDelay() {
+		console.warn("Cannot cancelDelay in web");
+	}
+	async isAutoUpdateAvailable() {
+		return console.warn("Cannot isAutoUpdateAvailable in web"), { available: !1 };
+	}
+	async getCurrentBundle() {
+		return console.warn("Cannot get current bundle in web"), n;
+	}
+	async getNextBundle() {
+		return Promise.resolve(null);
+	}
+	async getFailedUpdate() {
+		return console.warn("Cannot getFailedUpdate in web"), null;
+	}
+	async setShakeMenu(e) {
+		throw this.unimplemented("Shake menu not available on web platform");
+	}
+	async isShakeMenuEnabled() {
+		return Promise.resolve({
+			enabled: !1,
+			gesture: "shake"
+		});
+	}
+	async setShakeChannelSelector(e) {
+		throw this.unimplemented("Shake channel selector not available on web platform");
+	}
+	async isShakeChannelSelectorEnabled() {
+		return Promise.resolve({ enabled: !1 });
+	}
+	async getAppId() {
+		return console.warn("Cannot getAppId in web"), { appId: "default" };
+	}
+	async setAppId(e) {
+		console.warn("Cannot setAppId in web", e);
+	}
+	async getAppUpdateInfo(e) {
+		return console.warn("getAppUpdateInfo is not available on web platform"), {
+			currentVersionName: "0.0.0",
+			currentVersionCode: "0",
+			updateAvailability: t.UNKNOWN
+		};
+	}
+	async openAppStore(e) {
+		throw this.unimplemented("openAppStore is not available on web platform");
+	}
+	async performImmediateUpdate() {
+		throw this.unimplemented("performImmediateUpdate is only available on Android");
+	}
+	async startFlexibleUpdate() {
+		throw this.unimplemented("startFlexibleUpdate is only available on Android");
+	}
+	async completeFlexibleUpdate() {
+		throw this.unimplemented("completeFlexibleUpdate is only available on Android");
+	}
+};
+//#endregion
+export { r as CapacitorUpdaterWeb };

package/dist/interface/ha/web-Cpm1-DVe.js

@@ -0,0 +1,33 @@
+import { r as e } from "./dist-B7lgvbyI.js";
+//#region node_modules/@capacitor/app/dist/esm/web.js
+var t = class extends e {
+	constructor() {
+		super(), this.handleVisibilityChange = () => {
+			let e = { isActive: document.hidden !== !0 };
+			this.notifyListeners("appStateChange", e), document.hidden ? this.notifyListeners("pause", null) : this.notifyListeners("resume", null);
+		}, document.addEventListener("visibilitychange", this.handleVisibilityChange, !1);
+	}
+	exitApp() {
+		throw this.unimplemented("Not implemented on web.");
+	}
+	async getInfo() {
+		throw this.unimplemented("Not implemented on web.");
+	}
+	async getLaunchUrl() {
+		return { url: "" };
+	}
+	async getState() {
+		return { isActive: document.hidden !== !0 };
+	}
+	async minimizeApp() {
+		throw this.unimplemented("Not implemented on web.");
+	}
+	async toggleBackButtonHandler() {
+		throw this.unimplemented("Not implemented on web.");
+	}
+	async getAppLanguage() {
+		return { value: navigator.language.split("-")[0].toLowerCase() };
+	}
+};
+//#endregion
+export { t as AppWeb };

package/dist/interface/ha/web-DqRMXrnx.js

@@ -0,0 +1,31 @@
+import { t as e } from "./base-c1lsE5TW.js";
+//#region node_modules/@aparajita/capacitor-secure-storage/dist/esm/web.js
+var t = class extends e {
+	async setSynchronizeKeychain(e) {}
+	async internalGetItem(e) {
+		return { data: localStorage.getItem(e.prefixedKey) };
+	}
+	async internalSetItem(e) {
+		localStorage.setItem(e.prefixedKey, e.data);
+	}
+	async internalRemoveItem(e) {
+		return localStorage.getItem(e.prefixedKey) === null ? { success: !1 } : (localStorage.removeItem(e.prefixedKey), { success: !0 });
+	}
+	async clear() {
+		let { keys: e } = await this.getPrefixedKeys({ prefix: this.prefix });
+		for (let t of e) localStorage.removeItem(t);
+	}
+	async clearItemsWithPrefix(e) {
+		console.warn("clearItemsWithPrefix is native only");
+	}
+	async getPrefixedKeys(e) {
+		let t = [];
+		for (let n = 0; n < localStorage.length; n++) {
+			let r = localStorage.key(n);
+			r?.startsWith(e.prefix) && t.push(r);
+		}
+		return { keys: t };
+	}
+};
+//#endregion
+export { t as SecureStorageWeb };

package/dist/interface/ha/web-DtVT7WYt.js

@@ -0,0 +1,17 @@
+import { r as e } from "./dist-B7lgvbyI.js";
+//#region node_modules/@capacitor/share/dist/esm/web.js
+var t = class extends e {
+	async canShare() {
+		return typeof navigator > "u" || !navigator.share ? { value: !1 } : { value: !0 };
+	}
+	async share(e) {
+		if (typeof navigator > "u" || !navigator.share) throw this.unavailable("Share API not available in this browser");
+		return await navigator.share({
+			title: e.title,
+			text: e.text,
+			url: e.url
+		}), {};
+	}
+};
+//#endregion
+export { t as ShareWeb };

package/dist/interface/ha/web-DxJQZCiR.js

@@ -0,0 +1,59 @@
+import { i as e, n as t, r as n } from "./definitions-E-sY7Cxg.js";
+import { getBiometryName as r } from "./esm-CvxDASXR.js";
+import { t as i } from "./base-D_LAf3cS.js";
+//#region node_modules/@aparajita/capacitor-biometric-auth/dist/esm/web.js
+var a = class extends i {
+	constructor() {
+		super(...arguments), this.biometryType = e.none, this.biometryTypes = [], this.biometryIsEnrolled = !1, this.deviceIsSecure = !1;
+	}
+	async checkBiometry() {
+		let t = this.biometryType !== e.none, r = t && this.biometryIsEnrolled, i = "", a = n.none;
+		return t ? this.biometryIsEnrolled || (i = "Biometry is not enrolled", a = n.biometryNotEnrolled) : (i = "No biometry is available", a = n.biometryNotAvailable), {
+			isAvailable: r,
+			strongBiometryIsAvailable: this.biometryIsEnrolled && this.hasStrongBiometry(),
+			biometryType: this.biometryType,
+			biometryTypes: this.biometryTypes,
+			deviceIsSecure: this.deviceIsSecure,
+			reason: i,
+			code: a
+		};
+	}
+	hasStrongBiometry() {
+		return this.biometryTypes.some((t) => t === e.faceId || t === e.touchId || t === e.fingerprintAuthentication);
+	}
+	async internalAuthenticate(i) {
+		let a = await this.checkBiometry();
+		if (!(a.isAvailable && confirm(i?.reason || `Authenticate with ${a.biometryTypes.map((e) => r(e)).join(" or ")}?`))) {
+			if (i?.allowDeviceCredential) {
+				if (a.deviceIsSecure) {
+					if (confirm("Authenticate with device security?")) return;
+					throw new t("User cancelled", n.userCancel);
+				}
+				if (a.isAvailable) throw new t("Device is not secure", n.noDeviceCredential);
+			} else if (!a.isAvailable) throw a.biometryType === e.none ? new t("Biometry is not available", n.biometryNotAvailable) : new t("Biometry is not enrolled", n.biometryNotEnrolled);
+			throw new t("User cancelled", n.userCancel);
+		}
+	}
+	async setBiometryType(t) {
+		if (t === void 0) return;
+		let n = Array.isArray(t) ? t : [t];
+		if (this.biometryTypes = [], this.biometryType = e.none, n.length !== 0) {
+			if (s(n)) this.biometryType = n[0], this.biometryType !== e.none && (this.biometryTypes = n);
+			else for (let [t, r] of n.entries()) o(r) && (this.biometryType === e.none ? this.biometryTypes = [] : this.biometryTypes.push(r), t === 0 && (this.biometryType = r));
+		}
+	}
+	async setBiometryIsEnrolled(e) {
+		this.biometryIsEnrolled = e;
+	}
+	async setDeviceIsSecure(e) {
+		this.deviceIsSecure = e;
+	}
+};
+function o(t) {
+	return Object.values(e).includes(t);
+}
+function s(e) {
+	return e.every((e) => o(e));
+}
+//#endregion
+export { a as BiometricAuthWeb };

package/dist/interface/ha/web-I7Urp4AE.js

@@ -0,0 +1,46 @@
+import { r as e } from "./dist-B7lgvbyI.js";
+//#region node_modules/@capawesome/capacitor-badge/dist/esm/web.js
+var t = class t extends e {
+	constructor() {
+		super(), this.restore();
+	}
+	async checkPermissions() {
+		return { display: "granted" };
+	}
+	async requestPermissions() {
+		return { display: "granted" };
+	}
+	async get() {
+		let e = localStorage.getItem(t.STORAGE_KEY);
+		return { count: e ? parseInt(e, 10) : 0 };
+	}
+	async set(e) {
+		let n = e.count;
+		n === 0 ? await navigator.clearAppBadge() : await navigator.setAppBadge(n);
+		let r = n.toString();
+		localStorage.setItem(t.STORAGE_KEY, r);
+	}
+	async increase() {
+		let { count: e } = await this.get();
+		await this.set({ count: e + 1 });
+	}
+	async decrease() {
+		let { count: e } = await this.get();
+		e < 1 || await this.set({ count: e - 1 });
+	}
+	async clear() {
+		await this.set({ count: 0 });
+	}
+	async isSupported() {
+		return { isSupported: "setAppBadge" in navigator };
+	}
+	async restore() {
+		let e = localStorage.getItem(t.STORAGE_KEY);
+		if (!e) return;
+		let n = parseInt(e, 10);
+		await navigator.setAppBadge(n);
+	}
+};
+t.STORAGE_KEY = "capacitor.badge";
+//#endregion
+export { t as BadgeWeb };