@spcsn/taro-runtime 0.1.0

package/dist/index.cjs.js

@@ -0,0 +1,3776 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _spcsn_taro_shared = require("@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 {
+			if (process.env.NODE_ENV !== "production") console.warn("[Taro Warning] 若要使用 MutationObserver，请在 Taro 编译配置中设置 'mini.runtime.enableMutationObserver: true'");
+			this.core = {
+				observe: _spcsn_taro_shared.noop,
+				disconnect: _spcsn_taro_shared.noop,
+				takeRecords: _spcsn_taro_shared.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 = _spcsn_taro_shared.hooks.call("getEventCenter", _spcsn_taro_shared.Events);
+//#endregion
+//#region src/env.ts
+const env = {
+	window: process.env.TARO_PLATFORM === "web" ? window : _spcsn_taro_shared.EMPTY_OBJ,
+	document: process.env.TARO_PLATFORM === "web" ? document : _spcsn_taro_shared.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 _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 = (0, _spcsn_taro_shared.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) {
+					if (process.env.NODE_ENV !== "production") console.warn(`[Taro warn] URL 参数 ${value} decode 异常`);
+				}
+			}
+		} else if ((0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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) {
+		(0, _spcsn_taro_shared.isString)(val) && (this.#protocol = val.trim());
+	}
+	get host() {
+		return this.hostname + (this.port ? ":" + this.port : "");
+	}
+	set host(val) {
+		if (val && (0, _spcsn_taro_shared.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 && (0, _spcsn_taro_shared.isString)(val) && (this.#hostname = val.trim());
+	}
+	get port() {
+		return this.#port;
+	}
+	set port(val) {
+		(0, _spcsn_taro_shared.isString)(val) && (this.#port = val.trim());
+	}
+	get pathname() {
+		return this.#pathname;
+	}
+	set pathname(val) {
+		if ((0, _spcsn_taro_shared.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 ((0, _spcsn_taro_shared.isString)(val)) {
+			val = val.trim();
+			this.#search = new URLSearchParams(val);
+		}
+	}
+	get hash() {
+		return this.#hash;
+	}
+	set hash(val) {
+		if ((0, _spcsn_taro_shared.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 && (0, _spcsn_taro_shared.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 && (0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.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 || !(0, _spcsn_taro_shared.isString)(val) || !/^(http:|https:)?\/\/.+/.test(val = val.trim())) return;
+		const preValue = this.#getPreValue();
+		this.#url.origin = val;
+		if (this.#checkUrlChange(preValue)) this.#recordHistory();
+	}
+	assign() {
+		(0, _spcsn_taro_shared.warn)(true, "小程序环境中调用location.assign()无效.");
+	}
+	reload() {
+		(0, _spcsn_taro_shared.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 _spcsn_taro_shared.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) {
+				if (process.env.NODE_ENV !== "production") 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 (!(0, _spcsn_taro_shared.isString)(event)) return;
+		this.on(event, callback, null);
+	}
+	removeEventListener(event, callback) {
+		if (!(0, _spcsn_taro_shared.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 _spcsn_taro_shared.Shortcuts.Style;
+		case "id": return "uid";
+		case CLASS: return _spcsn_taro_shared.Shortcuts.Class;
+		default: return key;
+	}
+}
+const customWrapperCache = /* @__PURE__ */ new Map();
+function extend(ctor, methodName, options) {
+	if ((0, _spcsn_taro_shared.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 = (0, _spcsn_taro_shared.getComponentsAlias)(_spcsn_taro_shared.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 ||= _spcsn_taro_shared.hooks.call("getSpecialNodes");
+	const nodeName = node.nodeName;
+	let compileModeName = null;
+	if (isText(node)) return {
+		sid: node.sid,
+		[_spcsn_taro_shared.Shortcuts.Text]: node.nodeValue,
+		[_spcsn_taro_shared.Shortcuts.NodeName]: componentsAlias[nodeName]?._num || "8"
+	};
+	const data = {
+		[_spcsn_taro_shared.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[_spcsn_taro_shared.Shortcuts.NodeName] = `static-${nodeName}`;
+			if (nodeName === "view" && !isHasExtractProp(node)) data[_spcsn_taro_shared.Shortcuts.NodeName] = PURE_VIEW;
+		}
+		if (nodeName === "view" && node.isOnlyClickBinded() && !isHasExtractProp(node)) data[_spcsn_taro_shared.Shortcuts.NodeName] = CLICK_VIEW;
+	}
+	const { props } = node;
+	for (const prop in props) {
+		const propInCamelCase = (0, _spcsn_taro_shared.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[_spcsn_taro_shared.Shortcuts.NodeName] = CATCH_VIEW;
+		if (propInCamelCase === "compileMode") compileModeName = props[prop];
+	}
+	data[_spcsn_taro_shared.Shortcuts.Childnodes] = node.childNodes.filter((node) => !isComment(node)).map(hydrate);
+	if (node.className !== "") data[_spcsn_taro_shared.Shortcuts.Class] = node.className;
+	const cssText = node.cssText;
+	if (cssText !== "" && nodeName !== "swiper-item") data[_spcsn_taro_shared.Shortcuts.Style] = cssText;
+	_spcsn_taro_shared.hooks.call("modifyHydrateData", data, node);
+	const nn = data[_spcsn_taro_shared.Shortcuts.NodeName];
+	const componentAlias = componentsAlias[nn];
+	if (componentAlias) {
+		data[_spcsn_taro_shared.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[_spcsn_taro_shared.Shortcuts.NodeName] = compileModeName;
+	return _spcsn_taro_shared.hooks.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();
+		_spcsn_taro_shared.hooks.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 ((0, _spcsn_taro_shared.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;
+		}
+		process.env.NODE_ENV !== "production" && (0, _spcsn_taro_shared.warn)(isCapture, "Taro 暂未实现 event 的 capture 特性。");
+		const oldHandler = handler;
+		handler = function() {
+			return oldHandler.apply(this, arguments);
+		};
+		handler.oldHandler = oldHandler;
+		const handlers = this.__handlers[type];
+		if ((0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.isArray)(handlers)) return;
+		const index = handlers.findIndex((item) => {
+			if (item === handler || item.oldHandler === handler) return true;
+		});
+		process.env.NODE_ENV !== "production" && (0, _spcsn_taro_shared.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 = _spcsn_taro_shared.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);
+		(0, _spcsn_taro_shared.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 = _spcsn_taro_shared.hooks.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}.${_spcsn_taro_shared.Shortcuts.Style}`,
+		value: obj.cssText
+	});
+}
+function setStyle(newVal, styleKey) {
+	process.env.NODE_ENV !== "production" && (0, _spcsn_taro_shared.warn)((0, _spcsn_taro_shared.isString)(newVal) && newVal.length > 2046, `Style 属性 ${styleKey} 的值数据量过大，可能会影响渲染性能，考虑使用 CSS 类或其它方案替代。`);
+	if (this[styleKey] === newVal) return;
+	!this._pending && recordCss(this);
+	if ((0, _spcsn_taro_shared.isNull)(newVal) || (0, _spcsn_taro_shared.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 (0, _spcsn_taro_shared.isNull)(val) || (0, _spcsn_taro_shared.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 ((0, _spcsn_taro_shared.isNull)(val) || (0, _spcsn_taro_shared.isUndefined)(val)) return;
+			let styleName = isCssVariable(key) ? key : (0, _spcsn_taro_shared.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 === "" || (0, _spcsn_taro_shared.isUndefined)(str) || (0, _spcsn_taro_shared.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 ((0, _spcsn_taro_shared.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 = (0, _spcsn_taro_shared.toCamelCase)(propertyName);
+		if ((0, _spcsn_taro_shared.isNull)(value) || (0, _spcsn_taro_shared.isUndefined)(value)) this.removeProperty(propertyName);
+		else this[propertyName] = value;
+	}
+	removeProperty(propertyName) {
+		propertyName = (0, _spcsn_taro_shared.toCamelCase)(propertyName);
+		if (!this._usedStyleProp.has(propertyName)) return "";
+		const value = this[propertyName];
+		this[propertyName] = void 0;
+		return value;
+	}
+	getPropertyValue(propertyName) {
+		propertyName = (0, _spcsn_taro_shared.toCamelCase)(propertyName);
+		const value = this[propertyName];
+		if (!value) return "";
+		return value;
+	}
+};
+initStyle(Style, styleProperties);
+_spcsn_taro_shared.hooks.tap("injectNewStyleProperties", (newStyleProperties) => {
+	if ((0, _spcsn_taro_shared.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 = _spcsn_taro_shared.EMPTY_OBJ;
+		this.nodeType = 1;
+		this.style = new Style(this);
+		_spcsn_taro_shared.hooks.call("patchElement", this);
+	}
+	_stopPropagation(event) {
+		let target = this;
+		while (target = target.parentNode) {
+			const listeners = target.__handlers[event.type];
+			if (!(0, _spcsn_taro_shared.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 !(0, _spcsn_taro_shared.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) {
+		process.env.NODE_ENV !== "production" && (0, _spcsn_taro_shared.warn)((0, _spcsn_taro_shared.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 === _spcsn_taro_shared.EMPTY_OBJ) this.dataset = Object.create(null);
+					this.dataset[(0, _spcsn_taro_shared.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 = (0, _spcsn_taro_shared.toCamelCase)(qualifiedName);
+		const payload = {
+			path: `${_path}.${qualifiedNameInCamelCase}`,
+			value: (0, _spcsn_taro_shared.isFunction)(value) ? () => value : value
+		};
+		_spcsn_taro_shared.hooks.call("modifySetAttrPayload", this, qualifiedName, payload, componentsAlias);
+		if (_alias) payload.path = `${_path}.${(0, _spcsn_taro_shared.toCamelCase)(_alias[qualifiedNameInCamelCase] || qualifiedName)}`;
+		this.enqueueUpdate(payload);
+		if (this.nodeName === "view") {
+			if (qualifiedNameInCamelCase === "catchMove") this.enqueueUpdate({
+				path: `${_path}.${_spcsn_taro_shared.Shortcuts.NodeName}`,
+				value: value ? catchViewAlias : this.isOnlyClickBinded() && !isHasExtractProp(this) ? clickViewAlias : this.isAnyEventBinded() ? viewAlias : staticViewAlias
+			});
+			else if (isPureView && isHasExtractProp(this)) this.enqueueUpdate({
+				path: `${_path}.${_spcsn_taro_shared.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 (_spcsn_taro_shared.hooks.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 = (0, _spcsn_taro_shared.toCamelCase)(qualifiedName);
+		const payload = {
+			path: `${_path}.${qualifiedNameInCamelCase}`,
+			value: ""
+		};
+		_spcsn_taro_shared.hooks.call("modifyRmAttrPayload", this, qualifiedName, payload, componentsAlias);
+		if (_alias) payload.path = `${_path}.${(0, _spcsn_taro_shared.toCamelCase)(_alias[qualifiedNameInCamelCase] || qualifiedName)}`;
+		this.enqueueUpdate(payload);
+		if (this.nodeName === "view") {
+			if (qualifiedNameInCamelCase === "catchMove") this.enqueueUpdate({
+				path: `${_path}.${_spcsn_taro_shared.Shortcuts.NodeName}`,
+				value: this.isOnlyClickBinded() && !isHasExtractProp(this) ? clickViewAlias : this.isAnyEventBinded() ? viewAlias : isHasExtractProp(this) ? staticViewAlias : pureViewAlias
+			});
+			else if (isStaticView && !isHasExtractProp(this)) this.enqueueUpdate({
+				path: `${_path}.${_spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.isArray)(listeners)) return false;
+		for (let i = listeners.length; i--;) {
+			const listener = listeners[i];
+			let result;
+			if (listener._stop) listener._stop = false;
+			else {
+				_spcsn_taro_shared.hooks.call("modifyDispatchEvent", event, this);
+				result = listener.call(this, event);
+			}
+			if ((result === false || event._end) && cancelable) event.defaultPrevented = true;
+			if (!(0, _spcsn_taro_shared.isUndefined)(result) && event.mpEvent) {
+				if (_spcsn_taro_shared.hooks.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 = _spcsn_taro_shared.hooks.call("getSpecialNodes");
+		let sideEffect = true;
+		if ((0, _spcsn_taro_shared.isObject)(options) && options.sideEffect === false) {
+			sideEffect = false;
+			delete options.sideEffect;
+		}
+		_spcsn_taro_shared.hooks.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}.${_spcsn_taro_shared.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 = _spcsn_taro_shared.hooks.call("getSpecialNodes");
+		_spcsn_taro_shared.hooks.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}.${_spcsn_taro_shared.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 : _spcsn_taro_shared.EMPTY_OBJ,
+				...element !== null ? element.dataset : _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 };
+	_spcsn_taro_shared.hooks.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);
+			_spcsn_taro_shared.hooks.call("modifyTaroEvent", e, node);
+			_spcsn_taro_shared.hooks.call("dispatchTaroEvent", e, node);
+			_spcsn_taro_shared.hooks.call("dispatchTaroEventFinish", e, node);
+		};
+		if (_spcsn_taro_shared.hooks.isExist("batchedEventUpdates")) {
+			const type = event.type;
+			if (!_spcsn_taro_shared.hooks.call("isBubbleEvents", type) || !isParentBound(node, type) || type === "touchmove" && !!node.props.catchMove) {
+				_spcsn_taro_shared.hooks.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 ((0, _spcsn_taro_shared.isArray)(currentData)) currentData = currentData.filter((el) => !isComment(el));
+		if ((0, _spcsn_taro_shared.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 = _spcsn_taro_shared.hooks.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(_spcsn_taro_shared.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 ((0, _spcsn_taro_shared.isFunction)(value)) data[path] = value();
+			}
+			if ((0, _spcsn_taro_shared.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 (process.env.NODE_ENV !== "production" && options.debug) console.log("custom wrapper setData: ", data);
+				ctx.setData(data, cb);
+			});
+			if (isNeedNormalUpdate) {
+				if (process.env.NODE_ENV !== "production" && 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}.${_spcsn_taro_shared.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 _spcsn_taro_shared.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((0, _spcsn_taro_shared.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 (0, _spcsn_taro_shared.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([..._spcsn_taro_shared.DEFAULT_COMPONENTS, ..._spcsn_taro_shared.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 = (0, _spcsn_taro_shared.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) {
+	_spcsn_taro_shared.hooks.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 = _spcsn_taro_shared.hooks.call("getLifecycle", instance, lifecycle);
+	if ((0, _spcsn_taro_shared.isArray)(func)) return func.map((fn) => fn.apply(instance, args))[0];
+	if (!(0, _spcsn_taro_shared.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] = _spcsn_taro_shared.hooks.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 (!(0, _spcsn_taro_shared.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" && (0, _spcsn_taro_shared.isEnableTTDom)()) pageElement = env.document.getPageDocumentById(this.__webviewId__);
+					else pageElement = env.document.getElementById($taroPath);
+					(0, _spcsn_taro_shared.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" && (0, _spcsn_taro_shared.isEnableTTDom)()) pageElement.sync();
+						else pageElement.performUpdate(true, cb);
+					} else (0, _spcsn_taro_shared.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 _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.isUndefined)(data)) config.data = data;
+	_spcsn_taro_shared.hooks.call("modifyPageObject", config);
+	return config;
+}
+function createComponentConfig(component, componentName, data) {
+	const id = componentName ?? `taro_component_${pageId()}`;
+	let componentElement = null;
+	const [ATTACHED, DETACHED] = _spcsn_taro_shared.hooks.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);
+				(0, _spcsn_taro_shared.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" || !(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.isUndefined)(data)) config.data = data;
+	[
+		OPTIONS,
+		EXTERNAL_CLASSES,
+		BEHAVIORS
+	].forEach((key) => {
+		config[key] = component[key] ?? _spcsn_taro_shared.EMPTY_OBJ;
+	});
+	return config;
+}
+function createRecursiveComponentConfig(componentName) {
+	const isCustomWrapper = componentName === CUSTOM_WRAPPER;
+	const [ATTACHED, DETACHED] = _spcsn_taro_shared.hooks.call("getMiniLifecycleImpl").component;
+	const lifeCycles = isCustomWrapper ? {
+		[ATTACHED]() {
+			if (process.env.TARO_ENV === "tt" && (0, _spcsn_taro_shared.isEnableTTDom)()) return;
+			const componentId = this.data.i?.sid || this.props.i?.sid;
+			if ((0, _spcsn_taro_shared.isString)(componentId)) {
+				customWrapperCache.set(componentId, this);
+				const el = env.document.getElementById(componentId);
+				if (el) el.ctx = this;
+			}
+		},
+		[DETACHED]() {
+			if (process.env.TARO_ENV === "tt" && (0, _spcsn_taro_shared.isEnableTTDom)()) return;
+			const componentId = this.data.i?.sid || this.props.i?.sid;
+			if ((0, _spcsn_taro_shared.isString)(componentId)) {
+				customWrapperCache.delete(componentId);
+				const el = env.document.getElementById(componentId);
+				if (el) el.ctx = null;
+			}
+		}
+	} : _spcsn_taro_shared.EMPTY_OBJ;
+	const extraOptions = {};
+	if (process.env.TARO_ENV === "jd") extraOptions.addGlobalClass = true;
+	return _spcsn_taro_shared.hooks.call("modifyRecursiveComponentConfig", {
+		properties: {
+			i: {
+				type: Object,
+				value: { [_spcsn_taro_shared.Shortcuts.NodeName]: (0, _spcsn_taro_shared.getComponentsAlias)(_spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 ((0, _spcsn_taro_shared.isFunction)(node.addEventListener)) node.addEventListener(event, fn, opt_useCapture || false);
+		else if ((0, _spcsn_taro_shared.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 ((0, _spcsn_taro_shared.isFunction)(node.removeEventListener)) node.removeEventListener(event, fn, opt_useCapture || false);
+		else if ((0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.isFunction)(Object.defineProperties)) Object.defineProperties = function(obj, properties) {
+		function convertToDescriptor(desc) {
+			function hasProperty(obj, prop) {
+				return Object.prototype.hasOwnProperty.call(obj, prop);
+			}
+			if (!(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.isFunction)(g) && !(0, _spcsn_taro_shared.isUndefined)(g)) throw new TypeError("bad get");
+				d.get = g;
+			}
+			if (hasProperty(desc, "set")) {
+				const s = desc.set;
+				if (!(0, _spcsn_taro_shared.isFunction)(s) && !(0, _spcsn_taro_shared.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 (!(0, _spcsn_taro_shared.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" && (0, _spcsn_taro_shared.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
+exports.A = A;
+exports.APP = APP;
+exports.BEHAVIORS = BEHAVIORS;
+exports.BODY = BODY;
+exports.CATCHMOVE = CATCHMOVE;
+exports.CATCH_VIEW = CATCH_VIEW;
+exports.CHANGE = CHANGE;
+exports.CLASS = CLASS;
+exports.CLICK_VIEW = CLICK_VIEW;
+exports.COMMENT = COMMENT;
+exports.COMPILE_MODE = COMPILE_MODE;
+exports.CONFIRM = CONFIRM;
+exports.CONTAINER = CONTAINER;
+exports.CONTEXT_ACTIONS = CONTEXT_ACTIONS;
+exports.CURRENT_TARGET = CURRENT_TARGET;
+exports.CUSTOM_WRAPPER = CUSTOM_WRAPPER;
+exports.Current = Current;
+exports.DATASET = DATASET;
+exports.DATE = DATE;
+exports.DOCUMENT_ELEMENT_NAME = DOCUMENT_ELEMENT_NAME;
+exports.DOCUMENT_FRAGMENT = DOCUMENT_FRAGMENT;
+exports.EVENT_CALLBACK_RESULT = EVENT_CALLBACK_RESULT;
+exports.EXTERNAL_CLASSES = EXTERNAL_CLASSES;
+exports.Events = _spcsn_taro_shared.Events;
+exports.FOCUS = FOCUS;
+exports.FormElement = FormElement;
+exports.HEAD = HEAD;
+exports.HOOKS_APP_ID = HOOKS_APP_ID;
+exports.HTML = HTML;
+exports.History = History;
+exports.ID = ID;
+exports.INPUT = INPUT;
+exports.KEY_CODE = KEY_CODE;
+exports.Location = Location;
+exports.MutationObserver = MutationObserver$1;
+exports.OBJECT = OBJECT;
+exports.ON_HIDE = ON_HIDE;
+exports.ON_LOAD = ON_LOAD;
+exports.ON_READY = ON_READY;
+exports.ON_SHOW = ON_SHOW;
+exports.OPTIONS = OPTIONS;
+exports.PAGE_INIT = PAGE_INIT;
+exports.PROPERTY_THRESHOLD = PROPERTY_THRESHOLD;
+exports.PROPS = PROPS;
+exports.PURE_VIEW = PURE_VIEW;
+exports.ROOT_STR = ROOT_STR;
+exports.SET_DATA = SET_DATA;
+exports.SET_TIMEOUT = SET_TIMEOUT;
+exports.STATIC_VIEW = STATIC_VIEW;
+exports.STYLE = STYLE;
+exports.SVGElement = SVGElement;
+exports.Style = Style;
+exports.TARGET = TARGET;
+exports.TARO_RUNTIME = TARO_RUNTIME;
+exports.TIME_STAMP = TIME_STAMP;
+exports.TOUCHMOVE = TOUCHMOVE;
+exports.TYPE = TYPE;
+exports.TaroElement = TaroElement;
+exports.TaroEvent = TaroEvent;
+exports.TaroNode = TaroNode;
+exports.TaroRootElement = TaroRootElement;
+exports.TaroText = TaroText;
+exports.UID = UID;
+exports.URL = TaroURLProvider;
+exports.URLSearchParams = URLSearchParams;
+exports.VALUE = VALUE;
+exports.VIEW = VIEW;
+exports.addLeadingSlash = addLeadingSlash;
+exports.cancelAnimationFrame = _caf;
+exports.convertNumber2PX = convertNumber2PX;
+exports.createComponentConfig = createComponentConfig;
+exports.createEvent = createEvent;
+exports.createPageConfig = createPageConfig;
+exports.createRecursiveComponentConfig = createRecursiveComponentConfig;
+exports.customWrapperCache = customWrapperCache;
+exports.debounce = debounce;
+exports.document = taroDocumentProvider;
+exports.env = env;
+exports.eventCenter = eventCenter;
+exports.eventHandler = eventHandler;
+exports.eventHandlerTTDom = eventHandlerTTDom;
+exports.eventSource = eventSource;
+exports.extend = extend;
+exports.getComponentsAlias = getComponentsAlias;
+exports.getComputedStyle = taroGetComputedStyleProvider;
+exports.getCurrentInstance = getCurrentInstance;
+exports.getCurrentPage = getCurrentPage;
+exports.getHomePage = getHomePage;
+exports.getOnHideEventKey = getOnHideEventKey;
+exports.getOnReadyEventKey = getOnReadyEventKey;
+exports.getOnShowEventKey = getOnShowEventKey;
+exports.getPageInstance = getPageInstance;
+exports.getPath = getPath;
+exports.handlePolyfill = handlePolyfill;
+exports.hasBasename = hasBasename;
+exports.history = taroHistoryProvider;
+Object.defineProperty(exports, "hooks", {
+	enumerable: true,
+	get: function() {
+		return _spcsn_taro_shared.hooks;
+	}
+});
+exports.hydrate = hydrate;
+exports.incrementId = incrementId;
+exports.injectPageInstance = injectPageInstance;
+exports.isComment = isComment;
+exports.isElement = isElement;
+exports.isHasExtractProp = isHasExtractProp;
+exports.isParentBound = isParentBound;
+exports.isText = isText;
+exports.location = taroLocationProvider;
+exports.navigator = nav;
+exports.nextTick = nextTick;
+Object.defineProperty(exports, "now", {
+	enumerable: true,
+	get: function() {
+		return now;
+	}
+});
+exports.options = options;
+exports.parseUrl = parseUrl;
+exports.perf = perf;
+exports.removePageInstance = removePageInstance;
+exports.requestAnimationFrame = _raf;
+exports.safeExecute = safeExecute;
+exports.shortcutAttr = shortcutAttr;
+exports.stringify = stringify;
+exports.stripBasename = stripBasename;
+exports.stripSuffix = stripSuffix;
+exports.stripTrailing = stripTrailing;
+exports.throttle = throttle;
+exports.window = taroWindowProvider;
+
+//# sourceMappingURL=index.cjs.js.map