@emasoft/svg-matrix 1.0.28 → 1.0.30

package/src/css-specificity.js

@@ -10,13 +10,13 @@
 
 // Selector component types
 const SELECTOR_TYPES = {
-  ID: 'id',           // #foo
-  CLASS: 'class',     // .foo
-  ATTRIBUTE: 'attr',  // [foo]
-  PSEUDO_CLASS: 'pseudo-class',  // :hover
-  PSEUDO_ELEMENT: 'pseudo-element', // ::before
-  TYPE: 'type',       // div
-  UNIVERSAL: 'universal' // *
+  ID: "id", // #foo
+  CLASS: "class", // .foo
+  ATTRIBUTE: "attr", // [foo]
+  PSEUDO_CLASS: "pseudo-class", // :hover
+  PSEUDO_ELEMENT: "pseudo-element", // ::before
+  TYPE: "type", // div
+  UNIVERSAL: "universal", // *
 };
 
 /**
@@ -40,13 +40,13 @@ const SELECTOR_TYPES = {
  * // Returns array of component objects with type and value
  */
 export function parseSelector(selectorString) {
-  if (typeof selectorString !== 'string' || !selectorString.trim()) {
-    throw new Error('Selector must be a non-empty string');
+  if (typeof selectorString !== "string" || !selectorString.trim()) {
+    throw new Error("Selector must be a non-empty string");
   }
 
   const selector = selectorString.trim();
   const components = [];
-  let i = 0;
+  const _i = 0;
 
   // Split by combinators first (>, +, ~, space) to handle complex selectors
   const parts = splitByCombinators(selector);
@@ -71,7 +71,7 @@ export function parseSelector(selectorString) {
 function splitByCombinators(selector) {
   // Match combinators outside of brackets and parentheses
   const parts = [];
-  let current = '';
+  let current = "";
   let depth = 0; // Track nesting in [] and ()
   let inBracket = false;
   let inParen = false;
@@ -79,31 +79,31 @@ function splitByCombinators(selector) {
   for (let i = 0; i < selector.length; i++) {
     const char = selector[i];
 
-    if (char === '[') {
+    if (char === "[") {
       inBracket = true;
       depth++;
-    } else if (char === ']') {
+    } else if (char === "]") {
       depth--;
       if (depth === 0) inBracket = false;
-    } else if (char === '(') {
+    } else if (char === "(") {
       inParen = true;
       depth++;
-    } else if (char === ')') {
+    } else if (char === ")") {
       depth--;
       if (depth === 0) inParen = false;
     }
 
     // Only split on combinators when not inside brackets or parens
     if (depth === 0 && !inBracket && !inParen) {
-      if (char === '>' || char === '+' || char === '~') {
+      if (char === ">" || char === "+" || char === "~") {
         if (current.trim()) parts.push(current.trim());
         parts.push(char); // Keep combinator as separate part for context
-        current = '';
+        current = "";
         continue;
-      } else if (char === ' ' && current.trim()) {
+      } else if (char === " " && current.trim()) {
         // Space combinator (descendant)
         parts.push(current.trim());
-        current = '';
+        current = "";
         continue;
       }
     }
@@ -132,34 +132,38 @@ function parseSimpleSelector(selector) {
     const char = selector[i];
 
     // ID selector
-    if (char === '#') {
+    if (char === "#") {
       const match = selector.slice(i).match(/^#([\w-]+)/);
       if (!match) throw new Error(`Invalid ID selector at position ${i}`);
       components.push({ type: SELECTOR_TYPES.ID, value: match[1] });
       i += match[0].length;
     }
     // Class selector
-    else if (char === '.') {
+    else if (char === ".") {
       const match = selector.slice(i).match(/^\.([\w-]+)/);
       if (!match) throw new Error(`Invalid class selector at position ${i}`);
       components.push({ type: SELECTOR_TYPES.CLASS, value: match[1] });
       i += match[0].length;
     }
     // Attribute selector
-    else if (char === '[') {
+    else if (char === "[") {
       const endIdx = findMatchingBracket(selector, i);
-      if (endIdx === -1) throw new Error(`Unclosed attribute selector at position ${i}`);
+      if (endIdx === -1)
+        throw new Error(`Unclosed attribute selector at position ${i}`);
       const attrContent = selector.slice(i + 1, endIdx);
       components.push({ type: SELECTOR_TYPES.ATTRIBUTE, value: attrContent });
       i = endIdx + 1;
     }
     // Pseudo-element (::) or pseudo-class (:)
-    else if (char === ':') {
-      if (selector[i + 1] === ':') {
+    else if (char === ":") {
+      if (selector[i + 1] === ":") {
         // Pseudo-element
         const match = selector.slice(i).match(/^::([\w-]+)/);
         if (!match) throw new Error(`Invalid pseudo-element at position ${i}`);
-        components.push({ type: SELECTOR_TYPES.PSEUDO_ELEMENT, value: match[1] });
+        components.push({
+          type: SELECTOR_TYPES.PSEUDO_ELEMENT,
+          value: match[1],
+        });
         i += match[0].length;
       } else {
         // Pseudo-class (may have arguments like :not())
@@ -170,19 +174,23 @@ function parseSimpleSelector(selector) {
         i += match[0].length;
 
         // Check for function notation like :not()
-        if (selector[i] === '(') {
+        if (selector[i] === "(") {
           const endIdx = findMatchingParen(selector, i);
-          if (endIdx === -1) throw new Error(`Unclosed pseudo-class function at position ${i}`);
+          if (endIdx === -1)
+            throw new Error(`Unclosed pseudo-class function at position ${i}`);
           pseudoValue += selector.slice(i, endIdx + 1);
           i = endIdx + 1;
         }
 
-        components.push({ type: SELECTOR_TYPES.PSEUDO_CLASS, value: pseudoValue });
+        components.push({
+          type: SELECTOR_TYPES.PSEUDO_CLASS,
+          value: pseudoValue,
+        });
       }
     }
     // Universal selector
-    else if (char === '*') {
-      components.push({ type: SELECTOR_TYPES.UNIVERSAL, value: '*' });
+    else if (char === "*") {
+      components.push({ type: SELECTOR_TYPES.UNIVERSAL, value: "*" });
       i++;
     }
     // Type selector (element name)
@@ -193,10 +201,9 @@ function parseSimpleSelector(selector) {
       i += match[0].length;
     }
     // Skip combinators (should not be in simple selector)
-    else if (char === '>' || char === '+' || char === '~' || char === ' ') {
+    else if (char === ">" || char === "+" || char === "~" || char === " ") {
       i++;
-    }
-    else {
+    } else {
       throw new Error(`Unexpected character '${char}' at position ${i}`);
     }
   }
@@ -214,8 +221,8 @@ function parseSimpleSelector(selector) {
 function findMatchingBracket(str, startIdx) {
   let depth = 0;
   for (let i = startIdx; i < str.length; i++) {
-    if (str[i] === '[') depth++;
-    if (str[i] === ']') {
+    if (str[i] === "[") depth++;
+    if (str[i] === "]") {
       depth--;
       if (depth === 0) return i;
     }
@@ -233,8 +240,8 @@ function findMatchingBracket(str, startIdx) {
 function findMatchingParen(str, startIdx) {
   let depth = 0;
   for (let i = startIdx; i < str.length; i++) {
-    if (str[i] === '(') depth++;
-    if (str[i] === ')') {
+    if (str[i] === "(") depth++;
+    if (str[i] === ")") {
       depth--;
       if (depth === 0) return i;
     }
@@ -262,9 +269,8 @@ function findMatchingParen(str, startIdx) {
  */
 export function calculateSpecificity(selector) {
   // Parse if string, otherwise assume it's already parsed
-  const components = typeof selector === 'string'
-    ? parseSelector(selector)
-    : selector;
+  const components =
+    typeof selector === "string" ? parseSelector(selector) : selector;
 
   let a = 0; // IDs
   let b = 0; // Classes, attributes, pseudo-classes
@@ -283,7 +289,7 @@ export function calculateSpecificity(selector) {
 
       case SELECTOR_TYPES.PSEUDO_CLASS:
         // Handle :not() - it doesn't count itself, but its argument does
-        if (component.value.startsWith('not(')) {
+        if (component.value.startsWith("not(")) {
           const notContent = component.value.slice(4, -1); // Extract content inside :not()
           const notSpec = calculateSpecificity(notContent);
           a += notSpec[0];
@@ -325,10 +331,10 @@ export function calculateSpecificity(selector) {
  */
 export function compareSpecificity(spec1, spec2) {
   if (!Array.isArray(spec1) || spec1.length !== 3) {
-    throw new Error('spec1 must be an array of 3 numbers');
+    throw new Error("spec1 must be an array of 3 numbers");
   }
   if (!Array.isArray(spec2) || spec2.length !== 3) {
-    throw new Error('spec2 must be an array of 3 numbers');
+    throw new Error("spec2 must be an array of 3 numbers");
   }
 
   // Compare lexicographically: a first, then b, then c
@@ -358,12 +364,12 @@ export function compareSpecificity(spec1, spec2) {
  */
 export function sortBySpecificity(rules) {
   if (!Array.isArray(rules)) {
-    throw new Error('rules must be an array');
+    throw new Error("rules must be an array");
   }
 
   // Create array of [rule, specificity, originalIndex] tuples
   const withSpec = rules.map((rule, index) => {
-    if (!rule || typeof rule.selector !== 'string') {
+    if (!rule || typeof rule.selector !== "string") {
       throw new Error(`Rule at index ${index} must have a 'selector' property`);
     }
     return [rule, calculateSpecificity(rule.selector), index];
@@ -378,7 +384,7 @@ export function sortBySpecificity(rules) {
   });
 
   // Extract just the rules
-  return withSpec.map(tuple => tuple[0]);
+  return withSpec.map((tuple) => tuple[0]);
 }
 
 /**
@@ -390,29 +396,31 @@ export function sortBySpecificity(rules) {
  */
 export function stringifySelector(components) {
   if (!Array.isArray(components)) {
-    throw new Error('components must be an array');
+    throw new Error("components must be an array");
   }
 
-  return components.map(component => {
-    switch (component.type) {
-      case SELECTOR_TYPES.ID:
-        return `#${component.value}`;
-      case SELECTOR_TYPES.CLASS:
-        return `.${component.value}`;
-      case SELECTOR_TYPES.ATTRIBUTE:
-        return `[${component.value}]`;
-      case SELECTOR_TYPES.PSEUDO_CLASS:
-        return `:${component.value}`;
-      case SELECTOR_TYPES.PSEUDO_ELEMENT:
-        return `::${component.value}`;
-      case SELECTOR_TYPES.TYPE:
-        return component.value;
-      case SELECTOR_TYPES.UNIVERSAL:
-        return '*';
-      default:
-        return '';
-    }
-  }).join('');
+  return components
+    .map((component) => {
+      switch (component.type) {
+        case SELECTOR_TYPES.ID:
+          return `#${component.value}`;
+        case SELECTOR_TYPES.CLASS:
+          return `.${component.value}`;
+        case SELECTOR_TYPES.ATTRIBUTE:
+          return `[${component.value}]`;
+        case SELECTOR_TYPES.PSEUDO_CLASS:
+          return `:${component.value}`;
+        case SELECTOR_TYPES.PSEUDO_ELEMENT:
+          return `::${component.value}`;
+        case SELECTOR_TYPES.TYPE:
+          return component.value;
+        case SELECTOR_TYPES.UNIVERSAL:
+          return "*";
+        default:
+          return "";
+      }
+    })
+    .join("");
 }
 
 /**
@@ -427,7 +435,7 @@ export function verifySelector(selector) {
   const reconstructed = stringifySelector(components);
 
   // Normalize whitespace for comparison
-  const normalize = s => s.replace(/\s+/g, '');
+  const normalize = (s) => s.replace(/\s+/g, "");
 
   return normalize(selector) === normalize(reconstructed);
 }
@@ -439,5 +447,5 @@ export default {
   compareSpecificity,
   sortBySpecificity,
   stringifySelector,
-  verifySelector
+  verifySelector,
 };