postcss-normalize-string 9.0.4 → 9.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-normalize-string",
-  "version": "9.0.4",
+  "version": "9.0.5",
   "description": "Normalize wrapping quotes for CSS string literals.",
   "exports": {
     ".": {

package/src/index.js

@@ -6,6 +6,69 @@ const BACKSLASH = '\\'.charCodeAt(0);
 const NEWLINE = '\n'.charCodeAt(0);
 const FEED = '\f'.charCodeAt(0);
 const CR = '\r'.charCodeAt(0);
+const SPACE = ' '.charCodeAt(0);
+const TAB = '\t'.charCodeAt(0);
+
+/**
+ * @param {number} code
+ * @return {boolean}
+ */
+function isHexDigit(code) {
+  return (
+    (code >= 0x30 && code <= 0x39) ||
+    (code >= 0x41 && code <= 0x46) ||
+    (code >= 0x61 && code <= 0x66)
+  );
+}
+
+/**
+ * Return the index just past the hex digits of the escape whose backslash is at `pos`.
+ * CSS Syntax 3 allows one to six hex digits.
+ *
+ * @param {string} inner
+ * @param {number} pos
+ * @return {number}
+ */
+function getHexDigitsEnd(inner, pos) {
+  const limit = Math.min(pos + 7, inner.length);
+  let end = pos + 2;
+  while (end < limit && isHexDigit(inner.charCodeAt(end))) {
+    end++;
+  }
+  return end;
+}
+
+/**
+ * Return the length of the whitespace at `pos` (CRLF counts as one newline), or 0.
+ *
+ * @param {string} inner
+ * @param {number} pos
+ * @return {number}
+ */
+function getWhitespaceLength(inner, pos) {
+  const code = inner.charCodeAt(pos);
+  if (code === CR) {
+    return inner.charCodeAt(pos + 1) === NEWLINE ? 2 : 1;
+  }
+  return code === SPACE || code === TAB || code === NEWLINE || code === FEED
+    ? 1
+    : 0;
+}
+
+/**
+ * Return the space that keeps an open hex escape from absorbing the code point at `pos`.
+ *
+ * @param {string} inner
+ * @param {number} pos
+ * @param {boolean} acceptsMoreDigits
+ * @return {string}
+ */
+function getHexEscapeDelimiter(inner, pos, acceptsMoreDigits) {
+  return getWhitespaceLength(inner, pos) > 0 ||
+    (acceptsMoreDigits && isHexDigit(inner.charCodeAt(pos)))
+    ? ' '
+    : '';
+}
 
 /**
  * Verify whether a string token has matching delimiters and balanced trailing escapes.
@@ -14,20 +77,21 @@ const CR = '\r'.charCodeAt(0);
  * @return {boolean}
  */
 function isClosedString(value) {
-  if (value.length < 2 || (value[0] !== "'" && value[0] !== '"')) {
+  const len = value.length;
+  if (len < 2 || value.charCodeAt(len - 1) !== value.charCodeAt(0)) {
     return false;
   }
 
   let backslashes = 0;
   for (
-    let index = value.length - 2;
-    index >= 0 && value[index] === '\\';
+    let index = len - 2;
+    index >= 0 && value.charCodeAt(index) === BACKSLASH;
     index--
   ) {
     backslashes++;
   }
 
-  return value.at(-1) === value[0] && backslashes % 2 === 0;
+  return backslashes % 2 === 0;
 }
 
 /**
@@ -66,43 +130,30 @@ function scanQuotes(inner, currentQuote) {
 
   while (pos < len) {
     const code = inner.charCodeAt(pos);
-    if (code === BACKSLASH) {
-      if (pos + 1 < len) {
-        const newlineLen = getEscapedNewlineLength(inner, pos, len);
-        if (newlineLen > 0) {
-          hasEscapedNewline = true;
-          pos += newlineLen;
-          continue;
-        }
-        const next = inner.charCodeAt(pos + 1);
-        if (next === SINGLE_QUOTE) {
-          singleCount++;
-          if (currentQuote === '"') {
-            hasRedundantEscape = true;
-          }
-          pos += 2;
-          continue;
-        }
-        if (next === DOUBLE_QUOTE) {
-          doubleCount++;
-          if (currentQuote === "'") {
-            hasRedundantEscape = true;
-          }
-          pos += 2;
-          continue;
-        }
-        pos += 2;
-        continue;
+    if (code !== BACKSLASH) {
+      if (code === SINGLE_QUOTE) {
+        singleCount++;
+      } else if (code === DOUBLE_QUOTE) {
+        doubleCount++;
       }
       pos++;
       continue;
     }
-    if (code === SINGLE_QUOTE) {
+    const newlineLen = getEscapedNewlineLength(inner, pos, len);
+    if (newlineLen > 0) {
+      hasEscapedNewline = true;
+      pos += newlineLen;
+      continue;
+    }
+    const next = inner.charCodeAt(pos + 1);
+    if (next === SINGLE_QUOTE) {
       singleCount++;
-    } else if (code === DOUBLE_QUOTE) {
+      hasRedundantEscape ||= currentQuote === '"';
+    } else if (next === DOUBLE_QUOTE) {
       doubleCount++;
+      hasRedundantEscape ||= currentQuote === "'";
     }
-    pos++;
+    pos += 2;
   }
 
   return { singleCount, doubleCount, hasEscapedNewline, hasRedundantEscape };
@@ -151,35 +202,55 @@ function reconstructString(inner, targetQuote) {
   const chunks = [targetQuote];
   let cursor = 0;
   let pos = 0;
+  // A hex escape without a whitespace terminator would absorb a following hex
+  // digit or whitespace once the line continuations after it are removed.
+  let openHexEnd = -1;
+  let openHexIsShort = false;
 
   while (pos < len) {
     const code = inner.charCodeAt(pos);
     if (code === BACKSLASH) {
-      if (pos + 1 < len) {
-        const newlineLen = getEscapedNewlineLength(inner, pos, len);
-        if (newlineLen > 0) {
-          if (pos > cursor) {
-            chunks.push(inner.slice(cursor, pos));
-          }
-          pos += newlineLen;
-          cursor = pos;
-          continue;
+      const newlineLen = getEscapedNewlineLength(inner, pos, len);
+      if (newlineLen > 0) {
+        if (pos > cursor) {
+          chunks.push(inner.slice(cursor, pos));
         }
-        if (inner.charCodeAt(pos + 1) === otherCode) {
-          if (pos > cursor) {
-            chunks.push(inner.slice(cursor, pos));
-          }
-          chunks.push(otherQuote);
-          pos += 2;
-          cursor = pos;
-          continue;
+        const followsOpenHex = pos === openHexEnd;
+        pos += newlineLen;
+        cursor = pos;
+        if (followsOpenHex) {
+          openHexEnd = pos;
+          chunks.push(getHexEscapeDelimiter(inner, pos, openHexIsShort));
+        }
+        continue;
+      }
+
+      const next = inner.charCodeAt(pos + 1);
+      if (next === otherCode) {
+        if (pos > cursor) {
+          chunks.push(inner.slice(cursor, pos));
         }
+        chunks.push(otherQuote);
         pos += 2;
+        cursor = pos;
         continue;
       }
-      pos++;
+
+      if (isHexDigit(next)) {
+        const digitsEnd = getHexDigitsEnd(inner, pos);
+        const terminatorLen = getWhitespaceLength(inner, digitsEnd);
+        if (terminatorLen === 0) {
+          openHexEnd = digitsEnd;
+          openHexIsShort = digitsEnd - pos < 7;
+        }
+        pos = digitsEnd + terminatorLen;
+        continue;
+      }
+
+      pos += 2;
       continue;
     }
+
     if (code === targetCode) {
       if (pos > cursor) {
         chunks.push(inner.slice(cursor, pos));
@@ -189,6 +260,7 @@ function reconstructString(inner, targetQuote) {
       cursor = pos;
       continue;
     }
+
     pos++;
   }
 
@@ -208,7 +280,13 @@ function reconstructString(inner, targetQuote) {
  */
 function normalizeString(raw, preferredQuote) {
   const currentQuote = raw[0];
+  const targetDelimiter = preferredQuote === 'single' ? "'" : '"';
   const inner = raw.slice(1, -1);
+
+  if (currentQuote === targetDelimiter && !inner.includes('\\')) {
+    return raw;
+  }
+
   const { singleCount, doubleCount, hasEscapedNewline, hasRedundantEscape } =
     scanQuotes(inner, currentQuote);
 
@@ -236,25 +314,16 @@ function normalizeString(raw, preferredQuote) {
  * @return {string}
  */
 function normalize(value, preferredQuote) {
-  if (!value || (!value.includes("'") && !value.includes('"'))) {
-    return value;
-  }
-
   const chunks = [];
   let cursor = 0;
-  let changed = false;
   for (const [type, raw, start, end] of tokenize({ css: value })) {
-    if (type !== TokenType.String) continue;
-    if (!isClosedString(raw)) continue;
+    if (type !== TokenType.String || !isClosedString(raw)) continue;
     const normalized = normalizeString(raw, preferredQuote);
-    if (normalized !== raw) {
-      changed = true;
-    }
-    chunks.push(value.slice(cursor, start));
-    chunks.push(normalized);
+    if (normalized === raw) continue;
+    chunks.push(value.slice(cursor, start), normalized);
     cursor = end + 1;
   }
-  if (!changed) return value;
+  if (cursor === 0) return value;
   chunks.push(value.slice(cursor));
   return chunks.join('');
 }
@@ -266,12 +335,14 @@ function normalize(value, preferredQuote) {
  * @return {string}
  */
 function minify(original, cache, preferredQuote) {
-  const key = original + '|' + preferredQuote;
-  if (cache.has(key)) {
-    return /** @type {string} */ (cache.get(key));
+  if (!original || (!original.includes("'") && !original.includes('"'))) {
+    return original;
+  }
+  if (cache.has(original)) {
+    return /** @type {string} */ (cache.get(original));
   }
   const newValue = normalize(original, preferredQuote);
-  cache.set(key, newValue);
+  cache.set(original, newValue);
   return newValue;
 }
 
@@ -287,13 +358,7 @@ function assignValue(decl, value) {
  * @return {import('postcss').Plugin}
  */
 function pluginCreator(opts) {
-  const { preferredQuote } = Object.assign(
-    {},
-    {
-      preferredQuote: 'double',
-    },
-    opts
-  );
+  const { preferredQuote = 'double' } = opts ?? {};
 
   return {
     postcssPlugin: 'postcss-normalize-string',
@@ -309,17 +374,19 @@ function pluginCreator(opts) {
           case 'rule':
             node.selector = minify(node.selector, cache, preferredQuote);
             break;
-          case 'decl':
-            {
-              const value =
-                node.raws.value?.value === node.value
-                  ? (node.raws.value.raw ?? node.value)
-                  : node.value;
-              assignValue(node, minify(value, cache, preferredQuote));
-            }
+          case 'decl': {
+            const rawValue = node.raws.value;
+            const value =
+              rawValue?.value === node.value
+                ? (rawValue.raw ?? node.value)
+                : node.value;
+            assignValue(node, minify(value, cache, preferredQuote));
             break;
+          }
           case 'atrule':
-            node.params = minify(node.params, cache, preferredQuote);
+            if (node.name.toLowerCase() !== 'charset') {
+              node.params = minify(node.params, cache, preferredQuote);
+            }
             break;
         }
       });

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AA2RI,YAAkD,OAAO,GAA/C;IAAC,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAAC,CAAS;AAA7D,gEAAgE;AAChE;;;GAGG;AACH,iBAAS,aAAa,CAAC,IAAI,EAHhB,OAGgB,GAFf,OAAO,SAAS,EAAE,MAAM,CAyCnC;kBAvCQ,aAAa;iBAwCX,IAAI;;AAEf,QAAA,MAAM,aAAa,sBAAgB,CAAC;AAEpC,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAkWI,YAAkD,OAAO,GAA/C;IAAC,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAAC,CAAS;AAA7D,gEAAgE;AAChE;;;GAGG;AACH,iBAAS,aAAa,CAAC,IAAI,EAHhB,OAGgB,GAFf,OAAO,SAAS,EAAE,MAAM,CAqCnC;kBAnCQ,aAAa;iBAoCX,IAAI;;AAEf,QAAA,MAAM,aAAa,sBAAgB,CAAC;AAEpC,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}