/******************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __spreadArray(to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
}

var ARG_LENGTH = {
    a: 7,
    c: 6,
    h: 1,
    l: 2,
    m: 2,
    q: 4,
    s: 4,
    t: 2,
    v: 1,
    z: 0
};
var SEGMENT_PATTERN = /([astvzqmhlc])([^astvzqmhlc]*)/gi;
var NUMBER = /-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/gi;
function parseValues(args) {
    var numbers = args.match(NUMBER);
    return numbers ? numbers.map(Number) : [];
}
/**
 * parse an svg path data string. Generates an Array
 * of commands where each command is an Array of the
 * form `[command, arg1, arg2, ...]`
 *
 * https://www.w3.org/TR/SVG/paths.html#PathDataGeneralInformation
 * @ignore
 *
 * @param {string} path
 * @returns {array}
 */
function parsePath(path) {
    var data = [];
    var p = String(path).trim();
    // A path data segment (if there is one) must begin with a "moveto" command
    if (p[0] !== "M" && p[0] !== "m") {
        return data;
    }
    p.replace(SEGMENT_PATTERN, function (_, command, args) {
        var theArgs = parseValues(args);
        var type = command.toLowerCase();
        var theCommand = command;
        // overloaded moveTo
        if (type === "m" && theArgs.length > 2) {
            data.push(__spreadArray([theCommand], theArgs.splice(0, 2), true));
            type = "l";
            theCommand = theCommand === "m" ? "l" : "L";
        }
        // Ignore invalid commands
        if (theArgs.length < ARG_LENGTH[type]) {
            return "";
        }
        data.push(__spreadArray([theCommand], theArgs.splice(0, ARG_LENGTH[type]), true));
        // The command letter can be eliminated on subsequent commands if the
        // same command is used multiple times in a row (e.g., you can drop the
        // second "L" in "M 100 200 L 200 100 L -100 -200" and use
        // "M 100 200 L 200 100 -100 -200" instead).
        while (theArgs.length >= ARG_LENGTH[type] && theArgs.length && ARG_LENGTH[type]) {
            data.push(__spreadArray([theCommand], theArgs.splice(0, ARG_LENGTH[type]), true));
        }
        return "";
    });
    return data;
}

function rotatePoint(point, angle) {
    var nx = point.x * Math.cos(angle) - point.y * Math.sin(angle);
    var ny = point.y * Math.cos(angle) + point.x * Math.sin(angle);
    point.x = nx;
    point.y = ny;
}
function translatePoint(point, dx, dy) {
    point.x += dx;
    point.y += dy;
}
function scalePoint(point, s) {
    point.x *= s;
    point.y *= s;
}
/**
 * Implements a browser's Path2D api
 */
