first commit

node_modules/resize-observer-polyfill/src/ResizeObservation.js

@@ -0,0 +1,76 @@
+import {createRectInit, getContentRect} from './utils/geometry.js';
+
+/**
+ * Class that is responsible for computations of the content rectangle of
+ * provided DOM element and for keeping track of it's changes.
+ */
+export default class ResizeObservation {
+    /**
+     * Reference to the observed element.
+     *
+     * @type {Element}
+     */
+    target;
+
+    /**
+     * Broadcasted width of content rectangle.
+     *
+     * @type {number}
+     */
+    broadcastWidth = 0;
+
+    /**
+     * Broadcasted height of content rectangle.
+     *
+     * @type {number}
+     */
+    broadcastHeight = 0;
+
+    /**
+     * Reference to the last observed content rectangle.
+     *
+     * @private {DOMRectInit}
+     */
+    contentRect_ = createRectInit(0, 0, 0, 0);
+
+    /**
+     * Creates an instance of ResizeObservation.
+     *
+     * @param {Element} target - Element to be observed.
+     */
+    constructor(target) {
+        this.target = target;
+    }
+
+    /**
+     * Updates content rectangle and tells whether it's width or height properties
+     * have changed since the last broadcast.
+     *
+     * @returns {boolean}
+     */
+    isActive() {
+        const rect = getContentRect(this.target);
+
+        this.contentRect_ = rect;
+
+        return (
+            rect.width !== this.broadcastWidth ||
+            rect.height !== this.broadcastHeight
+        );
+    }
+
+    /**
+     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data
+     * from the corresponding properties of the last observed content rectangle.
+     *
+     * @returns {DOMRectInit} Last observed content rectangle.
+     */
+    broadcastRect() {
+        const rect = this.contentRect_;
+
+        this.broadcastWidth = rect.width;
+        this.broadcastHeight = rect.height;
+
+        return rect;
+    }
+}

node_modules/resize-observer-polyfill/src/ResizeObserver.js

@@ -0,0 +1,47 @@
+import {Map} from './shims/es6-collections.js';
+import ResizeObserverController from './ResizeObserverController.js';
+import ResizeObserverSPI from './ResizeObserverSPI.js';
+
+// Registry of internal observers. If WeakMap is not available use current shim
+// for the Map collection as it has all required methods and because WeakMap
+// can't be fully polyfilled anyway.
+const observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new Map();
+
+/**
+ * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation
+ * exposing only those methods and properties that are defined in the spec.
+ */
+class ResizeObserver {
+    /**
+     * Creates a new instance of ResizeObserver.
+     *
+     * @param {ResizeObserverCallback} callback - Callback that is invoked when
+     *      dimensions of the observed elements change.
+     */
+    constructor(callback) {
+        if (!(this instanceof ResizeObserver)) {
+            throw new TypeError('Cannot call a class as a function.');
+        }
+        if (!arguments.length) {
+            throw new TypeError('1 argument required, but only 0 present.');
+        }
+
+        const controller = ResizeObserverController.getInstance();
+        const observer = new ResizeObserverSPI(callback, controller, this);
+
+        observers.set(this, observer);
+    }
+}
+
+// Expose public methods of ResizeObserver.
+[
+    'observe',
+    'unobserve',
+    'disconnect'
+].forEach(method => {
+    ResizeObserver.prototype[method] = function () {
+        return observers.get(this)[method](...arguments);
+    };
+});
+
+export default ResizeObserver;

node_modules/resize-observer-polyfill/src/ResizeObserverController.js

