@spcsn/taro-runtime 0.1.0

package/dist/runtime.esm.js

@@ -0,0 +1,3644 @@
+import { DEFAULT_COMPONENTS, EMPTY_OBJ, EventChannel, Events, Shortcuts, TT_SPECIFIC_COMPONENTS, controlledComponent, ensure, getComponentsAlias as getComponentsAlias$1, hooks, hooks as hooks$1, internalComponents, isArray, isEnableTTDom, isFunction, isNull, isNumber, isObject, isString, isUndefined, noop, toCamelCase, toDashed, warn } from "@spcsn/taro-shared";
+//#region src/constants/index.ts
+const PROPERTY_THRESHOLD = 2046;
+const TARO_RUNTIME = "Taro runtime";
+const HOOKS_APP_ID = "taro-app";
+const SET_DATA = "小程序 setData";
+const PAGE_INIT = "页面初始化";
+const ROOT_STR = "root";
+const HTML = "html";
+const HEAD = "head";
+const BODY = "body";
+const APP = "app";
+const CONTAINER = "container";
+const DOCUMENT_ELEMENT_NAME = "#document";
+const DOCUMENT_FRAGMENT = "document-fragment";
+const ID = "id";
+const UID = "uid";
+const CLASS = "class";
+const STYLE = "style";
+const FOCUS = "focus";
+const VIEW = "view";
+const STATIC_VIEW = "static-view";
+const PURE_VIEW = "pure-view";
+const CLICK_VIEW = "click-view";
+const PROPS = "props";
+const DATASET = "dataset";
+const OBJECT = "object";
+const VALUE = "value";
+const INPUT = "input";
+const CHANGE = "change";
+const CUSTOM_WRAPPER = "custom-wrapper";
+const TARGET = "target";
+const CURRENT_TARGET = "currentTarget";
+const TYPE = "type";
+const CONFIRM = "confirm";
+const TIME_STAMP = "timeStamp";
+const KEY_CODE = "keyCode";
+const TOUCHMOVE = "touchmove";
+const DATE = "Date";
+const SET_TIMEOUT = "setTimeout";
+const COMPILE_MODE = "compileMode";
+const CATCHMOVE = "catchMove";
+const CATCH_VIEW = "catch-view";
+const COMMENT = "comment";
+const ON_LOAD = "onLoad";
+const ON_READY = "onReady";
+const ON_SHOW = "onShow";
+const ON_HIDE = "onHide";
+const OPTIONS = "options";
+const EXTERNAL_CLASSES = "externalClasses";
+const EVENT_CALLBACK_RESULT = "e_result";
+const BEHAVIORS = "behaviors";
+const A = "a";
+let CONTEXT_ACTIONS = /* @__PURE__ */ function(CONTEXT_ACTIONS) {
+	CONTEXT_ACTIONS["INIT"] = "0";
+	CONTEXT_ACTIONS["RESTORE"] = "1";
+	CONTEXT_ACTIONS["RECOVER"] = "2";
+	CONTEXT_ACTIONS["DESTROY"] = "3";
+	return CONTEXT_ACTIONS;
+}({});
+//#endregion
+//#region src/dom-external/mutation-observer/implements.ts
+const observers = [];
+/**
+* The MutationObserver provides the ability
+* to watch for changes being made to the DOM tree.
+* It will invoke a specified callback function
+* when DOM changes occur.
+* @see https://dom.spec.whatwg.org/#mutationobserver
+* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+*/
+var MutationObserverImpl = class {
+	constructor(callback) {
+		this.records = [];
+		this.callback = callback;
+	}
+	/**
+	* Configures the MutationObserver
+	* to begin receiving notifications
+	* through its callback function
+	* when DOM changes matching the given options occur.
+	*
+	* Options matching is to be implemented.
+	*/
+	observe(target, options) {
+		this.disconnect();
+		this.target = target;
+		this.options = options || {};
+		observers.push(this);
+	}
+	/**
+	* Stop the MutationObserver instance
+	* from receiving further notifications
+	* until and unless observe() is called again.
+	*/
+	disconnect() {
+		this.target = null;
+		const index = observers.indexOf(this);
+		if (index >= 0) observers.splice(index, 1);
+	}
+	/**
+	* Removes all pending notifications
+	* from the MutationObserver's notification queue
+	* and returns them in a new Array of MutationRecord objects.
+	*/
+	takeRecords() {
+		return this.records.splice(0, this.records.length);
+	}
+};
+/** Match two TaroNodes by sid. */
+const sidMatches = (observerTarget, target) => {
+	return !!observerTarget && observerTarget.sid === target?.sid;
+};
+const isConcerned = (record, options) => {
+	const { characterData, characterDataOldValue, attributes, attributeOldValue, childList } = options;
+	switch (record.type) {
+		case "characterData":
+			if (characterData) {
+				if (!characterDataOldValue) record.oldValue = null;
+				return true;
+			}
+			return false;
+		case "attributes":
+			if (attributes) {
+				if (!attributeOldValue) record.oldValue = null;
+				return true;
+			}
+			return false;
+		case "childList":
+			if (childList) return true;
+			return false;
+	}
+};
+let pendingMuatations = false;
+function logMutation(observer, record) {
+	observer.records.push(record);
+	if (!pendingMuatations) {
+		pendingMuatations = true;
+		Promise.resolve().then(() => {
+			pendingMuatations = false;
+			observers.forEach((observer) => {
+				return observer.callback(observer.takeRecords());
+			});
+		});
+	}
+}
+function recordMutation(record) {
+	observers.forEach((observer) => {
+		const { options } = observer;
+		for (let t = record.target; t; t = t.parentNode) {
+			if (sidMatches(observer.target, t) && isConcerned(record, options)) {
+				logMutation(observer, record);
+				break;
+			}
+			if (!options.subtree) break;
+		}
+	});
+}
+//#endregion
+//#region src/dom-external/mutation-observer/index.ts
+var MutationObserver$1 = class {
+	constructor(callback) {
+		if (ENABLE_MUTATION_OBSERVER) this.core = new MutationObserverImpl(callback);
+		else {
+			console.warn("[Taro Warning] 若要使用 MutationObserver，请在 Taro 编译配置中设置 'mini.runtime.enableMutationObserver: true'");
+			this.core = {
+				observe: noop,
+				disconnect: noop,
+				takeRecords: noop
+			};
+		}
+	}
+	observe(...args) {
+		this.core.observe(...args);
+	}
+	disconnect() {
+		this.core.disconnect();
+	}
+	takeRecords() {
+		return this.core.takeRecords();
+	}
+	static record(record) {
+		recordMutation(record);
+	}
+};
+//#endregion
+//#region src/utils/lodash.ts
+function throttle(fn, threshold = 250, scope) {
+	let lastTime = 0;
+	let deferTimer;
+	return function(...args) {
+		const context = scope || this;
+		const now = Date.now();
+		if (now - lastTime > threshold) {
+			fn.apply(this, args);
+			lastTime = now;
+		} else {
+			clearTimeout(deferTimer);
+			deferTimer = setTimeout(() => {
+				lastTime = now;
+				fn.apply(context, args);
+			}, threshold);
+		}
+	};
+}
+function debounce(fn, ms = 250, scope) {
+	let timer;
+	return function(...args) {
+		const context = scope || this;
+		clearTimeout(timer);
+		timer = setTimeout(function() {
+			fn.apply(context, args);
+		}, ms);
+	};
+}
+//#endregion
+//#region src/emitter/emitter.ts
+const eventCenter = hooks$1.call("getEventCenter", Events);
+//#endregion
+//#region src/env.ts
+const env = {
+	window: process.env.TARO_PLATFORM === "web" ? window : EMPTY_OBJ,
+	document: process.env.TARO_PLATFORM === "web" ? document : EMPTY_OBJ
+};
+//#endregion
+//#region src/bom/getComputedStyle.ts
+const taroGetComputedStyleProvider = process.env.TARO_PLATFORM === "web" ? env.window.getComputedStyle : function(element) {
+	return element.style;
+};
+//#endregion
+//#region src/utils/cache.ts
+/**
+* 一个小型缓存池，用于在切换页面时，存储一些上下文信息
+*/
+var RuntimeCache = class {
+	constructor(name) {
+		this.cache = /* @__PURE__ */ new Map();
+		this.name = name;
+	}
+	has(identifier) {
+		return this.cache.has(identifier);
+	}
+	set(identifier, ctx) {
+		if (identifier && ctx) this.cache.set(identifier, ctx);
+	}
+	get(identifier) {
+		if (this.has(identifier)) return this.cache.get(identifier);
+	}
+	delete(identifier) {
+		this.cache.delete(identifier);
+	}
+};
+//#endregion
+//#region src/bom/history.ts
+const cache$1 = new RuntimeCache("history");
+var TaroHistory = class extends Events {
+	#location;
+	#stack = [];
+	#cur = 0;
+	#window;
+	constructor(location, options) {
+		super();
+		this.#window = options.window;
+		this.#location = location;
+		this.#location.on("__record_history__", (href) => {
+			this.#cur++;
+			this.#stack = this.#stack.slice(0, this.#cur);
+			this.#stack.push({
+				state: null,
+				title: "",
+				url: href
+			});
+		}, null);
+		this.#location.on("__reset_history__", (href) => {
+			this.#reset(href);
+		}, null);
+		this.on("0", () => {
+			this.#reset();
+		}, null);
+		this.on("1", (pageId) => {
+			cache$1.set(pageId, {
+				location: this.#location,
+				stack: this.#stack.slice(),
+				cur: this.#cur
+			});
+		}, null);
+		this.on("2", (pageId) => {
+			if (cache$1.has(pageId)) {
+				const ctx = cache$1.get(pageId);
+				this.#location = ctx.location;
+				this.#stack = ctx.stack;
+				this.#cur = ctx.cur;
+			}
+		}, null);
+		this.on("3", (pageId) => {
+			cache$1.delete(pageId);
+		}, null);
+		this.#reset();
+	}
+	#reset(href = "") {
+		this.#stack = [{
+			state: null,
+			title: "",
+			url: href || this.#location.href
+		}];
+		this.#cur = 0;
+	}
+	get length() {
+		return this.#stack.length;
+	}
+	get state() {
+		return this.#stack[this.#cur].state;
+	}
+	go(delta) {
+		if (!isNumber(delta) || isNaN(delta)) return;
+		let targetIdx = this.#cur + delta;
+		targetIdx = Math.min(Math.max(targetIdx, 0), this.length - 1);
+		this.#cur = targetIdx;
+		this.#location.trigger("__set_href_without_history__", this.#stack[this.#cur].url);
+		this.#window.trigger("popstate", this.#stack[this.#cur]);
+	}
+	back() {
+		this.go(-1);
+	}
+	forward() {
+		this.go(1);
+	}
+	pushState(state, title, url) {
+		if (!url || !isString(url)) return;
+		this.#stack = this.#stack.slice(0, this.#cur + 1);
+		this.#stack.push({
+			state,
+			title,
+			url
+		});
+		this.#cur = this.length - 1;
+		this.#location.trigger("__set_href_without_history__", url);
+	}
+	replaceState(state, title, url) {
+		if (!url || !isString(url)) return;
+		this.#stack[this.#cur] = {
+			state,
+			title,
+			url
+		};
+		this.#location.trigger("__set_href_without_history__", url);
+	}
+	get cache() {
+		return cache$1;
+	}
+};
+const History = process.env.TARO_PLATFORM === "web" ? env.window.History : TaroHistory;
+//#endregion
+//#region src/current.ts
+const Current = {
+	app: null,
+	router: null,
+	page: null
+};
+const getCurrentInstance = () => Current;
+//#endregion
+//#region src/bom/URLSearchParams.ts
+const findReg = /[!'()~]|%20|%00/g;
+const plusReg = /\+/g;
+const replaceCharMap = {
+	"!": "%21",
+	"'": "%27",
+	"(": "%28",
+	")": "%29",
+	"~": "%7E",
+	"%20": "+",
+	"%00": "\0"
+};
+function replacer(match) {
+	return replaceCharMap[match];
+}
+function appendTo(dict, name, value) {
+	const res = isArray(value) ? value.join(",") : value;
+	if (name in dict) dict[name].push(res);
+	else dict[name] = [res];
+}
+function addEach(value, key) {
+	appendTo(this, key, value);
+}
+function decode(str) {
+	return decodeURIComponent(str.replace(plusReg, " "));
+}
+function encode(str) {
+	return encodeURIComponent(str).replace(findReg, replacer);
+}
+const URLSearchParams = process.env.TARO_PLATFORM === "web" ? env.window.URLSearchParams : class {
+	#dict = Object.create(null);
+	constructor(query) {
+		query ??= "";
+		const dict = this.#dict;
+		if (typeof query === "string") {
+			if (query.charAt(0) === "?") query = query.slice(1);
+			for (let pairs = query.split("&"), i = 0, length = pairs.length; i < length; i++) {
+				const value = pairs[i];
+				const index = value.indexOf("=");
+				try {
+					if (index > -1) appendTo(dict, decode(value.slice(0, index)), decode(value.slice(index + 1)));
+					else if (value.length) appendTo(dict, decode(value), "");
+				} catch (err) {
+					console.warn(`[Taro warn] URL 参数 ${value} decode 异常`);
+				}
+			}
+		} else if (isArray(query)) for (let i = 0, length = query.length; i < length; i++) {
+			const value = query[i];
+			appendTo(dict, value[0], value[1]);
+		}
+		else if (query.forEach) query.forEach(addEach, dict);
+		else for (const key in query) appendTo(dict, key, query[key]);
+	}
+	append(name, value) {
+		appendTo(this.#dict, name, value);
+	}
+	delete(name) {
+		delete this.#dict[name];
+	}
+	get(name) {
+		const dict = this.#dict;
+		return name in dict ? dict[name][0] : null;
+	}
+	getAll(name) {
+		const dict = this.#dict;
+		return name in dict ? dict[name].slice(0) : [];
+	}
+	has(name) {
+		return name in this.#dict;
+	}
+	keys() {
+		return Object.keys(this.#dict);
+	}
+	set(name, value) {
+		this.#dict[name] = ["" + value];
+	}
+	forEach(callback, thisArg) {
+		const dict = this.#dict;
+		Object.getOwnPropertyNames(dict).forEach(function(name) {
+			dict[name].forEach(function(value) {
+				callback.call(thisArg, value, name, this);
+			}, this);
+		}, this);
+	}
+	toJSON() {
+		return {};
+	}
+	toString() {
+		const dict = this.#dict;
+		const query = [];
+		for (const key in dict) {
+			const name = encode(key);
+			for (let i = 0, value = dict[key]; i < value.length; i++) query.push(name + "=" + encode(value[i]));
+		}
+		return query.join("&");
+	}
+};
+//#endregion
+//#region src/bom/URL.ts
+var TaroURL = class {
+	static createObjectURL() {
+		throw new Error("Oops, not support URL.createObjectURL() in miniprogram.");
+	}
+	static revokeObjectURL() {
+		throw new Error("Oops, not support URL.revokeObjectURL() in miniprogram.");
+	}
+	#hash = "";
+	#hostname = "";
+	#pathname = "";
+	#port = "";
+	#protocol = "";
+	#search;
+	constructor(url, base) {
+		if (!isString(url)) url = String(url);
+		const { hash, hostname, pathname, port, protocol, search } = parseUrlBase(url, base);
+		this.#hash = hash;
+		this.#hostname = hostname;
+		this.#pathname = pathname || "/";
+		this.#port = port;
+		this.#protocol = protocol;
+		this.#search = new URLSearchParams(search);
+	}
+	get protocol() {
+		return this.#protocol;
+	}
+	set protocol(val) {
+		isString(val) && (this.#protocol = val.trim());
+	}
+	get host() {
+		return this.hostname + (this.port ? ":" + this.port : "");
+	}
+	set host(val) {
+		if (val && isString(val)) {
+			val = val.trim();
+			const { hostname, port } = parseUrl(`//${val}`);
+			this.hostname = hostname;
+			this.port = port;
+		}
+	}
+	get hostname() {
+		return this.#hostname;
+	}
+	set hostname(val) {
+		val && isString(val) && (this.#hostname = val.trim());
+	}
+	get port() {
+		return this.#port;
+	}
+	set port(val) {
+		isString(val) && (this.#port = val.trim());
+	}
+	get pathname() {
+		return this.#pathname;
+	}
+	set pathname(val) {
+		if (isString(val)) {
+			val = val.trim();
+			const HEAD_REG = /^(\/|\.\/|\.\.\/)/;
+			let temp = val;
+			while (HEAD_REG.test(temp)) temp = temp.replace(HEAD_REG, "");
+			if (temp) this.#pathname = "/" + temp;
+			else this.#pathname = "/";
+		}
+	}
+	get search() {
+		const val = this.#search.toString();
+		return val.length === 0 || val.startsWith("?") ? val : `?${val}`;
+	}
+	set search(val) {
+		if (isString(val)) {
+			val = val.trim();
+			this.#search = new URLSearchParams(val);
+		}
+	}
+	get hash() {
+		return this.#hash;
+	}
+	set hash(val) {
+		if (isString(val)) {
+			val = val.trim();
+			if (val) this.#hash = val.startsWith("#") ? val : `#${val}`;
+			else this.#hash = "";
+		}
+	}
+	get href() {
+		return `${this.protocol}//${this.host}${this.pathname}${this.search}${this.hash}`;
+	}
+	set href(val) {
+		if (val && isString(val)) {
+			val = val.trim();
+			const { protocol, hostname, port, hash, search, pathname } = parseUrl(val);
+			this.protocol = protocol;
+			this.hostname = hostname;
+			this.pathname = pathname;
+			this.port = port;
+			this.hash = hash;
+			this.search = search;
+		}
+	}
+	get origin() {
+		return `${this.protocol}//${this.host}`;
+	}
+	set origin(val) {
+		if (val && isString(val)) {
+			val = val.trim();
+			const { protocol, hostname, port } = parseUrl(val);
+			this.protocol = protocol;
+			this.hostname = hostname;
+			this.port = port;
+		}
+	}
+	get searchParams() {
+		return this.#search;
+	}
+	toString() {
+		return this.href;
+	}
+	toJSON() {
+		return this.toString();
+	}
+	_toRaw() {
+		return {
+			protocol: this.protocol,
+			port: this.port,
+			host: this.host,
+			hostname: this.hostname,
+			pathname: this.pathname,
+			hash: this.hash,
+			search: this.search,
+			origin: this.origin,
+			href: this.href
+		};
+	}
+};
+const TaroURLProvider = process.env.TARO_PLATFORM === "web" ? env.window.URL : TaroURL;
+function parseUrl(url = "") {
+	const result = {
+		href: "",
+		origin: "",
+		protocol: "",
+		hostname: "",
+		host: "",
+		port: "",
+		pathname: "",
+		search: "",
+		hash: ""
+	};
+	if (!url || !isString(url)) return result;
+	url = url.trim();
+	const matches = url.match(/^(([^:/?#]+):)?\/\/(([^/?#]+):(.+)@)?([^/?#:]*)(:(\d+))?([^?#]*)(\?([^#]*))?(#(.*))?/);
+	if (!matches) return result;
+	result.protocol = matches[1] || "https:";
+	result.hostname = matches[6] || "taro.com";
+	result.port = matches[8] || "";
+	result.pathname = matches[9] || "/";
+	result.search = matches[10] || "";
+	result.hash = matches[12] || "";
+	result.href = url;
+	result.origin = result.protocol + "//" + result.hostname + (result.port ? `:${result.port}` : "");
+	result.host = result.hostname + (result.port ? `:${result.port}` : "");
+	return result;
+}
+function parseUrlBase(url, base) {
+	const VALID_URL = /^(https?:)\/\//i;
+	let fullUrl = "";
+	let parsedBase = null;
+	if (!isUndefined(base)) {
+		base = String(base).trim();
+		if (!VALID_URL.test(base)) throw new TypeError(`Failed to construct 'URL': Invalid base URL`);
+		parsedBase = parseUrl(base);
+	}
+	url = String(url).trim();
+	if (VALID_URL.test(url)) fullUrl = url;
+	else if (parsedBase) if (url) if (url.startsWith("//")) fullUrl = parsedBase.protocol + url;
+	else fullUrl = parsedBase.origin + (url.startsWith("/") ? url : `/${url}`);
+	else fullUrl = parsedBase.href;
+	else throw new TypeError(`Failed to construct 'URL': Invalid URL`);
+	return parseUrl(fullUrl);
+}
+//#endregion
+//#region src/bom/location.ts
+const INIT_URL = "https://taro.com";
+const cache = new RuntimeCache("location");
+var TaroLocation = class extends Events {
+	#url = new TaroURLProvider(INIT_URL);
+	#noCheckUrl = false;
+	#window;
+	constructor(options) {
+		super();
+		this.#window = options.window;
+		this.#reset();
+		this.on("__set_href_without_history__", (href) => {
+			this.#noCheckUrl = true;
+			const lastHash = this.#url.hash;
+			this.#url.href = generateFullUrl(href);
+			if (lastHash !== this.#url.hash) this.#window.trigger("hashchange");
+			this.#noCheckUrl = false;
+		}, null);
+		this.on("0", () => {
+			this.#reset();
+		}, null);
+		this.on("1", (pageId) => {
+			cache.set(pageId, { lastHref: this.href });
+		}, null);
+		this.on("2", (pageId) => {
+			if (cache.has(pageId)) {
+				const ctx = cache.get(pageId);
+				this.#noCheckUrl = true;
+				this.#url.href = ctx.lastHref;
+				this.#noCheckUrl = false;
+			}
+		}, null);
+		this.on("3", (pageId) => {
+			cache.delete(pageId);
+		}, null);
+	}
+	#reset() {
+		const router = getCurrentInstance().router;
+		if (router) {
+			const { path, params } = router;
+			const searchArr = Object.keys(params).map((key) => {
+				return `${key}=${params[key]}`;
+			});
+			const searchStr = searchArr.length > 0 ? "?" + searchArr.join("&") : "";
+			const url = `${INIT_URL}${path.startsWith("/") ? path : "/" + path}${searchStr}`;
+			this.#url = new TaroURLProvider(url);
+			this.trigger("__reset_history__", this.href);
+		}
+	}
+	#getPreValue() {
+		return this.#url._toRaw();
+	}
+	#rollBack(href) {
+		this.#url.href = href;
+	}
+	#recordHistory() {
+		this.trigger("__record_history__", this.href);
+	}
+	/**
+	* 校验url的变化，是否需要更新history
+	*/
+	#checkUrlChange(preValue) {
+		if (this.#noCheckUrl) return false;
+		const { protocol, hostname, port, pathname, search, hash } = this.#url._toRaw();
+		if (protocol !== preValue.protocol || hostname !== preValue.hostname || port !== preValue.port) {
+			this.#rollBack(preValue.href);
+			return false;
+		}
+		if (pathname !== preValue.pathname) return true;
+		if (search !== preValue.search) return true;
+		if (hash !== preValue.hash) {
+			this.#window.trigger("hashchange");
+			return true;
+		}
+		this.#rollBack(preValue.href);
+		return false;
+	}
+	get protocol() {
+		return this.#url.protocol;
+	}
+	set protocol(val) {
+		if (!val || !isString(val) || !/^(http|https):$/i.test(val.trim())) return;
+		val = val.trim();
+		const preValue = this.#getPreValue();
+		this.#url.protocol = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	get host() {
+		return this.#url.host;
+	}
+	set host(val) {
+		if (!val || !isString(val)) return;
+		val = val.trim();
+		const preValue = this.#getPreValue();
+		this.#url.host = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	get hostname() {
+		return this.#url.hostname;
+	}
+	set hostname(val) {
+		if (!val || !isString(val)) return;
+		val = val.trim();
+		const preValue = this.#getPreValue();
+		this.#url.hostname = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	get port() {
+		return this.#url.port;
+	}
+	set port(val) {
+		const xVal = Number(val = val.trim());
+		if (!isNumber(xVal) || xVal <= 0) return;
+		const preValue = this.#getPreValue();
+		this.#url.port = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	get pathname() {
+		return this.#url.pathname;
+	}
+	set pathname(val) {
+		if (!val || !isString(val)) return;
+		val = val.trim();
+		const preValue = this.#getPreValue();
+		this.#url.pathname = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	get search() {
+		return this.#url.search;
+	}
+	set search(val) {
+		if (!val || !isString(val)) return;
+		val = val.trim();
+		val = val.startsWith("?") ? val : `?${val}`;
+		const preValue = this.#getPreValue();
+		this.#url.search = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	get hash() {
+		return this.#url.hash;
+	}
+	set hash(val) {
+		if (!val || !isString(val)) return;
+		val = val.trim();
+		val = val.startsWith("#") ? val : `#${val}`;
+		const preValue = this.#getPreValue();
+		this.#url.hash = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	get href() {
+		return this.#url.href;
+	}
+	set href(val) {
+		if (!val || !isString(val) || !/^(http:|https:)?\/\/.+/.test(val = val.trim())) return;
+		const preValue = this.#getPreValue();
+		this.#url.href = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	get origin() {
+		return this.#url.origin;
+	}
+	set origin(val) {
+		if (!val || !isString(val) || !/^(http:|https:)?\/\/.+/.test(val = val.trim())) return;
+		const preValue = this.#getPreValue();
+		this.#url.origin = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	assign() {
+		warn(true, "小程序环境中调用location.assign()无效.");
+	}
+	reload() {
+		warn(true, "小程序环境中调用location.reload()无效.");
+	}
+	replace(url) {
+		this.trigger("__set_href_without_history__", url);
+	}
+	toString() {
+		return this.href;
+	}
+	get cache() {
+		return cache;
+	}
+};
+const Location = process.env.TARO_PLATFORM === "web" ? env.window.Location : TaroLocation;
+function generateFullUrl(val = "") {
+	const origin = INIT_URL;
+	if (/^[/?#]/.test(val)) return origin + val;
+	return val;
+}
+//#endregion
+//#region src/bom/navigator.ts
+const msg = "(Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/534.36 (KHTML, like Gecko) NodeJS/v4.1.0 Chrome/76.0.3809.132 Safari/534.36";
+const nav = process.env.TARO_PLATFORM === "web" ? env.window.navigator : {
+	appCodeName: "Mozilla",
+	appName: "Netscape",
+	appVersion: "5.0 " + msg,
+	cookieEnabled: true,
+	mimeTypes: [],
+	onLine: true,
+	platform: "MacIntel",
+	plugins: [],
+	product: "Taro",
+	productSub: "20030107",
+	userAgent: "Mozilla/5.0 " + msg,
+	vendor: "Joyent",
+	vendorSub: ""
+};
+//#endregion
+//#region src/bom/raf.ts
+let now;
+(function() {
+	let loadTime;
+	if (typeof performance !== "undefined" && performance !== null && performance.now) now = () => performance.now();
+	else if (Date.now) {
+		loadTime = Date.now();
+		now = () => Date.now() - loadTime;
+	} else {
+		loadTime = (/* @__PURE__ */ new Date()).getTime();
+		now = () => (/* @__PURE__ */ new Date()).getTime() - loadTime;
+	}
+})();
+let lastTime = 0;
+const _raf = process.env.TARO_PLATFORM === "web" ? requestAnimationFrame : function(callback) {
+	const _now = now();
+	const nextTime = Math.max(lastTime + 16, _now);
+	return setTimeout(function() {
+		callback(lastTime = nextTime);
+	}, nextTime - _now);
+};
+const _caf = process.env.TARO_PLATFORM === "web" ? cancelAnimationFrame : function(seed) {
+	clearTimeout(seed);
+};
+//#endregion
+//#region src/bom/window.ts
+var TaroWindow = class extends Events {
+	constructor() {
+		super();
+		this.navigator = nav;
+		this.requestAnimationFrame = _raf;
+		this.cancelAnimationFrame = _caf;
+		this.getComputedStyle = taroGetComputedStyleProvider;
+		[...Object.getOwnPropertyNames(global || {}), ...Object.getOwnPropertySymbols(global || {})].forEach((property) => {
+			if (property === "atob" || property === "document") return;
+			if (!Object.prototype.hasOwnProperty.call(this, property)) try {
+				this[property] = global[property];
+			} catch (e) {
+				console.warn(`[Taro warn] window.${String(property)} 在赋值到 window 时报错`);
+			}
+		});
+		this.Date ||= Date;
+		this.location = new Location({ window: this });
+		this.history = new History(this.location, { window: this });
+		this.initEvent();
+	}
+	initEvent() {
+		const _location = this.location;
+		const _history = this.history;
+		this.on("0", (pageId) => {
+			_location.trigger("0", pageId);
+		}, null);
+		this.on("2", (pageId) => {
+			_location.trigger("2", pageId);
+			_history.trigger("2", pageId);
+		}, null);
+		this.on("1", (pageId) => {
+			_location.trigger("1", pageId);
+			_history.trigger("1", pageId);
+		}, null);
+		this.on("3", (pageId) => {
+			_location.trigger("3", pageId);
+			_history.trigger("3", pageId);
+		}, null);
+	}
+	get document() {
+		return env.document;
+	}
+	addEventListener(event, callback) {
+		if (!isString(event)) return;
+		this.on(event, callback, null);
+	}
+	removeEventListener(event, callback) {
+		if (!isString(event)) return;
+		this.off(event, callback, null);
+	}
+	setTimeout(...args) {
+		return setTimeout(...args);
+	}
+	clearTimeout(...args) {
+		return clearTimeout(...args);
+	}
+};
+const taroWindowProvider = process.env.TARO_PLATFORM === "web" ? env.window : env.window = new TaroWindow();
+const taroLocationProvider = taroWindowProvider.location;
+const taroHistoryProvider = taroWindowProvider.history;
+//#endregion
+//#region src/utils/router.ts
+const addLeadingSlash = (url = "") => url.charAt(0) === "/" ? url : "/" + url;
+const hasBasename = (path = "", prefix = "") => new RegExp("^" + prefix + "(\\/|\\?|#|$)", "i").test(path) || path === prefix;
+const stripBasename = (path = "", prefix = "") => hasBasename(path, prefix) ? path.substring(prefix.length) : path;
+const stripTrailing = (str = "") => str.replace(/[?#][\s\S]*$/, "");
+const stripSuffix = (path = "", suffix = "") => path.includes(suffix) ? path.substring(0, path.length - suffix.length) : path;
+const getHomePage = (path = "", basename = "", customRoutes = {}, entryPagePath = "") => {
+	const routePath = addLeadingSlash(stripBasename(path, basename));
+	const alias = Object.entries(customRoutes).find(([key]) => key === routePath)?.[1] || routePath;
+	return entryPagePath || (typeof alias === "string" ? alias : alias[0]) || basename;
+};
+const getCurrentPage = (routerMode = "hash", basename = "/") => {
+	return addLeadingSlash(stripBasename(routerMode === "hash" ? taroLocationProvider.hash.slice(1).split("?")[0] : taroLocationProvider.pathname, basename));
+};
+//#endregion
+//#region src/utils/index.ts
+const incrementId = () => {
+	const chatCodes = [];
+	for (let i = 65; i <= 90; i++) chatCodes.push(i);
+	for (let i = 97; i <= 122; i++) chatCodes.push(i);
+	const chatCodesLen = chatCodes.length - 1;
+	const list = [0, 0];
+	return () => {
+		const target = list.map((item) => chatCodes[item]);
+		const res = String.fromCharCode(...target);
+		let tailIdx = list.length - 1;
+		list[tailIdx]++;
+		while (list[tailIdx] > chatCodesLen) {
+			list[tailIdx] = 0;
+			tailIdx = tailIdx - 1;
+			if (tailIdx < 0) {
+				list.push(0);
+				break;
+			}
+			list[tailIdx]++;
+		}
+		return res;
+	};
+};
+function isElement(node) {
+	return node.nodeType === 1;
+}
+function isText(node) {
+	return node.nodeType === 3;
+}
+function isComment(node) {
+	return node.nodeName === COMMENT;
+}
+function isHasExtractProp(el) {
+	const res = Object.keys(el.props).find((prop) => {
+		return !(/^(class|style|id)$/.test(prop) || prop.startsWith("data-"));
+	});
+	return Boolean(res);
+}
+/**
+* 往上寻找组件树直到 root，寻找是否有祖先组件绑定了同类型的事件
+* @param node 当前组件
+* @param type 事件类型
+*/
+function isParentBound(node, type) {
+	while (node = node?.parentElement || null) if (!node || node.nodeName === "root" || node.nodeName === "root-portal") return false;
+	else if (node.__handlers[type]?.length) return true;
+	return false;
+}
+function shortcutAttr(key) {
+	switch (key) {
+		case STYLE: return Shortcuts.Style;
+		case "id": return "uid";
+		case CLASS: return Shortcuts.Class;
+		default: return key;
+	}
+}
+const customWrapperCache = /* @__PURE__ */ new Map();
+function extend(ctor, methodName, options) {
+	if (isFunction(options)) options = { value: options };
+	Object.defineProperty(ctor.prototype, methodName, {
+		configurable: true,
+		enumerable: true,
+		...options
+	});
+}
+let componentsAlias$1;
+function getComponentsAlias() {
+	if (!componentsAlias$1) componentsAlias$1 = getComponentsAlias$1(internalComponents);
+	return componentsAlias$1;
+}
+function convertNumber2PX(value) {
+	return value + "px";
+}
+//#endregion
+//#region src/dom/class-list.ts
+var ClassList = class {
+	constructor(className, el) {
+		this.tokenList = [];
+		this.el = el;
+		className.trim().split(/\s+/).forEach((token) => this.tokenList.push(token));
+	}
+	get value() {
+		return this.toString();
+	}
+	get length() {
+		return this.tokenList.length;
+	}
+	add() {
+		let index = 0;
+		let updated = false;
+		const tokens = arguments;
+		const length = tokens.length;
+		const tokenList = this.tokenList;
+		do {
+			const token = tokens[index];
+			if (this.checkTokenIsValid(token) && !~tokenList.indexOf(token)) {
+				tokenList.push(token);
+				updated = true;
+			}
+		} while (++index < length);
+		if (updated) this._update();
+	}
+	remove() {
+		let i = 0;
+		let updated = false;
+		const tokens = arguments;
+		const length = tokens.length;
+		const tokenList = this.tokenList;
+		do {
+			const token = tokens[i] + "";
+			if (!this.checkTokenIsValid(token)) continue;
+			const index = tokenList.indexOf(token);
+			if (~tokenList.indexOf(token)) {
+				tokenList.splice(index, 1);
+				updated = true;
+			}
+		} while (++i < length);
+		if (updated) this._update();
+	}
+	contains(token) {
+		if (!this.checkTokenIsValid(token)) return false;
+		return !!~this.tokenList.indexOf(token);
+	}
+	toggle(token, force) {
+		const result = this.contains(token);
+		const method = result ? force !== true && "remove" : force !== false && "add";
+		if (method) this[method](token);
+		if (force === true || force === false) return force;
+		else return !result;
+	}
+	replace(token, replacement_token) {
+		if (!this.checkTokenIsValid(token) || !this.checkTokenIsValid(replacement_token)) return;
+		const index = this.tokenList.indexOf(token);
+		if (~index) {
+			this.tokenList.splice(index, 1, replacement_token);
+			this._update();
+		}
+	}
+	toString() {
+		return this.tokenList.filter((v) => v !== "").join(" ");
+	}
+	checkTokenIsValid(token) {
+		if (token === "" || /\s/.test(token)) return false;
+		return true;
+	}
+	_update() {
+		this.el.className = this.value;
+	}
+};
+//#endregion
+//#region src/dom/event-source.ts
+var EventSource = class extends Map {
+	removeNode(child) {
+		const { sid, uid } = child;
+		this.delete(sid);
+		if (uid !== sid && uid) this.delete(uid);
+	}
+	removeNodeTree(child) {
+		this.removeNode(child);
+		const { childNodes } = child;
+		childNodes.forEach((node) => this.removeNodeTree(node));
+	}
+};
+const eventSource = new EventSource();
+//#endregion
+//#region src/hydrate.ts
+let SPECIAL_NODES;
+let componentsAlias;
+/**
+* React also has a fancy function's name for this: `hydrate()`.
+* You may have been heard `hydrate` as a SSR-related function,
+* actually, `hydrate` basicly do the `render()` thing, but ignore some properties,
+* it's a vnode traverser and modifier: that's exactly what Taro's doing in here.
+*/
+function hydrate(node) {
+	componentsAlias ||= getComponentsAlias();
+	SPECIAL_NODES ||= hooks$1.call("getSpecialNodes");
+	const nodeName = node.nodeName;
+	let compileModeName = null;
+	if (isText(node)) return {
+		sid: node.sid,
+		[Shortcuts.Text]: node.nodeValue,
+		[Shortcuts.NodeName]: componentsAlias[nodeName]?._num || "8"
+	};
+	const data = {
+		[Shortcuts.NodeName]: nodeName,
+		sid: node.sid
+	};
+	if (node.uid !== node.sid) data.uid = node.uid;
+	if (SPECIAL_NODES.indexOf(nodeName) > -1) {
+		if (!node.isAnyEventBinded()) {
+			data[Shortcuts.NodeName] = `static-${nodeName}`;
+			if (nodeName === "view" && !isHasExtractProp(node)) data[Shortcuts.NodeName] = PURE_VIEW;
+		}
+		if (nodeName === "view" && node.isOnlyClickBinded() && !isHasExtractProp(node)) data[Shortcuts.NodeName] = CLICK_VIEW;
+	}
+	const { props } = node;
+	for (const prop in props) {
+		const propInCamelCase = toCamelCase(prop);
+		if (!prop.startsWith("data-") && prop !== "class" && prop !== "style" && prop !== "id" && propInCamelCase !== "catchMove" && propInCamelCase !== "compileMode") data[propInCamelCase] = props[prop];
+		if (process.env.TARO_ENV !== "swan" && nodeName === "view" && propInCamelCase === "catchMove" && props[prop] !== false) data[Shortcuts.NodeName] = CATCH_VIEW;
+		if (propInCamelCase === "compileMode") compileModeName = props[prop];
+	}
+	data[Shortcuts.Childnodes] = node.childNodes.filter((node) => !isComment(node)).map(hydrate);
+	if (node.className !== "") data[Shortcuts.Class] = node.className;
+	const cssText = node.cssText;
+	if (cssText !== "" && nodeName !== "swiper-item") data[Shortcuts.Style] = cssText;
+	hooks$1.call("modifyHydrateData", data, node);
+	const nn = data[Shortcuts.NodeName];
+	const componentAlias = componentsAlias[nn];
+	if (componentAlias) {
+		data[Shortcuts.NodeName] = componentAlias._num;
+		for (const prop in data) if (prop in componentAlias) {
+			data[componentAlias[prop]] = data[prop];
+			delete data[prop];
+		}
+	}
+	if (compileModeName !== null) data[Shortcuts.NodeName] = compileModeName;
+	return hooks$1.call("transferHydrateData", data, node, componentAlias) || data;
+}
+//#endregion
+//#region src/dom/event-target.ts
+var TaroEventTarget = class {
+	constructor() {
+		this.__handlers = {};
+	}
+	addEventListener(type, handler, options) {
+		type = type.toLowerCase();
+		hooks$1.call("onAddEvent", type, handler, options, this);
+		if (type === "regionchange") {
+			this.addEventListener("begin", handler, options);
+			this.addEventListener("end", handler, options);
+			return;
+		}
+		let isCapture = Boolean(options);
+		let isOnce = false;
+		if (isObject(options)) {
+			isCapture = Boolean(options.capture);
+			isOnce = Boolean(options.once);
+		}
+		if (isOnce) {
+			const wrapper = function() {
+				handler.apply(this, arguments);
+				this.removeEventListener(type, wrapper);
+			};
+			this.addEventListener(type, wrapper, {
+				...options,
+				once: false
+			});
+			return;
+		}
+		warn(isCapture, "Taro 暂未实现 event 的 capture 特性。");
+		const oldHandler = handler;
+		handler = function() {
+			return oldHandler.apply(this, arguments);
+		};
+		handler.oldHandler = oldHandler;
+		const handlers = this.__handlers[type];
+		if (isArray(handlers)) handlers.push(handler);
+		else this.__handlers[type] = [handler];
+	}
+	removeEventListener(type, handler) {
+		type = type.toLowerCase();
+		if (type === "regionchange") {
+			this.removeEventListener("begin", handler);
+			this.removeEventListener("end", handler);
+			return;
+		}
+		if (!handler) return;
+		const handlers = this.__handlers[type];
+		if (!isArray(handlers)) return;
+		const index = handlers.findIndex((item) => {
+			if (item === handler || item.oldHandler === handler) return true;
+		});
+		warn(index === -1, `事件: '${type}' 没有注册在 DOM 中，因此不会被移除。`);
+		handlers.splice(index, 1);
+	}
+	isAnyEventBinded() {
+		const handlers = this.__handlers;
+		const isAnyEventBinded = Object.keys(handlers).find((key) => handlers[key].length);
+		return Boolean(isAnyEventBinded);
+	}
+	isOnlyClickBinded() {
+		const handlers = this.__handlers;
+		const isOnlyClickBinded = handlers.tap && Object.keys(handlers).length === 1;
+		return Boolean(isOnlyClickBinded);
+	}
+};
+//#endregion
+//#region src/dom/node.ts
+const CHILDNODES = Shortcuts.Childnodes;
+const nodeId = incrementId();
+var TaroNode = class TaroNode extends TaroEventTarget {
+	constructor() {
+		super();
+		this.parentNode = null;
+		this.childNodes = [];
+		this.hydrate = (node) => () => hydrate(node);
+		this.uid = "_" + nodeId();
+		this.sid = this.uid;
+		eventSource.set(this.sid, this);
+	}
+	updateChildNodes(isClean) {
+		const cleanChildNodes = () => [];
+		const rerenderChildNodes = () => {
+			return this.childNodes.filter((node) => !isComment(node)).map(hydrate);
+		};
+		this.enqueueUpdate({
+			path: `${this._path}.${CHILDNODES}`,
+			value: isClean ? cleanChildNodes : rerenderChildNodes
+		});
+	}
+	updateSingleChild(index) {
+		this.childNodes.forEach((child, childIndex) => {
+			if (isComment(child)) return;
+			if (index && childIndex < index) return;
+			this.enqueueUpdate({
+				path: child._path,
+				value: this.hydrate(child)
+			});
+		});
+	}
+	get _root() {
+		return this.parentNode?._root || null;
+	}
+	findIndex(refChild) {
+		const index = this.childNodes.indexOf(refChild);
+		ensure(index !== -1, "The node to be replaced is not a child of this node.");
+		return index;
+	}
+	get _path() {
+		const parentNode = this.parentNode;
+		if (parentNode) {
+			const indexOfNode = parentNode.childNodes.filter((node) => !isComment(node)).indexOf(this);
+			const index = hooks$1.call("getPathIndex", indexOfNode);
+			return `${parentNode._path}.${CHILDNODES}.${index}`;
+		}
+		return "";
+	}
+	get nextSibling() {
+		const parentNode = this.parentNode;
+		return parentNode?.childNodes[parentNode.findIndex(this) + 1] || null;
+	}
+	get previousSibling() {
+		const parentNode = this.parentNode;
+		return parentNode?.childNodes[parentNode.findIndex(this) - 1] || null;
+	}
+	get parentElement() {
+		const parentNode = this.parentNode;
+		if (parentNode?.nodeType === 1) return parentNode;
+		return null;
+	}
+	get firstChild() {
+		return this.childNodes[0] || null;
+	}
+	get lastChild() {
+		const childNodes = this.childNodes;
+		return childNodes[childNodes.length - 1] || null;
+	}
+	/**
+	* @textContent 目前只能置空子元素
+	* @TODO 等待完整 innerHTML 实现
+	*/
+	set textContent(text) {
+		const removedNodes = this.childNodes.slice();
+		const addedNodes = [];
+		while (this.firstChild) this.removeChild(this.firstChild, { doUpdate: false });
+		if (text === "") this.updateChildNodes(true);
+		else {
+			const newText = env.document.createTextNode(text);
+			addedNodes.push(newText);
+			this.appendChild(newText);
+			this.updateChildNodes();
+		}
+		MutationObserver$1.record({
+			type: "childList",
+			target: this,
+			removedNodes,
+			addedNodes
+		});
+	}
+	/**
+	* @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/insertBefore
+	* @scenario
+	* [A,B,C]
+	*   1. insert D before C, D has no parent
+	*   2. insert D before C, D has the same parent of C
+	*   3. insert D before C, D has the different parent of C
+	*/
+	insertBefore(newChild, refChild, isReplace) {
+		if (newChild.nodeName === "document-fragment") {
+			newChild.childNodes.reduceRight((previousValue, currentValue) => {
+				this.insertBefore(currentValue, previousValue);
+				return currentValue;
+			}, refChild);
+			return newChild;
+		}
+		newChild.remove({ cleanRef: false });
+		let index = 0;
+		newChild.parentNode = this;
+		if (refChild) {
+			index = this.findIndex(refChild);
+			this.childNodes.splice(index, 0, newChild);
+		} else this.childNodes.push(newChild);
+		const childNodesLength = this.childNodes.length;
+		if (this._root) if (!refChild) if (childNodesLength === 1) this.updateChildNodes();
+		else this.enqueueUpdate({
+			path: newChild._path,
+			value: this.hydrate(newChild)
+		});
+		else if (isReplace) this.enqueueUpdate({
+			path: newChild._path,
+			value: this.hydrate(newChild)
+		});
+		else if (childNodesLength * 2 / 3 > index) this.updateChildNodes();
+		else this.updateSingleChild(index);
+		MutationObserver$1.record({
+			type: "childList",
+			target: this,
+			addedNodes: [newChild],
+			removedNodes: isReplace ? [refChild] : [],
+			nextSibling: isReplace ? refChild.nextSibling : refChild || null,
+			previousSibling: newChild.previousSibling
+		});
+		return newChild;
+	}
+	/**
+	* @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/appendChild
+	* @scenario
+	* [A,B,C]
+	*   1. append C, C has no parent
+	*   2. append C, C has the same parent of B
+	*   3. append C, C has the different parent of B
+	*/
+	appendChild(newChild) {
+		return this.insertBefore(newChild);
+	}
+	/**
+	* @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/replaceChild
+	* @scenario
+	* [A,B,C]
+	*   1. replace B with C, C has no parent
+	*   2. replace B with C, C has no parent, C has the same parent of B
+	*   3. replace B with C, C has no parent, C has the different parent of B
+	*/
+	replaceChild(newChild, oldChild) {
+		if (oldChild.parentNode !== this) return;
+		this.insertBefore(newChild, oldChild, true);
+		oldChild.remove({ doUpdate: false });
+		return oldChild;
+	}
+	/**
+	* @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/removeChild
+	* @scenario
+	* [A,B,C]
+	*   1. remove A or B
+	*   2. remove C
+	*/
+	removeChild(child, options = {}) {
+		const { cleanRef, doUpdate } = options;
+		if (cleanRef !== false && doUpdate !== false) MutationObserver$1.record({
+			type: "childList",
+			target: this,
+			removedNodes: [child],
+			nextSibling: child.nextSibling,
+			previousSibling: child.previousSibling
+		});
+		const index = this.findIndex(child);
+		this.childNodes.splice(index, 1);
+		child.parentNode = null;
+		if (cleanRef !== false) eventSource.removeNodeTree(child);
+		if (this._root && doUpdate !== false) this.updateChildNodes();
+		return child;
+	}
+	remove(options) {
+		this.parentNode?.removeChild(this, options);
+	}
+	hasChildNodes() {
+		return this.childNodes.length > 0;
+	}
+	enqueueUpdate(payload) {
+		this._root?.enqueueUpdate(payload);
+	}
+	get ownerDocument() {
+		return env.document;
+	}
+	static extend(methodName, options) {
+		extend(TaroNode, methodName, options);
+	}
+};
+//#endregion
+//#region src/dom/style_properties.ts
+const WEBKIT = "webkit";
+const styleProperties = [
+	"all",
+	"appearance",
+	"backdropFilter",
+	"blockOverflow",
+	"blockSize",
+	"bottom",
+	"clear",
+	"contain",
+	"content",
+	"continue",
+	"cursor",
+	"direction",
+	"display",
+	"filter",
+	"float",
+	"gap",
+	"height",
+	"inset",
+	"isolation",
+	"left",
+	"letterSpacing",
+	"lightingColor",
+	"markerSide",
+	"mixBlendMode",
+	"opacity",
+	"order",
+	"position",
+	"quotes",
+	"resize",
+	"right",
+	"rowGap",
+	"tabSize",
+	"tableLayout",
+	"top",
+	"userSelect",
+	"verticalAlign",
+	"visibility",
+	"voiceFamily",
+	"volume",
+	"whiteSpace",
+	"widows",
+	"width",
+	"zIndex",
+	"pointerEvents",
+	"aspectRatio"
+];
+function combine(prefix, list, excludeSelf) {
+	!excludeSelf && styleProperties.push(prefix);
+	list.forEach((item) => {
+		styleProperties.push(prefix + item);
+		if (prefix === WEBKIT) styleProperties.push("Webkit" + item);
+	});
+}
+const color = "Color";
+const style = "Style";
+const width = "Width";
+const image = "Image";
+const size = "Size";
+const color_style_width = [
+	color,
+	style,
+	width
+];
+const fitlength_fitwidth_image = [
+	"FitLength",
+	"FitWidth",
+	image
+];
+const fitlength_fitwidth_image_radius = [...fitlength_fitwidth_image, "Radius"];
+const color_style_width_fitlength_fitwidth_image = [...color_style_width, ...fitlength_fitwidth_image];
+const endRadius_startRadius = ["EndRadius", "StartRadius"];
+const bottom_left_right_top = [
+	"Bottom",
+	"Left",
+	"Right",
+	"Top"
+];
+const end_start = ["End", "Start"];
+const content_items_self = [
+	"Content",
+	"Items",
+	"Self"
+];
+const blockSize_height_inlineSize_width = [
+	"BlockSize",
+	"Height",
+	"InlineSize",
+	width
+];
+const after_before = ["After", "Before"];
+combine("borderBlock", color_style_width);
+combine("borderBlockEnd", color_style_width);
+combine("borderBlockStart", color_style_width);
+combine("outline", [...color_style_width, "Offset"]);
+combine("border", [
+	...color_style_width,
+	"Boundary",
+	"Break",
+	"Collapse",
+	"Radius",
+	"Spacing"
+]);
+combine("borderFit", ["Length", width]);
+combine("borderInline", color_style_width);
+combine("borderInlineEnd", color_style_width);
+combine("borderInlineStart", color_style_width);
+combine("borderLeft", color_style_width_fitlength_fitwidth_image);
+combine("borderRight", color_style_width_fitlength_fitwidth_image);
+combine("borderTop", color_style_width_fitlength_fitwidth_image);
+combine("borderBottom", color_style_width_fitlength_fitwidth_image);
+combine("textDecoration", [
+	color,
+	style,
+	"Line"
+]);
+combine("textEmphasis", [
+	color,
+	style,
+	"Position"
+]);
+combine("scrollMargin", bottom_left_right_top);
+combine("scrollPadding", bottom_left_right_top);
+combine("padding", bottom_left_right_top);
+combine("margin", [...bottom_left_right_top, "Trim"]);
+combine("scrollMarginBlock", end_start);
+combine("scrollMarginInline", end_start);
+combine("scrollPaddingBlock", end_start);
+combine("scrollPaddingInline", end_start);
+combine("gridColumn", end_start);
+combine("gridRow", end_start);
+combine("insetBlock", end_start);
+combine("insetInline", end_start);
+combine("marginBlock", end_start);
+combine("marginInline", end_start);
+combine("paddingBlock", end_start);
+combine("paddingInline", end_start);
+combine("pause", after_before);
+combine("cue", after_before);
+combine("mask", [
+	"Clip",
+	"Composite",
+	image,
+	"Mode",
+	"Origin",
+	"Position",
+	"Repeat",
+	size,
+	"Type"
+]);
+combine("borderImage", [
+	"Outset",
+	"Repeat",
+	"Slice",
+	"Source",
+	"Transform",
+	width
+]);
+combine("maskBorder", [
+	"Mode",
+	"Outset",
+	"Repeat",
+	"Slice",
+	"Source",
+	width
+]);
+combine("font", [
+	"Family",
+	"FeatureSettings",
+	"Kerning",
+	"LanguageOverride",
+	"MaxSize",
+	"MinSize",
+	"OpticalSizing",
+	"Palette",
+	size,
+	"SizeAdjust",
+	"Stretch",
+	style,
+	"Weight",
+	"VariationSettings"
+]);
+combine("transform", [
+	"Box",
+	"Origin",
+	style
+]);
+combine("background", [
+	color,
+	image,
+	"Attachment",
+	"BlendMode",
+	"Clip",
+	"Origin",
+	"Position",
+	"Repeat",
+	size
+]);
+combine("listStyle", [
+	image,
+	"Position",
+	"Type"
+]);
+combine("scrollSnap", [
+	"Align",
+	"Stop",
+	"Type"
+]);
+combine("grid", [
+	"Area",
+	"AutoColumns",
+	"AutoFlow",
+	"AutoRows"
+]);
+combine("gridTemplate", [
+	"Areas",
+	"Columns",
+	"Rows"
+]);
+combine("overflow", [
+	"Block",
+	"Inline",
+	"Wrap",
+	"X",
+	"Y"
+]);
+combine("transition", [
+	"Delay",
+	"Duration",
+	"Property",
+	"TimingFunction"
+]);
+combine("color", [
+	"Adjust",
+	"InterpolationFilters",
+	"Scheme"
+]);
+combine("textAlign", ["All", "Last"]);
+combine("page", [
+	"BreakAfter",
+	"BreakBefore",
+	"BreakInside"
+]);
+combine("animation", [
+	"Delay",
+	"Direction",
+	"Duration",
+	"FillMode",
+	"IterationCount",
+	"Name",
+	"PlayState",
+	"TimingFunction"
+]);
+combine("flex", [
+	"Basis",
+	"Direction",
+	"Flow",
+	"Grow",
+	"Shrink",
+	"Wrap"
+]);
+combine("offset", [
+	...after_before,
+	...end_start,
+	"Anchor",
+	"Distance",
+	"Path",
+	"Position",
+	"Rotate"
+]);
+combine("perspective", ["Origin"]);
+combine("clip", ["Path", "Rule"]);
+combine("flow", ["From", "Into"]);
+combine("align", [
+	"Content",
+	"Items",
+	"Self"
+], true);
+combine("alignment", ["Adjust", "Baseline"], true);
+combine("borderStart", endRadius_startRadius, true);
+combine("borderEnd", endRadius_startRadius, true);
+combine("borderCorner", [
+	"Fit",
+	image,
+	"ImageTransform"
+], true);
+combine("borderTopLeft", fitlength_fitwidth_image_radius, true);
+combine("borderTopRight", fitlength_fitwidth_image_radius, true);
+combine("borderBottomLeft", fitlength_fitwidth_image_radius, true);
+combine("borderBottomRight", fitlength_fitwidth_image_radius, true);
+combine("column", [
+	"s",
+	"Count",
+	"Fill",
+	"Gap",
+	"Rule",
+	"RuleColor",
+	"RuleStyle",
+	"RuleWidth",
+	"Span",
+	width
+], true);
+combine("break", [...after_before, "Inside"], true);
+combine("wrap", [
+	...after_before,
+	"Flow",
+	"Inside",
+	"Through"
+], true);
+combine("justify", content_items_self, true);
+combine("place", content_items_self, true);
+combine("max", [...blockSize_height_inlineSize_width, "Lines"], true);
+combine("min", blockSize_height_inlineSize_width, true);
+combine("line", [
+	"Break",
+	"Clamp",
+	"Grid",
+	"Height",
+	"Padding",
+	"Snap"
+], true);
+combine("inline", [
+	"BoxAlign",
+	size,
+	"Sizing"
+], true);
+combine("text", [
+	"CombineUpright",
+	"GroupAlign",
+	"Height",
+	"Indent",
+	"Justify",
+	"Orientation",
+	"Overflow",
+	"Shadow",
+	"SpaceCollapse",
+	"SpaceTrim",
+	"Spacing",
+	"Transform",
+	"UnderlinePosition",
+	"Wrap"
+], true);
+combine("shape", [
+	"ImageThreshold",
+	"Inside",
+	"Margin",
+	"Outside"
+], true);
+combine("word", [
+	"Break",
+	"Spacing",
+	"Wrap"
+], true);
+combine("object", ["Fit", "Position"], true);
+combine("box", [
+	"DecorationBreak",
+	"Shadow",
+	"Sizing",
+	"Snap"
+], true);
+combine(WEBKIT, [
+	"LineClamp",
+	"BoxOrient",
+	"TextFillColor",
+	"TextStroke",
+	"TextStrokeColor",
+	"TextStrokeWidth"
+], true);
+//#endregion
+//#region src/dom/style.ts
+function recordCss(obj) {
+	MutationObserver$1.record({
+		type: "attributes",
+		target: obj._element,
+		attributeName: "style",
+		oldValue: obj.cssText
+	});
+}
+function enqueueUpdate(obj) {
+	const element = obj._element;
+	if (element._root) element.enqueueUpdate({
+		path: `${element._path}.${Shortcuts.Style}`,
+		value: obj.cssText
+	});
+}
+function setStyle(newVal, styleKey) {
+	warn(isString(newVal) && newVal.length > 2046, `Style 属性 ${styleKey} 的值数据量过大，可能会影响渲染性能，考虑使用 CSS 类或其它方案替代。`);
+	if (this[styleKey] === newVal) return;
+	!this._pending && recordCss(this);
+	if (isNull(newVal) || isUndefined(newVal) || newVal === "") {
+		this._usedStyleProp.delete(styleKey);
+		delete this._value[styleKey];
+	} else {
+		this._usedStyleProp.add(styleKey);
+		this._value[styleKey] = newVal;
+	}
+	!this._pending && enqueueUpdate(this);
+}
+function initStyle(ctor, styleProperties) {
+	const properties = {};
+	for (let i = 0; i < styleProperties.length; i++) {
+		const styleKey = styleProperties[i];
+		if (ctor[styleKey]) return;
+		properties[styleKey] = {
+			get() {
+				const val = this._value[styleKey];
+				return isNull(val) || isUndefined(val) ? "" : val;
+			},
+			set(newVal) {
+				setStyle.call(this, newVal, styleKey);
+			}
+		};
+	}
+	Object.defineProperties(ctor.prototype, properties);
+}
+function isCssVariable(propertyName) {
+	return /^--/.test(propertyName);
+}
+var Style = class {
+	constructor(element) {
+		this._element = element;
+		this._usedStyleProp = /* @__PURE__ */ new Set();
+		this._value = {};
+	}
+	setCssVariables(styleKey) {
+		this.hasOwnProperty(styleKey) || Object.defineProperty(this, styleKey, {
+			enumerable: true,
+			configurable: true,
+			get: () => {
+				return this._value[styleKey] || "";
+			},
+			set: (newVal) => {
+				setStyle.call(this, newVal, styleKey);
+			}
+		});
+	}
+	get cssText() {
+		if (!this._usedStyleProp.size) return "";
+		const texts = [];
+		this._usedStyleProp.forEach((key) => {
+			const val = this[key];
+			if (isNull(val) || isUndefined(val)) return;
+			let styleName = isCssVariable(key) ? key : toDashed(key);
+			if (styleName.indexOf("webkit") === 0 || styleName.indexOf("Webkit") === 0) styleName = `-${styleName}`;
+			texts.push(`${styleName}: ${val};`);
+		});
+		return texts.join(" ");
+	}
+	set cssText(str) {
+		this._pending = true;
+		recordCss(this);
+		this._usedStyleProp.forEach((prop) => {
+			this.removeProperty(prop);
+		});
+		if (str === "" || isUndefined(str) || isNull(str)) {
+			this._pending = false;
+			enqueueUpdate(this);
+			return;
+		}
+		const rules = str.split(";");
+		for (let i = 0; i < rules.length; i++) {
+			const rule = rules[i].trim();
+			if (rule === "") continue;
+			const [propName, ...valList] = rule.split(":");
+			const val = valList.join(":");
+			if (isUndefined(val)) continue;
+			this.setProperty(propName.trim(), val.trim());
+		}
+		this._pending = false;
+		enqueueUpdate(this);
+	}
+	setProperty(propertyName, value) {
+		if (propertyName[0] === "-") this.setCssVariables(propertyName);
+		else propertyName = toCamelCase(propertyName);
+		if (isNull(value) || isUndefined(value)) this.removeProperty(propertyName);
+		else this[propertyName] = value;
+	}
+	removeProperty(propertyName) {
+		propertyName = toCamelCase(propertyName);
+		if (!this._usedStyleProp.has(propertyName)) return "";
+		const value = this[propertyName];
+		this[propertyName] = void 0;
+		return value;
+	}
+	getPropertyValue(propertyName) {
+		propertyName = toCamelCase(propertyName);
+		const value = this[propertyName];
+		if (!value) return "";
+		return value;
+	}
+};
+initStyle(Style, styleProperties);
+hooks$1.tap("injectNewStyleProperties", (newStyleProperties) => {
+	if (isArray(newStyleProperties)) initStyle(Style, newStyleProperties);
+	else {
+		if (typeof newStyleProperties !== "string") return;
+		initStyle(Style, [newStyleProperties]);
+	}
+});
+//#endregion
+//#region src/dom/tree.ts
+function returnTrue() {
+	return true;
+}
+function treeToArray(root, predict) {
+	const array = [];
+	const filter = predict ?? returnTrue;
+	let object = root;
+	while (object) {
+		if (object.nodeType === 1 && filter(object)) array.push(object);
+		object = following(object, root);
+	}
+	return array;
+}
+function following(el, root) {
+	const firstChild = el.firstChild;
+	const isElmentTypeValid = el.nodeType === 1 || el.nodeType === 9;
+	if (firstChild && isElmentTypeValid) return firstChild;
+	let current = el;
+	do {
+		if (current === root) return null;
+		const nextSibling = current.nextSibling;
+		if (nextSibling) return nextSibling;
+		current = current.parentElement;
+	} while (current);
+	return null;
+}
+//#endregion
+//#region src/dom/element.ts
+var TaroElement = class TaroElement extends TaroNode {
+	constructor() {
+		super();
+		this.props = {};
+		this.dataset = EMPTY_OBJ;
+		this.nodeType = 1;
+		this.style = new Style(this);
+		hooks$1.call("patchElement", this);
+	}
+	_stopPropagation(event) {
+		let target = this;
+		while (target = target.parentNode) {
+			const listeners = target.__handlers[event.type];
+			if (!isArray(listeners)) continue;
+			for (let i = listeners.length; i--;) {
+				const l = listeners[i];
+				l._stop = true;
+			}
+		}
+	}
+	get id() {
+		return this.getAttribute("id");
+	}
+	set id(val) {
+		this.setAttribute("id", val);
+	}
+	get className() {
+		return this.getAttribute("class") || "";
+	}
+	set className(val) {
+		this.setAttribute(CLASS, val);
+	}
+	get cssText() {
+		return this.getAttribute("style") || "";
+	}
+	get classList() {
+		return new ClassList(this.className, this);
+	}
+	get children() {
+		return this.childNodes.filter(isElement);
+	}
+	get attributes() {
+		const props = this.props;
+		const propKeys = Object.keys(props);
+		const style = this.style.cssText;
+		return propKeys.map((key) => ({
+			name: key,
+			value: props[key]
+		})).concat(style ? {
+			name: STYLE,
+			value: style
+		} : []);
+	}
+	get textContent() {
+		let text = "";
+		const childNodes = this.childNodes;
+		for (let i = 0; i < childNodes.length; i++) text += childNodes[i].textContent;
+		return text;
+	}
+	set textContent(text) {
+		super.textContent = text;
+	}
+	hasAttribute(qualifiedName) {
+		return !isUndefined(this.props[qualifiedName]);
+	}
+	hasAttributes() {
+		return this.attributes.length > 0;
+	}
+	get focus() {
+		return function() {
+			this.setAttribute(FOCUS, true);
+		};
+	}
+	set focus(value) {
+		this.setAttribute(FOCUS, value);
+	}
+	blur() {
+		this.setAttribute(FOCUS, false);
+	}
+	setAttribute(qualifiedName, value) {
+		warn(isString(value) && value.length > 2046, `元素 ${this.nodeName} 的 ${qualifiedName} 属性值数据量过大，可能会影响渲染性能。考虑降低图片转为 base64 的阈值或在 CSS 中使用 base64。`);
+		const isPureView = this.nodeName === "view" && !isHasExtractProp(this) && !this.isAnyEventBinded();
+		if (qualifiedName !== "style") MutationObserver$1.record({
+			target: this,
+			type: "attributes",
+			attributeName: qualifiedName,
+			oldValue: this.getAttribute(qualifiedName)
+		});
+		switch (qualifiedName) {
+			case STYLE:
+				this.style.cssText = value;
+				break;
+			case "id":
+				if (this.uid !== this.sid) eventSource.delete(this.uid);
+				value = String(value);
+				this.props[qualifiedName] = this.uid = value;
+				eventSource.set(value, this);
+				break;
+			default:
+				this.props[qualifiedName] = value;
+				if (qualifiedName.startsWith("data-")) {
+					if (this.dataset === EMPTY_OBJ) this.dataset = Object.create(null);
+					this.dataset[toCamelCase(qualifiedName.replace(/^data-/, ""))] = value;
+				}
+				break;
+		}
+		if (!this._root) return;
+		const componentsAlias = getComponentsAlias();
+		const _alias = componentsAlias[this.nodeName];
+		const viewAlias = componentsAlias[VIEW]._num;
+		const clickViewAlias = componentsAlias[CLICK_VIEW]._num;
+		const staticViewAlias = componentsAlias[STATIC_VIEW]._num;
+		const catchViewAlias = componentsAlias[CATCH_VIEW]._num;
+		const _path = this._path;
+		qualifiedName = shortcutAttr(qualifiedName);
+		const qualifiedNameInCamelCase = toCamelCase(qualifiedName);
+		const payload = {
+			path: `${_path}.${qualifiedNameInCamelCase}`,
+			value: isFunction(value) ? () => value : value
+		};
+		hooks$1.call("modifySetAttrPayload", this, qualifiedName, payload, componentsAlias);
+		if (_alias) payload.path = `${_path}.${toCamelCase(_alias[qualifiedNameInCamelCase] || qualifiedName)}`;
+		this.enqueueUpdate(payload);
+		if (this.nodeName === "view") {
+			if (qualifiedNameInCamelCase === "catchMove") this.enqueueUpdate({
+				path: `${_path}.${Shortcuts.NodeName}`,
+				value: value ? catchViewAlias : this.isOnlyClickBinded() && !isHasExtractProp(this) ? clickViewAlias : this.isAnyEventBinded() ? viewAlias : staticViewAlias
+			});
+			else if (isPureView && isHasExtractProp(this)) this.enqueueUpdate({
+				path: `${_path}.${Shortcuts.NodeName}`,
+				value: staticViewAlias
+			});
+		}
+	}
+	removeAttribute(qualifiedName) {
+		const isStaticView = this.nodeName === "view" && isHasExtractProp(this) && !this.isAnyEventBinded();
+		MutationObserver$1.record({
+			target: this,
+			type: "attributes",
+			attributeName: qualifiedName,
+			oldValue: this.getAttribute(qualifiedName)
+		});
+		if (qualifiedName === "style") this.style.cssText = "";
+		else {
+			if (hooks$1.call("onRemoveAttribute", this, qualifiedName)) return;
+			if (!this.props.hasOwnProperty(qualifiedName)) return;
+			delete this.props[qualifiedName];
+		}
+		if (!this._root) return;
+		const componentsAlias = getComponentsAlias();
+		const _alias = componentsAlias[this.nodeName];
+		const viewAlias = componentsAlias[VIEW]._num;
+		const staticViewAlias = componentsAlias[STATIC_VIEW]._num;
+		const pureViewAlias = componentsAlias[PURE_VIEW]._num;
+		const clickViewAlias = componentsAlias[CLICK_VIEW]._num;
+		const _path = this._path;
+		qualifiedName = shortcutAttr(qualifiedName);
+		const qualifiedNameInCamelCase = toCamelCase(qualifiedName);
+		const payload = {
+			path: `${_path}.${qualifiedNameInCamelCase}`,
+			value: ""
+		};
+		hooks$1.call("modifyRmAttrPayload", this, qualifiedName, payload, componentsAlias);
+		if (_alias) payload.path = `${_path}.${toCamelCase(_alias[qualifiedNameInCamelCase] || qualifiedName)}`;
+		this.enqueueUpdate(payload);
+		if (this.nodeName === "view") {
+			if (qualifiedNameInCamelCase === "catchMove") this.enqueueUpdate({
+				path: `${_path}.${Shortcuts.NodeName}`,
+				value: this.isOnlyClickBinded() && !isHasExtractProp(this) ? clickViewAlias : this.isAnyEventBinded() ? viewAlias : isHasExtractProp(this) ? staticViewAlias : pureViewAlias
+			});
+			else if (isStaticView && !isHasExtractProp(this)) this.enqueueUpdate({
+				path: `${_path}.${Shortcuts.NodeName}`,
+				value: pureViewAlias
+			});
+		}
+	}
+	getAttribute(qualifiedName) {
+		return (qualifiedName === "style" ? this.style.cssText : this.props[qualifiedName]) ?? "";
+	}
+	getElementsByTagName(tagName) {
+		return treeToArray(this, (el) => {
+			return el.nodeName === tagName || tagName === "*" && this !== el;
+		});
+	}
+	getElementsByClassName(className) {
+		const classNames = className.trim().split(/\s+/);
+		return treeToArray(this, (el) => {
+			const classList = el.classList;
+			return classNames.every((c) => classList.contains(c));
+		});
+	}
+	dispatchEvent(event) {
+		const cancelable = event.cancelable;
+		const listeners = this.__handlers[event.type];
+		if (!isArray(listeners)) return false;
+		for (let i = listeners.length; i--;) {
+			const listener = listeners[i];
+			let result;
+			if (listener._stop) listener._stop = false;
+			else {
+				hooks$1.call("modifyDispatchEvent", event, this);
+				result = listener.call(this, event);
+			}
+			if ((result === false || event._end) && cancelable) event.defaultPrevented = true;
+			if (!isUndefined(result) && event.mpEvent) {
+				if (hooks$1.call("modifyTaroEventReturn", this, event, result)) event.mpEvent[EVENT_CALLBACK_RESULT] = result;
+			}
+			if (event._end && event._stop) break;
+		}
+		if (event._stop) this._stopPropagation(event);
+		return listeners != null;
+	}
+	addEventListener(type, handler, options) {
+		const name = this.nodeName;
+		const SPECIAL_NODES = hooks$1.call("getSpecialNodes");
+		let sideEffect = true;
+		if (isObject(options) && options.sideEffect === false) {
+			sideEffect = false;
+			delete options.sideEffect;
+		}
+		hooks$1.call("modifyAddEventListener", this, sideEffect, getComponentsAlias);
+		if (sideEffect !== false && !this.isAnyEventBinded() && SPECIAL_NODES.indexOf(name) > -1) {
+			const alias = getComponentsAlias()[name]._num;
+			this.enqueueUpdate({
+				path: `${this._path}.${Shortcuts.NodeName}`,
+				value: alias
+			});
+		}
+		super.addEventListener(type, handler, options);
+	}
+	removeEventListener(type, handler, sideEffect = true) {
+		super.removeEventListener(type, handler);
+		const name = this.nodeName;
+		const SPECIAL_NODES = hooks$1.call("getSpecialNodes");
+		hooks$1.call("modifyRemoveEventListener", this, sideEffect, getComponentsAlias);
+		if (sideEffect !== false && !this.isAnyEventBinded() && SPECIAL_NODES.indexOf(name) > -1) {
+			const valueAlias = getComponentsAlias()[isHasExtractProp(this) ? `static-${name}` : `pure-${name}`]._num;
+			this.enqueueUpdate({
+				path: `${this._path}.${Shortcuts.NodeName}`,
+				value: valueAlias
+			});
+		}
+	}
+	static extend(methodName, options) {
+		extend(TaroElement, methodName, options);
+	}
+};
+//#endregion
+//#region src/options.ts
+const options = {
+	prerender: true,
+	debug: false
+};
+//#endregion
+//#region src/dom/event.ts
+var TaroEvent = class {
+	constructor(type, opts, event) {
+		this._stop = false;
+		this._end = false;
+		this.defaultPrevented = false;
+		this.button = 0;
+		this.timeStamp = Date.now();
+		this.type = type.toLowerCase();
+		this.mpEvent = event;
+		this.bubbles = Boolean(opts && opts.bubbles);
+		this.cancelable = Boolean(opts && opts.cancelable);
+	}
+	stopPropagation() {
+		this._stop = true;
+	}
+	stopImmediatePropagation() {
+		this._end = this._stop = true;
+	}
+	preventDefault() {
+		this.defaultPrevented = true;
+	}
+	get target() {
+		const cacheTarget = this.cacheTarget;
+		if (!cacheTarget) {
+			const target = Object.create(this.mpEvent?.target || null);
+			const currentEle = env.document.getElementById(target.dataset?.sid || target.id || null);
+			const element = env.document.getElementById(target.targetDataset?.sid || target.dataset?.sid || target.id || null);
+			target.dataset = {
+				...currentEle !== null ? currentEle.dataset : EMPTY_OBJ,
+				...element !== null ? element.dataset : EMPTY_OBJ
+			};
+			for (const key in this.mpEvent?.detail) target[key] = this.mpEvent.detail[key];
+			this.cacheTarget = target;
+			return target;
+		} else return cacheTarget;
+	}
+	get currentTarget() {
+		const cacheCurrentTarget = this.cacheCurrentTarget;
+		if (!cacheCurrentTarget) {
+			const doc = env.document;
+			const currentTarget = Object.create(this.mpEvent?.currentTarget || null);
+			const element = doc.getElementById(currentTarget.dataset?.sid || currentTarget.id || null);
+			const targetElement = doc.getElementById(this.mpEvent?.target?.dataset?.sid || this.mpEvent?.target?.id || null);
+			if (element === null || element && element === targetElement) {
+				this.cacheCurrentTarget = this.target;
+				return this.target;
+			}
+			currentTarget.dataset = element.dataset;
+			for (const key in this.mpEvent?.detail) currentTarget[key] = this.mpEvent.detail[key];
+			this.cacheCurrentTarget = currentTarget;
+			return currentTarget;
+		} else return cacheCurrentTarget;
+	}
+};
+function createEvent(event, node) {
+	if (typeof event === "string") return new TaroEvent(event, {
+		bubbles: true,
+		cancelable: true
+	});
+	const domEv = new TaroEvent(event.type, {
+		bubbles: true,
+		cancelable: true
+	}, event);
+	for (const key in event) if (key === "currentTarget" || key === "target" || key === "type" || key === "timeStamp") continue;
+	else domEv[key] = event[key];
+	if (domEv.type === "confirm" && node?.nodeName === "input") domEv[KEY_CODE] = 13;
+	return domEv;
+}
+const eventsBatch = {};
+function getEventCBResult(event) {
+	const result = event[EVENT_CALLBACK_RESULT];
+	if (!isUndefined(result)) delete event[EVENT_CALLBACK_RESULT];
+	return result;
+}
+function eventHandler(event) {
+	event.type === void 0 && Object.defineProperty(event, "type", { value: event._type });
+	event.detail === void 0 && Object.defineProperty(event, "detail", { value: event._detail || { ...event } });
+	event.currentTarget = event.currentTarget || event.target || { ...event };
+	hooks$1.call("modifyMpEventImpl", event);
+	const currentTarget = event.currentTarget;
+	const id = currentTarget.dataset?.sid || currentTarget.id || event.detail?.id || "";
+	const node = env.document.getElementById(id);
+	if (node) {
+		const dispatch = () => {
+			const e = createEvent(event, node);
+			hooks$1.call("modifyTaroEvent", e, node);
+			hooks$1.call("dispatchTaroEvent", e, node);
+			hooks$1.call("dispatchTaroEventFinish", e, node);
+		};
+		if (hooks$1.isExist("batchedEventUpdates")) {
+			const type = event.type;
+			if (!hooks$1.call("isBubbleEvents", type) || !isParentBound(node, type) || type === "touchmove" && !!node.props.catchMove) {
+				hooks$1.call("batchedEventUpdates", () => {
+					if (eventsBatch[type]) {
+						eventsBatch[type].forEach((fn) => fn());
+						delete eventsBatch[type];
+					}
+					dispatch();
+				});
+				return getEventCBResult(event);
+			} else (eventsBatch[type] ||= []).push(dispatch);
+		} else {
+			dispatch();
+			return getEventCBResult(event);
+		}
+	}
+}
+function eventHandlerTTDom(ele, listener, event) {
+	Object.assign(event, {
+		mpEvent: event,
+		bubbles: true,
+		cancelable: true
+	});
+	listener(event, ele);
+}
+//#endregion
+//#region src/dom/form.ts
+var FormElement = class extends TaroElement {
+	get type() {
+		return this.props["type"] ?? "";
+	}
+	set type(val) {
+		this.setAttribute(TYPE, val);
+	}
+	get value() {
+		const val = this.props[VALUE];
+		return val == null ? "" : val;
+	}
+	set value(val) {
+		this.setAttribute(VALUE, val);
+	}
+	dispatchEvent(event) {
+		if (event.mpEvent) {
+			const val = event.mpEvent.detail.value;
+			if (event.type === "change") this.props.value = val;
+			else if (event.type === "input") this.value = val;
+		}
+		return super.dispatchEvent(event);
+	}
+};
+//#endregion
+//#region src/perf.ts
+var Performance = class {
+	constructor() {
+		this.recorder = /* @__PURE__ */ new Map();
+	}
+	start(id) {
+		if (!options.debug) return;
+		this.recorder.set(id, Date.now());
+	}
+	stop(id, now = Date.now()) {
+		if (!options.debug) return;
+		const prev = this.recorder.get(id);
+		if (!(prev >= 0)) return;
+		this.recorder.delete(id);
+		const time = now - prev;
+		console.log(`${id} 时长： ${time}ms 开始时间：${this.#parseTime(prev)} 结束时间：${this.#parseTime(now)}`);
+	}
+	delayStop(id, delay = 500) {
+		if (!options.debug) return;
+		return debounce((now = Date.now(), cb) => {
+			this.stop(id, now);
+			cb?.();
+		}, delay);
+	}
+	#parseTime(time) {
+		const d = new Date(time);
+		return `${d.getHours()}:${d.getMinutes()}:${d.getSeconds()}.${`${d.getMilliseconds()}`.padStart(3, "0")}`;
+	}
+};
+const perf = new Performance();
+//#endregion
+//#region src/dom/root.ts
+function findCustomWrapper(root, dataPathArr) {
+	const list = dataPathArr.slice(1);
+	let currentData = root;
+	let customWrapper;
+	let splitedPath = "";
+	list.some((item, i) => {
+		const key = item.replace(/^\[(.+)\]$/, "$1").replace(/\bcn\b/g, "childNodes");
+		currentData = currentData[key];
+		if (isArray(currentData)) currentData = currentData.filter((el) => !isComment(el));
+		if (isUndefined(currentData)) return true;
+		if (currentData.nodeName === "custom-wrapper") {
+			const res = customWrapperCache.get(currentData.sid);
+			if (res) {
+				customWrapper = res;
+				splitedPath = dataPathArr.slice(i + 2).join(".");
+			}
+		}
+	});
+	if (customWrapper) return {
+		customWrapper,
+		splitedPath
+	};
+}
+var TaroRootElement = class extends TaroElement {
+	constructor() {
+		super();
+		this.updatePayloads = [];
+		this.updateCallbacks = [];
+		this.pendingUpdate = false;
+		this.ctx = null;
+		this.nodeName = ROOT_STR;
+		this.tagName = ROOT_STR.toUpperCase();
+	}
+	get _path() {
+		return ROOT_STR;
+	}
+	get _root() {
+		return this;
+	}
+	scheduleTask(fn) {
+		setTimeout(fn);
+	}
+	enqueueUpdate(payload) {
+		this.updatePayloads.push(payload);
+		if (!this.pendingUpdate && this.ctx) this.performUpdate();
+	}
+	performUpdate(initRender = false, prerender) {
+		this.pendingUpdate = true;
+		const ctx = hooks$1.call("proxyToRaw", this.ctx);
+		this.scheduleTask(() => {
+			const setDataMark = `${SET_DATA} 开始时间戳 ${Date.now()}`;
+			perf.start(setDataMark);
+			const data = Object.create(null);
+			const resetPaths = new Set(initRender ? ["root.cn.[0]", "root.cn[0]"] : []);
+			while (this.updatePayloads.length > 0) {
+				const { path, value } = this.updatePayloads.shift();
+				if (path.endsWith(Shortcuts.Childnodes)) resetPaths.add(path);
+				data[path] = value;
+			}
+			for (const path in data) {
+				resetPaths.forEach((p) => {
+					if (path.includes(p) && path !== p) delete data[path];
+				});
+				const value = data[path];
+				if (isFunction(value)) data[path] = value();
+			}
+			if (isFunction(prerender)) return prerender(data);
+			this.pendingUpdate = false;
+			let normalUpdate = {};
+			const customWrapperMap = /* @__PURE__ */ new Map();
+			if (initRender) normalUpdate = data;
+			else for (const p in data) {
+				const dataPathArr = p.split(".");
+				const found = findCustomWrapper(this, dataPathArr);
+				if (found) {
+					const { customWrapper, splitedPath } = found;
+					customWrapperMap.set(customWrapper, {
+						...customWrapperMap.get(customWrapper) || {},
+						[`i.${splitedPath}`]: data[p]
+					});
+				} else normalUpdate[p] = data[p];
+			}
+			const customWrapperCount = customWrapperMap.size;
+			const isNeedNormalUpdate = Object.keys(normalUpdate).length > 0;
+			const updateArrLen = customWrapperCount + (isNeedNormalUpdate ? 1 : 0);
+			let executeTime = 0;
+			const cb = () => {
+				if (++executeTime === updateArrLen) {
+					perf.stop(setDataMark);
+					this.flushUpdateCallback();
+					initRender && perf.stop("页面初始化");
+				}
+			};
+			if (customWrapperCount) customWrapperMap.forEach((data, ctx) => {
+				if (options.debug) console.log("custom wrapper setData: ", data);
+				ctx.setData(data, cb);
+			});
+			if (isNeedNormalUpdate) {
+				if (options.debug) console.log("page setData:", normalUpdate);
+				ctx.setData(normalUpdate, cb);
+			}
+		});
+	}
+	enqueueUpdateCallback(cb, ctx) {
+		this.updateCallbacks.push(() => {
+			ctx ? cb.call(ctx) : cb();
+		});
+	}
+	flushUpdateCallback() {
+		const updateCallbacks = this.updateCallbacks;
+		if (!updateCallbacks.length) return;
+		const copies = updateCallbacks.slice(0);
+		this.updateCallbacks.length = 0;
+		for (let i = 0; i < copies.length; i++) copies[i]();
+	}
+};
+//#endregion
+//#region src/dom/text.ts
+var TaroText = class extends TaroNode {
+	constructor(value) {
+		super();
+		this.nodeType = 3;
+		this.nodeName = "#text";
+		this._value = value;
+	}
+	set textContent(text) {
+		MutationObserver$1.record({
+			target: this,
+			type: "characterData",
+			oldValue: this._value
+		});
+		this._value = text;
+		this.enqueueUpdate({
+			path: `${this._path}.${Shortcuts.Text}`,
+			value: text
+		});
+	}
+	get textContent() {
+		return this._value;
+	}
+	set nodeValue(text) {
+		this.textContent = text;
+	}
+	get nodeValue() {
+		return this._value;
+	}
+	set data(text) {
+		this.textContent = text;
+	}
+	get data() {
+		return this._value;
+	}
+};
+//#endregion
+//#region src/dom/anchor-element.ts
+var AnchorElement = class extends TaroElement {
+	get href() {
+		return this.props["href"] ?? "";
+	}
+	set href(val) {
+		this.setAttribute("href", val);
+	}
+	get protocol() {
+		return this.props["protocol"] ?? "";
+	}
+	get host() {
+		return this.props["host"] ?? "";
+	}
+	get search() {
+		return this.props["search"] ?? "";
+	}
+	get hash() {
+		return this.props["hash"] ?? "";
+	}
+	get hostname() {
+		return this.props["hostname"] ?? "";
+	}
+	get port() {
+		return this.props["port"] ?? "";
+	}
+	get pathname() {
+		return this.props["pathname"] ?? "";
+	}
+	setAttribute(qualifiedName, value) {
+		if (qualifiedName === "href") {
+			const willSetAttr = parseUrl(value);
+			for (const k in willSetAttr) super.setAttribute(k, willSetAttr[k]);
+		} else super.setAttribute(qualifiedName, value);
+	}
+};
+//#endregion
+//#region src/dom/transfer.ts
+var TransferElement = class extends TaroElement {
+	constructor(dataName) {
+		super();
+		this.dataName = dataName;
+		this.isTransferElement = true;
+	}
+	get _path() {
+		return this.dataName;
+	}
+};
+//#endregion
+//#region src/dom/document.ts
+var TaroDocument = class extends TaroElement {
+	constructor() {
+		super();
+		this.createEvent = createEvent;
+		this.nodeType = 9;
+		this.nodeName = DOCUMENT_ELEMENT_NAME;
+	}
+	createElement(type) {
+		const nodeName = type.toLowerCase();
+		let element;
+		switch (true) {
+			case nodeName === ROOT_STR:
+				element = new TaroRootElement();
+				return element;
+			case controlledComponent.has(nodeName):
+				element = new FormElement();
+				break;
+			case nodeName === "a":
+				element = new AnchorElement();
+				break;
+			case nodeName === "page-meta":
+			case nodeName === "navigation-bar":
+				element = new TransferElement(toCamelCase(nodeName));
+				break;
+			default:
+				element = new TaroElement();
+				break;
+		}
+		element.nodeName = nodeName;
+		element.tagName = type.toUpperCase();
+		return element;
+	}
+	createElementNS(_svgNS, type) {
+		return this.createElement(type);
+	}
+	createTextNode(text) {
+		return new TaroText(text);
+	}
+	getElementById(id) {
+		const el = eventSource.get(id);
+		return isUndefined(el) ? null : el;
+	}
+	querySelector(query) {
+		if (/^#/.test(query)) return this.getElementById(query.slice(1));
+		return null;
+	}
+	querySelectorAll() {
+		return [];
+	}
+	createComment() {
+		const textnode = new TaroText("");
+		textnode.nodeName = COMMENT;
+		return textnode;
+	}
+	get defaultView() {
+		return env.window;
+	}
+};
+//#endregion
+//#region src/bom/document.ts
+function createDocument() {
+	/**
+	* <document>
+	*   <html>
+	*     <head></head>
+	*     <body>
+	*       <container>
+	*         <app id="app" />
+	*       </container>
+	*     </body>
+	*   </html>
+	* </document>
+	*/
+	const doc = new TaroDocument();
+	const documentCreateElement = doc.createElement.bind(doc);
+	const html = documentCreateElement(HTML);
+	const head = documentCreateElement(HEAD);
+	const body = documentCreateElement(BODY);
+	const app = documentCreateElement("app");
+	app.id = "app";
+	const container = documentCreateElement(CONTAINER);
+	doc.appendChild(html);
+	html.appendChild(head);
+	html.appendChild(body);
+	body.appendChild(container);
+	container.appendChild(app);
+	doc.documentElement = html;
+	doc.head = head;
+	doc.body = body;
+	return doc;
+}
+function createTTDomDocument() {
+	const document = tt?.appDocument;
+	if (!document) throw new Error("tt.appDocument is not found");
+	const html = document.createElement(HTML);
+	const head = document.createElement(HEAD);
+	const body = document.createElement(BODY);
+	const app = document.createElement("app");
+	app.id = "app";
+	const container = document.createElement(CONTAINER);
+	const emptyFunction = () => {};
+	document.childNodes.push(html);
+	html.childNodes.push(head, body);
+	body.childNodes.push(container);
+	container.childNodes.push(app);
+	document.documentElement = html;
+	document.head = head;
+	document.body = body;
+	document.appElement = app;
+	let builtInComponents = tt?.getBuiltInComponents?.();
+	if (Array.isArray(builtInComponents)) builtInComponents = new Set(builtInComponents);
+	else if (!(builtInComponents instanceof Set)) builtInComponents = new Set([...DEFAULT_COMPONENTS, ...TT_SPECIFIC_COMPONENTS]);
+	document.getElementById = function getElementById(id) {
+		if (id === "app") return app;
+		else return Object.getPrototypeOf(this).getElementById.call(this, id);
+	};
+	document.getLastPage = function getLastPage() {
+		let last;
+		for (const v of this._pageDocumentMap.values()) last = v;
+		return last;
+	};
+	document.createElement = function(type, ...args) {
+		if (type === "root") return this.getLastPage();
+		else {
+			const el = builtInComponents.has(type) ? Object.getPrototypeOf(this).createElement.call(this, type, ...args) : Object.getPrototypeOf(this).createNativeComponent.call(this, type, { __tt__inner__options__: { name: type } });
+			el.setAttribute("class", "");
+			const originalSetAttribute = el.setAttribute.bind(el);
+			const originalRemoveAttribute = el.removeAttribute.bind(el);
+			el.setAttribute = function(name, value) {
+				const result = originalSetAttribute(name, value);
+				if (name === "catchMove" && value) el.addEventListener("catchtouchmove", emptyFunction);
+				return result;
+			};
+			el.removeAttribute = function(name) {
+				const oldValue = el.getAttribute(name);
+				if (name === "catchMove" && oldValue) el.removeEventListener("catchtouchmove", emptyFunction);
+				return originalRemoveAttribute(name);
+			};
+			return el;
+		}
+	};
+	return document;
+}
+const taroDocumentProvider = process.env.TARO_PLATFORM === "web" ? env.document : env.document = isEnableTTDom() ? createTTDomDocument() : createDocument();
+//#endregion
+//#region src/dom/svg.ts
+var SVGElement = class extends TaroElement {};
+//#endregion
+//#region src/dsl/common.ts
+const instances = /* @__PURE__ */ new Map();
+const pageId = incrementId();
+function injectPageInstance(inst, id) {
+	hooks$1.call("mergePageInstance", instances.get(id), inst);
+	instances.set(id, inst);
+}
+function getPageInstance(id) {
+	return instances.get(id);
+}
+function removePageInstance(id) {
+	instances.delete(id);
+}
+function safeExecute(path, lifecycle, ...args) {
+	const instance = instances.get(path);
+	if (instance == null) return;
+	const func = hooks$1.call("getLifecycle", instance, lifecycle);
+	if (isArray(func)) return func.map((fn) => fn.apply(instance, args))[0];
+	if (!isFunction(func)) return;
+	return func.apply(instance, args);
+}
+function stringify(obj) {
+	if (obj == null) return "";
+	const path = Object.keys(obj).map((key) => {
+		return key + "=" + obj[key];
+	}).join("&");
+	return path === "" ? path : "?" + path;
+}
+function getPath(id, options) {
+	const idx = id.indexOf("?");
+	if (process.env.TARO_PLATFORM === "web") return `${idx > -1 ? id.substring(0, idx) : id}${stringify(options?.stamp ? { stamp: options.stamp } : {})}`;
+	else return `${idx > -1 ? id.substring(0, idx) : id}${stringify(options)}`;
+}
+function getOnReadyEventKey(path) {
+	return path + ".onReady";
+}
+function getOnShowEventKey(path) {
+	return path + ".onShow";
+}
+function getOnHideEventKey(path) {
+	return path + ".onHide";
+}
+function createPageConfig(component, pageName, data, pageConfig) {
+	const id = pageName ?? `taro_page_${pageId()}`;
+	const [ONLOAD, ONUNLOAD, ONREADY, ONSHOW, ONHIDE, LIFECYCLES, SIDE_EFFECT_LIFECYCLES] = hooks$1.call("getMiniLifecycleImpl").page;
+	let pageElement = null;
+	let unmounting = false;
+	let prepareMountList = [];
+	function setCurrentRouter(page) {
+		const router = process.env.TARO_PLATFORM === "web" ? page.$taroPath : page.route || page.__route__ || page.$taroPath;
+		Current.router = {
+			params: page.$taroParams,
+			path: addLeadingSlash(router),
+			$taroPath: page.$taroPath,
+			onReady: getOnReadyEventKey(id),
+			onShow: getOnShowEventKey(id),
+			onHide: getOnHideEventKey(id)
+		};
+		if (!isUndefined(page.exitState)) Current.router.exitState = page.exitState;
+	}
+	let loadResolver;
+	let hasLoaded;
+	const config = {
+		[ONLOAD](options = {}, cb) {
+			hasLoaded = new Promise((resolve) => {
+				loadResolver = resolve;
+			});
+			perf.start(PAGE_INIT);
+			Current.page = this;
+			this.config = pageConfig || {};
+			const uniqueOptions = Object.assign({}, options, { $taroTimestamp: Date.now() });
+			const $taroPath = this.$taroPath = getPath(id, uniqueOptions);
+			if (process.env.TARO_PLATFORM === "web") config.path = $taroPath;
+			if (this.$taroParams == null) this.$taroParams = uniqueOptions;
+			setCurrentRouter(this);
+			if (process.env.TARO_PLATFORM !== "web") taroWindowProvider.trigger("0", $taroPath);
+			const mount = () => {
+				Current.app.mount(component, $taroPath, () => {
+					if (process.env.TARO_ENV === "tt" && isEnableTTDom()) pageElement = env.document.getPageDocumentById(this.__webviewId__);
+					else pageElement = env.document.getElementById($taroPath);
+					ensure(pageElement !== null, "没有找到页面实例。");
+					safeExecute($taroPath, ON_LOAD, this.$taroParams);
+					loadResolver();
+					if (process.env.TARO_PLATFORM !== "web") {
+						pageElement.ctx = this;
+						if (process.env.TARO_ENV === "tt" && isEnableTTDom()) pageElement.sync();
+						else pageElement.performUpdate(true, cb);
+					} else isFunction(cb) && cb();
+				});
+			};
+			if (unmounting) prepareMountList.push(mount);
+			else mount();
+		},
+		[ONUNLOAD]() {
+			const $taroPath = this.$taroPath;
+			if (process.env.TARO_PLATFORM !== "web") taroWindowProvider.trigger("3", $taroPath);
+			safeExecute($taroPath, ONUNLOAD);
+			unmounting = true;
+			Current.app.unmount($taroPath, () => {
+				unmounting = false;
+				instances.delete($taroPath);
+				if (pageElement) {
+					pageElement.ctx = null;
+					pageElement = null;
+				}
+				if (prepareMountList.length) {
+					prepareMountList.forEach((fn) => fn());
+					prepareMountList = [];
+				}
+			});
+		},
+		[ONREADY]() {
+			hasLoaded.then(() => {
+				safeExecute(this.$taroPath, ON_READY);
+				_raf(() => eventCenter.trigger(getOnReadyEventKey(id)));
+				this.onReady.called = true;
+			});
+		},
+		[ONSHOW](options = {}) {
+			hasLoaded.then(() => {
+				Current.page = this;
+				setCurrentRouter(this);
+				if (process.env.TARO_PLATFORM !== "web") taroWindowProvider.trigger("2", this.$taroPath);
+				safeExecute(this.$taroPath, ON_SHOW, options);
+				_raf(() => eventCenter.trigger(getOnShowEventKey(id)));
+			});
+		},
+		[ONHIDE]() {
+			if (process.env.TARO_PLATFORM !== "web") taroWindowProvider.trigger("1", this.$taroPath);
+			if (Current.page === this) {
+				Current.page = null;
+				Current.router = null;
+			}
+			safeExecute(this.$taroPath, ON_HIDE);
+			eventCenter.trigger(getOnHideEventKey(id));
+		}
+	};
+	if (process.env.TARO_PLATFORM === "web") config.getOpenerEventChannel = () => {
+		return EventChannel.pageChannel;
+	};
+	const isSWAN = process.env.TARO_ENV === "swan";
+	LIFECYCLES.forEach((lifecycle) => {
+		let isDefer = false;
+		let isEvent = false;
+		lifecycle = lifecycle.replace(/^defer:/, () => {
+			isDefer = true;
+			return "";
+		});
+		lifecycle = lifecycle.replace(/^events:/, () => {
+			isEvent = true;
+			return "";
+		});
+		if (isEvent && process.env.TARO_ENV === "alipay") {
+			if (!config.events) config.events = {};
+			config.events[lifecycle] = function() {
+				return safeExecute(this.$taroPath, lifecycle, ...arguments);
+			};
+		} else config[lifecycle] = function() {
+			const exec = () => safeExecute(this.$taroPath, lifecycle, ...arguments);
+			if (isSWAN) return exec();
+			if (isDefer) hasLoaded.then(exec);
+			else return exec();
+		};
+	});
+	SIDE_EFFECT_LIFECYCLES.forEach((lifecycle) => {
+		if (component[lifecycle] || component.prototype?.[lifecycle] || component[lifecycle.replace(/^on/, "enable")] || pageConfig?.[lifecycle.replace(/^on/, "enable")]) config[lifecycle] = function(...args) {
+			const target = args[0]?.target;
+			if (target?.id) {
+				const id = target.id;
+				const element = env.document.getElementById(id);
+				if (element) target.dataset = element.dataset;
+			}
+			return safeExecute(this.$taroPath, lifecycle, ...args);
+		};
+	});
+	config.eh = eventHandler;
+	if (!isUndefined(data)) config.data = data;
+	hooks$1.call("modifyPageObject", config);
+	return config;
+}
+function createComponentConfig(component, componentName, data) {
+	const id = componentName ?? `taro_component_${pageId()}`;
+	let componentElement = null;
+	const [ATTACHED, DETACHED] = hooks$1.call("getMiniLifecycleImpl").component;
+	const config = {
+		[ATTACHED]() {
+			perf.start(PAGE_INIT);
+			this.pageIdCache = this.getPageId?.() || pageId();
+			const path = getPath(id, { id: this.pageIdCache });
+			Current.app.mount(component, path, () => {
+				componentElement = env.document.getElementById(path);
+				ensure(componentElement !== null, "没有找到组件实例。");
+				this.$taroInstances = instances.get(path);
+				safeExecute(path, ON_LOAD);
+				if (process.env.TARO_PLATFORM !== "web") {
+					componentElement.ctx = this;
+					if (process.env.TARO_ENV !== "tt" || !isEnableTTDom()) componentElement.performUpdate(true);
+				}
+			});
+		},
+		[DETACHED]() {
+			const path = getPath(id, { id: this.pageIdCache });
+			Current.app.unmount(path, () => {
+				instances.delete(path);
+				if (componentElement) componentElement.ctx = null;
+			});
+		},
+		methods: { eh: eventHandler }
+	};
+	if (!isUndefined(data)) config.data = data;
+	[
+		OPTIONS,
+		EXTERNAL_CLASSES,
+		BEHAVIORS
+	].forEach((key) => {
+		config[key] = component[key] ?? EMPTY_OBJ;
+	});
+	return config;
+}
+function createRecursiveComponentConfig(componentName) {
+	const isCustomWrapper = componentName === CUSTOM_WRAPPER;
+	const [ATTACHED, DETACHED] = hooks$1.call("getMiniLifecycleImpl").component;
+	const lifeCycles = isCustomWrapper ? {
+		[ATTACHED]() {
+			if (process.env.TARO_ENV === "tt" && isEnableTTDom()) return;
+			const componentId = this.data.i?.sid || this.props.i?.sid;
+			if (isString(componentId)) {
+				customWrapperCache.set(componentId, this);
+				const el = env.document.getElementById(componentId);
+				if (el) el.ctx = this;
+			}
+		},
+		[DETACHED]() {
+			if (process.env.TARO_ENV === "tt" && isEnableTTDom()) return;
+			const componentId = this.data.i?.sid || this.props.i?.sid;
+			if (isString(componentId)) {
+				customWrapperCache.delete(componentId);
+				const el = env.document.getElementById(componentId);
+				if (el) el.ctx = null;
+			}
+		}
+	} : EMPTY_OBJ;
+	const extraOptions = {};
+	if (process.env.TARO_ENV === "jd") extraOptions.addGlobalClass = true;
+	return hooks$1.call("modifyRecursiveComponentConfig", {
+		properties: {
+			i: {
+				type: Object,
+				value: { [Shortcuts.NodeName]: getComponentsAlias$1(internalComponents)[VIEW]._num }
+			},
+			l: {
+				type: String,
+				value: ""
+			}
+		},
+		options: {
+			...extraOptions,
+			virtualHost: !isCustomWrapper
+		},
+		methods: { eh: eventHandler },
+		...lifeCycles
+	}, { isCustomWrapper });
+}
+//#endregion
+//#region src/next-tick.ts
+const TIMEOUT = 100;
+const nextTick = (cb, ctx) => {
+	const beginTime = Date.now();
+	const router = Current.router;
+	const timerFunc = () => {
+		setTimeout(function() {
+			ctx ? cb.call(ctx) : cb();
+		}, 1);
+	};
+	if (router === null) return timerFunc();
+	const path = router.$taroPath;
+	/**
+	* 三种情况
+	*   1. 调用 nextTick 时，pendingUpdate 已经从 true 变为 false（即已更新完成），那么需要光等 100ms
+	*   2. 调用 nextTick 时，pendingUpdate 为 true，那么刚好可以搭上便车
+	*   3. 调用 nextTick 时，pendingUpdate 还是 false，框架仍未启动更新逻辑，这时最多轮询 100ms，等待 pendingUpdate 变为 true。
+	*/
+	function next() {
+		const pageElement = env.document.getElementById(path);
+		if (pageElement?.pendingUpdate) if (process.env.TARO_PLATFORM === "web") pageElement.firstChild?.["componentOnReady"]?.().then(() => {
+			timerFunc();
+		}) ?? timerFunc();
+		else pageElement.enqueueUpdateCallback(cb, ctx);
+		else if (Date.now() - beginTime > TIMEOUT) timerFunc();
+		else setTimeout(() => next(), 20);
+	}
+	next();
+};
+//#endregion
+//#region src/polyfill/array.ts
+function handleArrayFindPolyfill() {
+	if (!isFunction(Array.prototype.find)) Object.defineProperty(Array.prototype, "find", { value(predicate) {
+		if (this == null) throw new TypeError("\"this\" is null or not defined");
+		const o = Object(this);
+		const len = o.length >>> 0;
+		if (!isFunction(predicate)) throw new TypeError("predicate must be a function");
+		const thisArg = arguments[1];
+		let k = 0;
+		while (k < len) {
+			const kValue = o[k];
+			if (predicate.call(thisArg, kValue, k, o)) return kValue;
+			k++;
+		}
+	} });
+}
+function handleArrayIncludesPolyfill() {
+	if (!isFunction(Array.prototype.includes)) Object.defineProperty(Array.prototype, "includes", { value(searchElement, fromIndex) {
+		if (this == null) throw new TypeError("\"this\" is null or not defined");
+		const o = Object(this);
+		const len = o.length >>> 0;
+		if (len === 0) return false;
+		const n = fromIndex | 0;
+		let k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+		while (k < len) {
+			if (o[k] === searchElement) return true;
+			k++;
+		}
+		return false;
+	} });
+}
+//#endregion
+//#region src/polyfill/intersection-observer.ts
+function handleIntersectionObserverPolyfill() {
+	if ("IntersectionObserver" in window && "IntersectionObserverEntry" in window && "intersectionRatio" in window.IntersectionObserverEntry.prototype) {
+		if (!("isIntersecting" in window.IntersectionObserverEntry.prototype)) Object.defineProperty(window.IntersectionObserverEntry.prototype, "isIntersecting", { get: function() {
+			return this.intersectionRatio > 0;
+		} });
+	} else handleIntersectionObserverObjectPolyfill();
+}
+function handleIntersectionObserverObjectPolyfill() {
+	const document = window.document;
+	/**
+	* An IntersectionObserver registry. This registry exists to hold a strong
+	* reference to IntersectionObserver instances currently observing a target
+	* element. Without this registry, instances without another reference may be
+	* garbage collected.
+	*/
+	const registry = [];
+	/**
+	* Creates the global IntersectionObserverEntry constructor.
+	* https://w3c.github.io/IntersectionObserver/#intersection-observer-entry
+	* @param {Object} entry A dictionary of instance properties.
+	* @constructor
+	*/
+	function IntersectionObserverEntry(entry) {
+		this.time = entry.time;
+		this.target = entry.target;
+		this.rootBounds = entry.rootBounds;
+		this.boundingClientRect = entry.boundingClientRect;
+		this.intersectionRect = entry.intersectionRect || getEmptyRect();
+		this.isIntersecting = !!entry.intersectionRect;
+		const targetRect = this.boundingClientRect;
+		const targetArea = targetRect.width * targetRect.height;
+		const intersectionRect = this.intersectionRect;
+		const intersectionArea = intersectionRect.width * intersectionRect.height;
+		if (targetArea) this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));
+		else this.intersectionRatio = this.isIntersecting ? 1 : 0;
+	}
+	/**
+	* Creates the global IntersectionObserver constructor.
+	* https://w3c.github.io/IntersectionObserver/#intersection-observer-interface
+	* @param {Function} callback The function to be invoked after intersection
+	*     changes have queued. The function is not invoked if the queue has
+	*     been emptied by calling the `takeRecords` method.
+	* @param {Object=} opt_options Optional configuration options.
+	* @constructor
+	*/
+	function IntersectionObserver(callback, options = {}) {
+		if (!isFunction(callback)) throw new Error("callback must be a function");
+		if (options.root && options.root.nodeType != 1) throw new Error("root must be an Element");
+		this._checkForIntersections = throttle(this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);
+		this._callback = callback;
+		this._observationTargets = [];
+		this._queuedEntries = [];
+		this._rootMarginValues = this._parseRootMargin(options.rootMargin);
+		this.thresholds = this._initThresholds(options.threshold);
+		this.root = options.root || null;
+		this.rootMargin = this._rootMarginValues.map(function(margin) {
+			return margin.value + margin.unit;
+		}).join(" ");
+	}
+	/**
+	* The minimum interval within which the document will be checked for
+	* intersection changes.
+	*/
+	IntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;
+	/**
+	* The frequency in which the polyfill polls for intersection changes.
+	* this can be updated on a per instance basis and must be set prior to
+	* calling `observe` on the first target.
+	*/
+	IntersectionObserver.prototype.POLL_INTERVAL = null;
+	/**
+	* Use a mutation observer on the root element
+	* to detect intersection changes.
+	*/
+	IntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;
+	/**
+	* Starts observing a target element for intersection changes based on
+	* the thresholds values.
+	* @param {Element} target The DOM element to observe.
+	*/
+	IntersectionObserver.prototype.observe = function(target) {
+		if (this._observationTargets.some(function(item) {
+			return item.element == target;
+		})) return;
+		if (!(target && target.nodeType == 1)) throw new Error("target must be an Element");
+		this._registerInstance();
+		this._observationTargets.push({
+			element: target,
+			entry: null
+		});
+		this._monitorIntersections();
+		this._checkForIntersections();
+	};
+	/**
+	* Stops observing a target element for intersection changes.
+	* @param {Element} target The DOM element to observe.
+	*/
+	IntersectionObserver.prototype.unobserve = function(target) {
+		this._observationTargets = this._observationTargets.filter(function(item) {
+			return item.element != target;
+		});
+		if (!this._observationTargets.length) {
+			this._unmonitorIntersections();
+			this._unregisterInstance();
+		}
+	};
+	/**
+	* Stops observing all target elements for intersection changes.
+	*/
+	IntersectionObserver.prototype.disconnect = function() {
+		this._observationTargets = [];
+		this._unmonitorIntersections();
+		this._unregisterInstance();
+	};
+	/**
+	* Returns any queue entries that have not yet been reported to the
+	* callback and clears the queue. This can be used in conjunction with the
+	* callback to obtain the absolute most up-to-date intersection information.
+	* @return {Array} The currently queued entries.
+	*/
+	IntersectionObserver.prototype.takeRecords = function() {
+		const records = this._queuedEntries.slice();
+		this._queuedEntries = [];
+		return records;
+	};
+	/**
+	* Accepts the threshold value from the user configuration object and
+	* returns a sorted array of unique threshold values. If a value is not
+	* between 0 and 1 and error is thrown.
+	* @private
+	* @param {Array|number=} opt_threshold An optional threshold value or
+	*     a list of threshold values, defaulting to [0].
+	* @return {Array} A sorted list of unique and valid threshold values.
+	*/
+	IntersectionObserver.prototype._initThresholds = function(opt_threshold) {
+		let threshold = opt_threshold || [0];
+		if (!Array.isArray(threshold)) threshold = [threshold];
+		return threshold.sort().filter(function(t, i, a) {
+			if (!isNumber(t) || isNaN(t) || t < 0 || t > 1) throw new Error("threshold must be a number between 0 and 1 inclusively");
+			return t !== a[i - 1];
+		});
+	};
+	/**
+	* Accepts the rootMargin value from the user configuration object
+	* and returns an array of the four margin values as an object containing
+	* the value and unit properties. If any of the values are not properly
+	* formatted or use a unit other than px or %, and error is thrown.
+	* @private
+	* @param {string=} opt_rootMargin An optional rootMargin value,
+	*     defaulting to '0px'.
+	* @return {Array<Object>} An array of margin objects with the keys
+	*     value and unit.
+	*/
+	IntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {
+		const margins = (opt_rootMargin || "0px").split(/\s+/).map(function(margin) {
+			const parts = /^(-?\d*\.?\d+)(px|%)$/.exec(margin);
+			if (!parts) throw new Error("rootMargin must be specified in pixels or percent");
+			return {
+				value: parseFloat(parts[1]),
+				unit: parts[2]
+			};
+		});
+		margins[1] = margins[1] || margins[0];
+		margins[2] = margins[2] || margins[0];
+		margins[3] = margins[3] || margins[1];
+		return margins;
+	};
+	/**
+	* Starts polling for intersection changes if the polling is not already
+	* happening, and if the page's visibility state is visible.
+	* @private
+	*/
+	IntersectionObserver.prototype._monitorIntersections = function() {
+		if (!this._monitoringIntersections) {
+			this._monitoringIntersections = true;
+			if (this.POLL_INTERVAL) this._monitoringInterval = setInterval(this._checkForIntersections, this.POLL_INTERVAL);
+			else {
+				addEvent(window, "resize", this._checkForIntersections, true);
+				addEvent(document, "scroll", this._checkForIntersections, true);
+				if (this.USE_MUTATION_OBSERVER && "MutationObserver" in window) {
+					this._domObserver = new MutationObserver(this._checkForIntersections);
+					this._domObserver.observe(document, {
+						attributes: true,
+						childList: true,
+						characterData: true,
+						subtree: true
+					});
+				}
+			}
+		}
+	};
+	/**
+	* Stops polling for intersection changes.
+	* @private
+	*/
+	IntersectionObserver.prototype._unmonitorIntersections = function() {
+		if (this._monitoringIntersections) {
+			this._monitoringIntersections = false;
+			clearInterval(this._monitoringInterval);
+			this._monitoringInterval = null;
+			removeEvent(window, "resize", this._checkForIntersections, true);
+			removeEvent(document, "scroll", this._checkForIntersections, true);
+			if (this._domObserver) {
+				this._domObserver.disconnect();
+				this._domObserver = null;
+			}
+		}
+	};
+	/**
+	* Scans each observation target for intersection changes and adds them
+	* to the internal entries queue. If new entries are found, it
+	* schedules the callback to be invoked.
+	* @private
+	*/
+	IntersectionObserver.prototype._checkForIntersections = function() {
+		const rootIsInDom = this._rootIsInDom();
+		const rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();
+		this._observationTargets.forEach(function(item) {
+			const target = item.element;
+			const targetRect = getBoundingClientRect(target);
+			const rootContainsTarget = this._rootContainsTarget(target);
+			const oldEntry = item.entry;
+			const intersectionRect = rootIsInDom && rootContainsTarget && this._computeTargetAndRootIntersection(target, rootRect);
+			const newEntry = item.entry = new IntersectionObserverEntry({
+				time: now(),
+				target,
+				boundingClientRect: targetRect,
+				rootBounds: rootRect,
+				intersectionRect,
+				intersectionRatio: -1,
+				isIntersecting: false
+			});
+			if (!oldEntry) this._queuedEntries.push(newEntry);
+			else if (rootIsInDom && rootContainsTarget) {
+				if (this._hasCrossedThreshold(oldEntry, newEntry)) this._queuedEntries.push(newEntry);
+			} else if (oldEntry && oldEntry.isIntersecting) this._queuedEntries.push(newEntry);
+		}, this);
+		if (this._queuedEntries.length) this._callback(this.takeRecords(), this);
+	};
+	/**
+	* Accepts a target and root rect computes the intersection between then
+	* following the algorithm in the spec.
+	* TODO(philipwalton): at this time clip-path is not considered.
+	* https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo
+	* @param {Element} target The target DOM element
+	* @param {Object} rootRect The bounding rect of the root after being
+	*     expanded by the rootMargin value.
+	* @return {?Object} The final intersection rect object or undefined if no
+	*     intersection is found.
+	* @private
+	*/
+	IntersectionObserver.prototype._computeTargetAndRootIntersection = function(target, rootRect) {
+		if (window.getComputedStyle(target).display === "none") return;
+		let intersectionRect = getBoundingClientRect(target);
+		let parent = getParentNode(target);
+		let atRoot = false;
+		while (!atRoot) {
+			let parentRect = null;
+			const parentComputedStyle = parent.nodeType == 1 ? window.getComputedStyle(parent) : {};
+			if (parentComputedStyle.display === "none") return;
+			if (parent == this.root || parent == document) {
+				atRoot = true;
+				parentRect = rootRect;
+			} else if (parent != document.body && parent != document.documentElement && parentComputedStyle.overflow != "visible") parentRect = getBoundingClientRect(parent);
+			if (parentRect) {
+				intersectionRect = computeRectIntersection(parentRect, intersectionRect);
+				if (!intersectionRect) break;
+			}
+			parent = getParentNode(parent);
+		}
+		return intersectionRect;
+	};
+	/**
+	* Returns the root rect after being expanded by the rootMargin value.
+	* @return {Object} The expanded root rect.
+	* @private
+	*/
+	IntersectionObserver.prototype._getRootRect = function() {
+		let rootRect;
+		if (this.root) rootRect = getBoundingClientRect(this.root);
+		else {
+			const html = document.documentElement;
+			const body = document.body;
+			rootRect = {
+				top: 0,
+				left: 0,
+				right: html.clientWidth || body.clientWidth,
+				width: html.clientWidth || body.clientWidth,
+				bottom: html.clientHeight || body.clientHeight,
+				height: html.clientHeight || body.clientHeight
+			};
+		}
+		return this._expandRectByRootMargin(rootRect);
+	};
+	/**
+	* Accepts a rect and expands it by the rootMargin value.
+	* @param {Object} rect The rect object to expand.
+	* @return {Object} The expanded rect.
+	* @private
+	*/
+	IntersectionObserver.prototype._expandRectByRootMargin = function(rect) {
+		const margins = this._rootMarginValues.map(function(margin, i) {
+			return margin.unit === "px" ? margin.value : margin.value * (i % 2 ? rect.width : rect.height) / 100;
+		});
+		const newRect = {
+			top: rect.top - margins[0],
+			right: rect.right + margins[1],
+			bottom: rect.bottom + margins[2],
+			left: rect.left - margins[3]
+		};
+		newRect.width = newRect.right - newRect.left;
+		newRect.height = newRect.bottom - newRect.top;
+		return newRect;
+	};
+	/**
+	* Accepts an old and new entry and returns true if at least one of the
+	* threshold values has been crossed.
+	* @param {?IntersectionObserverEntry} oldEntry The previous entry for a
+	*    particular target element or null if no previous entry exists.
+	* @param {IntersectionObserverEntry} newEntry The current entry for a
+	*    particular target element.
+	* @return {boolean} Returns true if a any threshold has been crossed.
+	* @private
+	*/
+	IntersectionObserver.prototype._hasCrossedThreshold = function(oldEntry, newEntry) {
+		const oldRatio = oldEntry && oldEntry.isIntersecting ? oldEntry.intersectionRatio || 0 : -1;
+		const newRatio = newEntry.isIntersecting ? newEntry.intersectionRatio || 0 : -1;
+		if (oldRatio === newRatio) return;
+		for (let i = 0; i < this.thresholds.length; i++) {
+			const threshold = this.thresholds[i];
+			if (threshold == oldRatio || threshold == newRatio || threshold < oldRatio !== threshold < newRatio) return true;
+		}
+	};
+	/**
+	* Returns whether or not the root element is an element and is in the DOM.
+	* @return {boolean} True if the root element is an element and is in the DOM.
+	* @private
+	*/
+	IntersectionObserver.prototype._rootIsInDom = function() {
+		return !this.root || containsDeep(document, this.root);
+	};
+	/**
+	* Returns whether or not the target element is a child of root.
+	* @param {Element} target The target element to check.
+	* @return {boolean} True if the target element is a child of root.
+	* @private
+	*/
+	IntersectionObserver.prototype._rootContainsTarget = function(target) {
+		return containsDeep(this.root || document, target);
+	};
+	/**
+	* Adds the instance to the global IntersectionObserver registry if it isn't
+	* already present.
+	* @private
+	*/
+	IntersectionObserver.prototype._registerInstance = function() {
+		if (registry.indexOf(this) < 0) registry.push(this);
+	};
+	/**
+	* Removes the instance from the global IntersectionObserver registry.
+	* @private
+	*/
+	IntersectionObserver.prototype._unregisterInstance = function() {
+		const index = registry.indexOf(this);
+		if (index != -1) registry.splice(index, 1);
+	};
+	/**
+	* Returns the result of the performance.now() method or null in browsers
+	* that don't support the API.
+	* @return {number} The elapsed time since the page was requested.
+	*/
+	function now() {
+		return window.performance && performance.now && performance.now();
+	}
+	/**
+	* Adds an event handler to a DOM node ensuring cross-browser compatibility.
+	* @param {Node} node The DOM node to add the event handler to.
+	* @param {string} event The event name.
+	* @param {Function} fn The event handler to add.
+	* @param {boolean} opt_useCapture Optionally adds the even to the capture
+	*     phase. Note: this only works in modern browsers.
+	*/
+	function addEvent(node, event, fn, opt_useCapture) {
+		if (isFunction(node.addEventListener)) node.addEventListener(event, fn, opt_useCapture || false);
+		else if (isFunction(node.attachEvent)) node.attachEvent("on" + event, fn);
+	}
+	/**
+	* Removes a previously added event handler from a DOM node.
+	* @param {Node} node The DOM node to remove the event handler from.
+	* @param {string} event The event name.
+	* @param {Function} fn The event handler to remove.
+	* @param {boolean} opt_useCapture If the event handler was added with this
+	*     flag set to true, it should be set to true here in order to remove it.
+	*/
+	function removeEvent(node, event, fn, opt_useCapture) {
+		if (isFunction(node.removeEventListener)) node.removeEventListener(event, fn, opt_useCapture || false);
+		else if (isFunction(node.detatchEvent)) node.detatchEvent("on" + event, fn);
+	}
+	/**
+	* Returns the intersection between two rect objects.
+	* @param {Object} rect1 The first rect.
+	* @param {Object} rect2 The second rect.
+	* @return {?Object} The intersection rect or undefined if no intersection
+	*     is found.
+	*/
+	function computeRectIntersection(rect1, rect2) {
+		const top = Math.max(rect1.top, rect2.top);
+		const bottom = Math.min(rect1.bottom, rect2.bottom);
+		const left = Math.max(rect1.left, rect2.left);
+		const right = Math.min(rect1.right, rect2.right);
+		const width = right - left;
+		const height = bottom - top;
+		return width >= 0 && height >= 0 && {
+			top,
+			bottom,
+			left,
+			right,
+			width,
+			height
+		};
+	}
+	/**
+	* Shims the native getBoundingClientRect for compatibility with older IE.
+	* @param {Element} el The element whose bounding rect to get.
+	* @return {Object} The (possibly shimmed) rect of the element.
+	*/
+	function getBoundingClientRect(el) {
+		let rect;
+		try {
+			rect = el.getBoundingClientRect();
+		} catch (err) {}
+		if (!rect) return getEmptyRect();
+		if (!(rect.width && rect.height)) rect = {
+			top: rect.top,
+			right: rect.right,
+			bottom: rect.bottom,
+			left: rect.left,
+			width: rect.right - rect.left,
+			height: rect.bottom - rect.top
+		};
+		return rect;
+	}
+	/**
+	* Returns an empty rect object. An empty rect is returned when an element
+	* is not in the DOM.
+	* @return {Object} The empty rect.
+	*/
+	function getEmptyRect() {
+		return {
+			top: 0,
+			bottom: 0,
+			left: 0,
+			right: 0,
+			width: 0,
+			height: 0
+		};
+	}
+	/**
+	* Checks to see if a parent element contains a child element (including inside
+	* shadow DOM).
+	* @param {Node} parent The parent element.
+	* @param {Node} child The child element.
+	* @return {boolean} True if the parent node contains the child node.
+	*/
+	function containsDeep(parent, child) {
+		let node = child;
+		while (node) {
+			if (node == parent) return true;
+			node = getParentNode(node);
+		}
+		return false;
+	}
+	/**
+	* Gets the parent node of an element or its host element if the parent node
+	* is a shadow root.
+	* @param {Node} node The node whose parent to get.
+	* @return {Node|null} The parent node or null if no parent exists.
+	*/
+	function getParentNode(node) {
+		const parent = node.parentNode;
+		if (parent && parent.nodeType == 11 && parent.host) return parent.host;
+		if (parent && parent.assignedSlot) return parent.assignedSlot.parentNode;
+		return parent;
+	}
+	window.IntersectionObserver = IntersectionObserver;
+	window.IntersectionObserverEntry = IntersectionObserverEntry;
+}
+//#endregion
+//#region src/polyfill/object.ts
+function handleObjectAssignPolyfill() {
+	if (!isFunction(Object.assign)) Object.assign = function(target) {
+		if (target == null) throw new TypeError("Cannot convert undefined or null to object");
+		const to = Object(target);
+		for (let index = 1; index < arguments.length; index++) {
+			const nextSource = arguments[index];
+			if (nextSource != null) {
+				for (const nextKey in nextSource) if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) to[nextKey] = nextSource[nextKey];
+			}
+		}
+		return to;
+	};
+}
+function handleObjectEntriesPolyfill() {
+	if (!isFunction(Object.entries)) Object.entries = function(obj) {
+		if (obj == null) throw new TypeError("Cannot convert undefined or null to object");
+		const to = [];
+		if (obj != null) {
+			for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) to.push([key, obj[key]]);
+		}
+		return to;
+	};
+}
+function handleObjectDefinePropertyPolyfill() {
+	if (!isFunction(Object.defineProperties)) Object.defineProperties = function(obj, properties) {
+		function convertToDescriptor(desc) {
+			function hasProperty(obj, prop) {
+				return Object.prototype.hasOwnProperty.call(obj, prop);
+			}
+			if (!isObject(desc)) throw new TypeError("bad desc");
+			const d = {};
+			if (hasProperty(desc, "enumerable")) d.enumerable = !!desc.enumerable;
+			if (hasProperty(desc, "configurable")) d.configurable = !!desc.configurable;
+			if (hasProperty(desc, "value")) d.value = desc.value;
+			if (hasProperty(desc, "writable")) d.writable = !!desc.writable;
+			if (hasProperty(desc, "get")) {
+				const g = desc.get;
+				if (!isFunction(g) && !isUndefined(g)) throw new TypeError("bad get");
+				d.get = g;
+			}
+			if (hasProperty(desc, "set")) {
+				const s = desc.set;
+				if (!isFunction(s) && !isUndefined(s)) throw new TypeError("bad set");
+				d.set = s;
+			}
+			if (("get" in d || "set" in d) && ("value" in d || "writable" in d)) throw new TypeError("identity-confused descriptor");
+			return d;
+		}
+		if (!isObject(obj)) throw new TypeError("bad obj");
+		properties = Object(properties);
+		const keys = Object.keys(properties);
+		const descs = [];
+		for (let i = 0; i < keys.length; i++) descs.push([keys[i], convertToDescriptor(properties[keys[i]])]);
+		for (let i = 0; i < descs.length; i++) Object.defineProperty(obj, descs[i][0], descs[i][1]);
+		return obj;
+	};
+}
+//#endregion
+//#region src/polyfill/index.ts
+function handlePolyfill() {
+	if (process.env.SUPPORT_TARO_POLYFILL === "enabled" || process.env.SUPPORT_TARO_POLYFILL === "Object" || process.env.SUPPORT_TARO_POLYFILL === "Object.assign") handleObjectAssignPolyfill();
+	if (process.env.SUPPORT_TARO_POLYFILL === "enabled" || process.env.SUPPORT_TARO_POLYFILL === "Object" || process.env.SUPPORT_TARO_POLYFILL === "Object.entries") handleObjectEntriesPolyfill();
+	if (process.env.SUPPORT_TARO_POLYFILL === "enabled" || process.env.SUPPORT_TARO_POLYFILL === "Object" || process.env.SUPPORT_TARO_POLYFILL === "Object.defineProperty") handleObjectDefinePropertyPolyfill();
+	if (process.env.SUPPORT_TARO_POLYFILL === "enabled" || process.env.SUPPORT_TARO_POLYFILL === "Array" || process.env.SUPPORT_TARO_POLYFILL === "Array.find") handleArrayFindPolyfill();
+	if (process.env.SUPPORT_TARO_POLYFILL === "enabled" || process.env.SUPPORT_TARO_POLYFILL === "Array" || process.env.SUPPORT_TARO_POLYFILL === "Array.includes") handleArrayIncludesPolyfill();
+	if (process.env.TARO_PLATFORM === "web" && isObject(window)) {
+		if (process.env.SUPPORT_TARO_POLYFILL === "enabled" || process.env.SUPPORT_TARO_POLYFILL === "IntersectionObserver") handleIntersectionObserverPolyfill();
+	}
+}
+if (process.env.SUPPORT_TARO_POLYFILL !== "disabled" && process.env.TARO_PLATFORM !== "web") handlePolyfill();
+//#endregion
+export { A, APP, BEHAVIORS, BODY, CATCHMOVE, CATCH_VIEW, CHANGE, CLASS, CLICK_VIEW, COMMENT, COMPILE_MODE, CONFIRM, CONTAINER, CONTEXT_ACTIONS, CURRENT_TARGET, CUSTOM_WRAPPER, Current, DATASET, DATE, DOCUMENT_ELEMENT_NAME, DOCUMENT_FRAGMENT, EVENT_CALLBACK_RESULT, EXTERNAL_CLASSES, Events, FOCUS, FormElement, HEAD, HOOKS_APP_ID, HTML, History, ID, INPUT, KEY_CODE, Location, MutationObserver$1 as MutationObserver, OBJECT, ON_HIDE, ON_LOAD, ON_READY, ON_SHOW, OPTIONS, PAGE_INIT, PROPERTY_THRESHOLD, PROPS, PURE_VIEW, ROOT_STR, SET_DATA, SET_TIMEOUT, STATIC_VIEW, STYLE, SVGElement, Style, TARGET, TARO_RUNTIME, TIME_STAMP, TOUCHMOVE, TYPE, TaroElement, TaroEvent, TaroNode, TaroRootElement, TaroText, UID, TaroURLProvider as URL, URLSearchParams, VALUE, VIEW, addLeadingSlash, _caf as cancelAnimationFrame, convertNumber2PX, createComponentConfig, createEvent, createPageConfig, createRecursiveComponentConfig, customWrapperCache, debounce, taroDocumentProvider as document, env, eventCenter, eventHandler, eventHandlerTTDom, eventSource, extend, getComponentsAlias, taroGetComputedStyleProvider as getComputedStyle, getCurrentInstance, getCurrentPage, getHomePage, getOnHideEventKey, getOnReadyEventKey, getOnShowEventKey, getPageInstance, getPath, handlePolyfill, hasBasename, taroHistoryProvider as history, hooks, hydrate, incrementId, injectPageInstance, isComment, isElement, isHasExtractProp, isParentBound, isText, taroLocationProvider as location, nav as navigator, nextTick, now, options, parseUrl, perf, removePageInstance, _raf as requestAnimationFrame, safeExecute, shortcutAttr, stringify, stripBasename, stripSuffix, stripTrailing, throttle, taroWindowProvider as window };
+
+//# sourceMappingURL=runtime.esm.js.map