var Path2D = /** @class */ (function () {
    function Path2D(path) {
        var _a;
        this.commands = [];
        if (path && path instanceof Path2D) {
            (_a = this.commands).push.apply(_a, path.commands);
        }
        else if (path) {
            this.commands = parsePath(path);
        }
    }
    Path2D.prototype.addPath = function (path) {
        var _a;
        if (path && path instanceof Path2D) {
            (_a = this.commands).push.apply(_a, path.commands);
        }
    };
    Path2D.prototype.moveTo = function (x, y) {
        this.commands.push(["M", x, y]);
    };
    Path2D.prototype.lineTo = function (x, y) {
        this.commands.push(["L", x, y]);
    };
    Path2D.prototype.arc = function (x, y, r, start, end, ccw) {
        this.commands.push(["AC", x, y, r, start, end, !!ccw]);
    };
    Path2D.prototype.arcTo = function (x1, y1, x2, y2, r) {
        this.commands.push(["AT", x1, y1, x2, y2, r]);
    };
    Path2D.prototype.ellipse = function (x, y, rx, ry, angle, start, end, ccw) {
        this.commands.push(["E", x, y, rx, ry, angle, start, end, !!ccw]);
    };
    Path2D.prototype.closePath = function () {
        this.commands.push(["Z"]);
    };
    Path2D.prototype.bezierCurveTo = function (cp1x, cp1y, cp2x, cp2y, x, y) {
        this.commands.push(["C", cp1x, cp1y, cp2x, cp2y, x, y]);
    };
    Path2D.prototype.quadraticCurveTo = function (cpx, cpy, x, y) {
        this.commands.push(["Q", cpx, cpy, x, y]);
    };
    Path2D.prototype.rect = function (x, y, width, height) {
        this.commands.push(["R", x, y, width, height]);
    };
    Path2D.prototype.roundRect = function (x, y, width, height, radii) {
        if (typeof radii === "undefined") {
            this.commands.push(["RR", x, y, width, height, 0]);
        }
        else {
            this.commands.push(["RR", x, y, width, height, radii]);
        }
    };
    return Path2D;
}());
function buildPath(ctx, commands) {
    var x = 0;
    var y = 0;
    var endAngle;
    var startAngle;
    var largeArcFlag;
    var sweepFlag;
    var endPoint;
    var midPoint;
    var angle;
    var lambda;
    var t1;
    var t2;
    var x1;
    var y1;
    var r;
    var rx;
    var ry;
    var w;
    var h;
    var pathType;
    var centerPoint;
    var ccw;
    var radii;
    var cpx = null;
    var cpy = null;
    var qcpx = null;
    var qcpy = null;
    var startPoint = null;
    var currentPoint = null;
    ctx.beginPath();
    for (var i = 0; i < commands.length; ++i) {
        pathType = commands[i][0];
        // Reset control point if command is not cubic
        if (pathType !== "S" && pathType !== "s" && pathType !== "C" && pathType !== "c") {
            cpx = null;
            cpy = null;
        }
        if (pathType !== "T" && pathType !== "t" && pathType !== "Q" && pathType !== "q") {
            qcpx = null;
            qcpy = null;
        }
        var c = void 0;
        switch (pathType) {
            case "m":
            case "M":
                c = commands[i];
                if (pathType === "m") {
                    x += c[1];
                    y += c[2];
                }
                else {
                    x = c[1];
                    y = c[2];
                }
                if (pathType === "M" || !startPoint) {
                    startPoint = { x: x, y: y };
                }
                ctx.moveTo(x, y);
                break;
            case "l":
                c = commands[i];
                x += c[1];
                y += c[2];
                ctx.lineTo(x, y);
                break;
            case "L":
                c = commands[i];
                x = c[1];
                y = c[2];
                ctx.lineTo(x, y);
                break;
            case "H":
                c = commands[i];
                x = c[1];
                ctx.lineTo(x, y);
                break;
            case "h":
                c = commands[i];
                x += c[1];
                ctx.lineTo(x, y);
                break;
            case "V":
                c = commands[i];
                y = c[1];
                ctx.lineTo(x, y);
                break;
            case "v":
                c = commands[i];
                y += c[1];
                ctx.lineTo(x, y);
                break;
            case "a":
            case "A":
                c = commands[i];
                if (currentPoint === null) {
                    throw new Error("This should never happen");
                }
                if (pathType === "a") {
                    x += c[6];
                    y += c[7];
                }
                else {
                    x = c[6];
                    y = c[7];
                }
                rx = c[1]; // rx
                ry = c[2]; // ry
                angle = (c[3] * Math.PI) / 180;
                largeArcFlag = !!c[4];
                sweepFlag = !!c[5];
                endPoint = { x: x, y: y };
                // https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
                midPoint = {
                    x: (currentPoint.x - endPoint.x) / 2,
                    y: (currentPoint.y - endPoint.y) / 2
                };
                rotatePoint(midPoint, -angle);
                // radius correction
                lambda = (midPoint.x * midPoint.x) / (rx * rx) + (midPoint.y * midPoint.y) / (ry * ry);
                if (lambda > 1) {
                    lambda = Math.sqrt(lambda);
                    rx *= lambda;
                    ry *= lambda;
                }
                centerPoint = {
                    x: (rx * midPoint.y) / ry,
                    y: -(ry * midPoint.x) / rx
                };
                t1 = rx * rx * ry * ry;
                t2 = rx * rx * midPoint.y * midPoint.y + ry * ry * midPoint.x * midPoint.x;
                if (sweepFlag !== largeArcFlag) {
                    scalePoint(centerPoint, Math.sqrt((t1 - t2) / t2) || 0);
                }
                else {
                    scalePoint(centerPoint, -Math.sqrt((t1 - t2) / t2) || 0);
                }
                startAngle = Math.atan2((midPoint.y - centerPoint.y) / ry, (midPoint.x - centerPoint.x) / rx);
                endAngle = Math.atan2(-(midPoint.y + centerPoint.y) / ry, -(midPoint.x + centerPoint.x) / rx);
                rotatePoint(centerPoint, angle);
                translatePoint(centerPoint, (endPoint.x + currentPoint.x) / 2, (endPoint.y + currentPoint.y) / 2);
                ctx.save();
                ctx.translate(centerPoint.x, centerPoint.y);
                ctx.rotate(angle);
                ctx.scale(rx, ry);
                ctx.arc(0, 0, 1, startAngle, endAngle, !sweepFlag);
                ctx.restore();
                break;
            case "C":
                c = commands[i];
                cpx = c[3]; // Last control point
                cpy = c[4];
                x = c[5];
                y = c[6];
                ctx.bezierCurveTo(c[1], c[2], cpx, cpy, x, y);
                break;
            case "c":
                c = commands[i];
                ctx.bezierCurveTo(c[1] + x, c[2] + y, c[3] + x, c[4] + y, c[5] + x, c[6] + y);
                cpx = c[3] + x; // Last control point
                cpy = c[4] + y;
                x += c[5];
                y += c[6];
                break;
            case "S":
                c = commands[i];
                if (cpx === null || cpy === null) {
                    cpx = x;
                    cpy = y;
                }
                ctx.bezierCurveTo(2 * x - cpx, 2 * y - cpy, c[1], c[2], c[3], c[4]);
                cpx = c[1]; // last control point
                cpy = c[2];
                x = c[3];
                y = c[4];
                break;
            case "s":
                c = commands[i];
                if (cpx === null || cpy === null) {
                    cpx = x;
                    cpy = y;
                }
                ctx.bezierCurveTo(2 * x - cpx, 2 * y - cpy, c[1] + x, c[2] + y, c[3] + x, c[4] + y);
                cpx = c[1] + x; // last control point
                cpy = c[2] + y;
                x += c[3];
                y += c[4];
                break;
            case "Q":
                c = commands[i];
                qcpx = c[1]; // last control point
                qcpy = c[2];
                x = c[3];
                y = c[4];
                ctx.quadraticCurveTo(qcpx, qcpy, x, y);
                break;
            case "q":
                c = commands[i];
                qcpx = c[1] + x; // last control point
                qcpy = c[2] + y;
                x += c[3];
                y += c[4];
                ctx.quadraticCurveTo(qcpx, qcpy, x, y);
                break;
            case "T":
                c = commands[i];
                if (qcpx === null || qcpy === null) {
                    qcpx = x;
                    qcpy = y;
                }
                qcpx = 2 * x - qcpx; // last control point
                qcpy = 2 * y - qcpy;
                x = c[1];
                y = c[2];
                ctx.quadraticCurveTo(qcpx, qcpy, x, y);
                break;
            case "t":
                c = commands[i];
                if (qcpx === null || qcpy === null) {
                    qcpx = x;
                    qcpy = y;
                }
                qcpx = 2 * x - qcpx; // last control point
                qcpy = 2 * y - qcpy;
                x += c[1];
                y += c[2];
                ctx.quadraticCurveTo(qcpx, qcpy, x, y);
                break;
            case "z":
            case "Z":
                if (startPoint) {
                    x = startPoint.x;
                    y = startPoint.y;
                }
                startPoint = null;
                ctx.closePath();
                break;
            case "AC": // arc
                c = commands[i];
                x = c[1];
                y = c[2];
                r = c[3];
                startAngle = c[4];
                endAngle = c[5];
                ccw = c[6];
                ctx.arc(x, y, r, startAngle, endAngle, ccw);
                break;
            case "AT": // arcTo
                c = commands[i];
                x1 = c[1];
                y1 = c[2];
                x = c[3];
                y = c[4];
                r = c[5];
                ctx.arcTo(x1, y1, x, y, r);
                break;
            case "E": // ellipse
                c = commands[i];
                x = c[1];
                y = c[2];
                rx = c[3];
                ry = c[4];
                angle = c[5];
                startAngle = c[6];
                endAngle = c[7];
                ccw = c[8];
                ctx.save();
                ctx.translate(x, y);
                ctx.rotate(angle);
                ctx.scale(rx, ry);
                ctx.arc(0, 0, 1, startAngle, endAngle, ccw);
                ctx.restore();
                break;
            case "R": // rect
                c = commands[i];
                x = c[1];
                y = c[2];
                w = c[3];
                h = c[4];
                startPoint = { x: x, y: y };
                ctx.rect(x, y, w, h);
                break;
            case "RR": // roundedRect
                c = commands[i];
                x = c[1];
                y = c[2];
                w = c[3];
                h = c[4];
                radii = c[5];
                startPoint = { x: x, y: y };
                ctx.roundRect(x, y, w, h, radii);
                break;
        }
        if (!currentPoint) {
            currentPoint = { x: x, y: y };
        }
        else {
            currentPoint.x = x;
            currentPoint.y = y;
        }
    }
}
/**
 * Polyfills CanvasRenderingContext2D stroke, fill and isPointInPath so that they support Path2D objects.
 * @param {WindowLike} window - window like object containing a CanvasRenderingContext2D constructor
 */