@@ -0,0 +1,238 @@
+import isBrowser from './utils/isBrowser.js';
+import throttle from './utils/throttle.js';
+
+// Minimum delay before invoking the update of observers.
+const REFRESH_DELAY = 20;
+
+// A list of substrings of CSS properties used to find transition events that
+// might affect dimensions of observed elements.
+const transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];
+
+// Check if MutationObserver is available.
+const mutationObserverSupported = typeof MutationObserver !== 'undefined';
+
+/**
+ * Singleton controller class which handles updates of ResizeObserver instances.
+ */
+export default class ResizeObserverController {
+    /**
+     * Indicates whether DOM listeners have been added.
+     *
+     * @private {boolean}
+     */
+    connected_ = false;
+
+    /**
+     * Tells that controller has subscribed for Mutation Events.
+     *
+     * @private {boolean}
+     */
+    mutationEventsAdded_ = false;
+
+    /**
+     * Keeps reference to the instance of MutationObserver.
+     *
+     * @private {MutationObserver}
+     */
+    mutationsObserver_ = null;
+
+    /**
+     * A list of connected observers.
+     *
+     * @private {Array<ResizeObserverSPI>}
+     */
+    observers_ = [];
+
+    /**
+     * Holds reference to the controller's instance.
+     *
+     * @private {ResizeObserverController}
+     */
+    static instance_ = null;
+
+    /**
+     * Creates a new instance of ResizeObserverController.
+     *
+     * @private
+     */
+    constructor() {
+        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
+        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
+    }
+
+    /**
+     * Adds observer to observers list.
+     *
+     * @param {ResizeObserverSPI} observer - Observer to be added.
+     * @returns {void}
+     */
+    addObserver(observer) {
+        if (!~this.observers_.indexOf(observer)) {
+            this.observers_.push(observer);
+        }
+
+        // Add listeners if they haven't been added yet.
+        if (!this.connected_) {
+            this.connect_();
+        }
+    }
+
+    /**
+     * Removes observer from observers list.
+     *
+     * @param {ResizeObserverSPI} observer - Observer to be removed.
+     * @returns {void}
+     */
+    removeObserver(observer) {
+        const observers = this.observers_;
+        const index = observers.indexOf(observer);
+
+        // Remove observer if it's present in registry.
+        if (~index) {
+            observers.splice(index, 1);
+        }
+
+        // Remove listeners if controller has no connected observers.
+        if (!observers.length && this.connected_) {
+            this.disconnect_();
+        }
+    }
+
+    /**
+     * Invokes the update of observers. It will continue running updates insofar
+     * it detects changes.
+     *
+     * @returns {void}
+     */
+    refresh() {
+        const changesDetected = this.updateObservers_();
+
+        // Continue running updates if changes have been detected as there might
+        // be future ones caused by CSS transitions.
+        if (changesDetected) {
+            this.refresh();
+        }
+    }
+
+    /**
+     * Updates every observer from observers list and notifies them of queued
+     * entries.
+     *
+     * @private
+     * @returns {boolean} Returns "true" if any observer has detected changes in
+     *      dimensions of it's elements.
+     */
+    updateObservers_() {
+        // Collect observers that have active observations.
+        const activeObservers = this.observers_.filter(observer => {
+            return observer.gatherActive(), observer.hasActive();
+        });
+
+        // Deliver notifications in a separate cycle in order to avoid any
+        // collisions between observers, e.g. when multiple instances of
+        // ResizeObserver are tracking the same element and the callback of one
+        // of them changes content dimensions of the observed target. Sometimes
+        // this may result in notifications being blocked for the rest of observers.
+        activeObservers.forEach(observer => observer.broadcastActive());
+
+        return activeObservers.length > 0;
+    }
+
+    /**
+     * Initializes DOM listeners.
+     *
+     * @private
+     * @returns {void}
+     */
+    connect_() {
+        // Do nothing if running in a non-browser environment or if listeners
+        // have been already added.
+        if (!isBrowser || this.connected_) {
+            return;
+        }
+
+        // Subscription to the "Transitionend" event is used as a workaround for
+        // delayed transitions. This way it's possible to capture at least the
+        // final state of an element.
+        document.addEventListener('transitionend', this.onTransitionEnd_);
+
+        window.addEventListener('resize', this.refresh);
+
+        if (mutationObserverSupported) {
+            this.mutationsObserver_ = new MutationObserver(this.refresh);
+
+            this.mutationsObserver_.observe(document, {
+                attributes: true,
+                childList: true,
+                characterData: true,
+                subtree: true
+            });
+        } else {
+            document.addEventListener('DOMSubtreeModified', this.refresh);
+
+            this.mutationEventsAdded_ = true;
+        }
+
+        this.connected_ = true;
+    }
+
+    /**
+     * Removes DOM listeners.
+     *
+     * @private
+     * @returns {void}
+     */
+    disconnect_() {
+        // Do nothing if running in a non-browser environment or if listeners
+        // have been already removed.
+        if (!isBrowser || !this.connected_) {
+            return;
+        }
+
+        document.removeEventListener('transitionend', this.onTransitionEnd_);
+        window.removeEventListener('resize', this.refresh);
+
+        if (this.mutationsObserver_) {
+            this.mutationsObserver_.disconnect();
+        }
+
+        if (this.mutationEventsAdded_) {
+            document.removeEventListener('DOMSubtreeModified', this.refresh);
+        }
+
+        this.mutationsObserver_ = null;
+        this.mutationEventsAdded_ = false;
+        this.connected_ = false;
+    }
+
+    /**
+     * "Transitionend" event handler.
+     *
+     * @private
+     * @param {TransitionEvent} event
+     * @returns {void}
+     */
+    onTransitionEnd_({propertyName = ''}) {
+        // Detect whether transition may affect dimensions of an element.
+        const isReflowProperty = transitionKeys.some(key => {
+            return !!~propertyName.indexOf(key);
+        });
+
+        if (isReflowProperty) {
+            this.refresh();
+        }
+    }
+
+    /**
+     * Returns instance of the ResizeObserverController.
+     *
+     * @returns {ResizeObserverController}
+     */
+    static getInstance() {
+        if (!this.instance_) {
+            this.instance_ = new ResizeObserverController();
+        }
+
+        return this.instance_;
+    }
+}

