fix: read a rule's contents past a quoted brace, and keep the caller's options

`ruleBody` now skips braces inside strings and comments instead of declining
the rule, `esbuildMinifyCss` no longer deletes `as` from the options object it
is handed, and `swcMinifyCss` drops a map the options asked for when the body
was wrapped.

Claude-Session: https://claude.ai/code/session_01Vszf1WJhCqatsMQ2xZLF9x

Author: alexander-akait

src/utils.js

@@ -86,9 +86,37 @@ function ruleBody(answered) {
 
   if (written === "") return "";
 
-  const match = /^a\s*\{([^{}]*)\}$/.exec(written);
+  const opened = /^a\s*\{/.exec(written);
 
-  return match ? match[1].trim() : undefined;
+  if (!opened || !written.endsWith("}")) return undefined;
+
+  const end = written.length - 1;
+
+  // A brace a string or a comment holds is text rather than a block's edge, and
+  // one left open would reach past the brace closing the rule.
+  for (let i = opened[0].length; i < end; i++) {
+    const char = written[i];
+
+    if (char === "{" || char === "}") return undefined;
+
+    if (char === "\\") {
+      i++;
+    } else if (char === '"' || char === "'") {
+      for (i++; i < end && written[i] !== char; i++) {
+        if (written[i] === "\\") i++;
+      }
+
+      if (i >= end) return undefined;
+    } else if (char === "/" && written[i + 1] === "*") {
+      const closed = written.indexOf("*/", i + 2);
+
+      if (closed === -1 || closed + 2 > end) return undefined;
+
+      i = closed + 1;
+    }
+  }
+
+  return written.slice(opened[0].length, end).trim();
 }
 
 /**
@@ -1878,23 +1906,23 @@ async function esbuildMinifyCss(input, sourceMap, minimizerOptions) {
    * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean, as?: string }=} esbuildOptions esbuild options
    * @returns {import("esbuild").TransformOptions} built esbuild options
    */
-  const buildEsbuildOptions = (esbuildOptions = {}) => {
+  const buildEsbuildOptions = ({
     // `module` and `ecma` are JavaScript-only concepts; the dispatcher
     // injects them for every minimizer, and `as` is the body's rather than
     // esbuild's, but esbuild's CSS transform rejects unknown options.
-    delete esbuildOptions.ecma;
-    delete esbuildOptions.module;
-    delete esbuildOptions.as;
-
+    ecma,
+    module,
+    as,
+    ...esbuildOptions
+  } = {}) =>
     // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
-    return {
+    ({
       loader: "css",
       minify: true,
       legalComments: "inline",
       ...esbuildOptions,
       sourcemap: false,
-    };
-  };
+    });
 
   let esbuild;
 
@@ -2148,8 +2176,11 @@ async function swcMinifyCss(input, sourceMap, minimizerOptions) {
   const swcOptions = buildSwcOptions(minimizerOptions);
 
   // Let `swc` generate a SourceMap; a wrap moves every position, so the map
-  // would describe a stylesheet that is not what comes back.
-  if (sourceMap && !contents) {
+  // would describe a stylesheet that is not what comes back, whatever the
+  // options asked for.
+  if (contents) {
+    swcOptions.sourceMap = false;
+  } else if (sourceMap) {
     swcOptions.sourceMap = true;
   }
 

test/embedded-protocol.test.js

@@ -893,11 +893,78 @@ describe("the rule a block's contents are minified inside", () => {
     expect(ruleBody("")).toBe("");
   });
 
+  it("reads past a brace a string or a comment holds", () => {
+    expect(ruleBody('a{content:"{"}')).toBe('content:"{"');
+    expect(ruleBody("a{content:'}'}")).toBe("content:'}'");
+    expect(ruleBody('a{content:"\\"}"}')).toBe('content:"\\"}"');
+    expect(ruleBody("a{/* } */color:red}")).toBe("/* } */color:red");
+  });
+
   it("declines an answer that is not that one rule", () => {
     expect(ruleBody("color:red")).toBeUndefined();
     expect(ruleBody("a{color:red}b{color:blue}")).toBeUndefined();
     expect(ruleBody("b{color:red}")).toBeUndefined();
     expect(ruleBody("@media print{a{color:red}}")).toBeUndefined();
     expect(ruleBody(undefined)).toBeUndefined();
+    expect(ruleBody('a{content:"{"}b{color:blue}')).toBeUndefined();
+    expect(ruleBody("a{color:red")).toBeUndefined();
+  });
+});
+
+describe("a CSS minimizer handed a block's contents directly", () => {
+  it("minifies a string holding a brace", async () => {
+    const result = await MinimizerPlugin.cssoMinify(
+      { "style.css": '  content :  "{"  ' },
+      undefined,
+      { as: "block-contents" },
+    );
+
+    expect(result.code).toBe('content:"{"');
+  });
+
+  it("leaves the options it was handed as they were", async () => {
+    const options = { as: "block-contents" };
+    const input = { "style.css": "  color :  red  " };
+
+    const first = await MinimizerPlugin.esbuildMinifyCss(
+      input,
+      undefined,
+      options,
+    );
+    const second = await MinimizerPlugin.esbuildMinifyCss(
+      input,
+      undefined,
+      options,
+    );
+
+    expect(options).toEqual({ as: "block-contents" });
+    expect(first.code).toBe("color:red");
+    expect(second.code).toBe("color:red");
   });
+
+  it.each([
+    ["cssoMinify", MinimizerPlugin.cssoMinify, { sourceMap: true }],
+    ["cleanCssMinify", MinimizerPlugin.cleanCssMinify, { sourceMap: true }],
+    ["esbuildMinifyCss", MinimizerPlugin.esbuildMinifyCss, { sourcemap: true }],
+    [
+      "lightningCssMinify",
+      MinimizerPlugin.lightningCssMinify,
+      { sourceMap: true },
+    ],
+    ["swcMinifyCss", MinimizerPlugin.swcMinifyCss, { sourceMap: true }],
+  ])(
+    "returns no map for the rule `%s` minified it inside",
+    async (name, minifier, mapOptions) => {
+      // The wrap moves every position, so a map asked for by the options too
+      // would describe a stylesheet that is not what comes back.
+      const result = await minifier(
+        { "style.css": "  color :  red  " },
+        { version: 3, sources: [], names: [], mappings: "" },
+        { as: "block-contents", ...mapOptions },
+      );
+
+      expect(result.code).toBe("color:red");
+      expect(result.map).toBeUndefined();
+    },
+  );
 });