@ziztechnology/dial-library 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -1,6 +1,1734 @@
+import { Gunzip } from "fflate";
+//#region src/sensor/check_status.ts
+const DEFAULT_DRIVING_STATUS_TUNING = Object.freeze({
+	version: "driving-status-v1",
+	maxSampleAgeMs: 1e3,
+	rapidLongitudinalThreshold: 3,
+	longitudinalThreshold: 1,
+	turnYawThreshold: .5,
+	turnLateralThreshold: 2.5,
+	motionWindowMs: 1e3,
+	motionMinimumSamples: 5,
+	drivingMotionThreshold: .4,
+	stoppedMotionThreshold: .25,
+	stoppedGyroThreshold: .1,
+	hysteresisRatio: .75,
+	smoothingWindowSize: 3,
+	confirmationSamples: Object.freeze({
+		STOPPED: 5,
+		STEADY_DRIVING: 3,
+		ACCELERATION: 2,
+		RAPID_ACCELERATION: 1,
+		BRAKING: 2,
+		SUDDEN_BRAKING: 1,
+		LEFT_TURN: 2,
+		RIGHT_TURN: 2
+	}),
+	minimumDisplayMs: Object.freeze({
+		STOPPED: 1200,
+		STEADY_DRIVING: 1200,
+		ACCELERATION: 700,
+		RAPID_ACCELERATION: 1200,
+		BRAKING: 700,
+		SUDDEN_BRAKING: 1200,
+		LEFT_TURN: 800,
+		RIGHT_TURN: 800
+	})
+});
+const classifyDrivingSnapshot = (info, tuningOverrides) => {
+	const tuning = resolveDrivingStatusTuning(tuningOverrides);
+	const metrics = extractDrivingSnapshotMetrics(info, tuning);
+	return metrics === null ? null : classifyDrivingMetrics(metrics, tuning);
+};
+const checkRunningStatus = classifyDrivingSnapshot;
+const resolveDrivingStatusTuning = (overrides = {}) => {
+	const tuning = {
+		...DEFAULT_DRIVING_STATUS_TUNING,
+		...overrides,
+		confirmationSamples: {
+			...DEFAULT_DRIVING_STATUS_TUNING.confirmationSamples,
+			...overrides.confirmationSamples
+		},
+		minimumDisplayMs: {
+			...DEFAULT_DRIVING_STATUS_TUNING.minimumDisplayMs,
+			...overrides.minimumDisplayMs
+		}
+	};
+	assertPositiveFinite("maxSampleAgeMs", tuning.maxSampleAgeMs);
+	assertPositiveFinite("rapidLongitudinalThreshold", tuning.rapidLongitudinalThreshold);
+	assertPositiveFinite("longitudinalThreshold", tuning.longitudinalThreshold);
+	assertPositiveFinite("turnYawThreshold", tuning.turnYawThreshold);
+	assertPositiveFinite("turnLateralThreshold", tuning.turnLateralThreshold);
+	assertPositiveFinite("motionWindowMs", tuning.motionWindowMs);
+	if (!Number.isInteger(tuning.motionMinimumSamples) || tuning.motionMinimumSamples < 1) throw new RangeError("motionMinimumSamples must be a positive integer");
+	assertPositiveFinite("drivingMotionThreshold", tuning.drivingMotionThreshold);
+	assertPositiveFinite("stoppedMotionThreshold", tuning.stoppedMotionThreshold);
+	assertPositiveFinite("stoppedGyroThreshold", tuning.stoppedGyroThreshold);
+	if (tuning.drivingMotionThreshold <= tuning.stoppedMotionThreshold) throw new RangeError("drivingMotionThreshold must be greater than stoppedMotionThreshold");
+	if (!Number.isInteger(tuning.smoothingWindowSize) || tuning.smoothingWindowSize < 1) throw new RangeError("smoothingWindowSize must be a positive integer");
+	if (tuning.rapidLongitudinalThreshold < tuning.longitudinalThreshold) throw new RangeError("rapidLongitudinalThreshold must be greater than or equal to longitudinalThreshold");
+	if (!Number.isFinite(tuning.hysteresisRatio) || tuning.hysteresisRatio <= 0 || tuning.hysteresisRatio >= 1) throw new RangeError("hysteresisRatio must be greater than 0 and less than 1");
+	for (const [status, value] of Object.entries(tuning.confirmationSamples)) if (!Number.isInteger(value) || value < 1) throw new RangeError(`confirmationSamples.${status} must be a positive integer`);
+	for (const [status, value] of Object.entries(tuning.minimumDisplayMs)) if (!Number.isFinite(value) || value < 0) throw new RangeError(`minimumDisplayMs.${status} must be a non-negative finite number`);
+	return tuning;
+};
+const extractDrivingSnapshotMetrics = (info, tuning = DEFAULT_DRIVING_STATUS_TUNING) => {
+	if (!info || !Number.isFinite(info.capturedAtMs)) return null;
+	const linearAcceleration = availableFreshVector(info.linearAcceleration, info.capturedAtMs, tuning.maxSampleAgeMs);
+	const gyroscope = availableFreshVector(info.gyroscope, info.capturedAtMs, tuning.maxSampleAgeMs);
+	if (linearAcceleration === null || gyroscope === null) return null;
+	const longitudinal = -linearAcceleration.z;
+	const lateral = linearAcceleration.x;
+	const yaw = gyroscope.y;
+	const motionIntensity = info.motionIntensity === void 0 ? vectorMagnitude(linearAcceleration) : availableFreshNumber(info.motionIntensity, info.capturedAtMs, tuning.maxSampleAgeMs);
+	if (motionIntensity === null) return null;
+	return {
+		capturedAtMs: info.capturedAtMs,
+		longitudinal,
+		lateral,
+		yaw,
+		motionIntensity,
+		gyroMagnitude: vectorMagnitude(gyroscope)
+	};
+};
+const classifyDrivingMetrics = (metrics, tuning = DEFAULT_DRIVING_STATUS_TUNING) => {
+	const { longitudinal, lateral, yaw, motionIntensity, gyroMagnitude } = metrics;
+	if (longitudinal <= -tuning.rapidLongitudinalThreshold) return "SUDDEN_BRAKING";
+	if (longitudinal >= tuning.rapidLongitudinalThreshold) return "RAPID_ACCELERATION";
+	if (Math.abs(yaw) >= tuning.turnYawThreshold) return yaw > 0 ? "LEFT_TURN" : "RIGHT_TURN";
+	if (Math.abs(lateral) >= tuning.turnLateralThreshold) return lateral < 0 ? "LEFT_TURN" : "RIGHT_TURN";
+	if (longitudinal <= -tuning.longitudinalThreshold) return "BRAKING";
+	if (longitudinal >= tuning.longitudinalThreshold) return "ACCELERATION";
+	if (motionIntensity < tuning.drivingMotionThreshold && gyroMagnitude <= tuning.stoppedGyroThreshold) return "STOPPED";
+	return "STEADY_DRIVING";
+};
+const availableFreshVector = (metric, capturedAtMs, maxSampleAgeMs) => {
+	if (!metric?.available || !isFresh(metric.sampledAtMs, capturedAtMs, maxSampleAgeMs)) return null;
+	const { x, y, z } = metric.value;
+	return [
+		x,
+		y,
+		z
+	].every(Number.isFinite) ? metric.value : null;
+};
+const availableFreshNumber = (metric, capturedAtMs, maxSampleAgeMs) => {
+	if (!metric?.available || !isFresh(metric.sampledAtMs, capturedAtMs, maxSampleAgeMs)) return null;
+	return Number.isFinite(metric.value) && metric.value >= 0 ? metric.value : null;
+};
+const isFresh = (sampledAtMs, capturedAtMs, maxSampleAgeMs) => {
+	if (sampledAtMs === null || !Number.isFinite(sampledAtMs)) return false;
+	const age = capturedAtMs - sampledAtMs;
+	return age >= 0 && age <= maxSampleAgeMs;
+};
+const vectorMagnitude = ({ x, y, z }) => Math.hypot(x, y, z);
+const assertPositiveFinite = (name, value) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a positive finite number`);
+};
+//#endregion
 //#region src/sensor/unified_info.ts
 const unifiedSensorInfo = () => {
 	return window.unifiedSensorInfo();
 };
 //#endregion
-export { unifiedSensorInfo };
+//#region src/sensor/constants.ts
+const BATTERY_HEALTH_LABELS = {
+	GOOD: "良好",
+	OVERHEAT: "过热",
+	DEAD: "失效",
+	OVER_VOLTAGE: "电压过高",
+	UNSPECIFIED_FAILURE: "异常",
+	COLD: "温度过低",
+	UNKNOWN: "未知"
+};
+const CAR_RUNNING_LABELS = {
+	STOPPED: "静止",
+	STEADY_DRIVING: "匀速行驶",
+	SUDDEN_BRAKING: "急刹车",
+	BRAKING: "刹车",
+	LEFT_TURN: "左转",
+	RIGHT_TURN: "右转",
+	ACCELERATION: "加速",
+	RAPID_ACCELERATION: "急加速"
+};
+const CAR_RUNNING_STATUSES = [
+	"STOPPED",
+	"STEADY_DRIVING",
+	"ACCELERATION",
+	"RAPID_ACCELERATION",
+	"BRAKING",
+	"SUDDEN_BRAKING",
+	"LEFT_TURN",
+	"RIGHT_TURN"
+];
+const CAR_RUNNING_STATUS_PRIORITY = {
+	STOPPED: 0,
+	STEADY_DRIVING: 0,
+	ACCELERATION: 1,
+	BRAKING: 2,
+	LEFT_TURN: 3,
+	RIGHT_TURN: 3,
+	RAPID_ACCELERATION: 4,
+	SUDDEN_BRAKING: 5
+};
+//#endregion
+//#region src/sensor/driving_expressions.ts
+const OFFICIAL_DRIVING_EXPRESSION_FALLBACKS = Object.freeze({
+	STOPPED: Object.freeze({
+		kind: "emoji",
+		text: "😐"
+	}),
+	STEADY_DRIVING: Object.freeze({
+		kind: "emoji",
+		text: "😊"
+	}),
+	ACCELERATION: Object.freeze({
+		kind: "emoji",
+		text: "😄"
+	}),
+	RAPID_ACCELERATION: Object.freeze({
+		kind: "emoji",
+		text: "😲"
+	}),
+	BRAKING: Object.freeze({
+		kind: "emoji",
+		text: "😣"
+	}),
+	SUDDEN_BRAKING: Object.freeze({
+		kind: "emoji",
+		text: "😱"
+	}),
+	LEFT_TURN: Object.freeze({
+		kind: "emoji",
+		text: "🤨"
+	}),
+	RIGHT_TURN: Object.freeze({
+		kind: "emoji",
+		text: "🤨"
+	})
+});
+const OFFICIAL_DRIVING_EXPRESSIONS_CONFIG = Object.freeze({
+	schemaVersion: 1,
+	states: OFFICIAL_DRIVING_EXPRESSION_FALLBACKS
+});
+var DrivingExpressionsConfigError = class extends Error {
+	constructor(code, message, state) {
+		super(message);
+		this.name = "DrivingExpressionsConfigError";
+		this.code = code;
+		this.state = state;
+	}
+};
+var DrivingExpressionResolutionError = class extends Error {
+	constructor(status) {
+		super(`No driving expression is configured for ${status}`);
+		this.name = "DrivingExpressionResolutionError";
+		this.status = status;
+	}
+};
+const parseDrivingExpressionsConfig = (raw, options = {}) => {
+	const parsed = parseJsonObject(raw);
+	if (parsed.schemaVersion !== 1 || !isRecord$1(parsed.states)) throw new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INVALID_SCHEMA", "drivingExpressions must use schemaVersion 1 and contain a states object");
+	const knownStatuses = new Set(CAR_RUNNING_STATUSES);
+	const stateKeys = Object.keys(parsed.states);
+	if (stateKeys.length !== CAR_RUNNING_STATUSES.length || stateKeys.some((key) => !knownStatuses.has(key))) throw new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INCOMPLETE", "drivingExpressions.states must contain exactly the eight supported statuses");
+	const states = {};
+	for (const status of CAR_RUNNING_STATUSES) {
+		if (!Object.prototype.hasOwnProperty.call(parsed.states, status)) throw new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INCOMPLETE", `drivingExpressions.states is missing ${status}`, status);
+		states[status] = parseDrivingExpressionMedia(parsed.states[status], status, options);
+	}
+	return {
+		schemaVersion: 1,
+		states
+	};
+};
+const tryParseDrivingExpressionsConfig = (raw, options) => {
+	try {
+		return parseDrivingExpressionsConfig(raw, options);
+	} catch {
+		return null;
+	}
+};
+/**
+* Reads Runtime's typed injection first, then the legacy face-config value.
+* It never installs official fallbacks implicitly.
+*/
+const readDrivingExpressionsConfig = (raw, options) => {
+	const source = raw === void 0 ? readRuntimeDrivingExpressionsValue() : raw;
+	return source === void 0 ? null : tryParseDrivingExpressionsConfig(source, options);
+};
+/** Original resolver behavior: missing legacy slots fall back to STEADY_DRIVING. */
+const resolveDrivingExpression = (config, status) => config.states[status] ?? config.states.STEADY_DRIVING;
+/** Strict resolver used by the player; official fallbacks are opt-in. */
+const resolveDrivingExpressionStrict = (config, status, fallbacks) => {
+	const configured = config.states[status];
+	if (configured !== void 0) return configured;
+	const fallback = fallbacks?.[status];
+	if (fallback !== void 0) return fallback;
+	throw new DrivingExpressionResolutionError(status);
+};
+const isPublicDrivingMediaUrl = (value) => {
+	try {
+		const url = new URL(value);
+		if (url.protocol !== "https:" || url.username !== "" || url.password !== "") return false;
+		if (!isPublicHostname(url.hostname)) return false;
+		for (const key of url.searchParams.keys()) if (TEMPORARY_SIGNATURE_QUERY_KEYS.has(key.toLowerCase())) return false;
+		return true;
+	} catch {
+		return false;
+	}
+};
+const isPublicHostname = (rawHostname) => {
+	const hostname = rawHostname.toLowerCase().replace(/^\[|\]$/gu, "").replace(/\.+$/gu, "");
+	if (hostname === "") return false;
+	const ipv4 = parseIpv4(hostname);
+	if (ipv4 !== null) return !isRestrictedIpv4(ipv4);
+	const ipv6 = parseIpv6(hostname);
+	if (ipv6 !== null) return !isRestrictedIpv6(ipv6);
+	if (!hostname.includes(".")) return false;
+	return !INTERNAL_HOST_SUFFIXES.some((suffix) => hostname === suffix || hostname.endsWith(`.${suffix}`));
+};
+const INTERNAL_HOST_SUFFIXES = [
+	"corp",
+	"home",
+	"home.arpa",
+	"internal",
+	"intranet",
+	"lan",
+	"local",
+	"localdomain",
+	"localhost",
+	"private"
+];
+const parseIpv4 = (hostname) => {
+	const parts = hostname.split(".");
+	if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/u.test(part))) return null;
+	const octets = parts.map(Number);
+	if (octets.some((octet) => octet > 255)) return null;
+	return octets;
+};
+const isRestrictedIpv4 = ([a, b, c]) => a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 && c === 0 || a === 192 && b === 0 && c === 2 || a === 192 && b === 31 && c === 196 || a === 192 && b === 52 && c === 193 || a === 192 && b === 88 && c === 99 || a === 192 && b === 168 || a === 192 && b === 175 && c === 48 || a === 198 && (b === 18 || b === 19) || a === 198 && b === 51 && c === 100 || a === 203 && b === 0 && c === 113 || a >= 224;
+const parseIpv6 = (hostname) => {
+	if (!hostname.includes(":")) return null;
+	let normalized = hostname;
+	if (normalized.includes(".")) {
+		const lastColon = normalized.lastIndexOf(":");
+		const ipv4 = parseIpv4(normalized.slice(lastColon + 1));
+		if (ipv4 === null) return null;
+		normalized = `${normalized.slice(0, lastColon)}:${(ipv4[0] << 8 | ipv4[1]).toString(16)}:${(ipv4[2] << 8 | ipv4[3]).toString(16)}`;
+	}
+	const halves = normalized.split("::");
+	if (halves.length > 2) return null;
+	const left = halves[0] === "" ? [] : halves[0].split(":");
+	const right = halves.length === 1 || halves[1] === "" ? [] : halves[1].split(":");
+	if ([...left, ...right].some((part) => !/^[\da-f]{1,4}$/u.test(part))) return null;
+	const omitted = 8 - left.length - right.length;
+	if (halves.length === 1 && omitted !== 0 || halves.length === 2 && omitted < 1) return null;
+	const groups = [
+		...left,
+		...Array.from({ length: omitted }, () => "0"),
+		...right
+	].map((part) => Number.parseInt(part, 16));
+	if (groups.length !== 8) return null;
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	groups.forEach((group, index) => {
+		bytes[index * 2] = group >>> 8;
+		bytes[index * 2 + 1] = group & 255;
+	});
+	return bytes;
+};
+const isRestrictedIpv6 = (bytes) => {
+	const allZeroPrefix = (length) => bytes.subarray(0, length).every((value) => value === 0);
+	if (bytes.every((value) => value === 0)) return true;
+	if (allZeroPrefix(15) && bytes[15] === 1) return true;
+	if (allZeroPrefix(12)) return true;
+	if (allZeroPrefix(10) && bytes[10] === 255 && bytes[11] === 255) return true;
+	if (bytes[0] === 0 && bytes[1] === 100 && bytes[2] === 255 && bytes[3] === 155) return true;
+	if ((bytes[0] & 254) === 252) return true;
+	if (bytes[0] === 254 && (bytes[1] & 192) === 128) return true;
+	if (bytes[0] === 255) return true;
+	if (bytes[0] === 1 && bytes.subarray(1, 8).every((value) => value === 0)) return true;
+	if (bytes[0] === 32 && bytes[1] === 1 && bytes[2] === 13 && bytes[3] === 184) return true;
+	if (bytes[0] === 32 && bytes[1] === 1 && bytes[2] <= 1) return true;
+	if (bytes[0] === 32 && bytes[1] === 2) return true;
+	return bytes[0] === 63 && bytes[1] === 254;
+};
+const TEMPORARY_SIGNATURE_QUERY_KEYS = /* @__PURE__ */ new Set([
+	"expires",
+	"googleaccessid",
+	"ossaccesskeyid",
+	"q-ak",
+	"q-key-time",
+	"q-sign-algorithm",
+	"q-sign-time",
+	"q-signature",
+	"security-token",
+	"sig",
+	"signature",
+	"token",
+	"x-amz-algorithm",
+	"x-amz-credential",
+	"x-amz-date",
+	"x-amz-expires",
+	"x-amz-security-token",
+	"x-amz-signature",
+	"x-amz-signedheaders",
+	"x-cos-security-token",
+	"x-cos-signature",
+	"x-goog-algorithm",
+	"x-goog-credential",
+	"x-goog-date",
+	"x-goog-expires",
+	"x-goog-signature",
+	"x-goog-signedheaders",
+	"x-oss-credential",
+	"x-oss-expires",
+	"x-oss-security-token",
+	"x-oss-signature"
+]);
+const parseDrivingExpressionMedia = (raw, status, options) => {
+	if (typeof raw === "string" && options.allowLegacyImageUrls) {
+		assertPublicUrl(raw, status, "url");
+		return {
+			kind: "image",
+			url: raw
+		};
+	}
+	if (!isRecord$1(raw) || typeof raw.kind !== "string") throw invalidMedia(status, "media must be a structured object with a supported kind");
+	const mediaAssetId = parseMediaAssetId(raw.mediaAssetId, status);
+	assertFieldsAbsent(raw, status, [
+		"items",
+		"urls",
+		"duration"
+	]);
+	switch (raw.kind) {
+		case "emoji":
+			assertFieldsAbsent(raw, status, [
+				"mediaAssetId",
+				"url",
+				"coverUrl",
+				"motionUrl",
+				"mimeType"
+			]);
+			if (typeof raw.text !== "string" || !isOneVisibleGrapheme(raw.text)) throw invalidMedia(status, "emoji.text must contain exactly one visible grapheme");
+			return {
+				kind: "emoji",
+				text: raw.text.trim()
+			};
+		case "image": {
+			assertFieldsAbsent(raw, status, [
+				"text",
+				"coverUrl",
+				"motionUrl"
+			]);
+			const url = parseRequiredUrl(raw.url, status, "url");
+			const mimeType = parseOptionalString(raw.mimeType, status, "mimeType");
+			return compact({
+				kind: "image",
+				mediaAssetId,
+				url,
+				mimeType
+			});
+		}
+		case "video": {
+			assertFieldsAbsent(raw, status, ["text", "motionUrl"]);
+			const url = parseRequiredUrl(raw.url, status, "url");
+			const coverUrl = parseOptionalUrl(raw.coverUrl, status, "coverUrl");
+			const mimeType = parseOptionalString(raw.mimeType, status, "mimeType");
+			return compact({
+				kind: "video",
+				mediaAssetId,
+				url,
+				coverUrl,
+				mimeType
+			});
+		}
+		case "live_photo": {
+			assertFieldsAbsent(raw, status, [
+				"text",
+				"url",
+				"mimeType"
+			]);
+			const coverUrl = parseRequiredUrl(raw.coverUrl, status, "coverUrl");
+			const motionUrl = parseRequiredUrl(raw.motionUrl, status, "motionUrl");
+			return compact({
+				kind: "live_photo",
+				mediaAssetId,
+				coverUrl,
+				motionUrl
+			});
+		}
+		case "tgs": {
+			assertFieldsAbsent(raw, status, [
+				"text",
+				"motionUrl",
+				"mimeType"
+			]);
+			const url = parseRequiredUrl(raw.url, status, "url");
+			const coverUrl = parseOptionalUrl(raw.coverUrl, status, "coverUrl");
+			return compact({
+				kind: "tgs",
+				mediaAssetId,
+				url,
+				coverUrl
+			});
+		}
+		default: throw invalidMedia(status, `unsupported media kind: ${raw.kind}`);
+	}
+};
+const parseJsonObject = (raw) => {
+	let value = raw;
+	if (typeof value === "string") try {
+		value = JSON.parse(value);
+	} catch {
+		throw new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INVALID_SCHEMA", "drivingExpressions is not valid JSON");
+	}
+	if (!isRecord$1(value)) throw new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INVALID_SCHEMA", "drivingExpressions must be a JSON object or JSON object string");
+	return value;
+};
+const readRuntimeDrivingExpressionsValue = () => {
+	const runtimeGlobal = globalThis;
+	if (runtimeGlobal.__TOOOONY_DRIVING_EXPRESSIONS__ !== void 0) return runtimeGlobal.__TOOOONY_DRIVING_EXPRESSIONS__;
+	const faceConfig = runtimeGlobal.__TOOOONY_FACE_CONFIG__;
+	if (!isRecord$1(faceConfig)) return void 0;
+	if (faceConfig.drivingExpressions !== void 0) return faceConfig.drivingExpressions;
+	return isRecord$1(faceConfig.values) ? faceConfig.values.drivingExpressions : void 0;
+};
+const parseMediaAssetId = (raw, status) => {
+	if (raw === void 0) return void 0;
+	if (!Number.isSafeInteger(raw) || raw <= 0) throw invalidMedia(status, "mediaAssetId must be a positive safe integer when present");
+	return raw;
+};
+const assertFieldsAbsent = (value, status, fields) => {
+	const present = fields.find((field) => Object.prototype.hasOwnProperty.call(value, field));
+	if (present !== void 0) throw invalidMedia(status, `${present} is not allowed for this media kind`);
+};
+const parseRequiredUrl = (raw, status, field) => {
+	if (typeof raw !== "string" || raw.length === 0) throw invalidMedia(status, `${field} is required`);
+	assertPublicUrl(raw, status, field);
+	return raw;
+};
+const parseOptionalUrl = (raw, status, field) => {
+	if (raw === void 0) return void 0;
+	return parseRequiredUrl(raw, status, field);
+};
+const parseOptionalString = (raw, status, field) => {
+	if (raw === void 0) return void 0;
+	if (typeof raw !== "string" || raw.trim() === "" || raw.length > 255) throw invalidMedia(status, `${field} must be a non-empty string of at most 255 characters`);
+	return raw;
+};
+const assertPublicUrl = (value, status, field) => {
+	if (!isPublicDrivingMediaUrl(value)) throw new DrivingExpressionsConfigError("MEDIA_URL_NOT_PUBLIC_HTTPS", `${status}.${field} must be a long-lived public HTTPS URL`, status);
+};
+const isOneVisibleGrapheme = (value) => {
+	const trimmed = value.trim();
+	if (trimmed === "" || trimmed.length > 32) return false;
+	const Segmenter = Intl.Segmenter;
+	return (Segmenter ? Array.from(new Segmenter(void 0, { granularity: "grapheme" }).segment(trimmed)) : Array.from(trimmed)).length === 1;
+};
+const invalidMedia = (status, detail) => new DrivingExpressionsConfigError("DRIVING_EXPRESSION_INVALID_MEDIA", `Invalid driving expression for ${status}: ${detail}`, status);
+const compact = (value) => {
+	for (const key of Object.keys(value)) if (value[key] === void 0) delete value[key];
+	return value;
+};
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+//#region src/sensor/page_lifecycle.ts
+const subscribers = /* @__PURE__ */ new Set();
+let installedWindow = null;
+let installedDocument = null;
+let previousPauseHook;
+let previousResumeHook;
+let hadOwnPauseHook = false;
+let hadOwnResumeHook = false;
+let pauseHook = null;
+let resumeHook = null;
+const subscribeDrivingPageLifecycle = (pause, resume) => {
+	const subscriber = {
+		pause,
+		resume
+	};
+	subscribers.add(subscriber);
+	if (subscribers.size === 1) installLifecycleHooks();
+	if (isDrivingPageHidden()) safeInvoke(pause);
+	let subscribed = true;
+	return () => {
+		if (!subscribed) return;
+		subscribed = false;
+		subscribers.delete(subscriber);
+		if (subscribers.size === 0) uninstallLifecycleHooks();
+	};
+};
+const isDrivingPageHidden = () => typeof document !== "undefined" && document.visibilityState === "hidden";
+const installLifecycleHooks = () => {
+	installedDocument = typeof document === "undefined" ? null : document;
+	installedWindow = typeof window === "undefined" ? null : window;
+	installedDocument?.addEventListener("visibilitychange", handleVisibilityChange);
+	installedWindow?.addEventListener("pagehide", dispatchPause);
+	installedWindow?.addEventListener("freeze", dispatchPause);
+	installedWindow?.addEventListener("pageshow", dispatchResume);
+	installedWindow?.addEventListener("resume", dispatchResume);
+	installedWindow?.addEventListener("toooony-device-sensors-release", dispatchPause);
+	installedWindow?.addEventListener("toooony-device-sensors-resume", dispatchResume);
+	if (!installedWindow) return;
+	hadOwnPauseHook = Object.prototype.hasOwnProperty.call(installedWindow, "__watchFaceRuntimePause");
+	hadOwnResumeHook = Object.prototype.hasOwnProperty.call(installedWindow, "__watchFaceRuntimeResume");
+	previousPauseHook = installedWindow.__watchFaceRuntimePause;
+	previousResumeHook = installedWindow.__watchFaceRuntimeResume;
+	pauseHook = function(...args) {
+		try {
+			return typeof previousPauseHook === "function" ? previousPauseHook.apply(this, args) : void 0;
+		} finally {
+			dispatchPause();
+		}
+	};
+	resumeHook = function(...args) {
+		try {
+			return typeof previousResumeHook === "function" ? previousResumeHook.apply(this, args) : void 0;
+		} finally {
+			dispatchResume();
+		}
+	};
+	installedWindow.__watchFaceRuntimePause = pauseHook;
+	installedWindow.__watchFaceRuntimeResume = resumeHook;
+};
+const uninstallLifecycleHooks = () => {
+	installedDocument?.removeEventListener("visibilitychange", handleVisibilityChange);
+	installedWindow?.removeEventListener("pagehide", dispatchPause);
+	installedWindow?.removeEventListener("freeze", dispatchPause);
+	installedWindow?.removeEventListener("pageshow", dispatchResume);
+	installedWindow?.removeEventListener("resume", dispatchResume);
+	installedWindow?.removeEventListener("toooony-device-sensors-release", dispatchPause);
+	installedWindow?.removeEventListener("toooony-device-sensors-resume", dispatchResume);
+	if (installedWindow?.__watchFaceRuntimePause === pauseHook) if (hadOwnPauseHook) installedWindow.__watchFaceRuntimePause = previousPauseHook;
+	else delete installedWindow.__watchFaceRuntimePause;
+	if (installedWindow?.__watchFaceRuntimeResume === resumeHook) if (hadOwnResumeHook) installedWindow.__watchFaceRuntimeResume = previousResumeHook;
+	else delete installedWindow.__watchFaceRuntimeResume;
+	installedWindow = null;
+	installedDocument = null;
+	previousPauseHook = void 0;
+	previousResumeHook = void 0;
+	hadOwnPauseHook = false;
+	hadOwnResumeHook = false;
+	pauseHook = null;
+	resumeHook = null;
+};
+const handleVisibilityChange = () => {
+	if (isDrivingPageHidden()) dispatchPause();
+	else dispatchResume();
+};
+const dispatchPause = () => {
+	for (const subscriber of [...subscribers]) safeInvoke(subscriber.pause);
+};
+const dispatchResume = () => {
+	if (isDrivingPageHidden()) return;
+	for (const subscriber of [...subscribers]) safeInvoke(subscriber.resume);
+};
+const safeInvoke = (callback) => {
+	try {
+		callback();
+	} catch {}
+};
+//#endregion
+//#region src/sensor/driving_status_controller.ts
+const createDrivingStatusController = (options = {}) => new DefaultDrivingStatusController(options);
+var DefaultDrivingStatusController = class {
+	constructor(options) {
+		this.listeners = /* @__PURE__ */ new Set();
+		this.metricWindow = [];
+		this.motionWindow = [];
+		this.candidate = null;
+		this.candidateConfirmationCount = 0;
+		this.lastAvailableAtMs = null;
+		this.unavailableSinceMs = null;
+		this.fallbackApplied = false;
+		this.heldCandidate = null;
+		this.requestedRunning = false;
+		this.polling = false;
+		this.lifecycleSuspended = false;
+		this.destroyed = false;
+		this.generation = 0;
+		this.pendingRead = null;
+		this.unsubscribePageLifecycle = null;
+		this.handleLifecyclePause = () => {
+			if (!this.requestedRunning || this.lifecycleSuspended) return;
+			this.lifecycleSuspended = true;
+			this.deactivatePolling();
+			this.resetTransientRecognition();
+		};
+		this.handleLifecycleResume = () => {
+			if (!this.requestedRunning || !this.lifecycleSuspended || this.destroyed || isDrivingPageHidden()) return;
+			this.lifecycleSuspended = false;
+			this.activatePolling();
+		};
+		this.sensorProvider = options.sensorProvider ?? defaultSensorProvider;
+		this.pollIntervalMs = requirePositiveFinite("pollIntervalMs", options.pollIntervalMs ?? 200);
+		this.unavailableFallbackMs = requirePositiveFinite("unavailableFallbackMs", options.unavailableFallbackMs ?? 3e3);
+		this.tuning = resolveDrivingStatusTuning(options.tuning);
+		this.clock = options.clock ?? systemClock;
+		this.onDiagnostic = options.onDiagnostic;
+		this.managePageLifecycle = options.managePageLifecycle ?? true;
+		const initialStatus = options.initialStatus ?? "STOPPED";
+		if (!CAR_RUNNING_STATUSES.includes(initialStatus)) throw new TypeError(`Unsupported initialStatus: ${initialStatus}`);
+		this.status = initialStatus;
+		this.baseStatus = isBaseStatus(initialStatus) ? initialStatus : "STOPPED";
+		this.statusCommittedAtMs = this.clock.now();
+	}
+	start() {
+		if (this.destroyed || this.requestedRunning) return;
+		this.requestedRunning = true;
+		this.attachLifecycleListeners();
+		if (!this.lifecycleSuspended) this.activatePolling();
+	}
+	stop() {
+		if (this.destroyed || !this.requestedRunning) return;
+		this.requestedRunning = false;
+		this.lifecycleSuspended = false;
+		this.detachLifecycleListeners();
+		this.deactivatePolling();
+		this.resetTransientRecognition();
+	}
+	destroy() {
+		if (this.destroyed) return;
+		if (this.requestedRunning) this.stop();
+		else {
+			this.detachLifecycleListeners();
+			this.deactivatePolling();
+		}
+		this.destroyed = true;
+		this.listeners.clear();
+		this.metricWindow.length = 0;
+		this.motionWindow.length = 0;
+	}
+	getSnapshot() {
+		return {
+			lifecycle: this.destroyed ? "destroyed" : this.polling ? "running" : "stopped",
+			status: this.status,
+			candidate: this.candidate,
+			candidateConfirmationCount: this.candidateConfirmationCount,
+			statusCommittedAtMs: this.statusCommittedAtMs,
+			lastAvailableAtMs: this.lastAvailableAtMs,
+			unavailableSinceMs: this.unavailableSinceMs,
+			tuningVersion: this.tuning.version
+		};
+	}
+	subscribe(listener) {
+		if (this.destroyed) return noop;
+		this.listeners.add(listener);
+		let subscribed = true;
+		return () => {
+			if (!subscribed) return;
+			subscribed = false;
+			this.listeners.delete(listener);
+		};
+	}
+	activatePolling() {
+		if (this.destroyed || this.polling || !this.requestedRunning || this.lifecycleSuspended) return;
+		this.polling = true;
+		this.generation += 1;
+		this.schedulePoll(0, this.generation);
+	}
+	deactivatePolling() {
+		if (!this.polling && this.timer === void 0 && this.pendingRead === null) return;
+		this.polling = false;
+		this.generation += 1;
+		if (this.timer !== void 0) {
+			this.clock.clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+		this.pendingRead?.abort();
+		this.pendingRead = null;
+	}
+	schedulePoll(delayMs, generation) {
+		if (!this.polling || generation !== this.generation || this.timer !== void 0) return;
+		this.timer = this.clock.setTimeout(() => {
+			this.timer = void 0;
+			this.poll(generation);
+		}, delayMs);
+	}
+	async poll(generation) {
+		if (!this.polling || generation !== this.generation || this.pendingRead !== null) return;
+		const pendingRead = new AbortController();
+		this.pendingRead = pendingRead;
+		try {
+			const payload = await this.sensorProvider(pendingRead.signal);
+			if (!this.polling || generation !== this.generation || pendingRead.signal.aborted) return;
+			const metrics = extractDrivingSnapshotMetrics(payload, this.tuning);
+			const accelerometerSample = extractFreshAccelerometerSample(payload, this.tuning.maxSampleAgeMs);
+			if (metrics === null || accelerometerSample === null) this.processUnavailable("invalid_or_stale_snapshot");
+			else this.processAvailable(metrics, accelerometerSample);
+		} catch (error) {
+			if (!this.polling || generation !== this.generation || pendingRead.signal.aborted || isAbortError$1(error)) return;
+			this.processUnavailable("provider_error");
+		} finally {
+			if (this.pendingRead === pendingRead) this.pendingRead = null;
+			if (this.polling && generation === this.generation) this.schedulePoll(this.pollIntervalMs, generation);
+		}
+	}
+	processAvailable(rawMetrics, accelerometerSample) {
+		const now = this.clock.now();
+		this.lastAvailableAtMs = now;
+		this.unavailableSinceMs = null;
+		this.fallbackApplied = false;
+		this.emitDiagnostic({
+			type: "sample_available",
+			atMs: now,
+			capturedAtMs: rawMetrics.capturedAtMs,
+			tuningVersion: this.tuning.version
+		});
+		this.metricWindow.push(rawMetrics);
+		while (this.metricWindow.length > Math.floor(this.tuning.smoothingWindowSize)) this.metricWindow.shift();
+		const smoothedMetrics = averageMetrics(this.metricWindow);
+		const motionIntensity = this.recordMotionSample(accelerometerSample, rawMetrics.capturedAtMs);
+		const nextCandidate = classifyControllerCandidate(rawMetrics, smoothedMetrics, motionIntensity, this.status, this.baseStatus, this.tuning);
+		this.processCandidate(nextCandidate, now);
+	}
+	recordMotionSample(sample, capturedAtMs) {
+		if (!this.motionWindow.some((existing) => existing.sampledAtMs === sample.sampledAtMs)) {
+			this.motionWindow.push(sample);
+			this.motionWindow.sort((left, right) => left.sampledAtMs - right.sampledAtMs);
+		}
+		const cutoffMs = capturedAtMs - this.tuning.motionWindowMs;
+		while (this.motionWindow[0] && this.motionWindow[0].sampledAtMs <= cutoffMs) this.motionWindow.shift();
+		if (this.motionWindow.length < this.tuning.motionMinimumSamples) return null;
+		return combinedAxisStandardDeviation(this.motionWindow);
+	}
+	processUnavailable(category) {
+		const now = this.clock.now();
+		if (this.unavailableSinceMs === null) this.unavailableSinceMs = now;
+		const unavailableForMs = Math.max(0, now - this.unavailableSinceMs);
+		this.metricWindow.length = 0;
+		this.motionWindow.length = 0;
+		this.setCandidate(null, now);
+		this.emitDiagnostic({
+			type: "sample_unavailable",
+			atMs: now,
+			unavailableForMs,
+			category,
+			tuningVersion: this.tuning.version
+		});
+		if (unavailableForMs < this.unavailableFallbackMs || this.fallbackApplied) return;
+		this.fallbackApplied = true;
+		this.emitDiagnostic({
+			type: "fallback_to_stopped",
+			atMs: now,
+			unavailableForMs,
+			tuningVersion: this.tuning.version
+		});
+		this.commit("STOPPED", now, "unavailable_fallback", true);
+	}
+	processCandidate(nextCandidate, now) {
+		if (nextCandidate === this.status) {
+			this.setCandidate(null, now);
+			return;
+		}
+		if (nextCandidate !== this.candidate) {
+			this.setCandidate(nextCandidate, now);
+			this.candidateConfirmationCount = 1;
+			this.heldCandidate = null;
+		} else this.candidateConfirmationCount += 1;
+		if (this.candidateConfirmationCount < this.tuning.confirmationSamples[nextCandidate]) return;
+		const elapsedMs = Math.max(0, now - this.statusCommittedAtMs);
+		const remainingMs = Math.max(0, this.tuning.minimumDisplayMs[this.status] - elapsedMs);
+		const canPreempt = CAR_RUNNING_STATUS_PRIORITY[nextCandidate] > CAR_RUNNING_STATUS_PRIORITY[this.status];
+		if (remainingMs > 0 && !canPreempt) {
+			if (this.heldCandidate !== nextCandidate) {
+				this.heldCandidate = nextCandidate;
+				this.emitDiagnostic({
+					type: "status_held_by_min_duration",
+					atMs: now,
+					status: this.status,
+					candidate: nextCandidate,
+					remainingMs,
+					tuningVersion: this.tuning.version
+				});
+			}
+			return;
+		}
+		this.commit(nextCandidate, now, "candidate_confirmed");
+	}
+	commit(nextStatus, now, reason, force = false) {
+		if (!force && nextStatus === this.status) return;
+		if (nextStatus === this.status) return;
+		const previousStatus = this.status;
+		this.status = nextStatus;
+		if (isBaseStatus(nextStatus)) this.baseStatus = nextStatus;
+		this.statusCommittedAtMs = now;
+		this.setCandidate(null, now);
+		this.heldCandidate = null;
+		const event = {
+			type: "status_changed",
+			status: nextStatus,
+			previousStatus,
+			reason,
+			atMs: now
+		};
+		for (const listener of [...this.listeners]) safeCall(listener, event);
+		this.emitDiagnostic({
+			type: "status_committed",
+			atMs: now,
+			status: nextStatus,
+			previousStatus,
+			reason,
+			tuningVersion: this.tuning.version
+		});
+	}
+	setCandidate(candidate, now) {
+		if (candidate === this.candidate) {
+			if (candidate === null) this.candidateConfirmationCount = 0;
+			return;
+		}
+		const previousCandidate = this.candidate;
+		this.candidate = candidate;
+		this.candidateConfirmationCount = 0;
+		this.heldCandidate = null;
+		this.emitDiagnostic({
+			type: "candidate_changed",
+			atMs: now,
+			candidate,
+			previousCandidate,
+			tuningVersion: this.tuning.version
+		});
+	}
+	resetTransientRecognition() {
+		this.metricWindow.length = 0;
+		this.motionWindow.length = 0;
+		this.candidate = null;
+		this.candidateConfirmationCount = 0;
+		this.unavailableSinceMs = null;
+		this.fallbackApplied = false;
+		this.heldCandidate = null;
+	}
+	emitDiagnostic(event) {
+		if (this.onDiagnostic) safeCall(this.onDiagnostic, event);
+	}
+	attachLifecycleListeners() {
+		if (!this.managePageLifecycle || this.unsubscribePageLifecycle !== null) return;
+		this.unsubscribePageLifecycle = subscribeDrivingPageLifecycle(this.handleLifecyclePause, this.handleLifecycleResume);
+	}
+	detachLifecycleListeners() {
+		this.unsubscribePageLifecycle?.();
+		this.unsubscribePageLifecycle = null;
+	}
+};
+const classifyControllerCandidate = (raw, smoothed, motionIntensity, current, baseStatus, tuning) => {
+	const entry = classifyEntryCandidate(raw, smoothed, motionIntensity, baseStatus, tuning);
+	if (!retainsCurrentStatus(raw, smoothed, motionIntensity, current, tuning)) return entry;
+	if (entry === current) return current;
+	if (CAR_RUNNING_STATUS_PRIORITY[entry] > CAR_RUNNING_STATUS_PRIORITY[current]) return entry;
+	if (isOppositeTurn(entry, current)) return entry;
+	if ((entry === "STOPPED" || entry === "STEADY_DRIVING") && (current === "STOPPED" || current === "STEADY_DRIVING")) return entry;
+	return current;
+};
+const classifyEntryCandidate = (raw, smoothed, motionIntensity, baseStatus, tuning) => {
+	if (raw.longitudinal <= -tuning.rapidLongitudinalThreshold) return "SUDDEN_BRAKING";
+	if (raw.longitudinal >= tuning.rapidLongitudinalThreshold) return "RAPID_ACCELERATION";
+	if (Math.abs(smoothed.yaw) >= tuning.turnYawThreshold) return smoothed.yaw > 0 ? "LEFT_TURN" : "RIGHT_TURN";
+	if (Math.abs(smoothed.lateral) >= tuning.turnLateralThreshold) return smoothed.lateral < 0 ? "LEFT_TURN" : "RIGHT_TURN";
+	if (smoothed.longitudinal <= -tuning.longitudinalThreshold) return "BRAKING";
+	if (smoothed.longitudinal >= tuning.longitudinalThreshold) return "ACCELERATION";
+	if (motionIntensity === null) return baseStatus;
+	if (motionIntensity > tuning.drivingMotionThreshold || smoothed.gyroMagnitude > tuning.stoppedGyroThreshold) return "STEADY_DRIVING";
+	if (motionIntensity < tuning.stoppedMotionThreshold) return "STOPPED";
+	return baseStatus;
+};
+const retainsCurrentStatus = (raw, smoothed, motionIntensity, current, tuning) => {
+	const ratio = tuning.hysteresisRatio;
+	switch (current) {
+		case "SUDDEN_BRAKING": return raw.longitudinal <= -tuning.rapidLongitudinalThreshold * ratio;
+		case "RAPID_ACCELERATION": return raw.longitudinal >= tuning.rapidLongitudinalThreshold * ratio;
+		case "LEFT_TURN": return smoothed.yaw >= tuning.turnYawThreshold * ratio || smoothed.lateral <= -tuning.turnLateralThreshold * ratio;
+		case "RIGHT_TURN": return smoothed.yaw <= -tuning.turnYawThreshold * ratio || smoothed.lateral >= tuning.turnLateralThreshold * ratio;
+		case "BRAKING": return smoothed.longitudinal <= -tuning.longitudinalThreshold * ratio;
+		case "ACCELERATION": return smoothed.longitudinal >= tuning.longitudinalThreshold * ratio;
+		case "STOPPED": return (motionIntensity === null || motionIntensity <= tuning.drivingMotionThreshold) && smoothed.gyroMagnitude <= tuning.stoppedGyroThreshold;
+		case "STEADY_DRIVING": return motionIntensity === null || motionIntensity >= tuning.stoppedMotionThreshold || smoothed.gyroMagnitude > tuning.stoppedGyroThreshold;
+	}
+};
+const averageMetrics = (metrics) => {
+	const result = {
+		capturedAtMs: metrics[metrics.length - 1]?.capturedAtMs ?? 0,
+		longitudinal: 0,
+		lateral: 0,
+		yaw: 0,
+		motionIntensity: 0,
+		gyroMagnitude: 0
+	};
+	for (const value of metrics) {
+		result.longitudinal += value.longitudinal;
+		result.lateral += value.lateral;
+		result.yaw += value.yaw;
+		result.motionIntensity += value.motionIntensity;
+		result.gyroMagnitude += value.gyroMagnitude;
+	}
+	const count = Math.max(1, metrics.length);
+	result.longitudinal /= count;
+	result.lateral /= count;
+	result.yaw /= count;
+	result.motionIntensity /= count;
+	result.gyroMagnitude /= count;
+	return result;
+};
+const extractFreshAccelerometerSample = (info, maxSampleAgeMs) => {
+	const metric = info?.accelerometer;
+	if (!metric?.available || !Number.isFinite(info.capturedAtMs) || !Number.isFinite(metric.sampledAtMs)) return null;
+	const ageMs = info.capturedAtMs - metric.sampledAtMs;
+	if (ageMs < 0 || ageMs > maxSampleAgeMs) return null;
+	const { x, y, z } = metric.value;
+	if (![
+		x,
+		y,
+		z
+	].every(Number.isFinite)) return null;
+	return {
+		sampledAtMs: metric.sampledAtMs,
+		value: metric.value
+	};
+};
+const combinedAxisStandardDeviation = (samples) => {
+	const count = samples.length;
+	let meanX = 0;
+	let meanY = 0;
+	let meanZ = 0;
+	for (const sample of samples) {
+		meanX += sample.value.x;
+		meanY += sample.value.y;
+		meanZ += sample.value.z;
+	}
+	meanX /= count;
+	meanY /= count;
+	meanZ /= count;
+	let varianceX = 0;
+	let varianceY = 0;
+	let varianceZ = 0;
+	for (const sample of samples) {
+		varianceX += (sample.value.x - meanX) ** 2;
+		varianceY += (sample.value.y - meanY) ** 2;
+		varianceZ += (sample.value.z - meanZ) ** 2;
+	}
+	return Math.sqrt((varianceX + varianceY + varianceZ) / count);
+};
+const defaultSensorProvider = () => {
+	const runtimeGlobal = globalThis;
+	if (typeof runtimeGlobal.unifiedSensorInfo !== "function") return Promise.reject(/* @__PURE__ */ new Error("window.unifiedSensorInfo is unavailable"));
+	return runtimeGlobal.unifiedSensorInfo();
+};
+const systemClock = {
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
+	clearTimeout: (handle) => globalThis.clearTimeout(handle)
+};
+const isOppositeTurn = (candidate, current) => candidate === "LEFT_TURN" && current === "RIGHT_TURN" || candidate === "RIGHT_TURN" && current === "LEFT_TURN";
+const isBaseStatus = (status) => status === "STOPPED" || status === "STEADY_DRIVING";
+const isAbortError$1 = (error) => error instanceof Error && error.name === "AbortError";
+const requirePositiveFinite = (name, value) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a positive finite number`);
+	return value;
+};
+const safeCall = (callback, value) => {
+	try {
+		callback(value);
+	} catch {}
+};
+const noop = () => {};
+//#endregion
+//#region src/sensor/driving_expression_player.ts
+const createDrivingExpressionPlayer = (container, options) => new DefaultDrivingExpressionPlayer(container, options);
+var DefaultDrivingExpressionPlayer = class {
+	constructor(container, options) {
+		this.status = null;
+		this.phase = "idle";
+		this.mediaKind = null;
+		this.errorCategory = null;
+		this.desiredMedia = null;
+		this.userPaused = false;
+		this.lifecycleSuspended = false;
+		this.paused = false;
+		this.destroyed = false;
+		this.operation = 0;
+		this.failedOperation = null;
+		this.loadAbort = null;
+		this.preloadAbort = null;
+		this.activeVideo = null;
+		this.activeVideoListenersCleanup = null;
+		this.reusableVideo = null;
+		this.activeTgs = null;
+		this.unsubscribePageLifecycle = null;
+		this.handleLifecyclePause = () => {
+			if (this.destroyed || this.lifecycleSuspended) return;
+			this.lifecycleSuspended = true;
+			this.updatePauseState();
+		};
+		this.handleLifecycleResume = () => {
+			if (this.destroyed || !this.lifecycleSuspended) return;
+			this.lifecycleSuspended = false;
+			this.updatePauseState();
+		};
+		if (!container || typeof container.replaceChildren !== "function") throw new TypeError("container must be an HTMLElement-like DOM container");
+		this.container = container;
+		this.document = container.ownerDocument;
+		this.config = options.config;
+		this.fallbacks = options.fallbacks;
+		this.loadTimeoutMs = positiveFinite("loadTimeoutMs", options.loadTimeoutMs ?? 5e3);
+		this.retryBackoffMs = positiveFinite("retryBackoffMs", options.retryBackoffMs ?? 15e3);
+		this.fit = options.fit ?? "contain";
+		this.tgsRenderer = options.tgsRenderer ?? defaultTgsRenderer;
+		this.fetchImplementation = options.fetch ?? globalThis.fetch?.bind(globalThis);
+		this.onDiagnostic = options.onDiagnostic;
+		this.maxTgsCompressedBytes = positiveFinite("maxTgsCompressedBytes", options.maxTgsCompressedBytes ?? 2 * 1024 * 1024);
+		this.maxTgsJsonBytes = positiveFinite("maxTgsJsonBytes", options.maxTgsJsonBytes ?? 8 * 1024 * 1024);
+		this.maxTgsLayers = positiveFinite("maxTgsLayers", options.maxTgsLayers ?? 500);
+		if (options.managePageLifecycle ?? true) this.unsubscribePageLifecycle = subscribeDrivingPageLifecycle(this.handleLifecyclePause, this.handleLifecycleResume);
+	}
+	async show(status) {
+		if (this.destroyed || status === this.status && this.phase !== "idle") return;
+		this.status = status;
+		const operation = this.beginOperation();
+		const configured = this.config.states[status];
+		if (configured === void 0) {
+			const fallback = this.fallbacks?.[status];
+			if (fallback === void 0) {
+				this.handleFailure(status, null, new DrivingExpressionResolutionError(status), "invalid_config", operation, false);
+				return;
+			}
+			this.desiredMedia = fallback;
+			if (this.paused) {
+				this.phase = "idle";
+				return;
+			}
+			this.renderFallback(status, fallback);
+			return;
+		}
+		const media = normalizeMedia(configured);
+		this.desiredMedia = media;
+		if (this.paused) {
+			this.phase = "idle";
+			return;
+		}
+		await this.load(status, media, operation);
+	}
+	pause() {
+		if (this.destroyed || this.userPaused) return;
+		this.userPaused = true;
+		this.updatePauseState();
+	}
+	resume() {
+		if (this.destroyed || !this.userPaused) return;
+		this.userPaused = false;
+		this.updatePauseState();
+	}
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.unsubscribePageLifecycle?.();
+		this.unsubscribePageLifecycle = null;
+		this.operation += 1;
+		this.failedOperation = null;
+		this.cancelPendingWork();
+		this.releaseActiveMedia();
+		this.container.replaceChildren();
+		this.status = null;
+		this.desiredMedia = null;
+		this.phase = "idle";
+		this.mediaKind = null;
+		this.errorCategory = null;
+	}
+	getSnapshot() {
+		return {
+			lifecycle: this.destroyed ? "destroyed" : this.paused ? "paused" : "active",
+			status: this.status,
+			phase: this.phase,
+			mediaKind: this.mediaKind,
+			errorCategory: this.errorCategory
+		};
+	}
+	beginOperation() {
+		this.operation += 1;
+		this.failedOperation = null;
+		this.cancelPendingWork();
+		this.releaseActiveMedia();
+		this.container.replaceChildren();
+		this.phase = "loading";
+		this.mediaKind = null;
+		this.errorCategory = null;
+		return this.operation;
+	}
+	updatePauseState() {
+		const shouldPause = this.userPaused || this.lifecycleSuspended;
+		if (shouldPause === this.paused) return;
+		this.paused = shouldPause;
+		if (shouldPause) {
+			this.operation += 1;
+			this.cancelPendingWork();
+			this.activeVideo?.pause();
+			this.activeTgs?.pause?.();
+			return;
+		}
+		if (this.phase === "ready") {
+			if (this.activeVideo && this.status !== null && this.desiredMedia !== null) {
+				const video = this.activeVideo;
+				const status = this.status;
+				const media = this.desiredMedia;
+				const operation = this.operation;
+				this.attachActiveVideoFailureListeners(video, status, media, operation);
+				video.play().catch((error) => this.handleActiveVideoFailure(video, status, media, operation, "decode", error));
+			}
+			this.activeTgs?.play?.();
+			return;
+		}
+		if (this.status !== null && this.desiredMedia !== null) {
+			const operation = this.beginOperation();
+			this.load(this.status, this.desiredMedia, operation);
+		}
+	}
+	async load(status, media, operation) {
+		const startedAt = Date.now();
+		this.mediaKind = media.kind;
+		if (media.kind === "emoji") {
+			this.renderEmoji(media.text);
+			this.markReady(status, media.kind, startedAt, operation);
+			return;
+		}
+		if (firstInvalidMediaUrl(media) !== null) {
+			this.handleFailure(status, media, /* @__PURE__ */ new Error("One or more media URLs are not long-lived public HTTPS URLs"), "invalid_config", operation);
+			return;
+		}
+		const loadAbort = new AbortController();
+		this.loadAbort = loadAbort;
+		try {
+			switch (media.kind) {
+				case "image":
+					this.renderConfiguredFallback(status, false);
+					await this.loadImage(media.url, loadAbort.signal, operation);
+					break;
+				case "video":
+					this.renderLoadingPlaceholder(status, media.coverUrl, operation, loadAbort.signal);
+					await this.loadVideo(media.url, media.mimeType, status, media, loadAbort.signal, operation);
+					break;
+				case "live_photo":
+					await this.loadLivePhoto(media, status, loadAbort.signal, operation);
+					break;
+				case "tgs":
+					this.renderLoadingPlaceholder(status, media.coverUrl, operation, loadAbort.signal);
+					await this.loadTgs(media.url, loadAbort.signal, operation);
+					break;
+			}
+			if (!this.isCurrent(operation) || this.failedOperation === operation) return;
+			this.markReady(status, media.kind, startedAt, operation);
+			this.startPreloading(status, operation);
+		} catch (error) {
+			if (!this.isCurrent(operation) || isAbortError(error)) return;
+			this.handleFailure(status, media, error, categorizeMediaError(error), operation);
+		} finally {
+			loadAbort.abort();
+			if (this.loadAbort === loadAbort) this.loadAbort = null;
+		}
+	}
+	async loadImage(url, signal, operation) {
+		const image = this.createImage();
+		await waitForElementEvent(image, "load", "error", signal, this.loadTimeoutMs, () => {
+			image.src = url;
+		});
+		if (!this.isCurrent(operation)) return;
+		this.container.replaceChildren(image);
+	}
+	async loadVideo(url, mimeType, status, media, signal, operation) {
+		const video = this.getReusableVideo();
+		resetVideo(video);
+		video.preload = "auto";
+		if (mimeType) video.setAttribute("type", mimeType);
+		await waitForElementEvent(video, "canplay", "error", signal, this.loadTimeoutMs, () => {
+			video.src = url;
+			video.load();
+		});
+		if (!this.isCurrent(operation)) return;
+		video.currentTime = 0;
+		this.container.replaceChildren(video);
+		this.activeVideo = video;
+		this.attachActiveVideoFailureListeners(video, status, media, operation);
+		await video.play();
+	}
+	async loadLivePhoto(media, status, signal, operation) {
+		this.renderConfiguredFallback(status, false);
+		const cover = this.createImage();
+		await waitForElementEvent(cover, "load", "error", signal, this.loadTimeoutMs, () => {
+			cover.src = media.coverUrl;
+		});
+		if (!this.isCurrent(operation)) return;
+		this.container.replaceChildren(cover);
+		await this.loadVideo(media.motionUrl, void 0, status, media, signal, operation);
+	}
+	async loadTgs(url, signal, operation) {
+		if (!this.fetchImplementation) throw new MediaPlayerError("unsupported", "fetch is unavailable");
+		const response = await withTimeout(this.fetchImplementation(url, {
+			credentials: "omit",
+			mode: "cors",
+			signal
+		}), this.loadTimeoutMs, signal);
+		if (!response.ok) throw new MediaPlayerError("network", `TGS request failed with HTTP ${response.status}`);
+		const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+		if (!SUPPORTED_TGS_CONTENT_TYPES.has(contentType)) throw new MediaPlayerError("unsupported", `Unsupported TGS Content-Type: ${contentType || "missing"}`);
+		const contentLength = Number(response.headers.get("content-length"));
+		if (Number.isFinite(contentLength) && contentLength > this.maxTgsCompressedBytes) throw new MediaPlayerError("decode", "TGS compressed payload exceeds the configured limit");
+		const compressed = new Uint8Array(await withTimeout(response.arrayBuffer(), this.loadTimeoutMs, signal));
+		if (compressed.byteLength > this.maxTgsCompressedBytes) throw new MediaPlayerError("decode", "TGS compressed payload exceeds the configured limit");
+		const bytes = compressed[0] === 31 && compressed[1] === 139 ? gunzipWithLimit(compressed, this.maxTgsJsonBytes) : compressed;
+		if (bytes.byteLength > this.maxTgsJsonBytes) throw new MediaPlayerError("decode", "TGS JSON payload exceeds the configured limit");
+		let animationData;
+		try {
+			animationData = JSON.parse(new TextDecoder().decode(bytes));
+		} catch {
+			throw new MediaPlayerError("decode", "TGS JSON is malformed");
+		}
+		validateTgsAnimation(animationData, this.maxTgsLayers);
+		const host = this.document.createElement("div");
+		styleMediaElement(host, this.fit);
+		const handle = await withTimeout(Promise.resolve(this.tgsRenderer(host, animationData, signal)), this.loadTimeoutMs, signal);
+		if (!this.isCurrent(operation)) {
+			handle.destroy();
+			return;
+		}
+		this.activeTgs = handle;
+		this.container.replaceChildren(host);
+	}
+	renderLoadingPlaceholder(status, coverUrl, operation, signal) {
+		this.renderConfiguredFallback(status, false);
+		if (!coverUrl) return;
+		const cover = this.createImage();
+		waitForElementEvent(cover, "load", "error", signal, this.loadTimeoutMs, () => {
+			cover.src = coverUrl;
+		}).then(() => {
+			if (this.isCurrent(operation) && this.phase === "loading") this.container.replaceChildren(cover);
+		}).catch(() => {
+			if (this.isCurrent(operation) && this.phase === "loading") this.renderConfiguredFallback(status, false);
+		});
+	}
+	renderConfiguredFallback(status, report = true) {
+		const fallback = this.fallbacks?.[status];
+		if (!fallback) {
+			this.container.replaceChildren();
+			return false;
+		}
+		this.renderFallback(status, fallback, report);
+		return true;
+	}
+	renderFallback(status, fallback, report = true) {
+		if (report) {
+			this.phase = "fallback";
+			this.mediaKind = fallback.kind;
+			this.errorCategory = null;
+		}
+		if (fallback.kind === "emoji") this.renderEmoji(fallback.text);
+		else if (fallback.kind === "image") {
+			const image = this.createImage();
+			image.src = fallback.url;
+			this.container.replaceChildren(image);
+		} else this.container.replaceChildren();
+		if (report) this.emitDiagnostic({
+			type: "media_fallback_applied",
+			status,
+			kind: fallback.kind
+		});
+	}
+	renderEmoji(text) {
+		const emoji = this.document.createElement("span");
+		emoji.textContent = text;
+		emoji.setAttribute("role", "img");
+		emoji.setAttribute("aria-label", "driving expression");
+		Object.assign(emoji.style, {
+			alignItems: "center",
+			display: "flex",
+			fontFamily: "system-ui, \"Apple Color Emoji\", \"Noto Color Emoji\", sans-serif",
+			fontSize: "min(52vw, 240px)",
+			height: "100%",
+			justifyContent: "center",
+			lineHeight: "1",
+			width: "100%"
+		});
+		this.container.replaceChildren(emoji);
+	}
+	markReady(status, kind, startedAt, operation) {
+		if (!this.isCurrent(operation) || this.failedOperation === operation) return;
+		this.phase = "ready";
+		this.mediaKind = kind;
+		this.errorCategory = null;
+		this.emitDiagnostic({
+			type: "media_ready",
+			status,
+			kind,
+			elapsedMs: Math.max(0, Date.now() - startedAt)
+		});
+	}
+	handleFailure(status, media, error, category, operation, scheduleRetry = true) {
+		if (!this.isCurrent(operation) || this.failedOperation === operation) return;
+		this.failedOperation = operation;
+		this.stopActiveVideo();
+		this.phase = "error";
+		this.errorCategory = category;
+		this.emitDiagnostic({
+			type: "media_load_failed",
+			status,
+			kind: media?.kind ?? "unknown",
+			category,
+			message: safeErrorMessage(error)
+		});
+		if (!this.renderConfiguredFallback(status)) {
+			this.phase = "error";
+			this.errorCategory = category;
+		}
+		if (scheduleRetry && media !== null) this.scheduleRetry(status, media, operation);
+	}
+	scheduleRetry(status, media, failedOperation) {
+		if (this.destroyed || this.paused || !this.isCurrent(failedOperation)) return;
+		this.retryTimer = globalThis.setTimeout(() => {
+			this.retryTimer = void 0;
+			if (this.destroyed || this.paused || this.status !== status || !this.isCurrent(failedOperation)) return;
+			const operation = this.beginOperation();
+			this.load(status, media, operation);
+		}, this.retryBackoffMs);
+	}
+	startPreloading(currentStatus, operation) {
+		this.preloadAbort?.abort();
+		const preloadAbort = new AbortController();
+		this.preloadAbort = preloadAbort;
+		const statuses = [
+			currentStatus,
+			"STOPPED",
+			...CAR_RUNNING_STATUSES
+		].filter((status, index, all) => all.indexOf(status) === index);
+		(async () => {
+			for (const status of statuses) {
+				if (!this.isCurrent(operation) || preloadAbort.signal.aborted) return;
+				const configured = this.config.states[status];
+				if (configured === void 0 || status === currentStatus) continue;
+				const media = normalizeMedia(configured);
+				const hintUrl = mediaPreloadHint(media);
+				if (!hintUrl || !isPublicDrivingMediaUrl(hintUrl)) continue;
+				try {
+					const image = this.createImage();
+					await waitForElementEvent(image, "load", "error", preloadAbort.signal, this.loadTimeoutMs, () => {
+						image.src = hintUrl;
+					});
+					image.removeAttribute("src");
+				} catch {
+					if (preloadAbort.signal.aborted) return;
+				}
+			}
+		})();
+	}
+	createImage() {
+		const image = this.document.createElement("img");
+		image.alt = "";
+		image.decoding = "async";
+		styleMediaElement(image, this.fit);
+		return image;
+	}
+	getReusableVideo() {
+		if (!this.reusableVideo) {
+			this.reusableVideo = this.document.createElement("video");
+			this.reusableVideo.muted = true;
+			this.reusableVideo.loop = true;
+			this.reusableVideo.playsInline = true;
+			this.reusableVideo.setAttribute("muted", "");
+			this.reusableVideo.setAttribute("playsinline", "");
+			styleMediaElement(this.reusableVideo, this.fit);
+		}
+		return this.reusableVideo;
+	}
+	attachActiveVideoFailureListeners(video, status, media, operation) {
+		this.detachActiveVideoFailureListeners();
+		let attached = true;
+		const cleanup = () => {
+			if (!attached) return;
+			attached = false;
+			video.removeEventListener("error", handleError);
+			video.removeEventListener("stalled", handleStalled);
+			if (this.activeVideoListenersCleanup === cleanup) this.activeVideoListenersCleanup = null;
+		};
+		const failed = (category, event) => {
+			if (!attached) return;
+			this.handleActiveVideoFailure(video, status, media, operation, category, new MediaPlayerError(category, `${event.type} after video playback started`));
+		};
+		const handleError = (event) => failed("decode", event);
+		const handleStalled = (event) => failed("network", event);
+		video.addEventListener("error", handleError);
+		video.addEventListener("stalled", handleStalled);
+		this.activeVideoListenersCleanup = cleanup;
+	}
+	handleActiveVideoFailure(video, status, media, operation, category, error) {
+		if (this.activeVideo !== video || !this.isCurrent(operation)) return;
+		this.stopActiveVideo();
+		this.handleFailure(status, media, error, category, operation);
+	}
+	detachActiveVideoFailureListeners() {
+		const cleanup = this.activeVideoListenersCleanup;
+		this.activeVideoListenersCleanup = null;
+		cleanup?.();
+	}
+	stopActiveVideo() {
+		this.detachActiveVideoFailureListeners();
+		if (!this.activeVideo) return;
+		resetVideo(this.activeVideo);
+		this.activeVideo = null;
+	}
+	releaseActiveMedia() {
+		this.stopActiveVideo();
+		if (this.activeTgs) {
+			safeDestroy(this.activeTgs);
+			this.activeTgs = null;
+		}
+	}
+	cancelPendingWork() {
+		this.loadAbort?.abort();
+		this.loadAbort = null;
+		this.detachActiveVideoFailureListeners();
+		if (this.activeVideo === null && this.reusableVideo !== null) resetVideo(this.reusableVideo);
+		this.preloadAbort?.abort();
+		this.preloadAbort = null;
+		if (this.retryTimer !== void 0) {
+			globalThis.clearTimeout(this.retryTimer);
+			this.retryTimer = void 0;
+		}
+	}
+	isCurrent(operation) {
+		return !this.destroyed && !this.paused && operation === this.operation;
+	}
+	emitDiagnostic(event) {
+		if (!this.onDiagnostic) return;
+		try {
+			this.onDiagnostic(event);
+		} catch {}
+	}
+};
+var MediaPlayerError = class extends Error {
+	constructor(category, message) {
+		super(message);
+		this.name = "MediaPlayerError";
+		this.category = category;
+	}
+};
+const SUPPORTED_TGS_CONTENT_TYPES = /* @__PURE__ */ new Set([
+	"application/gzip",
+	"application/json",
+	"application/vnd.telegram.tgsticker",
+	"application/x-gzip",
+	"application/x-tgsticker"
+]);
+const normalizeMedia = (media) => typeof media === "string" ? {
+	kind: "image",
+	url: media
+} : media;
+const firstInvalidMediaUrl = (media) => {
+	let values;
+	switch (media.kind) {
+		case "emoji":
+			values = [];
+			break;
+		case "image":
+			values = [media.url];
+			break;
+		case "live_photo":
+			values = [media.coverUrl, media.motionUrl];
+			break;
+		case "video":
+		case "tgs":
+			values = [media.url, media.coverUrl];
+			break;
+	}
+	return values.find((value) => typeof value === "string" && !isPublicDrivingMediaUrl(value)) ?? null;
+};
+const mediaPreloadHint = (media) => {
+	switch (media.kind) {
+		case "image": return media.url;
+		case "video":
+		case "tgs": return media.coverUrl;
+		case "live_photo": return media.coverUrl;
+		case "emoji": return;
+	}
+};
+const waitForElementEvent = (element, successEvent, failureEvent, signal, timeoutMs, start) => new Promise((resolve, reject) => {
+	let timer;
+	const cleanup = () => {
+		element.removeEventListener(successEvent, handleSuccess);
+		element.removeEventListener(failureEvent, handleFailure);
+		signal.removeEventListener("abort", handleAbort);
+		if (timer !== void 0) globalThis.clearTimeout(timer);
+	};
+	const handleSuccess = () => {
+		cleanup();
+		resolve();
+	};
+	const handleFailure = () => {
+		cleanup();
+		reject(new MediaPlayerError("decode", `${failureEvent} while loading media`));
+	};
+	const handleAbort = () => {
+		cleanup();
+		reject(createAbortError());
+	};
+	element.addEventListener(successEvent, handleSuccess, { once: true });
+	element.addEventListener(failureEvent, handleFailure, { once: true });
+	signal.addEventListener("abort", handleAbort, { once: true });
+	timer = globalThis.setTimeout(() => {
+		cleanup();
+		reject(new MediaPlayerError("timeout", `media load timed out after ${timeoutMs}ms`));
+	}, timeoutMs);
+	try {
+		start();
+	} catch (error) {
+		cleanup();
+		reject(error);
+	}
+});
+const withTimeout = (promise, timeoutMs, signal) => new Promise((resolve, reject) => {
+	let timer;
+	const cleanup = () => {
+		signal.removeEventListener("abort", handleAbort);
+		if (timer !== void 0) globalThis.clearTimeout(timer);
+	};
+	const handleAbort = () => {
+		cleanup();
+		reject(createAbortError());
+	};
+	signal.addEventListener("abort", handleAbort, { once: true });
+	timer = globalThis.setTimeout(() => {
+		cleanup();
+		reject(new MediaPlayerError("timeout", `media load timed out after ${timeoutMs}ms`));
+	}, timeoutMs);
+	promise.then((value) => {
+		cleanup();
+		resolve(value);
+	}, (error) => {
+		cleanup();
+		reject(error);
+	});
+});
+const defaultTgsRenderer = async (container, animationData, signal) => {
+	if (signal.aborted) throw createAbortError();
+	const module = await import("lottie-web");
+	if (signal.aborted) throw createAbortError();
+	const animation = module.default.loadAnimation({
+		animationData,
+		autoplay: true,
+		container,
+		loop: true,
+		renderer: "svg",
+		rendererSettings: { progressiveLoad: true }
+	});
+	await new Promise((resolve, reject) => {
+		const ready = () => {
+			cleanup();
+			resolve();
+		};
+		const failed = () => {
+			cleanup();
+			reject(new MediaPlayerError("decode", "Lottie could not initialize the TGS animation"));
+		};
+		const aborted = () => {
+			cleanup();
+			animation.destroy();
+			reject(createAbortError());
+		};
+		const cleanup = () => {
+			animation.removeEventListener("DOMLoaded", ready);
+			animation.removeEventListener("data_failed", failed);
+			signal.removeEventListener("abort", aborted);
+		};
+		animation.addEventListener("DOMLoaded", ready);
+		animation.addEventListener("data_failed", failed);
+		signal.addEventListener("abort", aborted, { once: true });
+	});
+	return {
+		destroy: () => animation.destroy(),
+		pause: () => animation.pause(),
+		play: () => animation.play(),
+		restart: () => animation.goToAndPlay(0, true)
+	};
+};
+function validateTgsAnimation(value, maxLayers) {
+	if (!isRecord(value) || !Array.isArray(value.layers)) throw new MediaPlayerError("decode", "TGS animation does not contain a layers array");
+	if (value.layers.length > maxLayers) throw new MediaPlayerError("decode", "TGS animation has too many layers");
+	if (typeof value.fr === "number" && (!Number.isFinite(value.fr) || value.fr <= 0 || value.fr > 120)) throw new MediaPlayerError("decode", "TGS animation frame rate is outside the supported range");
+	if (typeof value.ip === "number" && typeof value.op === "number" && (value.op <= value.ip || value.op - value.ip > 3e4)) throw new MediaPlayerError("decode", "TGS animation duration is outside the supported range");
+}
+const gunzipWithLimit = (compressed, maxOutputBytes) => {
+	if (compressed.byteLength < 18) throw new MediaPlayerError("decode", "TGS gzip payload is truncated");
+	if (new DataView(compressed.buffer, compressed.byteOffset + compressed.byteLength - 4, 4).getUint32(0, true) > maxOutputBytes) throw new MediaPlayerError("decode", "TGS JSON payload exceeds the configured limit");
+	const chunks = [];
+	let outputBytes = 0;
+	try {
+		const gunzip = new Gunzip((chunk) => {
+			outputBytes += chunk.byteLength;
+			if (outputBytes > maxOutputBytes) throw new MediaPlayerError("decode", "TGS JSON payload exceeds the configured limit");
+			if (chunk.byteLength > 0) chunks.push(chunk);
+		});
+		const compressedChunkBytes = 64;
+		for (let offset = 0; offset < compressed.byteLength; offset += compressedChunkBytes) {
+			const end = Math.min(compressed.byteLength, offset + compressedChunkBytes);
+			gunzip.push(compressed.subarray(offset, end), end === compressed.byteLength);
+		}
+	} catch (error) {
+		if (error instanceof MediaPlayerError) throw error;
+		throw new MediaPlayerError("decode", "TGS gzip decompression failed");
+	}
+	const output = new Uint8Array(outputBytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		output.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return output;
+};
+const resetVideo = (video) => {
+	video.pause();
+	video.removeAttribute("src");
+	video.removeAttribute("type");
+	try {
+		video.load();
+	} catch {}
+};
+const styleMediaElement = (element, fit) => {
+	Object.assign(element.style, {
+		display: "block",
+		height: "100%",
+		maxHeight: "100%",
+		maxWidth: "100%",
+		objectFit: fit,
+		width: "100%"
+	});
+};
+const categorizeMediaError = (error) => {
+	if (error instanceof MediaPlayerError) return error.category;
+	if (error instanceof TypeError) return "network";
+	return "decode";
+};
+const safeErrorMessage = (error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	return redactUrlQueries(message).slice(0, 240);
+};
+const redactUrlQueries = (message) => message.replace(/https:\/\/[^\s"'<>]+/gu, (candidate) => {
+	try {
+		const url = new URL(candidate);
+		return `${url.origin}${url.pathname}`;
+	} catch {
+		return "[url]";
+	}
+});
+const createAbortError = () => {
+	if (typeof DOMException !== "undefined") return new DOMException("Aborted", "AbortError");
+	const error = /* @__PURE__ */ new Error("Aborted");
+	error.name = "AbortError";
+	return error;
+};
+const isAbortError = (error) => error instanceof Error && error.name === "AbortError";
+const positiveFinite = (name, value) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a positive finite number`);
+	return value;
+};
+const safeDestroy = (handle) => {
+	try {
+		handle.destroy();
+	} catch {}
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+export { BATTERY_HEALTH_LABELS, CAR_RUNNING_LABELS, CAR_RUNNING_STATUSES, CAR_RUNNING_STATUS_PRIORITY, DEFAULT_DRIVING_STATUS_TUNING, DrivingExpressionResolutionError, DrivingExpressionsConfigError, OFFICIAL_DRIVING_EXPRESSIONS_CONFIG, OFFICIAL_DRIVING_EXPRESSION_FALLBACKS, checkRunningStatus, classifyDrivingMetrics, classifyDrivingSnapshot, createDrivingExpressionPlayer, createDrivingStatusController, extractDrivingSnapshotMetrics, isPublicDrivingMediaUrl, parseDrivingExpressionsConfig, readDrivingExpressionsConfig, resolveDrivingExpression, resolveDrivingExpressionStrict, resolveDrivingStatusTuning, tryParseDrivingExpressionsConfig, unifiedSensorInfo };