node_modules/resize-observer-polyfill/src/ResizeObserverEntry.js

@@ -0,0 +1,40 @@
+import {createReadOnlyRect} from './utils/geometry.js';
+import defineConfigurable from './utils/defineConfigurable.js';
+
+export default class ResizeObserverEntry {
+    /**
+     * Element size of which has changed.
+     * Spec: https://wicg.github.io/ResizeObserver/#dom-resizeobserverentry-target
+     *
+     * @readonly
+     * @type {Element}
+     */
+    target;
+
+    /**
+     * Element's content rectangle.
+     * Spec: https://wicg.github.io/ResizeObserver/#dom-resizeobserverentry-contentrect
+     *
+     * @readonly
+     * @type {DOMRectReadOnly}
+     */
+    contentRect;
+
+    /**
+     * Creates an instance of ResizeObserverEntry.
+     *
+     * @param {Element} target - Element that is being observed.
+     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.
+     */
+    constructor(target, rectInit) {
+        const contentRect = createReadOnlyRect(rectInit);
+
+        // According to the specification following properties are not writable
+        // and are also not enumerable in the native implementation.
+        //
+        // Property accessors are not being used as they'd require to define a
+        // private WeakMap storage which may cause memory leaks in browsers that
+        // don't support this type of collections.
+        defineConfigurable(this, {target, contentRect});
+    }
+}

node_modules/resize-observer-polyfill/src/ResizeObserverSPI.js

