upgrade

1 files changed, 34 insertions, 27 deletions

diff --git a/node_modules/svgo/plugins/convertTransform.js b/node_modules/svgo/plugins/convertTransform.js
index b69e17a3..6f399078 100644
--- a/node_modules/svgo/plugins/convertTransform.js
+++ b/node_modules/svgo/plugins/convertTransform.js
@@ -1,10 +1,12 @@
 'use strict';
 
 /**
+ * @typedef {import('../lib/types').XastChild} XastChild
  * @typedef {import('../lib/types').XastElement} XastElement
+ * @typedef {import('../lib/types').XastParent} XastParent
  */
 
-const { cleanupOutData } = require('../lib/svgo/tools.js');
+const { cleanupOutData, toFixed } = require('../lib/svgo/tools.js');
 const {
   transform2js,
   transformsMultiply,
@@ -59,15 +61,14 @@ exports.fn = (_root, params) => {
   return {
     element: {
       enter: (node) => {
-        // transform
         if (node.attributes.transform != null) {
           convertTransform(node, 'transform', newParams);
         }
-        // gradientTransform
+
         if (node.attributes.gradientTransform != null) {
           convertTransform(node, 'gradientTransform', newParams);
         }
-        // patternTransform
+
         if (node.attributes.patternTransform != null) {
           convertTransform(node, 'patternTransform', newParams);
         }
@@ -94,13 +95,13 @@ exports.fn = (_root, params) => {
  */
 
 /**
- * @typedef {{ name: string, data: Array<number> }} TransformItem
+ * @typedef {{ name: string, data: number[] }} TransformItem
  */
 
 /**
- * Main function.
- *
- * @type {(item: XastElement, attrName: string, params: TransformParams) => void}
+ * @param {XastElement} item
+ * @param {string} attrName
+ * @param {TransformParams} params
  */
 const convertTransform = (item, attrName, params) => {
   let data = transform2js(item.attributes[attrName]);
@@ -134,7 +135,7 @@ const convertTransform = (item, attrName, params) => {
  * degPrecision - for rotate and skew. By default it's equal to (roughly)
  * transformPrecision - 2 or floatPrecision whichever is lower. Can be set in params.
  *
- * @type {(data: Array<TransformItem>, params: TransformParams) => TransformParams}
+ * @type {(data: TransformItem[], params: TransformParams) => TransformParams}
  *
  * clone params so it don't affect other elements transformations.
  */
@@ -145,33 +146,33 @@ const definePrecision = (data, { ...newParams }) => {
       matrixData.push(...item.data.slice(0, 4));
     }
   }
-  let significantDigits = newParams.transformPrecision;
+  let numberOfDigits = newParams.transformPrecision;
   // Limit transform precision with matrix one. Calculating with larger precision doesn't add any value.
   if (matrixData.length) {
     newParams.transformPrecision = Math.min(
       newParams.transformPrecision,
       Math.max.apply(Math, matrixData.map(floatDigits)) ||
-        newParams.transformPrecision
+        newParams.transformPrecision,
     );
-    significantDigits = Math.max.apply(
+    numberOfDigits = Math.max.apply(
       Math,
       matrixData.map(
-        (n) => n.toString().replace(/\D+/g, '').length // Number of digits in a number. 123.45 → 5
-      )
+        (n) => n.toString().replace(/\D+/g, '').length, // Number of digits in a number. 123.45 → 5
+      ),
     );
   }
   // No sense in angle precision more then number of significant digits in matrix.
   if (newParams.degPrecision == null) {
     newParams.degPrecision = Math.max(
       0,
-      Math.min(newParams.floatPrecision, significantDigits - 2)
+      Math.min(newParams.floatPrecision, numberOfDigits - 2),
     );
   }
   return newParams;
 };
 
 /**
- * @type {(data: Array<number>, params: TransformParams) => Array<number>}
+ * @type {(data: number[], params: TransformParams) => number[]}
  */
 const degRound = (data, params) => {
   if (
@@ -185,7 +186,7 @@ const degRound = (data, params) => {
   }
 };
 /**
- * @type {(data: Array<number>, params: TransformParams) => Array<number>}
+ * @type {(data: number[], params: TransformParams) => number[]}
  */
 const floatRound = (data, params) => {
   if (params.floatPrecision >= 1 && params.floatPrecision < 20) {
@@ -196,7 +197,7 @@ const floatRound = (data, params) => {
 };
 
 /**
- * @type {(data: Array<number>, params: TransformParams) => Array<number>}
+ * @type {(data: number[], params: TransformParams) => number[]}
  */
 const transformRound = (data, params) => {
   if (params.transformPrecision >= 1 && params.floatPrecision < 20) {
@@ -219,11 +220,13 @@ const floatDigits = (n) => {
 /**
  * Convert transforms to the shorthand alternatives.
  *
- * @type {(transforms: Array<TransformItem>, params: TransformParams) => Array<TransformItem>}
+ * @param {TransformItem[]} transforms
+ * @param {TransformParams} params
+ * @returns {TransformItem[]}
  */
 const convertToShorts = (transforms, params) => {
   for (var i = 0; i < transforms.length; i++) {
-    var transform = transforms[i];
+    let transform = transforms[i];
 
     // convert matrix to the short aliases
     if (params.matrixToTransform && transform.name === 'matrix') {
@@ -267,8 +270,7 @@ const convertToShorts = (transforms, params) => {
     // translate(cx cy) rotate(a) translate(-cx -cy) → rotate(a cx cy)
     if (
       params.shortRotate &&
-      transforms[i - 2] &&
-      transforms[i - 2].name === 'translate' &&
+      transforms[i - 2]?.name === 'translate' &&
       transforms[i - 1].name === 'rotate' &&
       transforms[i].name === 'translate' &&
       transforms[i - 2].data[0] === -transforms[i].data[0] &&
@@ -294,7 +296,7 @@ const convertToShorts = (transforms, params) => {
 /**
  * Remove useless transforms.
  *
- * @type {(transforms: Array<TransformItem>) => Array<TransformItem>}
+ * @type {(transforms: TransformItem[]) => TransformItem[]}
  */
 const removeUseless = (transforms) => {
   return transforms.filter((transform) => {
@@ -332,7 +334,9 @@ const removeUseless = (transforms) => {
 /**
  * Convert transforms JS representation to string.
  *
- * @type {(transformJS: Array<TransformItem>, params: TransformParams) => string}
+ * @param {TransformItem[]} transformJS
+ * @param {TransformParams} params
+ * @returns {string}
  */
 const js2transform = (transformJS, params) => {
   const transformString = transformJS
@@ -379,7 +383,7 @@ const roundTransform = (transform, params) => {
 /**
  * Rounds numbers in array.
  *
- * @type {(data: Array<number>) => Array<number>}
+ * @type {(data: number[]) => number[]}
  */
 const round = (data) => {
   return data.map(Math.round);
@@ -390,7 +394,9 @@ const round = (data) => {
  * in transforms keeping a specified number of decimals.
  * Smart rounds values like 2.349 to 2.35.
  *
- * @type {(precision: number, data: Array<number>) => Array<number>}
+ * @param {number} precision
+ * @param {number[]} data
+ * @returns {number[]}
  */
 const smartRound = (precision, data) => {
   for (
@@ -399,7 +405,7 @@ const smartRound = (precision, data) => {
     i--;
 
   ) {
-    if (Number(data[i].toFixed(precision)) !== data[i]) {
+    if (toFixed(data[i], precision) !== data[i]) {
       var rounded = +data[i].toFixed(precision - 1);
       data[i] =
         +Math.abs(rounded - data[i]).toFixed(precision + 1) >= tolerance
@@ -407,5 +413,6 @@ const smartRound = (precision, data) => {
           : rounded;
     }
   }
+
   return data;
 };