first commit
This commit is contained in:
commit
eb2f504652
32490 changed files with 5731109 additions and 0 deletions
597
node_modules/path2d-polyfill/dist/path2d-polyfill.dev.js
generated
vendored
Normal file
597
node_modules/path2d-polyfill/dist/path2d-polyfill.dev.js
generated
vendored
Normal file
|
|
@ -0,0 +1,597 @@
|
|||
(function () {
|
||||
'use strict';
|
||||
|
||||
/******************************************************************************
|
||||
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);
|
||||
|
||||
})();
|
||||
Loading…
Add table
Add a link
Reference in a new issue