@@ -0,0 +1,203 @@
+import {Map} from './shims/es6-collections.js';
+import ResizeObservation from './ResizeObservation.js';
+import ResizeObserverEntry from './ResizeObserverEntry.js';
+import getWindowOf from './utils/getWindowOf.js';
+
+export default class ResizeObserverSPI {
+    /**
+     * Collection of resize observations that have detected changes in dimensions
+     * of elements.
+     *
+     * @private {Array<ResizeObservation>}
+     */
+    activeObservations_ = [];
+
+    /**
+     * Reference to the callback function.
+     *
+     * @private {ResizeObserverCallback}
+     */
+    callback_;
+
+    /**
+     * Public ResizeObserver instance which will be passed to the callback
+     * function and used as a value of it's "this" binding.
+     *
+     * @private {ResizeObserver}
+     */
+    callbackCtx_;
+
+    /**
+     * Reference to the associated ResizeObserverController.
+     *
+     * @private {ResizeObserverController}
+     */
+    controller_;
+
+    /**
+     * Registry of the ResizeObservation instances.
+     *
+     * @private {Map<Element, ResizeObservation>}
+     */
+    observations_ = new Map();
+
+    /**
+     * Creates a new instance of ResizeObserver.
+     *
+     * @param {ResizeObserverCallback} callback - Callback function that is invoked
+     *      when one of the observed elements changes it's content dimensions.
+     * @param {ResizeObserverController} controller - Controller instance which
+     *      is responsible for the updates of observer.
+     * @param {ResizeObserver} callbackCtx - Reference to the public
+     *      ResizeObserver instance which will be passed to callback function.
+     */
+    constructor(callback, controller, callbackCtx) {
+        if (typeof callback !== 'function') {
+            throw new TypeError('The callback provided as parameter 1 is not a function.');
+        }
+
+        this.callback_ = callback;
+        this.controller_ = controller;
+        this.callbackCtx_ = callbackCtx;
+    }
+
+    /**
+     * Starts observing provided element.
+     *
+     * @param {Element} target - Element to be observed.
+     * @returns {void}
+     */
+    observe(target) {
+        if (!arguments.length) {
+            throw new TypeError('1 argument required, but only 0 present.');
+        }
+
+        // Do nothing if current environment doesn't have the Element interface.
+        if (typeof Element === 'undefined' || !(Element instanceof Object)) {
+            return;
+        }
+
+        if (!(target instanceof getWindowOf(target).Element)) {
+            throw new TypeError('parameter 1 is not of type "Element".');
+        }
+
+        const observations = this.observations_;
+
+        // Do nothing if element is already being observed.
+        if (observations.has(target)) {
+            return;
+        }
+
+        observations.set(target, new ResizeObservation(target));
+
+        this.controller_.addObserver(this);
+
+        // Force the update of observations.
+        this.controller_.refresh();
+    }
+
+    /**
+     * Stops observing provided element.
+     *
+     * @param {Element} target - Element to stop observing.
+     * @returns {void}
+     */
+    unobserve(target) {
+        if (!arguments.length) {
+            throw new TypeError('1 argument required, but only 0 present.');
+        }
+
+        // Do nothing if current environment doesn't have the Element interface.
+        if (typeof Element === 'undefined' || !(Element instanceof Object)) {
+            return;
+        }
+
+        if (!(target instanceof getWindowOf(target).Element)) {
+            throw new TypeError('parameter 1 is not of type "Element".');
+        }
+
+        const observations = this.observations_;
+
+        // Do nothing if element is not being observed.
+        if (!observations.has(target)) {
+            return;
+        }
+
+        observations.delete(target);
+
+        if (!observations.size) {
+            this.controller_.removeObserver(this);
+        }
+    }
+
+    /**
+     * Stops observing all elements.
+     *
+     * @returns {void}
+     */
+    disconnect() {
+        this.clearActive();
+        this.observations_.clear();
+        this.controller_.removeObserver(this);
+    }
+
+    /**
+     * Collects observation instances the associated element of which has changed
+     * it's content rectangle.
+     *
+     * @returns {void}
+     */
+    gatherActive() {
+        this.clearActive();
+
+        this.observations_.forEach(observation => {
+            if (observation.isActive()) {
+                this.activeObservations_.push(observation);
+            }
+        });
+    }
+
+    /**
+     * Invokes initial callback function with a list of ResizeObserverEntry
+     * instances collected from active resize observations.
+     *
+     * @returns {void}
+     */
+    broadcastActive() {
+        // Do nothing if observer doesn't have active observations.
+        if (!this.hasActive()) {
+            return;
+        }
+
+        const ctx = this.callbackCtx_;
+
+        // Create ResizeObserverEntry instance for every active observation.
+        const entries = this.activeObservations_.map(observation => {
+            return new ResizeObserverEntry(
+                observation.target,
+                observation.broadcastRect()
+            );
+        });
+
+        this.callback_.call(ctx, entries, ctx);
+        this.clearActive();
+    }
+
+    /**
+     * Clears the collection of active observations.
+     *
+     * @returns {void}
+     */
+    clearActive() {
+        this.activeObservations_.splice(0);
+    }
+
+    /**
+     * Tells whether observer has active observations.
+     *
+     * @returns {boolean}
+     */
+    hasActive() {
+        return this.activeObservations_.length > 0;
+    }
+}

node_modules/resize-observer-polyfill/src/index.d.ts

