@tarojs/api 3.6.22-nightly.0 → 3.6.22-nightly.3

package/dist/taro.js

@@ -1,356 +1,948 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/typeof'), require('@tarojs/runtime'), require('@tarojs/shared'), require('@babel/runtime/helpers/objectSpread2'), require('@babel/runtime/helpers/classCallCheck'), require('@babel/runtime/helpers/createClass'), require('@babel/runtime/helpers/defineProperty')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/typeof', '@tarojs/runtime', '@tarojs/shared', '@babel/runtime/helpers/objectSpread2', '@babel/runtime/helpers/classCallCheck', '@babel/runtime/helpers/createClass', '@babel/runtime/helpers/defineProperty'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Taro = {}, global._typeof, global.runtime, global.shared, global._objectSpread, global._classCallCheck, global._createClass, global._defineProperty));
-})(this, (function (exports, _typeof, runtime, shared, _objectSpread, _classCallCheck, _createClass, _defineProperty) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@tarojs/shared'), require('@tarojs/runtime')) :
+  typeof define === 'function' && define.amd ? define(['@tarojs/shared', '@tarojs/runtime'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Taro = factory(global.shared, global.runtime));
+})(this, (function (shared, runtime) { 'use strict';
 
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-  var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
-  var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
-  var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-  var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-  var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-
-  function isFunction(x) {
-    return typeof x === 'function';
+  function throttle(fn, threshold = 250, scope) {
+      let lastTime = 0;
+      let deferTimer;
+      return function (...args) {
+          const context = scope || this;
+          const now = Date.now();
+          if (now - lastTime > threshold) {
+              fn.apply(this, args);
+              lastTime = now;
+          }
+          else {
+              clearTimeout(deferTimer);
+              deferTimer = setTimeout(() => {
+                  lastTime = now;
+                  fn.apply(context, args);
+              }, threshold);
+          }
+      };
   }
-  function isUndefined(x) {
-    return typeof x === 'undefined';
+
+  /* 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 isObject(x) {
-    return x && _typeof__default["default"](x) === 'object';
+  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;
   }
 
-  var isBadObj = function isBadObj(x) {
-    return !isObject(x);
-  };
-  function throwTypeError(s) {
-    throw new TypeError(s);
+  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;
+          };
+      }
   }
-  if (!isFunction(Object.assign)) {
-    // Must be writable: true, enumerable: false, configurable: true
-    Object.assign = function (target) {
-      // .length of function is 2
-      if (target == null) {
-        // TypeError if undefined or null
-        throwTypeError('Cannot convert undefined or null to object');
-      }
-      var to = Object(target);
-      for (var index = 1; index < arguments.length; index++) {
-        var nextSource = arguments[index];
-        if (nextSource != null) {
-          // Skip over if undefined or null
-          for (var nextKey in nextSource) {
-            // Avoid bugs when hasOwnProperty is shadowed
-            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
-              to[nextKey] = nextSource[nextKey];
-            }
-          }
-        }
+  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;
+          };
       }
-      return to;
-    };
   }
-  if (!isFunction(Object.defineProperties)) {
-    Object.defineProperties = function (obj, properties) {
-      function convertToDescriptor(desc) {
-        function hasProperty(obj, prop) {
-          return Object.prototype.hasOwnProperty.call(obj, prop);
-        }
-        if (isBadObj(desc)) {
-          throwTypeError('bad desc');
-        }
-        var 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')) {
-          var g = desc.get;
-          if (!isFunction(g) && !isUndefined(g)) {
-            throwTypeError('bad get');
-          }
-          d.get = g;
-        }
-        if (hasProperty(desc, 'set')) {
-          var s = desc.set;
-          if (!isFunction(s) && !isUndefined(s)) {
-            throwTypeError('bad set');
+
+  if (process.env.SUPPORT_TARO_POLYFILL !== 'disabled') {
+      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.defineProperty') {
+          handleObjectDefinePropertyPolyfill();
+      }
+      // 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();
           }
-          d.set = s;
-        }
-        if (('get' in d || 'set' in d) && ('value' in d || 'writable' in d)) {
-          throwTypeError('identity-confused descriptor');
-        }
-        return d;
-      }
-      if (isBadObj(obj)) throwTypeError('bad obj');
-      properties = Object(properties);
-      var keys = Object.keys(properties);
-      var descs = [];
-      for (var i = 0; i < keys.length; i++) {
-        descs.push([keys[i], convertToDescriptor(properties[keys[i]])]);
-      }
-      for (var _i = 0; _i < descs.length; _i++) {
-        Object.defineProperty(obj, descs[_i][0], descs[_i][1]);
-      }
-      return obj;
-    };
+      }
   }
 
-  var ENV_TYPE = {
-    WEAPP: 'WEAPP',
-    SWAN: 'SWAN',
-    ALIPAY: 'ALIPAY',
-    TT: 'TT',
-    QQ: 'QQ',
-    JD: 'JD',
-    WEB: 'WEB',
-    RN: 'RN',
-    HARMONY: 'HARMONY',
-    QUICKAPP: 'QUICKAPP'
+  const ENV_TYPE = {
+      WEAPP: 'WEAPP',
+      SWAN: 'SWAN',
+      ALIPAY: 'ALIPAY',
+      TT: 'TT',
+      QQ: 'QQ',
+      JD: 'JD',
+      WEB: 'WEB',
+      RN: 'RN',
+      HARMONY: 'HARMONY',
+      QUICKAPP: 'QUICKAPP'
   };
-  var isWeb = shared.isWebPlatform();
   function getEnv() {
-    if (process.env.TARO_ENV === 'weapp') {
-      return ENV_TYPE.WEAPP;
-    } else if (process.env.TARO_ENV === 'alipay') {
-      return ENV_TYPE.ALIPAY;
-    } else if (process.env.TARO_ENV === 'swan') {
-      return ENV_TYPE.SWAN;
-    } else if (process.env.TARO_ENV === 'tt') {
-      return ENV_TYPE.TT;
-    } else if (process.env.TARO_ENV === 'jd') {
-      return ENV_TYPE.JD;
-    } else if (process.env.TARO_ENV === 'qq') {
-      return ENV_TYPE.QQ;
-    } else if (isWeb) {
-      return ENV_TYPE.WEB;
-    } else if (process.env.TARO_ENV === 'rn') {
-      return ENV_TYPE.RN;
-    } else if (process.env.TARO_ENV === 'harmony') {
-      return ENV_TYPE.HARMONY;
-    } else if (process.env.TARO_ENV === 'quickapp') {
-      return ENV_TYPE.QUICKAPP;
-    } else {
-      return process.env.TARO_ENV || 'Unknown';
-    }
+      if (process.env.TARO_ENV === 'weapp') {
+          return ENV_TYPE.WEAPP;
+      }
+      else if (process.env.TARO_ENV === 'alipay') {
+          return ENV_TYPE.ALIPAY;
+      }
+      else if (process.env.TARO_ENV === 'swan') {
+          return ENV_TYPE.SWAN;
+      }
+      else if (process.env.TARO_ENV === 'tt') {
+          return ENV_TYPE.TT;
+      }
+      else if (process.env.TARO_ENV === 'jd') {
+          return ENV_TYPE.JD;
+      }
+      else if (process.env.TARO_ENV === 'qq') {
+          return ENV_TYPE.QQ;
+      }
+      else if (process.env.TARO_ENV === 'h5' || process.env.TARO_PLATFORM === 'web') {
+          return ENV_TYPE.WEB;
+      }
+      else if (process.env.TARO_ENV === 'rn') {
+          return ENV_TYPE.RN;
+      }
+      else if (process.env.TARO_ENV === 'harmony' || process.env.TARO_PLATFORM === 'harmony') {
+          return ENV_TYPE.HARMONY;
+      }
+      else if (process.env.TARO_ENV === 'quickapp') {
+          return ENV_TYPE.QUICKAPP;
+      }
+      else {
+          return process.env.TARO_ENV || 'Unknown';
+      }
   }
 
-  var Chain = /*#__PURE__*/function () {
-    function Chain(requestParams, interceptors, index) {
-      _classCallCheck__default["default"](this, Chain);
-      this.index = index || 0;
-      this.requestParams = requestParams;
-      this.interceptors = interceptors || [];
-    }
-    _createClass__default["default"](Chain, [{
-      key: "proceed",
-      value: function proceed(requestParams) {
-        this.requestParams = requestParams;
-        if (this.index >= this.interceptors.length) {
-          throw new Error('chain 参数错误, 请勿直接修改 request.chain');
-        }
-        var nextInterceptor = this._getNextInterceptor();
-        var nextChain = this._getNextChain();
-        var p = nextInterceptor(nextChain);
-        var res = p.catch(function (err) {
-          return Promise.reject(err);
-        });
-        Object.keys(p).forEach(function (k) {
-          return isFunction(p[k]) && (res[k] = p[k]);
-        });
-        return res;
-      }
-    }, {
-      key: "_getNextInterceptor",
-      value: function _getNextInterceptor() {
-        return this.interceptors[this.index];
-      }
-    }, {
-      key: "_getNextChain",
-      value: function _getNextChain() {
-        return new Chain(this.requestParams, this.interceptors, this.index + 1);
-      }
-    }]);
-    return Chain;
-  }();
+  class Chain {
+      constructor(requestParams, interceptors, index) {
+          this.index = index || 0;
+          this.requestParams = requestParams || {};
+          this.interceptors = interceptors || [];
+      }
+      proceed(requestParams = {}) {
+          this.requestParams = requestParams;
+          if (this.index >= this.interceptors.length) {
+              throw new Error('chain 参数错误, 请勿直接修改 request.chain');
+          }
+          const nextInterceptor = this._getNextInterceptor();
+          const nextChain = this._getNextChain();
+          const p = nextInterceptor(nextChain);
+          const res = p.catch(err => Promise.reject(err));
+          Object.keys(p).forEach(k => shared.isFunction(p[k]) && (res[k] = p[k]));
+          return res;
+      }
+      _getNextInterceptor() {
+          return this.interceptors[this.index];
+      }
+      _getNextChain() {
+          return new Chain(this.requestParams, this.interceptors, this.index + 1);
+      }
+  }
 
-  var Link = /*#__PURE__*/function () {
-    function Link(interceptor) {
-      _classCallCheck__default["default"](this, Link);
-      this.taroInterceptor = interceptor;
-      this.chain = new Chain();
-    }
-    _createClass__default["default"](Link, [{
-      key: "request",
-      value: function request(requestParams) {
-        var chain = this.chain;
-        var taroInterceptor = this.taroInterceptor;
-        chain.interceptors = chain.interceptors.filter(function (interceptor) {
-          return interceptor !== taroInterceptor;
-        }).concat(taroInterceptor);
-        return chain.proceed(_objectSpread__default["default"]({}, requestParams));
-      }
-    }, {
-      key: "addInterceptor",
-      value: function addInterceptor(interceptor) {
-        this.chain.interceptors.push(interceptor);
-      }
-    }, {
-      key: "cleanInterceptors",
-      value: function cleanInterceptors() {
-        this.chain = new Chain();
-      }
-    }]);
-    return Link;
-  }();
+  class Link {
+      constructor(interceptor) {
+          this.taroInterceptor = interceptor;
+          this.chain = new Chain();
+      }
+      request(requestParams) {
+          const chain = this.chain;
+          const taroInterceptor = this.taroInterceptor;
+          chain.interceptors = chain.interceptors
+              .filter(interceptor => interceptor !== taroInterceptor)
+              .concat(taroInterceptor);
+          return chain.proceed(Object.assign({}, requestParams));
+      }
+      addInterceptor(interceptor) {
+          this.chain.interceptors.push(interceptor);
+      }
+      cleanInterceptors() {
+          this.chain = new Chain();
+      }
+  }
   function interceptorify(promiseifyApi) {
-    return new Link(function (chain) {
-      return promiseifyApi(chain.requestParams);
-    });
+      return new Link(function (chain) {
+          return promiseifyApi(chain.requestParams);
+      });
   }
 
   function timeoutInterceptor(chain) {
-    var requestParams = chain.requestParams;
-    var p;
-    var res = new Promise(function (resolve, reject) {
-      var timeout = setTimeout(function () {
-        timeout = null;
-        reject(new Error('网络链接超时,请稍后再试！'));
-      }, requestParams && requestParams.timeout || 60000);
-      p = chain.proceed(requestParams);
-      p.then(function (res) {
-        if (!timeout) return;
-        clearTimeout(timeout);
-        resolve(res);
-      }).catch(function (err) {
-        timeout && clearTimeout(timeout);
-        reject(err);
+      const requestParams = chain.requestParams;
+      let p;
+      const res = new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+              clearTimeout(timeout);
+              reject(new Error('网络链接超时,请稍后再试！'));
+          }, (requestParams && requestParams.timeout) || 60000);
+          p = chain.proceed(requestParams);
+          p
+              .then(res => {
+              if (!timeout)
+                  return;
+              clearTimeout(timeout);
+              resolve(res);
+          })
+              .catch(err => {
+              timeout && clearTimeout(timeout);
+              reject(err);
+          });
       });
-    });
-    if (!isUndefined(p) && isFunction(p.abort)) res.abort = p.abort;
-    return res;
+      // @ts-ignore
+      if (!shared.isUndefined(p) && shared.isFunction(p.abort))
+          res.abort = p.abort;
+      return res;
   }
   function logInterceptor(chain) {
-    var requestParams = chain.requestParams;
-    var method = requestParams.method,
-      data = requestParams.data,
-      url = requestParams.url;
-
-    // eslint-disable-next-line no-console
-    console.log("http ".concat(method || 'GET', " --> ").concat(url, " data: "), data);
-    var p = chain.proceed(requestParams);
-    var res = p.then(function (res) {
+      const requestParams = chain.requestParams;
+      const { method, data, url } = requestParams;
       // eslint-disable-next-line no-console
-      console.log("http <-- ".concat(url, " result:"), res);
+      console.log(`http ${method || 'GET'} --> ${url} data: `, data);
+      const p = chain.proceed(requestParams);
+      const res = p
+          .then(res => {
+          // eslint-disable-next-line no-console
+          console.log(`http <-- ${url} result:`, res);
+          return res;
+      });
+      // @ts-ignore
+      if (shared.isFunction(p.abort))
+          res.abort = p.abort;
       return res;
-    });
-    if (isFunction(p.abort)) res.abort = p.abort;
-    return res;
   }
 
   var interceptors = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    timeoutInterceptor: timeoutInterceptor,
-    logInterceptor: logInterceptor
+    logInterceptor: logInterceptor,
+    timeoutInterceptor: timeoutInterceptor
   });
 
   function Behavior(options) {
-    return options;
+      return options;
   }
   function getPreload(current) {
-    return function (key, val) {
-      current.preloadData = isObject(key) ? key : _defineProperty__default["default"]({}, key, val);
-    };
+      return function (key, val) {
+          current.preloadData = shared.isObject(key)
+              ? key
+              : {
+                  [key]: val
+              };
+      };
   }
-  var defaultDesignWidth = 750;
-  var defaultDesignRatio = {
-    640: 2.34 / 2,
-    750: 1,
-    828: 1.81 / 2
+  const defaultDesignWidth = 750;
+  const defaultDesignRatio = {
+      640: 2.34 / 2,
+      750: 1,
+      828: 1.81 / 2
   };
-  var defaultBaseFontSize = 20;
-  var defaultUnitPrecision = 5;
-  var defaultTargetUnit = 'rpx';
+  const defaultBaseFontSize = 20;
+  const defaultUnitPrecision = 5;
+  const defaultTargetUnit = 'rpx';
   function getInitPxTransform(taro) {
-    return function (config) {
-      var _config$designWidth = config.designWidth,
-        designWidth = _config$designWidth === void 0 ? defaultDesignWidth : _config$designWidth,
-        _config$deviceRatio = config.deviceRatio,
-        deviceRatio = _config$deviceRatio === void 0 ? defaultDesignRatio : _config$deviceRatio,
-        _config$baseFontSize = config.baseFontSize,
-        baseFontSize = _config$baseFontSize === void 0 ? defaultBaseFontSize : _config$baseFontSize,
-        _config$targetUnit = config.targetUnit,
-        targetUnit = _config$targetUnit === void 0 ? defaultTargetUnit : _config$targetUnit,
-        _config$unitPrecision = config.unitPrecision,
-        unitPrecision = _config$unitPrecision === void 0 ? defaultUnitPrecision : _config$unitPrecision;
-      taro.config = taro.config || {};
-      taro.config.designWidth = designWidth;
-      taro.config.deviceRatio = deviceRatio;
-      taro.config.baseFontSize = baseFontSize;
-      taro.config.targetUnit = targetUnit;
-      taro.config.unitPrecision = unitPrecision;
-    };
+      return function (config) {
+          const { designWidth = defaultDesignWidth, deviceRatio = defaultDesignRatio, baseFontSize = defaultBaseFontSize, targetUnit = defaultTargetUnit, unitPrecision = defaultUnitPrecision, } = config;
+          taro.config = taro.config || {};
+          taro.config.designWidth = designWidth;
+          taro.config.deviceRatio = deviceRatio;
+          taro.config.baseFontSize = baseFontSize;
+          taro.config.targetUnit = targetUnit;
+          taro.config.unitPrecision = unitPrecision;
+      };
   }
   function getPxTransform(taro) {
-    return function (size) {
-      var config = taro.config || {};
-      var baseFontSize = config.baseFontSize;
-      var deviceRatio = config.deviceRatio || defaultDesignRatio;
-      var designWidth = function () {
-        var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-        return isFunction(config.designWidth) ? config.designWidth(input) : config.designWidth || defaultDesignWidth;
-      }(size);
-      if (!(designWidth in deviceRatio)) {
-        throw new Error("deviceRatio \u914D\u7F6E\u4E2D\u4E0D\u5B58\u5728 ".concat(designWidth, " \u7684\u8BBE\u7F6E\uFF01"));
-      }
-      var targetUnit = config.targetUnit || defaultTargetUnit;
-      var unitPrecision = config.unitPrecision || defaultUnitPrecision;
-      var formatSize = ~~size;
-      var rootValue = 1 / deviceRatio[designWidth];
-      switch (targetUnit) {
-        case 'rem':
-          rootValue *= baseFontSize * 2;
-          break;
-        case 'px':
-          rootValue *= 2;
-          break;
-      }
-      var val = formatSize / rootValue;
-      if (unitPrecision >= 0 && unitPrecision <= 100) {
-        val = Number(val.toFixed(unitPrecision));
-      }
-      return val + targetUnit;
-    };
+      return function (size) {
+          const config = taro.config || {};
+          const baseFontSize = config.baseFontSize;
+          const deviceRatio = config.deviceRatio || defaultDesignRatio;
+          const designWidth = (((input = 0) => shared.isFunction(config.designWidth)
+              ? config.designWidth(input)
+              : config.designWidth || defaultDesignWidth))(size);
+          if (!(designWidth in deviceRatio)) {
+              throw new Error(`deviceRatio 配置中不存在 ${designWidth} 的设置！`);
+          }
+          const targetUnit = config.targetUnit || defaultTargetUnit;
+          const unitPrecision = config.unitPrecision || defaultUnitPrecision;
+          const formatSize = ~~size;
+          let rootValue = 1 / deviceRatio[designWidth];
+          switch (targetUnit) {
+              case 'rem':
+                  rootValue *= baseFontSize * 2;
+                  break;
+              case 'px':
+                  rootValue *= 2;
+                  break;
+          }
+          let val = formatSize / rootValue;
+          if (unitPrecision >= 0 && unitPrecision <= 100) {
+              val = Number(val.toFixed(unitPrecision));
+          }
+          return val + targetUnit;
+      };
   }
 
   /* eslint-disable camelcase */
-  var Taro = {
-    Behavior: Behavior,
-    getEnv: getEnv,
-    ENV_TYPE: ENV_TYPE,
-    Link: Link,
-    interceptors: interceptors,
-    Current: runtime.Current,
-    getCurrentInstance: runtime.getCurrentInstance,
-    options: runtime.options,
-    nextTick: runtime.nextTick,
-    eventCenter: runtime.eventCenter,
-    Events: runtime.Events,
-    getInitPxTransform: getInitPxTransform,
-    interceptorify: interceptorify
+  const Taro = {
+      Behavior,
+      getEnv,
+      ENV_TYPE,
+      Link,
+      interceptors,
+      Current: runtime.Current,
+      getCurrentInstance: runtime.getCurrentInstance,
+      options: runtime.options,
+      nextTick: runtime.nextTick,
+      eventCenter: runtime.eventCenter,
+      Events: runtime.Events,
+      getInitPxTransform,
+      interceptorify
   };
   Taro.initPxTransform = getInitPxTransform(Taro);
   Taro.preload = getPreload(runtime.Current);
   Taro.pxTransform = getPxTransform(Taro);
 
-  exports["default"] = Taro;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
+  return Taro;
 
 }));
-//# sourceMappingURL=taro.js.map