function polyfillPath2D(window) {
    if (!window || !window.CanvasRenderingContext2D || window.Path2D)
        return;
    var CanvasRenderingContext2D = window.CanvasRenderingContext2D;
    /* eslint-disable @typescript-eslint/unbound-method */
    // setting unbound functions here. Make sure this is set in function call later
    var cFill = CanvasRenderingContext2D.prototype.fill;
    var cStroke = CanvasRenderingContext2D.prototype.stroke;
    var cIsPointInPath = CanvasRenderingContext2D.prototype.isPointInPath;
    /* eslint-enable @typescript-eslint/unbound-method */
    CanvasRenderingContext2D.prototype.fill = function fill() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
        }
        if (args[0] instanceof Path2D) {
            var path = args[0];
            var fillRule = args[1] || "nonzero";
            buildPath(this, path.commands);
            cFill.apply(this, [fillRule]);
        }
        else {
            var fillRule = args[0] || "nonzero";
            return cFill.apply(this, [fillRule]);
        }
    };
    CanvasRenderingContext2D.prototype.stroke = function stroke(path) {
        if (path) {
            buildPath(this, path.commands);
        }
        cStroke.apply(this);
    };
    CanvasRenderingContext2D.prototype.isPointInPath = function isPointInPath() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
        }
        if (args[0] instanceof Path2D) {
            // first argument is a Path2D object
            var path = args[0];
            var x = args[1];
            var y = args[2];
            var fillRule = args[3] || "nonzero";
            buildPath(this, path.commands);
            return cIsPointInPath.apply(this, [x, y, fillRule]);
        }
        else {
            return cIsPointInPath.apply(this, args);
        }
    };
    window.Path2D = Path2D;
}