@@ -0,0 +1,40 @@
+interface DOMRectReadOnly {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}
+
+declare global {
+    interface ResizeObserverCallback {
+        (entries: ResizeObserverEntry[], observer: ResizeObserver): void
+    }
+
+    interface ResizeObserverEntry {
+        readonly target: Element;
+        readonly contentRect: DOMRectReadOnly;
+    }
+
+    interface ResizeObserver {
+        observe(target: Element): void;
+        unobserve(target: Element): void;
+        disconnect(): void;
+    }
+}
+
+declare var ResizeObserver: {
+    prototype: ResizeObserver;
+    new(callback: ResizeObserverCallback): ResizeObserver;
+}
+
+interface ResizeObserver {
+    observe(target: Element): void;
+    unobserve(target: Element): void;
+    disconnect(): void;
+}
+
+export default ResizeObserver;

node_modules/resize-observer-polyfill/src/index.js

@@ -0,0 +1,11 @@
+import ResizeObserverPolyfill from './ResizeObserver.js';
+import global from './shims/global.js';
+
+export default (() => {
+    // Export existing implementation if available.
+    if (typeof global.ResizeObserver !== 'undefined') {
+        return global.ResizeObserver;
+    }
+
+    return ResizeObserverPolyfill;
+})();

node_modules/resize-observer-polyfill/src/index.js.flow

@@ -0,0 +1,32 @@
+// @flow
+
+class DOMRectReadOnly {
+    +x: number;
+    +y: number;
+    +width: number;
+    +height: number;
+    +top: number;
+    +right: number;
+    +bottom: number;
+    +left: number;
+}
+
+class ResizeObserverEntry {
+    +target: Element;
+    +contentRect: DOMRectReadOnly;
+}
+
+type Entries = $ReadOnlyArray<ResizeObserverEntry>;
+
+type ResizeObserverCallback = {
+    (entries: Entries, observer: ResizeObserver): void
+};
+
+declare class ResizeObserver {
+    constructor(ResizeObserverCallback): ResizeObserver;
+    observe(target: Element): void;
+    unobserve(target: Element): void;
+    disconnect(): void;
+};
+
+declare export default typeof ResizeObserver;

node_modules/resize-observer-polyfill/src/shims/es6-collections.js

@@ -0,0 +1,115 @@
+/**
+ * A collection of shims that provide minimal functionality of the ES6 collections.
+ *
+ * These implementations are not meant to be used outside of the ResizeObserver
+ * modules as they cover only a limited range of use cases.
+ */
+/* eslint-disable require-jsdoc, valid-jsdoc */
+const MapShim = (() => {
+    if (typeof Map !== 'undefined') {
+        return Map;
+    }
+
+    /**
+     * Returns index in provided array that matches the specified key.
+     *
+     * @param {Array<Array>} arr
+     * @param {*} key
+     * @returns {number}
+     */
+    function getIndex(arr, key) {
+        let result = -1;
+
+        arr.some((entry, index) => {
+            if (entry[0] === key) {
+                result = index;
+
+                return true;
+            }
+
+            return false;
+        });
+
+        return result;
+    }
+
+    return class {
+        constructor() {
+            this.__entries__ = [];
+        }
+
+        /**
+         * @returns {boolean}
+         */
+        get size() {
+            return this.__entries__.length;
+        }
+
+        /**
+         * @param {*} key
+         * @returns {*}
+         */
+        get(key) {
+            const index = getIndex(this.__entries__, key);
+            const entry = this.__entries__[index];
+
+            return entry && entry[1];
+        }
+
+        /**
+         * @param {*} key
+         * @param {*} value
+         * @returns {void}
+         */
+        set(key, value) {
+            const index = getIndex(this.__entries__, key);
+
+            if (~index) {
+                this.__entries__[index][1] = value;
+            } else {
+                this.__entries__.push([key, value]);
+            }
+        }
+
+        /**
+         * @param {*} key
+         * @returns {void}
+         */
+        delete(key) {
+            const entries = this.__entries__;
+            const index = getIndex(entries, key);
+
+            if (~index) {
+                entries.splice(index, 1);
+            }
+        }
+
+        /**
+         * @param {*} key
+         * @returns {void}
+         */
+        has(key) {
+            return !!~getIndex(this.__entries__, key);
+        }
+
+        /**
+         * @returns {void}
+         */
+        clear() {
+            this.__entries__.splice(0);
+        }
+
+        /**
+         * @param {Function} callback
+         * @param {*} [ctx=null]
+         * @returns {void}
+         */
+        forEach(callback, ctx = null) {
+            for (const entry of this.__entries__) {
+                callback.call(ctx, entry[1], entry[0]);
+            }
+        }
+    };
+})();
+
+export {MapShim as Map};

