@blotch/angular-lynx 22.2.2 → 22.2.4

package/fesm2022/blotch-angular-lynx.mjs

@@ -1,18 +1,482 @@
 import * as i0 from "@angular/core";
-import { ApplicationRef, Component, DOCUMENT, DestroyRef, Directive, ElementRef, EnvironmentInjector, ErrorHandler, Injectable, InjectionToken, LOCALE_ID, Renderer2, RendererFactory2, RendererStyleFlags2, TemplateRef, ViewContainerRef, ViewEncapsulation, computed, contentChild, createComponent, effect, forwardRef, inject, input, makeEnvironmentProviders, output, signal, viewChild } from "@angular/core";
+import { ApplicationRef, Component, DOCUMENT, DestroyRef, Directive, ElementRef, EnvironmentInjector, ErrorHandler, Injectable, InjectionToken, Injector, LOCALE_ID, Renderer2, RendererFactory2, RendererStyleFlags2, TemplateRef, ViewContainerRef, ViewEncapsulation, computed, contentChild, createComponent, effect, forwardRef, inject, input, makeEnvironmentProviders, output, provideEnvironmentInitializer, signal, viewChild, ɵɵreplaceMetadata } from "@angular/core";
+import { ReplaySubject, Subject, firstValueFrom } from "rxjs";
+import { APP_BASE_HREF, IMAGE_CONFIG, Location, LocationStrategy, PlatformLocation, getLocaleId } from "@angular/common";
 import { NG_VALUE_ACCESSOR } from "@angular/forms";
-import { APP_BASE_HREF, IMAGE_CONFIG, LocationStrategy, PlatformLocation } from "@angular/common";
-import { RouteReuseStrategy, provideRouter as provideRouter$1, withRouterConfig } from "@angular/router";
+import { RouterLinkActive, provideRouter as provideRouter$1, withRouterConfig } from "@angular/router";
 import { bootstrapApplication as bootstrapApplication$1 } from "@angular/platform-browser";
