fix(text/unstable): dedent() correct blank line handling (#6738)

Author: lionel-rowe

text/unstable_dedent.ts

@@ -1,5 +1,16 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 // This module is browser compatible.
+import { longestCommonPrefix } from "./unstable_longest_common_prefix.ts";
+
+const WHITE_SPACE = String.raw`\t\v\f\ufeff\p{Space_Separator}`;
+const INDENT_REGEXP = new RegExp(
+  String.raw`^[${WHITE_SPACE}]+`,
+  "u",
+);
+const WHITE_SPACE_ONLY_LINE_REGEXP = new RegExp(
+  String.raw`^[${WHITE_SPACE}]+$`,
+  "mu",
+);
 
 /**
  * Removes indentation from multiline strings.
@@ -68,36 +79,30 @@ export function dedent(
   const trimmedTemplate = joinedTemplate.replace(/^\n/, "").trimEnd();
   const lines = trimmedTemplate.split("\n");
 
-  let minIndentWidth: number | undefined = undefined;
-  for (let i = 0; i < lines.length; i++) {
-    const indentMatch = lines[i]!.match(/^(\s*)\S/);
-
-    // Skip empty lines
-    if (indentMatch === null) {
-      continue;
-    }
+  const linesToCheck = lines.slice(
+    ignoreFirstUnindented && !INDENT_REGEXP.test(lines[0] ?? "") ? 1 : 0,
+  )
+    .filter((l) => l.length > 0 && !WHITE_SPACE_ONLY_LINE_REGEXP.test(l));
 
-    const indentWidth = indentMatch[1]!.length;
-    if (ignoreFirstUnindented && i === 0 && indentWidth === 0) {
-      continue;
-    }
-    if (minIndentWidth === undefined || indentWidth < minIndentWidth) {
-      minIndentWidth = indentWidth;
-    }
-  }
+  const commonPrefix = longestCommonPrefix(linesToCheck);
+  const indent = commonPrefix.match(INDENT_REGEXP)?.[0];
 
   const inputString = typeof input === "string"
     ? input
     : String.raw({ raw: input }, ...values);
   const trimmedInput = inputString.replace(/^\n/, "").trimEnd();
 
   // No lines to indent
-  if (minIndentWidth === undefined || minIndentWidth === 0) {
-    return trimmedInput;
-  }
+  if (!indent) return trimmedInput;
 
-  const minIndentRegex = new RegExp(`^\\s{${minIndentWidth}}`, "gm");
+  const minIndentRegex = new RegExp(String.raw`^${indent}`, "gmu");
   return trimmedInput
     .replaceAll(minIndentRegex, "")
-    .replaceAll(/^\s+$/gm, "");
+    .replaceAll(
+      new RegExp(
+        WHITE_SPACE_ONLY_LINE_REGEXP,
+        WHITE_SPACE_ONLY_LINE_REGEXP.flags + "g",
+      ),
+      "",
+    );
 }

text/unstable_dedent_test.ts

@@ -1,6 +1,7 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 import { dedent } from "./unstable_dedent.ts";
 import { assertEquals } from "@std/assert";
+import { stub } from "@std/testing/mock";
 
 Deno.test("dedent() handles example 1", () => {
   assertEquals(
@@ -78,3 +79,99 @@ Deno.test("dedent() handles multiline substitution", () => {
 `;
   assertEquals(outer, "1\n2\n3\n4");
 });
+
+Deno.test("dedent() handles mixed tabs and spaces", async (t) => {
+  // @ts-ignore augmenting globalThis so we don't need to resort to bare `eval`
+  using _ = stub(globalThis, "dedent", dedent);
+
+  await t.step("with partial common prefix", () => {
+    assertEquals(
+      globalThis.eval(`dedent\`\n  a\n \tb\n\``),
+      " a\n\tb",
+    );
+  });
+
+  await t.step("with no common prefix", () => {
+    assertEquals(
+      globalThis.eval(`dedent\`\n\t a\n \tb\n\``),
+      "\t a\n \tb",
+    );
+  });
+});
+
+Deno.test("dedent() handles blank lines correctly", async (t) => {
+  // @ts-ignore augmenting globalThis so we don't need to resort to bare `eval`
+  using _ = stub(globalThis, "dedent", dedent);
+
+  for (const lineEnding of ["\n", "\r\n"]) {
+    // CRLF actually doesn't change the output, as literal CRLFs in template literals in JS files are read as `\n`
+    // (this behavior is in the JS spec, not library behavior).
+    await t.step(
+      `${lineEnding === "\n" ? "LF" : "CRLF"} line ending`,
+      async (t) => {
+        for (const space of [" ", "\t"]) {
+          const spaceName = space === " " ? "space" : "tab";
+          await t.step(`${spaceName}s`, async (t) => {
+            for (const indent of [0, 1, 2]) {
+              for (const between of [0, 1, 2]) {
+                // these cases won't fully dedent, which is probably (??) fine
+                if (indent === 0 && between !== 0) continue;
+
+                const testName =
+                  `${indent}-${spaceName} indent with ${between} ${spaceName}s between`;
+
+                await t.step(testName, () => {
+                  const source = [
+                    "",
+                    `${space.repeat(indent)}a`,
+                    space.repeat(between),
+                    `${space.repeat(indent)}b`,
+                    "",
+                  ].join(lineEnding);
+
+                  const result = globalThis.eval(`dedent\`${source}\``);
+                  assertEquals(result, "a\n\nb");
+                });
+
+                // these cases will strip the first-line/last-line indents, which is probably (??) fine
+                if (indent === 0) continue;
+
+                await t.step(
+                  `${testName} preserves added first-line indent`,
+                  () => {
+                    const source = [
+                      "",
+                      `${space.repeat(indent + 1)}a`,
+                      space.repeat(between),
+                      `${space.repeat(indent)}b`,
+                      "",
+                    ].join(lineEnding);
+
+                    const result = globalThis.eval(`dedent\`${source}\``);
+                    assertEquals(result, `${space}a\n\nb`);
+                  },
+                );
+
+                await t.step(
+                  `${testName} preserves added last-line indent`,
+                  () => {
+                    const source = [
+                      "",
+                      `${space.repeat(indent)}a`,
+                      space.repeat(between),
+                      `${space.repeat(indent + 1)}b`,
+                      "",
+                    ].join(lineEnding);
+
+                    const result = globalThis.eval(`dedent\`${source}\``);
+                    assertEquals(result, `a\n\n${space}b`);
+                  },
+                );
+              }
+            }
+          });
+        }
+      },
+    );
+  }
+});