node_modules/resize-observer-polyfill/src/shims/global.js

@@ -0,0 +1,17 @@
+// Returns global object of a current environment.
+export default (() => {
+    if (typeof global !== 'undefined' && global.Math === Math) {
+        return global;
+    }
+
+    if (typeof self !== 'undefined' && self.Math === Math) {
+        return self;
+    }
+
+    if (typeof window !== 'undefined' && window.Math === Math) {
+        return window;
+    }
+
+    // eslint-disable-next-line no-new-func
+    return Function('return this')();
+})();

node_modules/resize-observer-polyfill/src/shims/requestAnimationFrame.js

@@ -0,0 +1,18 @@
+import global from './global.js';
+
+/**
+ * A shim for the requestAnimationFrame which falls back to the setTimeout if
+ * first one is not supported.
+ *
+ * @returns {number} Requests' identifier.
+ */
+export default (() => {
+    if (typeof requestAnimationFrame === 'function') {
+        // It's required to use a bounded function because IE sometimes throws
+        // an "Invalid calling object" error if rAF is invoked without the global
+        // object on the left hand side.
+        return requestAnimationFrame.bind(global);
+    }
+
+    return callback => setTimeout(() => callback(Date.now()), 1000 / 60);
+})();

node_modules/resize-observer-polyfill/src/utils/defineConfigurable.js

@@ -0,0 +1,19 @@
+/**
+ * Defines non-writable/enumerable properties of the provided target object.
+ *
+ * @param {Object} target - Object for which to define properties.
+ * @param {Object} props - Properties to be defined.
+ * @returns {Object} Target object.
+ */
+export default (target, props) => {
+    for (const key of Object.keys(props)) {
+        Object.defineProperty(target, key, {
+            value: props[key],
+            enumerable: false,
+            writable: false,
+            configurable: true
+        });
+    }
+
+    return target;
+};

node_modules/resize-observer-polyfill/src/utils/geometry.js

