From 31a8bcd69c3bdc7cc743f3eafffaa212c9737ed3 Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Fri, 1 Dec 2023 16:19:28 -0800
Subject: [PATCH 01/20] Added mergeText plugin.

---
 plugins/mergeText.js          | 306 ++++++++++++++++++++++++++++++++++
 plugins/plugins-types.d.ts    |   1 +
 test/plugins/mergeText.01.svg |  18 ++
 test/plugins/mergeText.02.svg |  18 ++
 test/plugins/mergeText.03.svg |  21 +++
 test/plugins/mergeText.04.svg |  14 ++
 test/plugins/mergeText.05.svg |  13 ++
 test/plugins/mergeText.06.svg |  18 ++
 test/plugins/mergeText.07.svg |  20 +++
 test/plugins/mergeText.08.svg |  17 ++
 10 files changed, 446 insertions(+)
 create mode 100644 plugins/mergeText.js
 create mode 100644 test/plugins/mergeText.01.svg
 create mode 100644 test/plugins/mergeText.02.svg
 create mode 100644 test/plugins/mergeText.03.svg
 create mode 100644 test/plugins/mergeText.04.svg
 create mode 100644 test/plugins/mergeText.05.svg
 create mode 100644 test/plugins/mergeText.06.svg
 create mode 100644 test/plugins/mergeText.07.svg
 create mode 100644 test/plugins/mergeText.08.svg

diff --git a/plugins/mergeText.js b/plugins/mergeText.js
new file mode 100644
index 000000000..c7d202ddc
--- /dev/null
+++ b/plugins/mergeText.js
@@ -0,0 +1,306 @@
+'use strict';
+
+/**
+ * @typedef {import('../lib/types').XastElement} XastElement
+ * @typedef {import('../lib/types').XastChild} XastChild
+ */
+
+exports.name = 'mergeText';
+exports.description = 'merges <text> elements and children where possible';
+
+/**
+ * @typedef {{
+ * x:string,
+ * y:string,
+ * attributes:Map<string,string>,
+ * children:XastChild[]
+ * }} TspanData
+ */
+
+/**
+ * @typedef {{
+ * x:string,
+ * y:string,
+ * children:TspanData[],
+ * }
+ * }TextData
+ */
+
+/**
+ * Merge <text> elements and children where possible, and minimize duplication of attributes.
+ *
+ * @author John Kenny
+ *
+ * @type {import('./plugins-types').Plugin<'mergeText'>}
+ */
+
+exports.fn = () => {
+  let deoptimized = false;
+
+  return {
+    element: {
+      enter: (node) => {
+        // Don't collapse if styles are present.
+        if (node.name === 'style' && node.children.length !== 0) {
+          deoptimized = true;
+        }
+      },
+
+      exit: (node) => {
+        if (deoptimized) {
+          return;
+        }
+
+        // See if the node has <text> children.
+        /** @type Map<number,TextData> */
+        const mergeableChildren = new Map();
+        for (let index = 0; index < node.children.length; index++) {
+          const child = node.children[index];
+          if (child.type === 'element' && child.name === 'text') {
+            const mergeData = getMergeData(child);
+            if (mergeData) {
+              mergeableChildren.set(index, mergeData);
+            }
+          }
+        }
+
+        // If nothing to merge, return.
+        if (mergeableChildren.size === 0) {
+          return;
+        }
+
+        // Create new child nodes.
+        /** @type XastChild[] */
+        const newChildren = [];
+        for (let index = 0; index < node.children.length; index++) {
+          if (!mergeableChildren.has(index)) {
+            // This is not a <text> element; do not process.
+            newChildren.push(node.children[index]);
+            continue;
+          }
+          if (mergeableChildren.has(index - 1)) {
+            // The previous child was a mergeable <text> element; assume this one was already merged into it.
+            continue;
+          }
+          // Merge and insert text elements.
+          newChildren.push(mergeTextElements(mergeableChildren, index));
+        }
+
+        // Update children.
+        node.children = newChildren;
+      },
+    },
+  };
+};
+
+/**
+ *
+ * @param {XastElement} textEl
+ * @returns {any}
+ */
+function getMergeData(textEl) {
+  /**@type TextData   */
+  const data = {};
+  /**@type Map<string,string> */
+  const textAttributes = new Map();
+  data.children = [];
+
+  // Gather all <text> attributes.
+  for (const [k, v] of Object.entries(textEl.attributes)) {
+    switch (k) {
+      case 'x':
+      case 'y':
+        data[k] = v;
+        break;
+      default:
+        textAttributes.set(k, v);
+        break;
+    }
+  }
+
+  // Check all children of <text> element.
+  for (const child of textEl.children) {
+    if (child.type === 'text') {
+      if (isWhiteSpace(child.value)) {
+        // Ignore nodes that are all whitespace.
+        continue;
+      }
+    }
+    if (child.type !== 'element' || child.name !== 'tspan') {
+      // Don't transform unless all children are <tspan> elements.
+      return;
+    }
+    for (const tspanChild of child.children) {
+      // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
+      if (tspanChild.type === 'text') {
+        continue;
+      }
+      if (tspanChild.type === 'element' && tspanChild.name === 'tspan') {
+        continue;
+      }
+      return;
+    }
+
+    /** @type TspanData     */
+    const tspanData = {};
+
+    // Copy all <text> attributes to the tspan data.
+    tspanData.attributes = new Map(textAttributes);
+
+    // Merge all <tspan> attributes.
+    for (const [k, v] of Object.entries(child.attributes)) {
+      switch (k) {
+        case 'x':
+        case 'y':
+          tspanData[k] = v;
+          break;
+        case 'color':
+        case 'fill':
+        case 'fill-opacity':
+        case 'fill-rule':
+        case 'opacity':
+        case 'stroke':
+        case 'stroke-dasharray':
+        case 'stroke-dashoffset':
+        case 'stroke-linecap':
+        case 'stroke-linejoin':
+        case 'stroke-miterlimit':
+        case 'stroke-opacity':
+        case 'stroke-width':
+          tspanData.attributes.set(k, v);
+          break;
+        default:
+          // Don't transform if <tspan> has unrecognized attributes.
+          return;
+      }
+    }
+
+    // Don't transform unless all children have x and y attributes.
+    if (!tspanData.x || !tspanData.y) {
+      return;
+    }
+
+    tspanData.children = child.children;
+
+    data.children.push(tspanData);
+  }
+
+  return data;
+}
+
+/**
+ *
+ * @param {TspanData[]} tspans
+ * @returns {{}}
+ */
+function getTextAttributes(tspans) {
+  // Figure out what attributes and values we have.
+  const allAttributes = new Map();
+  for (const tspanElement of tspans) {
+    for (const [attName, attValue] of tspanElement.attributes) {
+      let values = allAttributes.get(attName);
+      if (!values) {
+        values = new Map();
+        allAttributes.set(attName, values);
+      }
+      if (!values.has(attValue)) {
+        values.set(attValue, 1);
+      } else {
+        values.set(attValue, values.get(attValue) + 1);
+      }
+    }
+  }
+
+  // Figure out which ones to use as <text> attributes.
+  /** @type Object.<string,string> */
+  const textAttributes = {};
+  for (const [attName, values] of allAttributes) {
+    // Check all values. If there are fewer values than children, at least one child does not have the attribute;
+    // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
+    let total = 0;
+    let maxCount = 0;
+    let textAttValue;
+    for (const [value, count] of values) {
+      total += count;
+      if (count > maxCount) {
+        maxCount = count;
+        textAttValue = value;
+      }
+    }
+    if (total === tspans.length && textAttValue) {
+      textAttributes[attName] = textAttValue;
+    }
+  }
+
+  return textAttributes;
+}
+
+/**
+ * @param {string} s
+ * @returns {boolean}
+ */
+function isWhiteSpace(s) {
+  return /^\s*$/.test(s);
+}
+
+/**
+ *
+ * @param {Map<number,TextData>} mergeableChildren
+ * @param {number} index
+ * @returns XastElement
+ */
+function mergeTextElements(mergeableChildren, index) {
+  /** @type {XastElement} */
+  const textElement = {
+    type: 'element',
+    name: 'text',
+    attributes: {},
+    children: [],
+  };
+
+  //   Find all child data.
+  const tspans = [];
+  for (; ; index++) {
+    const textData = mergeableChildren.get(index);
+    if (!textData) {
+      break;
+    }
+    tspans.push(...textData.children);
+  }
+
+  // Find the default attributes for the <text> element.
+  textElement.attributes = getTextAttributes(tspans);
+
+  // If there is only one <tspan>, merge content into <text>.
+  if (tspans.length === 1) {
+    const tspanData = tspans[0];
+    textElement.attributes.x = tspanData.x;
+    textElement.attributes.y = tspanData.y;
+    textElement.children = tspanData.children;
+    return textElement;
+  }
+
+  // Generate <tspan> elements.
+  const textChildren = [];
+  for (const tspanData of tspans) {
+    /** @type {XastElement} */
+    const tspanElement = {
+      type: 'element',
+      name: 'tspan',
+      attributes: { x: tspanData.x, y: tspanData.y },
+      children: tspanData.children,
+    };
+
+    // Add any attributes that are different from <text> attributes.
+    for (const [k, v] of tspanData.attributes) {
+      if (textElement.attributes[k] !== v) {
+        tspanElement.attributes[k] = v;
+      }
+    }
+
+    textChildren.push(tspanElement);
+  }
+
+  textElement.children = textChildren;
+  return textElement;
+}
diff --git a/plugins/plugins-types.d.ts b/plugins/plugins-types.d.ts
index 8e3972c1c..3a114689d 100644
--- a/plugins/plugins-types.d.ts
+++ b/plugins/plugins-types.d.ts
@@ -136,6 +136,7 @@ type DefaultPlugins = {
         };
   };
 
