summaryrefslogtreecommitdiff
path: root/node_modules/svgo/plugins/_transforms.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/svgo/plugins/_transforms.js')
-rw-r--r--node_modules/svgo/plugins/_transforms.js379
1 files changed, 379 insertions, 0 deletions
diff --git a/node_modules/svgo/plugins/_transforms.js b/node_modules/svgo/plugins/_transforms.js
new file mode 100644
index 00000000..159f1a3b
--- /dev/null
+++ b/node_modules/svgo/plugins/_transforms.js
@@ -0,0 +1,379 @@
+'use strict';
+
+const regTransformTypes = /matrix|translate|scale|rotate|skewX|skewY/;
+const regTransformSplit =
+ /\s*(matrix|translate|scale|rotate|skewX|skewY)\s*\(\s*(.+?)\s*\)[\s,]*/;
+const regNumericValues = /[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
+
+/**
+ * @typedef {{ name: string, data: Array<number> }} TransformItem
+ */
+
+/**
+ * Convert transform string to JS representation.
+ *
+ * @type {(transformString: string) => Array<TransformItem>}
+ */
+exports.transform2js = (transformString) => {
+ // JS representation of the transform data
+ /**
+ * @type {Array<TransformItem>}
+ */
+ const transforms = [];
+ // current transform context
+ /**
+ * @type {null | TransformItem}
+ */
+ let current = null;
+ // split value into ['', 'translate', '10 50', '', 'scale', '2', '', 'rotate', '-45', '']
+ for (const item of transformString.split(regTransformSplit)) {
+ var num;
+ if (item) {
+ // if item is a translate function
+ if (regTransformTypes.test(item)) {
+ // then collect it and change current context
+ current = { name: item, data: [] };
+ transforms.push(current);
+ // else if item is data
+ } else {
+ // then split it into [10, 50] and collect as context.data
+ // eslint-disable-next-line no-cond-assign
+ while ((num = regNumericValues.exec(item))) {
+ num = Number(num);
+ if (current != null) {
+ current.data.push(num);
+ }
+ }
+ }
+ }
+ }
+ // return empty array if broken transform (no data)
+ return current == null || current.data.length == 0 ? [] : transforms;
+};
+
+/**
+ * Multiply transforms into one.
+ *
+ * @type {(transforms: Array<TransformItem>) => TransformItem}
+ */
+exports.transformsMultiply = (transforms) => {
+ // convert transforms objects to the matrices
+ const matrixData = transforms.map((transform) => {
+ if (transform.name === 'matrix') {
+ return transform.data;
+ }
+ return transformToMatrix(transform);
+ });
+ // multiply all matrices into one
+ const matrixTransform = {
+ name: 'matrix',
+ data:
+ matrixData.length > 0 ? matrixData.reduce(multiplyTransformMatrices) : [],
+ };
+ return matrixTransform;
+};
+
+/**
+ * math utilities in radians.
+ */
+const mth = {
+ /**
+ * @type {(deg: number) => number}
+ */
+ rad: (deg) => {
+ return (deg * Math.PI) / 180;
+ },
+
+ /**
+ * @type {(rad: number) => number}
+ */
+ deg: (rad) => {
+ return (rad * 180) / Math.PI;
+ },
+
+ /**
+ * @type {(deg: number) => number}
+ */
+ cos: (deg) => {
+ return Math.cos(mth.rad(deg));
+ },
+
+ /**
+ * @type {(val: number, floatPrecision: number) => number}
+ */
+ acos: (val, floatPrecision) => {
+ return Number(mth.deg(Math.acos(val)).toFixed(floatPrecision));
+ },
+
+ /**
+ * @type {(deg: number) => number}
+ */
+ sin: (deg) => {
+ return Math.sin(mth.rad(deg));
+ },
+
+ /**
+ * @type {(val: number, floatPrecision: number) => number}
+ */
+ asin: (val, floatPrecision) => {
+ return Number(mth.deg(Math.asin(val)).toFixed(floatPrecision));
+ },
+
+ /**
+ * @type {(deg: number) => number}
+ */
+ tan: (deg) => {
+ return Math.tan(mth.rad(deg));
+ },
+
+ /**
+ * @type {(val: number, floatPrecision: number) => number}
+ */
+ atan: (val, floatPrecision) => {
+ return Number(mth.deg(Math.atan(val)).toFixed(floatPrecision));
+ },
+};
+
+/**
+ * @typedef {{
+ * convertToShorts: boolean,
+ * floatPrecision: number,
+ * transformPrecision: number,
+ * matrixToTransform: boolean,
+ * shortTranslate: boolean,
+ * shortScale: boolean,
+ * shortRotate: boolean,
+ * removeUseless: boolean,
+ * collapseIntoOne: boolean,
+ * leadingZero: boolean,
+ * negativeExtraSpace: boolean,
+ * }} TransformParams
+ */
+
+/**
+ * Decompose matrix into simple transforms. See
+ * https://frederic-wang.fr/decomposition-of-2d-transform-matrices.html
+ *
+ * @type {(transform: TransformItem, params: TransformParams) => Array<TransformItem>}
+ */
+exports.matrixToTransform = (transform, params) => {
+ let floatPrecision = params.floatPrecision;
+ let data = transform.data;
+ let transforms = [];
+ let sx = Number(
+ Math.hypot(data[0], data[1]).toFixed(params.transformPrecision)
+ );
+ let sy = Number(
+ ((data[0] * data[3] - data[1] * data[2]) / sx).toFixed(
+ params.transformPrecision
+ )
+ );
+ let colsSum = data[0] * data[2] + data[1] * data[3];
+ let rowsSum = data[0] * data[1] + data[2] * data[3];
+ let scaleBefore = rowsSum != 0 || sx == sy;
+
+ // [..., ..., ..., ..., tx, ty] → translate(tx, ty)
+ if (data[4] || data[5]) {
+ transforms.push({
+ name: 'translate',
+ data: data.slice(4, data[5] ? 6 : 5),
+ });
+ }
+
+ // [sx, 0, tan(a)·sy, sy, 0, 0] → skewX(a)·scale(sx, sy)
+ if (!data[1] && data[2]) {
+ transforms.push({
+ name: 'skewX',
+ data: [mth.atan(data[2] / sy, floatPrecision)],
+ });
+
+ // [sx, sx·tan(a), 0, sy, 0, 0] → skewY(a)·scale(sx, sy)
+ } else if (data[1] && !data[2]) {
+ transforms.push({
+ name: 'skewY',
+ data: [mth.atan(data[1] / data[0], floatPrecision)],
+ });
+ sx = data[0];
+ sy = data[3];
+
+ // [sx·cos(a), sx·sin(a), sy·-sin(a), sy·cos(a), x, y] → rotate(a[, cx, cy])·(scale or skewX) or
+ // [sx·cos(a), sy·sin(a), sx·-sin(a), sy·cos(a), x, y] → scale(sx, sy)·rotate(a[, cx, cy]) (if !scaleBefore)
+ } else if (!colsSum || (sx == 1 && sy == 1) || !scaleBefore) {
+ if (!scaleBefore) {
+ sx = (data[0] < 0 ? -1 : 1) * Math.hypot(data[0], data[2]);
+ sy = (data[3] < 0 ? -1 : 1) * Math.hypot(data[1], data[3]);
+ transforms.push({ name: 'scale', data: [sx, sy] });
+ }
+ var angle = Math.min(Math.max(-1, data[0] / sx), 1),
+ rotate = [
+ mth.acos(angle, floatPrecision) *
+ ((scaleBefore ? 1 : sy) * data[1] < 0 ? -1 : 1),
+ ];
+
+ if (rotate[0]) transforms.push({ name: 'rotate', data: rotate });
+
+ if (rowsSum && colsSum)
+ transforms.push({
+ name: 'skewX',
+ data: [mth.atan(colsSum / (sx * sx), floatPrecision)],
+ });
+
+ // rotate(a, cx, cy) can consume translate() within optional arguments cx, cy (rotation point)
+ if (rotate[0] && (data[4] || data[5])) {
+ transforms.shift();
+ var cos = data[0] / sx,
+ sin = data[1] / (scaleBefore ? sx : sy),
+ x = data[4] * (scaleBefore ? 1 : sy),
+ y = data[5] * (scaleBefore ? 1 : sx),
+ denom =
+ (Math.pow(1 - cos, 2) + Math.pow(sin, 2)) *
+ (scaleBefore ? 1 : sx * sy);
+ rotate.push(((1 - cos) * x - sin * y) / denom);
+ rotate.push(((1 - cos) * y + sin * x) / denom);
+ }
+
+ // Too many transformations, return original matrix if it isn't just a scale/translate
+ } else if (data[1] || data[2]) {
+ return [transform];
+ }
+
+ if ((scaleBefore && (sx != 1 || sy != 1)) || !transforms.length)
+ transforms.push({
+ name: 'scale',
+ data: sx == sy ? [sx] : [sx, sy],
+ });
+
+ return transforms;
+};
+
+/**
+ * Convert transform to the matrix data.
+ *
+ * @type {(transform: TransformItem) => Array<number> }
+ */
+const transformToMatrix = (transform) => {
+ if (transform.name === 'matrix') {
+ return transform.data;
+ }
+ switch (transform.name) {
+ case 'translate':
+ // [1, 0, 0, 1, tx, ty]
+ return [1, 0, 0, 1, transform.data[0], transform.data[1] || 0];
+ case 'scale':
+ // [sx, 0, 0, sy, 0, 0]
+ return [
+ transform.data[0],
+ 0,
+ 0,
+ transform.data[1] || transform.data[0],
+ 0,
+ 0,
+ ];
+ case 'rotate':
+ // [cos(a), sin(a), -sin(a), cos(a), x, y]
+ var cos = mth.cos(transform.data[0]),
+ sin = mth.sin(transform.data[0]),
+ cx = transform.data[1] || 0,
+ cy = transform.data[2] || 0;
+ return [
+ cos,
+ sin,
+ -sin,
+ cos,
+ (1 - cos) * cx + sin * cy,
+ (1 - cos) * cy - sin * cx,
+ ];
+ case 'skewX':
+ // [1, 0, tan(a), 1, 0, 0]
+ return [1, 0, mth.tan(transform.data[0]), 1, 0, 0];
+ case 'skewY':
+ // [1, tan(a), 0, 1, 0, 0]
+ return [1, mth.tan(transform.data[0]), 0, 1, 0, 0];
+ default:
+ throw Error(`Unknown transform ${transform.name}`);
+ }
+};
+
+/**
+ * Applies transformation to an arc. To do so, we represent ellipse as a matrix, multiply it
+ * by the transformation matrix and use a singular value decomposition to represent in a form
+ * rotate(θ)·scale(a b)·rotate(φ). This gives us new ellipse params a, b and θ.
+ * SVD is being done with the formulae provided by Wolffram|Alpha (svd {{m0, m2}, {m1, m3}})
+ *
+ * @type {(
+ * cursor: [x: number, y: number],
+ * arc: Array<number>,
+ * transform: Array<number>
+ * ) => Array<number>}
+ */
+exports.transformArc = (cursor, arc, transform) => {
+ const x = arc[5] - cursor[0];
+ const y = arc[6] - cursor[1];
+ let a = arc[0];
+ let b = arc[1];
+ const rot = (arc[2] * Math.PI) / 180;
+ const cos = Math.cos(rot);
+ const sin = Math.sin(rot);
+ // skip if radius is 0
+ if (a > 0 && b > 0) {
+ let h =
+ Math.pow(x * cos + y * sin, 2) / (4 * a * a) +
+ Math.pow(y * cos - x * sin, 2) / (4 * b * b);
+ if (h > 1) {
+ h = Math.sqrt(h);
+ a *= h;
+ b *= h;
+ }
+ }
+ const ellipse = [a * cos, a * sin, -b * sin, b * cos, 0, 0];
+ const m = multiplyTransformMatrices(transform, ellipse);
+ // Decompose the new ellipse matrix
+ const lastCol = m[2] * m[2] + m[3] * m[3];
+ const squareSum = m[0] * m[0] + m[1] * m[1] + lastCol;
+ const root =
+ Math.hypot(m[0] - m[3], m[1] + m[2]) * Math.hypot(m[0] + m[3], m[1] - m[2]);
+
+ if (!root) {
+ // circle
+ arc[0] = arc[1] = Math.sqrt(squareSum / 2);
+ arc[2] = 0;
+ } else {
+ const majorAxisSqr = (squareSum + root) / 2;
+ const minorAxisSqr = (squareSum - root) / 2;
+ const major = Math.abs(majorAxisSqr - lastCol) > 1e-6;
+ const sub = (major ? majorAxisSqr : minorAxisSqr) - lastCol;
+ const rowsSum = m[0] * m[2] + m[1] * m[3];
+ const term1 = m[0] * sub + m[2] * rowsSum;
+ const term2 = m[1] * sub + m[3] * rowsSum;
+ arc[0] = Math.sqrt(majorAxisSqr);
+ arc[1] = Math.sqrt(minorAxisSqr);
+ arc[2] =
+ (((major ? term2 < 0 : term1 > 0) ? -1 : 1) *
+ Math.acos((major ? term1 : term2) / Math.hypot(term1, term2)) *
+ 180) /
+ Math.PI;
+ }
+
+ if (transform[0] < 0 !== transform[3] < 0) {
+ // Flip the sweep flag if coordinates are being flipped horizontally XOR vertically
+ arc[4] = 1 - arc[4];
+ }
+
+ return arc;
+};
+
+/**
+ * Multiply transformation matrices.
+ *
+ * @type {(a: Array<number>, b: Array<number>) => Array<number>}
+ */
+const multiplyTransformMatrices = (a, b) => {
+ return [
+ a[0] * b[0] + a[2] * b[1],
+ a[1] * b[0] + a[3] * b[1],
+ a[0] * b[2] + a[2] * b[3],
+ a[1] * b[2] + a[3] * b[3],
+ a[0] * b[4] + a[2] * b[5] + a[4],
+ a[1] * b[4] + a[3] * b[5] + a[5],
+ ];
+};
generated by cgit v1.2.3 (git 2.25.1) at 2026-11-01 15:25:06 +0000