@@ -0,0 +1,233 @@
+import defineConfigurable from './defineConfigurable.js';
+import getWindowOf from './getWindowOf.js';
+import isBrowser from './isBrowser.js';
+
+// Placeholder of an empty content rectangle.
+const emptyRect = createRectInit(0, 0, 0, 0);
+
+/**
+ * Converts provided string to a number.
+ *
+ * @param {number|string} value
+ * @returns {number}
+ */
+function toFloat(value) {
+    return parseFloat(value) || 0;
+}
+
+/**
+ * Extracts borders size from provided styles.
+ *
+ * @param {CSSStyleDeclaration} styles
+ * @param {...string} positions - Borders positions (top, right, ...)
+ * @returns {number}
+ */
+function getBordersSize(styles, ...positions) {
+    return positions.reduce((size, position) => {
+        const value = styles['border-' + position + '-width'];
+
+        return size + toFloat(value);
+    }, 0);
+}
+
+/**
+ * Extracts paddings sizes from provided styles.
+ *
+ * @param {CSSStyleDeclaration} styles
+ * @returns {Object} Paddings box.
+ */
+function getPaddings(styles) {
+    const positions = ['top', 'right', 'bottom', 'left'];
+    const paddings = {};
+
+    for (const position of positions) {
+        const value = styles['padding-' + position];
+
+        paddings[position] = toFloat(value);
+    }
+
+    return paddings;
+}
+
+/**
+ * Calculates content rectangle of provided SVG element.
+ *
+ * @param {SVGGraphicsElement} target - Element content rectangle of which needs
+ *      to be calculated.
+ * @returns {DOMRectInit}
+ */
+function getSVGContentRect(target) {
+    const bbox = target.getBBox();
+
+    return createRectInit(0, 0, bbox.width, bbox.height);
+}
+
+/**
+ * Calculates content rectangle of provided HTMLElement.
+ *
+ * @param {HTMLElement} target - Element for which to calculate the content rectangle.
+ * @returns {DOMRectInit}
+ */
+function getHTMLElementContentRect(target) {
+    // Client width & height properties can't be
+    // used exclusively as they provide rounded values.
+    const {clientWidth, clientHeight} = target;
+
+    // By this condition we can catch all non-replaced inline, hidden and
+    // detached elements. Though elements with width & height properties less
+    // than 0.5 will be discarded as well.
+    //
+    // Without it we would need to implement separate methods for each of
+    // those cases and it's not possible to perform a precise and performance
+    // effective test for hidden elements. E.g. even jQuery's ':visible' filter
+    // gives wrong results for elements with width & height less than 0.5.
+    if (!clientWidth && !clientHeight) {
+        return emptyRect;
+    }
+
+    const styles = getWindowOf(target).getComputedStyle(target);
+    const paddings = getPaddings(styles);
+    const horizPad = paddings.left + paddings.right;
+    const vertPad = paddings.top + paddings.bottom;
+
+    // Computed styles of width & height are being used because they are the
+    // only dimensions available to JS that contain non-rounded values. It could
+    // be possible to utilize the getBoundingClientRect if only it's data wasn't
+    // affected by CSS transformations let alone paddings, borders and scroll bars.
+    let width = toFloat(styles.width),
+        height = toFloat(styles.height);
+
+    // Width & height include paddings and borders when the 'border-box' box
+    // model is applied (except for IE).
+    if (styles.boxSizing === 'border-box') {
+        // Following conditions are required to handle Internet Explorer which
+        // doesn't include paddings and borders to computed CSS dimensions.
+        //
+        // We can say that if CSS dimensions + paddings are equal to the "client"
+        // properties then it's either IE, and thus we don't need to subtract
+        // anything, or an element merely doesn't have paddings/borders styles.
+        if (Math.round(width + horizPad) !== clientWidth) {
+            width -= getBordersSize(styles, 'left', 'right') + horizPad;
+        }
+
+        if (Math.round(height + vertPad) !== clientHeight) {
+            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;
+        }
+    }
+
+    // Following steps can't be applied to the document's root element as its
+    // client[Width/Height] properties represent viewport area of the window.
+    // Besides, it's as well not necessary as the <html> itself neither has
+    // rendered scroll bars nor it can be clipped.
+    if (!isDocumentElement(target)) {
+        // In some browsers (only in Firefox, actually) CSS width & height
+        // include scroll bars size which can be removed at this step as scroll
+        // bars are the only difference between rounded dimensions + paddings
+        // and "client" properties, though that is not always true in Chrome.
+        const vertScrollbar = Math.round(width + horizPad) - clientWidth;
+        const horizScrollbar = Math.round(height + vertPad) - clientHeight;
+
+        // Chrome has a rather weird rounding of "client" properties.
+        // E.g. for an element with content width of 314.2px it sometimes gives
+        // the client width of 315px and for the width of 314.7px it may give
+        // 314px. And it doesn't happen all the time. So just ignore this delta
+        // as a non-relevant.
+        if (Math.abs(vertScrollbar) !== 1) {
+            width -= vertScrollbar;
+        }
+
+        if (Math.abs(horizScrollbar) !== 1) {
+            height -= horizScrollbar;
+        }
+    }
+
+    return createRectInit(paddings.left, paddings.top, width, height);
+}
+
+/**
+ * Checks whether provided element is an instance of the SVGGraphicsElement.
+ *
+ * @param {Element} target - Element to be checked.
+ * @returns {boolean}
+ */
+const isSVGGraphicsElement = (() => {
+    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement
+    // interface.
+    if (typeof SVGGraphicsElement !== 'undefined') {
+        return target => target instanceof getWindowOf(target).SVGGraphicsElement;
+    }
+
+    // If it's so, then check that element is at least an instance of the
+    // SVGElement and that it has the "getBBox" method.
+    // eslint-disable-next-line no-extra-parens
+    return target => (
+        target instanceof getWindowOf(target).SVGElement &&
+        typeof target.getBBox === 'function'
+    );
+})();
+
+/**
+ * Checks whether provided element is a document element (<html>).
+ *
+ * @param {Element} target - Element to be checked.
+ * @returns {boolean}
+ */
+function isDocumentElement(target) {
+    return target === getWindowOf(target).document.documentElement;
+}
+
+/**
+ * Calculates an appropriate content rectangle for provided html or svg element.
+ *
+ * @param {Element} target - Element content rectangle of which needs to be calculated.
+ * @returns {DOMRectInit}
+ */
+export function getContentRect(target) {
+    if (!isBrowser) {
+        return emptyRect;
+    }
+
+    if (isSVGGraphicsElement(target)) {
+        return getSVGContentRect(target);
+    }
+
+    return getHTMLElementContentRect(target);
+}
+
+/**
+ * Creates rectangle with an interface of the DOMRectReadOnly.
+ * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly
+ *
+ * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.
+ * @returns {DOMRectReadOnly}
+ */
+export function createReadOnlyRect({x, y, width, height}) {
+    // If DOMRectReadOnly is available use it as a prototype for the rectangle.
+    const Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;
+    const rect = Object.create(Constr.prototype);
+
+    // Rectangle's properties are not writable and non-enumerable.
+    defineConfigurable(rect, {
+        x, y, width, height,
+        top: y,
+        right: x + width,
+        bottom: height + y,
+        left: x
+    });
+
+    return rect;
+}
+
+/**
+ * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.
+ * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit
+ *
+ * @param {number} x - X coordinate.
+ * @param {number} y - Y coordinate.
+ * @param {number} width - Rectangle's width.
+ * @param {number} height - Rectangle's height.
+ * @returns {DOMRectInit}
+ */
+export function createRectInit(x, y, width, height) {
+    return {x, y, width, height};
+}

