@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/dispatch/facts/import-facts.js

@@ -0,0 +1,169 @@
+import { logLatency } from "../../latency-logger.js";
+import { isJstsFactFile } from "../../file-kinds.js";
+import { childrenOfType, firstChildOfType, withFactTree, walk } from "./tree-sitter-facts.js";
+export function importFactsApplyTo(filePath) {
+  return isJstsFactFile(filePath);
+}
+function stripQuotes(raw) {
+  return raw.replace(/^["'`]+|["'`]+$/g, "");
+}
+function parseStaticImport(node, moduleType) {
+  const sourceNode = firstChildOfType(node, "string");
+  if (!sourceNode)
+    return null;
+  const source = stripQuotes(sourceNode.text);
+  const clause = firstChildOfType(node, "import_clause");
+  if (!clause) {
+    return { source, names: [], moduleType };
+  }
+  const entry = { source, names: [], moduleType };
+  for (const child of clause.children ?? []) {
+    if (!child)
+      continue;
+    if (child.type === "identifier") {
+      entry.defaultName = child.text;
+    } else if (child.type === "namespace_import") {
+      const id = firstChildOfType(child, "identifier");
+      if (id)
+        entry.namespace = id.text;
+    } else if (child.type === "named_imports") {
+      for (const spec of childrenOfType(child, "import_specifier")) {
+        const ids = childrenOfType(spec, "identifier");
+        const local = ids.length ? ids[ids.length - 1].text : undefined;
+        if (local)
+          entry.names.push(local);
+      }
+    }
+  }
+  return entry;
+}
+function parseReExport(node) {
+  const sourceNode = firstChildOfType(node, "string");
+  if (!sourceNode)
+    return null;
+  const source = stripQuotes(sourceNode.text);
+  const clause = firstChildOfType(node, "export_clause");
+  if (!clause) {
+    return { source, names: [] };
+  }
+  const names = [];
+  for (const spec of childrenOfType(clause, "export_specifier")) {
+    const ids = childrenOfType(spec, "identifier");
+    const name = ids.length ? ids[ids.length - 1].text : undefined;
+    if (name)
+      names.push(name);
+  }
+  return { source, names };
+}
+export const importFactProvider = {
+  id: "fact.file.imports",
+  provides: ["file.imports", "file.reexports", "file.importFactsCoverage"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return importFactsApplyTo(ctx.filePath);
+  },
+  async run(ctx, store) {
+    const content = store.getFileFact(ctx.filePath, "file.content");
+    const setEmpty = (complete = false) => {
+      store.setFileFact(ctx.filePath, "file.imports", []);
+      store.setFileFact(ctx.filePath, "file.reexports", []);
+      store.setFileFact(ctx.filePath, "file.importFactsCoverage", complete ? "complete" : "unavailable");
+    };
+    if (content == null) {
+      setEmpty();
+      return;
+    }
+    const parsed = await withFactTree(ctx.filePath, content, (root) => {
+      let hasEsm = false;
+      let hasCjs = false;
+      const importNodes = [];
+      const reExportNodes = [];
+      for (const child of root.children ?? []) {
+        if (!child)
+          continue;
+        if (child.type === "import_statement") {
+          hasEsm = true;
+          importNodes.push(child);
+        } else if (child.type === "export_statement") {
+          const isReExport = Boolean(firstChildOfType(child, "string"));
+          if (isReExport || firstChildOfType(child, "export_clause")) {
+            hasEsm = true;
+          }
+          if (isReExport)
+            reExportNodes.push(child);
+        }
+      }
+      const dynamicRaw = [];
+      walk(root, (node) => {
+        if (node.type === "call_expression") {
+          const callee = node.children?.[0];
+          const args = firstChildOfType(node, "arguments");
+          const strArg = args ? firstChildOfType(args, "string") : undefined;
+          if (!strArg)
+            return;
+          const source = stripQuotes(strArg.text);
+          if (callee?.type === "import") {
+            dynamicRaw.push({ source, kind: "import" });
+          } else if (callee?.type === "identifier" && callee.text === "require") {
+            dynamicRaw.push({ source, kind: "require" });
+            hasCjs = true;
+          }
+        } else if (node.type === "member_expression") {
+          const obj = node.children?.[0];
+          if (obj?.type === "identifier" && obj.text === "module") {
+            const prop = firstChildOfType(node, "property_identifier");
+            if (prop?.text === "exports")
+              hasCjs = true;
+          }
+        }
+      });
+      const moduleType = hasEsm && !hasCjs ? "esm" : hasCjs && !hasEsm ? "cjs" : hasEsm || hasCjs ? "esm" : "unknown";
+      const imports = [];
+      for (const node of importNodes) {
+        const entry = parseStaticImport(node, moduleType);
+        if (entry)
+          imports.push(entry);
+      }
+      let dynamicCount = 0;
+      for (const d of dynamicRaw) {
+        if (d.kind === "import") {
+          imports.push({
+            source: d.source,
+            names: [],
+            isDynamic: true,
+            moduleType
+          });
+        } else {
+          imports.push({ source: d.source, names: [], moduleType: "cjs" });
+        }
+        dynamicCount++;
+      }
+      store.setFileFact(ctx.filePath, "file.imports", imports);
+      const reexports = [];
+      for (const node of reExportNodes) {
+        const r = parseReExport(node);
+        if (r)
+          reexports.push(r);
+      }
+      store.setFileFact(ctx.filePath, "file.reexports", reexports);
+      if (dynamicCount > 0 || reexports.length > 0) {
+        logLatency({
+          type: "call_graph_facts",
+          filePath: ctx.filePath,
+          durationMs: 0,
+          metadata: {
+            moduleType,
+            staticImports: imports.length - dynamicCount,
+            dynamicImports: dynamicCount,
+            reexports: reexports.length,
+            starReexports: reexports.filter((r) => r.names.length === 0).length
+          }
+        });
+      }
+    });
+    if (!parsed.parsed)
+      setEmpty();
+    else
+      store.setFileFact(ctx.filePath, "file.importFactsCoverage", "complete");
+  }
+};

package/extensions/dm-lens/dist/clients/dispatch/facts/tree-sitter-facts.js

@@ -0,0 +1,19 @@
+import { childrenOfType, firstChildOfType, withTreeSitterRoot, walk } from "../../tree-sitter-shared.js";
+
+export { childrenOfType, firstChildOfType, walk };
+export const withFactTree = withTreeSitterRoot;
+export async function extractFactsFromTree(ctx, store, defaults, extract, coverageFact) {
+  const writeAll = (facts, complete) => {
+    for (const key of Object.keys(defaults)) {
+      store.setFileFact(ctx.filePath, key, facts[key] ?? defaults[key]);
+    }
+    if (coverageFact) {
+      store.setFileFact(ctx.filePath, coverageFact, complete ? "complete" : "unavailable");
+    }
+  };
+  const content = store.getFileFact(ctx.filePath, "file.content");
+  if (content == null)
+    return writeAll(defaults, false);
+  const parsed = await withFactTree(ctx.filePath, content, (root) => extract(root, content));
+  writeAll(parsed.parsed ? parsed.value : defaults, parsed.parsed);
+}

package/extensions/dm-lens/dist/clients/dispatch/facts/try-catch-facts.js

@@ -0,0 +1,95 @@
+import { extractFactsFromTree, firstChildOfType, walk } from "./tree-sitter-facts.js";
+function hasAssignmentExpression(node) {
+  if (!node)
+    return false;
+  let found = false;
+  walk(node, (n) => {
+    if (n.type === "assignment_expression")
+      found = true;
+  });
+  return found;
+}
+function isOnlyWhitespaceOrComments(text) {
+  let stripped = text.replace(/\/\*[\s\S]*?\*\//g, "");
+  stripped = stripped.replace(/\/\/[^\n]*/g, "");
+  return stripped.trim().length === 0;
+}
+const DEFAULT_VALUE_PATTERN = /\breturn\s+(null|undefined|false|true|0|""|''|``|\[\]|\{\}|new\s+\w+\(\))/;
+const STRUCTURED_ERROR_PATTERN = /\breturn\s+\{[^}]*(?:success\s*:\s*false|error\s*:)/;
+const EXPLAINING_COMMENT_PATTERN = /(?:\/\/\s*\S.{3,}|\/\*\s*\S[\s\S]{3,}?\*\/)/;
+const FS_PROBE_PATTERN = /\b(?:existsSync|statSync|lstatSync|readFileSync|accessSync)\b/;
+const DB_PATTERN = /\b(?:query|execute|findOne|findMany|findById|insert|update|delete|select|prisma\.|knex\.|sequelize\.)/;
+const NETWORK_PATTERN = /\b(?:fetch|axios|http\.|https\.|request\.|got\.|undici\.)/;
+const FS_PATTERN = /\b(?:readFileSync?|writeFileSync?|appendFileSync?|readdirSync?|mkdirSync?|statSync?|unlinkSync?|existsSync|accessSync?|copyFileSync?|renameSync?)\b/;
+const PROCESS_PATTERN = /\b(?:spawn|exec|execSync|spawnSync|child_process\.)\b/;
+function detectBoundaryCategory(tryText) {
+  if (DB_PATTERN.test(tryText))
+    return "db";
+  if (NETWORK_PATTERN.test(tryText))
+    return "network";
+  if (FS_PATTERN.test(tryText))
+    return "fs";
+  if (PROCESS_PATTERN.test(tryText))
+    return "process";
+  return "none";
+}
+function detectTryResolvesLocalValues(tryText) {
+  const hasAwait = /\bawait\b/.test(tryText);
+  const hasIO = DB_PATTERN.test(tryText) || NETWORK_PATTERN.test(tryText) || FS_PATTERN.test(tryText) || PROCESS_PATTERN.test(tryText);
+  return !hasAwait && !hasIO;
+}
+export const tryCatchFactProvider = {
+  id: "tryCatchFacts",
+  provides: ["file.tryCatchSummaries"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  async run(ctx, store) {
+    await extractFactsFromTree(ctx, store, { "file.tryCatchSummaries": [] }, (root) => {
+      const summaries = [];
+      walk(root, (node) => {
+        if (node.type !== "try_statement")
+          return;
+        const tryBlock = firstChildOfType(node, "statement_block");
+        const catchClause = firstChildOfType(node, "catch_clause");
+        if (!tryBlock || !catchClause)
+          return;
+        const tryText = tryBlock.text;
+        const tryResolvesLocalValues = detectTryResolvesLocalValues(tryText);
+        const boundaryCategory = detectBoundaryCategory(tryText);
+        const paramNode = firstChildOfType(catchClause, "identifier");
+        const catchParam = paramNode ? paramNode.text : null;
+        const catchBody = firstChildOfType(catchClause, "statement_block");
+        const bodyText = catchBody ? catchBody.text.replace(/^\{/, "").replace(/\}$/, "").trim() : "";
+        const isEmpty = isOnlyWhitespaceOrComments(bodyText);
+        const hasRethrow = /\bthrow\b/.test(bodyText);
+        const hasLogging = /\bconsole\.(log|warn|error)\b/.test(bodyText) || /\blogger\./.test(bodyText);
+        const catchReturnsDefault = DEFAULT_VALUE_PATTERN.test(bodyText);
+        const catchReturnsStructuredError = STRUCTURED_ERROR_PATTERN.test(bodyText);
+        const isDocumentedLocalFallback = EXPLAINING_COMMENT_PATTERN.test(bodyText);
+        const catchHasFallbackAssignment = hasAssignmentExpression(catchBody);
+        const catchLogsOnly = hasLogging && !hasRethrow && !catchReturnsDefault && !catchReturnsStructuredError && !/\b(?:set|update|notify|emit|dispatch|resolve|reject)\b/.test(bodyText);
+        const isFilesystemExistenceProbe = boundaryCategory === "fs" && FS_PROBE_PATTERN.test(tryText) && catchReturnsDefault;
+        summaries.push({
+          line: catchClause.startPosition.row + 1,
+          column: catchClause.startPosition.column + 1,
+          catchParam,
+          bodyText,
+          isEmpty,
+          hasRethrow,
+          hasLogging,
+          catchLogsOnly,
+          catchReturnsDefault,
+          catchReturnsStructuredError,
+          isDocumentedLocalFallback,
+          catchHasFallbackAssignment,
+          tryResolvesLocalValues,
+          isFilesystemExistenceProbe,
+          boundaryCategory
+        });
+      });
+      return { "file.tryCatchSummaries": summaries };
+    });
+  }
+};

package/extensions/dm-lens/dist/clients/dispatch/finding-policy.js

@@ -0,0 +1,159 @@
+import { applyDispositions, applyDispositionsMultiFile, hasAnyDispositionMarks } from "../diagnostic-dispositions.js";
+import { loadDmLensProjectConfig } from "../project-lens-config.js";
+import { retagAuxiliaryDiagnostics } from "./auxiliary-lsp.js";
+import { applyInlineSuppressions } from "./inline-suppressions.js";
+import { applyRulePolicy, rulePolicyMapFromConfig } from "./rule-policy.js";
+import { convertLspDiagnostics } from "./utils/lsp-diagnostics.js";
+export function applyFindingPolicy(diagnostics, options) {
+  const inlineKept = applyInlineSuppressions(diagnostics, options.content);
+  const disposed = filterDisposed(inlineKept, options);
+  return { kept: applyRulePolicy(disposed, options.policyMap), inlineKept };
+}
+export function loadProjectRulePolicyMap(cwd) {
+  return rulePolicyMapFromConfig(loadDmLensProjectConfig(cwd).rules);
+}
+function filterDisposed(diagnostics, options) {
+  const identities = options.identities;
+  if (!identities) {
+    return applyDispositions(diagnostics, options.cwd, options.filePath, options.content);
+  }
+  if (!diagnostics.length || !hasAnyDispositionMarks(options.cwd)) {
+    return diagnostics;
+  }
+  const expanded = diagnostics.flatMap((diagnostic) => identities(diagnostic).map((identity) => ({
+    diagnostic,
+    candidate: {
+      ...identity,
+      message: diagnostic.message,
+      ...diagnostic.line !== undefined && { line: diagnostic.line },
+      ...diagnostic.semantic !== undefined && {
+        semantic: diagnostic.semantic
+      }
+    }
+  })));
+  const survivors = new Set(applyDispositions(expanded.map((entry) => entry.candidate), options.cwd, options.filePath, options.content));
+  const disposed = new Set;
+  for (const entry of expanded) {
+    if (!survivors.has(entry.candidate))
+      disposed.add(entry.diagnostic);
+  }
+  return disposed.size === 0 ? diagnostics : diagnostics.filter((diagnostic) => !disposed.has(diagnostic));
+}
+function probeIdentities(canonical, raw) {
+  const rendered = [
+    [canonical.tool, canonical.rule]
+  ];
+  if (raw !== undefined && (raw.source !== undefined || raw.code !== undefined)) {
+    rendered.push([
+      raw.source,
+      raw.code === undefined ? undefined : String(raw.code)
+    ]);
+  }
+  return expandRenderedIdentities(rendered);
+}
+export function renderedRuleIdentities(diagnostic) {
+  return expandRenderedIdentities([[diagnostic.tool, diagnostic.rule]]);
+}
+export function inlineBlockerIdentities(diagnostic) {
+  return expandRenderedIdentities([
+    [diagnostic.tool, diagnostic.rule],
+    [undefined, undefined]
+  ]);
+}
+export function applyPushedFindingPolicy(findings, options) {
+  const { kept } = applyFindingPolicy(findings, {
+    cwd: options.cwd,
+    filePath: options.filePath,
+    content: options.content ?? "",
+    policyMap: loadProjectRulePolicyMap(options.cwd),
+    identities: renderedRuleIdentities
+  });
+  return { kept, suppressed: findings.length - kept.length };
+}
+function expandRenderedIdentities(rendered) {
+  const out = [];
+  const seen = new Set;
+  for (const [tool, rule] of rendered) {
+    for (const candidateTool of [tool, undefined]) {
+      const key = `${candidateTool ?? ""}\x00${rule ?? ""}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      out.push({
+        ...candidateTool !== undefined && { tool: candidateTool },
+        ...rule !== undefined && { rule }
+      });
+    }
+  }
+  return out;
+}
+export function applyLspFindingPolicy(diagnostics, options) {
+  if (!diagnostics.length)
+    return { kept: diagnostics, inlineKept: diagnostics };
+  const content = options.content ?? "";
+  const anchored = [];
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.range?.start?.line !== undefined)
+      anchored.push(diagnostic);
+  }
+  if (!anchored.length)
+    return { kept: diagnostics, inlineKept: diagnostics };
+  const converted = convertLspDiagnostics(anchored, options.filePath);
+  retagAuxiliaryDiagnostics(converted, anchored, content, {
+    cwd: options.cwd,
+    fileRole: options.fileRole
+  });
+  const rawByConverted = new Map;
+  for (const [index, diagnostic] of converted.entries()) {
+    const raw = anchored[index];
+    if (raw !== undefined)
+      rawByConverted.set(diagnostic, raw);
+  }
+  const { kept, inlineKept } = applyFindingPolicy(converted, {
+    cwd: options.cwd,
+    filePath: options.filePath,
+    content,
+    policyMap: options.policyMap,
+    identities: (diagnostic) => probeIdentities(diagnostic, rawByConverted.get(diagnostic))
+  });
+  const survivorsOf = (survivors) => {
+    if (survivors.length === converted.length)
+      return diagnostics;
+    const keptConverted = new Set(survivors);
+    const dropped = new Set;
+    for (const [diagnostic, raw] of rawByConverted) {
+      if (!keptConverted.has(diagnostic))
+        dropped.add(raw);
+    }
+    return diagnostics.filter((d) => !dropped.has(d));
+  };
+  return { kept: survivorsOf(kept), inlineKept: survivorsOf(inlineKept) };
+}
+export function filterFindingsByDisposition(findings, cwd, toDiagnostic) {
+  if (findings.length === 0)
+    return { kept: findings, suppressed: 0 };
+  const candidates = findings.flatMap((finding) => {
+    const diagnostic = toDiagnostic(finding);
+    return renderedRuleIdentities(diagnostic).map((identity) => ({
+      finding,
+      candidate: {
+        filePath: diagnostic.filePath,
+        message: diagnostic.message,
+        ...diagnostic.line !== undefined && { line: diagnostic.line },
+        ...diagnostic.semantic !== undefined && {
+          semantic: diagnostic.semantic
+        },
+        ...identity.tool !== undefined && { tool: identity.tool },
+        ...identity.rule !== undefined && { rule: identity.rule }
+      }
+    }));
+  });
+  const survivors = new Set(applyDispositionsMultiFile(candidates.map((c) => c.candidate), cwd, (d) => d.filePath));
+  const disposed = new Set;
+  for (const candidate of candidates) {
+    if (!survivors.has(candidate.candidate))
+      disposed.add(candidate.finding);
+  }
+  const kept = disposed.size === 0 ? findings : findings.filter((finding) => !disposed.has(finding));
+  return { kept, suppressed: findings.length - kept.length };
+}

package/extensions/dm-lens/dist/clients/dispatch/indent-detect.js

@@ -0,0 +1,227 @@
+const DEFAULT_INDENTATION = { style: "space", width: 2 };
+export function detectIndentation(content) {
+  const lines = structuralLines(content.split(/\r?\n/));
+  const tabs = lines.filter((line) => /^\t+\S/.test(line)).length;
+  const spaceCounts = lines.map((line) => line.match(/^ +(?=\S)/)?.[0].length ?? 0).filter((count) => count > 0);
+  if (tabs === 0 && spaceCounts.length === 0) {
+    return hasDetectableIndentation(content) ? undefined : DEFAULT_INDENTATION;
+  }
+  if (tabs > spaceCounts.length)
+    return { style: "tab", width: 1 };
+  if (spaceCounts.length > tabs) {
+    const minimum = Math.min(...spaceCounts);
+    const gcd = spaceCounts.reduce((unit, count) => greatestCommonDivisor(unit, count), 0);
+    const nonBlank = lines.map((line) => line.match(/^( *)\S/)?.[1]?.length).filter((count) => count !== undefined);
+    const hasStructuralBoundary = nonBlank.some((count, index) => {
+      const previous = nonBlank[index - 1];
+      return count === minimum && previous !== undefined && previous < minimum;
+    });
+    if (hasStructuralBoundary && minimum <= 8) {
+      return { style: "space", width: minimum };
+    }
+    if (gcd < minimum && gcd <= 8) {
+      return { style: "space", width: gcd };
+    }
+    return;
+  }
+  return DEFAULT_INDENTATION;
+}
+function opensBlockComment(line) {
+  const blockAt = line.indexOf("/*");
+  if (blockAt < 0)
+    return false;
+  const lineAt = line.indexOf("//");
+  if (lineAt >= 0 && lineAt < blockAt)
+    return false;
+  return line.indexOf("*/", blockAt + 2) < 0;
+}
+export function blockCommentInteriorMask(lines) {
+  const mask = Array.from({ length: lines.length }, () => false);
+  let pendingStart = -1;
+  for (const [i, line] of lines.entries()) {
+    if (pendingStart >= 0) {
+      mask[i] = true;
+      if (line.includes("*/"))
+        pendingStart = -1;
+      continue;
+    }
+    if (opensBlockComment(line))
+      pendingStart = i;
+  }
+  if (pendingStart >= 0) {
+    for (let i = pendingStart + 1;i < lines.length; i += 1)
+      mask[i] = false;
+  }
+  return mask;
+}
+function hasLiveFrame(stack) {
+  return stack.some((frame) => frame.kind !== "block");
+}
+function advanceTemplateState(line, stack) {
+  let j = 0;
+  while (j < line.length) {
+    const top = stack[stack.length - 1];
+    if (top?.kind === "template") {
+      if (line[j] === "\\") {
+        j += 2;
+        continue;
+      }
+      if (line.startsWith("${", j)) {
+        stack.push({ kind: "expr", braceDepth: 1 });
+        j += 2;
+        continue;
+      }
+      if (line[j] === "`") {
+        stack.pop();
+        j += 1;
+        continue;
+      }
+      j += 1;
+      continue;
+    }
+    if (top?.kind === "block") {
+      const closeAt = line.indexOf("*/", j);
+      if (closeAt < 0)
+        return;
+      stack.pop();
+      j = closeAt + 2;
+      continue;
+    }
+    if (line.startsWith("//", j))
+      return;
+    if (line.startsWith("/*", j)) {
+      stack.push({ kind: "block" });
+      j += 2;
+      continue;
+    }
+    if (line[j] === "/" && isRegexOpenerPosition(line, j)) {
+      const after = skipRegexLiteral(line, j);
+      if (after >= 0) {
+        j = after;
+        continue;
+      }
+    }
+    const ch = line[j];
+    if (ch === '"' || ch === "'") {
+      j = skipQuoted(line, j, ch);
+      continue;
+    }
+    if (ch === "`") {
+      stack.push({ kind: "template" });
+      j += 1;
+      continue;
+    }
+    if (top?.kind === "expr") {
+      if (ch === "{") {
+        top.braceDepth += 1;
+        j += 1;
+        continue;
+      }
+      if (ch === "}") {
+        top.braceDepth -= 1;
+        j += 1;
+        if (top.braceDepth === 0)
+          stack.pop();
+        continue;
+      }
+    }
+    j += 1;
+  }
+}
+function skipQuoted(line, start, quote) {
+  let j = start + 1;
+  while (j < line.length) {
+    if (line[j] === "\\") {
+      j += 2;
+      continue;
+    }
+    if (line[j] === quote)
+      return j + 1;
+    j += 1;
+  }
+  return line.length;
+}
+const REGEX_OPENER_PUNCTUATION = new Set([
+  "(",
+  ",",
+  "=",
+  ":",
+  "[",
+  "!",
+  "&",
+  "|",
+  "?"
+]);
+const REGEX_OPENER_KEYWORD = /(?:^|[^A-Za-z0-9_$])(?:return|typeof|case)$/;
+function isRegexOpenerPosition(line, at) {
+  const before = line.slice(0, at).replace(/[ \t]+$/, "");
+  if (before === "")
+    return true;
+  if (REGEX_OPENER_KEYWORD.test(before))
+    return true;
+  return REGEX_OPENER_PUNCTUATION.has(before.at(-1) ?? "");
+}
+const REGEX_FLAG_CHARS = "dgimsuvy";
+function skipRegexLiteral(line, start) {
+  let j = start + 1;
+  let inClass = false;
+  while (j < line.length) {
+    const c = line[j];
+    if (c === "\\") {
+      j += 2;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]")
+        inClass = false;
+      j += 1;
+      continue;
+    }
+    if (c === "[") {
+      inClass = true;
+      j += 1;
+      continue;
+    }
+    if (c === "/") {
+      let k = j + 1;
+      while (k < line.length && REGEX_FLAG_CHARS.includes(line[k] ?? ""))
+        k += 1;
+      if (k < line.length && /[A-Za-z0-9_$]/.test(line[k] ?? ""))
+        return -1;
+      return j + 1;
+    }
+    j += 1;
+  }
+  return -1;
+}
+export function templateLiteralInteriorMask(lines) {
+  const mask = Array.from({ length: lines.length }, () => false);
+  const stack = [];
+  let openLine = -1;
+  for (const [i, line] of lines.entries()) {
+    if (hasLiveFrame(stack)) {
+      mask[i] = true;
+    } else {
+      openLine = i;
+    }
+    advanceTemplateState(line, stack);
+  }
+  if (hasLiveFrame(stack)) {
+    for (let i = openLine + 1;i < lines.length; i += 1)
+      mask[i] = false;
+  }
+  return mask;
+}
+function structuralLines(lines) {
+  const blockCommentMask = blockCommentInteriorMask(lines);
+  const templateMask = templateLiteralInteriorMask(lines);
+  return lines.filter((_, index) => !blockCommentMask[index] && !templateMask[index]);
+}
+function greatestCommonDivisor(left, right) {
+  while (right !== 0)
+    [left, right] = [right, left % right];
+  return left;
+}
+export function hasDetectableIndentation(content) {
+  return /^(?:\t+| {1,})\S/m.test(content);
+}