-import { Subject, firstValueFrom } from "rxjs";
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const VALUES = new Map(Array.from(ALPHABET, (char, index) => [char, index]));
+const SLICE$1 = 8192;
+const bytesToBase64 = (bytes) => {
+	const codes = [];
+	let output = "";
+	for (let index = 0; index < bytes.length; index += 3) {
+		const a = bytes[index];
+		const b = bytes[index + 1];
+		const c = bytes[index + 2];
+		codes.push(ALPHABET.charCodeAt(a >> 2), ALPHABET.charCodeAt((a & 3) << 4 | (b ?? 0) >> 4), b === void 0 ? 61 : ALPHABET.charCodeAt((b & 15) << 2 | (c ?? 0) >> 6), c === void 0 ? 61 : ALPHABET.charCodeAt(c & 63));
+		if (codes.length >= SLICE$1) {
+			output += String.fromCharCode(...codes);
+			codes.length = 0;
+		}
+	}
+	return output + String.fromCharCode(...codes);
+};
+const base64ToBytes = (base64) => {
+	const values = [];
+	for (const char of base64) {
+		const value = VALUES.get(char);
+		if (value !== void 0) values.push(value);
+	}
+	const bytes = new Uint8Array(Math.floor(values.length * 3 / 4));
+	let byteIndex = 0;
+	for (let index = 0; index < values.length; index += 4) {
+		const a = values[index];
+		const b = values[index + 1] ?? 0;
+		const c = values[index + 2];
+		const d = values[index + 3];
+		bytes[byteIndex++] = a << 2 | b >> 4;
+		if (c !== void 0) bytes[byteIndex++] = (b & 15) << 4 | c >> 2;
+		if (d !== void 0) bytes[byteIndex++] = (c & 3) << 6 | d;
+	}
+	return bytes;
+};
+const LYNX_FAILURE_STATUS = 499;
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
+	101,
+	103,
+	204,
+	205,
+	304
+]);
+const TEXT_TYPE = /^(text\/|application\/([\w.+-]*\+)?(json|xml|javascript|ecmascript|x-www-form-urlencoded|graphql)\b)/;
+const isUtf8Text = (contentType) => {
+	if (!contentType) return false;
+	const type = contentType.toLowerCase();
+	const charset = /;\s*charset="?([^";]+)/.exec(type)?.[1];
+	return TEXT_TYPE.test(type) && (charset === void 0 || /^utf-?8$/.test(charset));
+};
+const decodeBody = (body) => {
+	if (body === null) return void 0;
+	if ("text" in body) return body.text;
+	return base64ToBytes(body.base64).buffer;
+};
+const backgroundFetch = () => typeof fetch === "function" ? fetch : void 0;
+const controllers = /* @__PURE__ */ new Map();
+const fetchForMainThread = async (id, request) => {
+	const fetchImpl = backgroundFetch();
+	if (!fetchImpl) throw new TypeError("fetch isn't available on the background thread in this environment");
+	const controller = new AbortController();
+	controllers.set(id, controller);
+	try {
+		const response = await fetchImpl(request.url, {
+			...request.options,
+			method: request.method,
+			headers: Object.fromEntries(request.headers),
+			body: decodeBody(request.body),
+			signal: controller.signal
+		});
+		const headers = [];
+		response.headers.forEach((value, name) => headers.push([name, value]));
+		if (response.status === LYNX_FAILURE_STATUS && headers.length === 0) throw new TypeError(response.statusText || "Network request failed");
+		let body = null;
+		if (!NULL_BODY_STATUSES.has(response.status)) body = isUtf8Text(response.headers.get("content-type")) ? { text: await response.text() } : { base64: bytesToBase64(new Uint8Array(await response.arrayBuffer())) };
+		return {
+			status: response.status,
+			statusText: response.statusText,
+			url: response.url || request.url,
+			redirected: response.redirected === true,
+			headers,
+			body
+		};
+	} finally {
+		controllers.delete(id);
+	}
+};
+const abortFetchForMainThread = (id) => {
+	controllers.get(id)?.abort();
+};
+const CALL_EVENT = "AngularLynx.BackgroundCall";
+const RESULT_EVENT = "AngularLynx.BackgroundCallResult";
+const SESSION_STORAGE_EVENT = "AngularLynx.SessionStorageChange";
+const CALLBACK_EVENT = "AngularLynx.Callback";
+const isMainThread = () => typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__;
+const lynxApi = (name) => {
+	const fn = typeof lynx !== "undefined" ? lynx[name] : void 0;
+	if (typeof fn !== "function") throw new Error(`lynx.${name} is not available in this environment`);
+	return fn.bind(lynx);
+};
+const relayedSubscriptions = /* @__PURE__ */ new Map();
+const relayedFunctions = /* @__PURE__ */ new Map();
+const relayedFunctionIds = /* @__PURE__ */ new WeakMap();
+let nextFunctionId = 0;
+const standIns = /* @__PURE__ */ new Map();
+const isPlainObject = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+const isFunctionMarker = (value) => isPlainObject(value) && typeof value["__angularLynxCallback"] === "number";
+const markFunction = (fn, owner) => {
+	let id = relayedFunctionIds.get(fn);
+	if (id === void 0) {
+		id = nextFunctionId++;
+		relayedFunctionIds.set(fn, id);
+		relayedFunctions.set(id, (...args) => fn.apply(owner, args));
+	}
+	return { __angularLynxCallback: id };
+};
+const relayFunctions = (value) => {
+	if (!isMainThread()) return value;
+	const relay = (item, owner) => {
+		if (typeof item === "function") return markFunction(item, owner);
+		if (Array.isArray(item)) return item.map((entry) => relay(entry));
+		if (isPlainObject(item)) {
+			const result = {};
+			for (const key of Object.keys(item)) result[key] = relay(item[key], item);
+			return result;
+		}
+		return item;
+	};
+	return relay(value);
+};
+const relayModuleObject = (module) => {
+	if (!isMainThread()) return module;
+	const result = {};
+	for (let source = module; source !== null && source !== Object.prototype; source = Object.getPrototypeOf(source)) for (const key of Object.getOwnPropertyNames(source)) {
+		if (key === "constructor" || key in result) continue;
+		const value = module[key];
+		result[key] = typeof value === "function" ? markFunction(value, module) : relayFunctions(value);
+	}
+	return result;
+};
+const restoreFunctions = (value) => {
+	if (isFunctionMarker(value)) {
+		const id = value.__angularLynxCallback;
+		let standIn = standIns.get(id);
+		if (!standIn) {
+			standIn = (...args) => {
+				try {
+					lynx.getCoreContext().dispatchEvent({
+						type: CALLBACK_EVENT,
+						data: JSON.stringify({
+							id,
+							args
+						})
+					});
+				} catch {}
+			};
+			standIns.set(id, standIn);
+		}
+		return standIn;
+	}
+	if (Array.isArray(value)) {
+		const items = value.map(restoreFunctions);
+		return items.some((item, i) => item !== value[i]) ? items : value;
+	}
+	if (isPlainObject(value)) {
+		let changed = false;
+		const result = {};
+		for (const key of Object.keys(value)) {
+			result[key] = restoreFunctions(value[key]);
+			changed ||= result[key] !== value[key];
+		}
+		return changed ? result : value;
+	}
+	return value;
+};
+const nativeBridge = () => {
+	const bridge = typeof NativeModules !== "undefined" && NativeModules != null ? NativeModules.bridge : void 0;
+	return typeof bridge?.call === "function" ? bridge : void 0;
+};
+const findModule = (kind, name) => {
+	if (kind === "native") return typeof NativeModules !== "undefined" && NativeModules != null ? NativeModules[name] : void 0;
+	return typeof lynx !== "undefined" && typeof lynx.getJSModule === "function" ? lynx.getJSModule(name) : void 0;
+};
+const handlers = {
+	accessibilityAnnounce: (content) => new Promise((resolve) => lynxApi("accessibilityAnnounce")({ content }, () => resolve())),
+	addFont: (fontFamily, src) => new Promise((resolve, reject) => lynxApi("addFont")({
+		"font-family": fontFamily,
+		src
+	}, (err) => err ? reject(err) : resolve())),
+	setObserverFrameRate: (options) => lynxApi("setObserverFrameRate")(options),
+	stopExposure: (options) => lynxApi("stopExposure")(options ?? {}),
+	resumeExposure: () => lynxApi("resumeExposure")(),
+	subscribeSessionStorage: (key, relayId) => {
+		const listenerId = lynxApi("subscribeSessionStorage")(key, (value) => lynx.getCoreContext().dispatchEvent({
+			type: SESSION_STORAGE_EVENT,
+			data: JSON.stringify({
+				relayId,
+				value
+			})
+		}));
+		relayedSubscriptions.set(relayId, {
+			key,
+			listenerId
+		});
+	},
+	unsubscribeSessionStorage: (relayId) => {
+		const subscription = relayedSubscriptions.get(relayId);
+		if (!subscription) return;
+		relayedSubscriptions.delete(relayId);
+		lynxApi("unsubscribeSessionStorage")(subscription.key, subscription.listenerId);
+	},
+	requestResourcePrefetch: (data) => new Promise((resolve) => lynxApi("requestResourcePrefetch")(data, resolve)),
+	cancelResourcePrefetch: (data) => new Promise((resolve) => lynxApi("cancelResourcePrefetch")(data, resolve)),
+	nativeBridgeCall: (name, params) => {
+		const bridge = nativeBridge();
+		if (!bridge) return Promise.resolve(void 0);
+		return new Promise((resolve) => bridge.call(name, params, (...args) => resolve(args[0])));
+	},
+	nativeBridgeOn: (name, callback) => {
+		nativeBridge()?.on(name, restoreFunctions(callback));
+	},
+	callModule: (kind, name, method, args) => {
+		const module = findModule(kind, name);
+		const fn = module?.[method];
+		if (typeof fn !== "function") throw new Error(`${kind === "native" ? "NativeModules" : "lynx.getJSModule"}: ${name}.${method} is not available`);
+		return fn.apply(module, restoreFunctions(args));
+	},
+	registerJSModule: (name, module) => {
+		lynxApi("registerModule")(name, restoreFunctions(module));
+	},
+	osVersion: () => typeof SystemInfo !== "undefined" ? SystemInfo.osVersion : void 0,
+	fetch: (id, request) => fetchForMainThread(id, request),
+	abortFetch: (id) => abortFetchForMainThread(id)
+};
+const pending = /* @__PURE__ */ new Map();
+let nextCallId = 0;
+const callOnBackground = (name, ...args) => {
+	if (!isMainThread()) try {
+		return Promise.resolve(handlers[name](...args));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+	return new Promise((resolve, reject) => {
+		const id = nextCallId++;
+		pending.set(id, {
+			resolve,
+			reject
+		});
+		try {
+			lynx.getJSContext().dispatchEvent({
+				type: CALL_EVENT,
+				data: JSON.stringify({
+					id,
+					name,
+					args
+				})
+			});
+		} catch {
+			pending.delete(id);
+			reject(/* @__PURE__ */ new Error(`Can't reach the background thread to call lynx.${name} in this environment`));
+		}
+	});
+};
+const moduleProxies = /* @__PURE__ */ new Map();
+const relayedModule = (kind, name) => {
+	const cacheKey = `${kind}:${name}`;
+	let proxy = moduleProxies.get(cacheKey);
+	if (!proxy) {
+		const methods = /* @__PURE__ */ new Map();
+		proxy = new Proxy({}, { get: (_target, method) => {
+			if (typeof method !== "string" || method === "then") return;
+			let call = methods.get(method);
+			if (!call) {
+				call = (...args) => callOnBackground("callModule", kind, name, method, relayFunctions(args));
+				methods.set(method, call);
+			}
+			return call;
+		} });
+		moduleProxies.set(cacheKey, proxy);
+	}
+	return proxy;
+};
+const sessionStorageListeners = /* @__PURE__ */ new Map();
+let nextRelayId = 0;
+const subscribeSessionStorageFromMainThread = (key, listener) => {
+	const relayId = nextRelayId++;
+	sessionStorageListeners.set(relayId, listener);
+	callOnBackground("subscribeSessionStorage", key, relayId).catch(() => {
+		sessionStorageListeners.delete(relayId);
+	});
+	return relayId;
+};
+const unsubscribeSessionStorageFromMainThread = (relayId) => {
+	if (!sessionStorageListeners.delete(relayId)) return;
+	callOnBackground("unsubscribeSessionStorage", relayId).catch(() => {});
+};
+const installRelay = () => {
+	if (typeof lynx === "undefined") return;
+	try {
+		if (isMainThread()) {
+			const context = lynx.getJSContext();
+			context.addEventListener(RESULT_EVENT, (event) => {
+				const { id, value, error } = JSON.parse(event.data);
+				const call = pending.get(id);
+				if (!call) return;
+				pending.delete(id);
+				if (error !== void 0) call.reject(new Error(error));
+				else call.resolve(value);
+			});
+			context.addEventListener(SESSION_STORAGE_EVENT, (event) => {
+				const { relayId, value } = JSON.parse(event.data);
+				sessionStorageListeners.get(relayId)?.(value);
+			});
+			context.addEventListener(CALLBACK_EVENT, (event) => {
+				const { id, args } = JSON.parse(event.data);
+				relayedFunctions.get(id)?.(...args);
+			});
+			return;
+		}
+		const context = lynx.getCoreContext();
+		context.addEventListener(CALL_EVENT, async (event) => {
+			const { id, name, args } = JSON.parse(event.data);
+			let reply;
+			try {
+				const handler = handlers[name];
+				if (!handler) throw new Error(`Unknown background call: ${name}`);
+				reply = {
+					id,
+					value: await handler(...args)
+				};
+			} catch (error) {
+				reply = {
+					id,
+					error: error instanceof Error ? error.message : String(error)
+				};
+			}
+			let data;
+			try {
+				data = JSON.stringify(reply);
+			} catch (error) {
+				data = JSON.stringify({
+					id,
+					error: `The result of ${name} can't be sent to the main thread: ${error.message}`
+				});
+			}
+			context.dispatchEvent({
+				type: RESULT_EVENT,
+				data
+			});
+		});
+	} catch {}
+};
+installRelay();
+const ANIMATION_START = 0;
+const ANIMATION_PLAY = 1;
+const ANIMATION_PAUSE = 2;
+const ANIMATION_CANCEL = 3;
+var LynxAnimation = class LynxAnimation {
+	static #count = 0;
+	id;
+	#element;
+	#key;
+	#webAnimation;
+	constructor(element, keyframes, options) {
+		this.#element = element;
+		this.id = `__lynx-angular-animation-${LynxAnimation.#count++}`;
+		this.#key = __WEB__ ? this.id : options.name ?? this.id;
+		const wireOptions = { ...options };
+		if (options.iterations != null && !("iterationCount" in options)) wireOptions["iterationCount"] = options.iterations === Infinity ? "infinite" : options.iterations;
+		if (options.easing != null && !("timingFunction" in options)) wireOptions["timingFunction"] = options.easing;
+		if (options.fill != null && !("fillMode" in options)) wireOptions["fillMode"] = options.fill;
+		__ElementAnimate(this.#element, [
+			ANIMATION_START,
+			this.#key,
+			keyframes,
+			wireOptions
+		]);
+		if (__WEB__) this.#webAnimation = this.#element.getAnimations?.().at(-1);
+	}
+	play() {
+		__ElementAnimate(this.#element, [ANIMATION_PLAY, this.#key]);
+	}
+	pause() {
+		__ElementAnimate(this.#element, [ANIMATION_PAUSE, this.#key]);
+	}
+	cancel() {
+		__ElementAnimate(this.#element, [ANIMATION_CANCEL, this.#key]);
+		this.#webAnimation?.cancel();
+	}
+};
+let willFlush = false;
+const scheduleFlush = () => {
+	if (willFlush) return;
+	willFlush = true;
+	Promise.resolve().then(() => {
+		willFlush = false;
+		__FlushElementTree();
+	});
+};
+var MainThreadElement = class MainThreadElement {
+	#element;
+	constructor(element) {
+		this.#element = element;
+	}
+	setAttribute(name, value) {
+		__SetAttribute(this.#element, name, value);
+		scheduleFlush();
+	}
+	getAttribute(name) {
+		return __GetAttributeByName(this.#element, name);
+	}
+	getAttributeNames() {
+		return __GetAttributeNames(this.#element);
+	}
+	setStyleProperty(name, value) {
+		__AddInlineStyle(this.#element, name, value);
+		scheduleFlush();
+	}
+	setStyleProperties(styles) {
+		for (const key in styles) __AddInlineStyle(this.#element, key, styles[key]);
+		scheduleFlush();
+	}
+	querySelector(selector) {
+		const ref = __QuerySelector(this.#element, selector, {});
+		return ref ? new MainThreadElement(ref) : null;
+	}
+	querySelectorAll(selector) {
+		return __QuerySelectorAll(this.#element, selector, {}).map((el) => new MainThreadElement(el));
+	}
+	invoke(methodName, params) {
+		return new Promise((resolve, reject) => {
+			__InvokeUIMethod(this.#element, methodName, params ?? {}, (res) => {
+				if (res.code === 0) resolve(res.data);
+				else reject(/* @__PURE__ */ new Error("UI method invoke: " + JSON.stringify(res)));
+			});
+			scheduleFlush();
+		});
+	}
+	animate(keyframes, options) {
+		const normalizedOptions = typeof options === "number" ? { duration: options } : options ?? {};
+		return new LynxAnimation(this.#element, keyframes, normalizedOptions);
+	}
+	getBoundingClientRect(options) {
+		return this.invoke("boundingClientRect", options).then((rect) => {
+			const { left, top, right, bottom, width, height } = rect;
+			return {
+				left,
+				top,
+				right,
+				bottom,
+				width,
+				height
+			};
+		});
+	}
+};
 var LynxAccessibility = class LynxAccessibility {
 	announce(content) {
-		if (typeof lynx === "undefined" || typeof lynx.accessibilityAnnounce !== "function") return Promise.reject(/* @__PURE__ */ new Error("lynx.accessibilityAnnounce is not available in this environment"));
-		return new Promise((resolve) => {
-			lynx.accessibilityAnnounce({ content }, () => resolve());
-		});
+		return callOnBackground("accessibilityAnnounce", content);
 	}
 	requestFocus(selector) {
+		if (typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__) {
+			const element = new MainThreadElement(__GetPageElement()).querySelector(selector);
+			if (!element) return Promise.reject(/* @__PURE__ */ new Error(`requestAccessibilityFocus: no element matches ${selector}`));
+			return element.invoke("requestAccessibilityFocus").then(() => void 0);
+		}
 		if (typeof lynx === "undefined" || !lynx.createSelectorQuery) return Promise.reject(/* @__PURE__ */ new Error("lynx.createSelectorQuery is not available in this environment"));
 		return new Promise((resolve, reject) => {
 			lynx.createSelectorQuery().select(selector).invoke({
@@ -49,38 +513,121 @@ i0.ɵɵngDeclareClassMetadata({
 		args: [{ providedIn: "root" }]
 	}]
 });
-const ANIMATION_START = 0;
-const ANIMATION_PLAY = 1;
-const ANIMATION_PAUSE = 2;
-const ANIMATION_CANCEL = 3;
-var LynxAnimation = class LynxAnimation {
-	static #count = 0;
-	id;
-	#element;
-	constructor(element, keyframes, options) {
-		this.#element = element;
-		this.id = `__lynx-angular-animation-${LynxAnimation.#count++}`;
-		const wireOptions = { ...options };
-		if (options.iterations != null && !("iterationCount" in options)) wireOptions["iterationCount"] = options.iterations === Infinity ? "infinite" : options.iterations;
-		if (options.easing != null && !("timingFunction" in options)) wireOptions["timingFunction"] = options.easing;
-		if (options.fill != null && !("fillMode" in options)) wireOptions["fillMode"] = options.fill;
-		__ElementAnimate(this.#element, [
-			ANIMATION_START,
-			options.name ?? this.id,
-			keyframes,
-			wireOptions
-		]);
-	}
-	play() {
-		__ElementAnimate(this.#element, [ANIMATION_PLAY, this.id]);
+const initDataUpdates = new Subject();
+const globalDataUpdates = new Subject();
+const asRecord = (data) => typeof data === "object" && data !== null ? data : {};
+const applyInitDataUpdate = (data, reset) => {
+	const host = lynx;
+	const next = {
+		...reset ? {} : host.__initData,
+		...asRecord(data)
+	};
+	host.__initData = next;
+	initDataUpdates.next(next);
+	return next;
+};
+const applyGlobalDataUpdate = (data) => {
+	const next = {
+		...lynx.__globalProps,
+		...asRecord(data)
+	};
+	lynx.__globalProps = next;
+	globalDataUpdates.next(next);
+	return next;
+};
+var LynxGlobalData = class LynxGlobalData {
+	globalData = signal(typeof lynx !== "undefined" && lynx.__globalProps || {}, ...ngDevMode ? [{ debugName: "globalData" }] : /* istanbul ignore next */ []);
+	constructor() {
+		const subscription = globalDataUpdates.subscribe((data) => this.globalData.set(data));
+		inject(DestroyRef).onDestroy(() => subscription.unsubscribe());
 	}
-	pause() {
-		__ElementAnimate(this.#element, [ANIMATION_PAUSE, this.id]);
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.1",
+		ngImport: i0,
+		type: LynxGlobalData,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.1",
+		ngImport: i0,
+		type: LynxGlobalData,
+		providedIn: "root"
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: LynxGlobalData,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}],
+	ctorParameters: () => []
+});
+const MEDIA_QUERIES = {
+	reduceMotion: "(prefers-reduced-motion: reduce)",
+	reduceTransparency: "(prefers-reduced-transparency: reduce)",
+	increaseContrast: "(prefers-contrast: more)"
+};
+const isOn = (data, setting) => data[setting] === true || data[setting] === "true";
+const pageWindow = () => {
+	if (!__WEB__ || typeof __GetPageElement !== "function") return void 0;
+	return __GetPageElement()?.ownerDocument?.defaultView ?? void 0;
+};
+const watchMediaQueries = (destroyRef) => {
+	const win = pageWindow();
+	const signals = {};
+	for (const setting of Object.keys(MEDIA_QUERIES)) {
+		const query = typeof win?.matchMedia === "function" ? win.matchMedia(MEDIA_QUERIES[setting]) : void 0;
+		const matches = signal(query?.matches ?? false, ...ngDevMode ? [{ debugName: "matches" }] : /* istanbul ignore next */ []);
+		if (query) {
+			const update = () => matches.set(query.matches);
+			query.addEventListener("change", update);
+			destroyRef.onDestroy(() => query.removeEventListener("change", update));
+		}
+		signals[setting] = matches.asReadonly();
 	}
-	cancel() {
-		__ElementAnimate(this.#element, [ANIMATION_CANCEL, this.id]);
+	return signals;
+};
+var LynxAccessibilitySettings = class LynxAccessibilitySettings {
+	#globalData = inject(LynxGlobalData);
+	#media = watchMediaQueries(inject(DestroyRef));
+	reduceMotion = this.#setting("reduceMotion");
+	reduceTransparency = this.#setting("reduceTransparency");
+	increaseContrast = this.#setting("increaseContrast");
+	#setting(setting) {
+		return computed(() => isOn(this.#globalData.globalData(), setting) || this.#media[setting]());
 	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.1",
+		ngImport: i0,
+		type: LynxAccessibilitySettings,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.1",
+		ngImport: i0,
+		type: LynxAccessibilitySettings,
+		providedIn: "root"
+	});
 };
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: LynxAccessibilitySettings,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
 var LynxPerformance = class LynxPerformance {
 	#perf = this.#resolve();
 	#resolve() {
@@ -142,6 +689,15 @@ const devStats = {
 		this.lastCdDurationMs = 0;
 	}
 };
+const now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+const cdStartTimes = [];
+const startCdTiming = () => {
+	cdStartTimes.push(now());
+};
+const endCdTiming = () => {
+	const start = cdStartTimes.pop();
+	if (start !== void 0) devStats.lastCdDurationMs = now() - start;
+};
 var LynxDevTools = class LynxDevTools {
 	#tick = signal(0, ...ngDevMode ? [{ debugName: "#tick" }] : /* istanbul ignore next */ []);
 	stats = computed(() => {
@@ -206,48 +762,11 @@ const registerDataProcessors = (definition) => {
 		}
 	};
 };
-var LynxGlobalData = class LynxGlobalData {
-	globalData = signal(typeof lynx !== "undefined" ? lynx.__globalProps : {}, ...ngDevMode ? [{ debugName: "globalData" }] : /* istanbul ignore next */ []);
-	constructor() {
-		if (typeof lynx === "undefined" || typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__ || typeof lynx.getJSModule !== "function") return;
-		const emitter = lynx.getJSModule("GlobalEventEmitter");
-		if (!emitter?.addListener) return;
-		emitter.addListener("onGlobalPropsChanged", (...args) => this.globalData.set(args[0]));
-	}
-	static ɵfac = i0.ɵɵngDeclareFactory({
-		minVersion: "12.0.0",
-		version: "22.2.1",
-		ngImport: i0,
-		type: LynxGlobalData,
-		deps: [],
-		target: i0.ɵɵFactoryTarget.Injectable
-	});
-	static ɵprov = i0.ɵɵngDeclareInjectable({
-		minVersion: "12.0.0",
-		version: "22.2.1",
-		ngImport: i0,
-		type: LynxGlobalData,
-		providedIn: "root"
-	});
-};
-i0.ɵɵngDeclareClassMetadata({
-	minVersion: "12.0.0",
-	version: "22.2.1",
-	ngImport: i0,
-	type: LynxGlobalData,
-	decorators: [{
-		type: Injectable,
-		args: [{ providedIn: "root" }]
-	}],
-	ctorParameters: () => []
-});
 var LynxInitData = class LynxInitData {
-	initData = signal(typeof lynx !== "undefined" ? lynx.__initData : {}, ...ngDevMode ? [{ debugName: "initData" }] : /* istanbul ignore next */ []);
+	initData = signal(typeof lynx !== "undefined" && lynx.__initData || {}, ...ngDevMode ? [{ debugName: "initData" }] : /* istanbul ignore next */ []);
 	constructor() {
-		if (typeof lynx === "undefined" || typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__ || typeof lynx.getJSModule !== "function") return;
-		const emitter = lynx.getJSModule("GlobalEventEmitter");
-		if (!emitter?.addListener) return;
-		emitter.addListener("onDataChanged", (...args) => this.initData.set(args[0]));
+		const subscription = initDataUpdates.subscribe((data) => this.initData.set(data));
+		inject(DestroyRef).onDestroy(() => subscription.unsubscribe());
 	}
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
@@ -356,30 +875,57 @@ i0.ɵɵngDeclareClassMetadata({
 	}],
 	ctorParameters: () => []
 });
+const globalExposureBatches = new Subject();
+const FORWARD_EVENT = "AngularLynx.GlobalExposure";
+const installGlobalExposureBridge = () => {
+	if (typeof lynx === "undefined") return;
+	try {
+		if (__MAIN_THREAD__) {
+			lynx.getJSContext?.()?.addEventListener(FORWARD_EVENT, (event) => globalExposureBatches.next(JSON.parse(event.data)));
+			return;
+		}
+		const emitter = lynx.getJSModule?.("GlobalEventEmitter");
+		if (!emitter?.addListener) return;
+		for (const type of ["exposure", "disexposure"]) emitter.addListener(type, (...args) => {
+			const batch = {
+				type,
+				events: args[0]
+			};
+			globalExposureBatches.next(batch);
+			lynx.getCoreContext?.()?.dispatchEvent({
+				type: FORWARD_EVENT,
+				data: JSON.stringify(batch)
+			});
+		});
+	} catch {}
+};
+installGlobalExposureBridge();
 var LynxGlobalExposure = class LynxGlobalExposure {
 	exposures = signal([], ...ngDevMode ? [{ debugName: "exposures" }] : /* istanbul ignore next */ []);
 	disexposures = signal([], ...ngDevMode ? [{ debugName: "disexposures" }] : /* istanbul ignore next */ []);
 	active = signal(true, ...ngDevMode ? [{ debugName: "active" }] : /* istanbul ignore next */ []);
 	constructor() {
-		if (typeof lynx === "undefined" || typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__) return;
-		const emitter = lynx.getJSModule("GlobalEventEmitter");
-		if (!emitter?.addListener) return;
-		emitter.addListener("exposure", (...args) => this.exposures.set(args[0]));
-		emitter.addListener("disexposure", (...args) => this.disexposures.set(args[0]));
+		const subscription = globalExposureBatches.subscribe(({ type, events }) => (type === "exposure" ? this.exposures : this.disexposures).set(events));
+		inject(DestroyRef).onDestroy(() => subscription.unsubscribe());
 	}
 	stopExposure(options) {
 		if (typeof lynx === "undefined") return;
-		lynx.stopExposure(options);
+		if (typeof lynx.stopExposure === "function") lynx.stopExposure(options);
+		else this.#relay(callOnBackground("stopExposure", options));
 		this.active.set(false);
 	}
 	resumeExposure() {
 		if (typeof lynx === "undefined") return;
-		lynx.resumeExposure();
+		if (typeof lynx.resumeExposure === "function") lynx.resumeExposure();
+		else this.#relay(callOnBackground("resumeExposure"));
 		this.active.set(true);
 	}
 	setObserverFrameRate(options) {
-		if (typeof lynx === "undefined") return;
-		lynx.setObserverFrameRate(options);
+		if (typeof lynx === "undefined") return Promise.resolve();
+		return callOnBackground("setObserverFrameRate", options);
+	}
+	#relay(call) {
+		call.catch((error) => console.error(error));
 	}
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
@@ -428,30 +974,23 @@ var LynxFont = class LynxFont {
 			src,
 			status: "loading"
 		});
-		const promise = new Promise((resolve, reject) => {
-			lynx.addFont({
-				"font-family": fontFamily,
-				src
-			}, (err) => {
-				if (err) {
-					this.#updateEntry(fontFamily, {
-						fontFamily,
-						src,
-						status: "error",
-						error: err
-					});
-					this.#pending.delete(fontFamily);
-					reject(err);
-				} else {
-					this.#updateEntry(fontFamily, {
-						fontFamily,
-						src,
-						status: "loaded"
-					});
-					this.#pending.delete(fontFamily);
-					resolve();
-				}
+		const promise = callOnBackground("addFont", fontFamily, src).then(() => {
+			this.#updateEntry(fontFamily, {
+				fontFamily,
+				src,
+				status: "loaded"
+			});
+			this.#pending.delete(fontFamily);
+		}, (err) => {
+			const error = err instanceof Error ? err : new Error(String(err));
+			this.#updateEntry(fontFamily, {
+				fontFamily,
+				src,
+				status: "error",
+				error
 			});
+			this.#pending.delete(fontFamily);
+			throw error;
 		});
 		this.#pending.set(fontFamily, promise);
 		return promise;
@@ -541,10 +1080,48 @@ const reportError = (source, cause) => {
 		_ReportError(error, { errorCode: 6 });
 	}
 };
+const DATA_KEY = "angularLynx";
+const ɵhmrAccept = (hot, components, signature, code) => {
+	hot.accept();
+	if (!isMainThread()) return components;
+	const previous = hot.data?.[DATA_KEY];
+	let live = components;
+	let invalidated = false;
+	if (previous && !previous.invalidated) {
+		if (previous.code !== code && previous.signature === signature && previous.components.length === components.length) try {
+			previous.components.forEach((type, index) => replaceComponent(type, components[index]));
+			live = previous.components;
+		} catch (error) {
+			console.error("[HMR] Could not update the component in place:", error);
+			invalidated = true;
+		}
+		else invalidated = true;
+	}
+	hot.dispose((data) => {
+		data[DATA_KEY] = {
+			components: live,
+			signature,
+			code,
+			invalidated
+		};
+	});
+	if (invalidated) hot.invalidate();
+	return live;
+};
+const replaceComponent = (current, next) => {
+	const currentDef = current.ɵcmp;
+	const nextDef = next.ɵcmp;
+	currentDef.directiveDefs = nextDef.directiveDefs;
+	currentDef.pipeDefs = nextDef.pipeDefs;
+	ɵɵreplaceMetadata(current, (type) => {
+		type.ɵcmp = next.ɵcmp;
+	}, [], []);
+};
 const extractAppLocale = (globalProps) => {
 	const value = globalProps?.["appLocale"];
 	return typeof value === "string" && value ? value : void 0;
 };
+const getSourceLocale = () => typeof __LYNX_SOURCE_LOCALE__ !== "undefined" ? __LYNX_SOURCE_LOCALE__ : "en-US";
 const getLynxAppLocale = () => {
 	if (typeof lynx === "undefined") return;
 	return extractAppLocale(lynx.__globalProps);
@@ -552,9 +1129,7 @@ const getLynxAppLocale = () => {
 var LynxLocale = class LynxLocale {
 	#globalData = inject(LynxGlobalData);
 	locale = computed(() => {
-		const value = extractAppLocale(this.#globalData.globalData());
-		if (value) return value;
-		return typeof __LYNX_SOURCE_LOCALE__ !== "undefined" ? __LYNX_SOURCE_LOCALE__ : "en-US";
+		return extractAppLocale(this.#globalData.globalData()) ?? getSourceLocale();
 	}, ...ngDevMode ? [{ debugName: "locale" }] : /* istanbul ignore next */ []);
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
@@ -582,17 +1157,31 @@ i0.ɵɵngDeclareClassMetadata({
 		args: [{ providedIn: "root" }]
 	}]
 });
+const hasLocaleData = (locale) => {
+	try {
+		getLocaleId(locale);
+		return true;
+	} catch {
+		return false;
+	}
+};
 const provideLocale = () => {
 	return makeEnvironmentProviders([{
 		provide: LOCALE_ID,
-		useFactory: () => inject(LynxLocale).locale()
+		useFactory: () => {
+			const locale = inject(LynxLocale).locale();
+			const source = getSourceLocale();
+			if (locale === source || hasLocaleData(locale)) return locale;
+			console.warn(`provideLocale(): Angular has no locale data for "${locale}", so LOCALE_ID is "${source}". Register it with registerLocaleData() to format dates and numbers for it.`);
+			return source;
+		}
 	}]);
 };
 let nextGestureId = 1;
 var BaseGesture = class {
 	id = nextGestureId++;
 	_callbacks = {};
-	_config = {};
+	_config = { enabled: true };
 	_waitFor = [];
 	_simultaneousWith = [];
 	_continueWith = [];
@@ -716,7 +1305,7 @@ const mapGestureEvent = (raw, name, origin) => {
 		absoluteY
 	};
 	if (origin) {
-		if (name === "onBegin" || name === "onStart" || origin.x === null) {
+		if (name === "onBegin" || origin.x === null) {
 			origin.x = absoluteX ?? 0;
 			origin.y = absoluteY ?? 0;
 		}
@@ -756,19 +1345,22 @@ var LynxGestureDetector = class LynxGestureDetector {
 	#el = inject(ElementRef).nativeElement;
 	#attachedIds = [];
 	lynxGesture;
+	constructor() {
+		const elementRef = this.#el.element;
+		if (elementRef) __SetAttribute(elementRef, "flatten", false);
+	}
 	ngOnChanges(_changes) {
 		this.#detachAll();
 		const gestures = this.#resolveGestures();
 		if (gestures.length === 0) return;
 		const elementRef = this.#el.element;
 		if (!elementRef) return;
-		__SetAttribute(elementRef, "flatten", false);
 		for (const g of gestures) {
 			const stateManager = new GestureStateManager(elementRef, g.id);
 			const origin = createGestureOrigin();
 			const config = {
 				callbacks: buildGestureCallbacks(g, origin, stateManager),
-				config: Object.keys(g._config).length > 0 ? g._config : void 0
+				config: g._config
 			};
 			const relationMap = {
 				waitFor: g._waitFor.map((dep) => dep.id),
@@ -826,7 +1418,8 @@ i0.ɵɵngDeclareClassMetadata({
 			selector: "[lynxGesture]",
 			inputs: ["lynxGesture"]
 		}]
-	}]
+	}],
+	ctorParameters: () => []
 });
 const buildGestureCallbacks = (gesture, origin, stateManager) => {
 	const wrap = (name, cb) => ({
@@ -834,7 +1427,11 @@ const buildGestureCallbacks = (gesture, origin, stateManager) => {
 		callback: { _fn: (event) => cb(mapGestureEvent(event, name, origin), stateManager) }
 	});
 	const userEnd = gesture._callbacks["onEnd"];
-	if (!(gesture.type === GestureType.TAP || gesture.type === GestureType.LONGPRESS) || !userEnd) return Object.entries(gesture._callbacks).map(([name, cb]) => wrap(name, cb));
+	if (!(gesture.type === GestureType.TAP || gesture.type === GestureType.LONGPRESS) || !userEnd) {
+		const callbacks = Object.entries(gesture._callbacks).map(([name, cb]) => wrap(name, cb));
+		if (gesture instanceof ContinuousGesture && !gesture._callbacks["onBegin"]) callbacks.push(wrap("onBegin", () => {}));
+		return callbacks;
+	}
 	const userStart = gesture._callbacks["onStart"];
 	const lifecycle = { started: false };
 	const callbacks = [{
@@ -934,6 +1531,15 @@ var TapGesture = class extends BaseGesture {
 		return this;
 	}
 };
+function booleanInput(value) {
+	return typeof value === "string" ? value !== "false" : value;
+}
+function panInterceptDirectionInput(value) {
+	return typeof value === "string" ? Number(value) : value;
+}
+function panInterceptScopeInput(value) {
+	return typeof value === "string" ? Number(value) : value;
+}
 var LynxElementBase = class LynxElementBase {
 	#el = inject(ElementRef).nativeElement;
 	ngOnChanges(changes) {
@@ -947,7 +1553,7 @@ var LynxElementBase = class LynxElementBase {
 	name;
 	"accessibility-element";
 	"accessibility-label";
-	"accessibility-trait";
+	"accessibility-traits";
 	"accessibility-elements";
 	"accessibility-elements-hidden";
 	"accessibility-exclusive-focus";
@@ -959,6 +1565,11 @@ var LynxElementBase = class LynxElementBase {
 	"block-native-event";
 	"ignore-focus";
 	"ios-enable-simultaneous-touch";
+	flatten;
+	"pan-intercept-direction";
+	"pan-intercept-scope";
+	"consume-slide-event";
+	"enable-touch-pseudo-propagation";
 	"exposure-id";
 	"exposure-scene";
 	"exposure-area";
@@ -970,6 +1581,7 @@ var LynxElementBase = class LynxElementBase {
 	"exposure-ui-margin-bottom";
 	"exposure-ui-margin-left";
 	"exposure-ui-margin-right";
+	"enable-exposure-ui-margin";
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
 		version: "22.2.1",
@@ -979,27 +1591,86 @@ var LynxElementBase = class LynxElementBase {
 		target: i0.ɵɵFactoryTarget.Directive
 	});
 	static ɵdir = i0.ɵɵngDeclareDirective({
-		minVersion: "14.0.0",
+		minVersion: "16.1.0",
 		version: "22.2.1",
 		type: LynxElementBase,
 		isStandalone: true,
 		inputs: {
 			id: "id",
 			name: "name",
-			"accessibility-element": "accessibility-element",
+			"accessibility-element": [
+				"accessibility-element",
+				"accessibility-element",
+				booleanInput
+			],
 			"accessibility-label": "accessibility-label",
-			"accessibility-trait": "accessibility-trait",
+			"accessibility-value": "accessibility-value",
+			"accessibility-actions": "accessibility-actions",
+			"accessibility-traits": "accessibility-traits",
 			"accessibility-elements": "accessibility-elements",
-			"accessibility-elements-hidden": "accessibility-elements-hidden",
-			"accessibility-exclusive-focus": "accessibility-exclusive-focus",
+			"accessibility-elements-hidden": [
+				"accessibility-elements-hidden",
+				"accessibility-elements-hidden",
+				booleanInput
+			],
+			"accessibility-exclusive-focus": [
+				"accessibility-exclusive-focus",
+				"accessibility-exclusive-focus",
+				booleanInput
+			],
 			"a11y-id": "a11y-id",
-			"user-interaction-enabled": "user-interaction-enabled",
-			"native-interaction-enabled": "native-interaction-enabled",
-			"event-through": "event-through",
+			"user-interaction-enabled": [
+				"user-interaction-enabled",
+				"user-interaction-enabled",
+				booleanInput
+			],
+			"native-interaction-enabled": [
+				"native-interaction-enabled",
+				"native-interaction-enabled",
+				booleanInput
+			],
+			"event-through": [
+				"event-through",
+				"event-through",
+				booleanInput
+			],
 			"hit-slop": "hit-slop",
-			"block-native-event": "block-native-event",
-			"ignore-focus": "ignore-focus",
-			"ios-enable-simultaneous-touch": "ios-enable-simultaneous-touch",
+			"block-native-event": [
+				"block-native-event",
+				"block-native-event",
+				booleanInput
+			],
+			"ignore-focus": [
+				"ignore-focus",
+				"ignore-focus",
+				booleanInput
+			],
+			"ios-enable-simultaneous-touch": [
+				"ios-enable-simultaneous-touch",
+				"ios-enable-simultaneous-touch",
+				booleanInput
+			],
+			flatten: [
+				"flatten",
+				"flatten",
+				booleanInput
+			],
+			"pan-intercept-direction": [
+				"pan-intercept-direction",
+				"pan-intercept-direction",
+				panInterceptDirectionInput
+			],
+			"pan-intercept-scope": [
+				"pan-intercept-scope",
+				"pan-intercept-scope",
+				panInterceptScopeInput
+			],
+			"consume-slide-event": "consume-slide-event",
+			"enable-touch-pseudo-propagation": [
+				"enable-touch-pseudo-propagation",
+				"enable-touch-pseudo-propagation",
+				booleanInput
+			],
 			"exposure-id": "exposure-id",
 			"exposure-scene": "exposure-scene",
 			"exposure-area": "exposure-area",
@@ -1010,7 +1681,12 @@ var LynxElementBase = class LynxElementBase {
 			"exposure-ui-margin-top": "exposure-ui-margin-top",
 			"exposure-ui-margin-bottom": "exposure-ui-margin-bottom",
 			"exposure-ui-margin-left": "exposure-ui-margin-left",
-			"exposure-ui-margin-right": "exposure-ui-margin-right"
+			"exposure-ui-margin-right": "exposure-ui-margin-right",
+			"enable-exposure-ui-margin": [
+				"enable-exposure-ui-margin",
+				"enable-exposure-ui-margin",
+				booleanInput
+			]
 		},
 		usesOnChanges: true,
 		ngImport: i0
@@ -1026,20 +1702,66 @@ i0.ɵɵngDeclareClassMetadata({
 		args: [{ inputs: [
 			"id",
 			"name",
-			"accessibility-element",
+			{
+				name: "accessibility-element",
+				transform: booleanInput
+			},
 			"accessibility-label",
-			"accessibility-trait",
+			"accessibility-value",
+			"accessibility-actions",
+			"accessibility-traits",
 			"accessibility-elements",
-			"accessibility-elements-hidden",
-			"accessibility-exclusive-focus",
+			{
+				name: "accessibility-elements-hidden",
+				transform: booleanInput
+			},
+			{
+				name: "accessibility-exclusive-focus",
+				transform: booleanInput
+			},
 			"a11y-id",
-			"user-interaction-enabled",
-			"native-interaction-enabled",
-			"event-through",
+			{
+				name: "user-interaction-enabled",
+				transform: booleanInput
+			},
+			{
+				name: "native-interaction-enabled",
+				transform: booleanInput
+			},
+			{
+				name: "event-through",
+				transform: booleanInput
+			},
 			"hit-slop",
-			"block-native-event",
-			"ignore-focus",
-			"ios-enable-simultaneous-touch",
+			{
+				name: "block-native-event",
+				transform: booleanInput
+			},
+			{
+				name: "ignore-focus",
+				transform: booleanInput
+			},
+			{
+				name: "ios-enable-simultaneous-touch",
+				transform: booleanInput
+			},
+			{
+				name: "flatten",
+				transform: booleanInput
+			},
+			{
+				name: "pan-intercept-direction",
+				transform: panInterceptDirectionInput
+			},
+			{
+				name: "pan-intercept-scope",
+				transform: panInterceptScopeInput
+			},
+			"consume-slide-event",
+			{
+				name: "enable-touch-pseudo-propagation",
+				transform: booleanInput
+			},
 			"exposure-id",
 			"exposure-scene",
 			"exposure-area",
@@ -1050,7 +1772,11 @@ i0.ɵɵngDeclareClassMetadata({
 			"exposure-ui-margin-top",
 			"exposure-ui-margin-bottom",
 			"exposure-ui-margin-left",
-			"exposure-ui-margin-right"
+			"exposure-ui-margin-right",
+			{
+				name: "enable-exposure-ui-margin",
+				transform: booleanInput
+			}
 		] }]
 	}]
 });
@@ -1106,7 +1832,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "blur-view",
-			standalone: true,
 			inputs: [
 				"blur-radius",
 				"blur-sampling",
@@ -1149,10 +1874,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxCoverView,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "cover-view",
-			standalone: true
-		}]
+		args: [{ selector: "cover-view" }]
 	}]
 });
 var LynxInputValueAccessor = class LynxInputValueAccessor {
@@ -1167,7 +1889,7 @@ var LynxInputValueAccessor = class LynxInputValueAccessor {
 		this.#onTouched();
 	}
 	writeValue(value) {
-		this.#el.nativeElement.invoke?.("setValue", { value: value ?? "" });
+		this.#el.nativeElement.invoke("setValue", { value: value ?? "" });
 	}
 	registerOnChange(fn) {
 		this.#onChange = fn;
@@ -1215,7 +1937,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "input[formControlName],input[formControl],input[ngModel],input[formField]",
-			standalone: true,
 			providers: [{
 				provide: NG_VALUE_ACCESSOR,
 				/* v8 ignore next -- Angular metadata: the forwardRef arrow is only invoked by Angular's directive DI resolution, which happens inside a full template render — the accessor's runtime behavior is covered by direct unit tests below. */
@@ -1241,7 +1962,7 @@ var LynxTextareaValueAccessor = class LynxTextareaValueAccessor {
 		this.#onTouched();
 	}
 	writeValue(value) {
-		this.#el.nativeElement.invoke?.("setValue", { value: value ?? "" });
+		this.#el.nativeElement.invoke("setValue", { value: value ?? "" });
 	}
 	registerOnChange(fn) {
 		this.#onChange = fn;
@@ -1289,7 +2010,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "textarea[formControlName],textarea[formControl],textarea[ngModel],textarea[formField]",
-			standalone: true,
 			providers: [{
 				provide: NG_VALUE_ACCESSOR,
 				/* v8 ignore next -- Angular metadata: the forwardRef arrow is only invoked by Angular's directive DI resolution, which happens inside a full template render — the accessor's runtime behavior is covered by direct unit tests below. */
@@ -1350,7 +2070,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "frame",
-			standalone: true,
 			inputs: [
 				"src",
 				"data",
@@ -1422,7 +2141,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "image",
-			standalone: true,
 			inputs: [
 				"src",
 				"mode",
@@ -1446,7 +2164,7 @@ var LynxInput = class LynxInput extends LynxElementBase {
 	#el = inject(ElementRef).nativeElement;
 	ngOnChanges(changes) {
 		if ("value" in changes) {
-			this.#el.invoke?.("setValue", { value: changes["value"].currentValue ?? "" });
+			this.#el.invoke("setValue", { value: changes["value"].currentValue ?? "" });
 			const { value: _ignored, ...rest } = changes;
 			if (Object.keys(rest).length) super.ngOnChanges(rest);
 		} else super.ngOnChanges(changes);
@@ -1507,7 +2225,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "input",
-			standalone: true,
 			inputs: [
 				"type",
 				"placeholder",
@@ -1530,7 +2247,7 @@ var LynxTextarea = class LynxTextarea extends LynxElementBase {
 	#el = inject(ElementRef).nativeElement;
 	ngOnChanges(changes) {
 		if ("value" in changes) {
-			this.#el.invoke?.("setValue", { value: changes["value"].currentValue ?? "" });
+			this.#el.invoke("setValue", { value: changes["value"].currentValue ?? "" });
 			const { value: _ignored, ...rest } = changes;
 			if (Object.keys(rest).length) super.ngOnChanges(rest);
 		} else super.ngOnChanges(changes);
@@ -1599,7 +2316,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "textarea",
-			standalone: true,
 			inputs: [
 				"type",
 				"placeholder",
@@ -1641,8 +2357,6 @@ var LynxList = class LynxList extends LynxElementBase {
 	"preload-buffer-count";
 	"item-snap";
 	"update-animation";
-	"list-main-axis-gap";
-	"list-cross-axis-gap";
 	"enable-async-list";
 	"enable-insert-platform-view-operation";
 	"experimental-search-ref-anchor-strategy";
@@ -1680,8 +2394,6 @@ var LynxList = class LynxList extends LynxElementBase {
 			"preload-buffer-count": "preload-buffer-count",
 			"item-snap": "item-snap",
 			"update-animation": "update-animation",
-			"list-main-axis-gap": "list-main-axis-gap",
-			"list-cross-axis-gap": "list-cross-axis-gap",
 			"enable-async-list": "enable-async-list",
 			"enable-insert-platform-view-operation": "enable-insert-platform-view-operation",
 			"experimental-search-ref-anchor-strategy": "experimental-search-ref-anchor-strategy",
@@ -1700,7 +2412,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "list",
-			standalone: true,
 			inputs: [
 				"list-type",
 				"span-count",
@@ -1720,8 +2431,6 @@ i0.ɵɵngDeclareClassMetadata({
 				"preload-buffer-count",
 				"item-snap",
 				"update-animation",
-				"list-main-axis-gap",
-				"list-cross-axis-gap",
 				"enable-async-list",
 				"enable-insert-platform-view-operation",
 				"experimental-search-ref-anchor-strategy",
@@ -1738,7 +2447,6 @@ var LynxListItem = class LynxListItem extends LynxElementBase {
 	recyclable;
 	"reuse-identifier";
 	"estimated-main-axis-size-px";
-	defer;
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
 		version: "22.2.1",
@@ -1760,8 +2468,7 @@ var LynxListItem = class LynxListItem extends LynxElementBase {
 			"sticky-bottom": "sticky-bottom",
 			recyclable: "recyclable",
 			"reuse-identifier": "reuse-identifier",
-			"estimated-main-axis-size-px": "estimated-main-axis-size-px",
-			defer: "defer"
+			"estimated-main-axis-size-px": "estimated-main-axis-size-px"
 		},
 		usesInheritance: true,
 		ngImport: i0
@@ -1776,7 +2483,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "list-item",
-			standalone: true,
 			inputs: [
 				"item-key",
 				"full-span",
@@ -1784,8 +2490,7 @@ i0.ɵɵngDeclareClassMetadata({
 				"sticky-bottom",
 				"recyclable",
 				"reuse-identifier",
-				"estimated-main-axis-size-px",
-				"defer"
+				"estimated-main-axis-size-px"
 			]
 		}]
 	}]
@@ -1816,10 +2521,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxBlock,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "block",
-			standalone: true
-		}]
+		args: [{ selector: "block" }]
 	}]
 });
 var LynxIf = class LynxIf extends LynxElementBase {
@@ -1848,10 +2550,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxIf,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "if",
-			standalone: true
-		}]
+		args: [{ selector: "if" }]
 	}]
 });
 var LynxFor = class LynxFor extends LynxElementBase {
@@ -1880,10 +2579,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxFor,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "for",
-			standalone: true
-		}]
+		args: [{ selector: "for" }]
 	}]
 });
 var LynxOverlay = class LynxOverlay extends LynxElementBase {
@@ -1928,7 +2624,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "overlay",
-			standalone: true,
 			inputs: [
 				"visible",
 				"level",
@@ -1970,7 +2665,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "refresh",
-			standalone: true,
 			inputs: ["enable-refresh"]
 		}]
 	}]
@@ -2001,10 +2695,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxRefreshHeader,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "refresh-header",
-			standalone: true
-		}]
+		args: [{ selector: "refresh-header" }]
 	}]
 });
 var LynxScrollCoordinator = class LynxScrollCoordinator extends LynxElementBase {
@@ -2057,7 +2748,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "scroll-coordinator",
-			standalone: true,
 			inputs: [
 				"enable-scroll",
 				"bounces",
@@ -2099,10 +2789,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxScrollCoordinatorHeader,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "scroll-coordinator-header",
-			standalone: true
-		}]
+		args: [{ selector: "scroll-coordinator-header" }]
 	}]
 });
 var LynxScrollCoordinatorToolbar = class LynxScrollCoordinatorToolbar extends LynxElementBase {
@@ -2131,10 +2818,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxScrollCoordinatorToolbar,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "scroll-coordinator-toolbar",
-			standalone: true
-		}]
+		args: [{ selector: "scroll-coordinator-toolbar" }]
 	}]
 });
 var LynxScrollCoordinatorSlot = class LynxScrollCoordinatorSlot extends LynxElementBase {
@@ -2163,10 +2847,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxScrollCoordinatorSlot,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "scroll-coordinator-slot",
-			standalone: true
-		}]
+		args: [{ selector: "scroll-coordinator-slot" }]
 	}]
 });
 var LynxScrollCoordinatorSlotDrag = class LynxScrollCoordinatorSlotDrag extends LynxElementBase {
@@ -2199,7 +2880,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "scroll-coordinator-slot-drag",
-			standalone: true,
 			inputs: ["enable-drag"]
 		}]
 	}]