node_modules/resize-observer-polyfill/src/utils/getWindowOf.js

@@ -0,0 +1,18 @@
+import global from '../shims/global.js';
+
+/**
+ * Returns the global object associated with provided element.
+ *
+ * @param {Object} target
+ * @returns {Object}
+ */
+export default target => {
+    // Assume that the element is an instance of Node, which means that it
+    // has the "ownerDocument" property from which we can retrieve a
+    // corresponding global object.
+    const ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
+
+    // Return the local global object if it's not possible extract one from
+    // provided element.
+    return ownerGlobal || global;
+};

node_modules/resize-observer-polyfill/src/utils/isBrowser.js

@@ -0,0 +1,4 @@
+/**
+ * Detects whether window and document objects are available in current environment.
+ */
+export default typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;

node_modules/resize-observer-polyfill/src/utils/throttle.js

@@ -0,0 +1,78 @@
+import requestAnimationFrame from '../shims/requestAnimationFrame.js';
+
+// Defines minimum timeout before adding a trailing call.
+const trailingTimeout = 2;
+
+/**
+ * Creates a wrapper function which ensures that provided callback will be
+ * invoked only once during the specified delay period.
+ *
+ * @param {Function} callback - Function to be invoked after the delay period.
+ * @param {number} delay - Delay after which to invoke callback.
+ * @returns {Function}
+ */
+export default function (callback, delay) {
+    let leadingCall = false,
+        trailingCall = false,
+        lastCallTime = 0;
+
+    /**
+     * Invokes the original callback function and schedules new invocation if
+     * the "proxy" was called during current request.
+     *
+     * @returns {void}
+     */
+    function resolvePending() {
+        if (leadingCall) {
+            leadingCall = false;
+
+            callback();
+        }
+
+        if (trailingCall) {
+            proxy();
+        }
+    }
+
+    /**
+     * Callback invoked after the specified delay. It will further postpone
+     * invocation of the original function delegating it to the
+     * requestAnimationFrame.
+     *
+     * @returns {void}
+     */
+    function timeoutCallback() {
+        requestAnimationFrame(resolvePending);
+    }
+
+    /**
+     * Schedules invocation of the original function.
+     *
+     * @returns {void}
+     */
+    function proxy() {
+        const timeStamp = Date.now();
+
+        if (leadingCall) {
+            // Reject immediately following calls.
+            if (timeStamp - lastCallTime < trailingTimeout) {
+                return;
+            }
+
+            // Schedule new call to be in invoked when the pending one is resolved.
+            // This is important for "transitions" which never actually start
+            // immediately so there is a chance that we might miss one if change
+            // happens amids the pending invocation.
+            trailingCall = true;
+        } else {
+            leadingCall = true;
+            trailingCall = false;
+
+            setTimeout(timeoutCallback, delay);
+        }
+
+        lastCallTime = timeStamp;
+    }
+
+    return proxy;
+}