@tarojs/runtime 3.7.0-canary.6 → 3.8.0-canary.1

package/dist/{runtime.h5.js → index.cjs.js}

@@ -1,6 +1,7 @@
 'use strict';
 
 var shared = require('@tarojs/shared');
+var tslib = require('tslib');
 
 const PROPERTY_THRESHOLD = 2046;
 const TARO_RUNTIME = 'Taro runtime';
@@ -39,6 +40,7 @@ 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';
@@ -63,6 +65,54 @@ exports.CONTEXT_ACTIONS = void 0;
 })(exports.CONTEXT_ACTIONS || (exports.CONTEXT_ACTIONS = {}));
 
 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
+ */
+class MutationObserverImpl {
+    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 === null || target === void 0 ? void 0 : target.sid);
@@ -120,9 +170,12 @@ function recordMutation(record) {
     });
 }
 
-class MutationObserver {
+let MutationObserver$1 = class MutationObserver {
     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\'');
             }
@@ -145,6 +198,26 @@ class MutationObserver {
     static record(record) {
         recordMutation(record);
     }
+};
+
+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);
+        }
+    };
 }
 
 const incrementId = () => {
@@ -343,8 +416,8 @@ class EventSource extends Map {
 const eventSource = new EventSource();
 
 const env = {
-    window: window ,
-    document: document 
+    window: process.env.TARO_PLATFORM === 'web' ? window : shared.EMPTY_OBJ,
+    document: process.env.TARO_PLATFORM === 'web' ? document : shared.EMPTY_OBJ
 };
 
 let SPECIAL_NODES;
@@ -357,15 +430,12 @@ let componentsAlias;
  */
 function hydrate(node) {
     var _a;
-    if (!componentsAlias) {
-        // 初始化 componentsAlias
-        componentsAlias = getComponentsAlias();
-    }
-    if (!SPECIAL_NODES) {
-        // 初始化 SPECIAL_NODES
-        SPECIAL_NODES = shared.hooks.call('getSpecialNodes');
-    }
+    // 初始化 componentsAlias
+    componentsAlias || (componentsAlias = getComponentsAlias());
+    // 初始化 SPECIAL_NODES
+    SPECIAL_NODES || (SPECIAL_NODES = shared.hooks.call('getSpecialNodes'));
     const nodeName = node.nodeName;
+    let compileModeName = null;
     if (isText(node)) {
         return {
             sid: node.sid,
@@ -393,22 +463,22 @@ function hydrate(node) {
             prop !== CLASS &&
             prop !== STYLE &&
             prop !== ID &&
-            propInCamelCase !== CATCHMOVE) {
+            propInCamelCase !== CATCHMOVE &&
+            propInCamelCase !== COMPILE_MODE) {
             data[propInCamelCase] = props[prop];
         }
-        if (nodeName === VIEW && propInCamelCase === CATCHMOVE && props[prop] !== false) {
+        if (process.env.TARO_ENV !== 'swan' &&
+            nodeName === VIEW &&
+            propInCamelCase === CATCHMOVE &&
+            props[prop] !== false) {
             data["nn" /* Shortcuts.NodeName */] = CATCH_VIEW;
         }
+        if (propInCamelCase === COMPILE_MODE) {
+            compileModeName = props[prop];
+        }
     }
-    let { childNodes } = node;
-    // 过滤 comment 节点
-    childNodes = childNodes.filter(node => !isComment(node));
-    if (childNodes.length > 0) {
-        data["cn" /* Shortcuts.Childnodes */] = childNodes.map(hydrate);
-    }
-    else {
-        data["cn" /* Shortcuts.Childnodes */] = [];
-    }
+    // Children
+    data["cn" /* Shortcuts.Childnodes */] = node.childNodes.filter(node => !isComment(node)).map(hydrate);
     if (node.className !== '') {
         data["cl" /* Shortcuts.Class */] = node.className;
     }
@@ -428,6 +498,9 @@ function hydrate(node) {
             }
         }
     }
+    if (compileModeName !== null) {
+        data["nn" /* Shortcuts.NodeName */] = compileModeName;
+    }
     const resData = shared.hooks.call('transferHydrateData', data, node, componentAlias);
     return resData || data;
 }
@@ -605,7 +678,7 @@ class TaroNode extends TaroEventTarget {
             this.updateChildNodes();
         }
         // @Todo: appendChild 会多触发一次
-        MutationObserver.record({
+        MutationObserver$1.record({
             type: "childList" /* MutationRecordType.CHILD_LIST */,
             target: this,
             removedNodes,
@@ -690,7 +763,7 @@ class TaroNode extends TaroEventTarget {
                 }
             }
         }
-        MutationObserver.record({
+        MutationObserver$1.record({
             type: "childList" /* MutationRecordType.CHILD_LIST */,
             target: this,
             addedNodes: [newChild],
@@ -746,7 +819,7 @@ class TaroNode extends TaroEventTarget {
         if (cleanRef !== false && doUpdate !== false) {
             // appendChild/replaceChild/insertBefore 不应该触发
             // @Todo: 但其实如果 newChild 的父节点是另一颗子树的节点，应该是要触发的
-            MutationObserver.record({
+            MutationObserver$1.record({
                 type: "childList" /* MutationRecordType.CHILD_LIST */,
                 target: this,
                 removedNodes: [child],
@@ -972,7 +1045,7 @@ combine('box', ['DecorationBreak', 'Shadow', 'Sizing', 'Snap'], true);
 combine(WEBKIT, ['LineClamp', 'BoxOrient', 'TextFillColor', 'TextStroke', 'TextStrokeColor', 'TextStrokeWidth'], true);
 
 function recordCss(obj) {
-    MutationObserver.record({
+    MutationObserver$1.record({
         type: "attributes" /* MutationRecordType.ATTRIBUTES */,
         target: obj._element,
         attributeName: 'style',
@@ -1253,7 +1326,7 @@ class TaroElement extends TaroNode {
         process.env.NODE_ENV !== 'production' && shared.warn(shared.isString(value) && value.length > PROPERTY_THRESHOLD, `元素 ${this.nodeName} 的 ${qualifiedName} 属性值数据量过大，可能会影响渲染性能。考虑降低图片转为 base64 的阈值或在 CSS 中使用 base64。`);
         const isPureView = this.nodeName === VIEW && !isHasExtractProp(this) && !this.isAnyEventBinded();
         if (qualifiedName !== STYLE) {
-            MutationObserver.record({
+            MutationObserver$1.record({
                 target: this,
                 type: "attributes" /* MutationRecordType.ATTRIBUTES */,
                 attributeName: qualifiedName,
@@ -1325,7 +1398,7 @@ class TaroElement extends TaroNode {
     }
     removeAttribute(qualifiedName) {
         const isStaticView = this.nodeName === VIEW && isHasExtractProp(this) && !this.isAnyEventBinded();
-        MutationObserver.record({
+        MutationObserver$1.record({
             target: this,
             type: "attributes" /* MutationRecordType.ATTRIBUTES */,
             attributeName: qualifiedName,
@@ -1418,7 +1491,10 @@ class TaroElement extends TaroNode {
                 event.defaultPrevented = true;
             }
             if (!shared.isUndefined(result) && event.mpEvent) {
-                event.mpEvent[EVENT_CALLBACK_RESULT] = result;
+                const res = shared.hooks.call('modifyTaroEventReturn', this, event, result);
+                if (res) {
+                    event.mpEvent[EVENT_CALLBACK_RESULT] = result;
+                }
             }
             if (event._end && event._stop) {
                 break;
@@ -1476,6 +1552,547 @@ const options = {
     debug: false
 };
 
+function initPosition() {
+    return {
+        index: 0,
+        column: 0,
+        line: 0
+    };
+}
+function feedPosition(position, str, len) {
+    const start = position.index;
+    const end = position.index = start + len;
+    for (let i = start; i < end; i++) {
+        const char = str.charAt(i);
+        if (char === '\n') {
+            position.line++;
+            position.column = 0;
+        }
+        else {
+            position.column++;
+        }
+    }
+}
+function jumpPosition(position, str, end) {
+    const len = end - position.index;
+    return feedPosition(position, str, len);
+}
+function copyPosition(position) {
+    return {
+        index: position.index,
+        line: position.line,
+        column: position.column
+    };
+}
+const whitespace = /\s/;
+function isWhitespaceChar(char) {
+    return whitespace.test(char);
+}
+const equalSign = /=/;
+function isEqualSignChar(char) {
+    return equalSign.test(char);
+}
+function shouldBeIgnore(tagName) {
+    const name = tagName.toLowerCase();
+    if (options.html.skipElements.has(name)) {
+        return true;
+    }
+    return false;
+}
+const alphanumeric = /[A-Za-z0-9]/;
+function findTextEnd(str, index) {
+    while (true) {
+        const textEnd = str.indexOf('<', index);
+        if (textEnd === -1) {
+            return textEnd;
+        }
+        const char = str.charAt(textEnd + 1);
+        if (char === '/' || char === '!' || alphanumeric.test(char)) {
+            return textEnd;
+        }
+        index = textEnd + 1;
+    }
+}
+function isWordEnd(cursor, wordBegin, html) {
+    if (!isWhitespaceChar(html.charAt(cursor)))
+        return false;
+    const len = html.length;
+    // backwrad
+    for (let i = cursor - 1; i > wordBegin; i--) {
+        const char = html.charAt(i);
+        if (!isWhitespaceChar(char)) {
+            if (isEqualSignChar(char))
+                return false;
+            break;
+        }
+    }
+    // forward
+    for (let i = cursor + 1; i < len; i++) {
+        const char = html.charAt(i);
+        if (!isWhitespaceChar(char)) {
+            if (isEqualSignChar(char))
+                return false;
+            return true;
+        }
+    }
+}
+class Scaner {
+    constructor(html) {
+        this.tokens = [];
+        this.position = initPosition();
+        this.html = html;
+    }
+    scan() {
+        const { html, position } = this;
+        const len = html.length;
+        while (position.index < len) {
+            const start = position.index;
+            this.scanText();
+            if (position.index === start) {
+                const isComment = html.startsWith('!--', start + 1);
+                if (isComment) {
+                    this.scanComment();
+                }
+                else {
+                    const tagName = this.scanTag();
+                    if (shouldBeIgnore(tagName)) {
+                        this.scanSkipTag(tagName);
+                    }
+                }
+            }
+        }
+        return this.tokens;
+    }
+    scanText() {
+        const type = 'text';
+        const { html, position } = this;
+        let textEnd = findTextEnd(html, position.index);
+        if (textEnd === position.index) {
+            return;
+        }
+        if (textEnd === -1) {
+            textEnd = html.length;
+        }
+        const start = copyPosition(position);
+        const content = html.slice(position.index, textEnd);
+        jumpPosition(position, html, textEnd);
+        const end = copyPosition(position);
+        this.tokens.push({ type, content, position: { start, end } });
+    }
+    scanComment() {
+        const type = 'comment';
+        const { html, position } = this;
+        const start = copyPosition(position);
+        feedPosition(position, html, 4); // "<!--".length
+        let contentEnd = html.indexOf('-->', position.index);
+        let commentEnd = contentEnd + 3; // "-->".length
+        if (contentEnd === -1) {
+            contentEnd = commentEnd = html.length;
+        }
+        const content = html.slice(position.index, contentEnd);
+        jumpPosition(position, html, commentEnd);
+        this.tokens.push({
+            type,
+            content,
+            position: {
+                start,
+                end: copyPosition(position)
+            }
+        });
+    }
+    scanTag() {
+        this.scanTagStart();
+        const tagName = this.scanTagName();
+        this.scanAttrs();
+        this.scanTagEnd();
+        return tagName;
+    }
+    scanTagStart() {
+        const type = 'tag-start';
+        const { html, position } = this;
+        const secondChar = html.charAt(position.index + 1);
+        const close = secondChar === '/';
+        const start = copyPosition(position);
+        feedPosition(position, html, close ? 2 : 1);
+        this.tokens.push({ type, close, position: { start } });
+    }
+    scanTagEnd() {
+        const type = 'tag-end';
+        const { html, position } = this;
+        const firstChar = html.charAt(position.index);
+        const close = firstChar === '/';
+        feedPosition(position, html, close ? 2 : 1);
+        const end = copyPosition(position);
+        this.tokens.push({ type, close, position: { end } });
+    }
+    scanTagName() {
+        const type = 'tag';
+        const { html, position } = this;
+        const len = html.length;
+        let start = position.index;
+        while (start < len) {
+            const char = html.charAt(start);
+            const isTagChar = !(isWhitespaceChar(char) || char === '/' || char === '>');
+            if (isTagChar)
+                break;
+            start++;
+        }
+        let end = start + 1;
+        while (end < len) {
+            const char = html.charAt(end);
+            const isTagChar = !(isWhitespaceChar(char) || char === '/' || char === '>');
+            if (!isTagChar)
+                break;
+            end++;
+        }
+        jumpPosition(position, html, end);
+        const tagName = html.slice(start, end);
+        this.tokens.push({
+            type,
+            content: tagName
+        });
+        return tagName;
+    }
+    scanAttrs() {
+        const { html, position, tokens } = this;
+        let cursor = position.index;
+        let quote = null; // null, single-, or double-quote
+        let wordBegin = cursor; // index of word start
+        const words = []; // "key", "key=value", "key='value'", etc
+        const len = html.length;
+        while (cursor < len) {
+            const char = html.charAt(cursor);
+            if (quote) {
+                const isQuoteEnd = char === quote;
+                if (isQuoteEnd) {
+                    quote = null;
+                }
+                cursor++;
+                continue;
+            }
+            const isTagEnd = char === '/' || char === '>';
+            if (isTagEnd) {
+                if (cursor !== wordBegin) {
+                    words.push(html.slice(wordBegin, cursor));
+                }
+                break;
+            }
+            if (isWordEnd(cursor, wordBegin, html)) {
+                if (cursor !== wordBegin) {
+                    words.push(html.slice(wordBegin, cursor));
+                }
+                wordBegin = cursor + 1;
+                cursor++;
+                continue;
+            }
+            const isQuoteStart = char === '\'' || char === '"';
+            if (isQuoteStart) {
+                quote = char;
+                cursor++;
+                continue;
+            }
+            cursor++;
+        }
+        jumpPosition(position, html, cursor);
+        const wLen = words.length;
+        const type = 'attribute';
+        for (let i = 0; i < wLen; i++) {
+            const word = words[i];
+            const isNotPair = word.includes('=');
+            if (isNotPair) {
+                const secondWord = words[i + 1];
+                if (secondWord && secondWord.startsWith('=')) {
+                    if (secondWord.length > 1) {
+                        const newWord = word + secondWord;
+                        tokens.push({ type, content: newWord });
+                        i += 1;
+                        continue;
+                    }
+                    const thirdWord = words[i + 2];
+                    i += 1;
+                    if (thirdWord) {
+                        const newWord = word + '=' + thirdWord;
+                        tokens.push({ type, content: newWord });
+                        i += 1;
+                        continue;
+                    }
+                }
+            }
+            if (word.endsWith('=')) {
+                const secondWord = words[i + 1];
+                if (secondWord && !secondWord.includes('=')) {
+                    const newWord = word + secondWord;
+                    tokens.push({ type, content: newWord });
+                    i += 1;
+                    continue;
+                }
+                const newWord = word.slice(0, -1);
+                tokens.push({ type, content: newWord });
+                continue;
+            }
+            tokens.push({ type, content: word });
+        }
+    }
+    scanSkipTag(tagName) {
+        const { html, position } = this;
+        const safeTagName = tagName.toLowerCase();
+        const len = html.length;
+        while (position.index < len) {
+            const nextTag = html.indexOf('</', position.index);
+            if (nextTag === -1) {
+                this.scanText();
+                break;
+            }
+            jumpPosition(position, html, nextTag);
+            const name = this.scanTag();
+            if (safeTagName === name.toLowerCase()) {
+                break;
+            }
+        }
+    }
+}
+
+function unquote(str) {
+    const car = str.charAt(0);
+    const end = str.length - 1;
+    const isQuoteStart = car === '"' || car === "'";
+    if (isQuoteStart && car === str.charAt(end)) {
+        return str.slice(1, end);
+    }
+    return str;
+}
+
+const LEFT_BRACKET = '{';
+const RIGHT_BRACKET = '}';
+const CLASS_SELECTOR = '.';
+const ID_SELECTOR = '#';
+const CHILD_COMBINATOR = '>';
+const GENERAL_SIBLING_COMBINATOR = '~';
+const ADJACENT_SIBLING_COMBINATOR = '+';
+class StyleTagParser {
+    constructor() {
+        this.styles = [];
+    }
+    extractStyle(src) {
+        const REG_STYLE = /<style\s?[^>]*>((.|\n|\s)+?)<\/style>/g;
+        let html = src;
+        // let html = src.replace(/\n/g, '')
+        html = html.replace(REG_STYLE, (_, $1) => {
+            const style = $1.trim();
+            this.stringToSelector(style);
+            return '';
+        });
+        return html.trim();
+    }
+    stringToSelector(style) {
+        let lb = style.indexOf(LEFT_BRACKET);
+        while (lb > -1) {
+            const rb = style.indexOf(RIGHT_BRACKET);
+            const selectors = style.slice(0, lb).trim();
+            let content = style.slice(lb + 1, rb);
+            content = content.replace(/:(.*);/g, function (_, $1) {
+                const t = $1.trim().replace(/ +/g, '+++');
+                return `:${t};`;
+            });
+            content = content.replace(/ /g, '');
+            content = content.replace(/\+\+\+/g, ' ');
+            if (!(/;$/.test(content))) {
+                content += ';';
+            }
+            selectors.split(',').forEach(src => {
+                const selectorList = this.parseSelector(src);
+                this.styles.push({
+                    content,
+                    selectorList
+                });
+            });
+            style = style.slice(rb + 1);
+            lb = style.indexOf(LEFT_BRACKET);
+        }
+        // console.log('res this.styles: ', this.styles)
+    }
+    parseSelector(src) {
+        const list = src
+            .trim()
+            .replace(/ *([>~+]) */g, ' $1')
+            .replace(/ +/g, ' ')
+            .replace(/\[\s*([^[\]=\s]+)\s*=\s*([^[\]=\s]+)\s*\]/g, '[$1=$2]')
+            .split(' ');
+        const selectors = list.map(item => {
+            const firstChar = item.charAt(0);
+            const selector = {
+                isChild: firstChar === CHILD_COMBINATOR,
+                isGeneralSibling: firstChar === GENERAL_SIBLING_COMBINATOR,
+                isAdjacentSibling: firstChar === ADJACENT_SIBLING_COMBINATOR,
+                tag: null,
+                id: null,
+                class: [],
+                attrs: []
+            };
+            item = item.replace(/^[>~+]/, '');
+            // 属性选择器
+            item = item.replace(/\[(.+?)\]/g, function (_, $1) {
+                const [key, value] = $1.split('=');
+                const all = $1.indexOf('=') === -1;
+                const attr = {
+                    all,
+                    key,
+                    value: all ? null : value
+                };
+                selector.attrs.push(attr);
+                return '';
+            });
+            item = item.replace(/([.#][A-Za-z0-9-_]+)/g, function (_, $1) {
+                if ($1[0] === ID_SELECTOR) {
+                    // id 选择器
+                    selector.id = $1.substr(1);
+                }
+                else if ($1[0] === CLASS_SELECTOR) {
+                    // class 选择器
+                    selector.class.push($1.substr(1));
+                }
+                return '';
+            });
+            // 标签选择器
+            if (item !== '') {
+                selector.tag = item;
+            }
+            return selector;
+        });
+        return selectors;
+    }
+    matchStyle(tagName, el, list) {
+        const res = sortStyles(this.styles).reduce((str, { content, selectorList }, i) => {
+            let idx = list[i];
+            let selector = selectorList[idx];
+            const nextSelector = selectorList[idx + 1];
+            if ((nextSelector === null || nextSelector === void 0 ? void 0 : nextSelector.isGeneralSibling) || (nextSelector === null || nextSelector === void 0 ? void 0 : nextSelector.isAdjacentSibling)) {
+                selector = nextSelector;
+                idx += 1;
+                list[i] += 1;
+            }
+            let isMatch = this.matchCurrent(tagName, el, selector);
+            if (isMatch && selector.isGeneralSibling) {
+                let prev = getPreviousElement(el);
+                while (prev) {
+                    if (prev.h5tagName && this.matchCurrent(prev.h5tagName, prev, selectorList[idx - 1])) {
+                        isMatch = true;
+                        break;
+                    }
+                    prev = getPreviousElement(prev);
+                    isMatch = false;
+                }
+            }
+            if (isMatch && selector.isAdjacentSibling) {
+                const prev = getPreviousElement(el);
+                if (!prev || !prev.h5tagName) {
+                    isMatch = false;
+                }
+                else {
+                    const isSiblingMatch = this.matchCurrent(prev.h5tagName, prev, selectorList[idx - 1]);
+                    if (!isSiblingMatch) {
+                        isMatch = false;
+                    }
+                }
+            }
+            if (isMatch) {
+                if (idx === selectorList.length - 1) {
+                    return str + content;
+                }
+                else if (idx < selectorList.length - 1) {
+                    list[i] += 1;
+                }
+            }
+            else {
+                // 直接子代组合器: >
+                if (selector.isChild && idx > 0) {
+                    list[i] -= 1;
+                    if (this.matchCurrent(tagName, el, selectorList[list[i]])) {
+                        list[i] += 1;
+                    }
+                }
+            }
+            return str;
+        }, '');
+        return res;
+    }
+    matchCurrent(tagName, el, selector) {
+        // 标签选择器
+        if (selector.tag && selector.tag !== tagName)
+            return false;
+        // id 选择器
+        if (selector.id && selector.id !== el.id)
+            return false;
+        // class 选择器
+        if (selector.class.length) {
+            const classList = el.className.split(' ');
+            for (let i = 0; i < selector.class.length; i++) {
+                const cls = selector.class[i];
+                if (classList.indexOf(cls) === -1) {
+                    return false;
+                }
+            }
+        }
+        // 属性选择器
+        if (selector.attrs.length) {
+            for (let i = 0; i < selector.attrs.length; i++) {
+                const { all, key, value } = selector.attrs[i];
+                if (all && !el.hasAttribute(key)) {
+                    return false;
+                }
+                else {
+                    const attr = el.getAttribute(key);
+                    if (attr !== unquote(value || '')) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+}
+function getPreviousElement(el) {
+    const parent = el.parentElement;
+    if (!parent)
+        return null;
+    const prev = el.previousSibling;
+    if (!prev)
+        return null;
+    if (prev.nodeType === 1 /* NodeType.ELEMENT_NODE */) {
+        return prev;
+    }
+    else {
+        return getPreviousElement(prev);
+    }
+}
+// 根据 css selector 权重排序: 权重大的靠后
+// @WARN 不考虑伪类
+// https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Cascade_and_inheritance#specificity_2
+function sortStyles(styles) {
+    return styles.sort((s1, s2) => {
+        const hundreds1 = getHundredsWeight(s1.selectorList);
+        const hundreds2 = getHundredsWeight(s2.selectorList);
+        if (hundreds1 !== hundreds2)
+            return hundreds1 - hundreds2;
+        const tens1 = getTensWeight(s1.selectorList);
+        const tens2 = getTensWeight(s2.selectorList);
+        if (tens1 !== tens2)
+            return tens1 - tens2;
+        const ones1 = getOnesWeight(s1.selectorList);
+        const ones2 = getOnesWeight(s2.selectorList);
+        return ones1 - ones2;
+    });
+}
+function getHundredsWeight(selectors) {
+    return selectors.reduce((pre, cur) => pre + (cur.id ? 1 : 0), 0);
+}
+function getTensWeight(selectors) {
+    return selectors.reduce((pre, cur) => pre + cur.class.length + cur.attrs.length, 0);
+}
+function getOnesWeight(selectors) {
+    return selectors.reduce((pre, cur) => pre + (cur.tag ? 1 : 0), 0);
+}
+
 function makeMap(str, expectsLowerCase) {
     const map = Object.create(null);
     const list = str.split(',');
@@ -1484,15 +2101,282 @@ function makeMap(str, expectsLowerCase) {
     }
     return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
 }
+const specialMiniElements = {
+    img: 'image',
+    iframe: 'web-view'
+};
+const specialElements = new Map([
+    ['a', {
+            mapName(props) {
+                if (props.as && shared.isString(props.as))
+                    return props.as.toLowerCase();
+                return !props.href || shared.isString(props.href) && (/^javascript/.test(props.href)) ? 'view' : 'navigator';
+            }
+        }],
+]);
+const getSpecialElementMapping = (tag, expectsLowerCase = true) => {
+    tag = expectsLowerCase ? tag.toLowerCase() : tag;
+    return specialElements.get(tag);
+};
 const internalCompsList = Object.keys(shared.internalComponents)
     .map(i => i.toLowerCase())
     .join(',');
 // https://developers.weixin.qq.com/miniprogram/dev/component
-makeMap(internalCompsList, true);
+const isMiniElements = makeMap(internalCompsList, true);
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Inline_elements
-makeMap('a,i,abbr,iframe,select,acronym,slot,small,span,bdi,kbd,strong,big,map,sub,sup,br,mark,mark,meter,template,canvas,textarea,cite,object,time,code,output,u,data,picture,tt,datalist,var,dfn,del,q,em,s,embed,samp,b', true);
+const isInlineElements = makeMap('i,abbr,iframe,select,acronym,slot,small,span,bdi,kbd,strong,big,map,sub,sup,br,mark,mark,meter,template,canvas,textarea,cite,object,time,code,output,u,data,picture,tt,datalist,var,dfn,del,q,em,s,embed,samp,b', true);
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Block-level_elements
-makeMap('address,fieldset,li,article,figcaption,main,aside,figure,nav,blockquote,footer,ol,details,form,p,dialog,h1,h2,h3,h4,h5,h6,pre,dd,header,section,div,hgroup,table,dl,hr,ul,dt', true);
+const isBlockElements = makeMap('address,fieldset,li,article,figcaption,main,aside,figure,nav,blockquote,footer,ol,details,form,p,dialog,h1,h2,h3,h4,h5,h6,pre,dd,header,section,div,hgroup,table,dl,hr,ul,dt', true);
+// specialElements
+const isSpecialElements = makeMap('a', true);
+
+const closingTagAncestorBreakers = {
+    li: ['ul', 'ol', 'menu'],
+    dt: ['dl'],
+    dd: ['dl'],
+    tbody: ['table'],
+    thead: ['table'],
+    tfoot: ['table'],
+    tr: ['table'],
+    td: ['table']
+};
+function hasTerminalParent(tagName, stack) {
+    const tagParents = closingTagAncestorBreakers[tagName];
+    if (tagParents) {
+        let currentIndex = stack.length - 1;
+        while (currentIndex >= 0) {
+            const parentTagName = stack[currentIndex].tagName;
+            if (parentTagName === tagName) {
+                break;
+            }
+            if (tagParents && tagParents.includes(parentTagName)) {
+                return true;
+            }
+            currentIndex--;
+        }
+    }
+    return false;
+}
+/**
+ * 将属性数组转换为属性对象
+ * @param attributes 字符串数组，包含属性信息
+ * @returns 属性对象，键为属性名，值为属性值或true
+ */
+function attributesArray2Props(attributes) {
+    const props = {};
+    for (let i = 0; i < attributes.length; i++) {
+        const attr = attributes[i];
+        const [key, value] = splitEqual(attr);
+        props[key] = value == null ? true : unquote(value);
+    }
+    return props;
+}
+function getTagName(tag, attributes) {
+    if (options.html.renderHTMLTag) {
+        return tag;
+    }
+    if (specialMiniElements[tag]) {
+        return specialMiniElements[tag];
+    }
+    else if (isMiniElements(tag)) {
+        return tag;
+    }
+    else if (isBlockElements(tag)) {
+        return 'view';
+    }
+    else if (isInlineElements(tag)) {
+        return 'text';
+    }
+    else if (isSpecialElements(tag)) {
+        // if it's special tag, the real tag is determined by the config mapping
+        const mapping = getSpecialElementMapping(tag);
+        const props = attributesArray2Props(attributes);
+        if (mapping) {
+            return mapping.mapName(props);
+        }
+    }
+    return 'view';
+}
+function splitEqual(str) {
+    const sep = '=';
+    const idx = str.indexOf(sep);
+    if (idx === -1)
+        return [str];
+    const key = str.slice(0, idx).trim();
+    const value = str.slice(idx + sep.length).trim();
+    return [key, value];
+}
+function format(children, document, styleOptions, parent) {
+    return children
+        .filter(child => {
+        // 过滤注释和空文本节点
+        if (child.type === 'comment') {
+            return false;
+        }
+        else if (child.type === 'text') {
+            return child.content !== '';
+        }
+        return true;
+    })
+        .map((child) => {
+        // 文本节点
+        if (child.type === 'text') {
+            let text = document.createTextNode(child.content);
+            if (shared.isFunction(options.html.transformText)) {
+                text = options.html.transformText(text, child);
+            }
+            parent === null || parent === void 0 ? void 0 : parent.appendChild(text);
+            return text;
+        }
+        // img标签,把width和height写入style,删除原有的width、height和style属性
+        if (child.tagName === 'img') {
+            let styleText = '';
+            const toBeRemovedIndexs = [];
+            for (let i = 0; i < child.attributes.length; i++) {
+                const attr = child.attributes[i];
+                const [key, value] = splitEqual(attr);
+                if (key === 'width' || key === 'height') {
+                    styleText += `${key}:${value};`;
+                    toBeRemovedIndexs.push(i);
+                }
+                else if (key === 'style') {
+                    styleText = `${styleText}${value};`;
+                    toBeRemovedIndexs.push(i);
+                }
+            }
+            child.attributes = child.attributes.filter((_, index) => !toBeRemovedIndexs.includes(index));
+            child.attributes.push(`style=${styleText.replace(/['"]/g, '')}`);
+        }
+        const el = document.createElement(getTagName(child.tagName, child.attributes));
+        el.h5tagName = child.tagName;
+        parent === null || parent === void 0 ? void 0 : parent.appendChild(el);
+        if (!options.html.renderHTMLTag) {
+            el.className = `h5-${child.tagName}`;
+        }
+        for (let i = 0; i < child.attributes.length; i++) {
+            const attr = child.attributes[i];
+            const [key, value] = splitEqual(attr);
+            if (key === 'class') {
+                el.className += ' ' + unquote(value);
+            }
+            else if (key[0] === 'o' && key[1] === 'n') {
+                continue;
+            }
+            else {
+                el.setAttribute(key, value == null ? true : unquote(value));
+            }
+        }
+        const { styleTagParser, descendantList } = styleOptions;
+        const list = descendantList.slice();
+        const style = styleTagParser.matchStyle(child.tagName, el, list);
+        el.setAttribute('style', style + el.style.cssText);
+        // console.log('style, ', style)
+        format(child.children, document, {
+            styleTagParser,
+            descendantList: list
+        }, el);
+        if (shared.isFunction(options.html.transformElement)) {
+            return options.html.transformElement(el, child);
+        }
+        return el;
+    });
+}
+function parser(html, document) {
+    const styleTagParser = new StyleTagParser();
+    html = styleTagParser.extractStyle(html);
+    const tokens = new Scaner(html).scan();
+    const root = { tagName: '', children: [], type: 'element', attributes: [] };
+    const state = { tokens, options, cursor: 0, stack: [root] };
+    parse(state);
+    return format(root.children, document, {
+        styleTagParser,
+        descendantList: Array(styleTagParser.styles.length).fill(0)
+    });
+}
+function parse(state) {
+    const { tokens, stack } = state;
+    let { cursor } = state;
+    const len = tokens.length;
+    let nodes = stack[stack.length - 1].children;
+    while (cursor < len) {
+        const token = tokens[cursor];
+        if (token.type !== 'tag-start') {
+            // comment or text
+            nodes.push(token);
+            cursor++;
+            continue;
+        }
+        const tagToken = tokens[++cursor];
+        cursor++;
+        const tagName = tagToken.content.toLowerCase();
+        if (token.close) {
+            let index = stack.length;
+            let shouldRewind = false;
+            while (--index > -1) {
+                if (stack[index].tagName === tagName) {
+                    shouldRewind = true;
+                    break;
+                }
+            }
+            while (cursor < len) {
+                const endToken = tokens[cursor];
+                if (endToken.type !== 'tag-end')
+                    break;
+                cursor++;
+            }
+            if (shouldRewind) {
+                stack.splice(index);
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        const isClosingTag = options.html.closingElements.has(tagName);
+        let shouldRewindToAutoClose = isClosingTag;
+        if (shouldRewindToAutoClose) {
+            shouldRewindToAutoClose = !hasTerminalParent(tagName, stack);
+        }
+        if (shouldRewindToAutoClose) {
+            let currentIndex = stack.length - 1;
+            while (currentIndex > 0) {
+                if (tagName === stack[currentIndex].tagName) {
+                    stack.splice(currentIndex);
+                    const previousIndex = currentIndex - 1;
+                    nodes = stack[previousIndex].children;
+                    break;
+                }
+                currentIndex = currentIndex - 1;
+            }
+        }
+        const attributes = [];
+        let attrToken;
+        while (cursor < len) {
+            attrToken = tokens[cursor];
+            if (attrToken.type === 'tag-end')
+                break;
+            attributes.push(attrToken.content);
+            cursor++;
+        }
+        cursor++;
+        const children = [];
+        const element = {
+            type: 'element',
+            tagName: tagToken.content,
+            attributes,
+            children
+        };
+        nodes.push(element);
+        const hasChildren = !(attrToken.close || options.html.voidElements.has(tagName));
+        if (hasChildren) {
+            stack.push({ tagName, children });
+            const innerState = { tokens, cursor, stack };
+            parse(innerState);
+            cursor = innerState.cursor;
+        }
+    }
+    state.cursor = cursor;
+}
 
 options.html = {
     skipElements: new Set(['style', 'script']),
@@ -1507,24 +2391,159 @@ options.html = {
     ]),
     renderHTMLTag: false
 };
-
-// Taro 事件对象。以 Web 标准的事件对象为基础，加入小程序事件对象中携带的部分信息，并模拟实现事件冒泡。
-class TaroEvent {
-    constructor(type, opts, event) {
-        this._stop = false;
-        this._end = false;
-        this.defaultPrevented = false;
-        // Mouse Event botton property, it's used in 3rd lib, like react-router. default 0 in general
-        this.button = 0;
-        // timestamp can either be hi-res ( relative to page load) or low-res (relative to UNIX epoch)
-        // here use hi-res timestamp
-        this.timeStamp = Date.now();
-        this.type = type.toLowerCase();
-        this.mpEvent = event;
-        this.bubbles = Boolean(opts && opts.bubbles);
-        this.cancelable = Boolean(opts && opts.cancelable);
+function setInnerHTML(element, html) {
+    while (element.firstChild) {
+        element.removeChild(element.firstChild);
     }
-    stopPropagation() {
+    const children = parser(html, element.ownerDocument);
+    for (let i = 0; i < children.length; i++) {
+        element.appendChild(children[i]);
+    }
+}
+
+function getBoundingClientRectImpl() {
+    if (!options.miniGlobal)
+        return Promise.resolve(null);
+    return new Promise(resolve => {
+        const query = options.miniGlobal.createSelectorQuery();
+        query.select(`#${this.uid}`).boundingClientRect(res => {
+            resolve(res);
+        }).exec();
+    });
+}
+function getTemplateContent(ctx) {
+    if (ctx.nodeName === 'template') {
+        const document = ctx.ownerDocument;
+        const content = document.createElement(DOCUMENT_FRAGMENT);
+        content.childNodes = ctx.childNodes;
+        ctx.childNodes = [content];
+        content.parentNode = ctx;
+        content.childNodes.forEach(nodes => {
+            nodes.parentNode = content;
+        });
+        return content;
+    }
+}
+
+/**
+ * An implementation of `Element.insertAdjacentHTML()`
+ * to support Vue 3 with a version of or greater than `vue@3.1.2`
+ */
+function insertAdjacentHTML(position, html) {
+    var _a, _b;
+    const parsedNodes = parser(html, this.ownerDocument);
+    for (let i = 0; i < parsedNodes.length; i++) {
+        const n = parsedNodes[i];
+        switch (position) {
+            case 'beforebegin':
+                (_a = this.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(n, this);
+                break;
+            case 'afterbegin':
+                if (this.hasChildNodes()) {
+                    this.insertBefore(n, this.childNodes[0]);
+                }
+                else {
+                    this.appendChild(n);
+                }
+                break;
+            case 'beforeend':
+                this.appendChild(n);
+                break;
+            case 'afterend':
+                (_b = this.parentNode) === null || _b === void 0 ? void 0 : _b.appendChild(n);
+                break;
+        }
+    }
+}
+function cloneNode(isDeep = false) {
+    const document = this.ownerDocument;
+    let newNode;
+    if (this.nodeType === 1 /* NodeType.ELEMENT_NODE */) {
+        newNode = document.createElement(this.nodeName);
+    }
+    else if (this.nodeType === 3 /* NodeType.TEXT_NODE */) {
+        newNode = document.createTextNode('');
+    }
+    for (const key in this) {
+        const value = this[key];
+        // eslint-disable-next-line valid-typeof
+        if ([PROPS, DATASET].includes(key) && typeof value === OBJECT) {
+            newNode[key] = Object.assign({}, value);
+        }
+        else if (key === '_value') {
+            newNode[key] = value;
+        }
+        else if (key === STYLE) {
+            newNode.style._value = Object.assign({}, value._value);
+            newNode.style._usedStyleProp = new Set(Array.from(value._usedStyleProp));
+        }
+    }
+    if (isDeep) {
+        newNode.childNodes = this.childNodes.map(node => node.cloneNode(true));
+    }
+    return newNode;
+}
+function contains(node) {
+    let isContains = false;
+    this.childNodes.some(childNode => {
+        const { uid } = childNode;
+        if (uid === node.uid || uid === node.id || childNode.contains(node)) {
+            isContains = true;
+            return true;
+        }
+    });
+    return isContains;
+}
+
+if (process.env.TARO_PLATFORM !== 'web') {
+    if (ENABLE_INNER_HTML) {
+        TaroNode.extend('innerHTML', {
+            set(html) {
+                setInnerHTML.call(this, this, html);
+            },
+            get() {
+                return '';
+            }
+        });
+        if (ENABLE_ADJACENT_HTML) {
+            TaroNode.extend('insertAdjacentHTML', insertAdjacentHTML);
+        }
+    }
+    if (ENABLE_CLONE_NODE) {
+        TaroNode.extend('cloneNode', cloneNode);
+    }
+    if (ENABLE_CONTAINS) {
+        TaroNode.extend('contains', contains);
+    }
+    if (ENABLE_SIZE_APIS) {
+        TaroElement.extend('getBoundingClientRect', getBoundingClientRectImpl);
+    }
+    if (ENABLE_TEMPLATE_CONTENT) {
+        TaroElement.extend('content', {
+            get() {
+                return getTemplateContent(this);
+            }
+        });
+    }
+}
+
+// Taro 事件对象。以 Web 标准的事件对象为基础，加入小程序事件对象中携带的部分信息，并模拟实现事件冒泡。
+class TaroEvent {
+    constructor(type, opts, event) {
+        this._stop = false;
+        this._end = false;
+        this.defaultPrevented = false;
+        // Mouse Event botton property, it's used in 3rd lib, like react-router. default 0 in general
+        this.button = 0;
+        // timestamp can either be hi-res ( relative to page load) or low-res (relative to UNIX epoch)
+        // here use hi-res timestamp
+        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() {
@@ -1534,14 +2553,15 @@ class TaroEvent {
         this.defaultPrevented = true;
     }
     get target() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         const cacheTarget = this.cacheTarget;
         if (!cacheTarget) {
             const target = Object.create(((_a = this.mpEvent) === null || _a === void 0 ? void 0 : _a.target) || null);
+            const currentEle = env.document.getElementById(((_b = target.dataset) === null || _b === void 0 ? void 0 : _b.sid) || target.id || null);
             // Note：优先判断冒泡场景alipay的targetDataset的sid, 不然冒泡场景target属性吐出不对，其余拿取当前绑定id
-            const element = env.document.getElementById(((_b = target.targetDataset) === null || _b === void 0 ? void 0 : _b.sid) || ((_c = target.dataset) === null || _c === void 0 ? void 0 : _c.sid) || target.id || null);
-            target.dataset = element !== null ? element.dataset : shared.EMPTY_OBJ;
-            for (const key in (_d = this.mpEvent) === null || _d === void 0 ? void 0 : _d.detail) {
+            const element = env.document.getElementById(((_c = target.targetDataset) === null || _c === void 0 ? void 0 : _c.sid) || ((_d = target.dataset) === null || _d === void 0 ? void 0 : _d.sid) || target.id || null);
+            target.dataset = Object.assign(Object.assign({}, (currentEle !== null ? currentEle.dataset : shared.EMPTY_OBJ)), (element !== null ? element.dataset : shared.EMPTY_OBJ));
+            for (const key in (_e = this.mpEvent) === null || _e === void 0 ? void 0 : _e.detail) {
                 target[key] = this.mpEvent.detail[key];
             }
             this.cacheTarget = target;
@@ -1877,7 +2897,7 @@ class TaroText extends TaroNode {
         this._value = value;
     }
     set textContent(text) {
-        MutationObserver.record({
+        MutationObserver$1.record({
             target: this,
             type: "characterData" /* MutationRecordType.CHARACTER_DATA */,
             oldValue: this._value
@@ -1905,37 +2925,7 @@ class TaroText extends TaroNode {
     }
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-var _URLSearchParams_dict;
+var _dict, _a;
 const findReg = /[!'()~]|%20|%00/g;
 const plusReg = /\+/g;
 const replaceCharMap = {
@@ -1966,93 +2956,102 @@ function decode(str) {
 function encode(str) {
     return encodeURIComponent(str).replace(findReg, replacer);
 }
-class URLSearchParams {
-    constructor(query) {
-        _URLSearchParams_dict.set(this, Object.create(null));
-        query !== null && query !== void 0 ? query : (query = '');
-        const dict = __classPrivateFieldGet(this, _URLSearchParams_dict, "f");
-        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('=');
-                if (index > -1) {
-                    appendTo(dict, decode(value.slice(0, index)), decode(value.slice(index + 1)));
-                }
-                else if (value.length) {
-                    appendTo(dict, decode(value), '');
+const URLSearchParams = process.env.TARO_PLATFORM === 'web' ? env.window.URLSearchParams : (_a = class {
+        constructor(query) {
+            _dict.set(this, Object.create(null));
+            query !== null && query !== void 0 ? query : (query = '');
+            const dict = tslib.__classPrivateFieldGet(this, _dict, "f");
+            if (typeof query === 'string') {
+                if (query.charAt(0) === '?') {
+                    query = query.slice(1);
                 }
-            }
-        }
-        else {
-            if (shared.isArray(query)) {
-                for (let i = 0, length = query.length; i < length; i++) {
-                    const value = query[i];
-                    appendTo(dict, value[0], value[1]);
+                for (let pairs = query.split('&'), i = 0, length = pairs.length; i < length; i++) {
+                    const value = pairs[i];
+                    const index = value.indexOf('=');
+                    // 针对不规范的 url 参数做容错处理，如：word=你%好
+                    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 (query.forEach) {
-                query.forEach(addEach, dict);
-            }
             else {
-                for (const key in query) {
-                    appendTo(dict, key, query[key]);
+                if (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(__classPrivateFieldGet(this, _URLSearchParams_dict, "f"), name, value);
-    }
-    delete(name) {
-        delete __classPrivateFieldGet(this, _URLSearchParams_dict, "f")[name];
-    }
-    get(name) {
-        const dict = __classPrivateFieldGet(this, _URLSearchParams_dict, "f");
-        return name in dict ? dict[name][0] : null;
-    }
-    getAll(name) {
-        const dict = __classPrivateFieldGet(this, _URLSearchParams_dict, "f");
-        return name in dict ? dict[name].slice(0) : [];
-    }
-    has(name) {
-        return name in __classPrivateFieldGet(this, _URLSearchParams_dict, "f");
-    }
-    keys() {
-        return Object.keys(__classPrivateFieldGet(this, _URLSearchParams_dict, "f"));
-    }
-    set(name, value) {
-        __classPrivateFieldGet(this, _URLSearchParams_dict, "f")[name] = ['' + value];
-    }
-    forEach(callback, thisArg) {
-        const dict = __classPrivateFieldGet(this, _URLSearchParams_dict, "f");
-        Object.getOwnPropertyNames(dict).forEach(function (name) {
-            dict[name].forEach(function (value) {
-                callback.call(thisArg, value, name, this);
+        append(name, value) {
+            appendTo(tslib.__classPrivateFieldGet(this, _dict, "f"), name, value);
+        }
+        delete(name) {
+            delete tslib.__classPrivateFieldGet(this, _dict, "f")[name];
+        }
+        get(name) {
+            const dict = tslib.__classPrivateFieldGet(this, _dict, "f");
+            return name in dict ? dict[name][0] : null;
+        }
+        getAll(name) {
+            const dict = tslib.__classPrivateFieldGet(this, _dict, "f");
+            return name in dict ? dict[name].slice(0) : [];
+        }
+        has(name) {
+            return name in tslib.__classPrivateFieldGet(this, _dict, "f");
+        }
+        keys() {
+            return Object.keys(tslib.__classPrivateFieldGet(this, _dict, "f"));
+        }
+        set(name, value) {
+            tslib.__classPrivateFieldGet(this, _dict, "f")[name] = ['' + value];
+        }
+        forEach(callback, thisArg) {
+            const dict = tslib.__classPrivateFieldGet(this, _dict, "f");
+            Object.getOwnPropertyNames(dict).forEach(function (name) {
+                dict[name].forEach(function (value) {
+                    callback.call(thisArg, value, name, this);
+                }, this);
             }, this);
-        }, this);
-    }
-    toJSON() {
-        return {};
-    }
-    toString() {
-        const dict = __classPrivateFieldGet(this, _URLSearchParams_dict, "f");
-        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]));
+        }
+        toJSON() {
+            return {};
+        }
+        toString() {
+            const dict = tslib.__classPrivateFieldGet(this, _dict, "f");
+            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('&');
         }
-        return query.join('&');
-    }
-}
-_URLSearchParams_dict = new WeakMap();
+    },
+    _dict = new WeakMap(),
+    _a);
 
-var _URL_hash, _URL_hostname, _URL_pathname, _URL_port, _URL_protocol, _URL_search;
-class URL {
+var _TaroURL_hash, _TaroURL_hostname, _TaroURL_pathname, _TaroURL_port, _TaroURL_protocol, _TaroURL_search;
+class TaroURL {
     static createObjectURL() {
         throw new Error('Oops, not support URL.createObjectURL() in miniprogram.');
     }
@@ -2061,29 +3060,29 @@ class URL {
     }
     constructor(url, base) {
         /* private property */
-        _URL_hash.set(this, '');
-        _URL_hostname.set(this, '');
-        _URL_pathname.set(this, '');
-        _URL_port.set(this, '');
-        _URL_protocol.set(this, '');
-        _URL_search.set(this, void 0);
+        _TaroURL_hash.set(this, '');
+        _TaroURL_hostname.set(this, '');
+        _TaroURL_pathname.set(this, '');
+        _TaroURL_port.set(this, '');
+        _TaroURL_protocol.set(this, '');
+        _TaroURL_search.set(this, void 0);
         if (!shared.isString(url))
             url = String(url);
         const parseResult = parseUrlBase(url, base);
         const { hash, hostname, pathname, port, protocol, search } = parseResult;
-        __classPrivateFieldSet(this, _URL_hash, hash, "f");
-        __classPrivateFieldSet(this, _URL_hostname, hostname, "f");
-        __classPrivateFieldSet(this, _URL_pathname, pathname || '/', "f");
-        __classPrivateFieldSet(this, _URL_port, port, "f");
-        __classPrivateFieldSet(this, _URL_protocol, protocol, "f");
-        __classPrivateFieldSet(this, _URL_search, new URLSearchParams(search), "f");
+        tslib.__classPrivateFieldSet(this, _TaroURL_hash, hash, "f");
+        tslib.__classPrivateFieldSet(this, _TaroURL_hostname, hostname, "f");
+        tslib.__classPrivateFieldSet(this, _TaroURL_pathname, pathname || '/', "f");
+        tslib.__classPrivateFieldSet(this, _TaroURL_port, port, "f");
+        tslib.__classPrivateFieldSet(this, _TaroURL_protocol, protocol, "f");
+        tslib.__classPrivateFieldSet(this, _TaroURL_search, new URLSearchParams(search), "f");
     }
     /* public property */
     get protocol() {
-        return __classPrivateFieldGet(this, _URL_protocol, "f");
+        return tslib.__classPrivateFieldGet(this, _TaroURL_protocol, "f");
     }
     set protocol(val) {
-        shared.isString(val) && (__classPrivateFieldSet(this, _URL_protocol, val.trim(), "f"));
+        shared.isString(val) && (tslib.__classPrivateFieldSet(this, _TaroURL_protocol, val.trim(), "f"));
     }
     get host() {
         return this.hostname + (this.port ? ':' + this.port : '');
@@ -2097,19 +3096,19 @@ class URL {
         }
     }
     get hostname() {
-        return __classPrivateFieldGet(this, _URL_hostname, "f");
+        return tslib.__classPrivateFieldGet(this, _TaroURL_hostname, "f");
     }
     set hostname(val) {
-        val && shared.isString(val) && (__classPrivateFieldSet(this, _URL_hostname, val.trim(), "f"));
+        val && shared.isString(val) && (tslib.__classPrivateFieldSet(this, _TaroURL_hostname, val.trim(), "f"));
     }
     get port() {
-        return __classPrivateFieldGet(this, _URL_port, "f");
+        return tslib.__classPrivateFieldGet(this, _TaroURL_port, "f");
     }
     set port(val) {
-        shared.isString(val) && (__classPrivateFieldSet(this, _URL_port, val.trim(), "f"));
+        shared.isString(val) && (tslib.__classPrivateFieldSet(this, _TaroURL_port, val.trim(), "f"));
     }
     get pathname() {
-        return __classPrivateFieldGet(this, _URL_pathname, "f");
+        return tslib.__classPrivateFieldGet(this, _TaroURL_pathname, "f");
     }
     set pathname(val) {
         if (shared.isString(val)) {
@@ -2120,31 +3119,31 @@ class URL {
                 temp = temp.replace(HEAD_REG, '');
             }
             if (temp)
-                __classPrivateFieldSet(this, _URL_pathname, '/' + temp, "f");
+                tslib.__classPrivateFieldSet(this, _TaroURL_pathname, '/' + temp, "f");
             else
-                __classPrivateFieldSet(this, _URL_pathname, '/', "f");
+                tslib.__classPrivateFieldSet(this, _TaroURL_pathname, '/', "f");
         }
     }
     get search() {
-        const val = __classPrivateFieldGet(this, _URL_search, "f").toString();
+        const val = tslib.__classPrivateFieldGet(this, _TaroURL_search, "f").toString();
         return (val.length === 0 || val.startsWith('?')) ? val : `?${val}`;
     }
     set search(val) {
         if (shared.isString(val)) {
             val = val.trim();
-            __classPrivateFieldSet(this, _URL_search, new URLSearchParams(val), "f");
+            tslib.__classPrivateFieldSet(this, _TaroURL_search, new URLSearchParams(val), "f");
         }
     }
     get hash() {
-        return __classPrivateFieldGet(this, _URL_hash, "f");
+        return tslib.__classPrivateFieldGet(this, _TaroURL_hash, "f");
     }
     set hash(val) {
         if (shared.isString(val)) {
             val = val.trim();
             if (val)
-                __classPrivateFieldSet(this, _URL_hash, val.startsWith('#') ? val : `#${val}`, "f");
+                tslib.__classPrivateFieldSet(this, _TaroURL_hash, val.startsWith('#') ? val : `#${val}`, "f");
             else
-                __classPrivateFieldSet(this, _URL_hash, '', "f");
+                tslib.__classPrivateFieldSet(this, _TaroURL_hash, '', "f");
         }
     }
     get href() {
@@ -2175,7 +3174,7 @@ class URL {
         }
     }
     get searchParams() {
-        return __classPrivateFieldGet(this, _URL_search, "f");
+        return tslib.__classPrivateFieldGet(this, _TaroURL_search, "f");
     }
     // public method
     toString() {
@@ -2199,7 +3198,8 @@ class URL {
         };
     }
 }
-_URL_hash = new WeakMap(), _URL_hostname = new WeakMap(), _URL_pathname = new WeakMap(), _URL_port = new WeakMap(), _URL_protocol = new WeakMap(), _URL_search = new WeakMap();
+_TaroURL_hash = new WeakMap(), _TaroURL_hostname = new WeakMap(), _TaroURL_pathname = new WeakMap(), _TaroURL_port = new WeakMap(), _TaroURL_protocol = new WeakMap(), _TaroURL_search = new WeakMap();
+const URL = process.env.TARO_PLATFORM === 'web' ? env.window.URL : TaroURL;
 function parseUrl(url = '') {
     const result = {
         href: '',
@@ -2390,49 +3390,42 @@ class TaroDocument extends TaroElement {
     }
 }
 
-exports.document = void 0;
-if (process.env.TARO_ENV && !true) {
-    /* eslint-disable no-inner-declarations */
-    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); // 多包一层主要为了兼容 vue
-        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;
-    }
-    exports.document = env.document = createDocument();
-}
-else {
-    exports.document = env.document;
+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); // 多包一层主要为了兼容 vue
+    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;
 }
+const document$1 = process.env.TARO_PLATFORM === 'web' ? env.document : (env.document = createDocument());
 
-function getComputedStyle(element) {
+const getComputedStyle = process.env.TARO_PLATFORM === 'web' ? env.window.getComputedStyle : function (element) {
     return element.style;
-}
+};
 
 const eventCenter = shared.hooks.call('getEventCenter', shared.Events);
 
@@ -2461,72 +3454,72 @@ class RuntimeCache {
     }
 }
 
-var _History_instances, _History_location, _History_stack, _History_cur, _History_window, _History_reset;
+var _TaroHistory_instances, _TaroHistory_location, _TaroHistory_stack, _TaroHistory_cur, _TaroHistory_window, _TaroHistory_reset;
 const cache$1 = new RuntimeCache('history');
-class History extends shared.Events {
+class TaroHistory extends shared.Events {
     constructor(location, options) {
         super();
-        _History_instances.add(this);
+        _TaroHistory_instances.add(this);
         /* private property */
-        _History_location.set(this, void 0);
-        _History_stack.set(this, []);
-        _History_cur.set(this, 0);
-        _History_window.set(this, void 0);
-        __classPrivateFieldSet(this, _History_window, options.window, "f");
-        __classPrivateFieldSet(this, _History_location, location, "f");
-        __classPrivateFieldGet(this, _History_location, "f").on('__record_history__', (href) => {
+        _TaroHistory_location.set(this, void 0);
+        _TaroHistory_stack.set(this, []);
+        _TaroHistory_cur.set(this, 0);
+        _TaroHistory_window.set(this, void 0);
+        tslib.__classPrivateFieldSet(this, _TaroHistory_window, options.window, "f");
+        tslib.__classPrivateFieldSet(this, _TaroHistory_location, location, "f");
+        tslib.__classPrivateFieldGet(this, _TaroHistory_location, "f").on('__record_history__', (href) => {
             var _a;
-            __classPrivateFieldSet(this, _History_cur, (_a = __classPrivateFieldGet(this, _History_cur, "f"), _a++, _a), "f");
-            __classPrivateFieldSet(this, _History_stack, __classPrivateFieldGet(this, _History_stack, "f").slice(0, __classPrivateFieldGet(this, _History_cur, "f")), "f");
-            __classPrivateFieldGet(this, _History_stack, "f").push({
+            tslib.__classPrivateFieldSet(this, _TaroHistory_cur, (_a = tslib.__classPrivateFieldGet(this, _TaroHistory_cur, "f"), _a++, _a), "f");
+            tslib.__classPrivateFieldSet(this, _TaroHistory_stack, tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f").slice(0, tslib.__classPrivateFieldGet(this, _TaroHistory_cur, "f")), "f");
+            tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f").push({
                 state: null,
                 title: '',
                 url: href
             });
         }, null);
-        __classPrivateFieldGet(this, _History_location, "f").on('__reset_history__', (href) => {
-            __classPrivateFieldGet(this, _History_instances, "m", _History_reset).call(this, href);
+        tslib.__classPrivateFieldGet(this, _TaroHistory_location, "f").on('__reset_history__', (href) => {
+            tslib.__classPrivateFieldGet(this, _TaroHistory_instances, "m", _TaroHistory_reset).call(this, href);
         }, null);
         // 切换上下文行为
         this.on(exports.CONTEXT_ACTIONS.INIT, () => {
-            __classPrivateFieldGet(this, _History_instances, "m", _History_reset).call(this);
+            tslib.__classPrivateFieldGet(this, _TaroHistory_instances, "m", _TaroHistory_reset).call(this);
         }, null);
         this.on(exports.CONTEXT_ACTIONS.RESTORE, (pageId) => {
             cache$1.set(pageId, {
-                location: __classPrivateFieldGet(this, _History_location, "f"),
-                stack: __classPrivateFieldGet(this, _History_stack, "f").slice(),
-                cur: __classPrivateFieldGet(this, _History_cur, "f")
+                location: tslib.__classPrivateFieldGet(this, _TaroHistory_location, "f"),
+                stack: tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f").slice(),
+                cur: tslib.__classPrivateFieldGet(this, _TaroHistory_cur, "f")
             });
         }, null);
         this.on(exports.CONTEXT_ACTIONS.RECOVER, (pageId) => {
             if (cache$1.has(pageId)) {
                 const ctx = cache$1.get(pageId);
-                __classPrivateFieldSet(this, _History_location, ctx.location, "f");
-                __classPrivateFieldSet(this, _History_stack, ctx.stack, "f");
-                __classPrivateFieldSet(this, _History_cur, ctx.cur, "f");
+                tslib.__classPrivateFieldSet(this, _TaroHistory_location, ctx.location, "f");
+                tslib.__classPrivateFieldSet(this, _TaroHistory_stack, ctx.stack, "f");
+                tslib.__classPrivateFieldSet(this, _TaroHistory_cur, ctx.cur, "f");
             }
         }, null);
         this.on(exports.CONTEXT_ACTIONS.DESTORY, (pageId) => {
             cache$1.delete(pageId);
         }, null);
-        __classPrivateFieldGet(this, _History_instances, "m", _History_reset).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroHistory_instances, "m", _TaroHistory_reset).call(this);
     }
     /* public property */
     get length() {
-        return __classPrivateFieldGet(this, _History_stack, "f").length;
+        return tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f").length;
     }
     get state() {
-        return __classPrivateFieldGet(this, _History_stack, "f")[__classPrivateFieldGet(this, _History_cur, "f")].state;
+        return tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f")[tslib.__classPrivateFieldGet(this, _TaroHistory_cur, "f")].state;
     }
     /* public method */
     go(delta) {
         if (!shared.isNumber(delta) || isNaN(delta))
             return;
-        let targetIdx = __classPrivateFieldGet(this, _History_cur, "f") + delta;
+        let targetIdx = tslib.__classPrivateFieldGet(this, _TaroHistory_cur, "f") + delta;
         targetIdx = Math.min(Math.max(targetIdx, 0), this.length - 1);
-        __classPrivateFieldSet(this, _History_cur, targetIdx, "f");
-        __classPrivateFieldGet(this, _History_location, "f").trigger('__set_href_without_history__', __classPrivateFieldGet(this, _History_stack, "f")[__classPrivateFieldGet(this, _History_cur, "f")].url);
-        __classPrivateFieldGet(this, _History_window, "f").trigger('popstate', __classPrivateFieldGet(this, _History_stack, "f")[__classPrivateFieldGet(this, _History_cur, "f")]);
+        tslib.__classPrivateFieldSet(this, _TaroHistory_cur, targetIdx, "f");
+        tslib.__classPrivateFieldGet(this, _TaroHistory_location, "f").trigger('__set_href_without_history__', tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f")[tslib.__classPrivateFieldGet(this, _TaroHistory_cur, "f")].url);
+        tslib.__classPrivateFieldGet(this, _TaroHistory_window, "f").trigger('popstate', tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f")[tslib.__classPrivateFieldGet(this, _TaroHistory_cur, "f")]);
     }
     back() {
         this.go(-1);
@@ -2537,40 +3530,41 @@ class History extends shared.Events {
     pushState(state, title, url) {
         if (!url || !shared.isString(url))
             return;
-        __classPrivateFieldSet(this, _History_stack, __classPrivateFieldGet(this, _History_stack, "f").slice(0, __classPrivateFieldGet(this, _History_cur, "f") + 1), "f");
-        __classPrivateFieldGet(this, _History_stack, "f").push({
+        tslib.__classPrivateFieldSet(this, _TaroHistory_stack, tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f").slice(0, tslib.__classPrivateFieldGet(this, _TaroHistory_cur, "f") + 1), "f");
+        tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f").push({
             state,
             title,
             url
         });
-        __classPrivateFieldSet(this, _History_cur, this.length - 1, "f");
-        __classPrivateFieldGet(this, _History_location, "f").trigger('__set_href_without_history__', url);
+        tslib.__classPrivateFieldSet(this, _TaroHistory_cur, this.length - 1, "f");
+        tslib.__classPrivateFieldGet(this, _TaroHistory_location, "f").trigger('__set_href_without_history__', url);
     }
     replaceState(state, title, url) {
         if (!url || !shared.isString(url))
             return;
-        __classPrivateFieldGet(this, _History_stack, "f")[__classPrivateFieldGet(this, _History_cur, "f")] = {
+        tslib.__classPrivateFieldGet(this, _TaroHistory_stack, "f")[tslib.__classPrivateFieldGet(this, _TaroHistory_cur, "f")] = {
             state,
             title,
             url
         };
-        __classPrivateFieldGet(this, _History_location, "f").trigger('__set_href_without_history__', url);
+        tslib.__classPrivateFieldGet(this, _TaroHistory_location, "f").trigger('__set_href_without_history__', url);
     }
     // For debug
     get cache() {
         return cache$1;
     }
 }
-_History_location = new WeakMap(), _History_stack = new WeakMap(), _History_cur = new WeakMap(), _History_window = new WeakMap(), _History_instances = new WeakSet(), _History_reset = function _History_reset(href = '') {
-    __classPrivateFieldSet(this, _History_stack, [
+_TaroHistory_location = new WeakMap(), _TaroHistory_stack = new WeakMap(), _TaroHistory_cur = new WeakMap(), _TaroHistory_window = new WeakMap(), _TaroHistory_instances = new WeakSet(), _TaroHistory_reset = function _TaroHistory_reset(href = '') {
+    tslib.__classPrivateFieldSet(this, _TaroHistory_stack, [
         {
             state: null,
             title: '',
-            url: href || __classPrivateFieldGet(this, _History_location, "f").href
+            url: href || tslib.__classPrivateFieldGet(this, _TaroHistory_location, "f").href
         }
     ], "f");
-    __classPrivateFieldSet(this, _History_cur, 0, "f");
+    tslib.__classPrivateFieldSet(this, _TaroHistory_cur, 0, "f");
 };
+const History = process.env.TARO_PLATFORM === 'web' ? env.window.History : TaroHistory;
 
 const Current = {
     app: null,
@@ -2579,31 +3573,31 @@ const Current = {
 };
 const getCurrentInstance = () => Current;
 
-var _Location_instances, _Location_url, _Location_noCheckUrl, _Location_window, _Location_reset, _Location_getPreValue, _Location_rollBack, _Location_recordHistory, _Location_checkUrlChange;
+var _TaroLocation_instances, _TaroLocation_url, _TaroLocation_noCheckUrl, _TaroLocation_window, _TaroLocation_reset, _TaroLocation_getPreValue, _TaroLocation_rollBack, _TaroLocation_recordHistory, _TaroLocation_checkUrlChange;
 const INIT_URL = 'https://taro.com';
 const cache = new RuntimeCache('location');
-class Location extends shared.Events {
+class TaroLocation extends shared.Events {
     constructor(options) {
         super();
-        _Location_instances.add(this);
+        _TaroLocation_instances.add(this);
         /* private property */
-        _Location_url.set(this, new URL(INIT_URL));
-        _Location_noCheckUrl.set(this, false);
-        _Location_window.set(this, void 0);
-        __classPrivateFieldSet(this, _Location_window, options.window, "f");
-        __classPrivateFieldGet(this, _Location_instances, "m", _Location_reset).call(this);
+        _TaroLocation_url.set(this, new URL(INIT_URL));
+        _TaroLocation_noCheckUrl.set(this, false);
+        _TaroLocation_window.set(this, void 0);
+        tslib.__classPrivateFieldSet(this, _TaroLocation_window, options.window, "f");
+        tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_reset).call(this);
         this.on('__set_href_without_history__', (href) => {
-            __classPrivateFieldSet(this, _Location_noCheckUrl, true, "f");
-            const lastHash = __classPrivateFieldGet(this, _Location_url, "f").hash;
-            __classPrivateFieldGet(this, _Location_url, "f").href = generateFullUrl(href);
-            if (lastHash !== __classPrivateFieldGet(this, _Location_url, "f").hash) {
-                __classPrivateFieldGet(this, _Location_window, "f").trigger('hashchange');
+            tslib.__classPrivateFieldSet(this, _TaroLocation_noCheckUrl, true, "f");
+            const lastHash = tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").hash;
+            tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").href = generateFullUrl(href);
+            if (lastHash !== tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").hash) {
+                tslib.__classPrivateFieldGet(this, _TaroLocation_window, "f").trigger('hashchange');
             }
-            __classPrivateFieldSet(this, _Location_noCheckUrl, false, "f");
+            tslib.__classPrivateFieldSet(this, _TaroLocation_noCheckUrl, false, "f");
         }, null);
         // 切换上下文行为
         this.on(exports.CONTEXT_ACTIONS.INIT, () => {
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_reset).call(this);
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_reset).call(this);
         }, null);
         this.on(exports.CONTEXT_ACTIONS.RESTORE, (pageId) => {
             cache.set(pageId, {
@@ -2614,9 +3608,9 @@ class Location extends shared.Events {
             // 数据恢复时，不需要执行跳转
             if (cache.has(pageId)) {
                 const ctx = cache.get(pageId);
-                __classPrivateFieldSet(this, _Location_noCheckUrl, true, "f");
-                __classPrivateFieldGet(this, _Location_url, "f").href = ctx.lastHref;
-                __classPrivateFieldSet(this, _Location_noCheckUrl, false, "f");
+                tslib.__classPrivateFieldSet(this, _TaroLocation_noCheckUrl, true, "f");
+                tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").href = ctx.lastHref;
+                tslib.__classPrivateFieldSet(this, _TaroLocation_noCheckUrl, false, "f");
             }
         }, null);
         this.on(exports.CONTEXT_ACTIONS.DESTORY, (pageId) => {
@@ -2625,81 +3619,81 @@ class Location extends shared.Events {
     }
     /* public property */
     get protocol() {
-        return __classPrivateFieldGet(this, _Location_url, "f").protocol;
+        return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").protocol;
     }
     set protocol(val) {
         const REG = /^(http|https):$/i;
         if (!val || !shared.isString(val) || !REG.test(val.trim()))
             return;
         val = val.trim();
-        const preValue = __classPrivateFieldGet(this, _Location_instances, "m", _Location_getPreValue).call(this);
-        __classPrivateFieldGet(this, _Location_url, "f").protocol = val;
-        if (__classPrivateFieldGet(this, _Location_instances, "m", _Location_checkUrlChange).call(this, preValue))
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_recordHistory).call(this);
+        const preValue = tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_getPreValue).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").protocol = val;
+        if (tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_checkUrlChange).call(this, preValue))
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_recordHistory).call(this);
     }
     get host() {
-        return __classPrivateFieldGet(this, _Location_url, "f").host;
+        return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").host;
     }
     set host(val) {
         if (!val || !shared.isString(val))
             return;
         val = val.trim();
-        const preValue = __classPrivateFieldGet(this, _Location_instances, "m", _Location_getPreValue).call(this);
-        __classPrivateFieldGet(this, _Location_url, "f").host = val;
-        if (__classPrivateFieldGet(this, _Location_instances, "m", _Location_checkUrlChange).call(this, preValue))
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_recordHistory).call(this);
+        const preValue = tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_getPreValue).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").host = val;
+        if (tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_checkUrlChange).call(this, preValue))
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_recordHistory).call(this);
     }
     get hostname() {
-        return __classPrivateFieldGet(this, _Location_url, "f").hostname;
+        return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").hostname;
     }
     set hostname(val) {
         if (!val || !shared.isString(val))
             return;
         val = val.trim();
-        const preValue = __classPrivateFieldGet(this, _Location_instances, "m", _Location_getPreValue).call(this);
-        __classPrivateFieldGet(this, _Location_url, "f").hostname = val;
-        if (__classPrivateFieldGet(this, _Location_instances, "m", _Location_checkUrlChange).call(this, preValue))
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_recordHistory).call(this);
+        const preValue = tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_getPreValue).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").hostname = val;
+        if (tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_checkUrlChange).call(this, preValue))
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_recordHistory).call(this);
     }
     get port() {
-        return __classPrivateFieldGet(this, _Location_url, "f").port;
+        return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").port;
     }
     set port(val) {
         const xVal = Number((val = val.trim()));
         if (!shared.isNumber(xVal) || xVal <= 0)
             return;
-        const preValue = __classPrivateFieldGet(this, _Location_instances, "m", _Location_getPreValue).call(this);
-        __classPrivateFieldGet(this, _Location_url, "f").port = val;
-        if (__classPrivateFieldGet(this, _Location_instances, "m", _Location_checkUrlChange).call(this, preValue))
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_recordHistory).call(this);
+        const preValue = tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_getPreValue).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").port = val;
+        if (tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_checkUrlChange).call(this, preValue))
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_recordHistory).call(this);
     }
     get pathname() {
-        return __classPrivateFieldGet(this, _Location_url, "f").pathname;
+        return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").pathname;
     }
     set pathname(val) {
         if (!val || !shared.isString(val))
             return;
         val = val.trim();
-        const preValue = __classPrivateFieldGet(this, _Location_instances, "m", _Location_getPreValue).call(this);
-        __classPrivateFieldGet(this, _Location_url, "f").pathname = val;
-        if (__classPrivateFieldGet(this, _Location_instances, "m", _Location_checkUrlChange).call(this, preValue))
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_recordHistory).call(this);
+        const preValue = tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_getPreValue).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").pathname = val;
+        if (tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_checkUrlChange).call(this, preValue))
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_recordHistory).call(this);
     }
     get search() {
-        return __classPrivateFieldGet(this, _Location_url, "f").search;
+        return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").search;
     }
     set search(val) {
         if (!val || !shared.isString(val))
             return;
         val = val.trim();
         val = val.startsWith('?') ? val : `?${val}`;
-        const preValue = __classPrivateFieldGet(this, _Location_instances, "m", _Location_getPreValue).call(this);
-        __classPrivateFieldGet(this, _Location_url, "f").search = val;
-        if (__classPrivateFieldGet(this, _Location_instances, "m", _Location_checkUrlChange).call(this, preValue))
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_recordHistory).call(this);
+        const preValue = tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_getPreValue).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").search = val;
+        if (tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_checkUrlChange).call(this, preValue))
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_recordHistory).call(this);
     }
     get hash() {
-        return __classPrivateFieldGet(this, _Location_url, "f").hash;
+        return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").hash;
     }
     // 小程序的navigateTo存在截断hash字符串的问题
     set hash(val) {
@@ -2707,34 +3701,34 @@ class Location extends shared.Events {
             return;
         val = val.trim();
         val = val.startsWith('#') ? val : `#${val}`;
-        const preValue = __classPrivateFieldGet(this, _Location_instances, "m", _Location_getPreValue).call(this);
-        __classPrivateFieldGet(this, _Location_url, "f").hash = val;
-        if (__classPrivateFieldGet(this, _Location_instances, "m", _Location_checkUrlChange).call(this, preValue))
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_recordHistory).call(this);
+        const preValue = tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_getPreValue).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").hash = val;
+        if (tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_checkUrlChange).call(this, preValue))
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_recordHistory).call(this);
     }
     get href() {
-        return __classPrivateFieldGet(this, _Location_url, "f").href;
+        return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").href;
     }
     set href(val) {
         const REG = /^(http:|https:)?\/\/.+/;
         if (!val || !shared.isString(val) || !REG.test((val = val.trim())))
             return;
-        const preValue = __classPrivateFieldGet(this, _Location_instances, "m", _Location_getPreValue).call(this);
-        __classPrivateFieldGet(this, _Location_url, "f").href = val;
-        if (__classPrivateFieldGet(this, _Location_instances, "m", _Location_checkUrlChange).call(this, preValue))
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_recordHistory).call(this);
+        const preValue = tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_getPreValue).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").href = val;
+        if (tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_checkUrlChange).call(this, preValue))
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_recordHistory).call(this);
     }
     get origin() {
-        return __classPrivateFieldGet(this, _Location_url, "f").origin;
+        return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").origin;
     }
     set origin(val) {
         const REG = /^(http:|https:)?\/\/.+/;
         if (!val || !shared.isString(val) || !REG.test((val = val.trim())))
             return;
-        const preValue = __classPrivateFieldGet(this, _Location_instances, "m", _Location_getPreValue).call(this);
-        __classPrivateFieldGet(this, _Location_url, "f").origin = val;
-        if (__classPrivateFieldGet(this, _Location_instances, "m", _Location_checkUrlChange).call(this, preValue))
-            __classPrivateFieldGet(this, _Location_instances, "m", _Location_recordHistory).call(this);
+        const preValue = tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_getPreValue).call(this);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").origin = val;
+        if (tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_checkUrlChange).call(this, preValue))
+            tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_recordHistory).call(this);
     }
     /* public method */
     assign() {
@@ -2754,7 +3748,7 @@ class Location extends shared.Events {
         return cache;
     }
 }
-_Location_url = new WeakMap(), _Location_noCheckUrl = new WeakMap(), _Location_window = new WeakMap(), _Location_instances = new WeakSet(), _Location_reset = function _Location_reset() {
+_TaroLocation_url = new WeakMap(), _TaroLocation_noCheckUrl = new WeakMap(), _TaroLocation_window = new WeakMap(), _TaroLocation_instances = new WeakSet(), _TaroLocation_reset = function _TaroLocation_reset() {
     const Current = getCurrentInstance();
     const router = Current.router;
     if (router) {
@@ -2764,23 +3758,23 @@ _Location_url = new WeakMap(), _Location_noCheckUrl = new WeakMap(), _Location_w
         });
         const searchStr = searchArr.length > 0 ? '?' + searchArr.join('&') : '';
         const url = `${INIT_URL}${path.startsWith('/') ? path : '/' + path}${searchStr}`;
-        __classPrivateFieldSet(this, _Location_url, new URL(url), "f");
+        tslib.__classPrivateFieldSet(this, _TaroLocation_url, new URL(url), "f");
         this.trigger('__reset_history__', this.href);
     }
-}, _Location_getPreValue = function _Location_getPreValue() {
-    return __classPrivateFieldGet(this, _Location_url, "f")._toRaw();
-}, _Location_rollBack = function _Location_rollBack(href) {
-    __classPrivateFieldGet(this, _Location_url, "f").href = href;
-}, _Location_recordHistory = function _Location_recordHistory() {
+}, _TaroLocation_getPreValue = function _TaroLocation_getPreValue() {
+    return tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f")._toRaw();
+}, _TaroLocation_rollBack = function _TaroLocation_rollBack(href) {
+    tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f").href = href;
+}, _TaroLocation_recordHistory = function _TaroLocation_recordHistory() {
     this.trigger('__record_history__', this.href);
-}, _Location_checkUrlChange = function _Location_checkUrlChange(preValue) {
-    if (__classPrivateFieldGet(this, _Location_noCheckUrl, "f")) {
+}, _TaroLocation_checkUrlChange = function _TaroLocation_checkUrlChange(preValue) {
+    if (tslib.__classPrivateFieldGet(this, _TaroLocation_noCheckUrl, "f")) {
         return false;
     }
-    const { protocol, hostname, port, pathname, search, hash } = __classPrivateFieldGet(this, _Location_url, "f")._toRaw();
+    const { protocol, hostname, port, pathname, search, hash } = tslib.__classPrivateFieldGet(this, _TaroLocation_url, "f")._toRaw();
     // 跨域三要素不允许修改
     if (protocol !== preValue.protocol || hostname !== preValue.hostname || port !== preValue.port) {
-        __classPrivateFieldGet(this, _Location_instances, "m", _Location_rollBack).call(this, preValue.href);
+        tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_rollBack).call(this, preValue.href);
         return false;
     }
     // pathname
@@ -2793,12 +3787,13 @@ _Location_url = new WeakMap(), _Location_noCheckUrl = new WeakMap(), _Location_w
     }
     // hashchange
     if (hash !== preValue.hash) {
-        __classPrivateFieldGet(this, _Location_window, "f").trigger('hashchange');
+        tslib.__classPrivateFieldGet(this, _TaroLocation_window, "f").trigger('hashchange');
         return true;
     }
-    __classPrivateFieldGet(this, _Location_instances, "m", _Location_rollBack).call(this, preValue.href);
+    tslib.__classPrivateFieldGet(this, _TaroLocation_instances, "m", _TaroLocation_rollBack).call(this, preValue.href);
     return false;
 };
+const Location = process.env.TARO_PLATFORM === 'web' ? env.window.Location : TaroLocation;
 function generateFullUrl(val = '') {
     const origin = INIT_URL;
     if (/^[/?#]/.test(val)) {
@@ -2807,7 +3802,25 @@ function generateFullUrl(val = '') {
     return val;
 }
 
-const nav = env.window.navigator ;
+const machine = 'Macintosh';
+const arch = 'Intel Mac OS X 10_14_5';
+const engine = 'AppleWebKit/534.36 (KHTML, like Gecko) NodeJS/v4.1.0 Chrome/76.0.3809.132 Safari/534.36';
+const msg = '(' + machine + '; ' + arch + ') ' + engine;
+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: ''
+};
 
 // https://github.com/myrne/performance-now
 exports.now = void 0;
@@ -2840,95 +3853,110 @@ const _caf = typeof cancelAnimationFrame !== 'undefined' && cancelAnimationFrame
         clearTimeout(seed);
     };
 
-exports.window = void 0;
-if (process.env.TARO_ENV && !true) {
-    class Window extends shared.Events {
-        constructor() {
-            super();
-            this.navigator = nav;
-            this.requestAnimationFrame = _raf;
-            this.cancelAnimationFrame = _caf;
-            this.getComputedStyle = getComputedStyle;
-            const globalProperties = [
-                ...Object.getOwnPropertyNames(global || {}),
-                ...Object.getOwnPropertySymbols(global || {})
-            ];
-            globalProperties.forEach(property => {
-                if (property === 'atob' || property === 'document')
-                    return;
-                if (!Object.prototype.hasOwnProperty.call(this, property)) {
-                    // 防止小程序环境下，window 上的某些 get 属性在赋值时报错
-                    try {
-                        this[property] = global[property];
-                    }
-                    catch (e) {
-                        if (process.env.NODE_ENV !== 'production') {
-                            console.warn(`[Taro warn] window.${String(property)} 在赋值到 window 时报错`);
-                        }
+class TaroWindow extends shared.Events {
+    constructor() {
+        super();
+        this.navigator = nav;
+        this.requestAnimationFrame = _raf;
+        this.cancelAnimationFrame = _caf;
+        this.getComputedStyle = getComputedStyle;
+        const globalProperties = [
+            ...Object.getOwnPropertyNames(global || {}),
+            ...Object.getOwnPropertySymbols(global || {})
+        ];
+        globalProperties.forEach(property => {
+            if (property === 'atob' || property === 'document')
+                return;
+            if (!Object.prototype.hasOwnProperty.call(this, property)) {
+                // 防止小程序环境下，window 上的某些 get 属性在赋值时报错
+                try {
+                    this[property] = global[property];
+                }
+                catch (e) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        console.warn(`[Taro warn] window.${String(property)} 在赋值到 window 时报错`);
                     }
                 }
-            });
-            this.Date || (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(exports.CONTEXT_ACTIONS.INIT, (pageId) => {
-                // 页面onload，为该页面建立新的上下文信息
-                _location.trigger(exports.CONTEXT_ACTIONS.INIT, pageId);
-            }, null);
-            this.on(exports.CONTEXT_ACTIONS.RECOVER, (pageId) => {
-                // 页面onshow，恢复当前页面的上下文信息
-                _location.trigger(exports.CONTEXT_ACTIONS.RECOVER, pageId);
-                _history.trigger(exports.CONTEXT_ACTIONS.RECOVER, pageId);
-            }, null);
-            this.on(exports.CONTEXT_ACTIONS.RESTORE, (pageId) => {
-                // 页面onhide，缓存当前页面的上下文信息
-                _location.trigger(exports.CONTEXT_ACTIONS.RESTORE, pageId);
-                _history.trigger(exports.CONTEXT_ACTIONS.RESTORE, pageId);
-            }, null);
-            this.on(exports.CONTEXT_ACTIONS.DESTORY, (pageId) => {
-                // 页面onunload，清除当前页面的上下文信息
-                _location.trigger(exports.CONTEXT_ACTIONS.DESTORY, pageId);
-                _history.trigger(exports.CONTEXT_ACTIONS.DESTORY, pageId);
-            }, null);
-        }
-        get document() {
-            return env.document;
-        }
-        addEventListener(event, callback) {
-            if (!shared.isString(event))
-                return;
-            this.on(event, callback, null);
-        }
-        removeEventListener(event, callback) {
-            if (!shared.isString(event))
-                return;
-            this.off(event, callback, null);
-        }
-        setTimeout(...args) {
-            return setTimeout(...args);
-        }
-        clearTimeout(...args) {
-            return clearTimeout(...args);
-        }
+            }
+        });
+        this.Date || (this.Date = Date);
+        // 应用启动时，提供给需要读取历史信息的库使用
+        this.location = new Location({ window: this });
+        // @ts-ignore
+        this.history = new History(this.location, { window: this });
+        this.initEvent();
+    }
+    initEvent() {
+        const _location = this.location;
+        const _history = this.history;
+        this.on(exports.CONTEXT_ACTIONS.INIT, (pageId) => {
+            // 页面onload，为该页面建立新的上下文信息
+            _location.trigger(exports.CONTEXT_ACTIONS.INIT, pageId);
+        }, null);
+        this.on(exports.CONTEXT_ACTIONS.RECOVER, (pageId) => {
+            // 页面onshow，恢复当前页面的上下文信息
+            _location.trigger(exports.CONTEXT_ACTIONS.RECOVER, pageId);
+            _history.trigger(exports.CONTEXT_ACTIONS.RECOVER, pageId);
+        }, null);
+        this.on(exports.CONTEXT_ACTIONS.RESTORE, (pageId) => {
+            // 页面onhide，缓存当前页面的上下文信息
+            _location.trigger(exports.CONTEXT_ACTIONS.RESTORE, pageId);
+            _history.trigger(exports.CONTEXT_ACTIONS.RESTORE, pageId);
+        }, null);
+        this.on(exports.CONTEXT_ACTIONS.DESTORY, (pageId) => {
+            // 页面onunload，清除当前页面的上下文信息
+            _location.trigger(exports.CONTEXT_ACTIONS.DESTORY, pageId);
+            _history.trigger(exports.CONTEXT_ACTIONS.DESTORY, pageId);
+        }, null);
+    }
+    get document() {
+        return env.document;
+    }
+    addEventListener(event, callback) {
+        if (!shared.isString(event))
+            return;
+        this.on(event, callback, null);
+    }
+    removeEventListener(event, callback) {
+        if (!shared.isString(event))
+            return;
+        this.off(event, callback, null);
+    }
+    setTimeout(...args) {
+        return setTimeout(...args);
+    }
+    clearTimeout(...args) {
+        return clearTimeout(...args);
     }
-    exports.window = env.window = new Window();
-}
-else {
-    exports.window = env.window;
 }
-const location = exports.window.location;
-const history = exports.window.history;
+const window$1 = process.env.TARO_PLATFORM === 'web' ? env.window : (env.window = new TaroWindow());
+const location = window$1.location;
+const history = window$1.history;
 
 // for Vue3
 class SVGElement extends TaroElement {
 }
 
+// export const removeLeadingSlash = (str = '') => str.replace(/^\.?\//, '')
+// export const removeTrailingSearch = (str = '') => str.replace(/\?[\s\S]*$/, '')
+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 = '') => {
+    var _a;
+    const routePath = addLeadingSlash(stripBasename(path, basename));
+    const alias = ((_a = Object.entries(customRoutes).find(([key]) => key === routePath)) === null || _a === void 0 ? void 0 : _a[1]) || routePath;
+    return entryPagePath || (typeof alias === 'string' ? alias : alias[0]) || basename;
+};
+const getCurrentPage = (routerMode = 'hash', basename = '/') => {
+    const pagePath = routerMode === 'hash'
+        ? location.hash.slice(1).split('?')[0]
+        : location.pathname;
+    return addLeadingSlash(stripBasename(pagePath, basename));
+};
+
 /* eslint-disable dot-notation */
 const instances = new Map();
 const pageId = incrementId();
@@ -2942,12 +3970,6 @@ function getPageInstance(id) {
 function removePageInstance(id) {
     instances.delete(id);
 }
-function addLeadingSlash(path) {
-    if (path == null) {
-        return '';
-    }
-    return path.charAt(0) === '/' ? path : '/' + path;
-}
 function safeExecute(path, lifecycle, ...args) {
     const instance = instances.get(path);
     if (instance == null) {
@@ -2974,9 +3996,12 @@ function stringify(obj) {
 }
 function getPath(id, options) {
     const idx = id.indexOf('?');
-    {
+    if (process.env.TARO_PLATFORM === 'web') {
         return `${idx > -1 ? id.substring(0, idx) : id}${stringify((options === null || options === void 0 ? void 0 : options.stamp) ? { stamp: options.stamp } : {})}`;
     }
+    else {
+        return `${idx > -1 ? id.substring(0, idx) : id}${stringify(options)}`;
+    }
 }
 function getOnReadyEventKey(path) {
     return path + '.' + ON_READY;
@@ -2995,7 +4020,7 @@ function createPageConfig(component, pageName, data, pageConfig) {
     let unmounting = false;
     let prepareMountList = [];
     function setCurrentRouter(page) {
-        const router = page.$taroPath ;
+        const router = process.env.TARO_PLATFORM === 'web' ? page.$taroPath : page.route || page.__route__ || page.$taroPath;
         Current.router = {
             params: page.$taroParams,
             path: addLeadingSlash(router),
@@ -3019,7 +4044,7 @@ function createPageConfig(component, pageName, data, pageConfig) {
             // this.$taroPath 是页面唯一标识
             const uniqueOptions = Object.assign({}, options, { $taroTimestamp: Date.now() });
             const $taroPath = this.$taroPath = getPath(id, uniqueOptions);
-            {
+            if (process.env.TARO_PLATFORM === 'web') {
                 config.path = $taroPath;
             }
             // this.$taroParams 作为暴露给开发者的页面参数对象，可以被随意修改
@@ -3027,13 +4052,21 @@ function createPageConfig(component, pageName, data, pageConfig) {
                 this.$taroParams = uniqueOptions;
             }
             setCurrentRouter(this);
+            // 初始化当前页面的上下文信息
+            if (process.env.TARO_PLATFORM !== 'web') {
+                window$1.trigger(exports.CONTEXT_ACTIONS.INIT, $taroPath);
+            }
             const mount = () => {
                 Current.app.mount(component, $taroPath, () => {
                     pageElement = env.document.getElementById($taroPath);
                     shared.ensure(pageElement !== null, '没有找到页面实例。');
                     safeExecute($taroPath, ON_LOAD, this.$taroParams);
                     loadResolver();
-                    {
+                    if (process.env.TARO_PLATFORM !== 'web') {
+                        pageElement.ctx = this;
+                        pageElement.performUpdate(true, cb);
+                    }
+                    else {
                         shared.isFunction(cb) && cb();
                     }
                 });
@@ -3047,6 +4080,10 @@ function createPageConfig(component, pageName, data, pageConfig) {
         },
         [ONUNLOAD]() {
             const $taroPath = this.$taroPath;
+            // 销毁当前页面的上下文信息
+            if (process.env.TARO_PLATFORM !== 'web') {
+                window$1.trigger(exports.CONTEXT_ACTIONS.DESTORY, $taroPath);
+            }
             // 触发onUnload生命周期
             safeExecute($taroPath, ONUNLOAD);
             unmounting = true;
@@ -3077,6 +4114,10 @@ function createPageConfig(component, pageName, data, pageConfig) {
                 // 设置 Current 的 page 和 router
                 Current.page = this;
                 setCurrentRouter(this);
+                // 恢复上下文信息
+                if (process.env.TARO_PLATFORM !== 'web') {
+                    window$1.trigger(exports.CONTEXT_ACTIONS.RECOVER, this.$taroPath);
+                }
                 // 触发生命周期
                 safeExecute(this.$taroPath, ON_SHOW, options);
                 // 通过事件触发子组件的生命周期
@@ -3084,6 +4125,10 @@ function createPageConfig(component, pageName, data, pageConfig) {
             });
         },
         [ONHIDE]() {
+            // 缓存当前页面上下文信息
+            if (process.env.TARO_PLATFORM !== 'web') {
+                window$1.trigger(exports.CONTEXT_ACTIONS.RESTORE, this.$taroPath);
+            }
             // 设置 Current 的 page 和 router
             if (Current.page === this) {
                 Current.page = null;
@@ -3095,6 +4140,11 @@ function createPageConfig(component, pageName, data, pageConfig) {
             eventCenter.trigger(getOnHideEventKey(id));
         }
     };
+    if (process.env.TARO_PLATFORM === 'web') {
+        config.getOpenerEventChannel = () => {
+            return shared.EventChannel.pageChannel;
+        };
+    }
     LIFECYCLES.forEach((lifecycle) => {
         let isDefer = false;
         lifecycle = lifecycle.replace(/^defer:/, () => {
@@ -3154,6 +4204,10 @@ function createComponentConfig(component, componentName, data) {
                 shared.ensure(componentElement !== null, '没有找到组件实例。');
                 this.$taroInstances = instances.get(path);
                 safeExecute(path, ON_LOAD);
+                if (process.env.TARO_PLATFORM !== 'web') {
+                    componentElement.ctx = this;
+                    componentElement.performUpdate(true);
+                }
             });
         },
         [DETACHED]() {
@@ -3248,12 +4302,15 @@ const nextTick = (cb, ctx) => {
         var _a, _b, _c;
         const pageElement = env.document.getElementById(path);
         if (pageElement === null || pageElement === void 0 ? void 0 : pageElement.pendingUpdate) {
-            {
+            if (process.env.TARO_PLATFORM === 'web') {
                 // eslint-disable-next-line dot-notation
                 (_c = (_b = (_a = pageElement.firstChild) === null || _a === void 0 ? void 0 : _a['componentOnReady']) === null || _b === void 0 ? void 0 : _b.call(_a).then(() => {
                     timerFunc();
                 })) !== null && _c !== void 0 ? _c : timerFunc();
             }
+            else {
+                pageElement.enqueueUpdateCallback(cb, ctx);
+            }
         }
         else if (Date.now() - beginTime > TIMEOUT) {
             timerFunc();
@@ -3265,6 +4322,776 @@ const nextTick = (cb, ctx) => {
     next();
 };
 
+function handleArrayFindPolyfill() {
+    if (!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 (!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++;
+                }
+                return undefined;
+            }
+        });
+    }
+}
+function handleArrayIncludesPolyfill() {
+    if (!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;
+            }
+        });
+    }
+}
+
+/* eslint-disable eqeqeq */
+function handleIntersectionObserverPolyfill() {
+    // Exit early if all IntersectionObserver and IntersectionObserverEntry
+    // features are natively supported.
+    if ('IntersectionObserver' in window &&
+        'IntersectionObserverEntry' in window &&
+        'intersectionRatio' in window.IntersectionObserverEntry.prototype) {
+        if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {
+            // Minimal polyfill for Edge 15's lack of `isIntersecting`
+            // See: https://github.com/w3c/IntersectionObserver/issues/211
+            Object.defineProperty(window.IntersectionObserverEntry.prototype, 'isIntersecting', {
+                get: function () {
+                    return this.intersectionRatio > 0;
+                }
+            });
+        }
+    }
+    else {
+        handleIntersectionObserverObjectPolyfill();
+    }
+}
+function handleIntersectionObserverObjectPolyfill() {
+    const document = window.document;
+    /**
+     * 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;
+        // Calculates the intersection ratio.
+        const targetRect = this.boundingClientRect;
+        const targetArea = targetRect.width * targetRect.height;
+        const intersectionRect = this.intersectionRect;
+        const intersectionArea = intersectionRect.width * intersectionRect.height;
+        // Sets intersection ratio.
+        if (targetArea) {
+            // Round the intersection ratio to avoid floating point math issues:
+            // https://github.com/w3c/IntersectionObserver/issues/324
+            this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));
+        }
+        else {
+            // If area is zero and is intersecting, sets to 1, otherwise to 0
+            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 (!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');
+        }
+        // Binds and throttles `this._checkForIntersections`.
+        this._checkForIntersections = throttle(this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);
+        // Private properties.
+        this._callback = callback;
+        this._observationTargets = [];
+        this._queuedEntries = [];
+        this._rootMarginValues = this._parseRootMargin(options.rootMargin);
+        // Public properties.
+        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) {
+        const isTargetAlreadyObserved = this._observationTargets.some(function (item) {
+            return item.element == target;
+        });
+        if (isTargetAlreadyObserved)
+            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 (!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 marginString = opt_rootMargin || '0px';
+        const margins = marginString.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] };
+        });
+        // Handles shorthand.
+        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 a poll interval is set, use polling instead of listening to
+            // resize and scroll events or DOM mutations.
+            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: target,
+                boundingClientRect: targetRect,
+                rootBounds: rootRect,
+                intersectionRect: intersectionRect,
+                intersectionRatio: -1,
+                isIntersecting: false,
+            });
+            if (!oldEntry) {
+                this._queuedEntries.push(newEntry);
+            }
+            else if (rootIsInDom && rootContainsTarget) {
+                // If the new entry intersection ratio has crossed any of the
+                // thresholds, add a new entry.
+                if (this._hasCrossedThreshold(oldEntry, newEntry)) {
+                    this._queuedEntries.push(newEntry);
+                }
+            }
+            else {
+                // If the root is not in the DOM or target is not contained within
+                // root but the previous entry for this target had an intersection,
+                // add a new record indicating removal.
+                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 the element isn't displayed, an intersection can't happen.
+        if (window.getComputedStyle(target).display === 'none')
+            return;
+        const targetRect = getBoundingClientRect(target);
+        let intersectionRect = targetRect;
+        let parent = getParentNode(target);
+        let atRoot = false;
+        while (!atRoot) {
+            let parentRect = null;
+            const parentComputedStyle = parent.nodeType == 1 ?
+                window.getComputedStyle(parent) : {};
+            // If the parent isn't displayed, an intersection can't happen.
+            if (parentComputedStyle.display === 'none')
+                return;
+            if (parent == this.root || parent == document) {
+                atRoot = true;
+                parentRect = rootRect;
+            }
+            else {
+                // If the element has a non-visible overflow, and it's not the <body>
+                // or <html> element, update the intersection rect.
+                // Note: <body> and <html> cannot be clipped to a rect that's not also
+                // the document rect, so no need to compute a new intersection.
+                if (parent != document.body &&
+                    parent != document.documentElement &&
+                    parentComputedStyle.overflow != 'visible') {
+                    parentRect = getBoundingClientRect(parent);
+                }
+            }
+            // If either of the above conditionals set a new parentRect,
+            // calculate new intersection data.
+            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 {
+            // Use <html>/<body> instead of window since scroll bars affect size.
+            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) {
+            // To make comparing easier, an entry that has a ratio of 0
+            // but does not actually intersect is given a value of -1
+            const oldRatio = oldEntry && oldEntry.isIntersecting ? oldEntry.intersectionRatio || 0 : -1;
+            const newRatio = newEntry.isIntersecting ? newEntry.intersectionRatio || 0 : -1;
+            // Ignore unchanged ratios
+            if (oldRatio === newRatio)
+                return;
+            for (let i = 0; i < this.thresholds.length; i++) {
+                const threshold = this.thresholds[i];
+                // Return true if an entry matches a threshold or if the new ratio
+                // and the old ratio are on the opposite sides of a threshold.
+                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 () {
+    };
+    /**
+   * Removes the instance from the global IntersectionObserver registry.
+   * @private
+   */
+    IntersectionObserver.prototype._unregisterInstance = function () {
+    };
+    /**
+     * 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 (shared.isFunction(node.addEventListener)) {
+            node.addEventListener(event, fn, opt_useCapture || false);
+        }
+        else if (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 (shared.isFunction(node.removeEventListener)) {
+            node.removeEventListener(event, fn, opt_useCapture || false);
+        }
+        else if (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: top,
+            bottom: bottom,
+            left: left,
+            right: right,
+            width: width,
+            height: 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) {
+            // Ignore Windows 7 IE11 "Unspecified error"
+            // https://github.com/w3c/IntersectionObserver/pull/205
+        }
+        if (!rect)
+            return getEmptyRect();
+        // Older IE
+        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) {
+            // If the parent is a shadow root, return the host element.
+            return parent.host;
+        }
+        if (parent && parent.assignedSlot) {
+            // If the parent is distributed in a <slot>, return the parent of a slot.
+            return parent.assignedSlot.parentNode;
+        }
+        return parent;
+    }
+    // Exposes the constructors globally.
+    window.IntersectionObserver = IntersectionObserver;
+    window.IntersectionObserverEntry = IntersectionObserverEntry;
+}
+
+function handleObjectAssignPolyfill() {
+    if (!shared.isFunction(Object.assign)) {
+        // Must be writable: true, enumerable: false, configurable: true
+        Object.assign = function (target) {
+            if (target == null) { // TypeError if undefined or 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) { // Skip over if undefined or null
+                    for (const nextKey in nextSource) {
+                        // Avoid bugs when hasOwnProperty is shadowed
+                        if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+                            to[nextKey] = nextSource[nextKey];
+                        }
+                    }
+                }
+            }
+            return to;
+        };
+    }
+}
+function handleObjectEntriesPolyfill() {
+    if (!shared.isFunction(Object.entries)) {
+        // Must be writable: true, enumerable: false, configurable: true
+        Object.entries = function (obj) {
+            if (obj == null) { // TypeError if undefined or null
+                throw new TypeError('Cannot convert undefined or null to object');
+            }
+            const to = [];
+            if (obj != null) { // Skip over if undefined or null
+                for (const key in obj) {
+                    // Avoid bugs when hasOwnProperty is shadowed
+                    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                        to.push([key, obj[key]]);
+                    }
+                }
+            }
+            return to;
+        };
+    }
+}
+function handleObjectDefinePropertyPolyfill() {
+    if (!shared.isFunction(Object.defineProperties)) {
+        Object.defineProperties = function (obj, properties) {
+            function convertToDescriptor(desc) {
+                function hasProperty(obj, prop) {
+                    return Object.prototype.hasOwnProperty.call(obj, prop);
+                }
+                if (!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 (!shared.isFunction(g) && !shared.isUndefined(g)) {
+                        throw new TypeError('bad get');
+                    }
+                    d.get = g;
+                }
+                if (hasProperty(desc, 'set')) {
+                    const s = desc.set;
+                    if (!shared.isFunction(s) && !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 (!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;
+        };
+    }
+}
+
+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();
+    }
+    // Exit early if we're not running in a browser.
+    if (process.env.TARO_PLATFORM === 'web' && 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();
+}
+
 Object.defineProperty(exports, 'Events', {
   enumerable: true,
   get: function () { return shared.Events; }
@@ -3282,6 +5109,7 @@ exports.CATCH_VIEW = CATCH_VIEW;
 exports.CHANGE = CHANGE;
 exports.CLASS = CLASS;
 exports.COMMENT = COMMENT;
+exports.COMPILE_MODE = COMPILE_MODE;
 exports.CONFIRM = CONFIRM;
 exports.CONTAINER = CONTAINER;
 exports.CURRENT_TARGET = CURRENT_TARGET;
@@ -3303,7 +5131,7 @@ exports.ID = ID;
 exports.INPUT = INPUT;
 exports.KEY_CODE = KEY_CODE;
 exports.Location = Location;
-exports.MutationObserver = MutationObserver;
+exports.MutationObserver = MutationObserver$1;
 exports.OBJECT = OBJECT;
 exports.ON_HIDE = ON_HIDE;
 exports.ON_LOAD = ON_LOAD;
@@ -3342,17 +5170,22 @@ exports.createComponentConfig = createComponentConfig;
 exports.createEvent = createEvent;
 exports.createPageConfig = createPageConfig;
 exports.createRecursiveComponentConfig = createRecursiveComponentConfig;
+exports.document = document$1;
 exports.env = env;
 exports.eventCenter = eventCenter;
 exports.eventHandler = eventHandler;
 exports.eventSource = eventSource;
 exports.getComputedStyle = getComputedStyle;
 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 = history;
 exports.hydrate = hydrate;
 exports.incrementId = incrementId;
@@ -3367,3 +5200,8 @@ exports.removePageInstance = removePageInstance;
 exports.requestAnimationFrame = _raf;
 exports.safeExecute = safeExecute;
 exports.stringify = stringify;
+exports.stripBasename = stripBasename;
+exports.stripSuffix = stripSuffix;
+exports.stripTrailing = stripTrailing;
+exports.window = window$1;
+//# sourceMappingURL=index.cjs.js.map