@@ -2254,7 +2934,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "scroll-view",
-			standalone: true,
 			inputs: [
 				"scroll-orientation",
 				"enable-scroll",
@@ -2306,7 +2985,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "svg",
-			standalone: true,
 			inputs: [
 				"src",
 				"content",
@@ -2363,7 +3041,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "text",
-			standalone: true,
 			inputs: [
 				"text-maxline",
 				"text-single-line-vertical-align",
@@ -2404,10 +3081,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxInlineTruncation,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "inline-truncation",
-			standalone: true
-		}]
+		args: [{ selector: "inline-truncation" }]
 	}]
 });
 var LynxTitleBarView = class LynxTitleBarView extends LynxElementBase {
@@ -2440,7 +3114,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "title-bar-view",
-			standalone: true,
 			inputs: ["moveable"]
 		}]
 	}]
@@ -2491,7 +3164,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "video",
-			standalone: true,
 			inputs: [
 				"src",
 				"loop",
@@ -2506,11 +3178,6 @@ i0.ɵɵngDeclareClassMetadata({
 	}]
 });
 var LynxView = class LynxView extends LynxElementBase {
-	flatten;
-	"pan-intercept-direction";
-	"pan-intercept-scope";
-	"consume-slide-event";
-	"enable-touch-pseudo-propagation";
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
 		version: "22.2.1",
@@ -2525,13 +3192,6 @@ var LynxView = class LynxView extends LynxElementBase {
 		type: LynxView,
 		isStandalone: true,
 		selector: "view",
-		inputs: {
-			flatten: "flatten",
-			"pan-intercept-direction": "pan-intercept-direction",
-			"pan-intercept-scope": "pan-intercept-scope",
-			"consume-slide-event": "consume-slide-event",
-			"enable-touch-pseudo-propagation": "enable-touch-pseudo-propagation"
-		},
 		usesInheritance: true,
 		ngImport: i0
 	});
@@ -2543,17 +3203,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxView,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "view",
-			standalone: true,
-			inputs: [
-				"flatten",
-				"pan-intercept-direction",
-				"pan-intercept-scope",
-				"consume-slide-event",
-				"enable-touch-pseudo-propagation"
-			]
-		}]
+		args: [{ selector: "view" }]
 	}]
 });
 var LynxViewPager = class LynxViewPager extends LynxElementBase {
@@ -2606,7 +3256,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "viewpager",
-			standalone: true,
 			inputs: [
 				"initial-select-index",
 				"enable-scroll",
@@ -2648,10 +3297,7 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxViewPagerItem,
 	decorators: [{
 		type: Directive,
-		args: [{
-			selector: "viewpager-item",
-			standalone: true
-		}]
+		args: [{ selector: "viewpager-item" }]
 	}]
 });
 var LynxWebView = class LynxWebView extends LynxElementBase {
@@ -2704,7 +3350,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Directive,
 		args: [{
 			selector: "webview",
-			standalone: true,
 			inputs: [
 				"src",
 				"html",
@@ -2720,6 +3365,43 @@ i0.ɵɵngDeclareClassMetadata({
 		}]
 	}]
 });