function roundRect(x, y, width, height, radii) {
    var _this = this;
    if (radii === void 0) { radii = 0; }
    if (typeof radii === "number") {
        // eslint-disable-next-line no-param-reassign
        radii = [radii];
    }
    // check for range error
    if (Array.isArray(radii)) {
        if (radii.length === 0 || radii.length > 4) {
            throw new RangeError("Failed to execute 'roundRect' on '".concat(this.constructor.name, "': ").concat(radii.length, " radii provided. Between one and four radii are necessary."));
        }
        radii.forEach(function (v) {
            if (v < 0) {
                throw new RangeError("Failed to execute 'roundRect' on '".concat(_this.constructor.name, "': Radius value ").concat(v, " is negative."));
            }
        });
    }
    else {
        return;
    }
    if (radii.length === 1 && radii[0] === 0) {
        return this.rect(x, y, width, height);
    }
    // set the corners
    // tl = top left radius
    // tr = top right radius
    // br = bottom right radius
    // bl = bottom left radius
    var minRadius = Math.min(width, height) / 2;
    var tr, br, bl;
    var tl = (tr = br = bl = Math.min(minRadius, radii[0]));
    if (radii.length === 2) {
        tr = bl = Math.min(minRadius, radii[1]);
    }
    if (radii.length === 3) {
        tr = bl = Math.min(minRadius, radii[1]);
        br = Math.min(minRadius, radii[2]);
    }
    if (radii.length === 4) {
        tr = Math.min(minRadius, radii[1]);
        br = Math.min(minRadius, radii[2]);
        bl = Math.min(minRadius, radii[3]);
    }
    // begin with closing current path
    // this.closePath();
    // let's draw the rounded rectangle
    this.moveTo(x, y + height - bl);
    this.arcTo(x, y, x + tl, y, tl);
    this.arcTo(x + width, y, x + width, y + tr, tr);
    this.arcTo(x + width, y + height, x + width - br, y + height, br);
    this.arcTo(x, y + height, x, y + height - bl, bl);
    // and move to rects control point for further path drawing
    this.moveTo(x, y);
}
/**
 * Polyfills roundRect on CanvasRenderingContext2D and Path2D
 * @param {WindowLike} window - window like object containing both CanvasRenderingContext2D and Path2D constructor
 */
function polyfillRoundRect(window) {
    if (!window || !window.CanvasRenderingContext2D)
        return;
    var CanvasRenderingContext2D = window.CanvasRenderingContext2D, Path2D = window.Path2D;
    // polyfill unsupported roundRect for e.g. firefox https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/roundRect#browser_compatibility
    if (CanvasRenderingContext2D && !CanvasRenderingContext2D.prototype.roundRect) {
        CanvasRenderingContext2D.prototype.roundRect = roundRect;
    }
    if (Path2D && !Path2D.prototype.roundRect) {
        Path2D.prototype.roundRect = roundRect;
    }
}

polyfillPath2D(window);
polyfillRoundRect(window);