@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/common/deps/ResizeObserver.js

@@ -1,113 +1,110 @@
-import { on, off } from '@opentiny/vue-renderless/common/deps/dom';
-var MapShim = function () {
-  if (typeof Map !== 'undefined') {
+import "../../chunk-PKUHTIDK.js";
+import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
+const MapShim = function() {
+  if (typeof Map !== "undefined") {
     return Map;
   }
-  var getIndex = function getIndex(arr, key) {
-    var result = -1;
-    arr.some(function (entry, index) {
+  const getIndex = (arr, key) => {
+    let result = -1;
+    arr.some((entry, index2) => {
       if (entry[0] === key) {
-        result = index;
+        result = index2;
         return true;
       }
       return false;
     });
     return result;
   };
-  return function () {
+  return function() {
     function obClass() {
       this.__entries__ = [];
     }
-    Object.defineProperty(obClass.prototype, 'size', {
-      get: function get() {
+    Object.defineProperty(obClass.prototype, "size", {
+      get() {
         return this.__entries__.length;
       },
       enumerable: true,
       configurable: true
     });
-    obClass.prototype.get = function (key) {
-      var index = getIndex(this.__entries__, key);
-      var entry = this.__entries__[index];
+    obClass.prototype.get = function(key) {
+      const index2 = getIndex(this.__entries__, key);
+      const entry = this.__entries__[index2];
       return entry && entry[1];
     };
-    obClass.prototype.set = function (key, value) {
-      var index = getIndex(this.__entries__, key);
-      if (~index) {
-        this.__entries__[index][1] = value;
+    obClass.prototype.set = function(key, value) {
+      const index2 = getIndex(this.__entries__, key);
+      if (~index2) {
+        this.__entries__[index2][1] = value;
       } else {
         this.__entries__.push([key, value]);
       }
     };
-    obClass.prototype["delete"] = function (key) {
-      var entries = this.__entries__;
-      var index = getIndex(entries, key);
-      if (~index) {
-        entries.splice(index, 1);
+    obClass.prototype.delete = function(key) {
+      const entries = this.__entries__;
+      const index2 = getIndex(entries, key);
+      if (~index2) {
+        entries.splice(index2, 1);
       }
     };
-    obClass.prototype.clear = function () {
+    obClass.prototype.clear = function() {
       this.__entries__.splice(0);
     };
-    obClass.prototype.has = function (key) {
+    obClass.prototype.has = function(key) {
       return !!~getIndex(this.__entries__, key);
     };
-    obClass.prototype.forEach = function (callback, ctx) {
+    obClass.prototype.forEach = function(callback, ctx) {
       if (ctx === void 0) {
         ctx = null;
       }
-      for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
-        var entry = _a[_i];
+      for (let _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
+        const entry = _a[_i];
         callback.call(ctx, entry[1], entry[0]);
       }
     };
     return obClass;
   }();
 }();
-var func = window.Function;
-var isBrowser = window !== 'undefined' && document !== 'undefined' && window.document === document;
-var global$1 = function () {
-  var isMath = function isMath(val) {
-    return val.Math === Math;
-  };
-  if (typeof global !== 'undefined' && isMath(global)) {
+const func = window.Function;
+const isBrowser = window !== "undefined" && document !== "undefined" && window.document === document;
+const global$1 = function() {
+  const isMath = (val) => val.Math === Math;
+  if (typeof global !== "undefined" && isMath(global)) {
     return global;
   }
-  if (typeof self !== 'undefined' && isMath(self)) {
+  if (typeof self !== "undefined" && isMath(self)) {
     return self;
   }
-  if (typeof window !== 'undefined' && isMath(window)) {
+  if (typeof window !== "undefined" && isMath(window)) {
     return window;
   }
-  return func('return this')();
+  return func("return this")();
 }();
-var requestAnimationFrame$1 = function () {
-  if (typeof requestAnimationFrame === 'function') {
+const requestAnimationFrame$1 = function() {
+  if (typeof requestAnimationFrame === "function") {
     return requestAnimationFrame.bind(global$1);
   }
-  return function (callback) {
-    return setTimeout(function () {
-      return callback(Date.now());
-    }, 1000 / 60);
+  return function(callback) {
+    return setTimeout(() => callback(Date.now()), 1e3 / 60);
   };
 }();
-var trailingTimeout = 2;
+let trailingTimeout = 2;
 function throttle(callback, delayTime) {
-  var leading = false;
-  var trailing = false;
-  var lastCallTime = 0;
-  var proxy;
-  var resolvePending = function resolvePending() {
+  let leading = false;
+  let trailing = false;
+  let lastCallTime = 0;
+  let proxy;
+  const resolvePending = () => {
     if (leading) {
       leading = false;
       callback();
     }
     trailing && proxy();
   };
-  var timeoutCallback = function timeoutCallback() {
+  const timeoutCallback = () => {
     requestAnimationFrame$1(resolvePending);
   };
-  proxy = function proxy() {
-    var timeStamps = Date.now();
+  proxy = () => {
+    const timeStamps = Date.now();
     if (leading) {
       if (timeStamps - lastCallTime < trailingTimeout) {
         return;
@@ -122,11 +119,11 @@ function throttle(callback, delayTime) {
   };
   return proxy;
 }
-var REFRESH_DELAY = 20;
-var transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];
-var mutationObserverSupported = typeof MutationObserver !== 'undefined';
-var ResizeObserverController = function () {
-  function ResizeObserverController() {
+const REFRESH_DELAY = 20;
+const transitionKeys = ["top", "right", "bottom", "left", "width", "height", "size", "weight"];
+const mutationObserverSupported = typeof MutationObserver !== "undefined";
+const ResizeObserverController = function() {
+  function ResizeObserverController2() {
     this.observers_ = [];
     this.connected_ = false;
     this.mutationEventsAdded_ = false;
@@ -134,41 +131,39 @@ var ResizeObserverController = function () {
     this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
     this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
   }
-  ResizeObserverController.prototype.addObserver = function (observer) {
+  ResizeObserverController2.prototype.addObserver = function(observer) {
     !~this.observers_.indexOf(observer) && this.observers_.push(observer);
     !this.connected_ && this.connect_();
   };
-  ResizeObserverController.prototype.removeObserver = function (observer) {
-    var observers = this.observers_;
-    var index = observers.indexOf(observer);
-    ~index && observers.splice(index, 1);
-    if (!observers.length && this.connected_) {
+  ResizeObserverController2.prototype.removeObserver = function(observer) {
+    const observers2 = this.observers_;
+    const index2 = observers2.indexOf(observer);
+    ~index2 && observers2.splice(index2, 1);
+    if (!observers2.length && this.connected_) {
       this.disconnect_();
     }
   };
-  ResizeObserverController.prototype.refresh = function () {
-    var changesDetected = this.updateObservers_();
+  ResizeObserverController2.prototype.refresh = function() {
+    const changesDetected = this.updateObservers_();
     changesDetected && this.refresh();
   };
-  ResizeObserverController.prototype.updateObservers_ = function () {
-    var activeObservers = this.observers_.filter(function (observer) {
+  ResizeObserverController2.prototype.updateObservers_ = function() {
+    const activeObservers = this.observers_.filter((observer) => {
       observer.gatherActive();
       return observer.hasActive();
     });
-    activeObservers.forEach(function (observer) {
-      return observer.broadcastActive();
-    });
+    activeObservers.forEach((observer) => observer.broadcastActive());
     return activeObservers.length > 0;
   };
-  ResizeObserverController.prototype.connect_ = function () {
+  ResizeObserverController2.prototype.connect_ = function() {
     if (!isBrowser || this.connected_) {
       return;
     }
-    on(document, 'transitionend', this.onTransitionEnd_);
-    on(window, 'resize', this.refresh);
+    on(document, "transitionend", this.onTransitionEnd_);
+    on(window, "resize", this.refresh);
     if (mutationObserverSupported) {
       this.mutationsObserver_ = new MutationObserver(this.refresh);
-      var options = {
+      const options = {
         attributes: true,
         childList: true,
         characterData: true,
@@ -176,45 +171,43 @@ var ResizeObserverController = function () {
       };
       this.mutationsObserver_.observe(document, options);
     } else {
-      on(document, 'DOMSubtreeModified', this.refresh);
+      on(document, "DOMSubtreeModified", this.refresh);
       this.mutationEventsAdded_ = true;
     }
     this.connected_ = true;
   };
-  ResizeObserverController.prototype.disconnect_ = function () {
+  ResizeObserverController2.prototype.disconnect_ = function() {
     if (!isBrowser || !this.connected_) {
       return;
     }
-    off(document, 'transitionend', this.onTransitionEnd_);
-    off(window, 'resize', this.refresh);
+    off(document, "transitionend", this.onTransitionEnd_);
+    off(window, "resize", this.refresh);
     this.mutationsObserver_ && this.mutationsObserver_.disconnect();
     if (this.mutationEventsAdded_) {
-      off(document, 'DOMSubtreeModified', this.refresh);
+      off(document, "DOMSubtreeModified", this.refresh);
     }
     this.mutationsObserver_ = null;
     this.mutationEventsAdded_ = false;
     this.connected_ = false;
   };
-  ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {
-    var _b = _a.propertyName;
-    var propertyName = _b === void 0 ? '' : _b;
-    var isReflowProperty = transitionKeys.some(function (key) {
-      return !!~propertyName.indexOf(key);
-    });
+  ResizeObserverController2.prototype.onTransitionEnd_ = function(_a) {
+    const _b = _a.propertyName;
+    const propertyName = _b === void 0 ? "" : _b;
+    const isReflowProperty = transitionKeys.some((key) => !!~propertyName.indexOf(key));
     isReflowProperty && this.refresh();
   };
-  ResizeObserverController.getInstance = function () {
+  ResizeObserverController2.getInstance = function() {
     if (!this._instance) {
-      this._instance = new ResizeObserverController();
+      this._instance = new ResizeObserverController2();
     }
     return this._instance;
   };
-  ResizeObserverController._instance = null;
-  return ResizeObserverController;
+  ResizeObserverController2._instance = null;
+  return ResizeObserverController2;
 }();
-var defineConfigurable = function defineConfigurable(target, props) {
-  for (var i = 0, a = Object.keys(props); i < a.length; i++) {
-    var key = a[i];
+const defineConfigurable = function(target, props) {
+  for (let i = 0, a = Object.keys(props); i < a.length; i++) {
+    const key = a[i];
     Object.defineProperty(target, key, {
       value: props[key],
       configurable: true,
@@ -224,72 +217,65 @@ var defineConfigurable = function defineConfigurable(target, props) {
   }
   return target;
 };
-var createRectInit = function createRectInit(x, y, width, height) {
-  return {
-    x: x,
-    y: y,
-    width: width,
-    height: height
-  };
+const createRectInit = function(x, y, width, height) {
+  return { x, y, width, height };
 };
-var getWindowOf = function getWindowOf(target) {
-  var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
+const getWindowOf = function(target) {
+  const ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
   return ownerGlobal || global$1;
 };
-var emptyRect = createRectInit(0, 0, 0, 0);
-var toFloat = function toFloat(value) {
-  return parseFloat(value) || 0;
-};
-var getBordersSize = function getBordersSize(styles) {
-  var positions = [];
-  for (var i = 1; i < arguments.length; i++) {
+const emptyRect = createRectInit(0, 0, 0, 0);
+const toFloat = (value) => parseFloat(value) || 0;
+const getBordersSize = function(styles) {
+  let positions = [];
+  for (let i = 1; i < arguments.length; i++) {
     positions[i - 1] = arguments[i];
   }
-  return positions.reduce(function (size, position) {
-    var value = styles["border-".concat(position, "-width")];
+  return positions.reduce((size, position) => {
+    const value = styles[`border-${position}-width`];
     return size + toFloat(value);
   }, 0);
 };
-var getPaddings = function getPaddings(styles) {
-  var positions = ['top', 'right', 'bottom', 'left'];
-  var paddings = {};
-  for (var i = 0, pos = positions; i < pos.length; i++) {
-    var position = pos[i];
-    var value = styles["padding-".concat(position)];
+const getPaddings = function(styles) {
+  const positions = ["top", "right", "bottom", "left"];
+  let paddings = {};
+  for (let i = 0, pos = positions; i < pos.length; i++) {
+    const position = pos[i];
+    const value = styles[`padding-${position}`];
     paddings[position] = toFloat(value);
   }
   return paddings;
 };
-var getSVGContentRect = function getSVGContentRect(target) {
-  var bbox = target.getBBox();
+const getSVGContentRect = function(target) {
+  const bbox = target.getBBox();
   return createRectInit(0, 0, bbox.width, bbox.height);
 };
-var isDocumentElement = function isDocumentElement(target) {
+const isDocumentElement = function(target) {
   return target === getWindowOf(target).document.documentElement;
 };
-var getHTMLElementContentRect = function getHTMLElementContentRect(target) {
-  var clientWidth = target.clientWidth;
-  var clientHeight = target.clientHeight;
+const getHTMLElementContentRect = function(target) {
+  const clientWidth = target.clientWidth;
+  const clientHeight = target.clientHeight;
   if (!clientHeight && !clientWidth) {
     return emptyRect;
   }
-  var styles = getWindowOf(target).getComputedStyle(target);
-  var paddings = getPaddings(styles);
-  var vertPad = paddings.top + paddings.bottom;
-  var horizPad = paddings.left + paddings.right;
-  var width = toFloat(styles.width);
-  var height = toFloat(styles.height);
-  if (styles.boxSizing === 'border-box') {
+  const styles = getWindowOf(target).getComputedStyle(target);
+  const paddings = getPaddings(styles);
+  const vertPad = paddings.top + paddings.bottom;
+  const horizPad = paddings.left + paddings.right;
+  let width = toFloat(styles.width);
+  let height = toFloat(styles.height);
+  if (styles.boxSizing === "border-box") {
     if (Math.round(height + vertPad) !== clientHeight) {
-      height -= getBordersSize(styles, 'top', 'bottom') + vertPad;
+      height -= getBordersSize(styles, "top", "bottom") + vertPad;
     }
     if (Math.round(width + horizPad) !== clientWidth) {
-      width -= getBordersSize(styles, 'left', 'right') + horizPad;
+      width -= getBordersSize(styles, "left", "right") + horizPad;
     }
   }
   if (!isDocumentElement(target)) {
-    var horizScrollbar = Math.round(height + vertPad) - clientHeight;
-    var vertScrollbar = Math.round(width + horizPad) - clientWidth;
+    const horizScrollbar = Math.round(height + vertPad) - clientHeight;
+    const vertScrollbar = Math.round(width + horizPad) - clientWidth;
     if (Math.abs(horizScrollbar) !== 1) {
       height -= horizScrollbar;
     }
@@ -299,17 +285,13 @@ var getHTMLElementContentRect = function getHTMLElementContentRect(target) {
   }
   return createRectInit(paddings.left, paddings.top, width, height);
 };
-var isSVGGraphicsElement = function () {
-  if (typeof SVGGraphicsElement !== 'undefined') {
-    return function (target) {
-      return target instanceof getWindowOf(target).SVGGraphicsElement;
-    };
+const isSVGGraphicsElement = function() {
+  if (typeof SVGGraphicsElement !== "undefined") {
+    return (target) => target instanceof getWindowOf(target).SVGGraphicsElement;
   }
-  return function (target) {
-    return target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === 'function';
-  };
+  return (target) => target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === "function";
 }();
-var getContentRect = function getContentRect(target) {
+const getContentRect = function(target) {
   if (!isBrowser) {
     return emptyRect;
   }
@@ -318,18 +300,18 @@ var getContentRect = function getContentRect(target) {
   }
   return getHTMLElementContentRect(target);
 };
-var createReadOnlyRect = function createReadOnlyRect(_a) {
-  var x = _a.x;
-  var y = _a.y;
-  var width = _a.width;
-  var height = _a.height;
-  var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;
-  var rect = Object.create(Constr.prototype);
+const createReadOnlyRect = function(_a) {
+  const x = _a.x;
+  const y = _a.y;
+  const width = _a.width;
+  const height = _a.height;
+  const Constr = typeof DOMRectReadOnly !== "undefined" ? DOMRectReadOnly : Object;
+  const rect = Object.create(Constr.prototype);
   defineConfigurable(rect, {
-    x: x,
-    y: y,
-    width: width,
-    height: height,
+    x,
+    y,
+    width,
+    height,
     top: y,
     right: x + width,
     bottom: height + y,
@@ -337,58 +319,55 @@ var createReadOnlyRect = function createReadOnlyRect(_a) {
   });
   return rect;
 };
-var ResizeObservation = function () {
-  function ResizeObservation(target) {
+const ResizeObservation = function() {
+  function ResizeObservation2(target) {
     this.broadcastWidth = 0;
     this.broadcastHeight = 0;
     this.contentRect_ = createRectInit(0, 0, 0, 0);
     this.target = target;
   }
-  ResizeObservation.prototype.broadcastRect = function () {
-    var rect = this.contentRect_;
+  ResizeObservation2.prototype.broadcastRect = function() {
+    const rect = this.contentRect_;
     this.broadcastWidth = rect.width;
     this.broadcastHeight = rect.height;
     return rect;
   };
-  ResizeObservation.prototype.isActive = function () {
-    var rect = getContentRect(this.target);
+  ResizeObservation2.prototype.isActive = function() {
+    const rect = getContentRect(this.target);
     this.contentRect_ = rect;
     return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;
   };
-  return ResizeObservation;
+  return ResizeObservation2;
 }();
-var ResizeObserverEntry = function () {
-  function ResizeObserverEntry(target, rectInit) {
-    var contentRect = createReadOnlyRect(rectInit);
-    defineConfigurable(this, {
-      target: target,
-      contentRect: contentRect
-    });
+const ResizeObserverEntry = function() {
+  function ResizeObserverEntry2(target, rectInit) {
+    const contentRect = createReadOnlyRect(rectInit);
+    defineConfigurable(this, { target, contentRect });
   }
-  return ResizeObserverEntry;
+  return ResizeObserverEntry2;
 }();
-var ResizeObserverSPI = function () {
-  function ResizeObserverSPI(callback, controller, callbackCtx) {
+const ResizeObserverSPI = function() {
+  function ResizeObserverSPI2(callback, controller, callbackCtx) {
     this.observations_ = new MapShim();
     this.activeObservations_ = [];
-    if (typeof callback !== 'function') {
-      throw new TypeError('[TINY-Resize] The callback provided as parameter 1 is not a function.');
+    if (typeof callback !== "function") {
+      throw new TypeError("[TINY-Resize] The callback provided as parameter 1 is not a function.");
     }
     this.callback_ = callback;
     this.controller_ = controller;
     this.callbackCtx_ = callbackCtx;
   }
-  ResizeObserverSPI.prototype.observe = function (target) {
+  ResizeObserverSPI2.prototype.observe = function(target) {
     if (!arguments.length) {
-      throw new TypeError('[TINY-Resize] 1 argument required, but only 0 present.');
+      throw new TypeError("[TINY-Resize] 1 argument required, but only 0 present.");
     }
-    if (typeof Element === 'undefined' || !(Element instanceof Object)) {
+    if (typeof Element === "undefined" || !(Element instanceof Object)) {
       return;
     }
     if (!(target instanceof getWindowOf(target).Element)) {
       throw new TypeError('[TINY-Resize] parameter 1 is not of type "Element".');
     }
-    var obserVations = this.observations_;
+    const obserVations = this.observations_;
     if (obserVations.has(target)) {
       return;
     }
@@ -396,79 +375,80 @@ var ResizeObserverSPI = function () {
     this.controller_.addObserver(this);
     this.controller_.refresh();
   };
-  ResizeObserverSPI.prototype.unobserve = function (target) {
+  ResizeObserverSPI2.prototype.unobserve = function(target) {
     if (!arguments.length) {
-      throw new TypeError('[TINY-Resize]1 argument required, but only 0 present.');
+      throw new TypeError("[TINY-Resize]1 argument required, but only 0 present.");
     }
-    if (typeof Element === 'undefined' || !(Element instanceof Object)) {
+    if (typeof Element === "undefined" || !(Element instanceof Object)) {
       return;
     }
     if (!(target instanceof getWindowOf(target).Element)) {
       throw new TypeError('[TINY-Resize] parameter 1 is not of type "Element".');
     }
-    var obserVations = this.observations_;
+    const obserVations = this.observations_;
     if (!obserVations.has(target)) {
       return;
     }
-    obserVations["delete"](target);
+    obserVations.delete(target);
     !obserVations.size && this.controller_.removeObserver(this);
   };
-  ResizeObserverSPI.prototype.gatherActive = function () {
-    var me = this;
+  ResizeObserverSPI2.prototype.gatherActive = function() {
+    const me = this;
     this.clearActive();
-    this.observations_.forEach(function (observation) {
+    this.observations_.forEach((observation) => {
       observation.isActive() && me.activeObservations_.push(observation);
     });
   };
-  ResizeObserverSPI.prototype.disconnect = function () {
+  ResizeObserverSPI2.prototype.disconnect = function() {
     this.clearActive();
     this.observations_.clear();
     this.controller_.removeObserver(this);
   };
-  ResizeObserverSPI.prototype.broadcastActive = function () {
+  ResizeObserverSPI2.prototype.broadcastActive = function() {
     if (!this.hasActive()) {
       return;
     }
-    var ctx = this.callbackCtx_;
-    var entries = this.activeObservations_.map(function (observation) {
-      return new ResizeObserverEntry(observation.target, observation.broadcastRect());
-    });
+    const ctx = this.callbackCtx_;
+    const entries = this.activeObservations_.map((observation) => new ResizeObserverEntry(observation.target, observation.broadcastRect()));
     this.callback_.call(ctx, entries, ctx);
     this.clearActive();
   };
-  ResizeObserverSPI.prototype.hasActive = function () {
+  ResizeObserverSPI2.prototype.hasActive = function() {
     return this.activeObservations_.length > 0;
   };
-  ResizeObserverSPI.prototype.clearActive = function () {
+  ResizeObserverSPI2.prototype.clearActive = function() {
     this.activeObservations_.splice(0);
   };
-  return ResizeObserverSPI;
+  return ResizeObserverSPI2;
 }();
-var observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();
-var ResizeObserver = function () {
-  function ResizeObserver(callback) {
-    if (!(this instanceof ResizeObserver)) {
-      throw new TypeError('[TINY-Resize] Cannot call a class as a function.');
+const observers = typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : new MapShim();
+const ResizeObserver = function() {
+  function ResizeObserver2(callback) {
+    if (!(this instanceof ResizeObserver2)) {
+      throw new TypeError("[TINY-Resize] Cannot call a class as a function.");
     }
     if (!arguments.length) {
-      throw new TypeError('[TINY-Resize] 1 argument required, but only 0 present.');
+      throw new TypeError("[TINY-Resize] 1 argument required, but only 0 present.");
     }
-    var controller = ResizeObserverController.getInstance();
-    var observer = new ResizeObserverSPI(callback, controller, this);
+    const controller = ResizeObserverController.getInstance();
+    const observer = new ResizeObserverSPI(callback, controller, this);
     observers.set(this, observer);
   }
-  return ResizeObserver;
+  return ResizeObserver2;
 }();
-['observe', 'unobserve', 'disconnect'].forEach(function (method) {
-  ResizeObserver.prototype[method] = function () {
-    var _a;
+["observe", "unobserve", "disconnect"].forEach((method) => {
+  ResizeObserver.prototype[method] = function() {
+    let _a;
     return (_a = observers.get(this))[method].apply(_a, arguments);
   };
 });
-var index = function () {
-  if (typeof global$1.ResizeObserver !== 'undefined') {
+const index = function() {
+  if (typeof global$1.ResizeObserver !== "undefined") {
     return global$1.ResizeObserver;
   }
   return ResizeObserver;
 }();
-export default index;
+var ResizeObserver_default = index;
+export {
+  ResizeObserver_default as default
+};