@@ -36,6 +36,7 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@tone-row/strip-comments": "2.0.6",
     "@typescript-eslint/eslint-plugin": "^6.7.3",
     "@typescript-eslint/parser": "^6.7.3",
     "eslint": "^8.50.0",
@@ -47,13 +48,10 @@
     "vitest": "^0.34.5"
   },
   "dependencies": {
-    "@types/strip-comments": "^2.0.2",
-    "@tone-row/strip-comments": "^2.0.6",
     "@types/cytoscape": "^3.19.11",
     "html-entities": "^2.4.0",
     "monaco-editor": "^0.43.0",
-    "pkgroll": "^2.4.1",
-    "strip-comments": "^2.0.1"
+    "pkgroll": "^2.4.1"
   },
   "browserslist": [
     "defaults"
 
@@ -3,9 +3,7 @@ import { getEdgeBreakIndex, getFeaturesIndex } from "./regexps";
 
 import { getFeatureData } from "./getFeatureData";
 import { matchAndRemovePointers } from "./matchAndRemovePointers";
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import { strip } from "@tone-row/strip-comments";
+import { stripComments } from "./stripComments";
 import { ParseError } from "./ParseError";
 import { getIndentSize } from "./getIndentSize";
 
@@ -35,7 +33,7 @@ export function parse(text: string): Graph {
   text = text.replace(/(https?:)\/\//g, "$1\\/\\/");
 
   // break into lines
-  let lines = strip(text, { preserveNewlines: true }).split(/\n/g);
+  let lines = stripComments(text).split(/\n/g);
 
   // unescape backslashes in newlines
   lines = lines.map((line: string) => line.replace(/\\n/g, "\n"));
 
@@ -0,0 +1,106 @@
+import { describe, expect, test } from "vitest";
+// @ts-expect-error the fork's package.json "exports" hides its type declarations
+import { strip } from "@tone-row/strip-comments";
+import { stripComments } from "./stripComments";
+import { realisticDoc, rng } from "../bench/generate";
+
+const fork = (text: string): string => strip(text, { preserveNewlines: true });
+const escapeUrls = (text: string) => text.replace(/(https?:)\/\//g, "$1\\/\\/");
+
+const EDGE_CASES = [
+  "a // line comment",
+  "// whole line\nb",
+  "a\n  // indented\nb",
+  "a /* inline */ b",
+  "a /* multi\nline\ncomment */\nb",
+  "a /* unclosed\nb\nc",
+  "a */ b",
+  "/* a /* nested */ still? */ b",
+  "/**/ after",
+  "/***/ after",
+  "/*! protected */ x",
+  "//! protected",
+  "x /*a*/\ny",
+  "see https:\\/\\/example.com // c",
+  '[url="http:\\/\\/x.com"] a',
+  "ftp://host/path",
+  '"quoted // not comment" x',
+  "'single // hidden' x",
+  "`tick // hidden` x",
+  'say "open // c\nnext // d\nclose" e',
+  "don't // c\nwon't",
+  "a'b // c'",
+  '"" // c',
+  '""x" // c',
+  'esc \\"q // c',
+  '"a\\" // b" // c',
+  "a \\/\\/ b",
+  "a \\// b",
+  "a \\\\// b",
+  "# hash",
+  "<!-- html -->",
+  "-- sql",
+  "a\r\nb // c\r\nd",
+  "a // c\u2028b",
+  "a /* x */\nb /* y */ c",
+  "label \\n newline // c",
+  "{ a // c\n}",
+  "a: b // c",
+  '"unterminated // c',
+  '/* "a*/" b */ c',
+  "/* \\*/ x */ y",
+  '"""// c"',
+  '\u00e9"a // b"',
+  '"a\x01b" // c"',
+  '"a\\" b // c',
+  "a // c\u2029b",
+  "_'x // y'",
+];
+
+const TOKENS = [
+  ...["/", "*", "\\", '"', "'", "`", "\n", "\r", "\u2028", "\u2029", "\x01"],
+  ...["a", "_", "\u00e9", "\u{1F600}", " ", "!", ":"],
+  ...["/*", "*/", "//", "/**", "/*!", "*/\n", '\\"', "\\*", '"""', "\\\n"],
+];
+
+function fuzzCorpus(count: number, seed: number) {
+  const r = rng(seed);
+  return Array.from({ length: count }, () => {
+    const length = 1 + Math.floor(r() * 40);
+    return Array.from({ length }, () => TOKENS[Math.floor(r() * TOKENS.length)]).join("");
+  });
+}
+
+const corpus = fuzzCorpus(20000, 7);
+
+function mismatches(inputs: string[]) {
+  return inputs
+    .map((input) => ({ input, expected: fork(input), actual: stripComments(input) }))
+    .filter(({ expected, actual }) => expected !== actual)
+    .slice(0, 5);
+}
+
+describe("stripComments matches @tone-row/strip-comments", () => {
+  test.each(EDGE_CASES)("%j", (input) => {
+    expect(stripComments(input)).toBe(fork(input));
+  });
+
+  test("seeded fuzz corpus", () => {
+    expect(mismatches(corpus)).toEqual([]);
+  });
+
+  test("realistic documents, raw and with URLs escaped as parse does", () => {
+    const docs = [50, 500, 2000].flatMap((lines) =>
+      [1, 2, 3, 4, 5].map((seed) => realisticDoc(lines, seed)),
+    );
+    expect(mismatches([...docs, ...docs.map(escapeUrls)])).toEqual([]);
+  });
+});
+
+test("stripComments keeps the line count, which parse relies on for line numbers", () => {
+  const lineCount = (text: string) => text.split("\n").length;
+  const changed = [...EDGE_CASES, ...corpus].filter(
+    (input) => lineCount(stripComments(input)) !== lineCount(input),
+  );
+  expect(changed.slice(0, 5)).toEqual([]);
+});
@@ -0,0 +1,72 @@
+const isWordChar = (c: string) => /\w/.test(c);
+const isLineTerminator = (c: string) =>
+  c === "\n" || c === "\r" || c === "\u2028" || c === "\u2029";
+const newlinesIn = (s: string) => s.replace(/[^\n]/g, "");
+
+/**
+ * Mirrors the fork's lazy /^(['"`])((?:\\\1|[^\1])+?)(\1)/: the body needs at least one char,
+ * `[^\1]` is the octal class "not \x01", and on failure the match backtracks to the last
+ * escaped quote.
+ */
+function findClosingQuote(text: string, open: number): number {
+  const quote = text.charAt(open);
+  let lastEscapedQuote = -1;
+  for (let j = open + 1; ; j++) {
+    if (j > open + 1 && text.charAt(j) === quote) return j;
+    if (j >= text.length || text.charAt(j) === "\x01") return lastEscapedQuote;
+    if (text.charAt(j) === "\\" && text.charAt(j + 1) === quote) {
+      lastEscapedQuote = j + 1;
+      j++;
+    }
+  }
+}
+
+export function stripComments(text: string): string {
+  let out = "";
+  let keptFrom = 0;
+  let depth = 0;
+  let i = 0;
+  while (i < text.length) {
+    const c = text.charAt(i);
+    const next = text.charAt(i + 1);
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (depth === 0 && (c === '"' || c === "'" || c === "`") && !isWordChar(text.charAt(i - 1))) {
+      const close = findClosingQuote(text, i);
+      if (close !== -1) {
+        i = close + 1;
+        continue;
+      }
+    }
+    if (c === "/" && next === "*") {
+      if (depth === 0) {
+        out += text.slice(keptFrom, i);
+        keptFrom = i;
+      }
+      depth++;
+      i += 2;
+      // The fork's opener is /^\/\*\*?/, so `/**/` never closes and swallows the rest of the document.
+      if (text.charAt(i) === "*") i++;
+      continue;
+    }
+    if (depth > 0 && c === "*" && next === "/") {
+      i += 2;
+      if (--depth === 0) {
+        out += newlinesIn(text.slice(keptFrom, i));
+        keptFrom = i;
+      }
+      continue;
+    }
+    if (depth === 0 && c === "/" && next === "/") {
+      out += text.slice(keptFrom, i);
+      while (i < text.length && !isLineTerminator(text.charAt(i))) i++;
+      keptFrom = i;
+      continue;
+    }
+    i++;
+  }
+  const rest = text.slice(keptFrom);
+  return out + (depth > 0 ? newlinesIn(rest) : rest);
+}