+const ROUTER_LINK_ACTIVE_CHANGE = new InjectionToken("router-link-active-change");
+var LynxRouterLinkActive = class LynxRouterLinkActive {
+	constructor() {
+		const activeChange = inject(ROUTER_LINK_ACTIVE_CHANGE, { optional: true })?.();
+		if (!activeChange) return;
+		const element = inject(ElementRef).nativeElement;
+		const subscription = activeChange.subscribe((active) => element.setAccessibilityTrait("selected", active));
+		inject(DestroyRef).onDestroy(() => subscription.unsubscribe());
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.1",
+		ngImport: i0,
+		type: LynxRouterLinkActive,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Directive
+	});
+	static ɵdir = i0.ɵɵngDeclareDirective({
+		minVersion: "14.0.0",
+		version: "22.2.1",
+		type: LynxRouterLinkActive,
+		isStandalone: true,
+		selector: "[routerLinkActive]",
+		ngImport: i0
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: LynxRouterLinkActive,
+	decorators: [{
+		type: Directive,
+		args: [{ selector: "[routerLinkActive]" }]
+	}],
+	ctorParameters: () => []
+});
 const LYNX_ELEMENTS = [
 	LynxView,
 	LynxText,
@@ -2734,7 +3416,8 @@ const LYNX_ELEMENTS = [
 	LynxFrame,
 	LynxInput,
 	LynxTextarea,
-	...LYNX_FORM_ACCESSORS,
+	LynxInputValueAccessor,
+	LynxTextareaValueAccessor,
 	LynxOverlay,
 	LynxRefresh,
 	LynxRefreshHeader,
@@ -2750,28 +3433,56 @@ const LYNX_ELEMENTS = [
 	LynxVideo,
 	LynxWebView,
 	LynxCoverView,
-	LynxTitleBarView
+	LynxTitleBarView,
+	LynxRouterLinkActive
 ];
-var LynxLogger = class LynxLogger {
-	#url = "";
-	#fetchFn;
-	constructor() {
-		if (!__DEV__) return;
-		this.#url = typeof __DEV_LOG_URL__ !== "undefined" ? __DEV_LOG_URL__ : "";
-		if (!this.#url) return;
-		try {
-			if (typeof fetch === "function") this.#fetchFn = fetch;
-			else if (typeof globalThis.fetch === "function") this.#fetchFn = globalThis.fetch;
-		} catch {}
-		if (!this.#fetchFn) return;
-		try {
-			if (typeof lynx !== "undefined" && typeof lynx.getCoreContext === "function") lynx.getCoreContext().addEventListener("__lynx_log__", (event) => {
-				try {
-					this.#postToServer(JSON.parse(event.data));
-				} catch {}
-			});
-		} catch {}
-	}
+const LOG_EVENT = "__lynx_log__";
+const logUrl = () => __DEV__ && typeof __DEV_LOG_URL__ !== "undefined" ? __DEV_LOG_URL__ : "";
+const resolveFetch = () => {
+	try {
+		if (typeof fetch === "function") return fetch;
+		else if (typeof globalThis.fetch === "function") return globalThis.fetch;
+	} catch {}
+};
+const toLogArg = (arg) => {
+	if (arg instanceof Error) return {
+		__type: "Error",
+		name: arg.name,
+		message: arg.message,
+		stack: arg.stack
+	};
+	if (typeof arg === "object" && arg !== null) try {
+		JSON.stringify(arg);
+		return arg;
+	} catch {}
+	return String(arg);
+};
+const postToServer = (fetchFn, url, entry) => {
+	try {
+		fetchFn(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ logs: [entry] })
+		}).catch(() => {});
+	} catch {}
+};
+const installLogRelay = () => {
+	if (typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__) return;
+	const url = logUrl();
+	const fetchFn = resolveFetch();
+	if (!url || !fetchFn) return;
+	try {
+		if (typeof lynx !== "undefined" && typeof lynx.getCoreContext === "function") lynx.getCoreContext().addEventListener(LOG_EVENT, (event) => {
+			try {
+				postToServer(fetchFn, url, JSON.parse(event.data));
+			} catch {}
+		});
+	} catch {}
+};
+installLogRelay();
+var LynxLogger = class LynxLogger {
+	#url = logUrl();
+	#fetchFn = this.#url ? resolveFetch() : void 0;
 	log(...args) {
 		this.#send("log", args);
 	}
@@ -2792,25 +3503,16 @@ var LynxLogger = class LynxLogger {
 		const entry = {
 			level,
 			timestamp: Date.now(),
-			args: args.map(String)
+			args: args.map(toLogArg)
 		};
-		if (this.#fetchFn) this.#postToServer(entry);
+		if (this.#fetchFn) postToServer(this.#fetchFn, this.#url, entry);
 		else try {
 			if (typeof lynx !== "undefined" && typeof lynx.getJSContext === "function") lynx.getJSContext().dispatchEvent({
-				type: "__lynx_log__",
+				type: LOG_EVENT,
 				data: JSON.stringify(entry)
 			});
 		} catch {}
 	}
-	#postToServer(entry) {
-		try {
-			this.#fetchFn(this.#url, {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({ logs: [entry] })
-			}).catch(() => {});
-		} catch {}
-	}
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
 		version: "22.2.1",
@@ -2835,39 +3537,35 @@ i0.ɵɵngDeclareClassMetadata({
 	decorators: [{
 		type: Injectable,
 		args: [{ providedIn: "root" }]
-	}],
-	ctorParameters: () => []
+	}]
 });
 var LynxNativeModule = class LynxNativeModule {
 	#hasNativeModules() {
-		return typeof NativeModules !== "undefined" && NativeModules != null && typeof NativeModules.bridge?.call === "function";
+		return typeof NativeModules !== "undefined" && NativeModules != null;
 	}
 	#hasLynx() {
 		return typeof lynx !== "undefined" && typeof lynx.getJSModule === "function";
 	}
 	call(name, params = {}) {
-		if (!this.#hasNativeModules()) return Promise.resolve(void 0);
-		return new Promise((resolve) => {
-			NativeModules.bridge.call(name, params, (...args) => {
-				resolve(args[0]);
-			});
-		});
+		if (isMainThread() && typeof lynx === "undefined") return Promise.resolve(void 0);
+		return callOnBackground("nativeBridgeCall", name, params);
 	}
 	on(name, callback) {
-		if (!this.#hasNativeModules()) return;
-		NativeModules.bridge.on(name, callback);
+		callOnBackground("nativeBridgeOn", name, relayFunctions(callback)).catch(() => {});
 	}
 	getNativeModule(name) {
-		if (typeof NativeModules === "undefined" || NativeModules == null) return;
+		if (isMainThread()) return typeof lynx !== "undefined" ? relayedModule("native", name) : void 0;
+		if (!this.#hasNativeModules()) return;
 		return NativeModules[name];
 	}
 	getJSModule(name) {
+		if (isMainThread()) return typeof lynx !== "undefined" ? relayedModule("js", name) : void 0;
 		if (!this.#hasLynx()) return;
 		return lynx.getJSModule(name);
 	}
 	registerJSModule(name, module) {
-		if (!this.#hasLynx()) return;
-		lynx.registerModule(name, module);
+		if (typeof lynx === "undefined") return;
+		callOnBackground("registerJSModule", name, relayModuleObject(module)).catch(() => {});
 	}
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
@@ -2979,10 +3677,67 @@ i0.ɵɵngDeclareClassMetadata({
 		args: [{ providedIn: "root" }]
 	}]
 });
+const __workletMap = {};
+const __mainThreadRefMap = {};
+const __pendingResolvers = {};
+let __nextResolveId = 0;
+const nextResolveId = () => __nextResolveId++;
+const transform = (value, elements) => {
+	if (typeof value !== "object" || value === null) return value;
+	if (Array.isArray(value)) return value.map((item) => transform(item, elements));
+	const obj = value;
+	if (elements && "elementRefptr" in obj) return new MainThreadElement(obj["elementRefptr"]);
+	if ("_wvid" in obj) return __mainThreadRefMap[obj["_wvid"]] ?? obj;
+	const result = {};
+	for (const key of Object.keys(obj)) result[key] = transform(obj[key], elements);
+	return result;
+};
+const transformParams = (value) => transform(value, true);
+const restoreRefs = (value) => transform(value, false);
+const isThenable = (value) => typeof value?.then === "function";
+const errorText = (e) => e instanceof Error ? e.message : String(e);
+const answerCall = (resolveId, run, send) => {
+	const reply = (result) => {
+		let data;
+		try {
+			data = JSON.stringify({
+				resolveId,
+				...result
+			});
+		} catch (e) {
+			data = JSON.stringify({
+				resolveId,
+				error: `[angular-lynx] The return value can't be sent to the other thread: ${errorText(e)}`
+			});
+		}
+		send(data);
+	};
+	let returnValue;
+	try {
+		returnValue = run();
+	} catch (e) {
+		reply({ error: errorText(e) });
+		return;
+	}
+	if (isThenable(returnValue)) returnValue.then((value) => reply({ returnValue: value }), (e) => reply({ error: errorText(e) }));
+	else reply({ returnValue });
+};
 let nextWorkletId = 0;
+const constructorDestroyRef = () => {
+	try {
+		return inject(DestroyRef);
+	} catch {
+		return null;
+	}
+};
 const mainThreadFn = (fn) => {
 	const id = "__angular_mts_" + nextWorkletId++;
-	if (__MAIN_THREAD__) globalThis.registerWorklet("main-thread", id, fn);
+	if (__MAIN_THREAD__) {
+		globalThis.registerWorklet("main-thread", id, fn);
+		constructorDestroyRef()?.onDestroy(() => {
+			delete __workletMap[id];
+		});
+	}
 	return {
 		_wkltId: id,
 		_workletType: "main-thread",
@@ -2990,11 +3745,11 @@ const mainThreadFn = (fn) => {
 	};
 };
 let nextBgWorkletId = 0;
-const backgroundFn = (fn) => {
-	const id = "__angular_bg_" + nextBgWorkletId++;
-	if (!__MAIN_THREAD__) globalThis.registerWorklet("background", id, fn);
+const backgroundFn = (fn, id) => {
+	const workletId = id ?? "__angular_bg_" + nextBgWorkletId++;
+	if (!__MAIN_THREAD__) globalThis.registerWorklet("background", workletId, fn);
 	return {
-		_wkltId: id,
+		_wkltId: workletId,
 		_workletType: "background",
 		__isBackgroundFn: true
 	};
@@ -3003,10 +3758,10 @@ let nextRefId = 0;
 var MainThreadRef = class {
 	_wvid;
 	#_value;
-	constructor(initValue) {
-		this._wvid = nextRefId++;
+	constructor(initValue, id) {
+		this._wvid = id ?? nextRefId++;
 		this.#_value = initValue;
-		if (__MAIN_THREAD__) globalThis.__workletRefMap[this._wvid] = this;
+		__mainThreadRefMap[this._wvid] = this;
 	}
 	get current() {
 		return this.#_value;
@@ -3018,82 +3773,7 @@ var MainThreadRef = class {
 		return { _wvid: this._wvid };
 	}
 };
-const createMainThreadRef = (initValue) => new MainThreadRef(initValue);
-let willFlush = false;
-const scheduleFlush = () => {
-	if (willFlush) return;
-	willFlush = true;
-	Promise.resolve().then(() => {
-		willFlush = false;
-		__FlushElementTree();
-	});
-};
-var MainThreadElement = class MainThreadElement {
-	#element;
-	constructor(element) {
-		this.#element = element;
-	}
-	setAttribute(name, value) {
-		__SetAttribute(this.#element, name, value);
-		scheduleFlush();
-	}
-	getAttribute(name) {
-		return __GetAttributeByName(this.#element, name);
-	}
-	getAttributeNames() {
-		return __GetAttributeNames(this.#element);
-	}
-	setStyleProperty(name, value) {
-		__AddInlineStyle(this.#element, name, value);
-		scheduleFlush();
-	}
-	setStyleProperties(styles) {
-		for (const key in styles) __AddInlineStyle(this.#element, key, styles[key]);
-		scheduleFlush();
-	}
-	querySelector(selector) {
-		const ref = __QuerySelector(this.#element, selector, {});
-		return ref ? new MainThreadElement(ref) : null;
-	}
-	querySelectorAll(selector) {
-		return __QuerySelectorAll(this.#element, selector, {}).map((el) => new MainThreadElement(el));
-	}
-	invoke(methodName, params) {
-		return new Promise((resolve, reject) => {
-			__InvokeUIMethod(this.#element, methodName, params ?? {}, (res) => {
-				if (res.code === 0) resolve(res.data);
-				else reject(/* @__PURE__ */ new Error("UI method invoke: " + JSON.stringify(res)));
-			});
-			scheduleFlush();
-		});
-	}
-	animate(keyframes, options) {
-		const normalizedOptions = typeof options === "number" ? { duration: options } : options ?? {};
-		return new LynxAnimation(this.#element, keyframes, normalizedOptions);
-	}
-	getBoundingClientRect() {
-		if (typeof __GetComputedStyleByKey !== "function") return {
-			left: 0,
-			top: 0,
-			right: 0,
-			bottom: 0,
-			width: 0,
-			height: 0
-		};
-		const width = parseFloat(__GetComputedStyleByKey(this.#element, "width")) || 0;
-		const height = parseFloat(__GetComputedStyleByKey(this.#element, "height")) || 0;
-		const left = parseFloat(__GetComputedStyleByKey(this.#element, "left")) || 0;
-		const top = parseFloat(__GetComputedStyleByKey(this.#element, "top")) || 0;
-		return {
-			left,
-			top,
-			right: left + width,
-			bottom: top + height,
-			width,
-			height
-		};
-	}
-};
+const createMainThreadRef = (initValue, id) => new MainThreadRef(initValue, id);
 const INPUT_TO_EVENT = {
 	mainThreadBindtap: ["bindEvent", "tap"],
 	mainThreadCatchtap: ["catchEvent", "tap"],
@@ -3103,6 +3783,12 @@ const INPUT_TO_EVENT = {
 	mainThreadCatchtouchmove: ["catchEvent", "touchmove"],
 	mainThreadBindtouchend: ["bindEvent", "touchend"],
 	mainThreadCatchtouchend: ["catchEvent", "touchend"],
+	mainThreadBindmousedown: ["bindEvent", "mousedown"],
+	mainThreadCatchmousedown: ["catchEvent", "mousedown"],
+	mainThreadBindmousemove: ["bindEvent", "mousemove"],
+	mainThreadCatchmousemove: ["catchEvent", "mousemove"],
+	mainThreadBindmouseup: ["bindEvent", "mouseup"],
+	mainThreadCatchmouseup: ["catchEvent", "mouseup"],
 	mainThreadBindlongpress: ["bindEvent", "longpress"],
 	mainThreadCatchlongpress: ["catchEvent", "longpress"],
 	mainThreadBindscroll: ["bindEvent", "scroll"],
@@ -3113,9 +3799,14 @@ const INPUT_TO_EVENT = {
 	mainThreadBindlayoutchange: ["bindEvent", "layoutchange"]
 };
 const isMainThreadHandle = (h) => !!h && "__isMainThreadFn" in h && !!h.__isMainThreadFn;
+let nextHandlerId = 0;
+const noHandler = () => ({
+	type: "worklet",
+	value: { _workletType: "main-thread" }
+});
 var LynxMainThreadEvent = class LynxMainThreadEvent {
 	#el = inject(ElementRef).nativeElement;
-	#registeredEvents = [];
+	#registrations = /* @__PURE__ */ new Map();
 	mainThreadBindtap;
 	mainThreadCatchtap;
 	mainThreadBindtouchstart;
@@ -3124,6 +3815,12 @@ var LynxMainThreadEvent = class LynxMainThreadEvent {
 	mainThreadCatchtouchmove;
 	mainThreadBindtouchend;
 	mainThreadCatchtouchend;
+	mainThreadBindmousedown;
+	mainThreadCatchmousedown;
+	mainThreadBindmousemove;
+	mainThreadCatchmousemove;
+	mainThreadBindmouseup;
+	mainThreadCatchmouseup;
 	mainThreadBindlongpress;
 	mainThreadCatchlongpress;
 	mainThreadBindscroll;
@@ -3140,23 +3837,44 @@ var LynxMainThreadEvent = class LynxMainThreadEvent {
 			if (!mapping) continue;
 			const [eventType, eventName] = mapping;
 			const handle = this[inputName];
-			if (isMainThreadHandle(handle)) {
-				__AddEvent(elementRef, eventType, eventName, {
-					type: "worklet",
-					value: {
-						_wkltId: handle._wkltId,
-						_workletType: "main-thread"
-					}
-				});
-				this.#registeredEvents.push([eventType, eventName]);
+			this.#release(inputName);
+			const registration = {
+				eventType,
+				eventName
+			};
+			let workletId;
+			if (isMainThreadHandle(handle)) workletId = handle._wkltId;
+			else if (typeof handle === "function") {
+				workletId = "__angular_mts_handler_" + nextHandlerId++;
+				registration.ownId = workletId;
+				__workletMap[workletId] = handle;
+			}
+			if (workletId === void 0) {
+				if (this.#registrations.delete(inputName)) __AddEvent(elementRef, eventType, eventName, noHandler());
+				continue;
 			}
+			__AddEvent(elementRef, eventType, eventName, {
+				type: "worklet",
+				value: {
+					_wkltId: workletId,
+					_workletType: "main-thread"
+				}
+			});
+			this.#registrations.set(inputName, registration);
 		}
 	}
 	ngOnDestroy() {
 		const elementRef = this.#el.element;
 		if (!elementRef) return;
-		for (const [eventType, eventName] of this.#registeredEvents) __AddEvent(elementRef, eventType, eventName, void 0);
-		this.#registeredEvents = [];
+		for (const [inputName, { eventType, eventName }] of this.#registrations) {
+			__AddEvent(elementRef, eventType, eventName, noHandler());
+			this.#release(inputName);
+		}
+		this.#registrations.clear();
+	}
+	#release(inputName) {
+		const ownId = this.#registrations.get(inputName)?.ownId;
+		if (ownId !== void 0) delete __workletMap[ownId];
 	}
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
@@ -3171,7 +3889,7 @@ var LynxMainThreadEvent = class LynxMainThreadEvent {
 		version: "22.2.1",
 		type: LynxMainThreadEvent,
 		isStandalone: true,
-		selector: "[mainThreadBindtap],[mainThreadCatchtap],[mainThreadBindtouchstart],[mainThreadCatchtouchstart],[mainThreadBindtouchmove],[mainThreadCatchtouchmove],[mainThreadBindtouchend],[mainThreadCatchtouchend],[mainThreadBindlongpress],[mainThreadCatchlongpress],[mainThreadBindscroll],[mainThreadCatchscroll],[mainThreadBindanimationstart],[mainThreadBindanimationend],[mainThreadBindtransitionend],[mainThreadBindlayoutchange]",
+		selector: "[mainThreadBindtap],[mainThreadCatchtap],[mainThreadBindtouchstart],[mainThreadCatchtouchstart],[mainThreadBindtouchmove],[mainThreadCatchtouchmove],[mainThreadBindtouchend],[mainThreadCatchtouchend],[mainThreadBindmousedown],[mainThreadCatchmousedown],[mainThreadBindmousemove],[mainThreadCatchmousemove],[mainThreadBindmouseup],[mainThreadCatchmouseup],[mainThreadBindlongpress],[mainThreadCatchlongpress],[mainThreadBindscroll],[mainThreadCatchscroll],[mainThreadBindanimationstart],[mainThreadBindanimationend],[mainThreadBindtransitionend],[mainThreadBindlayoutchange]",
 		inputs: {
 			mainThreadBindtap: "mainThreadBindtap",
 			mainThreadCatchtap: "mainThreadCatchtap",
@@ -3181,6 +3899,12 @@ var LynxMainThreadEvent = class LynxMainThreadEvent {
 			mainThreadCatchtouchmove: "mainThreadCatchtouchmove",
 			mainThreadBindtouchend: "mainThreadBindtouchend",
 			mainThreadCatchtouchend: "mainThreadCatchtouchend",
+			mainThreadBindmousedown: "mainThreadBindmousedown",
+			mainThreadCatchmousedown: "mainThreadCatchmousedown",
+			mainThreadBindmousemove: "mainThreadBindmousemove",
+			mainThreadCatchmousemove: "mainThreadCatchmousemove",
+			mainThreadBindmouseup: "mainThreadBindmouseup",
+			mainThreadCatchmouseup: "mainThreadCatchmouseup",
 			mainThreadBindlongpress: "mainThreadBindlongpress",
 			mainThreadCatchlongpress: "mainThreadCatchlongpress",
 			mainThreadBindscroll: "mainThreadBindscroll",
@@ -3202,8 +3926,7 @@ i0.ɵɵngDeclareClassMetadata({
 	decorators: [{
 		type: Directive,
 		args: [{
-			selector: "[mainThreadBindtap],[mainThreadCatchtap],[mainThreadBindtouchstart],[mainThreadCatchtouchstart],[mainThreadBindtouchmove],[mainThreadCatchtouchmove],[mainThreadBindtouchend],[mainThreadCatchtouchend],[mainThreadBindlongpress],[mainThreadCatchlongpress],[mainThreadBindscroll],[mainThreadCatchscroll],[mainThreadBindanimationstart],[mainThreadBindanimationend],[mainThreadBindtransitionend],[mainThreadBindlayoutchange]",
-			standalone: true,
+			selector: "[mainThreadBindtap],[mainThreadCatchtap],[mainThreadBindtouchstart],[mainThreadCatchtouchstart],[mainThreadBindtouchmove],[mainThreadCatchtouchmove],[mainThreadBindtouchend],[mainThreadCatchtouchend],[mainThreadBindmousedown],[mainThreadCatchmousedown],[mainThreadBindmousemove],[mainThreadCatchmousemove],[mainThreadBindmouseup],[mainThreadCatchmouseup],[mainThreadBindlongpress],[mainThreadCatchlongpress],[mainThreadBindscroll],[mainThreadCatchscroll],[mainThreadBindanimationstart],[mainThreadBindanimationend],[mainThreadBindtransitionend],[mainThreadBindlayoutchange]",
 			inputs: [
 				"mainThreadBindtap",
 				"mainThreadCatchtap",
@@ -3213,6 +3936,12 @@ i0.ɵɵngDeclareClassMetadata({
 				"mainThreadCatchtouchmove",
 				"mainThreadBindtouchend",
 				"mainThreadCatchtouchend",
+				"mainThreadBindmousedown",
+				"mainThreadCatchmousedown",
+				"mainThreadBindmousemove",
+				"mainThreadCatchmousemove",
+				"mainThreadBindmouseup",
+				"mainThreadCatchmouseup",
 				"mainThreadBindlongpress",
 				"mainThreadCatchlongpress",
 				"mainThreadBindscroll",
@@ -3227,42 +3956,13 @@ i0.ɵɵngDeclareClassMetadata({
 });
 var LynxMainThread = class LynxMainThread {
 	runOnMainThread(handle, ...args) {
-		if (__MAIN_THREAD__) {
-			const invokeDirect = globalThis.__lynxRunMainThreadWorklet;
-			if (!invokeDirect) return Promise.reject(/* @__PURE__ */ new Error("[angular-lynx] runOnMainThread() called on the main thread before the runtime worklet registry was initialized"));
-			try {
-				return Promise.resolve(invokeDirect(handle._wkltId, args));
-			} catch (e) {
-				return Promise.reject(e);
-			}
-		}
-		/* v8 ignore next 9 */
-		if (__DEV__) try {
-			JSON.stringify(args);
-		} catch {
-			throw new Error("[angular-lynx] MTS arguments must be JSON-serializable");
+		const invokeDirect = globalThis.__lynxRunMainThreadWorklet;
+		if (!invokeDirect) return Promise.reject(/* @__PURE__ */ new Error("[angular-lynx] runOnMainThread() called before the runtime worklet registry was initialized"));
+		try {
+			return Promise.resolve(invokeDirect(handle._wkltId, args));
+		} catch (e) {
+			return Promise.reject(e);
 		}
-		const resolveId = globalThis.__lynxMtsNextResolveId();
-		const pendingResolvers = globalThis.__lynxMtsPendingResolvers;
-		return new Promise((resolve, reject) => {
-			pendingResolvers[resolveId] = {
-				resolve,
-				reject
-			};
-			try {
-				lynx.getCoreContext().dispatchEvent({
-					type: "Lynx.Worklet.runWorkletCtx",
-					data: JSON.stringify({
-						worklet: { _wkltId: handle._wkltId },
-						params: args,
-						resolveId
-					})
-				});
-			} catch (e) {
-				delete pendingResolvers[resolveId];
-				reject(e);
-			}
-		});
 	}
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
@@ -3292,18 +3992,10 @@ i0.ɵɵngDeclareClassMetadata({
 });
 var LynxResourcePrefetch = class LynxResourcePrefetch {
 	request(resources) {
-		if (typeof lynx === "undefined" || !lynx.requestResourcePrefetch) return Promise.reject(/* @__PURE__ */ new Error("lynx.requestResourcePrefetch is not available in this environment"));
-		const data = this.#toNativeData(resources);
-		return new Promise((resolve) => {
-			lynx.requestResourcePrefetch(data, resolve);
-		});
+		return callOnBackground("requestResourcePrefetch", this.#toNativeData(resources));
 	}
 	cancel(resources) {
-		if (typeof lynx === "undefined" || !lynx.cancelResourcePrefetch) return Promise.reject(/* @__PURE__ */ new Error("lynx.cancelResourcePrefetch is not available in this environment"));
-		const data = this.#toNativeData(resources);
-		return new Promise((resolve) => {
-			lynx.cancelResourcePrefetch(data, resolve);
-		});
+		return callOnBackground("cancelResourcePrefetch", this.#toNativeData(resources));
 	}
 	#toNativeData(resources) {
 		return { data: resources.map((r) => {
@@ -3349,11 +4041,21 @@ i0.ɵɵngDeclareClassMetadata({
 		args: [{ providedIn: "root" }]
 	}]
 });
+const hostOsVersion = () => {
+	const value = typeof lynx !== "undefined" ? lynx.__globalProps?.["osVersion"] : void 0;
+	return typeof value === "string" && value !== "" ? value : void 0;
+};
 var LynxSystemInfo = class LynxSystemInfo {
 	#info;
+	#osVersion = signal(void 0, ...ngDevMode ? [{ debugName: "#osVersion" }] : /* istanbul ignore next */ []);
 	constructor() {
-		if (typeof SystemInfo === "undefined") throw new Error("SystemInfo is not available in this environment");
-		this.#info = SystemInfo;
+		const info = (typeof lynx !== "undefined" ? lynx.SystemInfo : void 0) ?? (typeof SystemInfo !== "undefined" ? SystemInfo : void 0);
+		if (!info) throw new Error("SystemInfo is not available in this environment");
+		this.#info = info;
+		this.#osVersion.set(info.osVersion || hostOsVersion());
+		if (this.#osVersion() === void 0 && isMainThread()) callOnBackground("osVersion").then((version) => {
+			if (version) this.#osVersion.set(version);
+		}, () => {});
 	}
 	get platform() {
 		return this.#info.platform;
@@ -3362,7 +4064,7 @@ var LynxSystemInfo = class LynxSystemInfo {
 		return this.#info.engineVersion;
 	}
 	get osVersion() {
-		return this.#info.osVersion;
+		return this.#osVersion() ?? "";
 	}
 	get pixelWidth() {
 		return this.#info.pixelWidth;
@@ -3418,10 +4120,10 @@ const SAFE_AREA_INSET_LEFT = "env(safe-area-inset-left)";
 const SAFE_AREA_INSET_RIGHT = "env(safe-area-inset-right)";
 var LynxSafeArea = class LynxSafeArea {
 	#globalData = inject(LynxGlobalData);
-	#systemInfo = inject(LynxSystemInfo);
+	#injector = inject(Injector);
 	isNotchScreen = computed(() => !!this.#globalData.globalData()["isNotchScreen"], ...ngDevMode ? [{ debugName: "isNotchScreen" }] : /* istanbul ignore next */ []);
 	get platform() {
-		return this.#systemInfo.platform;
+		return this.#injector.get(LynxSystemInfo).platform;
 	}
 	static ɵfac = i0.ɵɵngDeclareFactory({
 		minVersion: "12.0.0",
@@ -3453,11 +4155,18 @@ var LynxSessionStorage = class LynxSessionStorage {
 	#store = /* @__PURE__ */ new Map();
 	#listeners = /* @__PURE__ */ new Map();
 	#nextId = 0;
+	#relayIds = /* @__PURE__ */ new Map();
 	#hasNativeSessionStorage() {
-		return typeof lynx !== "undefined" && typeof lynx.setSessionStorageItem === "function";
+		return typeof lynx !== "undefined" && typeof lynx.setSessionStorageItem === "function" && !(typeof SystemInfo !== "undefined" && SystemInfo.platform === "web");
 	}
 	#hasNativeSubscription() {
-		return this.#hasNativeSessionStorage() && !(typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__);
+		return this.#hasNativeSessionStorage() && !this.#isMainThread();
+	}
+	#isMainThread() {
+		return typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__;
+	}
+	#unwrap(raw) {
+		return raw != null && typeof raw === "object" && "__data" in raw && Object.keys(raw).length === 1 ? raw.__data : raw;
 	}
 	#notifyLocalListeners(key, value) {
 		const keyListeners = this.#listeners.get(key);
@@ -3465,7 +4174,7 @@ var LynxSessionStorage = class LynxSessionStorage {
 	}
 	setItem(key, value) {
 		if (this.#hasNativeSessionStorage()) {
-			if (typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__) {
+			if (this.#isMainThread()) {
 				const wrapped = typeof value === "object" && value !== null ? value : { __data: value };
 				lynx.setSessionStorageItem(key, wrapped);
 				this.#notifyLocalListeners(key, value);
@@ -3479,13 +4188,9 @@ var LynxSessionStorage = class LynxSessionStorage {
 	}
 	getItem(key) {
 		if (this.#hasNativeSessionStorage()) {
-			if (typeof __MAIN_THREAD__ !== "undefined" && __MAIN_THREAD__) {
-				const raw = lynx.getSessionStorageItem(key);
-				const unwrapped = raw != null && typeof raw === "object" && "__data" in raw && Object.keys(raw).length === 1 ? raw.__data : raw;
-				return Promise.resolve(unwrapped);
-			}
+			if (this.#isMainThread()) return Promise.resolve(this.#unwrap(lynx.getSessionStorageItem(key)));
 			return new Promise((resolve) => {
-				lynx.getSessionStorageItem(key, (value) => resolve(value));
+				lynx.getSessionStorageItem(key, (value) => resolve(this.#unwrap(value)));
 			});
 		}
 		return Promise.resolve(this.#store.get(key));
@@ -3493,7 +4198,7 @@ var LynxSessionStorage = class LynxSessionStorage {
 	subscribe(key, callback) {
 		if (this.#hasNativeSubscription()) return {
 			key,
-			listenerId: lynx.subscribeSessionStorage(key, callback)
+			listenerId: lynx.subscribeSessionStorage(key, (value) => callback(this.#unwrap(value)))
 		};
 		const id = this.#nextId++;
 		let keyListeners = this.#listeners.get(key);
@@ -3502,6 +4207,7 @@ var LynxSessionStorage = class LynxSessionStorage {
 			this.#listeners.set(key, keyListeners);
 		}
 		keyListeners.set(id, callback);
+		if (this.#isMainThread() && this.#hasNativeSessionStorage()) this.#relayIds.set(id, subscribeSessionStorageFromMainThread(key, (value) => callback(this.#unwrap(value))));
 		return {
 			key,
 			listenerId: id
@@ -3513,6 +4219,11 @@ var LynxSessionStorage = class LynxSessionStorage {
 			return;
 		}
 		this.#listeners.get(subscription.key)?.delete(subscription.listenerId);
+		const relayId = this.#relayIds.get(subscription.listenerId);
+		if (relayId !== void 0) {
+			this.#relayIds.delete(subscription.listenerId);
+			unsubscribeSessionStorageFromMainThread(relayId);
+		}
 	}
 	watch(key, options) {
 		const value = signal(void 0, ...ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []);
@@ -3549,7 +4260,7 @@ i0.ɵɵngDeclareClassMetadata({
 });
 var LynxTextMeasure = class LynxTextMeasure {
 	measure(text, options) {
-		if (typeof lynx === "undefined") throw new Error("lynx.getTextInfo is not available in this environment");
+		if (typeof lynx === "undefined" || typeof lynx.getTextInfo !== "function") throw new Error("lynx.getTextInfo is not available in this environment");
 		if (!text) return { width: 0 };
 		return lynx.getTextInfo(text, options);
 	}
@@ -3726,7 +4437,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Component,
 		args: [{
 			selector: "lynx-transition",
-			standalone: true,
 			template: `@if (shouldRender()) {
     <ng-content />
   }`
@@ -4003,7 +4713,6 @@ i0.ɵɵngDeclareClassMetadata({
 		type: Component,
 		args: [{
 			selector: "lynx-transition-group",
-			standalone: true,
 			template: `<ng-template #anchor />`
 		}]
 	}],
@@ -4062,186 +4771,18 @@ i0.ɵɵngDeclareClassMetadata({
 		}]
 	}
 });
-var NoopLynxAnimation = class NoopLynxAnimation {
-	static #count = 0;
-	id;
-	constructor() {
-		this.id = `__lynx-angular-noop-animation-${NoopLynxAnimation.#count++}`;
-	}
-	play() {}
-	pause() {}
-	cancel() {}
-};
-var LynxBackgroundElement = class {
-	isRootPageElement = false;
-	tagName = "";
-	#props = /* @__PURE__ */ new Map();
-	#styles = /* @__PURE__ */ new Map();
-	#classes = /* @__PURE__ */ new Set();
-	#events = /* @__PURE__ */ new Map();
-	#parent = null;
-	#firstChild = null;
-	#lastChild = null;
-	#previousSibling = null;
-	#nextSibling = null;
-	setProperty(name, value) {
-		this.#props.set(name, value);
-	}
-	setAttribute(name, value) {
-		this.#props.set(name, value);
-	}
-	getAttribute(name) {
-		return this.#props.get(name) ?? null;
-	}
-	removeAttribute(name) {
-		this.#props.delete(name);
-	}
-	setStyle(key, value) {
-		this.#styles.set(key, value);
-	}
-	removeStyle(key) {
-		this.#styles.delete(key);
-	}
-	setInlineStyles(inlineStyle) {
-		const styles = inlineStyle.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
-		for (const s of styles) {
-			const [key, value] = s.split(":").map((s) => s.trim());
-			this.setStyle(key, value);
-		}
-	}
-	insertBefore(newChild, refChild) {
-		if (newChild.isRootPageElement) return;
-		if (refChild == null) {
-			this.appendChild(newChild);
-			return;
-		}
-		if (!refChild.#previousSibling) this.#firstChild = newChild;
-		else refChild.#previousSibling.#nextSibling = newChild;
-		newChild.#previousSibling = refChild.#previousSibling;
-		refChild.#previousSibling = newChild;
-		newChild.#nextSibling = refChild;
-		newChild.#parent = this;
-	}
-	appendChild(newChild) {
-		if (newChild.isRootPageElement) return;
-		if (!this.#firstChild) {
-			this.#firstChild = newChild;
-			this.#lastChild = newChild;
-		} else {
-			/* v8 ignore next 5 */
-			if (!this.#lastChild) throw new Error("Invariant violation: lastChild is null while firstChild is not null.");
-			this.#lastChild.#nextSibling = newChild;
-			newChild.#previousSibling = this.#lastChild;
-			this.#lastChild = newChild;
-		}
-		newChild.#parent = this;
-	}
-	addClass(name) {
-		this.#classes.add(name);
-	}
-	removeClass(name) {
-		this.#classes.delete(name);
-	}
-	remove() {
-		if (this.isRootPageElement) return;
-		if (!this.#parent) return;
-		if (this.#previousSibling) this.#previousSibling.#nextSibling = this.#nextSibling;
-		else this.#parent.#firstChild = this.#nextSibling;
-		if (this.#nextSibling) this.#nextSibling.#previousSibling = this.#previousSibling;
-		else this.#parent.#lastChild = this.#previousSibling;
-		this.#nextSibling = null;
-		this.#previousSibling = null;
-		this.#parent = null;
-	}
-	parentNode() {
-		return this.#parent;
-	}
-	nextSibling() {
-		return this.#nextSibling;
-	}
-	querySelector(selector) {
-		let child = this.#firstChild;
-		while (child) {
-			if (child.#matchesSelector(selector)) return child;
-			const found = child.querySelector(selector);
-			if (found) return found;
-			child = child.#nextSibling;
-		}
-		return null;
-	}
-	querySelectorAll(selector) {
-		const results = [];
-		this.#collectMatches(selector, results);
-		return results;
-	}
-	#collectMatches(selector, results) {
-		let child = this.#firstChild;
-		while (child) {
-			if (child.#matchesSelector(selector)) results.push(child);
-			child.#collectMatches(selector, results);
-			child = child.#nextSibling;
-		}
-	}
-	#matchesSelector(selector) {
-		let remaining = selector.trim();
-		if (/[\s>~+]/.test(remaining)) return false;
-		let tagName = null;
-		const classes = [];
-		const attrs = [];
-		const tagMatch = remaining.match(/^([a-zA-Z][a-zA-Z0-9_-]*)/);
-		if (tagMatch) {
-			tagName = tagMatch[1];
-			remaining = remaining.slice(tagMatch[0].length);
-		}
-		while (remaining.length > 0) {
-			const classMatch = remaining.match(/^\.([a-zA-Z0-9_-]+)/);
-			if (classMatch) {
-				classes.push(classMatch[1]);
-				remaining = remaining.slice(classMatch[0].length);
-				continue;
-			}
-			const idMatch = remaining.match(/^#([a-zA-Z0-9_-]+)/);
-			if (idMatch) {
-				attrs.push(["id", idMatch[1]]);
-				remaining = remaining.slice(idMatch[0].length);
-				continue;
-			}
-			const attrMatch = remaining.match(/^\[([a-zA-Z0-9_-]+)(?:=["']?([^"'\]]*)["']?)?\]/);
-			if (attrMatch) {
-				attrs.push([attrMatch[1], attrMatch[2] ?? null]);
-				remaining = remaining.slice(attrMatch[0].length);
-				continue;
-			}
-			return false;
-		}
-		if (!tagName && classes.length === 0 && attrs.length === 0) return false;
-		if (tagName && this.#props.get("tagName") !== tagName) return false;
-		for (const cls of classes) if (!this.#classes.has(cls)) return false;
-		for (const [attr, value] of attrs) {
-			const stored = this.#props.get(attr);
-			if (value === null) {
-				if (stored === void 0 || stored === null) return false;
-			} else if (String(stored) !== value) return false;
-		}
-		return true;
-	}
-	animate(_keyframes, _options) {
-		/* v8 ignore next 6 -- build-time __DEV__ define is false in vitest, so the guarded warn is dead code from the test bundle's point of view. */
-		if (__DEV__) console.warn("[angular-lynx] animate() called on background thread — animation will not play. Use a main-thread script for imperative animations.");
-		return new NoopLynxAnimation();
-	}
-	addEventListener(name, cb) {
-		this.#events.set(name, cb);
-		return () => {
-			this.#events.delete(name);
-		};
-	}
-};
 const createBlockElement = (pageId) => {
 	return __CreateWrapperElement(pageId);
 };
+const ANDROID_BLUR_CAPTURE_TARGET = "angular-lynx-page";
+const isAndroid = () => {
+	return ((typeof lynx !== "undefined" ? lynx.SystemInfo : void 0) ?? (typeof SystemInfo !== "undefined" ? SystemInfo : void 0))?.platform === "Android";
+};
 const createBlurViewElement = (pageId) => {
-	return __CreateElement("blur-view", pageId);
+	const element = __CreateElement("blur-view", pageId);
+	if (!__WEB__ && isAndroid()) __SetAttribute(element, "android-capture-target", ANDROID_BLUR_CAPTURE_TARGET);
+	if (__WEB__ && __MAIN_THREAD__) import("./blotch-angular-lynx-web-glass-ciDHw7Bw.mjs").then(({ attachWebGlass }) => attachWebGlass(element)).catch(() => {});
+	return element;
 };
 const createCommentElement = (pageId) => {
 	const element = __CreateView(pageId);
@@ -4265,22 +4806,13 @@ const createIfElement = (pageId) => {
 	return __CreateElement("if", pageId);
 };
 const createImageElement = (pageId) => {
-	const element = __CreateImage(pageId);
-	__SetConfig(element, {
-		mode: "aspectFit",
-		fadeIn: true,
-		loadingPlaceholder: ""
-	});
-	return element;
+	return __CreateImage(pageId);
 };
 const createInlineTruncationElement = (pageId) => {
 	return __CreateElement("inline-truncation", pageId);
 };
 const createInputElement = (tag, pageId) => {
-	const element = __CreateElement(tag, pageId);
-	__AddInlineStyle(element, "height", tag === "textarea" ? "80px" : "40px");
-	__AddInlineStyle(element, "border", "1px solid");
-	return element;
+	return __CreateElement(tag, pageId);
 };
 const createListItemElement = (pageId) => {
 	return __CreateElement("list-item", pageId);
@@ -4374,11 +4906,51 @@ const createNativeRefByTag = (tag, pageId, text) => {
 		default: return createDefaultElement(tag, pageId);
 	}
 };
+const BLUR_BACKGROUND_VARIABLE = "--angular-lynx-blur-background";
+const BLUR_BACKGROUND_IMAGE_VARIABLE = "--angular-lynx-blur-background-image";
+const BLUR_BOX_SHADOW_VARIABLE = "--angular-lynx-blur-box-shadow";
+const BLUR_MATERIAL_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"blur-effect",
+	"blur-radius",
+	"glass-style",
+	"glass-tint-color"
+]);
+const MATERIAL_BACKGROUNDS = {
+	light: "rgba(255, 255, 255, 0.3)",
+	"extra-light": "rgba(255, 255, 255, 0.75)",
+	dark: "rgba(0, 0, 0, 0.6)"
+};
+const GLASS_SHEEN = "rgba(255, 255, 255, 0.3)";
+const CLEAR_GLASS_SHEEN = "rgba(255, 255, 255, 0.1)";
+const GLASS_RIM = "inset 0 1px 0 rgba(255, 255, 255, 0.5), inset 0 0 0 1px rgba(0, 0, 0, 0.12)";
+const usesAndroidBlurMaterials = () => !__WEB__ && isAndroid();
+const declarations = (background, { image = "none", boxShadow = "none" } = {}) => `${BLUR_BACKGROUND_VARIABLE}: ${background}; ${BLUR_BACKGROUND_IMAGE_VARIABLE}: ${image}; ${BLUR_BOX_SHADOW_VARIABLE}: ${boxShadow}`;
+const androidBlurMaterialStyle = (attrs) => {
+	const effect = attrs.get("blur-effect") ?? "light";
+	if (effect === "glass") {
+		const tint = attrs.get("glass-tint-color");
+		return declarations(attrs.get("glass-style") === "clear" ? CLEAR_GLASS_SHEEN : GLASS_SHEEN, {
+			image: typeof tint === "string" && tint !== "" && tint !== "transparent" ? `linear-gradient(${tint}, ${tint})` : "none",
+			boxShadow: GLASS_RIM
+		});
+	}
+	if (effect === "glass-container" || !parseFloat(String(attrs.get("blur-radius") ?? ""))) return declarations("transparent");
+	return declarations(MATERIAL_BACKGROUNDS[String(effect)] ?? MATERIAL_BACKGROUNDS["light"]);
+};
 let __pageElementRef = null;
 const setPageElementRef = (ref) => {
 	__pageElementRef = ref;
 };
 const getPageId = () => __pageElementRef ? __GetElementUniqueID(__pageElementRef) : 0;
+let handingOverPage = false;
+const handOverPageToNextApp = () => {
+	handingOverPage = true;
+};
+const takePageHandOver = () => {
+	const handing = handingOverPage;
+	handingOverPage = false;
+	return handing;
+};
 let firstRenderPending = true;
 const deferredCallbacks = [];
 const isFirstRenderPending = () => firstRenderPending;
@@ -4402,6 +4974,79 @@ const setInsideChangeDetection = (value) => {
 	insideChangeDetection = value;
 };
 const isInsideChangeDetection = () => insideChangeDetection;
+const DASHARRAY_ATTRIBUTE = /(\s)stroke-dasharray\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+const DASHARRAY_DECLARATION = /(^|[;"'\s])stroke-dasharray\s*:\s*([^;"']*);?/g;
+const DASH_LENGTH = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?(?:px)?$/i;
+const normalizeDashArray = (value) => {
+	const tokens = value.trim().split(/[\s,]+/).filter((token) => token.length > 0);
+	if (tokens.length === 0 || !tokens.every((t) => DASH_LENGTH.test(t))) return null;
+	return tokens.map((token) => token.replace(/px$/i, "")).join(" ");
+};
+const sanitizeSvgContent = (content) => {
+	if (!content.includes("stroke-dasharray")) return content;
+	return content.replace(DASHARRAY_ATTRIBUTE, (_match, space, double, single) => {
+		const normalized = normalizeDashArray(double ?? single);
+		return normalized === null ? "" : `${space}stroke-dasharray="${normalized}"`;
+	}).replace(DASHARRAY_DECLARATION, (_match, before, value) => {
+		const normalized = normalizeDashArray(value);
+		return normalized === null ? before : `${before}stroke-dasharray:${normalized};`;
+	});
+};
+const LONG_PRESS_SLOP = 10;
+const TAP_GRACE = 300;
+let tapsDropped = false;
+let longPresses = 0;
+const dropsTap = () => tapsDropped;
+const pointOf = (event) => {
+	const { x = 0, y = 0 } = typeof event.detail === "object" && event.detail !== null ? event.detail : event;
+	return {
+		x,
+		y
+	};
+};
+var WebLongPress = class {
+	#fire;
+	#timer;
+	#start = null;
+	#fired = false;
+	constructor(fire) {
+		this.#fire = fire;
+	}
+	start = (event) => {
+		if (event.button !== void 0 && event.button !== 0) return;
+		this.#stop();
+		this.#fired = false;
+		const point = pointOf(event);
+		this.#start = point;
+		this.#timer = setTimeout(() => {
+			this.#timer = void 0;
+			this.#fired = true;
+			longPresses++;
+			tapsDropped = true;
+			this.#fire(point);
+		}, 500);
+	};
+	move = (event) => {
+		if (!this.#start) return;
+		const { x, y } = pointOf(event);
+		if (Math.hypot(x - this.#start.x, y - this.#start.y) > LONG_PRESS_SLOP) this.#stop();
+	};
+	end = () => {
+		this.#stop();
+		this.#start = null;
+		if (this.#fired) {
+			this.#fired = false;
+			const longPress = longPresses;
+			setTimeout(() => {
+				if (longPress === longPresses) tapsDropped = false;
+			}, TAP_GRACE);
+		}
+	};
+	#stop() {
+		if (this.#timer !== void 0) clearTimeout(this.#timer);
+		this.#timer = void 0;
+	}
+};
 const EVENT_PREFIXES = [
 	["capture-bind", "capture-bindEvent"],
 	["capture-catch", "capture-catchEvent"],
@@ -4409,12 +5054,57 @@ const EVENT_PREFIXES = [
 	["catch", "catchEvent"],
 	["bind", "bindEvent"]
 ];
+const DOM_EVENT_ALIASES = /* @__PURE__ */ new Map([["click", "tap"]]);
 var _a;
+const nativeEventKey = (type, name) => type === "global-bindEvent" ? `global:${name}` : name;
+const combinedEventType = (listeners) => {
+	if (listeners[0].eventType === "global-bindEvent") return "global-bindEvent";
+	const capture = listeners.every((l) => l.eventType.startsWith("capture-"));
+	const stops = listeners.some((l) => l.eventType.endsWith("catchEvent"));
+	if (capture) return stops ? "capture-catchEvent" : "capture-bindEvent";
+	return stops ? "catchEvent" : "bindEvent";
+};
+const parseEventName = (name) => {
+	const alias = DOM_EVENT_ALIASES.get(name);
+	if (alias) return {
+		eventType: "bindEvent",
+		eventName: alias
+	};
+	for (const [prefix, eventType] of EVENT_PREFIXES) if (name.startsWith(prefix)) return {
+		eventType,
+		eventName: name.slice(prefix.length)
+	};
+};
+const withAddedTraits = (own, added) => {
+	if (added.length === 0 || isAndroid()) return own;
+	const traits = own == null ? [] : String(own).split(",").map((trait) => trait.trim()).filter((trait) => trait !== "" && trait !== "none");
+	for (const trait of added) if (!traits.includes(trait)) traits.push(trait);
+	return traits.join(",");
+};
 const wouldFormCycle = (parent, candidate) => {
 	const candidateId = __GetElementUniqueID(candidate);
 	for (let cur = parent; cur; cur = __GetParent(cur)) if (__GetElementUniqueID(cur) === candidateId) return true;
 	return false;
 };
+const ancestry = (element) => {
+	const path = [];
+	for (let cur = element; cur; cur = __GetParent(cur)) path.push(cur);
+	return path;
+};
+const flushesBefore = (first, second) => {
+	const firstPath = ancestry(first);
+	const secondPath = ancestry(second);
+	const secondDepth = new Map(secondPath.map((element, depth) => [__GetElementUniqueID(element), depth]));
+	for (let depth = 0; depth < firstPath.length; depth++) {
+		const shared = secondDepth.get(__GetElementUniqueID(firstPath[depth]));
+		if (shared === void 0) continue;
+		if (depth === 0) return true;
+		if (shared === 0) return false;
+		const order = __GetChildren(firstPath[depth]).map((child) => __GetElementUniqueID(child));
+		return order.indexOf(__GetElementUniqueID(firstPath[depth - 1])) < order.indexOf(__GetElementUniqueID(secondPath[shared - 1]));
+	}
+	return false;
+};
 const isTextish = (el) => el.tagName === "text" || el.tagName === "raw-text";
 var LynxElement = class {
 	#nativeRef;
@@ -4426,14 +5116,20 @@ var LynxElement = class {
 	_virtualParent = null;
 	_virtualPrev = null;
 	_virtualNext = null;
-	#activeAnimationIds = [];
+	#activeAnimations = [];
 	#attrs = /* @__PURE__ */ new Map();
 	#id = null;
 	#dataset = {};
 	#classes = "";
+	#scopeClasses = [];
 	#inlineStyleWhole = null;
 	#inlineStyleKeys = /* @__PURE__ */ new Map();
+	#runtimeStyle = "";
+	#ownTraits = null;
+	#addedTraits = [];
 	#listeners = [];
+	#webLongPress = null;
+	#nativeHandlers = /* @__PURE__ */ new Map();
 	#text;
 	#rawText;
 	#children = [];
@@ -4468,8 +5164,9 @@ var LynxElement = class {
 	}
 	setAttribute(name, value) {
 		if (name === "class") {
-			__SetClasses(this.element, value ?? "");
-			this.#classes = value ?? "";
+			const classes = [.../* @__PURE__ */ new Set([...String(value ?? "").split(/\s+/).filter(Boolean), ...this.#scopeClasses])].join(" ");
+			__SetClasses(this.element, classes);
+			this.#classes = classes;
 		} else if (name === "style") this.setInlineStyles(value);
 		else if (name === "id") {
 			__SetID(this.element, value);
@@ -4481,6 +5178,11 @@ var LynxElement = class {
 			__SetDataset(this.element, data);
 			this.#dataset[key] = value;
 		} else {
+			if (this.tagName === "svg" && name === "content" && typeof value === "string") value = sanitizeSvgContent(value);
+			if (name === "accessibility-traits") {
+				this.#ownTraits = value ?? null;
+				value = withAddedTraits(this.#ownTraits, this.#addedTraits);
+			}
 			__SetAttribute(this.element, name, value);
 			if (value == null) this.#attrs.delete(name);
 			else this.#attrs.set(name, value);
@@ -4490,8 +5192,17 @@ var LynxElement = class {
 				this.#rawText = text;
 				_a.#enqueueTextNormalization(this);
 			}
+			if (this.tagName === "blur-view" && BLUR_MATERIAL_ATTRIBUTES.has(name)) this.updateBlurMaterial();
 		}
 	}
+	updateBlurMaterial() {
+		if (usesAndroidBlurMaterials()) this.#setRuntimeStyle(androidBlurMaterialStyle(this.#attrs));
+	}
+	setAccessibilityTrait(trait, on) {
+		if (this.#addedTraits.includes(trait) === on) return;
+		this.#addedTraits = on ? [...this.#addedTraits, trait] : this.#addedTraits.filter((added) => added !== trait);
+		this.setAttribute("accessibility-traits", this.#ownTraits);
+	}
 	getAttribute(name) {
 		return __GetAttributeByName(this.element, name);
 	}
@@ -4507,12 +5218,23 @@ var LynxElement = class {
 		this.#inlineStyleKeys.delete(key);
 	}
 	setInlineStyles(inlineStyle) {
-		__SetInlineStyles(this.element, inlineStyle);
+		__SetInlineStyles(this.element, this.#withRuntimeStyle(inlineStyle));
 		this.#inlineStyleWhole = inlineStyle;
 	}
+	#withRuntimeStyle(inlineStyle) {
+		if (!this.#runtimeStyle) return inlineStyle;
+		return inlineStyle ? `${this.#runtimeStyle}; ${inlineStyle}` : this.#runtimeStyle;
+	}
+	#setRuntimeStyle(style) {
+		if (style === this.#runtimeStyle) return;
+		this.#runtimeStyle = style;
+		__SetInlineStyles(this.element, this.#withRuntimeStyle(this.#inlineStyleWhole));
+		for (const [key, value] of this.#inlineStyleKeys) __AddInlineStyle(this.element, key, value);
+	}
 	insertBefore(newChild, refChild) {
 		if (newChild.isRootPageElement) return;
 		newChild.#cancelPendingRemoval();
+		newChild.#removeIfMoveWouldBeLost(this);
 		newChild.#recreateIfDead();
 		if (refChild == null) this.appendChild(newChild);
 		else {
@@ -4525,6 +5247,7 @@ var LynxElement = class {
 	appendChild(newChild) {
 		if (newChild.isRootPageElement) return;
 		newChild.#cancelPendingRemoval();
+		newChild.#removeIfMoveWouldBeLost(this);
 		newChild.#recreateIfDead();
 		if (wouldFormCycle(this.element, newChild.element)) return;
 		__AppendElement(this.element, newChild.element);
@@ -4551,6 +5274,11 @@ var LynxElement = class {
 		set.add(name);
 		this.#classes = [...set].join(" ");
 	}
+	addScopeClass(name) {
+		if (this.#scopeClasses.includes(name)) return;
+		this.#scopeClasses.push(name);
+		this.addClass(name);
+	}
 	removeClass(name) {
 		const joined = __GetClasses(this.element).filter((c) => c !== name).join(" ");
 		__SetClasses(this.element, joined);
@@ -4623,14 +5351,20 @@ var LynxElement = class {
 	#cancelPendingRemoval() {
 		_a.#pendingRemovals.delete(this);
 	}
+	#removeIfMoveWouldBeLost(newParent) {
+		if (__WEB__ || this.#paintingDead || this._virtualParent) return;
+		const oldParent = __GetParent(this.element);
+		if (!oldParent || __GetElementUniqueID(oldParent) === __GetElementUniqueID(newParent.element)) return;
+		if (flushesBefore(newParent.element, oldParent)) this.#doRemove();
+	}
 	#doRemove() {
 		const parent = this.parentNode();
 		if (!parent) return;
-		for (const id of this.#activeAnimationIds) __ElementAnimate(this.element, [3, id]);
-		if (this.#activeAnimationIds.length > 0) {
+		for (const anim of this.#activeAnimations) anim.cancel();
+		if (this.#activeAnimations.length > 0) {
 			__AddInlineStyle(this.element, "opacity", null);
 			__AddInlineStyle(this.element, "transform", null);
-			this.#activeAnimationIds.length = 0;
+			this.#activeAnimations.length = 0;
 		}
 		__RemoveElement(parent.element, this.element);
 		const jsParent = this.#jsParent;
@@ -4665,11 +5399,12 @@ var LynxElement = class {
 		if (Object.keys(this.#dataset).length > 0) __SetDataset(fresh, this.#dataset);
 		for (const [name, value] of this.#attrs) __SetAttribute(fresh, name, value);
 		if (this.#classes) __SetClasses(fresh, this.#classes);
-		if (this.#inlineStyleWhole != null) __SetInlineStyles(fresh, this.#inlineStyleWhole);
+		const inlineStyle = this.#withRuntimeStyle(this.#inlineStyleWhole);
+		if (inlineStyle != null) __SetInlineStyles(fresh, inlineStyle);
 		for (const [key, value] of this.#inlineStyleKeys) __AddInlineStyle(fresh, key, value);
-		for (const { eventType, eventName, listener } of this.#listeners) __AddEvent(fresh, eventType, eventName, {
+		for (const { eventType, eventName, dispatch } of this.#nativeHandlers.values()) __AddEvent(fresh, eventType, eventName, {
 			type: "worklet",
-			value: listener
+			value: dispatch
 		});
 		for (const child of this.#children) {
 			child.#recreateSubtree();
@@ -4703,44 +5438,91 @@ var LynxElement = class {
 	animate(keyframes, options) {
 		const normalizedOptions = typeof options === "number" ? { duration: options } : options ?? {};
 		const anim = new LynxAnimation(this.element, keyframes, normalizedOptions);
-		this.#activeAnimationIds.push(anim.id);
+		this.#activeAnimations.push(anim);
 		return anim;
 	}
 	addEventListener(name, cb) {
-		let eventName = "";
-		let eventType;
-		for (const [prefix, type] of EVENT_PREFIXES) if (name.startsWith(prefix)) {
-			eventName = name.slice(prefix.length);
-			eventType = type;
-			break;
-		}
-		if (!eventType) return () => {};
-		const listener = (event) => {
-			if (event && typeof event === "object") {
-				if (typeof event.stopPropagation !== "function") event.stopPropagation = () => {};
-				if (typeof event.preventDefault !== "function") event.preventDefault = () => {};
-				if (typeof event.stopImmediatePropagation !== "function") event.stopImmediatePropagation = () => {};
-			}
-			const result = cb(event);
-			scheduleSettleFlush();
-			return result;
-		};
+		const parsed = parseEventName(name);
+		if (!parsed) return () => {};
+		if (__WEB__ && parsed.eventName === "longpress") this.#listenForWebLongPress();
 		const entry = {
+			...parsed,
+			listener: cb
+		};
+		this.#listeners.push(entry);
+		this.#syncNativeHandler(entry);
+		return () => this.#removeListener(entry);
+	}
+	removeEventListener(name, cb) {
+		const parsed = parseEventName(name);
+		if (!parsed) return;
+		const entry = this.#listeners.find((other) => other.listener === cb && other.eventType === parsed.eventType && other.eventName === parsed.eventName);
+		if (entry) this.#removeListener(entry);
+	}
+	#listenForWebLongPress() {
+		if (this.#webLongPress) return;
+		const press = new WebLongPress((detail) => {
+			const entry = this.#listeners.find((listener) => listener.eventName === "longpress");
+			if (entry) this.#dispatch(entry, {
+				type: "longpress",
+				detail
+			});
+		});
+		this.#webLongPress = press;
+		this.addEventListener("bindtouchstart", press.start);
+		this.addEventListener("bindmousedown", press.start);
+		this.addEventListener("bindtouchmove", press.move);
+		this.addEventListener("bindmousemove", press.move);
+		for (const end of [
+			"touchend",
+			"touchcancel",
+			"mouseup",
+			"mouseleave"
+		]) this.addEventListener(`bind${end}`, press.end);
+	}
+	#removeListener(entry) {
+		const i = this.#listeners.indexOf(entry);
+		if (i < 0) return;
+		this.#listeners.splice(i, 1);
+		this.#syncNativeHandler(entry);
+	}
+	#listenersLike(entry) {
+		const key = nativeEventKey(entry.eventType, entry.eventName);
+		return this.#listeners.filter((other) => nativeEventKey(other.eventType, other.eventName) === key);
+	}
+	#syncNativeHandler(entry) {
+		const key = nativeEventKey(entry.eventType, entry.eventName);
+		const listeners = this.#listenersLike(entry);
+		const current = this.#nativeHandlers.get(key);
+		const eventType = listeners.length ? combinedEventType(listeners) : null;
+		if (current?.eventType === eventType) return;
+		if (current) {
+			__AddEvent(this.element, current.eventType, entry.eventName, void 0);
+			this.#nativeHandlers.delete(key);
+		}
+		if (!eventType) return;
+		const handler = {
 			eventType,
-			eventName,
-			listener
+			eventName: entry.eventName,
+			dispatch: current?.dispatch ?? ((event) => this.#dispatch(entry, event))
 		};
-		this.#listeners.push(entry);
-		__AddEvent(this.element, eventType, eventName, {
+		this.#nativeHandlers.set(key, handler);
+		__AddEvent(this.element, eventType, entry.eventName, {
 			type: "worklet",
-			value: listener
+			value: handler.dispatch
 		});
-		return () => {
-			const i = this.#listeners.indexOf(entry);
-			/* v8 ignore next */
-			if (i >= 0) this.#listeners.splice(i, 1);
-			__AddEvent(this.element, eventType, eventName, void 0);
-		};
+	}
+	#dispatch(entry, event) {
+		if (event && typeof event === "object") {
+			if (typeof event.stopPropagation !== "function") event.stopPropagation = () => {};
+			if (typeof event.preventDefault !== "function") event.preventDefault = () => {};
+			if (typeof event.stopImmediatePropagation !== "function") event.stopImmediatePropagation = () => {};
+		}
+		if (__WEB__ && entry.eventName === "tap" && dropsTap()) return void 0;
+		let result;
+		for (const other of this.#listenersLike(entry)) if (this.#listeners.includes(other)) result = other.listener(event);
+		scheduleSettleFlush();
+		return result;
 	}
 };
 _a = LynxElement;
@@ -4893,42 +5675,6 @@ var LynxListElement = class extends LynxElement {
 		__FlushElementTree(void 0, { triggerLayout: true });
 	}
 };
-var LynxBackgroundDocument = class {
-	#page = null;
-	constructor() {}
-	createRootElement() {
-		const page = new LynxBackgroundElement();
-		page.tagName = "page";
-		page.setAttribute("tagName", "page");
-		page.isRootPageElement = true;
-		this.#page = page;
-		return this.#page;
-	}
-	createElement(tag, value) {
-		if (tag === "page") return this.#page;
-		const element = new LynxBackgroundElement();
-		element.tagName = tag;
-		element.setAttribute("tagName", tag);
-		if (value) element.setAttribute("textContent", value);
-		return element;
-	}
-	createText(value) {
-		const element = new LynxBackgroundElement();
-		element.tagName = "text";
-		element.setAttribute("tagName", "text");
-		element.setAttribute("textContent", value);
-		return element;
-	}
-	createComment() {
-		const element = new LynxBackgroundElement();
-		element.tagName = "comment";
-		element.setAttribute("tagName", "comment");
-		return element;
-	}
-	appendChild(newChild) {
-		this.#page?.appendChild(newChild);
-	}
-};
 const createListElement = (pageId) => {
 	let listEl;
 	const componentAtIndex = (listRef, listId, cellIndex, opId) => {
@@ -4985,16 +5731,23 @@ const createPageElement = (page, pageElementRequested) => {
 		pageElementRequested: true
 	};
 };
+const takeOverPage = () => {
+	const page = __pageElementRef;
+	if (!takePageHandOver() || !page) return null;
+	for (const child of __GetChildren(page) ?? []) __RemoveElement(page, child);
+	return page;
+};
 var LynxDocument = class {
 	page;
 	#pageId = 0;
 	#pageElementRequested = false;
 	constructor() {}
 	createRootElement() {
-		const pageElement = __CreatePage("0", 0);
+		const pageElement = takeOverPage() ?? __CreatePage("0", 0);
 		this.page = new LynxElement(pageElement);
 		this.page.tagName = "page";
 		this.page.isRootPageElement = true;
+		if (isAndroid()) __SetID(pageElement, ANDROID_BLUR_CAPTURE_TARGET);
 		this.#pageId = __GetElementUniqueID(pageElement);
 		setPageElementRef(pageElement);
 		return this.page;
@@ -5012,6 +5765,7 @@ var LynxDocument = class {
 		const el = new LynxElement(createNativeRefByTag(tag, this.#pageId, value));
 		el.tagName = tag;
 		if (tag === "raw-text") el.setInitialText(value ?? "");
+		if (tag === "blur-view") el.updateBlurMaterial();
 		return el;
 	}
 	createText(value) {
@@ -5164,14 +5918,24 @@ var LynxRenderer = class {
 	}
 };
 var EmulatedLynxRenderer = class extends LynxRenderer {
-	#componentScopeId;
+	#contentClass;
+	#hostClass;
 	constructor(document, componentId) {
 		super(document);
-		this.#componentScopeId = componentId;
+		this.#contentClass = `_ngcontent-${componentId}`;
+		this.#hostClass = `_nghost-${componentId}`;
+	}
+	applyToHost(element) {
+		element.addScopeClass(this.#hostClass);
+	}
+	createElement(name, namespace) {
+		const element = super.createElement(name, namespace);
+		element.addScopeClass(this.#contentClass);
+		return element;
 	}
 	selectRootElement() {
 		const el = super.selectRootElement();
-		el.addClass(`_nghost-${this.#componentScopeId}`);
+		this.applyToHost(el);
 		return el;
 	}
 };
@@ -5179,13 +5943,9 @@ var LynxRendererFactory2 = class LynxRendererFactory2 {
 	lynxDocument = inject(LYNX_DOCUMENT);
 	#defaultRenderer = null;
 	#emulatedRenderers = /* @__PURE__ */ new Map();
-	createRenderer(_hostElement, type) {
-		if (!type || type.encapsulation === ViewEncapsulation.None) {
-			if (!this.#defaultRenderer) this.#defaultRenderer = new LynxRenderer(this.lynxDocument);
-			return this.#defaultRenderer;
-		}
-		if (type.encapsulation === ViewEncapsulation.ShadowDom) {
-			console.warn("ViewEncapsulation.ShadowDom is not supported in Lynx. Falling back to no encapsulation.");
+	createRenderer(hostElement, type) {
+		if (!type || type.encapsulation !== ViewEncapsulation.Emulated) {
+			if (type && type.encapsulation !== ViewEncapsulation.None) console.warn("ViewEncapsulation.ShadowDom is not supported in Lynx. Falling back to no encapsulation.");
 			if (!this.#defaultRenderer) this.#defaultRenderer = new LynxRenderer(this.lynxDocument);
 			return this.#defaultRenderer;
 		}
@@ -5194,14 +5954,18 @@ var LynxRendererFactory2 = class LynxRendererFactory2 {
 			renderer = new EmulatedLynxRenderer(this.lynxDocument, type.id);
 			this.#emulatedRenderers.set(type.id, renderer);
 		}
+		if (hostElement) renderer.applyToHost(hostElement);
 		return renderer;
 	}
 	begin() {
 		setInsideChangeDetection(true);
+		/* v8 ignore start */
+		if (__PROFILE__) startCdTiming();
+		/* v8 ignore stop */
 	}
 	end() {
-		setInsideChangeDetection(false);
-		if (__MAIN_THREAD__) {
+		try {
+			setInsideChangeDetection(false);
 			/* v8 ignore start */
 			if (__ENABLE_SSR__ && globalThis.__LYNX_IS_HYDRATING__) return;
 			/* v8 ignore stop */
@@ -5215,6 +5979,9 @@ var LynxRendererFactory2 = class LynxRendererFactory2 {
 			processPendingTextNormalization();
 			if (!isFirstRenderPending()) __FlushElementTree();
 			processPendingListUpdates();
+		} finally {
+			/* v8 ignore start */
+			if (__PROFILE__) endCdTiming();
 		}
 	}
 	static ɵfac = i0.ɵɵngDeclareFactory({
@@ -5244,12 +6011,9 @@ const provideRenderer = () => {
 		{
 			provide: LYNX_DOCUMENT,
 			useFactory: () => {
-				if (__MAIN_THREAD__) {
-					/* v8 ignore next 6 */
-					if (__ENABLE_SSR__ && globalThis.__LYNX_IS_HYDRATING__) return new LynxHydrateDocument(globalThis.__LYNX_HYDRATE_PAGE__, globalThis.__LYNX_HYDRATE_QUEUE__);
-					return new LynxDocument();
-				}
-				return new LynxBackgroundDocument();
+				/* v8 ignore next 6 */
+				if (__ENABLE_SSR__ && globalThis.__LYNX_IS_HYDRATING__) return new LynxHydrateDocument(globalThis.__LYNX_HYDRATE_PAGE__, globalThis.__LYNX_HYDRATE_QUEUE__);
+				return new LynxDocument();
 			}
 		},
 		{
@@ -5278,6 +6042,12 @@ const provideRenderer = () => {
 		}
 	]);
 };
+let carriedOver;
+let snapshotOf;
+const carryOverLocation = (injector) => {
+	const strategy = injector?.get(LocationStrategy, null);
+	if (strategy instanceof LynxLocationStrategy) carriedOver = snapshotOf(strategy);
+};
 var LynxLocationStrategy = class LynxLocationStrategy extends LocationStrategy {
 	#path = "/";
 	#baseHref = "/";
@@ -5287,6 +6057,24 @@ var LynxLocationStrategy = class LynxLocationStrategy extends LocationStrategy {
 	}];
 	#historyIndex = 0;
 	#listeners = [];
+	#canGoBack = signal(false, ...ngDevMode ? [{ debugName: "#canGoBack" }] : /* istanbul ignore next */ []);
+	constructor() {
+		super();
+		if (carriedOver) {
+			this.#history = carriedOver.history;
+			this.#historyIndex = carriedOver.index;
+			this.#path = this.#history[this.#historyIndex].url;
+			this.#canGoBack.set(this.#historyIndex > 0);
+			carriedOver = void 0;
+		}
+	}
+	static {
+		snapshotOf = (strategy) => ({
+			history: strategy.#history.map((entry) => ({ ...entry })),
+			index: strategy.#historyIndex
+		});
+	}
+	canGoBack = this.#canGoBack.asReadonly();
 	path() {
 		return this.#path;
 	}
@@ -5307,6 +6095,7 @@ var LynxLocationStrategy = class LynxLocationStrategy extends LocationStrategy {
 			url: fullUrl
 		});
 		this.#historyIndex++;
+		this.#canGoBack.set(true);
 		this.#path = fullUrl;
 	}
 	replaceState(state, _title, url, queryParams) {
@@ -5327,6 +6116,7 @@ var LynxLocationStrategy = class LynxLocationStrategy extends LocationStrategy {
 		const target = this.#historyIndex + relativePosition;
 		if (target < 0 || target >= this.#history.length) return;
 		this.#historyIndex = target;
+		this.#canGoBack.set(target > 0);
 		this.#path = this.#history[target].url;
 		for (const fn of this.#listeners) fn({
 			type: "popstate",
@@ -5344,7 +6134,7 @@ var LynxLocationStrategy = class LynxLocationStrategy extends LocationStrategy {
 		version: "22.2.1",
 		ngImport: i0,
 		type: LynxLocationStrategy,
-		deps: null,
+		deps: [],
 		target: i0.ɵɵFactoryTarget.Injectable
 	});
 	static ɵprov = i0.ɵɵngDeclareInjectable({
@@ -5359,7 +6149,8 @@ i0.ɵɵngDeclareClassMetadata({
 	version: "22.2.1",
 	ngImport: i0,
 	type: LynxLocationStrategy,
-	decorators: [{ type: Injectable }]
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
 });
 var LynxPlatformLocation = class LynxPlatformLocation extends PlatformLocation {
 	#history = [{
@@ -5520,6 +6311,51 @@ i0.ɵɵngDeclareClassMetadata({
 	type: LynxRouteReuseStrategy,
 	decorators: [{ type: Injectable }]
 });
+const SHELL_MODULE = "AngularLynxShell";
+const BACK_EVENT = "angularLynxBack";
+var LynxBackButton = class LynxBackButton {
+	constructor() {
+		const strategy = inject(LocationStrategy);
+		if (!(strategy instanceof LynxLocationStrategy)) return;
+		const location = inject(Location);
+		const modules = inject(LynxNativeModule);
+		const shell = modules.getNativeModule(SHELL_MODULE);
+		let hasShell = true;
+		effect(() => {
+			const enabled = strategy.canGoBack();
+			if (!hasShell) return;
+			Promise.resolve().then(() => shell?.setBackHandlerEnabled(enabled)).catch(() => hasShell = false);
+		});
+		const emitter = modules.getJSModule("GlobalEventEmitter");
+		Promise.resolve().then(() => emitter?.addListener(BACK_EVENT, () => location.back())).catch(() => {});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.1",
+		ngImport: i0,
+		type: LynxBackButton,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.1",
+		ngImport: i0,
+		type: LynxBackButton,
+		providedIn: "root"
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: LynxBackButton,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}],
+	ctorParameters: () => []
+});
 const provideRouter = (routes, ...features) => {
 	return makeEnvironmentProviders([
 		{
@@ -5530,11 +6366,15 @@ const provideRouter = (routes, ...features) => {
 			provide: LocationStrategy,
 			useClass: LynxLocationStrategy
 		},
+		provideRouter$1(routes, withRouterConfig({ resolveNavigationPromiseOnError: true }), ...features),
+		provideEnvironmentInitializer(() => inject(LynxBackButton)),
 		{
-			provide: RouteReuseStrategy,
-			useClass: LynxRouteReuseStrategy
-		},
-		provideRouter$1(routes, withRouterConfig({ resolveNavigationPromiseOnError: true }), ...features)
+			provide: ROUTER_LINK_ACTIVE_CHANGE,
+			useValue: () => inject(RouterLinkActive, {
+				self: true,
+				optional: true
+			})?.isActiveChange ?? null
+		}
 	]);
 };
 globalThis.__lynxLastError = "";
@@ -5552,12 +6392,98 @@ if (typeof globalThis.onunhandledrejection !== "function") globalThis.onunhandle
 	globalThis.__lynxLastError = `${e.name}: ${e.message}\n${e.stack ?? ""}`;
 	reportToNative(e);
 };
-const REPLACEMENT_CHARACTER = 65533;
+const CODES = {
+	NotSupportedError: 9,
+	InvalidStateError: 11,
+	SyntaxError: 12,
+	InvalidAccessError: 15,
+	NetworkError: 19,
+	AbortError: 20,
+	TimeoutError: 23
+};
+var LynxDOMException = class extends Error {
+	code;
+	constructor(message = "", name = "Error") {
+		super(message);
+		this.name = name;
+		this.code = CODES[name] ?? 0;
+	}
+};
+const NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const normalizeValue = (value) => {
+	const normalized = String(value).replace(/^[\t\n\r ]+|[\t\n\r ]+$/g, "");
+	if (/[\r\n]/.test(normalized) || normalized.includes("\0")) throw new TypeError(`Invalid header value: ${JSON.stringify(value)}`);
+	return normalized;
+};
+const normalizeName = (name) => {
+	const normalized = String(name);
+	if (!NAME.test(normalized)) throw new TypeError(`Invalid header name: ${JSON.stringify(name)}`);
+	return normalized.toLowerCase();
+};
+var LynxHeaders = class LynxHeaders {
+	#list = [];
+	constructor(init) {
+		if (init == null) return;
+		if (init instanceof LynxHeaders) this.#list = init.#list.map(([name, value]) => [name, value]);
+		else if (typeof init[Symbol.iterator] === "function") for (const pair of init) {
+			if (pair.length !== 2) throw new TypeError("Failed to construct 'Headers': Invalid value: each header must be a [name, value] pair");
+			this.append(pair[0], pair[1]);
+		}
+		else for (const name of Object.keys(init)) this.append(name, init[name]);
+	}
+	append(name, value) {
+		this.#list.push([normalizeName(name), normalizeValue(value)]);
+	}
+	delete(name) {
+		const key = normalizeName(name);
+		this.#list = this.#list.filter(([listed]) => listed !== key);
+	}
+	get(name) {
+		const key = normalizeName(name);
+		const values = this.#list.filter(([listed]) => listed === key).map(([, value]) => value);
+		return values.length > 0 ? values.join(", ") : null;
+	}
+	getSetCookie() {
+		return this.#list.filter(([name]) => name === "set-cookie").map(([, value]) => value);
+	}
+	has(name) {
+		const key = normalizeName(name);
+		return this.#list.some(([listed]) => listed === key);
+	}
+	set(name, value) {
+		const key = normalizeName(name);
+		const index = this.#list.findIndex(([listed]) => listed === key);
+		if (index === -1) {
+			this.append(key, value);
+			return;
+		}
+		this.#list[index] = [key, normalizeValue(value)];
+		this.#list = this.#list.filter(([listed], i) => listed !== key || i === index);
+	}
+	forEach(callback, thisArg) {
+		for (const [name, value] of this.entries()) callback.call(thisArg, value, name, this);
+	}
+	*entries() {
+		const names = [...new Set(this.#list.map(([name]) => name))].sort();
+		for (const name of names) if (name === "set-cookie") for (const value of this.getSetCookie()) yield [name, value];
+		else yield [name, this.get(name)];
+	}
+	*keys() {
+		for (const [name] of this.entries()) yield name;
+	}
+	*values() {
+		for (const [, value] of this.entries()) yield value;
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+};
+const REPLACEMENT_CHARACTER$1 = 65533;
 const utf8Encode = (input) => {
 	const bytes = [];
 	for (const char of input) {
 		let codePoint = char.codePointAt(0);
-		if (codePoint >= 55296 && codePoint <= 57343) codePoint = REPLACEMENT_CHARACTER;
+		if (codePoint >= 55296 && codePoint <= 57343) codePoint = REPLACEMENT_CHARACTER$1;
 		if (codePoint < 128) bytes.push(codePoint);
 		else if (codePoint < 2048) bytes.push(192 | codePoint >> 6, 128 | codePoint & 63);
 		else if (codePoint < 65536) bytes.push(224 | codePoint >> 12, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
@@ -5593,7 +6519,7 @@ const utf8Decode = (bytes) => {
 			needed = 3;
 			codePoint = lead & 7;
 		} else {
-			output += String.fromCharCode(REPLACEMENT_CHARACTER);
+			output += String.fromCharCode(REPLACEMENT_CHARACTER$1);
 			index++;
 			continue;
 		}
@@ -5607,7 +6533,7 @@ const utf8Decode = (bytes) => {
 			seen++;
 		}
 		if (seen < needed) {
-			output += String.fromCharCode(REPLACEMENT_CHARACTER);
+			output += String.fromCharCode(REPLACEMENT_CHARACTER$1);
 			index += 1 + seen;
 			continue;
 		}
@@ -5654,6 +6580,700 @@ const formUrlEncode = (input) => {
 	else output += percentEncodeByte(byte);
 	return output;
 };
+const UTF8_LABELS = /* @__PURE__ */ new Set([
+	"unicode-1-1-utf-8",
+	"unicode11utf8",
+	"unicode20utf8",
+	"utf-8",
+	"utf8",
+	"x-unicode20utf8"
+]);
+const REPLACEMENT_CHARACTER = 65533;
+const BYTE_ORDER_MARK = 65279;
+const SLICE = 8192;
+const toBytes$1 = (input) => {
+	if (input === void 0) return /* @__PURE__ */ new Uint8Array(0);
+	if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+	if (input instanceof ArrayBuffer) return new Uint8Array(input);
+	throw new TypeError("Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'.");
+};
+const sequenceLength = (lead) => {
+	if (lead >= 194 && lead <= 223) return 2;
+	if (lead >= 224 && lead <= 239) return 3;
+	if (lead >= 240 && lead <= 244) return 4;
+	return 1;
+};
+const completeLength = (bytes) => {
+	for (let back = 1; back <= 3 && back <= bytes.length; back++) {
+		const byte = bytes[bytes.length - back];
+		if ((byte & 192) !== 128) return sequenceLength(byte) > back ? bytes.length - back : bytes.length;
+	}
+	return bytes.length;
+};
+var LynxTextEncoder = class {
+	encoding = "utf-8";
+	encode(input = "") {
+		return new Uint8Array(utf8Encode(String(input)));
+	}
+	encodeInto(source, destination) {
+		let read = 0;
+		let written = 0;
+		for (const char of String(source)) {
+			const bytes = utf8Encode(char);
+			if (written + bytes.length > destination.length) break;
+			destination.set(bytes, written);
+			written += bytes.length;
+			read += char.length;
+		}
+		return {
+			read,
+			written
+		};
+	}
+};
+var LynxTextDecoder = class {
+	encoding = "utf-8";
+	fatal;
+	ignoreBOM;
+	#pending = [];
+	#started = false;
+	constructor(label = "utf-8", options = {}) {
+		if (!UTF8_LABELS.has(String(label).trim().toLowerCase())) throw new RangeError(`The encoding label provided ('${label}') is invalid or isn't supported on Lynx, which only decodes UTF-8.`);
+		this.fatal = !!options.fatal;
+		this.ignoreBOM = !!options.ignoreBOM;
+	}
+	decode(input, options = {}) {
+		let bytes = toBytes$1(input);
+		if (this.#pending.length > 0) bytes = [...this.#pending, ...Array.from(bytes)];
+		const end = options.stream ? completeLength(bytes) : bytes.length;
+		this.#pending = Array.from({ length: bytes.length - end }, (_, i) => Number(bytes[end + i]));
+		let output = this.#decode(bytes, end);
+		if (!this.ignoreBOM && !this.#started && output.charCodeAt(0) === BYTE_ORDER_MARK) output = output.slice(1);
+		this.#started = options.stream ? this.#started || output !== "" : false;
+		return output;
+	}
+	#decode(bytes, end) {
+		let output = "";
+		const codes = [];
+		const invalid = () => {
+			if (this.fatal) throw new TypeError("Failed to execute 'decode' on 'TextDecoder': The encoded data was not valid.");
+			codes.push(REPLACEMENT_CHARACTER);
+		};
+		let index = 0;
+		while (index < end) {
+			const lead = bytes[index];
+			if (lead < 128) {
+				codes.push(lead);
+				index++;
+			} else {
+				const needed = sequenceLength(lead) - 1;
+				let lower = lead === 224 ? 160 : lead === 240 ? 144 : 128;
+				let upper = lead === 237 ? 159 : lead === 244 ? 143 : 191;
+				let codePoint = lead & 255 >> needed + 2;
+				let seen = 0;
+				while (seen < needed && index + 1 + seen < end) {
+					const next = bytes[index + 1 + seen];
+					if (next < lower || next > upper) break;
+					lower = 128;
+					upper = 191;
+					codePoint = codePoint << 6 | next & 63;
+					seen++;
+				}
+				if (needed === 0 || seen < needed) {
+					invalid();
+					index += 1 + seen;
+				} else {
+					if (codePoint > 65535) {
+						codePoint -= 65536;
+						codes.push(55296 | codePoint >> 10, 56320 | codePoint & 1023);
+					} else codes.push(codePoint);
+					index += 1 + needed;
+				}
+			}
+			if (codes.length >= SLICE) {
+				output += String.fromCharCode(...codes);
+				codes.length = 0;
+			}
+		}
+		return output + String.fromCharCode(...codes);
+	}
+};
+const toBytes = (source) => typeof source === "string" ? new LynxTextEncoder().encode(source) : source ?? /* @__PURE__ */ new Uint8Array(0);
+const unsupportedBody = (kind) => /* @__PURE__ */ new TypeError(`${kind} request bodies aren't supported on Lynx. Send a string, URLSearchParams, an ArrayBuffer or a typed array.`);
+const extractBody = (body) => {
+	if (body == null) return {
+		source: null,
+		type: null
+	};
+	if (typeof body === "string") return {
+		source: body,
+		type: "text/plain;charset=UTF-8"
+	};
+	if (body instanceof ArrayBuffer) return {
+		source: new Uint8Array(body.slice(0)),
+		type: null
+	};
+	if (ArrayBuffer.isView(body)) return {
+		source: new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength)),
+		type: null
+	};
+	if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return {
+		source: body.toString(),
+		type: "application/x-www-form-urlencoded;charset=UTF-8"
+	};
+	for (const kind of [
+		"Blob",
+		"FormData",
+		"ReadableStream"
+	]) {
+		const type = globalThis[kind];
+		if (typeof type === "function" && body instanceof type) throw unsupportedBody(kind);
+	}
+	if (typeof body.getReader === "function") throw unsupportedBody("ReadableStream");
+	return {
+		source: String(body),
+		type: "text/plain;charset=UTF-8"
+	};
+};
+var LynxBodyStream = class {
+	#chunk;
+	#onRead;
+	locked = false;
+	constructor(chunk, onRead) {
+		this.#chunk = chunk.length > 0 ? chunk : null;
+		this.#onRead = onRead;
+	}
+	getReader() {
+		if (this.locked) throw new TypeError("Failed to execute 'getReader' on 'ReadableStream': ReadableStreamDefaultReader constructor can only accept readable streams that are not yet locked to a reader");
+		this.locked = true;
+		this.#onRead();
+		let released = false;
+		return {
+			read: async () => {
+				if (released) throw new TypeError("This reader has been released");
+				const chunk = this.#chunk;
+				this.#chunk = null;
+				return chunk ? {
+					done: false,
+					value: chunk
+				} : {
+					done: true,
+					value: void 0
+				};
+			},
+			cancel: async () => {
+				this.#chunk = null;
+			},
+			releaseLock: () => {
+				released = true;
+				this.locked = false;
+			},
+			closed: Promise.resolve(void 0)
+		};
+	}
+	async cancel() {
+		this.#onRead();
+		this.#chunk = null;
+	}
+	async *[Symbol.asyncIterator]() {
+		const reader = this.getReader();
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) return;
+			yield value;
+		}
+	}
+};
+var LynxBody = class {
+	#source;
+	#used = false;
+	#stream;
+	constructor(source) {
+		this.#source = source;
+	}
+	get body() {
+		if (this.#source === null) return null;
+		this.#stream ??= new LynxBodyStream(toBytes(this.#source), () => {
+			this.#used = true;
+		});
+		return this.#stream;
+	}
+	get bodyUsed() {
+		return this.#used;
+	}
+	relayedBody() {
+		const source = this.#source;
+		if (source === null) return null;
+		return typeof source === "string" ? { text: source } : { base64: bytesToBase64(source) };
+	}
+	cloneSource() {
+		if (this.#used) throw new TypeError("Failed to execute 'clone': the body is already used");
+		return this.#source;
+	}
+	async #consume() {
+		if (this.#used) throw new TypeError("Failed to execute 'text' on 'Body': body stream already read");
+		this.#used = true;
+		return this.#source;
+	}
+	async text() {
+		const source = await this.#consume();
+		return typeof source === "string" ? source : new LynxTextDecoder().decode(toBytes(source));
+	}
+	async json() {
+		return JSON.parse(await this.text());
+	}
+	async bytes() {
+		return toBytes(await this.#consume());
+	}
+	async arrayBuffer() {
+		const bytes = await this.bytes();
+		return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+	}
+	async blob() {
+		const BlobType = globalThis.Blob;
+		if (typeof BlobType !== "function") throw new TypeError("Lynx has no Blob. Use arrayBuffer() instead.");
+		return new BlobType([await this.arrayBuffer()], { type: this.headers.get("content-type") ?? "" });
+	}
+	async formData() {
+		throw new TypeError("Lynx has no FormData. Use text() or json() instead.");
+	}
+};
+const NORMALIZED_METHODS = /* @__PURE__ */ new Set([
+	"DELETE",
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"POST",
+	"PUT"
+]);
+const parseUrl$1 = (input) => {
+	try {
+		return new URL(input).href;
+	} catch {
+		throw new TypeError(`Failed to parse URL from ${input}. Lynx has no page URL to resolve a relative URL against, so requests need an absolute URL.`);
+	}
+};
+const DEFAULT_OPTIONS = {
+	cache: "default",
+	credentials: "same-origin",
+	integrity: "",
+	keepalive: false,
+	mode: "cors",
+	priority: "auto",
+	redirect: "follow",
+	referrer: "about:client",
+	referrerPolicy: ""
+};
+const neverAborts = () => new AbortController().signal;
+var LynxRequest = class LynxRequest extends LynxBody {
+	url;
+	method;
+	headers;
+	signal;
+	cache;
+	credentials;
+	integrity;
+	keepalive;
+	mode;
+	priority;
+	redirect;
+	referrer;
+	referrerPolicy;
+	destination = "";
+	constructor(input, init = {}) {
+		const base = input instanceof LynxRequest ? input : void 0;
+		const method = init.method ?? base?.method ?? "GET";
+		const upper = method.toUpperCase();
+		const normalizedMethod = NORMALIZED_METHODS.has(upper) ? upper : method;
+		const { source, type } = init.body !== void 0 ? extractBody(init.body) : {
+			source: base ? base.cloneSource() : null,
+			type: null
+		};
+		if (source !== null && (upper === "GET" || upper === "HEAD")) throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
+		super(source);
+		this.url = base ? base.url : parseUrl$1(String(input));
+		this.method = normalizedMethod;
+		this.headers = new LynxHeaders(init.headers ?? base?.headers);
+		if (type !== null && !this.headers.has("content-type")) this.headers.set("content-type", type);
+		this.signal = init.signal ?? base?.signal ?? neverAborts();
+		const options = base ?? DEFAULT_OPTIONS;
+		this.cache = init.cache ?? options.cache;
+		this.credentials = init.credentials ?? options.credentials;
+		this.integrity = init.integrity ?? options.integrity;
+		this.keepalive = init.keepalive ?? options.keepalive;
+		this.mode = init.mode ?? options.mode;
+		this.priority = init.priority ?? options.priority;
+		this.redirect = init.redirect ?? options.redirect;
+		this.referrer = init.referrer ?? options.referrer;
+		this.referrerPolicy = init.referrerPolicy ?? options.referrerPolicy;
+	}
+	clone() {
+		return new LynxRequest(this);
+	}
+	toRelayed() {
+		return {
+			url: this.url,
+			method: this.method,
+			headers: [...this.headers.entries()],
+			body: this.relayedBody(),
+			options: Object.fromEntries(Object.entries(DEFAULT_OPTIONS).filter(([name, value]) => this[name] !== value).map(([name]) => [name, this[name]]))
+		};
+	}
+};
+var ExtractedBody = class {
+	source;
+	constructor(source) {
+		this.source = source;
+	}
+};
+var LynxResponse = class LynxResponse extends LynxBody {
+	status;
+	statusText;
+	headers;
+	url;
+	redirected;
+	type;
+	constructor(body, init = {}, details = {
+		url: "",
+		redirected: false,
+		type: "default"
+	}) {
+		const status = init.status ?? 200;
+		if (details.type === "default" && (!Number.isInteger(status) || status < 200 || status > 599)) throw new RangeError(`Failed to construct 'Response': The status provided (${status}) is outside the range [200, 599].`);
+		const { source, type } = body instanceof ExtractedBody ? {
+			source: body.source,
+			type: null
+		} : extractBody(body);
+		super(source);
+		this.status = status;
+		this.statusText = init.statusText ?? "";
+		this.headers = new LynxHeaders(init.headers);
+		if (type !== null && !this.headers.has("content-type")) this.headers.set("content-type", type);
+		this.url = details.url;
+		this.redirected = details.redirected;
+		this.type = details.type;
+	}
+	get ok() {
+		return this.status >= 200 && this.status < 300;
+	}
+	clone() {
+		return new LynxResponse(new ExtractedBody(this.cloneSource()), {
+			status: this.status,
+			statusText: this.statusText,
+			headers: this.headers
+		}, {
+			url: this.url,
+			redirected: this.redirected,
+			type: this.type
+		});
+	}
+	static error() {
+		return new LynxResponse(null, { status: 0 }, {
+			url: "",
+			redirected: false,
+			type: "error"
+		});
+	}
+	static json(data, init = {}) {
+		const response = new LynxResponse(new ExtractedBody(JSON.stringify(data)), init);
+		if (!response.headers.has("content-type")) response.headers.set("content-type", "application/json");
+		return response;
+	}
+	static redirect(url, status = 302) {
+		if (![
+			301,
+			302,
+			303,
+			307,
+			308
+		].includes(status)) throw new RangeError(`Failed to execute 'redirect' on 'Response': Invalid status code ${status}`);
+		return new LynxResponse(null, {
+			status,
+			headers: { location: parseUrl$1(url) }
+		});
+	}
+	static fromRelayed(relayed) {
+		const body = relayed.body;
+		const source = body === null ? null : "text" in body ? body.text : base64ToBytes(body.base64);
+		return new LynxResponse(new ExtractedBody(source), {
+			status: relayed.status,
+			statusText: relayed.statusText,
+			headers: relayed.headers
+		}, {
+			url: relayed.url,
+			redirected: relayed.redirected,
+			type: "basic"
+		});
+	}
+};
+let nextFetchId = 0;
+const relayFetch = (input, init) => new Promise((resolve, reject) => {
+	const request = new LynxRequest(input, init);
+	const { signal } = request;
+	if (signal.aborted) {
+		reject(signal.reason);
+		return;
+	}
+	const id = nextFetchId++;
+	let settled = false;
+	const onAbort = () => {
+		settled = true;
+		reject(signal.reason);
+		callOnBackground("abortFetch", id).catch(() => {});
+	};
+	signal.addEventListener("abort", onAbort);
+	const settle = (fn) => {
+		signal.removeEventListener("abort", onAbort);
+		if (settled) return;
+		settled = true;
+		fn();
+	};
+	callOnBackground("fetch", id, request.toRelayed()).then((relayed) => settle(() => resolve(LynxResponse.fromRelayed(relayed))), (error) => settle(() => reject(new TypeError(error.message))));
+});
+var XhrEventTarget = class {
+	#listeners = /* @__PURE__ */ new Map();
+	onloadstart = null;
+	onprogress = null;
+	onabort = null;
+	onerror = null;
+	onload = null;
+	ontimeout = null;
+	onloadend = null;
+	addEventListener(type, listener) {
+		if (!listener) return;
+		let listeners = this.#listeners.get(type);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.#listeners.set(type, listeners);
+		}
+		listeners.add(listener);
+	}
+	removeEventListener(type, listener) {
+		if (listener) this.#listeners.get(type)?.delete(listener);
+	}
+	dispatchEvent(event) {
+		const full = {
+			lengthComputable: false,
+			loaded: 0,
+			total: 0,
+			...event,
+			target: this,
+			currentTarget: this
+		};
+		const handler = this[`on${event.type}`];
+		if (typeof handler === "function") handler.call(this, full);
+		for (const listener of Array.from(this.#listeners.get(event.type) ?? [])) listener.call(this, full);
+		return true;
+	}
+	fire(type, loaded = 0, total = 0) {
+		this.dispatchEvent({
+			type,
+			lengthComputable: total > 0,
+			loaded,
+			total
+		});
+	}
+};
+var XhrUpload = class extends XhrEventTarget {
+	emit(type, loaded, total) {
+		this.fire(type, loaded, total);
+	}
+};
+const UNSENT = 0;
+const OPENED = 1;
+const HEADERS_RECEIVED = 2;
+const LOADING = 3;
+const DONE = 4;
+const bodySize = (body) => {
+	if (typeof body === "string") return body.length;
+	if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return body.byteLength;
+	return 0;
+};
+var LynxXMLHttpRequest = class extends XhrEventTarget {
+	static UNSENT = UNSENT;
+	static OPENED = OPENED;
+	static HEADERS_RECEIVED = HEADERS_RECEIVED;
+	static LOADING = LOADING;
+	static DONE = DONE;
+	UNSENT = UNSENT;
+	OPENED = OPENED;
+	HEADERS_RECEIVED = HEADERS_RECEIVED;
+	LOADING = LOADING;
+	DONE = DONE;
+	upload = new XhrUpload();
+	onreadystatechange = null;
+	readyState = UNSENT;
+	status = 0;
+	statusText = "";
+	responseURL = "";
+	responseType = "";
+	response = "";
+	timeout = 0;
+	withCredentials = false;
+	#method = "GET";
+	#url = "";
+	#requestHeaders = new LynxHeaders();
+	#responseHeaders = new LynxHeaders();
+	#responseText = "";
+	#controller;
+	#generation = 0;
+	#timer;
+	#uploading = false;
+	get responseText() {
+		if (this.responseType !== "" && this.responseType !== "text") throw new LynxDOMException(`Failed to read the 'responseText' property from 'XMLHttpRequest': The value is only accessible if the object's 'responseType' is '' or 'text' (was '${this.responseType}').`, "InvalidStateError");
+		return this.#responseText;
+	}
+	open(method, url, async = true) {
+		if (!async) throw new LynxDOMException("Failed to execute 'open' on 'XMLHttpRequest': Synchronous requests aren't supported on Lynx, where the request runs on another thread.", "InvalidAccessError");
+		this.#cancel();
+		this.#method = method;
+		this.#url = String(url);
+		this.#requestHeaders = new LynxHeaders();
+		this.#reset();
+		this.#setReadyState(OPENED);
+	}
+	setRequestHeader(name, value) {
+		this.#assertOpened("setRequestHeader");
+		this.#requestHeaders.append(name, value);
+	}
+	send(body = null) {
+		this.#assertOpened("send");
+		const generation = ++this.#generation;
+		const controller = new AbortController();
+		this.#controller = controller;
+		const method = this.#method.toUpperCase();
+		const sendsBody = method !== "GET" && method !== "HEAD" && body != null;
+		const uploadSize = sendsBody ? bodySize(body) : 0;
+		this.#uploading = sendsBody;
+		this.fire("loadstart");
+		if (sendsBody) this.upload.emit("loadstart", 0, uploadSize);
+		if (this.timeout > 0) this.#timer = setTimeout(() => {
+			if (generation !== this.#generation) return;
+			this.#fail("timeout");
+		}, this.timeout);
+		const current = () => generation === this.#generation;
+		Promise.resolve().then(() => globalThis.fetch(this.#url, {
+			method: this.#method,
+			headers: this.#requestHeaders,
+			body: sendsBody ? body : void 0,
+			credentials: this.withCredentials ? "include" : "same-origin",
+			signal: controller.signal
+		})).then(async (response) => {
+			if (!current()) return;
+			this.#uploadDone(uploadSize);
+			this.status = response.status;
+			this.statusText = response.statusText;
+			this.responseURL = response.url;
+			this.#responseHeaders = new LynxHeaders(response.headers);
+			this.#setReadyState(HEADERS_RECEIVED);
+			this.#setReadyState(LOADING);
+			const size = await this.#readResponse(response);
+			if (!current()) return;
+			this.#finish();
+			this.fire("progress", size, size);
+			this.#setReadyState(DONE);
+			this.fire("load", size, size);
+			this.fire("loadend", size, size);
+		}).catch(() => {
+			if (current()) this.#fail("error");
+		});
+	}
+	abort() {
+		if (this.#controller && this.readyState !== DONE) this.#fail("abort");
+		if (this.readyState === DONE) this.readyState = UNSENT;
+	}
+	getResponseHeader(name) {
+		return this.readyState >= HEADERS_RECEIVED ? this.#responseHeaders.get(name) : null;
+	}
+	getAllResponseHeaders() {
+		if (this.readyState < HEADERS_RECEIVED) return "";
+		let headers = "";
+		for (const [name, value] of this.#responseHeaders) headers += `${name}: ${value}\r\n`;
+		return headers;
+	}
+	overrideMimeType(_mime) {}
+	async #readResponse(response) {
+		const type = this.responseType;
+		if (type === "arraybuffer" || type === "blob") {
+			const buffer = await response.arrayBuffer();
+			const BlobType = globalThis.Blob;
+			this.response = type === "arraybuffer" ? buffer : typeof BlobType === "function" ? new BlobType([buffer], { type: this.#responseHeaders.get("content-type") ?? "" }) : null;
+			return buffer.byteLength;
+		}
+		const text = await response.text();
+		if (type === "json") try {
+			this.response = text === "" ? null : JSON.parse(text);
+		} catch {
+			this.response = null;
+		}
+		else if (type === "document") this.response = null;
+		else {
+			this.#responseText = text;
+			this.response = text;
+		}
+		const length = Number(this.#responseHeaders.get("content-length"));
+		return Number.isFinite(length) && length > 0 ? length : text.length;
+	}
+	#uploadDone(size) {
+		if (!this.#uploading) return;
+		this.#uploading = false;
+		this.upload.emit("progress", size, size);
+		this.upload.emit("load", size, size);
+		this.upload.emit("loadend", size, size);
+	}
+	#fail(type) {
+		this.#cancel();
+		this.#reset();
+		this.#setReadyState(DONE);
+		if (this.#uploading) {
+			this.#uploading = false;
+			this.upload.emit(type);
+			this.upload.emit("loadend");
+		}
+		this.fire(type);
+		this.fire("loadend");
+	}
+	#cancel() {
+		this.#generation++;
+		this.#finish();
+		this.#controller?.abort();
+		this.#controller = void 0;
+	}
+	#finish() {
+		if (this.#timer !== void 0) clearTimeout(this.#timer);
+		this.#timer = void 0;
+	}
+	#reset() {
+		this.status = 0;
+		this.statusText = "";
+		this.responseURL = "";
+		this.response = this.responseType === "" || this.responseType === "text" ? "" : null;
+		this.#responseText = "";
+		this.#responseHeaders = new LynxHeaders();
+	}
+	#assertOpened(method) {
+		if (this.readyState !== OPENED || this.#controller) throw new LynxDOMException(`Failed to execute '${method}' on 'XMLHttpRequest': The object's state must be OPENED.`, "InvalidStateError");
+	}
+	#setReadyState(state) {
+		this.readyState = state;
+		this.dispatchEvent({ type: "readystatechange" });
+	}
+};
+const installNetworkGlobals = (target) => {
+	const install = (name, value) => {
+		if (typeof target[name] === "undefined") target[name] = value;
+	};
+	install("TextEncoder", LynxTextEncoder);
+	install("TextDecoder", LynxTextDecoder);
+	install("DOMException", LynxDOMException);
+	if (typeof target["fetch"] === "undefined") {
+		install("fetch", relayFetch);
+		install("Headers", LynxHeaders);
+		install("Request", LynxRequest);
+		install("Response", LynxResponse);
+	}
+	install("XMLHttpRequest", LynxXMLHttpRequest);
+};
 const invalidUrl = () => /* @__PURE__ */ new TypeError("Invalid URL");
 const FORBIDDEN_HOST = /[\u0000\t\n\r #/:<>?@[\\\]^|]/;
 const FORBIDDEN_DOMAIN = /[\u0000-\u001f #%/:<>?@[\\\]^|\u007f]/;
@@ -6388,6 +8008,7 @@ if (typeof AbortController === "undefined") {
 	};
 }
 installUrl(globalThis);
+if (isMainThread()) installNetworkGlobals(globalThis);
 if (typeof globalThis.queueMicrotask !== "function") {
 	if (typeof lynx !== "undefined" && lynx.queueMicrotask) globalThis.queueMicrotask = lynx.queueMicrotask;
 	else {
@@ -6548,27 +8169,41 @@ const ssrHydrate = (info) => {
 	globalThis.__LYNX_HYDRATE_PAGE__ = nativePage;
 	globalThis.__LYNX_HYDRATE_QUEUE__ = elementQueue;
 };
-const __workletMap = {};
-const __mainThreadRefMap = {};
-const __pendingResolvers = {};
-let __nextResolveId = 0;
-const nextResolveId = () => __nextResolveId++;
-const transformParams = (value) => {
-	if (typeof value !== "object" || value === null) return value;
-	if (Array.isArray(value)) return value.map(transformParams);
-	const obj = value;
-	if ("elementRefptr" in obj) return new MainThreadElement(obj["elementRefptr"]);
-	if ("_wvid" in obj) return __mainThreadRefMap[obj["_wvid"]] ?? obj;
-	const result = {};
-	for (const key of Object.keys(obj)) result[key] = transformParams(obj[key]);
-	return result;
+const callWorklet = (id, args, kind) => {
+	const fn = __workletMap[id];
+	if (!fn) throw new Error(`[angular-lynx] ${kind} not found: ${id}`);
+	return fn(...args);
 };
-const pageReady = new Subject();
-globalThis.renderPage = () => {
+const pageReady = new ReplaySubject(1);
+globalThis.renderPage = (data) => {
+	if (typeof lynx !== "undefined") lynx.__initData = data ?? {};
 	pageReady.next();
 };
-globalThis.updatePage = () => {};
-globalThis.processData = () => {};
+globalThis.updatePage = (data, options) => {
+	if (typeof lynx !== "undefined") applyInitDataUpdate(data, !!options?.resetPageData);
+};
+globalThis.updateGlobalProps = (data) => {
+	if (typeof lynx !== "undefined") applyGlobalDataUpdate(data);
+};
+if (__MAIN_THREAD__ && typeof lynx !== "undefined" && typeof lynx.getEngine === "function") lynx.getEngine().addEventListener("__UpdateGlobalProps", (event) => applyGlobalDataUpdate(event.data?.[0]));
+globalThis.processData = (data) => data;
+if (!__MAIN_THREAD__ && typeof lynx !== "undefined" && typeof lynx.getApp === "function") {
+	const app = lynx.getApp();
+	const params = app._params;
+	lynx.__initData = {
+		...params?.initData,
+		...params?.updateData
+	};
+	const emit = (eventName, args) => lynx.getJSModule?.("GlobalEventEmitter")?.emit?.(eventName, args);
+	app.updateCardData = (data, options) => {
+		const { __lynx_timing_flag: _timingFlag, ...patch } = data ?? {};
+		applyInitDataUpdate(patch, options?.type === 1);
+		emit("onDataChanged", [patch]);
+	};
+	app.updateGlobalProps = (data) => {
+		emit("onGlobalPropsChanged", [applyGlobalDataUpdate(data)]);
+	};
+}
 if (__ENABLE_SSR__) {
 	globalThis.ssrEncode = ssrEncode;
 	globalThis.ssrHydrate = ssrHydrate;
@@ -6588,36 +8223,15 @@ globalThis.runWorklet = (ctx, params) => {
 };
 if (__MAIN_THREAD__) {
 	try {
-		if (typeof lynx !== "undefined" && lynx.getJSContext) {
-			lynx.getJSContext().addEventListener("Lynx.Worklet.runWorkletCtx", (event) => {
-				const { worklet, params, resolveId } = JSON.parse(event.data);
-				const fn = __workletMap[worklet._wkltId];
-				let returnValue;
-				let error;
-				try {
-					returnValue = fn?.(...params);
-				} catch (e) {
-					error = String(e);
-				}
-				lynx.getJSContext().dispatchEvent({
-					type: "Lynx.Worklet.FunctionCallRet",
-					data: JSON.stringify({
-						resolveId,
-						returnValue,
-						error
-					})
-				});
-			});
-			lynx.getJSContext().addEventListener("Lynx.Worklet.BgFunctionCallRet", (event) => {
-				const { resolveId, returnValue, error } = JSON.parse(event.data);
-				const resolver = __pendingResolvers[resolveId];
-				if (resolver) {
-					delete __pendingResolvers[resolveId];
-					if (error) resolver.reject(new Error(error));
-					else resolver.resolve(returnValue);
-				}
-			});
-		}
+		if (typeof lynx !== "undefined" && lynx.getJSContext) lynx.getJSContext().addEventListener("Lynx.Worklet.BgFunctionCallRet", (event) => {
+			const { resolveId, returnValue, error } = JSON.parse(event.data);
+			const resolver = __pendingResolvers[resolveId];
+			if (resolver) {
+				delete __pendingResolvers[resolveId];
+				if (error) resolver.reject(new Error(error));
+				else resolver.resolve(returnValue);
+			}
+		});
 	} catch {}
 	globalThis.runOnBackground = (handle, ...args) => {
 		const resolveId = nextResolveId();
@@ -6643,44 +8257,15 @@ if (__MAIN_THREAD__) {
 	};
 }
 if (!__MAIN_THREAD__) try {
-	if (typeof lynx !== "undefined" && lynx.getCoreContext) {
-		lynx.getCoreContext().addEventListener("Lynx.Worklet.FunctionCallRet", (event) => {
-			const { resolveId, returnValue, error } = JSON.parse(event.data);
-			const resolver = __pendingResolvers[resolveId];
-			if (resolver) {
-				delete __pendingResolvers[resolveId];
-				if (error) resolver.reject(new Error(error));
-				else resolver.resolve(returnValue);
-			}
-		});
-		lynx.getCoreContext().addEventListener("Lynx.Worklet.runOnBackground", (event) => {
-			const { worklet, params, resolveId } = JSON.parse(event.data);
-			const fn = __workletMap[worklet._wkltId];
-			let returnValue;
-			let error;
-			try {
-				returnValue = fn?.(...params);
-			} catch (e) {
-				error = String(e);
-			}
-			lynx.getCoreContext().dispatchEvent({
-				type: "Lynx.Worklet.BgFunctionCallRet",
-				data: JSON.stringify({
-					resolveId,
-					returnValue,
-					error
-				})
-			});
-		});
-	}
+	if (typeof lynx !== "undefined" && lynx.getCoreContext) lynx.getCoreContext().addEventListener("Lynx.Worklet.runOnBackground", (event) => {
+		const { worklet, params, resolveId } = JSON.parse(event.data);
+		answerCall(resolveId, () => callWorklet(worklet._wkltId, params.map(restoreRefs), "Background function"), (data) => lynx.getCoreContext().dispatchEvent({
+			type: "Lynx.Worklet.BgFunctionCallRet",
+			data
+		}));
+	});
 } catch {}
-globalThis.__lynxMtsPendingResolvers = __pendingResolvers;
-globalThis.__lynxMtsNextResolveId = nextResolveId;
-globalThis.__lynxRunMainThreadWorklet = (wkltId, args) => {
-	const fn = __workletMap[wkltId];
-	if (!fn) throw new Error(`[angular-lynx] Main-thread worklet not found: ${wkltId}`);
-	return fn(...args);
-};
+globalThis.__lynxRunMainThreadWorklet = (wkltId, args) => callWorklet(wkltId, args, "Main-thread worklet");
 const installLazyBundleLoader = () => {
 	const host = lynx;
 	host.loadLazyBundle = loadLazyBundleWithQueryComponent;
@@ -6746,15 +8331,25 @@ const makeSyncThen = (value) => (onFulfilled) => {
 	if (next && typeof next.then === "function") return next;
 	return syncResolved(next);
 };
+const ɵstartBackgroundThread = () => {
+	installLazyBundleLoader();
+};
 const bootstrapApplication = async (rootComponent, options) => {
+	if (!__MAIN_THREAD__) return new Promise(() => {});
 	installLazyBundleLoader();
+	const bootstrap = bootstrapOnMainThread(rootComponent, options);
+	globalThis.__LYNX_ANGULAR_BOOTSTRAP__ = bootstrap;
+	return bootstrap;
+};
+const bootstrapOnMainThread = async (rootComponent, options) => {
 	const prev = globalThis.__LYNX_ANGULAR_APP_REF__;
 	if (prev) {
+		carryOverLocation(prev.injector);
+		handOverPageToNextApp();
 		prev.destroy();
 		globalThis.__LYNX_ANGULAR_APP_REF__ = void 0;
-		for (const key of Object.keys(__workletMap)) delete __workletMap[key];
 	}
-	if (__MAIN_THREAD__ && !prev) await firstValueFrom(pageReady);
+	await firstValueFrom(pageReady);
 	const appRef = await bootstrapApplication$1(rootComponent, options);
 	markFirstRenderComplete();
 	globalThis.__LYNX_ANGULAR_APP_REF__ = appRef;
@@ -6764,9 +8359,9 @@ const bootstrapApplication = async (rootComponent, options) => {
 		globalThis.__LYNX_HYDRATE_PAGE__ = void 0;
 		globalThis.__LYNX_HYDRATE_QUEUE__ = void 0;
 	}
-	if (__WEB__ && __MAIN_THREAD__ && !wasHydrating) setTimeout(() => __FlushElementTree(), 0);
+	if (__WEB__ && !wasHydrating) setTimeout(() => __FlushElementTree(), 0);
 	return appRef;
 };
-export { BaseGesture, ComposedGesture, ContinuousGesture, FlingDirection, FlingGesture, Gesture, GestureState, GestureStateManager, GestureType, LYNX_ELEMENTS, LYNX_FORM_ACCESSORS, LongPressGesture, LynxAccessibility, LynxAnimation, LynxBlock, LynxBlurView, LynxCoverView, LynxDevTools, LynxErrorHandler, LynxExposure, LynxFont, LynxFor, LynxFrame, LynxGestureDetector, LynxGlobalData, LynxGlobalExposure, LynxIf, LynxImage, LynxInitData, LynxInlineTruncation, LynxInput, LynxInputValueAccessor, LynxList, LynxListItem, LynxLocale, LynxLocationStrategy, LynxLogger, LynxMainThread, LynxMainThreadEvent, LynxNativeModule, LynxOverlay, LynxPerformance, LynxPlatformLocation, LynxPortal, LynxRefresh, LynxRefreshHeader, LynxResourcePrefetch, LynxRouteReuseStrategy, LynxSafeArea, LynxScrollCoordinator, LynxScrollCoordinatorHeader, LynxScrollCoordinatorSlot, LynxScrollCoordinatorSlotDrag, LynxScrollCoordinatorToolbar, LynxScrollView, LynxSessionStorage, LynxSvg, LynxSystemInfo, LynxText, LynxTextMeasure, LynxTextarea, LynxTextareaValueAccessor, LynxTheme, LynxTitleBarView, LynxTransition, LynxTransitionGroup, LynxVideo, LynxView, LynxViewPager, LynxViewPagerItem, LynxWebView, MainThreadElement, MainThreadRef, PanGesture, PinchGesture, PortalRef, RotationGesture, SAFE_AREA_INSET_BOTTOM, SAFE_AREA_INSET_LEFT, SAFE_AREA_INSET_RIGHT, SAFE_AREA_INSET_TOP, TapGesture, backgroundFn, bootstrapApplication, createMainThreadRef, getLynxAppLocale, loadLazyBundle, mainThreadFn, provideLocale, provideRenderer, provideRouter, registerDataProcessors };
+export { BaseGesture, ComposedGesture, ContinuousGesture, FlingDirection, FlingGesture, Gesture, GestureState, GestureStateManager, GestureType, LYNX_ELEMENTS, LYNX_FORM_ACCESSORS, LongPressGesture, LynxAccessibility, LynxAccessibilitySettings, LynxAnimation, LynxBlock, LynxBlurView, LynxCoverView, LynxDevTools, LynxErrorHandler, LynxExposure, LynxFont, LynxFor, LynxFrame, LynxGestureDetector, LynxGlobalData, LynxGlobalExposure, LynxIf, LynxImage, LynxInitData, LynxInlineTruncation, LynxInput, LynxInputValueAccessor, LynxList, LynxListItem, LynxLocale, LynxLocationStrategy, LynxLogger, LynxMainThread, LynxMainThreadEvent, LynxNativeModule, LynxOverlay, LynxPerformance, LynxPlatformLocation, LynxPortal, LynxRefresh, LynxRefreshHeader, LynxResourcePrefetch, LynxRouteReuseStrategy, LynxRouterLinkActive, LynxSafeArea, LynxScrollCoordinator, LynxScrollCoordinatorHeader, LynxScrollCoordinatorSlot, LynxScrollCoordinatorSlotDrag, LynxScrollCoordinatorToolbar, LynxScrollView, LynxSessionStorage, LynxSvg, LynxSystemInfo, LynxText, LynxTextMeasure, LynxTextarea, LynxTextareaValueAccessor, LynxTheme, LynxTitleBarView, LynxTransition, LynxTransitionGroup, LynxVideo, LynxView, LynxViewPager, LynxViewPagerItem, LynxWebView, MainThreadElement, MainThreadRef, PanGesture, PinchGesture, PortalRef, RotationGesture, SAFE_AREA_INSET_BOTTOM, SAFE_AREA_INSET_LEFT, SAFE_AREA_INSET_RIGHT, SAFE_AREA_INSET_TOP, TapGesture, backgroundFn, bootstrapApplication, createMainThreadRef, getLynxAppLocale, loadLazyBundle, mainThreadFn, provideLocale, provideRenderer, provideRouter, registerDataProcessors, ɵhmrAccept, ɵstartBackgroundThread };
 
 //# sourceMappingURL=blotch-angular-lynx.mjs.map