Liferay.Loader.define('commerce-dashboard-web$resize-observer-polyfill@1.5.1/src/utils/geometry', ['module', 'exports', 'require'], function (module, exports, require) {
    var define = undefined;
    var global = window;
    {
        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 };
        }
    }
});
//# sourceMappingURL=geometry.js.map