@ait-co/polyfill 0.1.4 → 0.1.6

package/dist/auto.cjs

@@ -0,0 +1,919 @@
+//#region src/detect.ts
+/**
+* Environment detection: are we running inside Apps in Toss, or a plain browser?
+*
+* Strategy: call the SDK's `getAppsInTossGlobals()` — a synchronous export
+* that returns the runtime's Toss globals (deploymentId, brand name, …)
+* inside the Apps in Toss runtime and throws (RN bridge unavailable)
+* anywhere else. The SDK itself is an **optional** peer dependency; if its
+* module can't be imported we are definitely not inside Toss.
+*
+* Just having the SDK module resolvable is not enough — apps can bundle it
+* and still run in a plain browser. We need the bridge probe to confirm.
+*
+* UA sniffing (spoofable) is avoided. We do call `getAppsInTossGlobals`, but
+* that's a constant read from the bridge — no permission dialogs, no
+* analytics fire. In a plain browser the bridge lookup fails fast (sync
+* throw, microsecond-scale), so the startup cost is negligible.
+*/
+let cached;
+/**
+* Synchronous read of the cached detection result. Returns:
+*   - `true` / `false` if an override is active or the async detection has
+*     already resolved
+*   - `undefined` if detection hasn't run yet
+*
+* Used by spec-sync APIs (e.g. `navigator.canShare`) that can't `await`
+* detection.
+*/
+function isTossEnvironmentCached() {
+	const force = globalThis.__AIT_POLYFILL_FORCE__;
+	if (force === "toss") return true;
+	if (force === "browser") return false;
+	return cached;
+}
+/**
+* Returns `true` iff we detect we are running in an environment where the
+* Apps in Toss SDK (`@apps-in-toss/web-framework`) is present and usable.
+*
+* Async because we use dynamic `import()` to probe the optional peer dep
+* without forcing it into the consumer's bundle.
+*/
+async function isTossEnvironment() {
+	const force = globalThis.__AIT_POLYFILL_FORCE__;
+	if (force === "toss") return true;
+	if (force === "browser") return false;
+	if (cached !== void 0) return cached;
+	const mod = await loadTossSdk();
+	if (typeof mod?.getAppsInTossGlobals !== "function") {
+		cached = false;
+		return cached;
+	}
+	try {
+		const globals = mod.getAppsInTossGlobals();
+		cached = Boolean(globals) && typeof globals === "object";
+	} catch {
+		cached = false;
+	}
+	return cached;
+}
+/**
+* Lazy SDK accessor — returns the module if available, else `null`. Callers
+* are expected to `await` and null-check. Never throws.
+*/
+async function loadTossSdk() {
+	try {
+		return await import("@apps-in-toss/web-framework");
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/shims/_install-helpers.ts
+/**
+* Install `descriptor` at `navigator[prop]`. Prefer instance-level; if the
+* browser refuses (property is non-configurable on the instance), install on
+* `Navigator.prototype` instead.
+*
+* Returns a snapshot describing where the original value was, which
+* `restoreNavigatorProperty` uses to undo the install.
+*/
+function installNavigatorProperty(prop, descriptor) {
+	const nav = navigator;
+	const instanceDesc = Object.getOwnPropertyDescriptor(nav, prop);
+	const instanceHadOwn = instanceDesc !== void 0;
+	if (!instanceDesc || instanceDesc.configurable) try {
+		Object.defineProperty(nav, prop, descriptor);
+		return {
+			location: "instance",
+			originalDescriptor: instanceDesc,
+			instanceHadOwn
+		};
+	} catch {}
+	const proto = Object.getPrototypeOf(nav);
+	const protoDesc = Object.getOwnPropertyDescriptor(proto, prop);
+	if (instanceHadOwn) try {
+		delete nav[prop];
+	} catch {}
+	Object.defineProperty(proto, prop, descriptor);
+	return {
+		location: "prototype",
+		originalDescriptor: protoDesc,
+		instanceHadOwn
+	};
+}
+/**
+* Reverse the install recorded in `snapshot`. If the original descriptor was
+* `undefined` (property didn't exist before), delete the property instead of
+* re-defining it.
+*/
+function restoreNavigatorProperty(prop, snapshot) {
+	const target = snapshot.location === "instance" ? navigator : Object.getPrototypeOf(navigator);
+	if (snapshot.originalDescriptor) try {
+		Object.defineProperty(target, prop, snapshot.originalDescriptor);
+	} catch {}
+	else try {
+		delete target[prop];
+	} catch {}
+}
+/**
+* Mutate methods on an existing object rather than replacing the object
+* itself. This is the path we take for `navigator.geolocation`, `navigator.share`,
+* and `navigator.vibrate` in Chromium, where the slot on `navigator` is a
+* non-configurable own property that we cannot replace — but the methods
+* themselves (or the methods on the referenced object) are still
+* `configurable: true, writable: true`.
+*
+* Each replacement is installed via plain assignment. If any slot is not
+* writable (e.g. frozen object), install is aborted and previously-applied
+* replacements are rolled back, so the caller observes an atomic "all or
+* nothing" failure as `null`. The caller is expected to degrade gracefully
+* (e.g. log a one-time `console.warn`) when that happens.
+*/
+function installObjectMethods(target, replacements) {
+	const methods = {};
+	const applied = [];
+	const bag = target;
+	for (const key of Object.keys(replacements)) {
+		const hadOwn = Object.hasOwn(target, key);
+		const original = bag[key];
+		try {
+			bag[key] = replacements[key];
+		} catch {
+			for (const applieKey of applied) {
+				const prev = methods[applieKey];
+				if (!prev) continue;
+				if (prev.hadOwn) bag[applieKey] = prev.original;
+				else delete bag[applieKey];
+			}
+			return null;
+		}
+		if (bag[key] !== replacements[key]) {
+			for (const applieKey of applied) {
+				const prev = methods[applieKey];
+				if (!prev) continue;
+				if (prev.hadOwn) bag[applieKey] = prev.original;
+				else delete bag[applieKey];
+			}
+			return null;
+		}
+		methods[key] = {
+			hadOwn,
+			original
+		};
+		applied.push(key);
+	}
+	return {
+		target,
+		methods
+	};
+}
+/**
+* Reverse an `installObjectMethods` snapshot. Reassigns originals for slots
+* that were own properties before install; deletes the override for slots
+* that were inherited (so the prototype method surfaces again).
+*/
+function restoreObjectMethods(snapshot) {
+	const bag = snapshot.target;
+	for (const key of Object.keys(snapshot.methods)) {
+		const entry = snapshot.methods[key];
+		if (!entry) continue;
+		try {
+			if (entry.hadOwn) bag[key] = entry.original;
+			else delete bag[key];
+		} catch {}
+	}
+}
+//#endregion
+//#region src/shims/clipboard.ts
+/**
+* `navigator.clipboard` shim.
+*
+* Inside Apps in Toss → routes `readText` / `writeText` through the SDK
+* (`getClipboardText` / `setClipboardText`).
+*
+* Outside Apps in Toss → defers to the browser's native `navigator.clipboard`.
+* If the browser doesn't implement it, the standard `TypeError` / `DOMException`
+* surfaces unchanged — we don't paper over missing support.
+*/
+const BACKUP_KEY$2 = Symbol.for("@ait-co/polyfill/clipboard.original");
+const SNAPSHOT_KEY$2 = Symbol.for("@ait-co/polyfill/clipboard.snapshot");
+/**
+* Produces a Clipboard-compatible object whose `readText` / `writeText` methods
+* route to the SDK when in Toss, else fall through to the supplied `fallback`.
+*/
+function createClipboardShim(fallback) {
+	return {
+		async readText() {
+			if (await isTossEnvironment()) {
+				const sdk = await loadTossSdk();
+				if (sdk?.getClipboardText) return sdk.getClipboardText();
+			}
+			if (!fallback) throw new DOMException("[@ait-co/polyfill] navigator.clipboard.readText is not available in this environment.", "NotSupportedError");
+			return fallback.readText();
+		},
+		async writeText(text) {
+			if (await isTossEnvironment()) {
+				const sdk = await loadTossSdk();
+				if (sdk?.setClipboardText) return sdk.setClipboardText(text);
+			}
+			if (!fallback) throw new DOMException("[@ait-co/polyfill] navigator.clipboard.writeText is not available in this environment.", "NotSupportedError");
+			return fallback.writeText(text);
+		},
+		async read() {
+			if (await isTossEnvironment()) throw new DOMException("[@ait-co/polyfill] navigator.clipboard.read (rich content) is not supported in the Apps in Toss environment. Use readText instead.", "NotSupportedError");
+			if (!fallback?.read) throw new DOMException("[@ait-co/polyfill] navigator.clipboard.read is not available.", "NotSupportedError");
+			return fallback.read();
+		},
+		async write(items) {
+			if (await isTossEnvironment()) throw new DOMException("[@ait-co/polyfill] navigator.clipboard.write (rich content) is not supported in the Apps in Toss environment. Use writeText instead.", "NotSupportedError");
+			if (!fallback?.write) throw new DOMException("[@ait-co/polyfill] navigator.clipboard.write is not available.", "NotSupportedError");
+			return fallback.write(items);
+		},
+		addEventListener: (...args) => fallback?.addEventListener(...args),
+		removeEventListener: (...args) => fallback?.removeEventListener(...args),
+		dispatchEvent: (event) => fallback?.dispatchEvent(event) ?? false
+	};
+}
+/**
+* Install the `navigator.clipboard` shim.
+*
+* @returns an uninstall function that restores the original `navigator.clipboard`.
+*          Calling install twice without uninstalling is a no-op on the second call
+*          and returns the same uninstall function.
+*/
+function installClipboardShim() {
+	if (typeof navigator === "undefined") return () => {};
+	const host = navigator;
+	if (BACKUP_KEY$2 in host) return () => uninstallClipboardShim();
+	const original = navigator.clipboard;
+	host[BACKUP_KEY$2] = original;
+	host[SNAPSHOT_KEY$2] = installNavigatorProperty("clipboard", {
+		value: createClipboardShim(original),
+		configurable: true,
+		writable: true
+	});
+	return uninstallClipboardShim;
+}
+/**
+* Remove the shim and restore the pre-install shape.
+*/
+function uninstallClipboardShim() {
+	if (typeof navigator === "undefined") return;
+	const host = navigator;
+	if (!(BACKUP_KEY$2 in host)) return;
+	const snapshot = host[SNAPSHOT_KEY$2];
+	if (snapshot) restoreNavigatorProperty("clipboard", snapshot);
+	delete host[BACKUP_KEY$2];
+	delete host[SNAPSHOT_KEY$2];
+}
+//#endregion
+//#region src/shims/geolocation.ts
+/**
+* `navigator.geolocation` shim.
+*
+* Inside Apps in Toss → routes through the SDK:
+*   - `getCurrentPosition` → `getCurrentLocation({ accuracy })`
+*   - `watchPosition` / `clearWatch` → `startUpdateLocation({ onEvent, onError, options })`
+*
+* Outside Apps in Toss → defers to the browser's native `navigator.geolocation`.
+* If neither is available, the error callback receives a `GeolocationPositionError`.
+*
+* Install strategy: **method-level**. We do **not** replace `navigator.geolocation`
+* itself — Chromium marks that slot as a non-configurable own property, which
+* both `defineProperty(navigator, 'geolocation', …)` and the prototype-level
+* fallback cannot override (the instance shadow blocks prototype reads). We
+* instead mutate the methods on the existing `Geolocation` object, whose own
+* method descriptors are configurable+writable in every browser we've seen.
+*
+* SDK/Web shape mismatch handled here:
+*   - SDK `Accuracy` is a numeric enum (1 = Lowest … 6 = BestForNavigation); the
+*     standard `PositionOptions.enableHighAccuracy` is a boolean. We map
+*     `true → Accuracy.High (4, "~10m")` and `false → Accuracy.Balanced (3)`.
+*     `Highest (5)` / `BestForNavigation (6)` are available but carry a battery
+*     cost that's rarely what mini-apps want; consumers who need them should
+*     call the SDK directly.
+*   - SDK coords lack `speed`; we surface `null` (per the W3C spec when unknown).
+*   - SDK `startUpdateLocation` returns an `unsubscribe` fn; we wrap it behind
+*     a numeric watch id so `clearWatch(id)` behaves like the standard.
+*
+* Caveat: watch ids reset whenever the shim is uninstalled and reinstalled;
+* they are not stable across such cycles. Ids obtained before uninstall
+* cannot be cleared after uninstall — `clearWatch(id)` on the restored native
+* `navigator.geolocation` uses a different id space, so the SDK subscription
+* leaks. Consumers should `clearWatch` all outstanding ids before calling
+* `uninstall()`.
+*/
+const BACKUP_KEY$1 = Symbol.for("@ait-co/polyfill/geolocation.original");
+const SNAPSHOT_KEY$1 = Symbol.for("@ait-co/polyfill/geolocation.snapshot");
+const ACCURACY_BALANCED = 3;
+const ACCURACY_HIGH = 4;
+function toStandardPosition(sdk) {
+	const coordsData = {
+		latitude: sdk.coords.latitude,
+		longitude: sdk.coords.longitude,
+		altitude: sdk.coords.altitude,
+		accuracy: sdk.coords.accuracy,
+		altitudeAccuracy: sdk.coords.altitudeAccuracy,
+		heading: sdk.coords.heading,
+		speed: null
+	};
+	return {
+		coords: {
+			...coordsData,
+			toJSON() {
+				return { ...coordsData };
+			}
+		},
+		timestamp: sdk.timestamp,
+		toJSON() {
+			return {
+				coords: { ...coordsData },
+				timestamp: sdk.timestamp
+			};
+		}
+	};
+}
+function toPositionError(code, message) {
+	const Ctor = globalThis.GeolocationPositionError;
+	if (typeof Ctor === "function") {
+		const proto = Ctor.prototype;
+		if (proto) {
+			const shape = {
+				code,
+				message
+			};
+			Object.setPrototypeOf(shape, proto);
+			return shape;
+		}
+	}
+	return {
+		code,
+		message,
+		PERMISSION_DENIED: 1,
+		POSITION_UNAVAILABLE: 2,
+		TIMEOUT: 3
+	};
+}
+function accuracyFromOptions(options) {
+	return options?.enableHighAccuracy ? ACCURACY_HIGH : ACCURACY_BALANCED;
+}
+function createGeolocationShim(fallback) {
+	let nextWatchId = 1;
+	const sdkWatches = /* @__PURE__ */ new Map();
+	const nativeWatches = /* @__PURE__ */ new Map();
+	const pendingWatches = /* @__PURE__ */ new Map();
+	return {
+		getCurrentPosition(success, error, options) {
+			(async () => {
+				if (await isTossEnvironment()) {
+					const fn = (await loadTossSdk())?.getCurrentLocation;
+					if (typeof fn === "function") {
+						try {
+							success(toStandardPosition(await fn({ accuracy: accuracyFromOptions(options) })));
+						} catch (e) {
+							error?.(toPositionError(2, e instanceof Error ? e.message : "[@ait-co/polyfill] getCurrentLocation failed."));
+						}
+						return;
+					}
+				}
+				if (!fallback.getCurrentPosition) {
+					error?.(toPositionError(2, "[@ait-co/polyfill] navigator.geolocation is not available in this environment."));
+					return;
+				}
+				fallback.getCurrentPosition(success, error, options);
+			})();
+		},
+		watchPosition(success, error, options) {
+			const id = nextWatchId++;
+			const pending = { cancelled: false };
+			pendingWatches.set(id, pending);
+			(async () => {
+				if (await isTossEnvironment()) {
+					const fn = (await loadTossSdk())?.startUpdateLocation;
+					if (typeof fn === "function") {
+						if (pending.cancelled) {
+							pendingWatches.delete(id);
+							return;
+						}
+						const unsubscribe = fn({
+							onEvent: (loc) => success(toStandardPosition(loc)),
+							onError: (err) => error?.(toPositionError(2, err instanceof Error ? err.message : "[@ait-co/polyfill] startUpdateLocation failed.")),
+							options: {
+								accuracy: accuracyFromOptions(options),
+								timeInterval: 1e3,
+								distanceInterval: 0
+							}
+						});
+						if (pending.cancelled) {
+							unsubscribe();
+							pendingWatches.delete(id);
+							return;
+						}
+						sdkWatches.set(id, unsubscribe);
+						pendingWatches.delete(id);
+						return;
+					}
+				}
+				if (!fallback.watchPosition) {
+					pendingWatches.delete(id);
+					error?.(toPositionError(2, "[@ait-co/polyfill] navigator.geolocation is not available in this environment."));
+					return;
+				}
+				if (pending.cancelled) {
+					pendingWatches.delete(id);
+					return;
+				}
+				const nativeId = fallback.watchPosition(success, error, options);
+				if (pending.cancelled) {
+					fallback.clearWatch?.(nativeId);
+					pendingWatches.delete(id);
+					return;
+				}
+				nativeWatches.set(id, nativeId);
+				pendingWatches.delete(id);
+			})();
+			return id;
+		},
+		clearWatch(id) {
+			const pending = pendingWatches.get(id);
+			if (pending) {
+				pending.cancelled = true;
+				pendingWatches.delete(id);
+				return;
+			}
+			const unsubscribe = sdkWatches.get(id);
+			if (unsubscribe) {
+				unsubscribe();
+				sdkWatches.delete(id);
+				return;
+			}
+			const nativeId = nativeWatches.get(id);
+			if (nativeId !== void 0 && fallback.clearWatch) {
+				fallback.clearWatch(nativeId);
+				nativeWatches.delete(id);
+			}
+		}
+	};
+}
+function installGeolocationShim() {
+	if (typeof navigator === "undefined") return () => {};
+	const host = navigator;
+	if (BACKUP_KEY$1 in host) return () => uninstallGeolocationShim();
+	const target = navigator.geolocation;
+	if (!target) {
+		host[BACKUP_KEY$1] = void 0;
+		return () => uninstallGeolocationShim();
+	}
+	const shim = createGeolocationShim({
+		getCurrentPosition: target.getCurrentPosition?.bind(target),
+		watchPosition: target.watchPosition?.bind(target),
+		clearWatch: target.clearWatch?.bind(target)
+	});
+	const snapshot = installObjectMethods(target, {
+		getCurrentPosition: shim.getCurrentPosition,
+		watchPosition: shim.watchPosition,
+		clearWatch: shim.clearWatch
+	});
+	if (!snapshot) {
+		host[BACKUP_KEY$1] = void 0;
+		return () => uninstallGeolocationShim();
+	}
+	host[BACKUP_KEY$1] = { target };
+	host[SNAPSHOT_KEY$1] = snapshot;
+	return uninstallGeolocationShim;
+}
+function uninstallGeolocationShim() {
+	if (typeof navigator === "undefined") return;
+	const host = navigator;
+	if (!(BACKUP_KEY$1 in host)) return;
+	const snapshot = host[SNAPSHOT_KEY$1];
+	if (snapshot) restoreObjectMethods(snapshot);
+	delete host[BACKUP_KEY$1];
+	delete host[SNAPSHOT_KEY$1];
+}
+//#endregion
+//#region src/shims/network.ts
+/**
+* `navigator.onLine` + `navigator.connection` shim.
+*
+* Inside Apps in Toss → seeded from SDK `getNetworkStatus()` on install and
+* refreshed on read (throttled):
+*   - `'OFFLINE'`   → `onLine = false`
+*   - `'WIFI'`      → `onLine = true`, `effectiveType = '4g'` (no web wifi value)
+*   - `'2G'/'3G'/'4G'/'5G'` → `onLine = true`, `effectiveType = <lowercased>`
+*   - `'WWAN'/'UNKNOWN'`    → `onLine = true`, `effectiveType = '4g'` (best guess)
+*
+* Outside Apps in Toss → both `navigator.onLine` and `navigator.connection`
+* read through to the native value. Install installs own-instance getters
+* that consult the Toss-seeded cache first; when the cache is empty (which
+* it always is in browser mode), the getter temporarily removes its own
+* shadow, reads the prototype value, and reinstates the shadow.
+*
+* Uninstall `delete`s the instance-level override so the prototype descriptor
+* (where `onLine` and `connection` actually live in real browsers) becomes
+* visible again. We never mutate the prototype — doing so would throw in
+* browsers where the descriptor is non-configurable.
+*
+* Browser-compat caveat (Chromium): `navigator.onLine` and `navigator.connection`
+* are value slots, not methods, so the method-level install trick we use for
+* `geolocation`/`share`/`vibrate` does not apply here. When Chromium marks the
+* instance descriptor as non-configurable AND the prototype descriptor is also
+* non-configurable, we cannot install. In that case the shim logs a one-time
+* `console.warn` and leaves the native values in place — consumers keep the
+* browser's own `onLine`/`connection` values; the SDK-synced state is simply
+* disabled for that session.
+*
+* Caveat: the Web NetworkInformation API is evented (`change` fires on
+* transitions). The SDK exposes only a one-shot query, so listeners attached
+* to `navigator.connection` are accepted but never fire from a `change` event
+* unless the shim observes a real status transition. Synthesising richer
+* events via polling is tracked in TODO.md.
+*
+* Lifecycle: `navigator.connection` is a ShimConnection instance that lives in
+* the install closure. On uninstall the instance-level override is removed,
+* but listeners the consumer attached to the old instance stay bound to that
+* (now-orphan) object and will not see events from a subsequent install.
+* Consumers should re-attach listeners after each install.
+*
+* Seed-boundary race: in Toss mode, reads before the install-time SDK seed
+* completes fall through to the native `navigator.connection`. After the seed
+* lands, subsequent reads return the shim's ShimConnection. Consumers that
+* specifically need the ShimConnection instance (e.g., to attach `change`
+* listeners that fire on Toss network transitions) should wait a microtask
+* after `install()` before attaching listeners, or accept that pre-seed
+* reads may return the native object.
+*/
+const INSTALLED_KEY = Symbol.for("@ait-co/polyfill/network.installed");
+const ON_LINE_SNAPSHOT_KEY = Symbol.for("@ait-co/polyfill/network.onLine.snapshot");
+const CONNECTION_SNAPSHOT_KEY = Symbol.for("@ait-co/polyfill/network.connection.snapshot");
+const REFRESH_THROTTLE_MS = 500;
+function statusToOnline(status) {
+	return status !== "OFFLINE";
+}
+function statusToEffectiveType(status) {
+	switch (status) {
+		case "2G": return "2g";
+		case "3G": return "3g";
+		default: return "4g";
+	}
+}
+function statusToConnectionType(status) {
+	switch (status) {
+		case "WIFI": return "wifi";
+		case "2G":
+		case "3G":
+		case "4G":
+		case "5G":
+		case "WWAN": return "cellular";
+		case "OFFLINE": return "none";
+		default: return "unknown";
+	}
+}
+const SET_STATUS = Symbol("@ait-co/polyfill/network.setStatus");
+var ShimConnection = class extends EventTarget {
+	#status = null;
+	onchange = null;
+	constructor() {
+		super();
+		this.addEventListener("change", (ev) => this.onchange?.call(this, ev));
+	}
+	[SET_STATUS](next) {
+		this.#status = next;
+	}
+	get effectiveType() {
+		return statusToEffectiveType(this.#status ?? "UNKNOWN");
+	}
+	get downlink() {
+		return 0;
+	}
+	get rtt() {
+		return 0;
+	}
+	get saveData() {
+		return false;
+	}
+	get type() {
+		return statusToConnectionType(this.#status ?? "UNKNOWN");
+	}
+};
+function installNetworkShim() {
+	if (typeof navigator === "undefined") return () => {};
+	const host = navigator;
+	if (host[INSTALLED_KEY]) return () => uninstallNetworkShim();
+	host[INSTALLED_KEY] = true;
+	let cachedStatus = null;
+	let lastRefresh = 0;
+	let inflight = null;
+	const connection = new ShimConnection();
+	async function refresh() {
+		if (inflight) return inflight;
+		if (Date.now() - lastRefresh < REFRESH_THROTTLE_MS) return;
+		inflight = (async () => {
+			try {
+				if (!await isTossEnvironment()) return;
+				const fn = (await loadTossSdk())?.getNetworkStatus;
+				if (typeof fn !== "function") return;
+				const next = await fn();
+				const prev = cachedStatus;
+				cachedStatus = next;
+				connection[SET_STATUS](next);
+				if (prev !== null && prev !== next) connection.dispatchEvent(new Event("change"));
+			} catch {} finally {
+				lastRefresh = Date.now();
+				inflight = null;
+			}
+		})();
+		return inflight;
+	}
+	const nativeOnLine = navigator.onLine;
+	const nativeConnection = navigator.connection;
+	refresh();
+	let installWarned = false;
+	const warnNonConfigurable = (e) => {
+		if (installWarned) return;
+		installWarned = true;
+		console.warn("[@ait-co/polyfill] navigator.onLine/connection is non-configurable in this browser; Toss network status sync disabled.", e);
+	};
+	try {
+		host[ON_LINE_SNAPSHOT_KEY] = installNavigatorProperty("onLine", {
+			configurable: true,
+			get() {
+				refresh();
+				if (cachedStatus !== null) return statusToOnline(cachedStatus);
+				return nativeOnLine ?? true;
+			}
+		});
+	} catch (e) {
+		warnNonConfigurable(e);
+	}
+	try {
+		host[CONNECTION_SNAPSHOT_KEY] = installNavigatorProperty("connection", {
+			configurable: true,
+			get() {
+				refresh();
+				if (cachedStatus === null && nativeConnection !== void 0) return nativeConnection;
+				return connection;
+			}
+		});
+	} catch (e) {
+		warnNonConfigurable(e);
+	}
+	return uninstallNetworkShim;
+}
+function uninstallNetworkShim() {
+	if (typeof navigator === "undefined") return;
+	const host = navigator;
+	if (!host[INSTALLED_KEY]) return;
+	const onLineSnap = host[ON_LINE_SNAPSHOT_KEY];
+	if (onLineSnap) restoreNavigatorProperty("onLine", onLineSnap);
+	const connSnap = host[CONNECTION_SNAPSHOT_KEY];
+	if (connSnap) restoreNavigatorProperty("connection", connSnap);
+	delete host[INSTALLED_KEY];
+	delete host[ON_LINE_SNAPSHOT_KEY];
+	delete host[CONNECTION_SNAPSHOT_KEY];
+}
+//#endregion
+//#region src/shims/share.ts
+/**
+* `navigator.share` shim.
+*
+* Inside Apps in Toss → routes through SDK `share({ message })`. The SDK only
+* accepts a single `message` string, so we concatenate `title`, `text`, and
+* `url` with newline separators (skipping missing/empty values).
+*
+* Outside Apps in Toss → defers to the browser's native `navigator.share`, or
+* throws `NotSupportedError` if unavailable.
+*
+* Install strategy: **method-level** on `navigator`. Assigning
+* `navigator.share = fn` creates an own property that shadows the prototype
+* method. Uninstall deletes the own shadow so the prototype method surfaces
+* again. We do not mutate `Navigator.prototype` — in real browsers its
+* descriptor may be non-configurable, which would throw on reassignment.
+*
+* Caveat: the SDK's share has no counterpart for `files` (Web Share Level 2).
+* `canShare({ files })` returns `false` whenever the sync-accessible detection
+* says Toss is active (or is being forced via the test override).
+*/
+const SHARE_BACKUP_KEY = Symbol.for("@ait-co/polyfill/share.original");
+const SHARE_SNAPSHOT_KEY = Symbol.for("@ait-co/polyfill/share.snapshot");
+function buildSdkMessage(data) {
+	const parts = [];
+	if (data?.title != null && data.title !== "") parts.push(data.title);
+	if (data?.text != null && data.text !== "") parts.push(data.text);
+	if (data?.url != null && data.url !== "") parts.push(data.url);
+	return parts.join("\n");
+}
+async function shareShim(data) {
+	if (await isTossEnvironment()) {
+		const fn = (await loadTossSdk())?.share;
+		if (typeof fn === "function") {
+			const message = buildSdkMessage(data);
+			if (!message) throw new TypeError("[@ait-co/polyfill] navigator.share requires at least one of title, text, or url.");
+			try {
+				await fn({ message });
+			} catch (e) {
+				const message_ = e instanceof Error ? e.message : String(e);
+				const wrapped = new DOMException(message_, "AbortError");
+				if (e instanceof Error) wrapped.cause = e;
+				throw wrapped;
+			}
+			return;
+		}
+	}
+	const original = navigator[SHARE_BACKUP_KEY]?.share;
+	if (!original) throw new DOMException("[@ait-co/polyfill] navigator.share is not available in this environment.", "NotSupportedError");
+	return original(data);
+}
+function canShareShim(data) {
+	const hasFiles = Boolean(data?.files && data.files.length > 0);
+	const toss = isTossEnvironmentCached();
+	if (hasFiles) {
+		if (toss === true) return false;
+		if (toss === void 0) return false;
+	}
+	if (toss === true) return Boolean(data?.title != null && data.title !== "" || data?.text != null && data.text !== "" || data?.url != null && data.url !== "");
+	const originalCanShare = navigator[SHARE_BACKUP_KEY]?.canShare;
+	if (originalCanShare) return originalCanShare(data);
+	return Boolean(data?.title != null && data.title !== "" || data?.text != null && data.text !== "" || data?.url != null && data.url !== "");
+}
+function installShareShim() {
+	if (typeof navigator === "undefined") return () => {};
+	const host = navigator;
+	if (SHARE_BACKUP_KEY in host) return () => uninstallShareShim();
+	const nav = navigator;
+	host[SHARE_BACKUP_KEY] = {
+		share: nav.share ? nav.share.bind(navigator) : void 0,
+		canShare: nav.canShare ? nav.canShare.bind(navigator) : void 0
+	};
+	const snapshot = installObjectMethods(navigator, {
+		share: shareShim,
+		canShare: canShareShim
+	});
+	if (!snapshot) {
+		delete host[SHARE_BACKUP_KEY];
+		return () => uninstallShareShim();
+	}
+	host[SHARE_SNAPSHOT_KEY] = snapshot;
+	return uninstallShareShim;
+}
+function uninstallShareShim() {
+	if (typeof navigator === "undefined") return;
+	const host = navigator;
+	if (!(SHARE_BACKUP_KEY in host)) return;
+	const snapshot = host[SHARE_SNAPSHOT_KEY];
+	if (snapshot) restoreObjectMethods(snapshot);
+	delete host[SHARE_BACKUP_KEY];
+	delete host[SHARE_SNAPSHOT_KEY];
+}
+//#endregion
+//#region src/shims/vibrate.ts
+/**
+* `navigator.vibrate` shim.
+*
+* Inside Apps in Toss → best-effort mapping to SDK `generateHapticFeedback`.
+* Single-duration calls land in three buckets so the qualitative SDK haptic
+* tracks intensity a little more closely than the original two-bucket split:
+*   - `vibrate(0)` → no-op (web standard: cancels pending vibration)
+*   - `vibrate(1..20ms)` → `tickWeak`
+*   - `vibrate(21..45ms)` → `tickMedium`
+*   - `vibrate(>=46ms)` → `basicMedium`
+*   - `vibrate(number[])` → iterates "on" segments (even indices) as `tap`
+*     pulses with `setTimeout` gaps. Per-element ms mapping is intentionally
+*     skipped: arrays in the wild are mostly rhythmic patterns, and the SDK
+*     has no "stronger heavy" variant to reach for, so per-pulse precision
+*     buys little. Callers needing intent should use `vibrateSemantic`.
+*
+* Outside Apps in Toss → defers to the browser's native `navigator.vibrate`,
+* or returns `false` when unavailable (matches the spec — browsers that don't
+* support vibration simply return `false`).
+*
+* Install strategy: **method-level** on `navigator`. We assign our wrapper to
+* `navigator.vibrate` (creating an own shadow over the prototype method) and
+* delete it on uninstall so the prototype re-surfaces. We do not mutate
+* `Navigator.prototype` itself — browsers may mark it non-configurable.
+*
+* Caveats (documented in CLAUDE.md as the known lossy trade-off):
+*   - SDK haptics are qualitative ("tickWeak", "basicMedium"), not millisecond
+*     durations. The shim approximates intensity from duration but cannot
+*     reproduce exact patterns. Length-only mapping cannot recover semantic
+*     intent (success vs. error vs. warning); use `vibrateSemantic` for that.
+*   - Arrays are fired sequentially via `setTimeout`; gaps between pulses are
+*     honoured only as "time until the next tap", not as silent-vs-vibrating.
+*   - `vibrate` is spec'd as **synchronous**; the SDK call is async. We return
+*     `true` immediately (fire-and-forget). Errors from the SDK are swallowed.
+*/
+const BACKUP_KEY = Symbol.for("@ait-co/polyfill/vibrate.original");
+const SNAPSHOT_KEY = Symbol.for("@ait-co/polyfill/vibrate.snapshot");
+const TICK_WEAK_MAX_MS = 20;
+const TICK_MEDIUM_MAX_MS = 45;
+async function haptic(type) {
+	const fn = (await loadTossSdk())?.generateHapticFeedback;
+	if (typeof fn === "function") try {
+		await fn({ type });
+	} catch {}
+}
+function durationToHaptic(duration) {
+	if (duration <= TICK_WEAK_MAX_MS) return "tickWeak";
+	if (duration <= TICK_MEDIUM_MAX_MS) return "tickMedium";
+	return "basicMedium";
+}
+function vibrateShim(pattern) {
+	const arr = Array.isArray(pattern) ? pattern : [pattern];
+	if (arr.length === 0 || arr.every((n) => n === 0)) {
+		(async () => {
+			if (!await isTossEnvironment()) navigator[BACKUP_KEY]?.(pattern);
+		})();
+		return true;
+	}
+	(async () => {
+		if (await isTossEnvironment()) {
+			if (!Array.isArray(pattern)) {
+				await haptic(durationToHaptic(pattern));
+				return;
+			}
+			for (let i = 0; i < pattern.length; i += 2) {
+				const on = pattern[i];
+				if (on === void 0) break;
+				if (on > 0) await haptic("tap");
+				const pause = pattern[i + 1];
+				if (typeof pause === "number" && pause > 0) await new Promise((r) => setTimeout(r, pause));
+			}
+			return;
+		}
+		const original = navigator[BACKUP_KEY];
+		original?.(pattern);
+	})();
+	return true;
+}
+function installVibrateShim() {
+	if (typeof navigator === "undefined") return () => {};
+	const host = navigator;
+	if (BACKUP_KEY in host) return () => uninstallVibrateShim();
+	const nav = navigator;
+	host[BACKUP_KEY] = nav.vibrate ? nav.vibrate.bind(navigator) : void 0;
+	const snapshot = installObjectMethods(navigator, { vibrate: vibrateShim });
+	if (!snapshot) {
+		delete host[BACKUP_KEY];
+		return () => uninstallVibrateShim();
+	}
+	host[SNAPSHOT_KEY] = snapshot;
+	return uninstallVibrateShim;
+}
+function uninstallVibrateShim() {
+	if (typeof navigator === "undefined") return;
+	const host = navigator;
+	if (!(BACKUP_KEY in host)) return;
+	const snapshot = host[SNAPSHOT_KEY];
+	if (snapshot) restoreObjectMethods(snapshot);
+	delete host[BACKUP_KEY];
+	delete host[SNAPSHOT_KEY];
+}
+//#endregion
+//#region src/index.ts
+const NOOP = () => {};
+/**
+* Install every shim this library ships, but only if we detect an Apps in
+* Toss runtime. In a plain browser `install()` is a no-op — the browser's
+* native APIs stay untouched.
+*
+* Returns a promise that resolves with an uninstall function. If the
+* environment turns out not to be Toss, the uninstall function is a no-op.
+*
+* Install order (when active): clipboard → geolocation → share → vibrate →
+* network. Not atomic on failure — if a per-shim install throws (e.g., a
+* consumer pinned a target navigator property as non-configurable), earlier
+* shims are already in place. Callers should catch and invoke the returned
+* uninstall to roll back.
+*/
+async function install() {
+	if (!await isTossEnvironment()) return NOOP;
+	const uninstalls = [
+		installClipboardShim(),
+		installGeolocationShim(),
+		installShareShim(),
+		installVibrateShim(),
+		installNetworkShim()
+	];
+	return () => {
+		for (const fn of uninstalls) fn();
+	};
+}
+//#endregion
+//#region src/auto.ts
+/**
+* Side-effect entry point: `import '@ait-co/polyfill/auto'`
+*
+* Kicks off detection and, if we're inside Apps in Toss, installs every shim
+* this library ships. In a plain browser this is a no-op — browser native
+* APIs stay untouched. No-op idempotent: importing the entry more than once
+* doesn't re-install.
+*
+* Use this when you want the "just add the dep" experience. If you need to
+* observe when the polyfill actually attached (to gate init logic) or to tear
+* it down, import `install` / `uninstall` from `@ait-co/polyfill` directly.
+*/
+install();
+//#endregion
+
+//# sourceMappingURL=auto.cjs.map