+  mergeText:void;
   moveElemsAttrsToGroup: void;
   moveGroupAttrsToElems: void;
   removeComments: {
diff --git a/test/plugins/mergeText.01.svg b/test/plugins/mergeText.01.svg
new file mode 100644
index 000000000..8da31fbef
--- /dev/null
+++ b/test/plugins/mergeText.01.svg
@@ -0,0 +1,18 @@
+Combine adjacent<text> elements.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <text xml:space="preserve" x="45.869" y="38.606" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="45.869" y="38.606">Part one</tspan>
+    </text>
+    <text xml:space="preserve" x="87.151" y="89.826" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="87.151" y="89.826">Part two</tspan>
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <text xml:space="preserve" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35"><tspan x="45.869" y="38.606">Part one</tspan><tspan x="87.151" y="89.826">Part two</tspan></text>
+</svg>
diff --git a/test/plugins/mergeText.02.svg b/test/plugins/mergeText.02.svg
new file mode 100644
index 000000000..1ae4c47ee
--- /dev/null
+++ b/test/plugins/mergeText.02.svg
@@ -0,0 +1,18 @@
+Combine adjacent<text> elements.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <text>
+        <tspan x="45.869" y="38.606" fill="red">Part one</tspan>
+    </text>
+    <text>
+        <tspan x="87.151" y="89.826" fill="green" stroke-width=".5">Part two</tspan>
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <text fill="red"><tspan x="45.869" y="38.606">Part one</tspan><tspan x="87.151" y="89.826" fill="green" stroke-width=".5">Part two</tspan></text>
+</svg>
diff --git a/test/plugins/mergeText.03.svg b/test/plugins/mergeText.03.svg
new file mode 100644
index 000000000..63d6a3fcb
--- /dev/null
+++ b/test/plugins/mergeText.03.svg
@@ -0,0 +1,21 @@
+Don't merge elements with text node children.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 210 120">
+    <text xml:space="preserve" x="45.869" y="38.606" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="45.869" y="38.606">  Part one</tspan>
+    </text>
+    <text xml:space="preserve" x="87.151" y="89.826" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+    xxx<tspan x="87.151" y="89.826">Part two</tspan>ooo
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 210 120">
+    <text xml:space="preserve" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35" x="45.869" y="38.606">  Part one</text>
+    <text xml:space="preserve" x="87.151" y="89.826" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+    xxx<tspan x="87.151" y="89.826">Part two</tspan>ooo
+    </text>
+</svg>
diff --git a/test/plugins/mergeText.04.svg b/test/plugins/mergeText.04.svg
new file mode 100644
index 000000000..76395f96d
--- /dev/null
+++ b/test/plugins/mergeText.04.svg
@@ -0,0 +1,14 @@
+Collapse single <tspan> child of <text>
+
+===
+
+<svg version="1.1" viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
+    <text x="64" y="64" fill="none" font-family="Arial" font-size="8px" letter-spacing=".5px"
+        stroke="#000000" xml:space="preserve"><tspan x="64" y="64">this is a test</tspan></text>
+</svg>
+
+@@@
+
+<svg version="1.1" viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
+    <text fill="none" font-family="Arial" font-size="8px" letter-spacing=".5px" stroke="#000000" xml:space="preserve" x="64" y="64">this is a test</text>
+</svg>
diff --git a/test/plugins/mergeText.05.svg b/test/plugins/mergeText.05.svg
new file mode 100644
index 000000000..f8a3d97ac
--- /dev/null
+++ b/test/plugins/mergeText.05.svg
@@ -0,0 +1,13 @@
+Collapse single <tspan> child of <text>, where single <tspan> has multiple children.
+
+===
+
+<svg width="210mm" height="297mm" version="1.1" viewBox="0 0 210 297" xmlns="http://www.w3.org/2000/svg">
+ <text x="56.571426" y="93.266411" fill="#0000ff" font-size="3.175px" stroke-width=".26458" xml:space="preserve"><tspan x="56.571426" y="93.266411" stroke-width=".26458">This is <tspan font-family="Arial" font-weight="bold">some</tspan> <tspan fill="#ff0000">text</tspan></tspan></text>
+</svg>
+
+@@@
+
+<svg width="210mm" height="297mm" version="1.1" viewBox="0 0 210 297" xmlns="http://www.w3.org/2000/svg">
+    <text fill="#0000ff" font-size="3.175px" stroke-width=".26458" xml:space="preserve" x="56.571426" y="93.266411">This is <tspan font-family="Arial" font-weight="bold">some</tspan> <tspan fill="#ff0000">text</tspan></text>
+</svg>
diff --git a/test/plugins/mergeText.06.svg b/test/plugins/mergeText.06.svg
new file mode 100644
index 000000000..92e8a9424
--- /dev/null
+++ b/test/plugins/mergeText.06.svg
@@ -0,0 +1,18 @@
+Do not collapse if styles are present.
+
+===
+
+<svg version="1.1" viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
+    <text x="64" y="64" fill="none" font-family="Arial" font-size="8px" letter-spacing=".5px"
+        stroke="#000000" xml:space="preserve"><tspan  x="64" y="64">this is a test</tspan></text>
+		<style>tspan { stroke:red;}</style>
+</svg>
+
+@@@
+
+<svg version="1.1" viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
+    <text x="64" y="64" fill="none" font-family="Arial" font-size="8px" letter-spacing=".5px" stroke="#000000" xml:space="preserve"><tspan x="64" y="64">this is a test</tspan></text>
+    <style>
+        tspan { stroke:red;}
+    </style>
+</svg>
diff --git a/test/plugins/mergeText.07.svg b/test/plugins/mergeText.07.svg
new file mode 100644
index 000000000..0b2284a19
--- /dev/null
+++ b/test/plugins/mergeText.07.svg
@@ -0,0 +1,20 @@
+Do not collapse if <textPath> present.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg"
+    xmlns:xlink="http://www.w3.org/1999/xlink" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <path id="a" fill="none" stroke="#000" stroke-opacity="1" stroke-width=".265" d="M21.788 147.927s129.197-188.062 144.868-1.53"/>
+    <text xml:space="preserve" fill="none" stroke="#000" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <textPath xlink:href="#a"><tspan fill="#f40b0b" font-size="11.289" font-weight="400">this is a test</tspan></textPath>
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <path id="a" fill="none" stroke="#000" stroke-opacity="1" stroke-width=".265" d="M21.788 147.927s129.197-188.062 144.868-1.53"/>
+    <text xml:space="preserve" fill="none" stroke="#000" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <textPath xlink:href="#a"><tspan fill="#f40b0b" font-size="11.289" font-weight="400">this is a test</tspan></textPath>
+    </text>
+</svg>
diff --git a/test/plugins/mergeText.08.svg b/test/plugins/mergeText.08.svg
new file mode 100644
index 000000000..2feb9474f
--- /dev/null
+++ b/test/plugins/mergeText.08.svg
@@ -0,0 +1,17 @@
+Don't merge elements with <title> children.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 210 120">
+    <text xml:space="preserve" x="45.869" y="38.606" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="45.869" y="38.606"><title>xxx</title>Part one</tspan>
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 210 120">
+    <text xml:space="preserve" x="45.869" y="38.606" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="45.869" y="38.606"><title>xxx</title>Part one</tspan>
+    </text>
+</svg>

From 45a62884ba2e7cc3df6ef227c85d54adaf862f08 Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Fri, 1 Dec 2023 16:23:43 -0800
Subject: [PATCH 02/20] Added mergeText plugin to builtin.js.

---
 lib/builtin.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/builtin.js b/lib/builtin.js
index 28a380ec9..1ab975bef 100644
--- a/lib/builtin.js
+++ b/lib/builtin.js
@@ -20,6 +20,7 @@ exports.builtin = [
   require('../plugins/mergeStyles.js'),
   require('../plugins/inlineStyles.js'),
   require('../plugins/mergePaths.js'),
+  require('../plugins/mergeText.js'),
   require('../plugins/minifyStyles.js'),
   require('../plugins/moveElemsAttrsToGroup.js'),
   require('../plugins/moveGroupAttrsToElems.js'),

From c379a5f66cefd18dafe7b12704d50aeceb79c783 Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Sun, 24 Dec 2023 10:37:30 -0800
Subject: [PATCH 03/20] Changed to use inheritableAttrs from collections.js.

---
 plugins/mergeText.js | 441 +++++++++++++++++++++----------------------
 1 file changed, 216 insertions(+), 225 deletions(-)

diff --git a/plugins/mergeText.js b/plugins/mergeText.js
index c7d202ddc..bbe0766a0 100644
--- a/plugins/mergeText.js
+++ b/plugins/mergeText.js
@@ -1,5 +1,7 @@
 'use strict';
 
+const { inheritableAttrs } = require( './_collections' );
+
 /**
  * @typedef {import('../lib/types').XastElement} XastElement
  * @typedef {import('../lib/types').XastChild} XastChild
@@ -35,62 +37,62 @@ exports.description = 'merges <text> elements and children where possible';
  */
 
 exports.fn = () => {
-  let deoptimized = false;
-
-  return {
-    element: {
-      enter: (node) => {
-        // Don't collapse if styles are present.
-        if (node.name === 'style' && node.children.length !== 0) {
-          deoptimized = true;
-        }
-      },
-
-      exit: (node) => {
-        if (deoptimized) {
-          return;
-        }
-
-        // See if the node has <text> children.
-        /** @type Map<number,TextData> */
-        const mergeableChildren = new Map();
-        for (let index = 0; index < node.children.length; index++) {
-          const child = node.children[index];
-          if (child.type === 'element' && child.name === 'text') {
-            const mergeData = getMergeData(child);
-            if (mergeData) {
-              mergeableChildren.set(index, mergeData);
-            }
-          }
-        }
-
-        // If nothing to merge, return.
-        if (mergeableChildren.size === 0) {
-          return;
-        }
-
-        // Create new child nodes.
-        /** @type XastChild[] */
-        const newChildren = [];
-        for (let index = 0; index < node.children.length; index++) {
-          if (!mergeableChildren.has(index)) {
-            // This is not a <text> element; do not process.
-            newChildren.push(node.children[index]);
-            continue;
-          }
-          if (mergeableChildren.has(index - 1)) {
-            // The previous child was a mergeable <text> element; assume this one was already merged into it.
-            continue;
-          }
-          // Merge and insert text elements.
-          newChildren.push(mergeTextElements(mergeableChildren, index));
-        }
-
-        // Update children.
-        node.children = newChildren;
-      },
-    },
-  };
+    let deoptimized = false;
+
+    return {
+        element: {
+            enter: ( node ) => {
+                // Don't collapse if styles are present.
+                if ( node.name === 'style' && node.children.length !== 0 ) {
+                    deoptimized = true;
+                }
+            },
+
+            exit: ( node ) => {
+                if ( deoptimized ) {
+                    return;
+                }
+
+                // See if the node has <text> children.
+                /** @type Map<number,TextData> */
+                const mergeableChildren = new Map();
+                for ( let index = 0; index < node.children.length; index++ ) {
+                    const child = node.children[ index ];
+                    if ( child.type === 'element' && child.name === 'text' ) {
+                        const mergeData = getMergeData( child );
+                        if ( mergeData ) {
+                            mergeableChildren.set( index, mergeData );
+                        }
+                    }
+                }
+
+                // If nothing to merge, return.
+                if ( mergeableChildren.size === 0 ) {
+                    return;
+                }
+
+                // Create new child nodes.
+                /** @type XastChild[] */
+                const newChildren = [];
+                for ( let index = 0; index < node.children.length; index++ ) {
+                    if ( !mergeableChildren.has( index ) ) {
+                        // This is not a <text> element; do not process.
+                        newChildren.push( node.children[ index ] );
+                        continue;
+                    }
+                    if ( mergeableChildren.has( index - 1 ) ) {
+                        // The previous child was a mergeable <text> element; assume this one was already merged into it.
+                        continue;
+                    }
+                    // Merge and insert text elements.
+                    newChildren.push( mergeTextElements( mergeableChildren, index ) );
+                }
+
+                // Update children.
+                node.children = newChildren;
+            },
+        },
+    };
 };
 
 /**
@@ -98,94 +100,83 @@ exports.fn = () => {
  * @param {XastElement} textEl
  * @returns {any}
  */
-function getMergeData(textEl) {
-  /**@type TextData   */
-  const data = {};
-  /**@type Map<string,string> */
-  const textAttributes = new Map();
-  data.children = [];
-
-  // Gather all <text> attributes.
-  for (const [k, v] of Object.entries(textEl.attributes)) {
-    switch (k) {
-      case 'x':
-      case 'y':
-        data[k] = v;
-        break;
-      default:
-        textAttributes.set(k, v);
-        break;
-    }
-  }
-
-  // Check all children of <text> element.
-  for (const child of textEl.children) {
-    if (child.type === 'text') {
-      if (isWhiteSpace(child.value)) {
-        // Ignore nodes that are all whitespace.
-        continue;
-      }
-    }
-    if (child.type !== 'element' || child.name !== 'tspan') {
-      // Don't transform unless all children are <tspan> elements.
-      return;
-    }
-    for (const tspanChild of child.children) {
-      // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
-      if (tspanChild.type === 'text') {
-        continue;
-      }
-      if (tspanChild.type === 'element' && tspanChild.name === 'tspan') {
-        continue;
-      }
-      return;
+function getMergeData( textEl ) {
+    /**@type TextData   */
+    const data = {};
+    /**@type Map<string,string> */
+    const textAttributes = new Map();
+    data.children = [];
+
+    // Gather all <text> attributes.
+    for ( const [ k, v ] of Object.entries( textEl.attributes ) ) {
+        switch ( k ) {
+            case 'x':
+            case 'y':
+                data[ k ] = v;
+                break;
+            default:
+                textAttributes.set( k, v );
+                break;
+        }
     }
 
-    /** @type TspanData     */
-    const tspanData = {};
-
-    // Copy all <text> attributes to the tspan data.
-    tspanData.attributes = new Map(textAttributes);
-
-    // Merge all <tspan> attributes.
-    for (const [k, v] of Object.entries(child.attributes)) {
-      switch (k) {
-        case 'x':
-        case 'y':
-          tspanData[k] = v;
-          break;
-        case 'color':
-        case 'fill':
-        case 'fill-opacity':
-        case 'fill-rule':
-        case 'opacity':
-        case 'stroke':
-        case 'stroke-dasharray':
-        case 'stroke-dashoffset':
-        case 'stroke-linecap':
-        case 'stroke-linejoin':
-        case 'stroke-miterlimit':
-        case 'stroke-opacity':
-        case 'stroke-width':
-          tspanData.attributes.set(k, v);
-          break;
-        default:
-          // Don't transform if <tspan> has unrecognized attributes.
-          return;
-      }
-    }
+    // Check all children of <text> element.
+    for ( const child of textEl.children ) {
+        if ( child.type === 'text' ) {
+            if ( isWhiteSpace( child.value ) ) {
+                // Ignore nodes that are all whitespace.
+                continue;
+            }
+        }
+        if ( child.type !== 'element' || child.name !== 'tspan' ) {
+            // Don't transform unless all children are <tspan> elements.
+            return;
+        }
+        for ( const tspanChild of child.children ) {
+            // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
+            if ( tspanChild.type === 'text' ) {
+                continue;
+            }
+            if ( tspanChild.type === 'element' && tspanChild.name === 'tspan' ) {
+                continue;
+            }
+            return;
+        }
 
-    // Don't transform unless all children have x and y attributes.
-    if (!tspanData.x || !tspanData.y) {
-      return;
-    }
+        /** @type TspanData     */
+        const tspanData = {};
+
+        // Copy all <text> attributes to the tspan data.
+        tspanData.attributes = new Map( textAttributes );
+
+        // Merge all <tspan> attributes.
+        for ( const [ k, v ] of Object.entries( child.attributes ) ) {
+            switch ( k ) {
+                case 'x':
+                case 'y':
+                    tspanData[ k ] = v;
+                    break;
+                default:
+                    if ( !inheritableAttrs.includes( k ) ) {
+                        // Don't transform if <tspan> has unrecognized attributes.
+                        return;
+                    }
+                    tspanData.attributes.set( k, v );
+                    break;
+            }
+        }
 
-    tspanData.children = child.children;
+        // Don't transform unless all children have x and y attributes.
+        if ( !tspanData.x || !tspanData.y ) {
+            return;
+        }
 
-    data.children.push(tspanData);
-  }
+        tspanData.children = child.children;
 
-  return data;
+        data.children.push( tspanData );
+    }
+
+    return data;
 }
 
 /**
@@ -193,54 +184,54 @@ function getMergeData(textEl) {
  * @param {TspanData[]} tspans
  * @returns {{}}
  */
-function getTextAttributes(tspans) {
-  // Figure out what attributes and values we have.
-  const allAttributes = new Map();
-  for (const tspanElement of tspans) {
-    for (const [attName, attValue] of tspanElement.attributes) {
-      let values = allAttributes.get(attName);
-      if (!values) {
-        values = new Map();
-        allAttributes.set(attName, values);
-      }
-      if (!values.has(attValue)) {
-        values.set(attValue, 1);
-      } else {
-        values.set(attValue, values.get(attValue) + 1);
-      }
-    }
-  }
-
-  // Figure out which ones to use as <text> attributes.
-  /** @type Object.<string,string> */
-  const textAttributes = {};
-  for (const [attName, values] of allAttributes) {
-    // Check all values. If there are fewer values than children, at least one child does not have the attribute;
-    // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
-    let total = 0;
-    let maxCount = 0;
-    let textAttValue;
-    for (const [value, count] of values) {
-      total += count;
-      if (count > maxCount) {
-        maxCount = count;
-        textAttValue = value;
-      }
+function getTextAttributes( tspans ) {
+    // Figure out what attributes and values we have.
+    const allAttributes = new Map();
+    for ( const tspanElement of tspans ) {
+        for ( const [ attName, attValue ] of tspanElement.attributes ) {
+            let values = allAttributes.get( attName );
+            if ( !values ) {
+                values = new Map();
+                allAttributes.set( attName, values );
+            }
+            if ( !values.has( attValue ) ) {
+                values.set( attValue, 1 );
+            } else {
+                values.set( attValue, values.get( attValue ) + 1 );
+            }
+        }
     }
-    if (total === tspans.length && textAttValue) {
-      textAttributes[attName] = textAttValue;
+
+    // Figure out which ones to use as <text> attributes.
+    /** @type Object.<string,string> */
+    const textAttributes = {};
+    for ( const [ attName, values ] of allAttributes ) {
+        // Check all values. If there are fewer values than children, at least one child does not have the attribute;
+        // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
+        let total = 0;
+        let maxCount = 0;
+        let textAttValue;
+        for ( const [ value, count ] of values ) {
+            total += count;
+            if ( count > maxCount ) {
+                maxCount = count;
+                textAttValue = value;
+            }
+        }
+        if ( total === tspans.length && textAttValue ) {
+            textAttributes[ attName ] = textAttValue;
+        }
     }
-  }
 
-  return textAttributes;
+    return textAttributes;
 }
 
 /**
  * @param {string} s
  * @returns {boolean}
  */
-function isWhiteSpace(s) {
-  return /^\s*$/.test(s);
+function isWhiteSpace( s ) {
+    return /^\s*$/.test( s );
 }
 
 /**
@@ -249,58 +240,58 @@ function isWhiteSpace(s) {
  * @param {number} index
  * @returns XastElement
  */
-function mergeTextElements(mergeableChildren, index) {
-  /** @type {XastElement} */
-  const textElement = {
-    type: 'element',
-    name: 'text',
-    attributes: {},
-    children: [],
-  };
-
-  //   Find all child data.
-  const tspans = [];
-  for (; ; index++) {
-    const textData = mergeableChildren.get(index);
-    if (!textData) {
-      break;
-    }
-    tspans.push(...textData.children);
-  }
-
-  // Find the default attributes for the <text> element.
-  textElement.attributes = getTextAttributes(tspans);
-
-  // If there is only one <tspan>, merge content into <text>.
-  if (tspans.length === 1) {
-    const tspanData = tspans[0];
-    textElement.attributes.x = tspanData.x;
-    textElement.attributes.y = tspanData.y;
-    textElement.children = tspanData.children;
-    return textElement;
-  }
-
-  // Generate <tspan> elements.
-  const textChildren = [];
-  for (const tspanData of tspans) {
+function mergeTextElements( mergeableChildren, index ) {
     /** @type {XastElement} */
-    const tspanElement = {
-      type: 'element',
-      name: 'tspan',
-      attributes: { x: tspanData.x, y: tspanData.y },
-      children: tspanData.children,
+    const textElement = {
+        type: 'element',
+        name: 'text',
+        attributes: {},
+        children: [],
     };
 
-    // Add any attributes that are different from <text> attributes.
-    for (const [k, v] of tspanData.attributes) {
-      if (textElement.attributes[k] !== v) {
-        tspanElement.attributes[k] = v;
-      }
+    //   Find all child data.
+    const tspans = [];
+    for ( ; ; index++ ) {
+        const textData = mergeableChildren.get( index );
+        if ( !textData ) {
+            break;
+        }
+        tspans.push( ...textData.children );
+    }
+
+    // Find the default attributes for the <text> element.
+    textElement.attributes = getTextAttributes( tspans );
+
+    // If there is only one <tspan>, merge content into <text>.
+    if ( tspans.length === 1 ) {
+        const tspanData = tspans[ 0 ];
+        textElement.attributes.x = tspanData.x;
+        textElement.attributes.y = tspanData.y;
+        textElement.children = tspanData.children;
+        return textElement;
     }
 
-    textChildren.push(tspanElement);
-  }
+    // Generate <tspan> elements.
+    const textChildren = [];
+    for ( const tspanData of tspans ) {
+        /** @type {XastElement} */
+        const tspanElement = {
+            type: 'element',
+            name: 'tspan',
+            attributes: { x: tspanData.x, y: tspanData.y },
+            children: tspanData.children,
+        };
+
+        // Add any attributes that are different from <text> attributes.
+        for ( const [ k, v ] of tspanData.attributes ) {
+            if ( textElement.attributes[ k ] !== v ) {
+                tspanElement.attributes[ k ] = v;
+            }
+        }
+
+        textChildren.push( tspanElement );
+    }
 
-  textElement.children = textChildren;
-  return textElement;
+    textElement.children = textChildren;
+    return textElement;
 }

From f72ff44698f7af95b66bfc6aa6b2e393fb1a22ab Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Mon, 25 Dec 2023 08:34:10 -0800
Subject: [PATCH 04/20] Fixed formatting.

---
 plugins/mergeText.js       | 428 ++++++++++++++++++-------------------
 plugins/plugins-types.d.ts |   2 +-
 2 files changed, 215 insertions(+), 215 deletions(-)

diff --git a/plugins/mergeText.js b/plugins/mergeText.js
index bbe0766a0..9af46fde5 100644
--- a/plugins/mergeText.js
+++ b/plugins/mergeText.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const { inheritableAttrs } = require( './_collections' );
+const { inheritableAttrs } = require('./_collections');
 
 /**
  * @typedef {import('../lib/types').XastElement} XastElement
@@ -37,62 +37,62 @@ exports.description = 'merges <text> elements and children where possible';
  */
 
 exports.fn = () => {
-    let deoptimized = false;
-
-    return {
-        element: {
-            enter: ( node ) => {
-                // Don't collapse if styles are present.
-                if ( node.name === 'style' && node.children.length !== 0 ) {
-                    deoptimized = true;
-                }
-            },
-
-            exit: ( node ) => {
-                if ( deoptimized ) {
-                    return;
-                }
-
-                // See if the node has <text> children.
-                /** @type Map<number,TextData> */
-                const mergeableChildren = new Map();
-                for ( let index = 0; index < node.children.length; index++ ) {
-                    const child = node.children[ index ];
-                    if ( child.type === 'element' && child.name === 'text' ) {
-                        const mergeData = getMergeData( child );
-                        if ( mergeData ) {
-                            mergeableChildren.set( index, mergeData );
-                        }
-                    }
-                }
-
-                // If nothing to merge, return.
-                if ( mergeableChildren.size === 0 ) {
-                    return;
-                }
-
-                // Create new child nodes.
-                /** @type XastChild[] */
-                const newChildren = [];
-                for ( let index = 0; index < node.children.length; index++ ) {
-                    if ( !mergeableChildren.has( index ) ) {
-                        // This is not a <text> element; do not process.
-                        newChildren.push( node.children[ index ] );
-                        continue;
-                    }
-                    if ( mergeableChildren.has( index - 1 ) ) {
-                        // The previous child was a mergeable <text> element; assume this one was already merged into it.
-                        continue;
-                    }
-                    // Merge and insert text elements.
-                    newChildren.push( mergeTextElements( mergeableChildren, index ) );
-                }
-
-                // Update children.
-                node.children = newChildren;
-            },
-        },
-    };
+  let deoptimized = false;
+
+  return {
+    element: {
+      enter: (node) => {
+        // Don't collapse if styles are present.
+        if (node.name === 'style' && node.children.length !== 0) {
+          deoptimized = true;
+        }
+      },
+
+      exit: (node) => {
+        if (deoptimized) {
+          return;
+        }
+
+        // See if the node has <text> children.
+        /** @type Map<number,TextData> */
+        const mergeableChildren = new Map();
+        for (let index = 0; index < node.children.length; index++) {
+          const child = node.children[index];
+          if (child.type === 'element' && child.name === 'text') {
+            const mergeData = getMergeData(child);
+            if (mergeData) {
+              mergeableChildren.set(index, mergeData);
+            }
+          }
+        }
+
+        // If nothing to merge, return.
+        if (mergeableChildren.size === 0) {
+          return;
+        }
+
+        // Create new child nodes.
+        /** @type XastChild[] */
+        const newChildren = [];
+        for (let index = 0; index < node.children.length; index++) {
+          if (!mergeableChildren.has(index)) {
+            // This is not a <text> element; do not process.
+            newChildren.push(node.children[index]);
+            continue;
+          }
+          if (mergeableChildren.has(index - 1)) {
+            // The previous child was a mergeable <text> element; assume this one was already merged into it.
+            continue;
+          }
+          // Merge and insert text elements.
+          newChildren.push(mergeTextElements(mergeableChildren, index));
+        }
+
+        // Update children.
+        node.children = newChildren;
+      },
+    },
+  };
 };
 
 /**
@@ -100,83 +100,83 @@ exports.fn = () => {
  * @param {XastElement} textEl
  * @returns {any}
  */
-function getMergeData( textEl ) {
-    /**@type TextData   */
-    const data = {};
-    /**@type Map<string,string> */
-    const textAttributes = new Map();
-    data.children = [];
-
-    // Gather all <text> attributes.
-    for ( const [ k, v ] of Object.entries( textEl.attributes ) ) {
-        switch ( k ) {
-            case 'x':
-            case 'y':
-                data[ k ] = v;
-                break;
-            default:
-                textAttributes.set( k, v );
-                break;
-        }
+function getMergeData(textEl) {
+  /**@type TextData   */
+  const data = {};
+  /**@type Map<string,string> */
+  const textAttributes = new Map();
+  data.children = [];
+
+  // Gather all <text> attributes.
+  for (const [k, v] of Object.entries(textEl.attributes)) {
+    switch (k) {
+      case 'x':
+      case 'y':
+        data[k] = v;
+        break;
+      default:
+        textAttributes.set(k, v);
+        break;
+    }
+  }
+
+  // Check all children of <text> element.
+  for (const child of textEl.children) {
+    if (child.type === 'text') {
+      if (isWhiteSpace(child.value)) {
+        // Ignore nodes that are all whitespace.
+        continue;
+      }
+    }
+    if (child.type !== 'element' || child.name !== 'tspan') {
+      // Don't transform unless all children are <tspan> elements.
+      return;
+    }
+    for (const tspanChild of child.children) {
+      // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
+      if (tspanChild.type === 'text') {
+        continue;
+      }
+      if (tspanChild.type === 'element' && tspanChild.name === 'tspan') {
+        continue;
+      }
+      return;
     }
 
-    // Check all children of <text> element.
-    for ( const child of textEl.children ) {
-        if ( child.type === 'text' ) {
-            if ( isWhiteSpace( child.value ) ) {
-                // Ignore nodes that are all whitespace.
-                continue;
-            }
-        }
-        if ( child.type !== 'element' || child.name !== 'tspan' ) {
-            // Don't transform unless all children are <tspan> elements.
+    /** @type TspanData     */
+    const tspanData = {};
+
+    // Copy all <text> attributes to the tspan data.
+    tspanData.attributes = new Map(textAttributes);
+
+    // Merge all <tspan> attributes.
+    for (const [k, v] of Object.entries(child.attributes)) {
+      switch (k) {
+        case 'x':
+        case 'y':
+          tspanData[k] = v;
+          break;
+        default:
+          if (!inheritableAttrs.includes(k)) {
+            // Don't transform if <tspan> has unrecognized attributes.
             return;
-        }
-        for ( const tspanChild of child.children ) {
-            // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
-            if ( tspanChild.type === 'text' ) {
-                continue;
-            }
-            if ( tspanChild.type === 'element' && tspanChild.name === 'tspan' ) {
-                continue;
-            }
-            return;
-        }
-
-        /** @type TspanData     */
-        const tspanData = {};
-
-        // Copy all <text> attributes to the tspan data.
-        tspanData.attributes = new Map( textAttributes );
-
-        // Merge all <tspan> attributes.
-        for ( const [ k, v ] of Object.entries( child.attributes ) ) {
-            switch ( k ) {
-                case 'x':
-                case 'y':
-                    tspanData[ k ] = v;
-                    break;
-                default:
-                    if ( !inheritableAttrs.includes( k ) ) {
-                        // Don't transform if <tspan> has unrecognized attributes.
-                        return;
-                    }
-                    tspanData.attributes.set( k, v );
-                    break;
-            }
-        }
+          }
+          tspanData.attributes.set(k, v);
+          break;
+      }
+    }
 
-        // Don't transform unless all children have x and y attributes.
-        if ( !tspanData.x || !tspanData.y ) {
-            return;
-        }
+    // Don't transform unless all children have x and y attributes.
+    if (!tspanData.x || !tspanData.y) {
+      return;
+    }
 
-        tspanData.children = child.children;
+    tspanData.children = child.children;
 
-        data.children.push( tspanData );
-    }
+    data.children.push(tspanData);
+  }
 
-    return data;
+  return data;
 }
 
 /**
@@ -184,54 +184,54 @@ function getMergeData( textEl ) {
  * @param {TspanData[]} tspans
  * @returns {{}}
  */
-function getTextAttributes( tspans ) {
-    // Figure out what attributes and values we have.
-    const allAttributes = new Map();
-    for ( const tspanElement of tspans ) {
-        for ( const [ attName, attValue ] of tspanElement.attributes ) {
-            let values = allAttributes.get( attName );
-            if ( !values ) {
-                values = new Map();
-                allAttributes.set( attName, values );
-            }
-            if ( !values.has( attValue ) ) {
-                values.set( attValue, 1 );
-            } else {
-                values.set( attValue, values.get( attValue ) + 1 );
-            }
-        }
+function getTextAttributes(tspans) {
+  // Figure out what attributes and values we have.
+  const allAttributes = new Map();
+  for (const tspanElement of tspans) {
+    for (const [attName, attValue] of tspanElement.attributes) {
+      let values = allAttributes.get(attName);
+      if (!values) {
+        values = new Map();
+        allAttributes.set(attName, values);
+      }
+      if (!values.has(attValue)) {
+        values.set(attValue, 1);
+      } else {
+        values.set(attValue, values.get(attValue) + 1);
+      }
     }
-
-    // Figure out which ones to use as <text> attributes.
-    /** @type Object.<string,string> */
-    const textAttributes = {};
-    for ( const [ attName, values ] of allAttributes ) {
-        // Check all values. If there are fewer values than children, at least one child does not have the attribute;
-        // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
-        let total = 0;
-        let maxCount = 0;
-        let textAttValue;
-        for ( const [ value, count ] of values ) {
-            total += count;
-            if ( count > maxCount ) {
-                maxCount = count;
-                textAttValue = value;
-            }
-        }
-        if ( total === tspans.length && textAttValue ) {
-            textAttributes[ attName ] = textAttValue;
-        }
+  }
+
+  // Figure out which ones to use as <text> attributes.
+  /** @type Object.<string,string> */
+  const textAttributes = {};
+  for (const [attName, values] of allAttributes) {
+    // Check all values. If there are fewer values than children, at least one child does not have the attribute;
+    // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
+    let total = 0;
+    let maxCount = 0;
+    let textAttValue;
+    for (const [value, count] of values) {
+      total += count;
+      if (count > maxCount) {
+        maxCount = count;
+        textAttValue = value;
+      }
+    }
+    if (total === tspans.length && textAttValue) {
+      textAttributes[attName] = textAttValue;
     }
+  }
 
-    return textAttributes;
+  return textAttributes;
 }
 
 /**
  * @param {string} s
  * @returns {boolean}
  */
-function isWhiteSpace( s ) {
-    return /^\s*$/.test( s );
+function isWhiteSpace(s) {
+  return /^\s*$/.test(s);
 }
 
 /**
@@ -240,58 +240,58 @@ function isWhiteSpace( s ) {
  * @param {number} index
  * @returns XastElement
  */
-function mergeTextElements( mergeableChildren, index ) {
-    /** @type {XastElement} */
-    const textElement = {
-        type: 'element',
-        name: 'text',
-        attributes: {},
-        children: [],
-    };
-
-    //   Find all child data.
-    const tspans = [];
-    for ( ; ; index++ ) {
-        const textData = mergeableChildren.get( index );
-        if ( !textData ) {
-            break;
-        }
-        tspans.push( ...textData.children );
+function mergeTextElements(mergeableChildren, index) {
+  /** @type {XastElement} */
+  const textElement = {
+    type: 'element',
+    name: 'text',
+    attributes: {},
+    children: [],
+  };
+
+  //   Find all child data.
+  const tspans = [];
+  for (; ; index++) {
+    const textData = mergeableChildren.get(index);
+    if (!textData) {
+      break;
     }
+    tspans.push(...textData.children);
+  }
+
+  // Find the default attributes for the <text> element.
+  textElement.attributes = getTextAttributes(tspans);
+
+  // If there is only one <tspan>, merge content into <text>.
+  if (tspans.length === 1) {
+    const tspanData = tspans[0];
+    textElement.attributes.x = tspanData.x;
+    textElement.attributes.y = tspanData.y;
+    textElement.children = tspanData.children;
+    return textElement;
+  }
 
-    // Find the default attributes for the <text> element.
-    textElement.attributes = getTextAttributes( tspans );
+  // Generate <tspan> elements.
+  const textChildren = [];
+  for (const tspanData of tspans) {
+    /** @type {XastElement} */
+    const tspanElement = {
+      type: 'element',
+      name: 'tspan',
+      attributes: { x: tspanData.x, y: tspanData.y },
+      children: tspanData.children,
+    };
 
-    // If there is only one <tspan>, merge content into <text>.
-    if ( tspans.length === 1 ) {
-        const tspanData = tspans[ 0 ];
-        textElement.attributes.x = tspanData.x;
-        textElement.attributes.y = tspanData.y;
-        textElement.children = tspanData.children;
-        return textElement;
+    // Add any attributes that are different from <text> attributes.
+    for (const [k, v] of tspanData.attributes) {
+      if (textElement.attributes[k] !== v) {
+        tspanElement.attributes[k] = v;
+      }
     }
 
-    // Generate <tspan> elements.
-    const textChildren = [];
-    for ( const tspanData of tspans ) {
-        /** @type {XastElement} */
-        const tspanElement = {
-            type: 'element',
-            name: 'tspan',
-            attributes: { x: tspanData.x, y: tspanData.y },
-            children: tspanData.children,
-        };
-
-        // Add any attributes that are different from <text> attributes.
-        for ( const [ k, v ] of tspanData.attributes ) {
-            if ( textElement.attributes[ k ] !== v ) {
-                tspanElement.attributes[ k ] = v;
-            }
-        }
-
-        textChildren.push( tspanElement );
-    }
+    textChildren.push(tspanElement);
+  }
 
-    textElement.children = textChildren;
-    return textElement;
+  textElement.children = textChildren;
+  return textElement;
 }
diff --git a/plugins/plugins-types.d.ts b/plugins/plugins-types.d.ts
index f789fa7a6..caadce489 100644
--- a/plugins/plugins-types.d.ts
+++ b/plugins/plugins-types.d.ts
@@ -136,7 +136,7 @@ type DefaultPlugins = {
         };
   };
 
-  mergeText:void;
+  mergeText: void;
   moveElemsAttrsToGroup: void;
   moveGroupAttrsToElems: void;
   removeComments: {

From 2cccb0e73be4cf123b6d24587ca0cc4e23d0fdb4 Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Mon, 25 Dec 2023 15:39:03 -0800
Subject: [PATCH 05/20] Added mergeText documentation.

---
 docs/03-plugins/merge-text.mdx | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 docs/03-plugins/merge-text.mdx

diff --git a/docs/03-plugins/merge-text.mdx b/docs/03-plugins/merge-text.mdx
new file mode 100644
index 000000000..38b19d2ae
--- /dev/null
+++ b/docs/03-plugins/merge-text.mdx
@@ -0,0 +1,15 @@
+---
+title: Merge Text
+svgo:
+  pluginId: mergeText
+---
+
+Merge adjacent `<text>` elements and remove `<tspan>` when it is the only child of a `<text>` element.
+
+If the SVG contains any `<style>` elements, it will not be modified.
+
+`<text>` or `<tspan>` elements which have non-inheritable attributes other than `x` or `y` will not be modified.
+
+## Implementation
+
+- https://github.com/svg/svgo/blob/main/plugins/mergeText.js

From 8855681d895235ac5b3e01e96d3f895c284990ce Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Tue, 26 Dec 2023 15:36:53 -0800
Subject: [PATCH 06/20] Fixed formatting.

---
 plugins/mergeText.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/mergeText.js b/plugins/mergeText.js
index 9af46fde5..55fbbe87d 100644
--- a/plugins/mergeText.js
+++ b/plugins/mergeText.js
@@ -157,7 +157,7 @@ function getMergeData(textEl) {
           tspanData[k] = v;
           break;
         default:
-          if (!inheritableAttrs.includes(k)) {
+          if (!inheritableAttrs.has(k)) {
             // Don't transform if <tspan> has unrecognized attributes.
             return;
           }

From 562152a7292ba402992d0e04a2530e1d7e4a55ea Mon Sep 17 00:00:00 2001
From: Kendell R <KTibow@users.noreply.github.com>
Date: Wed, 27 Dec 2023 07:53:01 -0500
Subject: [PATCH 07/20] feat(convertPathData): use the sagitta of arcs to round
 and convert to lines when applicable (#1873)

---
 docs/03-plugins/convert-path-data.mdx |  3 ++
 plugins/convertPathData.js            | 44 ++++++++++++++++++++++++++-
 plugins/plugins-types.d.ts            |  1 +
 test/plugins/convertPathData.14.svg   |  4 +--
 test/plugins/convertPathData.30.svg   |  2 +-
 test/plugins/convertPathData.31.svg   |  2 +-
 test/plugins/convertPathData.32.svg   | 13 ++++++++
 test/plugins/convertPathData.33.svg   | 13 ++++++++
 8 files changed, 77 insertions(+), 5 deletions(-)
 create mode 100644 test/plugins/convertPathData.32.svg
 create mode 100644 test/plugins/convertPathData.33.svg

diff --git a/docs/03-plugins/convert-path-data.mdx b/docs/03-plugins/convert-path-data.mdx
index 23ca9e7e0..66848688f 100644
--- a/docs/03-plugins/convert-path-data.mdx
+++ b/docs/03-plugins/convert-path-data.mdx
@@ -30,6 +30,9 @@ svgo:
     transformPrecision:
       description: Number of decimal places to round to, using conventional rounding rules.
       default: 5
+    smartArcRounding:
+      description: Round the radius of circular arcs when the effective change is under the error. The effective change is determined using the <a href="https://wikipedia.org/wiki/Sagitta_(geometry)" target="_blank">sagitta</a> of the arc.
+      default: true
     removeUseless:
       description: Remove redundant path commands that don't draw anything.
       default: true
diff --git a/plugins/convertPathData.js b/plugins/convertPathData.js
index 23c9b56ab..2a6c66507 100644
--- a/plugins/convertPathData.js
+++ b/plugins/convertPathData.js
@@ -50,6 +50,7 @@ let arcTolerance;
  *   curveSmoothShorthands: boolean,
  *   floatPrecision: number | false,
  *   transformPrecision: number,
+ *   smartArcRounding: boolean,
  *   removeUseless: boolean,
  *   collapseRepeated: boolean,
  *   utilizeAbsolute: boolean,
@@ -100,6 +101,7 @@ exports.fn = (root, params) => {
     curveSmoothShorthands = true,
     floatPrecision = 3,
     transformPrecision = 5,
+    smartArcRounding = true,
     removeUseless = true,
     collapseRepeated = true,
     utilizeAbsolute = true,
@@ -122,6 +124,7 @@ exports.fn = (root, params) => {
     curveSmoothShorthands,
     floatPrecision,
     transformPrecision,
+    smartArcRounding,
     removeUseless,
     collapseRepeated,
     utilizeAbsolute,
@@ -638,6 +641,24 @@ function filters(
         }
       }
 
+      // round arc radius more accurately
+      // eg m 0 0 a 1234.567 1234.567 0 0 1 10 0 -> m 0 0 a 1235 1235 0 0 1 10 0
+      const sagitta = command === 'a' ? calculateSagitta(data) : undefined;
+      if (params.smartArcRounding && sagitta !== undefined && precision) {
+        for (let precisionNew = precision; precisionNew >= 0; precisionNew--) {
+          const radius = toFixed(data[0], precisionNew);
+          const sagittaNew = /** @type {number} */ (
+            calculateSagitta([radius, radius, ...data.slice(2)])
+          );
+          if (Math.abs(sagitta - sagittaNew) < error) {
+            data[0] = radius;
+            data[1] = radius;
+          } else {
+            break;
+          }
+        }
+      }
+
       // convert straight curves into lines segments
       if (params.straightCurves) {
         if (
@@ -660,7 +681,12 @@ function filters(
         ) {
           command = 'l';
           data = data.slice(-2);
-        } else if (command === 'a' && (data[0] === 0 || data[1] === 0)) {
+        } else if (
+          command === 'a' &&
+          (data[0] === 0 ||
+            data[1] === 0 ||
+            (sagitta !== undefined && sagitta < error))
+        ) {
           command = 'l';
           data = data.slice(-2);
         }
@@ -1064,6 +1090,22 @@ function isCurveStraightLine(data) {
   return true;
 }
 
+/**
+ * Calculates the sagitta of an arc if possible.
+ *
+ * @type {(data: number[]) => number | undefined}
+ * @see https://wikipedia.org/wiki/Sagitta_(geometry)#Formulas
+ */
+function calculateSagitta(data) {
+  if (data[3] === 1) return undefined;
+
+  const [rx, ry] = data;
+  if (Math.abs(rx - ry) > error) return undefined;
+  const chord = Math.sqrt(data[5] ** 2 + data[6] ** 2);
+  if (chord > rx * 2) return undefined;
+  return rx - Math.sqrt(rx ** 2 - 0.25 * chord ** 2);
+}
+
 /**
  * Converts next curve from shorthand to full form using the current curve data.
  *
diff --git a/plugins/plugins-types.d.ts b/plugins/plugins-types.d.ts
index ff25f68cd..1d4740e7b 100644
--- a/plugins/plugins-types.d.ts
+++ b/plugins/plugins-types.d.ts
@@ -46,6 +46,7 @@ type DefaultPlugins = {
     curveSmoothShorthands?: boolean;
     floatPrecision?: number | false;
     transformPrecision?: number;
+    smartArcRounding?: boolean;
     removeUseless?: boolean;
     collapseRepeated?: boolean;
     utilizeAbsolute?: boolean;
diff --git a/test/plugins/convertPathData.14.svg b/test/plugins/convertPathData.14.svg
index c2b72a9c3..a84c400fb 100644
--- a/test/plugins/convertPathData.14.svg
+++ b/test/plugins/convertPathData.14.svg
@@ -16,10 +16,10 @@
     <path d="M0 0a5 5 0 0 1 5 5"/>
     <path d="M0 0a5 5 0 0 1 5 5l5-5"/>
     <path d="M15 10a5 5 0 1 1 5-5z"/>
-    <path d="M41.008.102a5.006 5.006 0 0 1 3.849 3.705"/>
+    <path d="M41.008.102a5.01 5.01 0 0 1 3.849 3.705"/>
     <path d="M7.234 19.474a5 5 0 0 1-4.933-8.683"/>
     <path d="M60 0a5 5 0 1 0 .001 10.001A5 5 0 0 0 60 0"/>
-    <path d="M15 23.54a8.493 8.493 0 0 1-5.25-1.807"/>
+    <path d="M15 23.54a8.5 8.5 0 0 1-5.25-1.807"/>
     <path d="M-9.5 82.311a4.81 4.81 0 1 1 .002-9.622A4.81 4.81 0 0 1-9.5 82.31"/>
     <path d="M1.5 13.456a3.418 3.418 0 0 0 6.729.854Z"/>
 </svg>
diff --git a/test/plugins/convertPathData.30.svg b/test/plugins/convertPathData.30.svg
index 1d29829d6..cdca02732 100644
--- a/test/plugins/convertPathData.30.svg
+++ b/test/plugins/convertPathData.30.svg
@@ -10,4 +10,4 @@ Should use relative instead of absolute here. (Checking for proper rounding of r
 
 <svg xmlns="http://www.w3.org/2000/svg" width="48" height="48">
     <path d="M6 6h.3"/>
-</svg>
\ No newline at end of file
+</svg>
diff --git a/test/plugins/convertPathData.31.svg b/test/plugins/convertPathData.31.svg
index 9a4d43348..c66efbb2e 100644
--- a/test/plugins/convertPathData.31.svg
+++ b/test/plugins/convertPathData.31.svg
@@ -10,4 +10,4 @@ Should have no commands here. (Checking for removing useless before trying to co
 
 <svg xmlns="http://www.w3.org/2000/svg" width="48" height="48">
     <path d="M6 6"/>
-</svg>
\ No newline at end of file
+</svg>
diff --git a/test/plugins/convertPathData.32.svg b/test/plugins/convertPathData.32.svg
new file mode 100644
index 000000000..97df96b12
--- /dev/null
+++ b/test/plugins/convertPathData.32.svg
@@ -0,0 +1,13 @@
+Should convert arc to line
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10">
+    <path d="m 1 1 a 10000 10000 0 0 0 8 0" stroke="black"/>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10">
+    <path d="M1 1h8" stroke="black"/>
+</svg>
diff --git a/test/plugins/convertPathData.33.svg b/test/plugins/convertPathData.33.svg
new file mode 100644
index 000000000..b8125535b
--- /dev/null
+++ b/test/plugins/convertPathData.33.svg
@@ -0,0 +1,13 @@
+Should round radius considering the sagitta
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10">
+    <path d="m 1 1 a 10.567 10.567 0 0 0 1 0" stroke="black"/>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10">
+    <path d="M1 1a11 11 0 0 0 1 0" stroke="black"/>
+</svg>

From c2cacc7060a87ce1c2cd81bb7fa4245838189e78 Mon Sep 17 00:00:00 2001
From: Seth Falco <seth@falco.fun>
Date: Wed, 27 Dec 2023 12:54:30 +0000
Subject: [PATCH 08/20]  chore: move health files to .github (#1906)

---
 .github/FUNDING.yml                           |  3 --
 SECURITY.md                                   |  5 ---
 lib/parser.js                                 |  2 +-
 lib/path.js                                   |  6 +--
 lib/path.test.js                              |  4 +-
 lib/style.js                                  | 10 ++---
 lib/svgo/coa.js                               | 10 ++---
 lib/svgo/tools.js                             |  2 +-
 lib/types.d.ts                                | 10 ++---
 lib/xast.js                                   |  2 +-
 lib/xast.test.js                              | 12 ++---
 plugins/_path.js                              | 44 +++++++++----------
 plugins/_transforms.js                        | 20 ++++-----
 plugins/applyTransforms.js                    |  4 +-
 plugins/cleanupIds.js                         |  6 +--
 plugins/convertColors.js                      |  2 +-
 plugins/convertShapeToPath.js                 | 10 ++---
 plugins/convertTransform.js                   | 20 ++++-----
 plugins/inlineStyles.js                       | 14 +++---
 plugins/minifyStyles.js                       |  2 +-
 plugins/removeEditorsNSData.js                |  2 +-
 plugins/removeOffCanvasPaths.js               |  2 +-
 plugins/removeUselessDefs.js                  |  4 +-
 plugins/reusePaths.js                         |  2 +-
 test/regression-extract.js                    |  2 +-
 test/svgo/_index.test.js                      |  2 +-
 ...le-specifity.svg => style-specificity.svg} |  0
 27 files changed, 95 insertions(+), 107 deletions(-)
 delete mode 100644 .github/FUNDING.yml
 delete mode 100644 SECURITY.md
 rename test/svgo/{style-specifity.svg => style-specificity.svg} (100%)

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
deleted file mode 100644
index e09ac4c74..000000000
--- a/.github/FUNDING.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-open_collective: svgo
diff --git a/SECURITY.md b/SECURITY.md
deleted file mode 100644
index 7a6e08a62..000000000
--- a/SECURITY.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-Please report security vulnerabilities to [trysound@yandex.ru](mailto:trysound@yandex.ru).
diff --git a/lib/parser.js b/lib/parser.js
index 4359373a9..4637acf15 100644
--- a/lib/parser.js
+++ b/lib/parser.js
@@ -100,7 +100,7 @@ const parseSvg = (data, from) => {
    */
   let current = root;
   /**
-   * @type {Array<XastParent>}
+   * @type {XastParent[]}
    */
   const stack = [root];
 
diff --git a/lib/path.js b/lib/path.js
index a5f7d5bfc..8e6b47221 100644
--- a/lib/path.js
+++ b/lib/path.js
@@ -135,11 +135,11 @@ const readNumber = (string, cursor) => {
 };
 
 /**
- * @type {(string: string) => Array<PathDataItem>}
+ * @type {(string: string) => PathDataItem[]}
  */
 const parsePathData = (string) => {
   /**
-   * @type {Array<PathDataItem>}
+   * @type {PathDataItem[]}
    */
   const pathData = [];
   /**
@@ -307,7 +307,7 @@ const stringifyArgs = (command, args, precision, disableSpaceAfterFlags) => {
 
 /**
  * @typedef {{
- *   pathData: Array<PathDataItem>;
+ *   pathData: PathDataItem[];
  *   precision?: number;
  *   disableSpaceAfterFlags?: boolean;
  * }} StringifyPathDataOptions
diff --git a/lib/path.test.js b/lib/path.test.js
index 8282ea95c..91e6eaa91 100644
--- a/lib/path.test.js
+++ b/lib/path.test.js
@@ -146,7 +146,7 @@ describe('stringify path data', () => {
   });
   it('should configure precision', () => {
     /**
-     * @type {Array<PathDataItem>}
+     * @type {PathDataItem[]}
      */
     const pathData = [
       { command: 'M', args: [0, -1.9876] },
@@ -169,7 +169,7 @@ describe('stringify path data', () => {
   });
   it('allows to avoid spaces after arc flags', () => {
     /**
-     * @type {Array<PathDataItem>}
+     * @type {PathDataItem[]}
      */
     const pathData = [
       { command: 'M', args: [0, 0] },
diff --git a/lib/style.js b/lib/style.js
index e54993a3c..fbfffc6b4 100644
--- a/lib/style.js
+++ b/lib/style.js
@@ -34,7 +34,7 @@ const csstreeWalkSkip = csstree.walk.skip;
  */
 const parseRule = (ruleNode, dynamic) => {
   /**
-   * @type {Array<StylesheetDeclaration>}
+   * @type {StylesheetDeclaration[]}
    */
   const declarations = [];
   // collect declarations
@@ -74,10 +74,10 @@ const parseRule = (ruleNode, dynamic) => {
 };
 
 /**
- * @type {(css: string, dynamic: boolean) => Array<StylesheetRule>}
+ * @type {(css: string, dynamic: boolean) => StylesheetRule[]}
  */
 const parseStylesheet = (css, dynamic) => {
-  /** @type {Array<StylesheetRule>} */
+  /** @type {StylesheetRule[]} */
   const rules = [];
   const ast = csstree.parse(css, {
     parseValue: false,
@@ -108,10 +108,10 @@ const parseStylesheet = (css, dynamic) => {
 };
 
 /**
- * @type {(css: string) => Array<StylesheetDeclaration>}
+ * @type {(css: string) => StylesheetDeclaration[]}
  */
 const parseStyleDeclarations = (css) => {
-  /** @type {Array<StylesheetDeclaration>} */
+  /** @type {StylesheetDeclaration[]} */
   const declarations = [];
   const ast = csstree.parse(css, {
     context: 'declarationList',
diff --git a/lib/svgo/coa.js b/lib/svgo/coa.js
index 331812f5e..8e638d068 100644
--- a/lib/svgo/coa.js
+++ b/lib/svgo/coa.js
@@ -254,10 +254,7 @@ async function action(args, opts, command) {
         process.stdin
           .on('data', (chunk) => (data += chunk))
           .once('end', () =>
-            processSVGData(config, { input: 'string' }, data, file).then(
-              resolve,
-              reject,
-            ),
+            processSVGData(config, null, data, file).then(resolve, reject),
           );
       });
       // file
@@ -271,7 +268,7 @@ async function action(args, opts, command) {
   } else if (opts.string) {
     var data = decodeSVGDatauri(opts.string);
 
-    return processSVGData(config, { input: 'string' }, data, output[0]);
+    return processSVGData(config, null, data, output[0]);
   }
 }
 
@@ -372,8 +369,7 @@ function getFilesDescriptions(config, dir, files, output) {
  */
 function optimizeFile(config, file, output) {
   return fs.promises.readFile(file, 'utf8').then(
-    (data) =>
-      processSVGData(config, { input: 'file', path: file }, data, output, file),
+    (data) => processSVGData(config, { path: file }, data, output, file),
     (error) => checkOptimizeFileError(config, file, output, error),
   );
 }
diff --git a/lib/svgo/tools.js b/lib/svgo/tools.js
index afbda50c0..618ca70aa 100644
--- a/lib/svgo/tools.js
+++ b/lib/svgo/tools.js
@@ -74,7 +74,7 @@ exports.decodeSVGDatauri = (str) => {
  * @example
  * [0, -1, .5, .5] → "0-1 .5.5"
  *
- * @type {(data: Array<number>, params: CleanupOutDataParams, command?: PathDataCommand) => string}
+ * @type {(data: number[], params: CleanupOutDataParams, command?: PathDataCommand) => string}
  */
 exports.cleanupOutData = (data, params, command) => {
   let str = '';
diff --git a/lib/types.d.ts b/lib/types.d.ts
index 75818c4a6..68dc97478 100644
--- a/lib/types.d.ts
+++ b/lib/types.d.ts
@@ -31,7 +31,7 @@ export type XastElement = {
   type: 'element';
   name: string;
   attributes: Record<string, string>;
-  children: Array<XastChild>;
+  children: XastChild[];
 };
 
 export type XastChild =
@@ -44,7 +44,7 @@ export type XastChild =
 
 export type XastRoot = {
   type: 'root';
-  children: Array<XastChild>;
+  children: XastChild[];
 };
 
 export type XastParent = XastRoot | XastElement;
@@ -123,11 +123,11 @@ export type StylesheetRule = {
   dynamic: boolean;
   selector: string;
   specificity: Specificity;
-  declarations: Array<StylesheetDeclaration>;
+  declarations: StylesheetDeclaration[];
 };
 
 export type Stylesheet = {
-  rules: Array<StylesheetRule>;
+  rules: StylesheetRule[];
   parents: Map<XastElement, XastParent>;
 };
 
@@ -168,7 +168,7 @@ export type PathDataCommand =
 
 export type PathDataItem = {
   command: PathDataCommand;
-  args: Array<number>;
+  args: number[];
 };
 
 export type DataUri = 'base64' | 'enc' | 'unenc';
diff --git a/lib/xast.js b/lib/xast.js
index 7f14e2a87..9dca96460 100644
--- a/lib/xast.js
+++ b/lib/xast.js
@@ -16,7 +16,7 @@ const cssSelectOptions = {
 };
 
 /**
- * @type {(node: XastNode, selector: string) => Array<XastChild>}
+ * @type {(node: XastNode, selector: string) => XastChild[]}
  */
 const querySelectorAll = (node, selector) => {
   return selectAll(selector, node, cssSelectOptions);
diff --git a/lib/xast.test.js b/lib/xast.test.js
index aefaaed5e..4371fc938 100644
--- a/lib/xast.test.js
+++ b/lib/xast.test.js
@@ -8,7 +8,7 @@
 const { visit, visitSkip, detachNodeFromParent } = require('./xast.js');
 
 /**
- * @type {(children: Array<XastElement>) => XastRoot}
+ * @type {(children: XastElement[]) => XastRoot}
  */
 const root = (children) => {
   return { type: 'root', children };
@@ -18,7 +18,7 @@ const root = (children) => {
  * @type {(
  *   name: string,
  *   attrs?: ?Record<string, string>,
- *   children?: Array<XastElement>
+ *   children?: XastElement[]
  * ) => XastElement}
  */
 const x = (name, attrs = null, children = []) => {
@@ -28,7 +28,7 @@ const x = (name, attrs = null, children = []) => {
 test('visit enters into nodes', () => {
   const ast = root([x('g', null, [x('rect'), x('circle')]), x('ellipse')]);
   /**
-   * @type {Array<string>}
+   * @type {string[]}
    */
   const entered = [];
   visit(ast, {
@@ -55,7 +55,7 @@ test('visit enters into nodes', () => {
 test('visit exits from nodes', () => {
   const ast = root([x('g', null, [x('rect'), x('circle')]), x('ellipse')]);
   /**
-   * @type {Array<string>}
+   * @type {string[]}
    */
   const exited = [];
   visit(ast, {
@@ -82,7 +82,7 @@ test('visit exits from nodes', () => {
 test('visit skips entering children if node is detached', () => {
   const ast = root([x('g', null, [x('rect'), x('circle')]), x('ellipse')]);
   /**
-   * @type {Array<string>}
+   * @type {string[]}
    */
   const entered = [];
   visit(ast, {
@@ -102,7 +102,7 @@ test('visit skips entering children if node is detached', () => {
 test('visit skips entering children when symbol is passed', () => {
   const ast = root([x('g', null, [x('rect'), x('circle')]), x('ellipse')]);
   /**
-   * @type {Array<string>}
+   * @type {string[]}
    */
   const entered = [];
   visit(ast, {
diff --git a/plugins/_path.js b/plugins/_path.js
index 60b4a9d72..7c3a28b93 100644
--- a/plugins/_path.js
+++ b/plugins/_path.js
@@ -15,13 +15,13 @@ var prevCtrlPoint;
 /**
  * Convert path string to JS representation.
  *
- * @type {(path: XastElement) => Array<PathDataItem>}
+ * @type {(path: XastElement) => PathDataItem[]}
  */
 const path2js = (path) => {
   // @ts-ignore legacy
   if (path.pathJS) return path.pathJS;
   /**
-   * @type {Array<PathDataItem>}
+   * @type {PathDataItem[]}
    */
   const pathData = []; // JS representation of the path data
   const newPathData = parsePathData(path.attributes.d);
@@ -41,12 +41,12 @@ exports.path2js = path2js;
 /**
  * Convert relative Path data to absolute.
  *
- * @type {(data: Array<PathDataItem>) => Array<PathDataItem>}
+ * @type {(data: PathDataItem[]) => PathDataItem[]}
  *
  */
 const convertRelativeToAbsolute = (data) => {
   /**
-   * @type {Array<PathDataItem>}
+   * @type {PathDataItem[]}
    */
   const newData = [];
   let start = [0, 0];
@@ -179,7 +179,7 @@ const convertRelativeToAbsolute = (data) => {
 /**
  * Convert path array to string.
  *
- * @type {(path: XastElement, data: Array<PathDataItem>, params: Js2PathParams) => void}
+ * @type {(path: XastElement, data: PathDataItem[], params: Js2PathParams) => void}
  */
 exports.js2path = function (path, data, params) {
   // @ts-ignore legacy
@@ -211,7 +211,7 @@ exports.js2path = function (path, data, params) {
 };
 
 /**
- * @type {(dest: Array<number>, source: Array<number>) => Array<number>}
+ * @type {(dest: number[], source: number[]) => number[]}
  */
 function set(dest, source) {
   dest[0] = source[source.length - 2];
@@ -224,7 +224,7 @@ function set(dest, source) {
  * collision using Gilbert-Johnson-Keerthi distance algorithm
  * https://web.archive.org/web/20180822200027/http://entropyinteractive.com/2011/04/gjk-algorithm/
  *
- * @type {(path1: Array<PathDataItem>, path2: Array<PathDataItem>) => boolean}
+ * @type {(path1: PathDataItem[], path2: PathDataItem[]) => boolean}
  */
 exports.intersects = function (path1, path2) {
   // Collect points of every subpath.
@@ -284,7 +284,7 @@ exports.intersects = function (path1, path2) {
   });
 
   /**
-   * @type {(a: Point, b: Point, direction: Array<number>) => Array<number>}
+   * @type {(a: Point, b: Point, direction: number[]) => number[]}
    */
   function getSupport(a, b, direction) {
     return sub(supportPoint(a, direction), supportPoint(b, minus(direction)));
@@ -294,7 +294,7 @@ exports.intersects = function (path1, path2) {
   // Thanks to knowledge of min/max x and y coordinates we can choose a quadrant to search in.
   // Since we're working on convex hull, the dot product is increasing until we find the farthest point.
   /**
-   * @type {(polygon: Point, direction: Array<number>) => Array<number>}
+   * @type {(polygon: Point, direction: number[]) => number[]}
    */
   function supportPoint(polygon, direction) {
     var index =
@@ -316,7 +316,7 @@ exports.intersects = function (path1, path2) {
 };
 
 /**
- * @type {(simplex: Array<Array<number>>, direction: Array<number>) => boolean}
+ * @type {(simplex: number[][], direction: number[]) => boolean}
  */
 function processSimplex(simplex, direction) {
   // we only need to handle to 1-simplex and 2-simplex
@@ -373,28 +373,28 @@ function processSimplex(simplex, direction) {
 }
 
 /**
- * @type {(v: Array<number>) => Array<number>}
+ * @type {(v: number[]) => number[]}
  */
 function minus(v) {
   return [-v[0], -v[1]];
 }
 
 /**
- * @type {(v1: Array<number>, v2: Array<number>) => Array<number>}
+ * @type {(v1: number[], v2: number[]) => number[]}
  */
 function sub(v1, v2) {
   return [v1[0] - v2[0], v1[1] - v2[1]];
 }
 
 /**
- * @type {(v1: Array<number>, v2: Array<number>) => number}
+ * @type {(v1: number[], v2: number[]) => number}
  */
 function dot(v1, v2) {
   return v1[0] * v2[0] + v1[1] * v2[1];
 }
 
 /**
- * @type {(v1: Array<number>, v2: Array<number>) => Array<number>}
+ * @type {(v1: number[], v2: number[]) => number[]}
  */
 function orth(v, from) {
   var o = [-v[1], v[0]];
@@ -403,7 +403,7 @@ function orth(v, from) {
 
 /**
  * @typedef {{
- *   list: Array<Array<number>>,
+ *   list: number[][],
  *   minX: number,
  *   minY: number,
  *   maxX: number,
@@ -413,7 +413,7 @@ function orth(v, from) {
 
 /**
  * @typedef {{
- *   list: Array<Point>,
+ *   list: Point[],
  *   minX: number,
  *   minY: number,
  *   maxX: number,
@@ -422,7 +422,7 @@ function orth(v, from) {
  */
 
 /**
- * @type {(pathData: Array<PathDataItem>) => Points}
+ * @type {(pathData: PathDataItem[]) => Points}
  */
 function gatherPoints(pathData) {
   /**
@@ -432,7 +432,7 @@ function gatherPoints(pathData) {
 
   // Writes data about the extreme points on each axle
   /**
-   * @type {(path: Point, point: Array<number>) => void}
+   * @type {(path: Point, point: number[]) => void}
    */
   const addPoint = (path, point) => {
     if (!path.list.length || point[1] > path.list[path.maxY][1]) {
@@ -670,7 +670,7 @@ function convexHull(points) {
 }
 
 /**
- * @type {(o: Array<number>, a: Array<number>, b: Array<number>) => number}
+ * @type {(o: number[], a: number[], b: number[]) => number}
  */
 function cross(o, a, b) {
   return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
@@ -690,8 +690,8 @@ function cross(o, a, b) {
  *  sweep_flag: number,
  *  x2: number,
  *  y2: number,
- *  recursive: Array<number>
- * ) => Array<number>}
+ *  recursive: number[]
+ * ) => number[]}
  */
 const a2c = (
   x1,
@@ -710,7 +710,7 @@ const a2c = (
   const _120 = (Math.PI * 120) / 180;
   const rad = (Math.PI / 180) * (+angle || 0);
   /**
-   * @type {Array<number>}
+   * @type {number[]}
    */
   let res = [];
   /**
diff --git a/plugins/_transforms.js b/plugins/_transforms.js
index df327bc65..5606b6e7d 100644
--- a/plugins/_transforms.js
+++ b/plugins/_transforms.js
@@ -6,18 +6,18 @@ const regTransformSplit =
 const regNumericValues = /[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
 
 /**
- * @typedef {{ name: string, data: Array<number> }} TransformItem
+ * @typedef {{ name: string, data: number[] }} TransformItem
  */
 
 /**
  * Convert transform string to JS representation.
  *
- * @type {(transformString: string) => Array<TransformItem>}
+ * @type {(transformString: string) => TransformItem[]}
  */
 exports.transform2js = (transformString) => {
   // JS representation of the transform data
   /**
-   * @type {Array<TransformItem>}
+   * @type {TransformItem[]}
    */
   const transforms = [];
   // current transform context
@@ -53,7 +53,7 @@ exports.transform2js = (transformString) => {
 /**
  * Multiply transforms into one.
  *
- * @type {(transforms: Array<TransformItem>) => TransformItem}
+ * @type {(transforms: TransformItem[]) => TransformItem}
  */
 exports.transformsMultiply = (transforms) => {
   // convert transforms objects to the matrices
@@ -153,7 +153,7 @@ const mth = {
  * Decompose matrix into simple transforms. See
  * https://frederic-wang.fr/decomposition-of-2d-transform-matrices.html
  *
- * @type {(transform: TransformItem, params: TransformParams) => Array<TransformItem>}
+ * @type {(transform: TransformItem, params: TransformParams) => TransformItem[]}
  */
 exports.matrixToTransform = (transform, params) => {
   let floatPrecision = params.floatPrecision;
@@ -248,7 +248,7 @@ exports.matrixToTransform = (transform, params) => {
 /**
  * Convert transform to the matrix data.
  *
- * @type {(transform: TransformItem) => Array<number> }
+ * @type {(transform: TransformItem) => number[] }
  */
 const transformToMatrix = (transform) => {
   if (transform.name === 'matrix') {
@@ -301,9 +301,9 @@ const transformToMatrix = (transform) => {
  *
  * @type {(
  *   cursor: [x: number, y: number],
- *   arc: Array<number>,
- *   transform: Array<number>
- * ) => Array<number>}
+ *   arc: number[],
+ *   transform: number[]
+ * ) => number[]}
  */
 exports.transformArc = (cursor, arc, transform) => {
   const x = arc[5] - cursor[0];
@@ -364,7 +364,7 @@ exports.transformArc = (cursor, arc, transform) => {
 /**
  * Multiply transformation matrices.
  *
- * @type {(a: Array<number>, b: Array<number>) => Array<number>}
+ * @type {(a: number[], b: number[]) => number[]}
  */
 const multiplyTransformMatrices = (a, b) => {
   return [
diff --git a/plugins/applyTransforms.js b/plugins/applyTransforms.js
index 3817c3d64..ae492d54a 100644
--- a/plugins/applyTransforms.js
+++ b/plugins/applyTransforms.js
@@ -19,8 +19,8 @@ const {
 const { referencesProps, attrsGroupsDefaults } = require('./_collections.js');
 
 /**
- * @typedef {Array<PathDataItem>} PathData
- * @typedef {Array<number>} Matrix
+ * @typedef {PathDataItem[]} PathData
+ * @typedef {number[]} Matrix
  */
 
 const regNumericValues = /[-+]?(\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
diff --git a/plugins/cleanupIds.js b/plugins/cleanupIds.js
index cdbc207a8..bfabcca55 100644
--- a/plugins/cleanupIds.js
+++ b/plugins/cleanupIds.js
@@ -69,7 +69,7 @@ const maxIdIndex = generateIdChars.length - 1;
 /**
  * Check if an ID starts with any one of a list of strings.
  *
- * @type {(string: string, prefixes: Array<string>) => boolean}
+ * @type {(string: string, prefixes: string[]) => boolean}
  */
 const hasStringPrefix = (string, prefixes) => {
   for (const prefix of prefixes) {
@@ -109,7 +109,7 @@ const generateId = (currentId) => {
 /**
  * Get string from generated ID array.
  *
- * @type {(arr: Array<number>) => string}
+ * @type {(arr: number[]) => string}
  */
 const getIdString = (arr) => {
   return arr.map((i) => generateIdChars[i]).join('');
@@ -144,7 +144,7 @@ exports.fn = (_root, params) => {
    */
   const nodeById = new Map();
   /**
-   * @type {Map<string, Array<{element: XastElement, name: string }>>}
+   * @type {Map<string, {element: XastElement, name: string }[]>}
    */
   const referencesById = new Map();
   let deoptimized = false;
diff --git a/plugins/convertColors.js b/plugins/convertColors.js
index 98517a08a..d894283f8 100644
--- a/plugins/convertColors.js
+++ b/plugins/convertColors.js
@@ -22,7 +22,7 @@ const regHEX = /^#(([a-fA-F0-9])\2){3}$/;
  *
  * @author Jed Schmidt
  *
- * @type {(rgb: Array<number>) => string}
+ * @type {(rgb: number[]) => string}
  */
 const convertRgbToHex = ([r, g, b]) => {
   // combine the octets into a 32-bit integer as: [1][r][g][b]
diff --git a/plugins/convertShapeToPath.js b/plugins/convertShapeToPath.js
index 8aa41cb72..f0ba0fd84 100644
--- a/plugins/convertShapeToPath.js
+++ b/plugins/convertShapeToPath.js
@@ -46,7 +46,7 @@ exports.fn = (root, params) => {
           // TODO: Calculate sizes from % and non-px units if possible.
           if (Number.isNaN(x - y + width - height)) return;
           /**
-           * @type {Array<PathDataItem>}
+           * @type {PathDataItem[]}
            */
           const pathData = [
             { command: 'M', args: [x, y] },
@@ -71,7 +71,7 @@ exports.fn = (root, params) => {
           const y2 = Number(node.attributes.y2 || '0');
           if (Number.isNaN(x1 - y1 + x2 - y2)) return;
           /**
-           * @type {Array<PathDataItem>}
+           * @type {PathDataItem[]}
            */
           const pathData = [
             { command: 'M', args: [x1, y1] },
@@ -98,7 +98,7 @@ exports.fn = (root, params) => {
             return;
           }
           /**
-           * @type {Array<PathDataItem>}
+           * @type {PathDataItem[]}
            */
           const pathData = [];
           for (let i = 0; i < coords.length; i += 2) {
@@ -124,7 +124,7 @@ exports.fn = (root, params) => {
             return;
           }
           /**
-           * @type {Array<PathDataItem>}
+           * @type {PathDataItem[]}
            */
           const pathData = [
             { command: 'M', args: [cx, cy - r] },
@@ -149,7 +149,7 @@ exports.fn = (root, params) => {
             return;
           }
           /**
-           * @type {Array<PathDataItem>}
+           * @type {PathDataItem[]}
            */
           const pathData = [
             { command: 'M', args: [ecx, ecy - ry] },
diff --git a/plugins/convertTransform.js b/plugins/convertTransform.js
index b8f75602e..730227ea3 100644
--- a/plugins/convertTransform.js
+++ b/plugins/convertTransform.js
@@ -94,7 +94,7 @@ exports.fn = (_root, params) => {
  */
 
 /**
- * @typedef {{ name: string, data: Array<number> }} TransformItem
+ * @typedef {{ name: string, data: number[] }} TransformItem
  */
 
 /**
@@ -134,7 +134,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.
  */
@@ -171,7 +171,7 @@ const definePrecision = (data, { ...newParams }) => {
 };
 
 /**
- * @type {(data: Array<number>, params: TransformParams) => Array<number>}
+ * @type {(data: number[], params: TransformParams) => number[]}
  */
 const degRound = (data, params) => {
   if (
@@ -185,7 +185,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 +196,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,7 +219,7 @@ const floatDigits = (n) => {
 /**
  * Convert transforms to the shorthand alternatives.
  *
- * @type {(transforms: Array<TransformItem>, params: TransformParams) => Array<TransformItem>}
+ * @type {(transforms: TransformItem[], params: TransformParams) => TransformItem[]}
  */
 const convertToShorts = (transforms, params) => {
   for (var i = 0; i < transforms.length; i++) {
@@ -294,7 +294,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 +332,7 @@ const removeUseless = (transforms) => {
 /**
  * Convert transforms JS representation to string.
  *
- * @type {(transformJS: Array<TransformItem>, params: TransformParams) => string}
+ * @type {(transformJS: TransformItem[], params: TransformParams) => string}
  */
 const js2transform = (transformJS, params) => {
   const transformString = transformJS
@@ -379,7 +379,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 +390,7 @@ 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>}
+ * @type {(precision: number, data: number[]) => number[]}
  */
 const smartRound = (precision, data) => {
   for (
diff --git a/plugins/inlineStyles.js b/plugins/inlineStyles.js
index 84b264eac..42029d2bd 100644
--- a/plugins/inlineStyles.js
+++ b/plugins/inlineStyles.js
@@ -51,16 +51,16 @@ exports.fn = (root, params) => {
   } = params;
 
   /**
-   * @type {Array<{ node: XastElement, parentNode: XastParent, cssAst: csstree.StyleSheet }>}
+   * @type {{ node: XastElement, parentNode: XastParent, cssAst: csstree.StyleSheet }[]}
    */
   const styles = [];
   /**
-   * @type {Array<{
+   * @type {{
    *   node: csstree.Selector,
    *   item: csstree.ListItem<csstree.CssNode>,
    *   rule: csstree.Rule,
-   *   matchedElements?: Array<XastElement>
-   * }>}
+   *   matchedElements?: XastElement[]
+   * }[]}
    */
   let selectors = [];
 
@@ -123,10 +123,10 @@ exports.fn = (root, params) => {
               node.prelude.children.forEach((childNode, item) => {
                 if (childNode.type === 'Selector') {
                   /**
-                   * @type {Array<{
+                   * @type {{
                    *   item: csstree.ListItem<csstree.CssNode>,
                    *   list: csstree.List<csstree.CssNode>
-                   * }>}
+                   * }[]}
                    */
                   const pseudos = [];
 
@@ -187,7 +187,7 @@ exports.fn = (root, params) => {
         for (const selector of sortedSelectors) {
           // match selectors
           const selectorText = csstree.generate(selector.item.data);
-          /** @type {Array<XastElement>} */
+          /** @type {XastElement[]} */
           const matchedElements = [];
           try {
             for (const node of querySelectorAll(root, selectorText)) {
diff --git a/plugins/minifyStyles.js b/plugins/minifyStyles.js
index 598b6db33..ade441b3b 100644
--- a/plugins/minifyStyles.js
+++ b/plugins/minifyStyles.js
@@ -22,7 +22,7 @@ exports.fn = (_root, { usage, ...params }) => {
   /** @type {Map<XastElement, XastParent>} */
   const styleElements = new Map();
 
-  /** @type {Array<XastElement>} */
+  /** @type {XastElement[]} */
   const elementsWithStyleAttributes = [];
 
   /** @type {Set<string>} */
diff --git a/plugins/removeEditorsNSData.js b/plugins/removeEditorsNSData.js
index 992241ea2..852681bf8 100644
--- a/plugins/removeEditorsNSData.js
+++ b/plugins/removeEditorsNSData.js
@@ -24,7 +24,7 @@ exports.fn = (_root, params) => {
     namespaces = [...editorNamespaces, ...params.additionalNamespaces];
   }
   /**
-   * @type {Array<string>}
+   * @type {string[]}
    */
   const prefixes = [];
   return {
diff --git a/plugins/removeOffCanvasPaths.js b/plugins/removeOffCanvasPaths.js
index 5f625d370..60a69fb1a 100644
--- a/plugins/removeOffCanvasPaths.js
+++ b/plugins/removeOffCanvasPaths.js
@@ -116,7 +116,7 @@ exports.fn = () => {
 
           const { left, top, width, height } = viewBoxData;
           /**
-           * @type {Array<PathDataItem>}
+           * @type {PathDataItem[]}
            */
           const viewBoxPathData = [
             { command: 'M', args: [left, top] },
diff --git a/plugins/removeUselessDefs.js b/plugins/removeUselessDefs.js
index d642b874e..5d19810e3 100644
--- a/plugins/removeUselessDefs.js
+++ b/plugins/removeUselessDefs.js
@@ -23,7 +23,7 @@ exports.fn = () => {
       enter: (node, parentNode) => {
         if (node.name === 'defs') {
           /**
-           * @type {Array<XastElement>}
+           * @type {XastElement[]}
            */
           const usefulNodes = [];
           collectUsefulNodes(node, usefulNodes);
@@ -50,7 +50,7 @@ exports.fn = () => {
 };
 
 /**
- * @type {(node: XastElement, usefulNodes: Array<XastElement>) => void}
+ * @type {(node: XastElement, usefulNodes: XastElement[]) => void}
  */
 const collectUsefulNodes = (node, usefulNodes) => {
   for (const child of node.children) {
diff --git a/plugins/reusePaths.js b/plugins/reusePaths.js
index 6079aceb7..8c2ddf0d3 100644
--- a/plugins/reusePaths.js
+++ b/plugins/reusePaths.js
@@ -27,7 +27,7 @@ exports.fn = (root) => {
   const stylesheet = collectStylesheet(root);
 
   /**
-   * @type {Map<string, Array<XastElement>>}
+   * @type {Map<string, XastElement[]>}
    */
   const paths = new Map();
 
diff --git a/test/regression-extract.js b/test/regression-extract.js
index 2c0e6232f..e5a594e65 100644
--- a/test/regression-extract.js
+++ b/test/regression-extract.js
@@ -73,7 +73,7 @@ const extractTarGz = async (url, baseDir, include) => {
 
 (async () => {
   try {
-    console.info('Download W3C SVG 1.1 Test Suite and extract SVG files');
+    console.info('Downloading W3C SVG 1.1 Test Suite and extracting files');
     await extractTarGz(
       'https://www.w3.org/Graphics/SVG/Test/20110816/archives/W3C_SVG_11_TestSuite.tar.gz',
       path.join(__dirname, 'regression-fixtures', 'w3c-svg-11-test-suite'),
diff --git a/test/svgo/_index.test.js b/test/svgo/_index.test.js
index a9e5f06c7..e855dc6bf 100644
--- a/test/svgo/_index.test.js
+++ b/test/svgo/_index.test.js
@@ -36,7 +36,7 @@ describe('svgo', () => {
     expect(result.data).toEqual('<svg/>');
   });
   it('should preserve style specificity over attributes', async () => {
-    const [original, expected] = await parseFixture('style-specifity.svg');
+    const [original, expected] = await parseFixture('style-specificity.svg');
     const result = optimize(original, {
       path: 'input.svg',
       js2svg: { pretty: true },
diff --git a/test/svgo/style-specifity.svg b/test/svgo/style-specificity.svg
similarity index 100%
rename from test/svgo/style-specifity.svg
rename to test/svgo/style-specificity.svg

From 4768af63e4ec15a10f5f721db79163341ad9947f Mon Sep 17 00:00:00 2001
From: Jon Dufresne <jon.dufresne@gmail.com>
Date: Wed, 27 Dec 2023 08:09:56 -0500
Subject: [PATCH 09/20] chore: Update @types/csso and correct types (#1910)

---
 lib/style.js            |  1 -
 lib/types.d.ts          |  2 +-
 package.json            |  4 ++--
 plugins/inlineStyles.js |  1 -
 yarn.lock               | 14 +++++++-------
 5 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/lib/style.js b/lib/style.js
index fbfffc6b4..0e62afb92 100644
--- a/lib/style.js
+++ b/lib/style.js
@@ -16,7 +16,6 @@
 const csstree = require('css-tree');
 const csswhat = require('css-what');
 const {
-  // @ts-ignore internal api
   syntax: { specificity },
 } = require('csso');
 const { visit, matches } = require('./xast.js');
diff --git a/lib/types.d.ts b/lib/types.d.ts
index 68dc97478..f61d9f18f 100644
--- a/lib/types.d.ts
+++ b/lib/types.d.ts
@@ -111,7 +111,7 @@ export type Plugin<Params> = (
   info: PluginInfo,
 ) => null | Visitor;
 
-export type Specificity = [number, number, number, number];
+export type Specificity = [number, number, number];
 
 export type StylesheetDeclaration = {
   name: string;
diff --git a/package.json b/package.json
index 3b51fb00e..93a06044d 100644
--- a/package.json
+++ b/package.json
@@ -83,14 +83,14 @@
     "css-select": "^5.1.0",
     "css-tree": "^2.2.1",
     "css-what": "^6.1.0",
-    "csso": "5.0.5",
+    "csso": "^5.0.5",
     "picocolors": "^1.0.0"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^22.0.2",
     "@rollup/plugin-node-resolve": "^14.1.0",
     "@types/css-tree": "^2.0.0",
-    "@types/csso": "~5.0.3",
+    "@types/csso": "^5.0.4",
     "@types/jest": "^29.5.5",
     "del": "^6.0.0",
     "eslint": "^8.55.0",
diff --git a/plugins/inlineStyles.js b/plugins/inlineStyles.js
index 42029d2bd..e09988de7 100644
--- a/plugins/inlineStyles.js
+++ b/plugins/inlineStyles.js
@@ -7,7 +7,6 @@
 
 const csstree = require('css-tree');
 const {
-  // @ts-ignore internal api
   syntax: { specificity },
 } = require('csso');
 const {
diff --git a/yarn.lock b/yarn.lock
index 8baf0bdf7..4f417bb81 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -983,12 +983,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/csso@npm:~5.0.3":
-  version: 5.0.3
-  resolution: "@types/csso@npm:5.0.3"
+"@types/csso@npm:^5.0.4":
+  version: 5.0.4
+  resolution: "@types/csso@npm:5.0.4"
   dependencies:
     "@types/css-tree": "*"
-  checksum: 3d299ea755732f9b913cfb3d94849e173cd1019559058af0a372aa1ca8f48a3c63aa74932fdfa2f2f25ee78255a115feaaec01ae4fe9578e76b7c4acd8ae3f2a
+  checksum: 606ea4de171e807ffc8908f7ffec774c8a40f3c81e7c60f8a84c7f5327eb00f3c9948b021b91e2e8fe3a76af4623ac58538780f0789f1e03947b7de96c5f7994
   languageName: node
   linkType: hard
 
@@ -1704,7 +1704,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"csso@npm:5.0.5":
+"csso@npm:^5.0.5":
   version: 5.0.5
   resolution: "csso@npm:5.0.5"
   dependencies:
@@ -4430,13 +4430,13 @@ __metadata:
     "@rollup/plugin-node-resolve": ^14.1.0
     "@trysound/sax": 0.2.0
     "@types/css-tree": ^2.0.0
-    "@types/csso": ~5.0.3
+    "@types/csso": ^5.0.4
     "@types/jest": ^29.5.5
     commander: ^7.2.0
     css-select: ^5.1.0
     css-tree: ^2.2.1
     css-what: ^6.1.0
-    csso: 5.0.5
+    csso: ^5.0.5
     del: ^6.0.0
     eslint: ^8.55.0
     jest: ^29.5.5

From 967d2f1e1452a7c0adf952a9d676416eb31680c9 Mon Sep 17 00:00:00 2001
From: Seth Falco <seth@falco.fun>
Date: Wed, 27 Dec 2023 13:51:50 +0000
Subject: [PATCH 10/20] deps: update css-tree and clean ts-ignores (#1911)

---
 package.json         |  4 ++--
 plugins/prefixIds.js |  3 ---
 yarn.lock            | 31 ++++++++++++++++++++++++-------
 3 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/package.json b/package.json
index 93a06044d..d53741856 100644
--- a/package.json
+++ b/package.json
@@ -81,7 +81,7 @@
     "@trysound/sax": "0.2.0",
     "commander": "^7.2.0",
     "css-select": "^5.1.0",
-    "css-tree": "^2.2.1",
+    "css-tree": "^2.3.1",
     "css-what": "^6.1.0",
     "csso": "^5.0.5",
     "picocolors": "^1.0.0"
@@ -89,7 +89,7 @@
   "devDependencies": {
     "@rollup/plugin-commonjs": "^22.0.2",
     "@rollup/plugin-node-resolve": "^14.1.0",
-    "@types/css-tree": "^2.0.0",
+    "@types/css-tree": "^2.3.4",
     "@types/csso": "^5.0.4",
     "@types/jest": "^29.5.5",
     "del": "^6.0.0",
diff --git a/plugins/prefixIds.js b/plugins/prefixIds.js
index eb5145527..ec305c6b0 100644
--- a/plugins/prefixIds.js
+++ b/plugins/prefixIds.js
@@ -173,15 +173,12 @@ exports.fn = (_root, params, info) => {
                 node.name = prefixId(prefixGenerator, node.name);
                 return;
               }
-              // @ts-ignore csstree v2 changed this type
               if (node.type === 'Url' && node.value.length > 0) {
                 const prefixed = prefixReference(
                   prefixGenerator,
-                  // @ts-ignore
                   unquote(node.value),
                 );
                 if (prefixed != null) {
-                  // @ts-ignore
                   node.value = prefixed;
                 }
               }
diff --git a/yarn.lock b/yarn.lock
index 4f417bb81..e6b23d23c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -976,10 +976,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/css-tree@npm:*, @types/css-tree@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "@types/css-tree@npm:2.0.0"
-  checksum: 52d89f5c52c6ec5feac674a3f28f35994211f26c662cc8718f21ebabad992329e8c810da1e070aa61c49f89e92cd5ef7b460e81de52f0d0f5973618d87ebc3ae
+"@types/css-tree@npm:*, @types/css-tree@npm:^2.3.4":
+  version: 2.3.4
+  resolution: "@types/css-tree@npm:2.3.4"
+  checksum: b06173d3ae048b74e7030cceae01d3d6e5589f7348e8e4b907427f91baeda76807bbde8c5be4c41e22b952268b46edcba7ab96e16efedb2d0b37ce2bf90d1835
   languageName: node
   linkType: hard
 
@@ -1687,7 +1687,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"css-tree@npm:^2.2.1, css-tree@npm:~2.2.0":
+"css-tree@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "css-tree@npm:2.3.1"
+  dependencies:
+    mdn-data: 2.0.30
+    source-map-js: ^1.0.1
+  checksum: 493cc24b5c22b05ee5314b8a0d72d8a5869491c1458017ae5ed75aeb6c3596637dbe1b11dac2548974624adec9f7a1f3a6cf40593dc1f9185eb0e8279543fbc0
+  languageName: node
+  linkType: hard
+
+"css-tree@npm:~2.2.0":
   version: 2.2.1
   resolution: "css-tree@npm:2.2.1"
   dependencies:
@@ -3390,6 +3400,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"mdn-data@npm:2.0.30":
+  version: 2.0.30
+  resolution: "mdn-data@npm:2.0.30"
+  checksum: d6ac5ac7439a1607df44b22738ecf83f48e66a0874e4482d6424a61c52da5cde5750f1d1229b6f5fa1b80a492be89465390da685b11f97d62b8adcc6e88189aa
+  languageName: node
+  linkType: hard
+
 "merge-stream@npm:^2.0.0":
   version: 2.0.0
   resolution: "merge-stream@npm:2.0.0"
@@ -4429,12 +4446,12 @@ __metadata:
     "@rollup/plugin-commonjs": ^22.0.2
     "@rollup/plugin-node-resolve": ^14.1.0
     "@trysound/sax": 0.2.0
-    "@types/css-tree": ^2.0.0
+    "@types/css-tree": ^2.3.4
     "@types/csso": ^5.0.4
     "@types/jest": ^29.5.5
     commander: ^7.2.0
     css-select: ^5.1.0
-    css-tree: ^2.2.1
+    css-tree: ^2.3.1
     css-what: ^6.1.0
     csso: ^5.0.5
     del: ^6.0.0

From f238d6a213a499deed31895d7ebbf139eb9996c5 Mon Sep 17 00:00:00 2001
From: Kendell R <KTibow@users.noreply.github.com>
Date: Wed, 27 Dec 2023 18:41:09 -0500
Subject: [PATCH 11/20] feat(convertPathData): allow converting q to t in more
 cases (#1889)

---
 plugins/convertPathData.js          | 52 +++++++++++++++++++++++++----
 test/plugins/convertPathData.34.svg | 16 +++++++++
 2 files changed, 61 insertions(+), 7 deletions(-)
 create mode 100644 test/plugins/convertPathData.34.svg

diff --git a/plugins/convertPathData.js b/plugins/convertPathData.js
index 2a6c66507..0ee7824ea 100644
--- a/plugins/convertPathData.js
+++ b/plugins/convertPathData.js
@@ -397,8 +397,13 @@ function filters(
     relSubpoint = [0, 0],
     pathBase = [0, 0],
     prev = {};
+  /** @type {Point | undefined} */
+  let qControlPoint;
 
   path = path.filter(function (item, index, path) {
+    const qPoint = qControlPoint;
+    qControlPoint = undefined;
+
     let command = item.command;
     let data = item.args;
     let next = path[index + 1];
@@ -795,14 +800,24 @@ function filters(
           // t + q → t + t
           else if (
             // @ts-ignore
-            prev.command === 't' &&
-            // @ts-ignore
-            Math.abs(data[2] - prev.args[0]) < error &&
-            // @ts-ignore
-            Math.abs(data[3] - prev.args[1]) < error
+            prev.command === 't'
           ) {
-            command = 't';
-            data = data.slice(2);
+            // @ts-ignore
+            const predictedControlPoint = reflectPoint(qPoint, item.base);
+            const realControlPoint = [
+              // @ts-ignore
+              data[0] + item.base[0],
+              // @ts-ignore
+              data[1] + item.base[1],
+            ];
+            if (
+              Math.abs(predictedControlPoint[0] - realControlPoint[0]) <
+                error &&
+              Math.abs(predictedControlPoint[1] - realControlPoint[1]) < error
+            ) {
+              command = 't';
+              data = data.slice(2);
+            }
           }
         }
       }
@@ -873,6 +888,18 @@ function filters(
     )
       return false;
 
+    if (command === 'q') {
+      // @ts-ignore
+      qControlPoint = [data[0] + item.base[0], data[1] + item.base[1]];
+    } else if (command === 't') {
+      if (qPoint) {
+        // @ts-ignore
+        qControlPoint = reflectPoint(qPoint, item.base);
+      } else {
+        // @ts-ignore
+        qControlPoint = item.coords;
+      }
+    }
     prev = item;
     return true;
   });
@@ -1138,6 +1165,17 @@ function getDistance(point1, point2) {
   return Math.hypot(point1[0] - point2[0], point1[1] - point2[1]);
 }
 
+/**
+ * Reflects point across another point
+ *
+ * @param {Point} input
+ * @param {Point} base
+ * @returns {Point}
+ */
+function reflectPoint(input, base) {
+  return [2 * base[0] - input[0], 2 * base[1] - input[1]];
+}
+
 /**
  * Returns coordinates of the curve point corresponding to the certain t
  * a·(1 - t)³·p1 + b·(1 - t)²·t·p2 + c·(1 - t)·t²·p3 + d·t³·p4,
diff --git a/test/plugins/convertPathData.34.svg b/test/plugins/convertPathData.34.svg
new file mode 100644
index 000000000..a6e3eba41
--- /dev/null
+++ b/test/plugins/convertPathData.34.svg
@@ -0,0 +1,16 @@
+Shouldn't incorrectly convert q to t. Should convert q to t when feasible.
+
+===
+
+<svg viewBox="0 0 20 20">
+    <path d="M0 0q2 0 5 5t5 5q5 0 5 5"/>
+    <path d="M0 0q2 0 5 5t5 5q2 0 5-2"/>
+</svg>
+
+@@@
+
+
+<svg viewBox="0 0 20 20">
+    <path d="M0 0q2 0 5 5t5 5q5 0 5 5"/>
+    <path d="M0 0q2 0 5 5t5 5 5-2"/>
+</svg>

From 433dcefd646edba35b015fc4f567077a79d1d8ee Mon Sep 17 00:00:00 2001
From: Seth Falco <seth@falco.fun>
Date: Thu, 28 Dec 2023 17:51:19 +0000
Subject: [PATCH 12/20] refactor(convertPaths): clean up plugin (#1913)

---
 plugins/convertPathData.js | 125 +++++++++++--------------------------
 1 file changed, 36 insertions(+), 89 deletions(-)

diff --git a/plugins/convertPathData.js b/plugins/convertPathData.js
index 0ee7824ea..e8d8350e1 100644
--- a/plugins/convertPathData.js
+++ b/plugins/convertPathData.js
@@ -15,25 +15,15 @@ exports.name = 'convertPathData';
 exports.description =
   'optimizes path data: writes in shorter form, applies transformations';
 
-/**
- * @type {(data: number[]) => number[]}
- */
+/** @type {(data: number[]) => number[]} */
 let roundData;
-/**
- * @type {number | false}
- */
+/** @type {number | false} */
 let precision;
-/**
- * @type {number}
- */
+/** @type {number} */
 let error;
-/**
- * @type {number}
- */
+/** @type {number} */
 let arcThreshold;
-/**
- * @type {number}
- */
+/** @type {number} */
 let arcTolerance;
 
 /**
@@ -393,16 +383,17 @@ function filters(
   params,
   { isSafeToUseZ, maybeHasStrokeAndLinecap, hasMarkerMid },
 ) {
-  var stringify = data2Path.bind(null, params),
-    relSubpoint = [0, 0],
-    pathBase = [0, 0],
-    prev = {};
+  const stringify = data2Path.bind(null, params);
+  const relSubpoint = [0, 0];
+  const pathBase = [0, 0];
+  /** @type {any} */
+  let prev = {};
   /** @type {Point | undefined} */
-  let qControlPoint;
+  let prevQControlPoint;
 
   path = path.filter(function (item, index, path) {
-    const qPoint = qControlPoint;
-    qControlPoint = undefined;
+    const qControlPoint = prevQControlPoint;
+    prevQControlPoint = undefined;
 
     let command = item.command;
     let data = item.args;
@@ -415,9 +406,8 @@ function filters(
       if (command === 's') {
         sdata = [0, 0].concat(data);
 
-        // @ts-ignore
-        var pdata = prev.args,
-          n = pdata.length;
+        const pdata = prev.args;
+        const n = pdata.length;
 
         // (-x, -y) of the prev tangent point relative to the current point
         sdata[0] = pdata[n - 2] - pdata[n - 4];
@@ -464,16 +454,11 @@ function filters(
           nextLonghand;
 
         if (
-          // @ts-ignore
           (prev.command == 'c' &&
-            // @ts-ignore
             isConvex(prev.args) &&
-            // @ts-ignore
             isArcPrev(prev.args, circle)) ||
-          // @ts-ignore
           (prev.command == 'a' && prev.sdata && isArcPrev(prev.sdata, circle))
         ) {
-          // @ts-ignore
           arcCurves.unshift(prev);
           // @ts-ignore
           arc.base = prev.base;
@@ -481,7 +466,6 @@ function filters(
           arc.args[5] = arc.coords[0] - arc.base[0];
           // @ts-ignore
           arc.args[6] = arc.coords[1] - arc.base[1];
-          // @ts-ignore
           var prevData = prev.command == 'a' ? prev.sdata : prev.args;
           var prevAngle = findArcAngle(prevData, {
             center: [
@@ -498,7 +482,7 @@ function filters(
         // check if next curves are fitting the arc
         for (
           var j = index;
-          (next = path[++j]) && ~'cs'.indexOf(next.command);
+          (next = path[++j]) && 'cs'.includes(next.command);
 
         ) {
           var nextData = next.args;
@@ -574,7 +558,6 @@ function filters(
             relSubpoint[0] += prevArc.args[5] - prev.args[prev.args.length - 2];
             // @ts-ignore
             relSubpoint[1] += prevArc.args[6] - prev.args[prev.args.length - 1];
-            // @ts-ignore
             prev.command = 'a';
             // @ts-ignore
             prev.args = prevArc.args;
@@ -588,11 +571,7 @@ function filters(
             item.sdata = sdata.slice(); // preserve curve data for future checks
           } else if (arcCurves.length - 1 - hasPrev > 0) {
             // filter out consumed next items
-            path.splice.apply(
-              path,
-              // @ts-ignore
-              [index + 1, arcCurves.length - 1 - hasPrev].concat(output),
-            );
+            path.splice(index + 1, arcCurves.length - 1 - hasPrev, ...output);
           }
           if (!arc) return false;
           command = 'a';
@@ -679,9 +658,7 @@ function filters(
           data = data.slice(-2);
         } else if (
           command === 't' &&
-          // @ts-ignore
           prev.command !== 'q' &&
-          // @ts-ignore
           prev.command !== 't'
         ) {
           command = 'l';
@@ -716,39 +693,29 @@ function filters(
         params.collapseRepeated &&
         hasMarkerMid === false &&
         (command === 'm' || command === 'h' || command === 'v') &&
-        // @ts-ignore
         prev.command &&
-        // @ts-ignore
         command == prev.command.toLowerCase() &&
         ((command != 'h' && command != 'v') ||
-          // @ts-ignore
           prev.args[0] >= 0 == data[0] >= 0)
       ) {
-        // @ts-ignore
         prev.args[0] += data[0];
         if (command != 'h' && command != 'v') {
-          // @ts-ignore
           prev.args[1] += data[1];
         }
         // @ts-ignore
         prev.coords = item.coords;
-        // @ts-ignore
         path[index] = prev;
         return false;
       }
 
       // convert curves into smooth shorthands
-      // @ts-ignore
       if (params.curveSmoothShorthands && prev.command) {
         // curveto
         if (command === 'c') {
           // c + c → c + s
           if (
-            // @ts-ignore
             prev.command === 'c' &&
-            // @ts-ignore
             Math.abs(data[0] - -(prev.args[2] - prev.args[4])) < error &&
-            // @ts-ignore
             Math.abs(data[1] - -(prev.args[3] - prev.args[5])) < error
           ) {
             command = 's';
@@ -757,11 +724,8 @@ function filters(
 
           // s + c → s + s
           else if (
-            // @ts-ignore
             prev.command === 's' &&
-            // @ts-ignore
             Math.abs(data[0] - -(prev.args[0] - prev.args[2])) < error &&
-            // @ts-ignore
             Math.abs(data[1] - -(prev.args[1] - prev.args[3])) < error
           ) {
             command = 's';
@@ -770,9 +734,7 @@ function filters(
 
           // [^cs] + c → [^cs] + s
           else if (
-            // @ts-ignore
             prev.command !== 'c' &&
-            // @ts-ignore
             prev.command !== 's' &&
             Math.abs(data[0]) < error &&
             Math.abs(data[1]) < error
@@ -786,11 +748,8 @@ function filters(
         else if (command === 'q') {
           // q + q → q + t
           if (
-            // @ts-ignore
             prev.command === 'q' &&
-            // @ts-ignore
             Math.abs(data[0] - (prev.args[2] - prev.args[0])) < error &&
-            // @ts-ignore
             Math.abs(data[1] - (prev.args[3] - prev.args[1])) < error
           ) {
             command = 't';
@@ -798,12 +757,13 @@ function filters(
           }
 
           // t + q → t + t
-          else if (
-            // @ts-ignore
-            prev.command === 't'
-          ) {
-            // @ts-ignore
-            const predictedControlPoint = reflectPoint(qPoint, item.base);
+          else if (prev.command === 't') {
+            const predictedControlPoint = reflectPoint(
+              // @ts-ignore
+              qControlPoint,
+              // @ts-ignore
+              item.base,
+            );
             const realControlPoint = [
               // @ts-ignore
               data[0] + item.base[0],
@@ -837,14 +797,12 @@ function filters(
             return i === 0;
           })
         ) {
-          // @ts-ignore
           path[index] = prev;
           return false;
         }
 
         // a 25,25 -30 0,1 0,0
         if (command === 'a' && data[5] === 0 && data[6] === 0) {
-          // @ts-ignore
           path[index] = prev;
           return false;
         }
@@ -874,7 +832,6 @@ function filters(
       // z resets coordinates
       relSubpoint[0] = pathBase[0];
       relSubpoint[1] = pathBase[1];
-      // @ts-ignore
       if (prev.command === 'Z' || prev.command === 'z') return false;
     }
     if (
@@ -890,14 +847,14 @@ function filters(
 
     if (command === 'q') {
       // @ts-ignore
-      qControlPoint = [data[0] + item.base[0], data[1] + item.base[1]];
+      prevQControlPoint = [data[0] + item.base[0], data[1] + item.base[1]];
     } else if (command === 't') {
-      if (qPoint) {
+      if (qControlPoint) {
         // @ts-ignore
-        qControlPoint = reflectPoint(qPoint, item.base);
+        prevQControlPoint = reflectPoint(qControlPoint, item.base);
       } else {
         // @ts-ignore
-        qControlPoint = item.coords;
+        prevQControlPoint = item.coords;
       }
     }
     prev = item;
@@ -971,8 +928,9 @@ function convertToMixed(path, params) {
           prev.command.charCodeAt(0) > 96 &&
           absoluteDataStr.length == relativeDataStr.length - 1 &&
           (data[0] < 0 ||
-            // @ts-ignore
-            (/^0\./.test(data[0]) && prev.args[prev.args.length - 1] % 1))
+            (Math.floor(data[0]) === 0 &&
+              !Number.isInteger(data[0]) &&
+              prev.args[prev.args.length - 1] % 1))
         ))
     ) {
       // @ts-ignore
@@ -981,7 +939,6 @@ function convertToMixed(path, params) {
     }
 
     prev = item;
-
     return true;
   });
 
@@ -1098,7 +1055,6 @@ function round(data) {
  *
  * @type {(data: number[]) => boolean}
  */
-
 function isCurveStraightLine(data) {
   // Get line equation a·x + b·y + c = 0 coefficients a, b (c = 0) by start and end points.
   var i = data.length - 2,
@@ -1125,7 +1081,6 @@ function isCurveStraightLine(data) {
  */
 function calculateSagitta(data) {
   if (data[3] === 1) return undefined;
-
   const [rx, ry] = data;
   if (Math.abs(rx - ry) > error) return undefined;
   const chord = Math.sqrt(data[5] ** 2 + data[6] ** 2);
@@ -1138,7 +1093,6 @@ function calculateSagitta(data) {
  *
  * @type {(item: PathDataItem, data: number[]) => PathDataItem}
  */
-
 function makeLonghand(item, data) {
   switch (item.command) {
     case 's':
@@ -1160,20 +1114,19 @@ function makeLonghand(item, data) {
  *
  * @type {(point1: Point, point2: Point) => number}
  */
-
 function getDistance(point1, point2) {
-  return Math.hypot(point1[0] - point2[0], point1[1] - point2[1]);
+  return Math.sqrt((point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2);
 }
 
 /**
- * Reflects point across another point
+ * Reflects point across another point.
  *
- * @param {Point} input
+ * @param {Point} controlPoint
  * @param {Point} base
  * @returns {Point}
  */
-function reflectPoint(input, base) {
-  return [2 * base[0] - input[0], 2 * base[1] - input[1]];
+function reflectPoint(controlPoint, base) {
+  return [2 * base[0] - controlPoint[0], 2 * base[1] - controlPoint[1]];
 }
 
 /**
@@ -1183,7 +1136,6 @@ function reflectPoint(input, base) {
  *
  * @type {(curve: number[], t: number) => Point}
  */
-
 function getCubicBezierPoint(curve, t) {
   var sqrT = t * t,
     cubT = sqrT * t,
@@ -1201,7 +1153,6 @@ function getCubicBezierPoint(curve, t) {
  *
  * @type {(curve: number[]) => undefined | Circle}
  */
-
 function findCircle(curve) {
   var midPoint = getCubicBezierPoint(curve, 1 / 2),
     m1 = [midPoint[0] / 2, midPoint[1] / 2],
@@ -1242,7 +1193,6 @@ function findCircle(curve) {
  *
  * @type {(curve: number[], circle: Circle) => boolean}
  */
-
 function isArc(curve, circle) {
   var tolerance = Math.min(
     arcThreshold * error,
@@ -1264,7 +1214,6 @@ function isArc(curve, circle) {
  *
  * @type {(curve: number[], circle: Circle) => boolean}
  */
-
 function isArcPrev(curve, circle) {
   return isArc(curve, {
     center: [circle.center[0] + curve[4], circle.center[1] + curve[5]],
@@ -1277,7 +1226,6 @@ function isArcPrev(curve, circle) {
 
  * @type {(curve: number[], relCircle: Circle) => number}
  */
-
 function findArcAngle(curve, relCircle) {
   var x1 = -relCircle.center[0],
     y1 = -relCircle.center[1],
@@ -1294,7 +1242,6 @@ function findArcAngle(curve, relCircle) {
  *
  * @type {(params: InternalParams, pathData: PathDataItem[]) => string}
  */
-
 function data2Path(params, pathData) {
   return pathData.reduce(function (pathString, item) {
     var strData = '';

From db05c5782a02b3c137800cb04098bb1ef5b552bf Mon Sep 17 00:00:00 2001
From: Jon Dufresne <jon.dufresne@gmail.com>
Date: Thu, 28 Dec 2023 14:06:05 -0500
Subject: [PATCH 13/20] chore: Use idiomatic Jest patterns to assert exceptions
 (#1909)

---
 lib/svgo-node.test.js   | 61 +++++++++++++----------------------------
 lib/svgo.test.js        |  8 +++---
 test/coa/_index.test.js | 30 ++++++++------------
 3 files changed, 34 insertions(+), 65 deletions(-)

diff --git a/lib/svgo-node.test.js b/lib/svgo-node.test.js
index 1b474e4af..2cf23dff0 100644
--- a/lib/svgo-node.test.js
+++ b/lib/svgo-node.test.js
@@ -156,56 +156,33 @@ describe('loadConfig', () => {
   });
 
   test('fails when specified config does not exist', async () => {
-    try {
-      await loadConfig('{}');
-      expect.fail('Config is loaded successfully');
-    } catch (error) {
-      expect(error.message).toMatch(/Cannot find module/);
-    }
+    await expect(loadConfig('{}')).rejects.toThrow(/Cannot find module/);
   });
 
   test('fails when exported config not an object', async () => {
-    try {
-      await loadConfig(path.join(fixtures, 'invalid-null.js'));
-      expect.fail('Config is loaded successfully');
-    } catch (error) {
-      expect(error.message).toMatch(/Invalid config file/);
-    }
-    try {
-      await loadConfig(path.join(fixtures, 'invalid-array.js'));
-      expect.fail('Config is loaded successfully');
-    } catch (error) {
-      expect(error.message).toMatch(/Invalid config file/);
-    }
-    try {
-      await loadConfig(path.join(fixtures, 'invalid-string.js'));
-      expect.fail('Config is loaded successfully');
-    } catch (error) {
-      expect(error.message).toMatch(/Invalid config file/);
-    }
+    await expect(
+      loadConfig(path.join(fixtures, 'invalid-null.js')),
+    ).rejects.toThrow(/Invalid config file/);
+    await expect(
+      loadConfig(path.join(fixtures, 'invalid-array.js')),
+    ).rejects.toThrow(/Invalid config file/);
+    await expect(
+      loadConfig(path.join(fixtures, 'invalid-string.js')),
+    ).rejects.toThrow(/Invalid config file/);
   });
 
   test('handles runtime errors properly', async () => {
-    try {
-      await loadConfig(path.join(fixtures, 'invalid-runtime.js'));
-      expect.fail('Config is loaded successfully');
-    } catch (error) {
-      expect(error.message).toMatch(/plugins is not defined/);
-    }
-    try {
-      await loadConfig(path.join(fixtures, 'invalid-runtime.mjs'));
-      expect.fail('Config is loaded successfully');
-    } catch (error) {
-      expect(error.message).toMatch(/plugins is not defined/);
-    }
+    await expect(
+      loadConfig(path.join(fixtures, 'invalid-runtime.js')),
+    ).rejects.toThrow(/plugins is not defined/);
+    await expect(
+      loadConfig(path.join(fixtures, 'invalid-runtime.mjs')),
+    ).rejects.toThrow(/plugins is not defined/);
   });
 
   test('handles MODULE_NOT_FOUND properly', async () => {
-    try {
-      await loadConfig(path.join(fixtures, 'module-not-found.js'));
-      expect.fail('Config is loaded successfully');
-    } catch (error) {
-      expect(error.message).toMatch(/Cannot find module 'unknown-module'/);
-    }
+    await expect(
+      loadConfig(path.join(fixtures, 'module-not-found.js')),
+    ).rejects.toThrow(/Cannot find module 'unknown-module'/);
   });
 });
diff --git a/lib/svgo.test.js b/lib/svgo.test.js
index 68fb8d7ea..468a894ab 100644
--- a/lib/svgo.test.js
+++ b/lib/svgo.test.js
@@ -267,13 +267,13 @@ test('plugin precision should override preset precision', () => {
 });
 
 test('provides informative error in result', () => {
+  expect.assertions(6);
   const svg = `<svg viewBox="0 0 120 120">
       <circle fill="#ff0000" cx=60.444444" cy="60" r="50"/>
     </svg>
   `;
   try {
     optimize(svg, { path: 'test.svg' });
-    expect(true).toEqual(false);
   } catch (error) {
     expect(error.name).toEqual('SvgoParserError');
     expect(error.message).toEqual('test.svg:2:33: Unquoted attribute value');
@@ -285,13 +285,13 @@ test('provides informative error in result', () => {
 });
 
 test('provides code snippet in rendered error', () => {
+  expect.assertions(1);
   const svg = `<svg viewBox="0 0 120 120">
   <circle fill="#ff0000" cx=60.444444" cy="60" r="50"/>
 </svg>
 `;
   try {
     optimize(svg, { path: 'test.svg' });
-    expect(true).toEqual(false);
   } catch (error) {
     expect(error.toString())
       .toEqual(`SvgoParserError: test.svg:2:29: Unquoted attribute value
@@ -306,6 +306,7 @@ test('provides code snippet in rendered error', () => {
 });
 
 test('supports errors without path', () => {
+  expect.assertions(1);
   const svg = `<svg viewBox="0 0 120 120">
   <circle/>
   <circle/>
@@ -321,7 +322,6 @@ test('supports errors without path', () => {
 `;
   try {
     optimize(svg);
-    expect(true).toEqual(false);
   } catch (error) {
     expect(error.toString())
       .toEqual(`SvgoParserError: <input>:11:29: Unquoted attribute value
@@ -337,13 +337,13 @@ test('supports errors without path', () => {
 });
 
 test('slices long line in error code snippet', () => {
+  expect.assertions(1);
   const svg = `<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" viewBox="0 0 230 120">
   <path d="M318.198 551.135 530.33 918.56l-289.778-77.646 38.823-144.889c77.646-289.778 294.98-231.543 256.156-86.655s178.51 203.124 217.334 58.235q58.234-217.334 250.955 222.534t579.555 155.292z stroke-width="1.5" fill="red" stroke="red" />
 </svg>
 `;
   try {
     optimize(svg);
-    expect(true).toEqual(false);
   } catch (error) {
     expect(error.toString())
       .toEqual(`SvgoParserError: <input>:2:211: Invalid attribute name
diff --git a/test/coa/_index.test.js b/test/coa/_index.test.js
index aed055c41..4fbb7d1d1 100644
--- a/test/coa/_index.test.js
+++ b/test/coa/_index.test.js
@@ -124,15 +124,11 @@ describe('coa', function () {
   it('should throw error when stated in input folder does not exist', async () => {
     replaceConsoleError();
     try {
-      await runProgram([
-        '--input',
-        svgFolderPath + 'temp',
-        '--output',
-        tempFolder,
-      ]);
-    } catch (error) {
+      await expect(
+        runProgram(['--input', svgFolderPath + 'temp', '--output', tempFolder]),
+      ).rejects.toThrow(/no such file or directory/);
+    } finally {
       restoreConsoleError();
-      expect(error.message).toMatch(/no such file or directory/);
     }
   });
 
@@ -142,23 +138,19 @@ describe('coa', function () {
       if (!fs.existsSync(emptyFolderPath)) {
         fs.mkdirSync(emptyFolderPath);
       }
-      try {
-        await runProgram(['--folder', emptyFolderPath, '--quiet']);
-      } catch (error) {
-        expect(error.message).toMatch(/No SVG files/);
-      }
+      await expect(
+        runProgram(['--folder', emptyFolderPath, '--quiet']),
+      ).rejects.toThrow(/No SVG files/);
     });
 
     it('should show message when folder does not consists any svg files', async () => {
-      try {
-        await runProgram([
+      await expect(
+        runProgram([
           '--folder',
           path.resolve(__dirname, 'testFolderWithNoSvg'),
           '--quiet',
-        ]);
-      } catch (error) {
-        expect(error.message).toMatch(/No SVG files have been found/);
-      }
+        ]),
+      ).rejects.toThrow(/No SVG files have been found/);
     });
   });
 });

From f6a2ca20d6472cb0f2b18dadd626d6db092f8767 Mon Sep 17 00:00:00 2001
From: Jon Dufresne <jon.dufresne@gmail.com>
Date: Thu, 28 Dec 2023 14:14:47 -0500
Subject: [PATCH 14/20] chore: improve jest tests with more precise assertions
 (#1912)

---
 lib/path.test.js               |  44 +++++++-------
 lib/style.test.js              | 102 ++++++++++++++++++++-------------
 lib/svgo-node.test.js          |  34 ++++++-----
 lib/svgo.test.js               |  40 ++++++-------
 lib/xast.test.js               |  12 ++--
 test/cli/cli.test.js           |  12 ++--
 test/plugins/_index.test.js    |   4 +-
 test/plugins/prefixIds.test.js |   6 +-
 test/svg2js/_index.test.js     |  14 ++---
 test/svgo/_index.test.js       |  18 +++---
 10 files changed, 149 insertions(+), 137 deletions(-)

diff --git a/lib/path.test.js b/lib/path.test.js
index 91e6eaa91..7fe7c5156 100644
--- a/lib/path.test.js
+++ b/lib/path.test.js
@@ -8,55 +8,55 @@ const { parsePathData, stringifyPathData } = require('./path.js');
 
 describe('parse path data', () => {
   it('should allow spaces between commands', () => {
-    expect(parsePathData('M0 10 L \n\r\t20 30')).toEqual([
+    expect(parsePathData('M0 10 L \n\r\t20 30')).toStrictEqual([
       { command: 'M', args: [0, 10] },
       { command: 'L', args: [20, 30] },
     ]);
   });
   it('should allow spaces and commas between arguments', () => {
-    expect(parsePathData('M0 , 10 L 20 \n\r\t30,40,50')).toEqual([
+    expect(parsePathData('M0 , 10 L 20 \n\r\t30,40,50')).toStrictEqual([
       { command: 'M', args: [0, 10] },
       { command: 'L', args: [20, 30] },
       { command: 'L', args: [40, 50] },
     ]);
   });
   it('should forbid commas before commands', () => {
-    expect(parsePathData(', M0 10')).toEqual([]);
+    expect(parsePathData(', M0 10')).toStrictEqual([]);
   });
   it('should forbid commas between commands', () => {
-    expect(parsePathData('M0,10 , L 20,30')).toEqual([
+    expect(parsePathData('M0,10 , L 20,30')).toStrictEqual([
       { command: 'M', args: [0, 10] },
     ]);
   });
   it('should forbid commas between command name and argument', () => {
-    expect(parsePathData('M0,10 L,20,30')).toEqual([
+    expect(parsePathData('M0,10 L,20,30')).toStrictEqual([
       { command: 'M', args: [0, 10] },
     ]);
   });
   it('should forbid multiple commas in a row', () => {
-    expect(parsePathData('M0 , , 10')).toEqual([]);
+    expect(parsePathData('M0 , , 10')).toStrictEqual([]);
   });
   it('should stop when unknown char appears', () => {
-    expect(parsePathData('M0 10 , L 20 #40')).toEqual([
+    expect(parsePathData('M0 10 , L 20 #40')).toStrictEqual([
       { command: 'M', args: [0, 10] },
     ]);
   });
   it('should stop when not enough arguments', () => {
-    expect(parsePathData('M0 10 L 20 L 30 40')).toEqual([
+    expect(parsePathData('M0 10 L 20 L 30 40')).toStrictEqual([
       { command: 'M', args: [0, 10] },
     ]);
   });
   it('should stop if moveto not the first command', () => {
-    expect(parsePathData('L 10 20')).toEqual([]);
-    expect(parsePathData('10 20')).toEqual([]);
+    expect(parsePathData('L 10 20')).toStrictEqual([]);
+    expect(parsePathData('10 20')).toStrictEqual([]);
   });
   it('should stop on invalid scientific notation', () => {
-    expect(parsePathData('M 0 5e++1 L 0 0')).toEqual([
+    expect(parsePathData('M 0 5e++1 L 0 0')).toStrictEqual([
       { command: 'M', args: [0, 5] },
     ]);
   });
   it('should stop on invalid numbers', () => {
-    expect(parsePathData('M ...')).toEqual([]);
+    expect(parsePathData('M ...')).toStrictEqual([]);
   });
   it('should handle arcs', () => {
     expect(
@@ -71,7 +71,7 @@ describe('parse path data', () => {
           l 50,-25
         `,
       ),
-    ).toEqual([
+    ).toStrictEqual([
       { command: 'M', args: [600, 350] },
       { command: 'l', args: [50, -25] },
       { command: 'a', args: [25, 25, -30, 0, 1, 50, -25] },
@@ -96,7 +96,7 @@ describe('stringify path data', () => {
           { command: 'H', args: [50] },
         ],
       }),
-    ).toEqual('M0 0h10 20 30H40 50');
+    ).toBe('M0 0h10 20 30H40 50');
   });
   it('should not combine sequence of moveto', () => {
     expect(
@@ -108,7 +108,7 @@ describe('stringify path data', () => {
           { command: 'm', args: [40, 50] },
         ],
       }),
-    ).toEqual('M0 0M10 10m20 30m40 50');
+    ).toBe('M0 0M10 10m20 30m40 50');
   });
   it('should combine moveto and sequence of lineto', () => {
     expect(
@@ -122,7 +122,7 @@ describe('stringify path data', () => {
           { command: 'L', args: [10, 10] },
         ],
       }),
-    ).toEqual('m0 0 10 10M0 0l10 10M0 0 10 10');
+    ).toBe('m0 0 10 10M0 0l10 10M0 0 10 10');
     expect(
       stringifyPathData({
         pathData: [
@@ -130,7 +130,7 @@ describe('stringify path data', () => {
           { command: 'L', args: [10, 10] },
         ],
       }),
-    ).toEqual('M0 0 10 10');
+    ).toBe('M0 0 10 10');
   });
   it('should avoid space before first, negative and decimals', () => {
     expect(
@@ -142,7 +142,7 @@ describe('stringify path data', () => {
           { command: 'L', args: [7, 0.8] },
         ],
       }),
-    ).toEqual('M0-1.2.3 4 5-.6 7 .8');
+    ).toBe('M0-1.2.3 4 5-.6 7 .8');
   });
   it('should configure precision', () => {
     /**
@@ -159,13 +159,13 @@ describe('stringify path data', () => {
         pathData,
         precision: 3,
       }),
-    ).toEqual('M0-1.988.3 3.142-.3-3.142 100 200');
+    ).toBe('M0-1.988.3 3.142-.3-3.142 100 200');
     expect(
       stringifyPathData({
         pathData,
         precision: 0,
       }),
-    ).toEqual('M0-2 0 3 0-3 100 200');
+    ).toBe('M0-2 0 3 0-3 100 200');
   });
   it('allows to avoid spaces after arc flags', () => {
     /**
@@ -182,12 +182,12 @@ describe('stringify path data', () => {
         pathData,
         disableSpaceAfterFlags: false,
       }),
-    ).toEqual('M0 0A50 50 10 1 0 .2 20a50 50 10 1 0 .2 20 50 50 10 1 0 .2 20');
+    ).toBe('M0 0A50 50 10 1 0 .2 20a50 50 10 1 0 .2 20 50 50 10 1 0 .2 20');
     expect(
       stringifyPathData({
         pathData,
         disableSpaceAfterFlags: true,
       }),
-    ).toEqual('M0 0A50 50 10 10.2 20a50 50 10 10.2 20 50 50 10 10.2 20');
+    ).toBe('M0 0A50 50 10 10.2 20a50 50 10 10.2 20 50 50 10 10.2 20');
   });
 });
diff --git a/lib/style.test.js b/lib/style.test.js
index b5e1b2c72..48a0779b2 100644
--- a/lib/style.test.js
+++ b/lib/style.test.js
@@ -58,31 +58,35 @@ it('collects styles', () => {
       </svg>
     `);
   const stylesheet = collectStylesheet(root);
-  expect(computeStyle(stylesheet, getElementById(root, 'class'))).toEqual({
-    fill: { type: 'static', inherited: false, value: 'red' },
-  });
-  expect(computeStyle(stylesheet, getElementById(root, 'two-classes'))).toEqual(
+  expect(computeStyle(stylesheet, getElementById(root, 'class'))).toStrictEqual(
     {
-      fill: { type: 'static', inherited: false, value: 'green' },
-      stroke: { type: 'static', inherited: false, value: 'black' },
+      fill: { type: 'static', inherited: false, value: 'red' },
     },
   );
-  expect(computeStyle(stylesheet, getElementById(root, 'attribute'))).toEqual({
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'two-classes')),
+  ).toStrictEqual({
+    fill: { type: 'static', inherited: false, value: 'green' },
+    stroke: { type: 'static', inherited: false, value: 'black' },
+  });
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'attribute')),
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'purple' },
   });
   expect(
     computeStyle(stylesheet, getElementById(root, 'inline-style')),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'grey' },
   });
-  expect(computeStyle(stylesheet, getElementById(root, 'inheritance'))).toEqual(
-    {
-      fill: { type: 'static', inherited: true, value: 'yellow' },
-    },
-  );
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'inheritance')),
+  ).toStrictEqual({
+    fill: { type: 'static', inherited: true, value: 'yellow' },
+  });
   expect(
     computeStyle(stylesheet, getElementById(root, 'nested-inheritance')),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: true, value: 'blue' },
   });
 });
@@ -107,12 +111,12 @@ it('prioritizes different kinds of styles', () => {
   const stylesheet = collectStylesheet(root);
   expect(
     computeStyle(stylesheet, getElementById(root, 'complex-selector')),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'red' },
   });
   expect(
     computeStyle(stylesheet, getElementById(root, 'override-selector')),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'blue' },
   });
   expect(
@@ -120,12 +124,12 @@ it('prioritizes different kinds of styles', () => {
       stylesheet,
       getElementById(root, 'attribute-over-inheritance'),
     ),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'orange' },
   });
   expect(
     computeStyle(stylesheet, getElementById(root, 'style-rule-over-attribute')),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'blue' },
   });
   expect(
@@ -133,7 +137,7 @@ it('prioritizes different kinds of styles', () => {
       stylesheet,
       getElementById(root, 'inline-style-over-style-rule'),
     ),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'purple' },
   });
 });
@@ -153,7 +157,7 @@ it('prioritizes important styles', () => {
   const stylesheet = collectStylesheet(root);
   expect(
     computeStyle(stylesheet, getElementById(root, 'complex-selector')),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'green' },
   });
   expect(
@@ -161,7 +165,7 @@ it('prioritizes important styles', () => {
       stylesheet,
       getElementById(root, 'style-rule-over-inline-style'),
     ),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'green' },
   });
   expect(
@@ -169,7 +173,7 @@ it('prioritizes important styles', () => {
       stylesheet,
       getElementById(root, 'inline-style-over-style-rule'),
     ),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'purple' },
   });
 });
@@ -195,23 +199,29 @@ it('treats at-rules and pseudo-classes as dynamic styles', () => {
       </svg>
     `);
   const stylesheet = collectStylesheet(root);
-  expect(computeStyle(stylesheet, getElementById(root, 'media-query'))).toEqual(
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'media-query')),
+  ).toStrictEqual({
+    fill: { type: 'dynamic', inherited: false },
+  });
+  expect(computeStyle(stylesheet, getElementById(root, 'hover'))).toStrictEqual(
     {
       fill: { type: 'dynamic', inherited: false },
     },
   );
-  expect(computeStyle(stylesheet, getElementById(root, 'hover'))).toEqual({
-    fill: { type: 'dynamic', inherited: false },
-  });
-  expect(computeStyle(stylesheet, getElementById(root, 'inherited'))).toEqual({
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'inherited')),
+  ).toStrictEqual({
     fill: { type: 'dynamic', inherited: true },
   });
   expect(
     computeStyle(stylesheet, getElementById(root, 'inherited-overriden')),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'blue' },
   });
-  expect(computeStyle(stylesheet, getElementById(root, 'static'))).toEqual({
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'static')),
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'black' },
   });
 });
@@ -234,17 +244,19 @@ it('considers <style> media attribute', () => {
       </svg>
     `);
   const stylesheet = collectStylesheet(root);
-  expect(computeStyle(stylesheet, getElementById(root, 'media-query'))).toEqual(
-    {
-      fill: { type: 'dynamic', inherited: false },
-    },
-  );
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'media-query')),
+  ).toStrictEqual({
+    fill: { type: 'dynamic', inherited: false },
+  });
   expect(
     computeStyle(stylesheet, getElementById(root, 'kinda-static')),
-  ).toEqual({
+  ).toStrictEqual({
     fill: { type: 'dynamic', inherited: false },
   });
-  expect(computeStyle(stylesheet, getElementById(root, 'static'))).toEqual({
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'static')),
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'blue' },
   });
 });
@@ -267,15 +279,19 @@ it('ignores <style> with invalid type', () => {
       </svg>
     `);
   const stylesheet = collectStylesheet(root);
-  expect(computeStyle(stylesheet, getElementById(root, 'valid-type'))).toEqual({
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'valid-type')),
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'red' },
   });
-  expect(computeStyle(stylesheet, getElementById(root, 'empty-type'))).toEqual({
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'empty-type')),
+  ).toStrictEqual({
     fill: { type: 'static', inherited: false, value: 'green' },
   });
   expect(
     computeStyle(stylesheet, getElementById(root, 'invalid-type')),
-  ).toEqual({});
+  ).toStrictEqual({});
 });
 
 it('ignores keyframes atrule', () => {
@@ -301,7 +317,9 @@ it('ignores keyframes atrule', () => {
       </svg>
     `);
   const stylesheet = collectStylesheet(root);
-  expect(computeStyle(stylesheet, getElementById(root, 'element'))).toEqual({
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'element')),
+  ).toStrictEqual({
     animation: {
       type: 'static',
       inherited: false,
@@ -330,7 +348,9 @@ it('ignores @-webkit-keyframes atrule', () => {
       </svg>
     `);
   const stylesheet = collectStylesheet(root);
-  expect(computeStyle(stylesheet, getElementById(root, 'element'))).toEqual({
+  expect(
+    computeStyle(stylesheet, getElementById(root, 'element')),
+  ).toStrictEqual({
     animation: {
       type: 'static',
       inherited: false,
diff --git a/lib/svgo-node.test.js b/lib/svgo-node.test.js
index 2cf23dff0..6a7e51002 100644
--- a/lib/svgo-node.test.js
+++ b/lib/svgo-node.test.js
@@ -23,8 +23,7 @@ describeLF('with LF line-endings', () => {
       </svg>
     `;
     const { data } = optimize(svg);
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120"><circle cx="60" cy="60" r="50" fill="red"/></svg>',
     );
   });
@@ -42,8 +41,7 @@ describeLF('with LF line-endings', () => {
     const { data } = optimize(svg, {
       js2svg: { pretty: true, indent: 2 },
     });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120">\n  <circle cx="60" cy="60" r="50" fill="red"/>\n</svg>\n',
     );
   });
@@ -61,8 +59,7 @@ describeLF('with LF line-endings', () => {
     const { data } = optimize(svg, {
       js2svg: { eol: 'crlf', pretty: true, indent: 2 },
     });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120">\r\n  <circle cx="60" cy="60" r="50" fill="red"/>\r\n</svg>\r\n',
     );
   });
@@ -80,8 +77,7 @@ describeCRLF('with CRLF line-endings', () => {
       </svg>
     `;
     const { data } = optimize(svg);
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120"><circle cx="60" cy="60" r="50" fill="red"/></svg>',
     );
   });
@@ -99,8 +95,7 @@ describeCRLF('with CRLF line-endings', () => {
     const { data } = optimize(svg, {
       js2svg: { pretty: true, indent: 2 },
     });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120">\r\n  <circle cx="60" cy="60" r="50" fill="red"/>\r\n</svg>\r\n',
     );
   });
@@ -118,8 +113,7 @@ describeCRLF('with CRLF line-endings', () => {
     const { data } = optimize(svg, {
       js2svg: { eol: 'lf', pretty: true, indent: 2 },
     });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120">\n  <circle cx="60" cy="60" r="50" fill="red"/>\n</svg>\n',
     );
   });
@@ -130,27 +124,31 @@ describe('loadConfig', () => {
   const fixtures = path.join(cwd, './test/fixtures/config-loader');
 
   test('loads by absolute path', async () => {
-    expect(await loadConfig(path.join(fixtures, 'one/two/config.js'))).toEqual({
+    expect(
+      await loadConfig(path.join(fixtures, 'one/two/config.js')),
+    ).toStrictEqual({
       plugins: [],
     });
   });
 
   test('loads by relative path to cwd', async () => {
     const config = await loadConfig('one/two/config.js', fixtures);
-    expect(config).toEqual({ plugins: [] });
+    expect(config).toStrictEqual({ plugins: [] });
   });
 
   test('searches in cwd and up', async () => {
-    expect(await loadConfig(null, path.join(fixtures, 'one/two'))).toEqual({
+    expect(
+      await loadConfig(null, path.join(fixtures, 'one/two')),
+    ).toStrictEqual({
       plugins: [],
     });
     expect(
       await loadConfig(null, path.join(cwd, './test/fixtures/missing')),
-    ).toEqual(null);
-    expect(await loadConfig(null, path.join(fixtures, 'mjs'))).toEqual({
+    ).toBeNull();
+    expect(await loadConfig(null, path.join(fixtures, 'mjs'))).toStrictEqual({
       plugins: ['mjs'],
     });
-    expect(await loadConfig(null, path.join(fixtures, 'cjs'))).toEqual({
+    expect(await loadConfig(null, path.join(fixtures, 'cjs'))).toStrictEqual({
       plugins: ['cjs'],
     });
   });
diff --git a/lib/svgo.test.js b/lib/svgo.test.js
index 468a894ab..de10d8317 100644
--- a/lib/svgo.test.js
+++ b/lib/svgo.test.js
@@ -109,8 +109,7 @@ describe('allow to configure EOL', () => {
     const { data } = optimize(svg, {
       js2svg: { eol: 'lf', pretty: true, indent: 2 },
     });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120">\n  <circle cx="60" cy="60" r="50" fill="red"/>\n</svg>\n',
     );
   });
@@ -128,8 +127,7 @@ describe('allow to configure EOL', () => {
     const { data } = optimize(svg, {
       js2svg: { eol: 'crlf', pretty: true, indent: 2 },
     });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120">\r\n  <circle cx="60" cy="60" r="50" fill="red"/>\r\n</svg>\r\n',
     );
   });
@@ -147,8 +145,7 @@ describe('allow to configure EOL', () => {
     const { data } = optimize(svg, {
       js2svg: { eol: 'invalid', pretty: true, indent: 2 },
     });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120">\n  <circle cx="60" cy="60" r="50" fill="red"/>\n</svg>\n',
     );
   });
@@ -166,8 +163,7 @@ describe('allow to configure final newline', () => {
       </svg>
     `;
     const { data } = optimize(svg, { js2svg: { eol: 'lf' } });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120"><circle cx="60" cy="60" r="50" fill="red"/></svg>',
     );
   });
@@ -185,8 +181,7 @@ describe('allow to configure final newline', () => {
     const { data } = optimize(svg, {
       js2svg: { finalNewline: true, eol: 'lf' },
     });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120"><circle cx="60" cy="60" r="50" fill="red"/></svg>\n',
     );
   });
@@ -204,8 +199,7 @@ describe('allow to configure final newline', () => {
     const { data } = optimize(svg, {
       js2svg: { finalNewline: true, pretty: true, indent: 2, eol: 'lf' },
     });
-    // using toEqual because line endings matter in these tests
-    expect(data).toEqual(
+    expect(data).toBe(
       '<svg viewBox="0 0 120 120">\n  <circle cx="60" cy="60" r="50" fill="red"/>\n</svg>\n',
     );
   });
@@ -275,12 +269,12 @@ test('provides informative error in result', () => {
   try {
     optimize(svg, { path: 'test.svg' });
   } catch (error) {
-    expect(error.name).toEqual('SvgoParserError');
-    expect(error.message).toEqual('test.svg:2:33: Unquoted attribute value');
-    expect(error.reason).toEqual('Unquoted attribute value');
-    expect(error.line).toEqual(2);
-    expect(error.column).toEqual(33);
-    expect(error.source).toEqual(svg);
+    expect(error.name).toBe('SvgoParserError');
+    expect(error.message).toBe('test.svg:2:33: Unquoted attribute value');
+    expect(error.reason).toBe('Unquoted attribute value');
+    expect(error.line).toBe(2);
+    expect(error.column).toBe(33);
+    expect(error.source).toBe(svg);
   }
 });
 
@@ -294,7 +288,7 @@ test('provides code snippet in rendered error', () => {
     optimize(svg, { path: 'test.svg' });
   } catch (error) {
     expect(error.toString())
-      .toEqual(`SvgoParserError: test.svg:2:29: Unquoted attribute value
+      .toBe(`SvgoParserError: test.svg:2:29: Unquoted attribute value
 
   1 | <svg viewBox="0 0 120 120">
 > 2 |   <circle fill="#ff0000" cx=60.444444" cy="60" r="50"/>
@@ -324,7 +318,7 @@ test('supports errors without path', () => {
     optimize(svg);
   } catch (error) {
     expect(error.toString())
-      .toEqual(`SvgoParserError: <input>:11:29: Unquoted attribute value
+      .toBe(`SvgoParserError: <input>:11:29: Unquoted attribute value
 
    9 |   <circle/>
   10 |   <circle/>
@@ -346,7 +340,7 @@ test('slices long line in error code snippet', () => {
     optimize(svg);
   } catch (error) {
     expect(error.toString())
-      .toEqual(`SvgoParserError: <input>:2:211: Invalid attribute name
+      .toBe(`SvgoParserError: <input>:2:211: Invalid attribute name
 
   1 | …-0.dtd" viewBox="0 0 230 120">
 > 2 | …7.334 250.955 222.534t579.555 155.292z stroke-width="1.5" fill="red" strok…
@@ -377,8 +371,8 @@ test('multipass option should trigger plugins multiple times', () => {
     },
   };
   const { data } = optimize(svg, { multipass: true, plugins: [testPlugin] });
-  expect(list).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-  expect(data).toEqual(`<svg id="klmnopqrstuvwxyz"/>`);
+  expect(list).toStrictEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+  expect(data).toBe(`<svg id="klmnopqrstuvwxyz"/>`);
 });
 
 test('encode as datauri', () => {
diff --git a/lib/xast.test.js b/lib/xast.test.js
index 4371fc938..0fed4fe98 100644
--- a/lib/xast.test.js
+++ b/lib/xast.test.js
@@ -43,7 +43,7 @@ test('visit enters into nodes', () => {
       },
     },
   });
-  expect(entered).toEqual([
+  expect(entered).toStrictEqual([
     'root',
     'element:g',
     'element:rect',
@@ -70,7 +70,7 @@ test('visit exits from nodes', () => {
       },
     },
   });
-  expect(exited).toEqual([
+  expect(exited).toStrictEqual([
     'element:rect',
     'element:circle',
     'element:g',
@@ -95,8 +95,8 @@ test('visit skips entering children if node is detached', () => {
       },
     },
   });
-  expect(entered).toEqual(['g', 'ellipse']);
-  expect(ast).toEqual(root([x('ellipse')]));
+  expect(entered).toStrictEqual(['g', 'ellipse']);
+  expect(ast).toStrictEqual(root([x('ellipse')]));
 });
 
 test('visit skips entering children when symbol is passed', () => {
@@ -115,8 +115,8 @@ test('visit skips entering children when symbol is passed', () => {
       },
     },
   });
-  expect(entered).toEqual(['g', 'ellipse']);
-  expect(ast).toEqual(
+  expect(entered).toStrictEqual(['g', 'ellipse']);
+  expect(ast).toStrictEqual(
     root([x('g', null, [x('rect'), x('circle')]), x('ellipse')]),
   );
 });
diff --git a/test/cli/cli.test.js b/test/cli/cli.test.js
index a53693bf4..ea4759015 100644
--- a/test/cli/cli.test.js
+++ b/test/cli/cli.test.js
@@ -47,7 +47,7 @@ test('accepts svg as input stream', async () => {
   proc.stdin.write('<svg><title>stdin</title></svg>');
   proc.stdin.end();
   const stdout = await waitStdout(proc);
-  expect(stdout).toEqual('<svg/>');
+  expect(stdout).toBe('<svg/>');
 });
 
 test('accepts svg as string', async () => {
@@ -58,7 +58,7 @@ test('accepts svg as string', async () => {
     { cwd: __dirname },
   );
   const stdout = await waitStdout(proc);
-  expect(stdout).toEqual('<svg/>');
+  expect(stdout).toBe('<svg/>');
 });
 
 test('accepts svg as filename', async () => {
@@ -72,7 +72,7 @@ test('accepts svg as filename', async () => {
     path.join(__dirname, 'output/single.svg'),
     'utf-8',
   );
-  expect(output).toEqual('<svg/>');
+  expect(output).toBe('<svg/>');
 });
 
 test('output as stream when "-" is specified', async () => {
@@ -82,7 +82,7 @@ test('output as stream when "-" is specified', async () => {
     { cwd: __dirname },
   );
   const stdout = await waitStdout(proc);
-  expect(stdout).toEqual('<svg/>');
+  expect(stdout).toBe('<svg/>');
 });
 
 test('should exit with 1 code on syntax error', async () => {
@@ -101,9 +101,9 @@ test('should exit with 1 code on syntax error', async () => {
       });
     }),
   ]);
-  expect(code).toEqual(1);
+  expect(code).toBe(1);
   expect(stderr)
-    .toEqual(`SvgoParserError: invalid.svg:2:27: Unquoted attribute value
+    .toBe(`SvgoParserError: invalid.svg:2:27: Unquoted attribute value
 
   1 | <svg>
 > 2 |   <rect x="0" y="0" width=10" height="20" />
diff --git a/test/plugins/_index.test.js b/test/plugins/_index.test.js
index ce1bff375..812282660 100644
--- a/test/plugins/_index.test.js
+++ b/test/plugins/_index.test.js
@@ -41,9 +41,9 @@ describe('plugins tests', function () {
               js2svg: { pretty: true },
             });
             lastResultData = result.data;
-            expect(result.error).not.toEqual(expect.anything());
+            expect(result.error).not.toStrictEqual(expect.anything());
             //FIXME: results.data has a '\n' at the end while it should not
-            expect(normalize(result.data)).toEqual(should);
+            expect(normalize(result.data)).toStrictEqual(should);
           }
         });
       });
diff --git a/test/plugins/prefixIds.test.js b/test/plugins/prefixIds.test.js
index 97f1a8fd1..8ae2b33b8 100644
--- a/test/plugins/prefixIds.test.js
+++ b/test/plugins/prefixIds.test.js
@@ -8,17 +8,17 @@ test('should extract prefix from path basename', () => {
     optimize(svg, {
       plugins: ['prefixIds'],
     }).data,
-  ).toEqual(`<svg id="prefix__my-id"/>`);
+  ).toBe(`<svg id="prefix__my-id"/>`);
   expect(
     optimize(svg, {
       plugins: ['prefixIds'],
       path: 'input.svg',
     }).data,
-  ).toEqual(`<svg id="input_svg__my-id"/>`);
+  ).toBe(`<svg id="input_svg__my-id"/>`);
   expect(
     optimize(svg, {
       plugins: ['prefixIds'],
       path: 'path/to/input.svg',
     }).data,
-  ).toEqual(`<svg id="input_svg__my-id"/>`);
+  ).toBe(`<svg id="input_svg__my-id"/>`);
 });
diff --git a/test/svg2js/_index.test.js b/test/svg2js/_index.test.js
index 77c9075fd..ece064284 100644
--- a/test/svg2js/_index.test.js
+++ b/test/svg2js/_index.test.js
@@ -22,7 +22,7 @@ describe('svg2js', function () {
 
     describe('root', function () {
       it('should exist', function () {
-        expect(root).toEqual(expect.anything());
+        expect(root).toStrictEqual(expect.anything());
       });
 
       it('should be an instance of Object', function () {
@@ -45,7 +45,7 @@ describe('svg2js', function () {
     });
 
     it('the first node should be instruction', () => {
-      expect(root.children[0]).toEqual({
+      expect(root.children[0]).toStrictEqual({
         type: 'instruction',
         name: 'xml',
         value: 'version="1.0" encoding="utf-8"',
@@ -53,7 +53,7 @@ describe('svg2js', function () {
     });
 
     it('the second node should be comment', () => {
-      expect(root.children[1]).toEqual({
+      expect(root.children[1]).toStrictEqual({
         type: 'comment',
         value:
           'Generator: Adobe Illustrator 15.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)',
@@ -61,7 +61,7 @@ describe('svg2js', function () {
     });
 
     it('the third node should be doctype', () => {
-      expect(root.children[2]).toEqual({
+      expect(root.children[2]).toStrictEqual({
         type: 'doctype',
         name: 'svg',
         data: {
@@ -73,7 +73,7 @@ describe('svg2js', function () {
 
     describe('name', function () {
       it('should have property name: "svg"', function () {
-        expect(root.children[3]).toEqual(
+        expect(root.children[3]).toStrictEqual(
           expect.objectContaining({
             name: 'svg',
           }),
@@ -83,7 +83,7 @@ describe('svg2js', function () {
 
     describe('children', function () {
       it('should exist', function () {
-        expect(root.children[3].children).toEqual(expect.anything());
+        expect(root.children[3].children).toStrictEqual(expect.anything());
       });
 
       it('should be an instance of Array', function () {
@@ -98,7 +98,7 @@ describe('svg2js', function () {
     describe('text nodes', function () {
       it('should contain preserved whitespace', function () {
         const textNode = root.children[3].children[1].children[0].children[1];
-        expect(textNode.children[0].value).toEqual('  test  ');
+        expect(textNode.children[0].value).toBe('  test  ');
       });
     });
   });
diff --git a/test/svgo/_index.test.js b/test/svgo/_index.test.js
index e855dc6bf..9d922852d 100644
--- a/test/svgo/_index.test.js
+++ b/test/svgo/_index.test.js
@@ -24,16 +24,16 @@ describe('svgo', () => {
       plugins: [],
       js2svg: { pretty: true, indent: 2 },
     });
-    expect(normalize(result.data)).toEqual(expected);
+    expect(normalize(result.data)).toStrictEqual(expected);
   });
   it('should handle plugins order properly', async () => {
     const [original, expected] = await parseFixture('plugins-order.svg');
     const result = optimize(original, { path: 'input.svg' });
-    expect(normalize(result.data)).toEqual(expected);
+    expect(normalize(result.data)).toStrictEqual(expected);
   });
   it('should handle empty svg tag', async () => {
     const result = optimize('<svg />', { path: 'input.svg' });
-    expect(result.data).toEqual('<svg/>');
+    expect(result.data).toBe('<svg/>');
   });
   it('should preserve style specificity over attributes', async () => {
     const [original, expected] = await parseFixture('style-specificity.svg');
@@ -41,7 +41,7 @@ describe('svgo', () => {
       path: 'input.svg',
       js2svg: { pretty: true },
     });
-    expect(normalize(result.data)).toEqual(expected);
+    expect(normalize(result.data)).toStrictEqual(expected);
   });
   it('should inline entities', async () => {
     const [original, expected] = await parseFixture('entities.svg');
@@ -50,7 +50,7 @@ describe('svgo', () => {
       plugins: [],
       js2svg: { pretty: true },
     });
-    expect(normalize(result.data)).toEqual(expected);
+    expect(normalize(result.data)).toStrictEqual(expected);
   });
   it('should preserve whitespaces between tspan tags', async () => {
     const [original, expected] = await parseFixture('whitespaces.svg');
@@ -58,7 +58,7 @@ describe('svgo', () => {
       path: 'input.svg',
       js2svg: { pretty: true },
     });
-    expect(normalize(result.data)).toEqual(expected);
+    expect(normalize(result.data)).toStrictEqual(expected);
   });
   it('should preserve "to" keyframe selector', async () => {
     const [original, expected] = await parseFixture('keyframe-selectors.svg');
@@ -66,14 +66,14 @@ describe('svgo', () => {
       path: 'input.svg',
       js2svg: { pretty: true },
     });
-    expect(normalize(result.data)).toEqual(expected);
+    expect(normalize(result.data)).toStrictEqual(expected);
   });
   it('should not trim whitespace at start and end of pre element', async () => {
     const [original, expected] = await parseFixture('pre-element.svg');
     const result = optimize(original, {
       path: 'input.svg',
     });
-    expect(normalize(result.data)).toEqual(expected);
+    expect(normalize(result.data)).toStrictEqual(expected);
   });
   it('should not add whitespace in pre element', async () => {
     const [original, expected] = await parseFixture('pre-element-pretty.svg');
@@ -81,6 +81,6 @@ describe('svgo', () => {
       path: 'input.svg',
       js2svg: { pretty: true },
     });
-    expect(normalize(result.data)).toEqual(expected);
+    expect(normalize(result.data)).toStrictEqual(expected);
   });
 });

From ccadbb1a8a983063a1e15e5666c155193155e831 Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Fri, 1 Dec 2023 16:19:28 -0800
Subject: [PATCH 15/20] Added mergeText plugin.

---
 plugins/mergeText.js          | 306 ++++++++++++++++++++++++++++++++++
 plugins/plugins-types.d.ts    |   1 +
 test/plugins/mergeText.01.svg |  18 ++
 test/plugins/mergeText.02.svg |  18 ++
 test/plugins/mergeText.03.svg |  21 +++
 test/plugins/mergeText.04.svg |  14 ++
 test/plugins/mergeText.05.svg |  13 ++
 test/plugins/mergeText.06.svg |  18 ++
 test/plugins/mergeText.07.svg |  20 +++
 test/plugins/mergeText.08.svg |  17 ++
 10 files changed, 446 insertions(+)
 create mode 100644 plugins/mergeText.js
 create mode 100644 test/plugins/mergeText.01.svg
 create mode 100644 test/plugins/mergeText.02.svg
 create mode 100644 test/plugins/mergeText.03.svg
 create mode 100644 test/plugins/mergeText.04.svg
 create mode 100644 test/plugins/mergeText.05.svg
 create mode 100644 test/plugins/mergeText.06.svg
 create mode 100644 test/plugins/mergeText.07.svg
 create mode 100644 test/plugins/mergeText.08.svg

diff --git a/plugins/mergeText.js b/plugins/mergeText.js
new file mode 100644
index 000000000..c7d202ddc
--- /dev/null
+++ b/plugins/mergeText.js
@@ -0,0 +1,306 @@
+'use strict';
+
+/**
+ * @typedef {import('../lib/types').XastElement} XastElement
+ * @typedef {import('../lib/types').XastChild} XastChild
+ */
+
+exports.name = 'mergeText';
+exports.description = 'merges <text> elements and children where possible';
+
+/**
+ * @typedef {{
+ * x:string,
+ * y:string,
+ * attributes:Map<string,string>,
+ * children:XastChild[]
+ * }} TspanData
+ */
+
+/**
+ * @typedef {{
+ * x:string,
+ * y:string,
+ * children:TspanData[],
+ * }
+ * }TextData
+ */
+
+/**
+ * Merge <text> elements and children where possible, and minimize duplication of attributes.
+ *
+ * @author John Kenny
+ *
+ * @type {import('./plugins-types').Plugin<'mergeText'>}
+ */
+
+exports.fn = () => {
+  let deoptimized = false;
+
+  return {
+    element: {
+      enter: (node) => {
+        // Don't collapse if styles are present.
+        if (node.name === 'style' && node.children.length !== 0) {
+          deoptimized = true;
+        }
+      },
+
+      exit: (node) => {
+        if (deoptimized) {
+          return;
+        }
+
+        // See if the node has <text> children.
+        /** @type Map<number,TextData> */
+        const mergeableChildren = new Map();
+        for (let index = 0; index < node.children.length; index++) {
+          const child = node.children[index];
+          if (child.type === 'element' && child.name === 'text') {
+            const mergeData = getMergeData(child);
+            if (mergeData) {
+              mergeableChildren.set(index, mergeData);
+            }
+          }
+        }
+
+        // If nothing to merge, return.
+        if (mergeableChildren.size === 0) {
+          return;
+        }
+
+        // Create new child nodes.
+        /** @type XastChild[] */
+        const newChildren = [];
+        for (let index = 0; index < node.children.length; index++) {
+          if (!mergeableChildren.has(index)) {
+            // This is not a <text> element; do not process.
+            newChildren.push(node.children[index]);
+            continue;
+          }
+          if (mergeableChildren.has(index - 1)) {
+            // The previous child was a mergeable <text> element; assume this one was already merged into it.
+            continue;
+          }
+          // Merge and insert text elements.
+          newChildren.push(mergeTextElements(mergeableChildren, index));
+        }
+
+        // Update children.
+        node.children = newChildren;
+      },
+    },
+  };
+};
+
+/**
+ *
+ * @param {XastElement} textEl
+ * @returns {any}
+ */
+function getMergeData(textEl) {
+  /**@type TextData   */
+  const data = {};
+  /**@type Map<string,string> */
+  const textAttributes = new Map();
+  data.children = [];
+
+  // Gather all <text> attributes.
+  for (const [k, v] of Object.entries(textEl.attributes)) {
+    switch (k) {
+      case 'x':
+      case 'y':
+        data[k] = v;
+        break;
+      default:
+        textAttributes.set(k, v);
+        break;
+    }
+  }
+
+  // Check all children of <text> element.
+  for (const child of textEl.children) {
+    if (child.type === 'text') {
+      if (isWhiteSpace(child.value)) {
+        // Ignore nodes that are all whitespace.
+        continue;
+      }
+    }
+    if (child.type !== 'element' || child.name !== 'tspan') {
+      // Don't transform unless all children are <tspan> elements.
+      return;
+    }
+    for (const tspanChild of child.children) {
+      // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
+      if (tspanChild.type === 'text') {
+        continue;
+      }
+      if (tspanChild.type === 'element' && tspanChild.name === 'tspan') {
+        continue;
+      }
+      return;
+    }
+
+    /** @type TspanData     */
+    const tspanData = {};
+
+    // Copy all <text> attributes to the tspan data.
+    tspanData.attributes = new Map(textAttributes);
+
+    // Merge all <tspan> attributes.
+    for (const [k, v] of Object.entries(child.attributes)) {
+      switch (k) {
+        case 'x':
+        case 'y':
+          tspanData[k] = v;
+          break;
+        case 'color':
+        case 'fill':
+        case 'fill-opacity':
+        case 'fill-rule':
+        case 'opacity':
+        case 'stroke':
+        case 'stroke-dasharray':
+        case 'stroke-dashoffset':
+        case 'stroke-linecap':
+        case 'stroke-linejoin':
+        case 'stroke-miterlimit':
+        case 'stroke-opacity':
+        case 'stroke-width':
+          tspanData.attributes.set(k, v);
+          break;
+        default:
+          // Don't transform if <tspan> has unrecognized attributes.
+          return;
+      }
+    }
+
+    // Don't transform unless all children have x and y attributes.
+    if (!tspanData.x || !tspanData.y) {
+      return;
+    }
+
+    tspanData.children = child.children;
+
+    data.children.push(tspanData);
+  }
+
+  return data;
+}
+
+/**
+ *
+ * @param {TspanData[]} tspans
+ * @returns {{}}
+ */
+function getTextAttributes(tspans) {
+  // Figure out what attributes and values we have.
+  const allAttributes = new Map();
+  for (const tspanElement of tspans) {
+    for (const [attName, attValue] of tspanElement.attributes) {
+      let values = allAttributes.get(attName);
+      if (!values) {
+        values = new Map();
+        allAttributes.set(attName, values);
+      }
+      if (!values.has(attValue)) {
+        values.set(attValue, 1);
+      } else {
+        values.set(attValue, values.get(attValue) + 1);
+      }
+    }
+  }
+
+  // Figure out which ones to use as <text> attributes.
+  /** @type Object.<string,string> */
+  const textAttributes = {};
+  for (const [attName, values] of allAttributes) {
+    // Check all values. If there are fewer values than children, at least one child does not have the attribute;
+    // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
+    let total = 0;
+    let maxCount = 0;
+    let textAttValue;
+    for (const [value, count] of values) {
+      total += count;
+      if (count > maxCount) {
+        maxCount = count;
+        textAttValue = value;
+      }
+    }
+    if (total === tspans.length && textAttValue) {
+      textAttributes[attName] = textAttValue;
+    }
+  }
+
+  return textAttributes;
+}
+
+/**
+ * @param {string} s
+ * @returns {boolean}
+ */
+function isWhiteSpace(s) {
+  return /^\s*$/.test(s);
+}
+
+/**
+ *
+ * @param {Map<number,TextData>} mergeableChildren
+ * @param {number} index
+ * @returns XastElement
+ */
+function mergeTextElements(mergeableChildren, index) {
+  /** @type {XastElement} */
+  const textElement = {
+    type: 'element',
+    name: 'text',
+    attributes: {},
+    children: [],
+  };
+
+  //   Find all child data.
+  const tspans = [];
+  for (; ; index++) {
+    const textData = mergeableChildren.get(index);
+    if (!textData) {
+      break;
+    }
+    tspans.push(...textData.children);
+  }
+
+  // Find the default attributes for the <text> element.
+  textElement.attributes = getTextAttributes(tspans);
+
+  // If there is only one <tspan>, merge content into <text>.
+  if (tspans.length === 1) {
+    const tspanData = tspans[0];
+    textElement.attributes.x = tspanData.x;
+    textElement.attributes.y = tspanData.y;
+    textElement.children = tspanData.children;
+    return textElement;
+  }
+
+  // Generate <tspan> elements.
+  const textChildren = [];
+  for (const tspanData of tspans) {
+    /** @type {XastElement} */
+    const tspanElement = {
+      type: 'element',
+      name: 'tspan',
+      attributes: { x: tspanData.x, y: tspanData.y },
+      children: tspanData.children,
+    };
+
+    // Add any attributes that are different from <text> attributes.
+    for (const [k, v] of tspanData.attributes) {
+      if (textElement.attributes[k] !== v) {
+        tspanElement.attributes[k] = v;
+      }
+    }
+
+    textChildren.push(tspanElement);
+  }
+
+  textElement.children = textChildren;
+  return textElement;
+}
diff --git a/plugins/plugins-types.d.ts b/plugins/plugins-types.d.ts
index 1d4740e7b..0b05ece73 100644
--- a/plugins/plugins-types.d.ts
+++ b/plugins/plugins-types.d.ts
@@ -137,6 +137,7 @@ type DefaultPlugins = {
         };
   };
 
+  mergeText:void;
   moveElemsAttrsToGroup: void;
   moveGroupAttrsToElems: void;
   removeComments: {
diff --git a/test/plugins/mergeText.01.svg b/test/plugins/mergeText.01.svg
new file mode 100644
index 000000000..8da31fbef
--- /dev/null
+++ b/test/plugins/mergeText.01.svg
@@ -0,0 +1,18 @@
+Combine adjacent<text> elements.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <text xml:space="preserve" x="45.869" y="38.606" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="45.869" y="38.606">Part one</tspan>
+    </text>
+    <text xml:space="preserve" x="87.151" y="89.826" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="87.151" y="89.826">Part two</tspan>
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <text xml:space="preserve" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35"><tspan x="45.869" y="38.606">Part one</tspan><tspan x="87.151" y="89.826">Part two</tspan></text>
+</svg>
diff --git a/test/plugins/mergeText.02.svg b/test/plugins/mergeText.02.svg
new file mode 100644
index 000000000..1ae4c47ee
--- /dev/null
+++ b/test/plugins/mergeText.02.svg
@@ -0,0 +1,18 @@
+Combine adjacent<text> elements.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <text>
+        <tspan x="45.869" y="38.606" fill="red">Part one</tspan>
+    </text>
+    <text>
+        <tspan x="87.151" y="89.826" fill="green" stroke-width=".5">Part two</tspan>
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <text fill="red"><tspan x="45.869" y="38.606">Part one</tspan><tspan x="87.151" y="89.826" fill="green" stroke-width=".5">Part two</tspan></text>
+</svg>
diff --git a/test/plugins/mergeText.03.svg b/test/plugins/mergeText.03.svg
new file mode 100644
index 000000000..63d6a3fcb
--- /dev/null
+++ b/test/plugins/mergeText.03.svg
@@ -0,0 +1,21 @@
+Don't merge elements with text node children.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 210 120">
+    <text xml:space="preserve" x="45.869" y="38.606" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="45.869" y="38.606">  Part one</tspan>
+    </text>
+    <text xml:space="preserve" x="87.151" y="89.826" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+    xxx<tspan x="87.151" y="89.826">Part two</tspan>ooo
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 210 120">
+    <text xml:space="preserve" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35" x="45.869" y="38.606">  Part one</text>
+    <text xml:space="preserve" x="87.151" y="89.826" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+    xxx<tspan x="87.151" y="89.826">Part two</tspan>ooo
+    </text>
+</svg>
diff --git a/test/plugins/mergeText.04.svg b/test/plugins/mergeText.04.svg
new file mode 100644
index 000000000..76395f96d
--- /dev/null
+++ b/test/plugins/mergeText.04.svg
@@ -0,0 +1,14 @@
+Collapse single <tspan> child of <text>
+
+===
+
+<svg version="1.1" viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
+    <text x="64" y="64" fill="none" font-family="Arial" font-size="8px" letter-spacing=".5px"
+        stroke="#000000" xml:space="preserve"><tspan x="64" y="64">this is a test</tspan></text>
+</svg>
+
+@@@
+
+<svg version="1.1" viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
+    <text fill="none" font-family="Arial" font-size="8px" letter-spacing=".5px" stroke="#000000" xml:space="preserve" x="64" y="64">this is a test</text>
+</svg>
diff --git a/test/plugins/mergeText.05.svg b/test/plugins/mergeText.05.svg
new file mode 100644
index 000000000..f8a3d97ac
--- /dev/null
+++ b/test/plugins/mergeText.05.svg
@@ -0,0 +1,13 @@
+Collapse single <tspan> child of <text>, where single <tspan> has multiple children.
+
+===
+
+<svg width="210mm" height="297mm" version="1.1" viewBox="0 0 210 297" xmlns="http://www.w3.org/2000/svg">
+ <text x="56.571426" y="93.266411" fill="#0000ff" font-size="3.175px" stroke-width=".26458" xml:space="preserve"><tspan x="56.571426" y="93.266411" stroke-width=".26458">This is <tspan font-family="Arial" font-weight="bold">some</tspan> <tspan fill="#ff0000">text</tspan></tspan></text>
+</svg>
+
+@@@
+
+<svg width="210mm" height="297mm" version="1.1" viewBox="0 0 210 297" xmlns="http://www.w3.org/2000/svg">
+    <text fill="#0000ff" font-size="3.175px" stroke-width=".26458" xml:space="preserve" x="56.571426" y="93.266411">This is <tspan font-family="Arial" font-weight="bold">some</tspan> <tspan fill="#ff0000">text</tspan></text>
+</svg>
diff --git a/test/plugins/mergeText.06.svg b/test/plugins/mergeText.06.svg
new file mode 100644
index 000000000..92e8a9424
--- /dev/null
+++ b/test/plugins/mergeText.06.svg
@@ -0,0 +1,18 @@
+Do not collapse if styles are present.
+
+===
+
+<svg version="1.1" viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
+    <text x="64" y="64" fill="none" font-family="Arial" font-size="8px" letter-spacing=".5px"
+        stroke="#000000" xml:space="preserve"><tspan  x="64" y="64">this is a test</tspan></text>
+		<style>tspan { stroke:red;}</style>
+</svg>
+
+@@@
+
+<svg version="1.1" viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
+    <text x="64" y="64" fill="none" font-family="Arial" font-size="8px" letter-spacing=".5px" stroke="#000000" xml:space="preserve"><tspan x="64" y="64">this is a test</tspan></text>
+    <style>
+        tspan { stroke:red;}
+    </style>
+</svg>
diff --git a/test/plugins/mergeText.07.svg b/test/plugins/mergeText.07.svg
new file mode 100644
index 000000000..0b2284a19
--- /dev/null
+++ b/test/plugins/mergeText.07.svg
@@ -0,0 +1,20 @@
+Do not collapse if <textPath> present.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg"
+    xmlns:xlink="http://www.w3.org/1999/xlink" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <path id="a" fill="none" stroke="#000" stroke-opacity="1" stroke-width=".265" d="M21.788 147.927s129.197-188.062 144.868-1.53"/>
+    <text xml:space="preserve" fill="none" stroke="#000" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <textPath xlink:href="#a"><tspan fill="#f40b0b" font-size="11.289" font-weight="400">this is a test</tspan></textPath>
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="210mm" height="297mm" viewBox="0 0 210 297">
+    <path id="a" fill="none" stroke="#000" stroke-opacity="1" stroke-width=".265" d="M21.788 147.927s129.197-188.062 144.868-1.53"/>
+    <text xml:space="preserve" fill="none" stroke="#000" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <textPath xlink:href="#a"><tspan fill="#f40b0b" font-size="11.289" font-weight="400">this is a test</tspan></textPath>
+    </text>
+</svg>
diff --git a/test/plugins/mergeText.08.svg b/test/plugins/mergeText.08.svg
new file mode 100644
index 000000000..2feb9474f
--- /dev/null
+++ b/test/plugins/mergeText.08.svg
@@ -0,0 +1,17 @@
+Don't merge elements with <title> children.
+
+===
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 210 120">
+    <text xml:space="preserve" x="45.869" y="38.606" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="45.869" y="38.606"><title>xxx</title>Part one</tspan>
+    </text>
+</svg>
+
+@@@
+
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 210 120">
+    <text xml:space="preserve" x="45.869" y="38.606" fill="red" stroke-width=".265" font-family="Sans" font-size="6.35">
+        <tspan x="45.869" y="38.606"><title>xxx</title>Part one</tspan>
+    </text>
+</svg>

From a94c45aeb70f103f274f81df4a43520e60f8f1d7 Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Fri, 1 Dec 2023 16:23:43 -0800
Subject: [PATCH 16/20] Added mergeText plugin to builtin.js.

---
 lib/builtin.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/builtin.js b/lib/builtin.js
index 28a380ec9..1ab975bef 100644
--- a/lib/builtin.js
+++ b/lib/builtin.js
@@ -20,6 +20,7 @@ exports.builtin = [
   require('../plugins/mergeStyles.js'),
   require('../plugins/inlineStyles.js'),
   require('../plugins/mergePaths.js'),
+  require('../plugins/mergeText.js'),
   require('../plugins/minifyStyles.js'),
   require('../plugins/moveElemsAttrsToGroup.js'),
   require('../plugins/moveGroupAttrsToElems.js'),

From 65c4d7f6c87ee5607b69039f95df87ce4612673b Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Sun, 24 Dec 2023 10:37:30 -0800
Subject: [PATCH 17/20] Changed to use inheritableAttrs from collections.js.

---
 plugins/mergeText.js | 441 +++++++++++++++++++++----------------------
 1 file changed, 216 insertions(+), 225 deletions(-)

diff --git a/plugins/mergeText.js b/plugins/mergeText.js
index c7d202ddc..bbe0766a0 100644
--- a/plugins/mergeText.js
+++ b/plugins/mergeText.js
@@ -1,5 +1,7 @@
 'use strict';
 
+const { inheritableAttrs } = require( './_collections' );
+
 /**
  * @typedef {import('../lib/types').XastElement} XastElement
  * @typedef {import('../lib/types').XastChild} XastChild
@@ -35,62 +37,62 @@ exports.description = 'merges <text> elements and children where possible';
  */
 
 exports.fn = () => {
-  let deoptimized = false;
-
-  return {
-    element: {
-      enter: (node) => {
-        // Don't collapse if styles are present.
-        if (node.name === 'style' && node.children.length !== 0) {
-          deoptimized = true;
-        }
-      },
-
-      exit: (node) => {
-        if (deoptimized) {
-          return;
-        }
-
-        // See if the node has <text> children.
-        /** @type Map<number,TextData> */
-        const mergeableChildren = new Map();
-        for (let index = 0; index < node.children.length; index++) {
-          const child = node.children[index];
-          if (child.type === 'element' && child.name === 'text') {
-            const mergeData = getMergeData(child);
-            if (mergeData) {
-              mergeableChildren.set(index, mergeData);
-            }
-          }
-        }
-
-        // If nothing to merge, return.
-        if (mergeableChildren.size === 0) {
-          return;
-        }
-
-        // Create new child nodes.
-        /** @type XastChild[] */
-        const newChildren = [];
-        for (let index = 0; index < node.children.length; index++) {
-          if (!mergeableChildren.has(index)) {
-            // This is not a <text> element; do not process.
-            newChildren.push(node.children[index]);
-            continue;
-          }
-          if (mergeableChildren.has(index - 1)) {
-            // The previous child was a mergeable <text> element; assume this one was already merged into it.
-            continue;
-          }
-          // Merge and insert text elements.
-          newChildren.push(mergeTextElements(mergeableChildren, index));
-        }
-
-        // Update children.
-        node.children = newChildren;
-      },
-    },
-  };
+    let deoptimized = false;
+
+    return {
+        element: {
+            enter: ( node ) => {
+                // Don't collapse if styles are present.
+                if ( node.name === 'style' && node.children.length !== 0 ) {
+                    deoptimized = true;
+                }
+            },
+
+            exit: ( node ) => {
+                if ( deoptimized ) {
+                    return;
+                }
+
+                // See if the node has <text> children.
+                /** @type Map<number,TextData> */
+                const mergeableChildren = new Map();
+                for ( let index = 0; index < node.children.length; index++ ) {
+                    const child = node.children[ index ];
+                    if ( child.type === 'element' && child.name === 'text' ) {
+                        const mergeData = getMergeData( child );
+                        if ( mergeData ) {
+                            mergeableChildren.set( index, mergeData );
+                        }
+                    }
+                }
+
+                // If nothing to merge, return.
+                if ( mergeableChildren.size === 0 ) {
+                    return;
+                }
+
+                // Create new child nodes.
+                /** @type XastChild[] */
+                const newChildren = [];
+                for ( let index = 0; index < node.children.length; index++ ) {
+                    if ( !mergeableChildren.has( index ) ) {
+                        // This is not a <text> element; do not process.
+                        newChildren.push( node.children[ index ] );
+                        continue;
+                    }
+                    if ( mergeableChildren.has( index - 1 ) ) {
+                        // The previous child was a mergeable <text> element; assume this one was already merged into it.
+                        continue;
+                    }
+                    // Merge and insert text elements.
+                    newChildren.push( mergeTextElements( mergeableChildren, index ) );
+                }
+
+                // Update children.
+                node.children = newChildren;
+            },
+        },
+    };
 };
 
 /**
@@ -98,94 +100,83 @@ exports.fn = () => {
  * @param {XastElement} textEl
  * @returns {any}
  */
-function getMergeData(textEl) {
-  /**@type TextData   */
-  const data = {};
-  /**@type Map<string,string> */
-  const textAttributes = new Map();
-  data.children = [];
-
-  // Gather all <text> attributes.
-  for (const [k, v] of Object.entries(textEl.attributes)) {
-    switch (k) {
-      case 'x':
-      case 'y':
-        data[k] = v;
-        break;
-      default:
-        textAttributes.set(k, v);
-        break;
-    }
-  }
-
-  // Check all children of <text> element.
-  for (const child of textEl.children) {
-    if (child.type === 'text') {
-      if (isWhiteSpace(child.value)) {
-        // Ignore nodes that are all whitespace.
-        continue;
-      }
-    }
-    if (child.type !== 'element' || child.name !== 'tspan') {
-      // Don't transform unless all children are <tspan> elements.
-      return;
-    }
-    for (const tspanChild of child.children) {
-      // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
-      if (tspanChild.type === 'text') {
-        continue;
-      }
-      if (tspanChild.type === 'element' && tspanChild.name === 'tspan') {
-        continue;
-      }
-      return;
+function getMergeData( textEl ) {
+    /**@type TextData   */
+    const data = {};
+    /**@type Map<string,string> */
+    const textAttributes = new Map();
+    data.children = [];
+
+    // Gather all <text> attributes.
+    for ( const [ k, v ] of Object.entries( textEl.attributes ) ) {
+        switch ( k ) {
+            case 'x':
+            case 'y':
+                data[ k ] = v;
+                break;
+            default:
+                textAttributes.set( k, v );
+                break;
+        }
     }
 
-    /** @type TspanData     */
-    const tspanData = {};
-
-    // Copy all <text> attributes to the tspan data.
-    tspanData.attributes = new Map(textAttributes);
-
-    // Merge all <tspan> attributes.
-    for (const [k, v] of Object.entries(child.attributes)) {
-      switch (k) {
-        case 'x':
-        case 'y':
-          tspanData[k] = v;
-          break;
-        case 'color':
-        case 'fill':
-        case 'fill-opacity':
-        case 'fill-rule':
-        case 'opacity':
-        case 'stroke':
-        case 'stroke-dasharray':
-        case 'stroke-dashoffset':
-        case 'stroke-linecap':
-        case 'stroke-linejoin':
-        case 'stroke-miterlimit':
-        case 'stroke-opacity':
-        case 'stroke-width':
-          tspanData.attributes.set(k, v);
-          break;
-        default:
-          // Don't transform if <tspan> has unrecognized attributes.
-          return;
-      }
-    }
+    // Check all children of <text> element.
+    for ( const child of textEl.children ) {
+        if ( child.type === 'text' ) {
+            if ( isWhiteSpace( child.value ) ) {
+                // Ignore nodes that are all whitespace.
+                continue;
+            }
+        }
+        if ( child.type !== 'element' || child.name !== 'tspan' ) {
+            // Don't transform unless all children are <tspan> elements.
+            return;
+        }
+        for ( const tspanChild of child.children ) {
+            // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
+            if ( tspanChild.type === 'text' ) {
+                continue;
+            }
+            if ( tspanChild.type === 'element' && tspanChild.name === 'tspan' ) {
+                continue;
+            }
+            return;
+        }
 
-    // Don't transform unless all children have x and y attributes.
-    if (!tspanData.x || !tspanData.y) {
-      return;
-    }
+        /** @type TspanData     */
+        const tspanData = {};
+
+        // Copy all <text> attributes to the tspan data.
+        tspanData.attributes = new Map( textAttributes );
+
+        // Merge all <tspan> attributes.
+        for ( const [ k, v ] of Object.entries( child.attributes ) ) {
+            switch ( k ) {
+                case 'x':
+                case 'y':
+                    tspanData[ k ] = v;
+                    break;
+                default:
+                    if ( !inheritableAttrs.includes( k ) ) {
+                        // Don't transform if <tspan> has unrecognized attributes.
+                        return;
+                    }
+                    tspanData.attributes.set( k, v );
+                    break;
+            }
+        }
 
-    tspanData.children = child.children;
+        // Don't transform unless all children have x and y attributes.
+        if ( !tspanData.x || !tspanData.y ) {
+            return;
+        }
 
-    data.children.push(tspanData);
-  }
+        tspanData.children = child.children;
 
-  return data;
+        data.children.push( tspanData );
+    }
+
+    return data;
 }
 
 /**
@@ -193,54 +184,54 @@ function getMergeData(textEl) {
  * @param {TspanData[]} tspans
  * @returns {{}}
  */
-function getTextAttributes(tspans) {
-  // Figure out what attributes and values we have.
-  const allAttributes = new Map();
-  for (const tspanElement of tspans) {
-    for (const [attName, attValue] of tspanElement.attributes) {
-      let values = allAttributes.get(attName);
-      if (!values) {
-        values = new Map();
-        allAttributes.set(attName, values);
-      }
-      if (!values.has(attValue)) {
-        values.set(attValue, 1);
-      } else {
-        values.set(attValue, values.get(attValue) + 1);
-      }
-    }
-  }
-
-  // Figure out which ones to use as <text> attributes.
-  /** @type Object.<string,string> */
-  const textAttributes = {};
-  for (const [attName, values] of allAttributes) {
-    // Check all values. If there are fewer values than children, at least one child does not have the attribute;
-    // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
-    let total = 0;
-    let maxCount = 0;
-    let textAttValue;
-    for (const [value, count] of values) {
-      total += count;
-      if (count > maxCount) {
-        maxCount = count;
-        textAttValue = value;
-      }
+function getTextAttributes( tspans ) {
+    // Figure out what attributes and values we have.
+    const allAttributes = new Map();
+    for ( const tspanElement of tspans ) {
+        for ( const [ attName, attValue ] of tspanElement.attributes ) {
+            let values = allAttributes.get( attName );
+            if ( !values ) {
+                values = new Map();
+                allAttributes.set( attName, values );
+            }
+            if ( !values.has( attValue ) ) {
+                values.set( attValue, 1 );
+            } else {
+                values.set( attValue, values.get( attValue ) + 1 );
+            }
+        }
     }
-    if (total === tspans.length && textAttValue) {
-      textAttributes[attName] = textAttValue;
+
+    // Figure out which ones to use as <text> attributes.
+    /** @type Object.<string,string> */
+    const textAttributes = {};
+    for ( const [ attName, values ] of allAttributes ) {
+        // Check all values. If there are fewer values than children, at least one child does not have the attribute;
+        // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
+        let total = 0;
+        let maxCount = 0;
+        let textAttValue;
+        for ( const [ value, count ] of values ) {
+            total += count;
+            if ( count > maxCount ) {
+                maxCount = count;
+                textAttValue = value;
+            }
+        }
+        if ( total === tspans.length && textAttValue ) {
+            textAttributes[ attName ] = textAttValue;
+        }
     }
-  }
 
-  return textAttributes;
+    return textAttributes;
 }
 
 /**
  * @param {string} s
  * @returns {boolean}
  */
-function isWhiteSpace(s) {
-  return /^\s*$/.test(s);
+function isWhiteSpace( s ) {
+    return /^\s*$/.test( s );
 }
 
 /**
@@ -249,58 +240,58 @@ function isWhiteSpace(s) {
  * @param {number} index
  * @returns XastElement
  */
-function mergeTextElements(mergeableChildren, index) {
-  /** @type {XastElement} */
-  const textElement = {
-    type: 'element',
-    name: 'text',
-    attributes: {},
-    children: [],
-  };
-
-  //   Find all child data.
-  const tspans = [];
-  for (; ; index++) {
-    const textData = mergeableChildren.get(index);
-    if (!textData) {
-      break;
-    }
-    tspans.push(...textData.children);
-  }
-
-  // Find the default attributes for the <text> element.
-  textElement.attributes = getTextAttributes(tspans);
-
-  // If there is only one <tspan>, merge content into <text>.
-  if (tspans.length === 1) {
-    const tspanData = tspans[0];
-    textElement.attributes.x = tspanData.x;
-    textElement.attributes.y = tspanData.y;
-    textElement.children = tspanData.children;
-    return textElement;
-  }
-
-  // Generate <tspan> elements.
-  const textChildren = [];
-  for (const tspanData of tspans) {
+function mergeTextElements( mergeableChildren, index ) {
     /** @type {XastElement} */
-    const tspanElement = {
-      type: 'element',
-      name: 'tspan',
-      attributes: { x: tspanData.x, y: tspanData.y },
-      children: tspanData.children,
+    const textElement = {
+        type: 'element',
+        name: 'text',
+        attributes: {},
+        children: [],
     };
 
-    // Add any attributes that are different from <text> attributes.
-    for (const [k, v] of tspanData.attributes) {
-      if (textElement.attributes[k] !== v) {
-        tspanElement.attributes[k] = v;
-      }
+    //   Find all child data.
+    const tspans = [];
+    for ( ; ; index++ ) {
+        const textData = mergeableChildren.get( index );
+        if ( !textData ) {
+            break;
+        }
+        tspans.push( ...textData.children );
+    }
+
+    // Find the default attributes for the <text> element.
+    textElement.attributes = getTextAttributes( tspans );
+
+    // If there is only one <tspan>, merge content into <text>.
+    if ( tspans.length === 1 ) {
+        const tspanData = tspans[ 0 ];
+        textElement.attributes.x = tspanData.x;
+        textElement.attributes.y = tspanData.y;
+        textElement.children = tspanData.children;
+        return textElement;
     }
 
-    textChildren.push(tspanElement);
-  }
+    // Generate <tspan> elements.
+    const textChildren = [];
+    for ( const tspanData of tspans ) {
+        /** @type {XastElement} */
+        const tspanElement = {
+            type: 'element',
+            name: 'tspan',
+            attributes: { x: tspanData.x, y: tspanData.y },
+            children: tspanData.children,
+        };
+
+        // Add any attributes that are different from <text> attributes.
+        for ( const [ k, v ] of tspanData.attributes ) {
+            if ( textElement.attributes[ k ] !== v ) {
+                tspanElement.attributes[ k ] = v;
+            }
+        }
+
+        textChildren.push( tspanElement );
+    }
 
-  textElement.children = textChildren;
-  return textElement;
+    textElement.children = textChildren;
+    return textElement;
 }

From 5de49974d5a027c9d35a8dbfae33ead1374731fa Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Mon, 25 Dec 2023 08:34:10 -0800
Subject: [PATCH 18/20] Fixed formatting.

---
 plugins/mergeText.js       | 428 ++++++++++++++++++-------------------
 plugins/plugins-types.d.ts |   2 +-
 2 files changed, 215 insertions(+), 215 deletions(-)

diff --git a/plugins/mergeText.js b/plugins/mergeText.js
index bbe0766a0..9af46fde5 100644
--- a/plugins/mergeText.js
+++ b/plugins/mergeText.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const { inheritableAttrs } = require( './_collections' );
+const { inheritableAttrs } = require('./_collections');
 
 /**
  * @typedef {import('../lib/types').XastElement} XastElement
@@ -37,62 +37,62 @@ exports.description = 'merges <text> elements and children where possible';
  */
 
 exports.fn = () => {
-    let deoptimized = false;
-
-    return {
-        element: {
-            enter: ( node ) => {
-                // Don't collapse if styles are present.
-                if ( node.name === 'style' && node.children.length !== 0 ) {
-                    deoptimized = true;
-                }
-            },
-
-            exit: ( node ) => {
-                if ( deoptimized ) {
-                    return;
-                }
-
-                // See if the node has <text> children.
-                /** @type Map<number,TextData> */
-                const mergeableChildren = new Map();
-                for ( let index = 0; index < node.children.length; index++ ) {
-                    const child = node.children[ index ];
-                    if ( child.type === 'element' && child.name === 'text' ) {
-                        const mergeData = getMergeData( child );
-                        if ( mergeData ) {
-                            mergeableChildren.set( index, mergeData );
-                        }
-                    }
-                }
-
-                // If nothing to merge, return.
-                if ( mergeableChildren.size === 0 ) {
-                    return;
-                }
-
-                // Create new child nodes.
-                /** @type XastChild[] */
-                const newChildren = [];
-                for ( let index = 0; index < node.children.length; index++ ) {
-                    if ( !mergeableChildren.has( index ) ) {
-                        // This is not a <text> element; do not process.
-                        newChildren.push( node.children[ index ] );
-                        continue;
-                    }
-                    if ( mergeableChildren.has( index - 1 ) ) {
-                        // The previous child was a mergeable <text> element; assume this one was already merged into it.
-                        continue;
-                    }
-                    // Merge and insert text elements.
-                    newChildren.push( mergeTextElements( mergeableChildren, index ) );
-                }
-
-                // Update children.
-                node.children = newChildren;
-            },
-        },
-    };
+  let deoptimized = false;
+
+  return {
+    element: {
+      enter: (node) => {
+        // Don't collapse if styles are present.
+        if (node.name === 'style' && node.children.length !== 0) {
+          deoptimized = true;
+        }
+      },
+
+      exit: (node) => {
+        if (deoptimized) {
+          return;
+        }
+
+        // See if the node has <text> children.
+        /** @type Map<number,TextData> */
+        const mergeableChildren = new Map();
+        for (let index = 0; index < node.children.length; index++) {
+          const child = node.children[index];
+          if (child.type === 'element' && child.name === 'text') {
+            const mergeData = getMergeData(child);
+            if (mergeData) {
+              mergeableChildren.set(index, mergeData);
+            }
+          }
+        }
+
+        // If nothing to merge, return.
+        if (mergeableChildren.size === 0) {
+          return;
+        }
+
+        // Create new child nodes.
+        /** @type XastChild[] */
+        const newChildren = [];
+        for (let index = 0; index < node.children.length; index++) {
+          if (!mergeableChildren.has(index)) {
+            // This is not a <text> element; do not process.
+            newChildren.push(node.children[index]);
+            continue;
+          }
+          if (mergeableChildren.has(index - 1)) {
+            // The previous child was a mergeable <text> element; assume this one was already merged into it.
+            continue;
+          }
+          // Merge and insert text elements.
+          newChildren.push(mergeTextElements(mergeableChildren, index));
+        }
+
+        // Update children.
+        node.children = newChildren;
+      },
+    },
+  };
 };
 
 /**
@@ -100,83 +100,83 @@ exports.fn = () => {
  * @param {XastElement} textEl
  * @returns {any}
  */
-function getMergeData( textEl ) {
-    /**@type TextData   */
-    const data = {};
-    /**@type Map<string,string> */
-    const textAttributes = new Map();
-    data.children = [];
-
-    // Gather all <text> attributes.
-    for ( const [ k, v ] of Object.entries( textEl.attributes ) ) {
-        switch ( k ) {
-            case 'x':
-            case 'y':
-                data[ k ] = v;
-                break;
-            default:
-                textAttributes.set( k, v );
-                break;
-        }
+function getMergeData(textEl) {
+  /**@type TextData   */
+  const data = {};
+  /**@type Map<string,string> */
+  const textAttributes = new Map();
+  data.children = [];
+
+  // Gather all <text> attributes.
+  for (const [k, v] of Object.entries(textEl.attributes)) {
+    switch (k) {
+      case 'x':
+      case 'y':
+        data[k] = v;
+        break;
+      default:
+        textAttributes.set(k, v);
+        break;
+    }
+  }
+
+  // Check all children of <text> element.
+  for (const child of textEl.children) {
+    if (child.type === 'text') {
+      if (isWhiteSpace(child.value)) {
+        // Ignore nodes that are all whitespace.
+        continue;
+      }
+    }
+    if (child.type !== 'element' || child.name !== 'tspan') {
+      // Don't transform unless all children are <tspan> elements.
+      return;
+    }
+    for (const tspanChild of child.children) {
+      // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
+      if (tspanChild.type === 'text') {
+        continue;
+      }
+      if (tspanChild.type === 'element' && tspanChild.name === 'tspan') {
+        continue;
+      }
+      return;
     }
 
-    // Check all children of <text> element.
-    for ( const child of textEl.children ) {
-        if ( child.type === 'text' ) {
-            if ( isWhiteSpace( child.value ) ) {
-                // Ignore nodes that are all whitespace.
-                continue;
-            }
-        }
-        if ( child.type !== 'element' || child.name !== 'tspan' ) {
-            // Don't transform unless all children are <tspan> elements.
+    /** @type TspanData     */
+    const tspanData = {};
+
+    // Copy all <text> attributes to the tspan data.
+    tspanData.attributes = new Map(textAttributes);
+
+    // Merge all <tspan> attributes.
+    for (const [k, v] of Object.entries(child.attributes)) {
+      switch (k) {
+        case 'x':
+        case 'y':
+          tspanData[k] = v;
+          break;
+        default:
+          if (!inheritableAttrs.includes(k)) {
+            // Don't transform if <tspan> has unrecognized attributes.
             return;
-        }
-        for ( const tspanChild of child.children ) {
-            // Don't transform unless <tspan> has only text nodes and <tspan>s as children.
-            if ( tspanChild.type === 'text' ) {
-                continue;
-            }
-            if ( tspanChild.type === 'element' && tspanChild.name === 'tspan' ) {
-                continue;
-            }
-            return;
-        }
-
-        /** @type TspanData     */
-        const tspanData = {};
-
-        // Copy all <text> attributes to the tspan data.
-        tspanData.attributes = new Map( textAttributes );
-
-        // Merge all <tspan> attributes.
-        for ( const [ k, v ] of Object.entries( child.attributes ) ) {
-            switch ( k ) {
-                case 'x':
-                case 'y':
-                    tspanData[ k ] = v;
-                    break;
-                default:
-                    if ( !inheritableAttrs.includes( k ) ) {
-                        // Don't transform if <tspan> has unrecognized attributes.
-                        return;
-                    }
-                    tspanData.attributes.set( k, v );
-                    break;
-            }
-        }
+          }
+          tspanData.attributes.set(k, v);
+          break;
+      }
+    }
 
-        // Don't transform unless all children have x and y attributes.
-        if ( !tspanData.x || !tspanData.y ) {
-            return;
-        }
+    // Don't transform unless all children have x and y attributes.
+    if (!tspanData.x || !tspanData.y) {
+      return;
+    }
 
-        tspanData.children = child.children;
+    tspanData.children = child.children;
 
-        data.children.push( tspanData );
-    }
+    data.children.push(tspanData);
+  }
 
-    return data;
+  return data;
 }
 
 /**
@@ -184,54 +184,54 @@ function getMergeData( textEl ) {
  * @param {TspanData[]} tspans
  * @returns {{}}
  */
-function getTextAttributes( tspans ) {
-    // Figure out what attributes and values we have.
-    const allAttributes = new Map();
-    for ( const tspanElement of tspans ) {
-        for ( const [ attName, attValue ] of tspanElement.attributes ) {
-            let values = allAttributes.get( attName );
-            if ( !values ) {
-                values = new Map();
-                allAttributes.set( attName, values );
-            }
-            if ( !values.has( attValue ) ) {
-                values.set( attValue, 1 );
-            } else {
-                values.set( attValue, values.get( attValue ) + 1 );
-            }
-        }
+function getTextAttributes(tspans) {
+  // Figure out what attributes and values we have.
+  const allAttributes = new Map();
+  for (const tspanElement of tspans) {
+    for (const [attName, attValue] of tspanElement.attributes) {
+      let values = allAttributes.get(attName);
+      if (!values) {
+        values = new Map();
+        allAttributes.set(attName, values);
+      }
+      if (!values.has(attValue)) {
+        values.set(attValue, 1);
+      } else {
+        values.set(attValue, values.get(attValue) + 1);
+      }
     }
-
-    // Figure out which ones to use as <text> attributes.
-    /** @type Object.<string,string> */
-    const textAttributes = {};
-    for ( const [ attName, values ] of allAttributes ) {
-        // Check all values. If there are fewer values than children, at least one child does not have the attribute;
-        // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
-        let total = 0;
-        let maxCount = 0;
-        let textAttValue;
-        for ( const [ value, count ] of values ) {
-            total += count;
-            if ( count > maxCount ) {
-                maxCount = count;
-                textAttValue = value;
-            }
-        }
-        if ( total === tspans.length && textAttValue ) {
-            textAttributes[ attName ] = textAttValue;
-        }
+  }
+
+  // Figure out which ones to use as <text> attributes.
+  /** @type Object.<string,string> */
+  const textAttributes = {};
+  for (const [attName, values] of allAttributes) {
+    // Check all values. If there are fewer values than children, at least one child does not have the attribute;
+    // in this case leave attribute off of <text>. Otherwise, set text attribute to the most-used value.
+    let total = 0;
+    let maxCount = 0;
+    let textAttValue;
+    for (const [value, count] of values) {
+      total += count;
+      if (count > maxCount) {
+        maxCount = count;
+        textAttValue = value;
+      }
+    }
+    if (total === tspans.length && textAttValue) {
+      textAttributes[attName] = textAttValue;
     }
+  }
 
-    return textAttributes;
+  return textAttributes;
 }
 
 /**
  * @param {string} s
  * @returns {boolean}
  */
-function isWhiteSpace( s ) {
-    return /^\s*$/.test( s );
+function isWhiteSpace(s) {
+  return /^\s*$/.test(s);
 }
 
 /**
@@ -240,58 +240,58 @@ function isWhiteSpace( s ) {
  * @param {number} index
  * @returns XastElement
  */
-function mergeTextElements( mergeableChildren, index ) {
-    /** @type {XastElement} */
-    const textElement = {
-        type: 'element',
-        name: 'text',
-        attributes: {},
-        children: [],
-    };
-
-    //   Find all child data.
-    const tspans = [];
-    for ( ; ; index++ ) {
-        const textData = mergeableChildren.get( index );
-        if ( !textData ) {
-            break;
-        }
-        tspans.push( ...textData.children );
+function mergeTextElements(mergeableChildren, index) {
+  /** @type {XastElement} */
+  const textElement = {
+    type: 'element',
+    name: 'text',
+    attributes: {},
+    children: [],
+  };
+
+  //   Find all child data.
+  const tspans = [];
+  for (; ; index++) {
+    const textData = mergeableChildren.get(index);
+    if (!textData) {
+      break;
     }
+    tspans.push(...textData.children);
+  }
+
+  // Find the default attributes for the <text> element.
+  textElement.attributes = getTextAttributes(tspans);
+
+  // If there is only one <tspan>, merge content into <text>.
+  if (tspans.length === 1) {
+    const tspanData = tspans[0];
+    textElement.attributes.x = tspanData.x;
+    textElement.attributes.y = tspanData.y;
+    textElement.children = tspanData.children;
+    return textElement;
+  }
 
-    // Find the default attributes for the <text> element.
-    textElement.attributes = getTextAttributes( tspans );
+  // Generate <tspan> elements.
+  const textChildren = [];
+  for (const tspanData of tspans) {
+    /** @type {XastElement} */
+    const tspanElement = {
+      type: 'element',
+      name: 'tspan',
+      attributes: { x: tspanData.x, y: tspanData.y },
+      children: tspanData.children,
+    };
 
-    // If there is only one <tspan>, merge content into <text>.
-    if ( tspans.length === 1 ) {
-        const tspanData = tspans[ 0 ];
-        textElement.attributes.x = tspanData.x;
-        textElement.attributes.y = tspanData.y;
-        textElement.children = tspanData.children;
-        return textElement;
+    // Add any attributes that are different from <text> attributes.
+    for (const [k, v] of tspanData.attributes) {
+      if (textElement.attributes[k] !== v) {
+        tspanElement.attributes[k] = v;
+      }
     }
 
-    // Generate <tspan> elements.
-    const textChildren = [];
-    for ( const tspanData of tspans ) {
-        /** @type {XastElement} */
-        const tspanElement = {
-            type: 'element',
-            name: 'tspan',
-            attributes: { x: tspanData.x, y: tspanData.y },
-            children: tspanData.children,
-        };
-
-        // Add any attributes that are different from <text> attributes.
-        for ( const [ k, v ] of tspanData.attributes ) {
-            if ( textElement.attributes[ k ] !== v ) {
-                tspanElement.attributes[ k ] = v;
-            }
-        }
-
-        textChildren.push( tspanElement );
-    }
+    textChildren.push(tspanElement);
+  }
 
-    textElement.children = textChildren;
-    return textElement;
+  textElement.children = textChildren;
+  return textElement;
 }
diff --git a/plugins/plugins-types.d.ts b/plugins/plugins-types.d.ts
index 0b05ece73..9d30515c2 100644
--- a/plugins/plugins-types.d.ts
+++ b/plugins/plugins-types.d.ts
@@ -137,7 +137,7 @@ type DefaultPlugins = {
         };
   };
 
-  mergeText:void;
+  mergeText: void;
   moveElemsAttrsToGroup: void;
   moveGroupAttrsToElems: void;
   removeComments: {

From 8cb03da0b06db7eadabdc43c9675f4346b7c4b86 Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Mon, 25 Dec 2023 15:39:03 -0800
Subject: [PATCH 19/20] Added mergeText documentation.

---
 docs/03-plugins/merge-text.mdx | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 docs/03-plugins/merge-text.mdx

diff --git a/docs/03-plugins/merge-text.mdx b/docs/03-plugins/merge-text.mdx
new file mode 100644
index 000000000..38b19d2ae
--- /dev/null
+++ b/docs/03-plugins/merge-text.mdx
@@ -0,0 +1,15 @@
+---
+title: Merge Text
+svgo:
+  pluginId: mergeText
+---
+
+Merge adjacent `<text>` elements and remove `<tspan>` when it is the only child of a `<text>` element.
+
+If the SVG contains any `<style>` elements, it will not be modified.
+
+`<text>` or `<tspan>` elements which have non-inheritable attributes other than `x` or `y` will not be modified.
+
+## Implementation
+
+- https://github.com/svg/svgo/blob/main/plugins/mergeText.js

From 01455890dbf1c34d18ee08e70f056400bf88caa0 Mon Sep 17 00:00:00 2001
From: John Kenny <johnkenny54@yahoo.com>
Date: Tue, 26 Dec 2023 15:36:53 -0800
Subject: [PATCH 20/20] Fixed formatting.

---
 plugins/mergeText.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/mergeText.js b/plugins/mergeText.js
index 9af46fde5..55fbbe87d 100644
--- a/plugins/mergeText.js
+++ b/plugins/mergeText.js
@@ -157,7 +157,7 @@ function getMergeData(textEl) {
           tspanData[k] = v;
           break;
         default:
-          if (!inheritableAttrs.includes(k)) {
+          if (!inheritableAttrs.has(k)) {
             // Don't transform if <tspan> has unrecognized attributes.
             return;
           }