@d3lm/lint-preset 1.4.6 → 1.5.1

package/dist/comments.js

@@ -0,0 +1,1460 @@
+// src/comments/analyze.ts
+import { parseSync } from "oxc-parser";
+
+// src/comments/style.ts
+var BANNER = /^(?!#{1,6}\s)([-=*#_~+/\\])\1{3,}|([-=*#_~])\2{3,}\s*$/;
+var COLUMN_RULE = /^([-=_~])\1*(?:\s+\1+)+$/;
+var DASH = /(?<!\d)\s[–-]\s(?!\d)|(?<!(?:^|\s)-[\w-]*)\s--\s(?!-)/;
+var SEMICOLON = /;(?:\s|$)/;
+var EMPHASIS = /(?:^|[\s(])(\*\*?)(?=[\p{L}\p{N}])[^*]+?(?<!\s)\1(?=$|[\s)"']|[.,;:!?](?:$|[\s)"']))/u;
+var LIST_MARKER = /^(?:[-*+]|\d+[.)])\s+/;
+var CODE_SPAN = /(?<!`)(`+)(?!`)[\s\S]*?(?<!`)\1(?!`)/g;
+var COLON = /(?<=[\w)\]'"’])(?<!(?:^|[.!?]\s+)(?:[A-Z]{2,}|[Tt]odo|[Ff]ixme|[Hh]ack|[Xx]xx))(?<!\b(?:code|url|entity|[A-Za-z][a-z\d]*[A-Z]\w*|\w*_\w*)):\s+\S/;
+function replaceKeepingLines(text, pattern, replacement) {
+  return text.replaceAll(pattern, (match) => `${replacement}${"\n".repeat(match.split("\n").length - 1)}`);
+}
+function stripNonProse(text) {
+  let stripped = replaceKeepingLines(text, CODE_SPAN, "code");
+  for (let previous = ""; previous !== stripped; ) {
+    previous = stripped;
+    stripped = replaceKeepingLines(stripped, /\{[^{}]*\}/g, "code");
+  }
+  return stripped.replaceAll(/\b[a-z][\w+.-]*:\/\/\S+/gi, "url").replaceAll(/&(?:[a-z][a-z\d]*|#\d+|#x[\da-f]+);/gi, "entity");
+}
+function hasExplanatoryColon(text) {
+  return COLON.test(text.replace(LIST_MARKER, ""));
+}
+function isBanner(text) {
+  const prose = stripNonProse(text.trim());
+  return BANNER.test(prose) && !COLUMN_RULE.test(prose);
+}
+function findStyleIssues(lines) {
+  const issues = [];
+  const prose = stripNonProse(lines.map((line) => line.text.trim()).join("\n"));
+  const proseLines = replaceKeepingLines(prose, /^@\w+\s+(?:code\s+)?(?:\S+\s+-\s+)?/gm, "").split("\n");
+  for (const [position, line] of lines.entries()) {
+    const text = proseLines[position].trim();
+    const report = (type) => {
+      issues.push({ type, index: line.index });
+    };
+    if (isBanner(line.text)) {
+      report("banner");
+    } else {
+      if (SEMICOLON.test(text)) {
+        report("semicolon");
+      }
+      if (text.includes("\u2014")) {
+        report("em-dash");
+      }
+      if (DASH.test(text)) {
+        report("dash");
+      }
+      if (hasExplanatoryColon(text)) {
+        report("label-colon");
+      }
+      if (EMPHASIS.test(text)) {
+        report("emphasis");
+      }
+    }
+  }
+  return issues;
+}
+
+// src/comments/wrap.ts
+var CLAUSE_END = /[.!?,;:]["')\]*_]*$/;
+var SENTENCE_END = /[.!?]["')\]*_]*$/;
+var ABBREVIATIONS = /* @__PURE__ */ new Set([
+  "e.g.",
+  "i.e.",
+  "etc.",
+  "vs.",
+  "cf.",
+  "approx.",
+  "incl.",
+  "resp.",
+  "al.",
+  "viz.",
+  "esp.",
+  "ca.",
+  "fig.",
+  "figs.",
+  "eq.",
+  "vol.",
+  "pp.",
+  "mr.",
+  "mrs.",
+  "ms.",
+  "dr.",
+  "prof.",
+  "st."
+]);
+function isAbbreviation(word) {
+  const bare = word.replace(/^[(["']+/, "").replace(/[)\]"']+$/, "").toLowerCase();
+  return ABBREVIATIONS.has(bare) || /^(?:[a-z]\.){2,}$/.test(bare);
+}
+function findClosingBrace(text, start) {
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    if (text[index] === "{") {
+      depth += 1;
+    } else if (text[index] === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+  return -1;
+}
+function backtickRun(text, start) {
+  let end = start;
+  while (text[end] === "`") {
+    end += 1;
+  }
+  return end - start;
+}
+function findCodeSpanEnd(text, start) {
+  const run = backtickRun(text, start);
+  for (let index = text.indexOf("`", start + run); index !== -1; ) {
+    const length = backtickRun(text, index);
+    if (length === run) {
+      return index + length - 1;
+    }
+    index = text.indexOf("`", index + length);
+  }
+  return -1;
+}
+function tokenize(text) {
+  const tokens = [];
+  let current = "";
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    const close = char === "`" ? findCodeSpanEnd(text, index) : char === "{" ? findClosingBrace(text, index) : -1;
+    if (char === "`" && close === -1) {
+      const run = backtickRun(text, index);
+      current += text.slice(index, index + run);
+      index += run;
+      continue;
+    }
+    if (close !== -1) {
+      current += text.slice(index, close + 1);
+      index = close + 1;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      index += 1;
+      continue;
+    }
+    current += char;
+    index += 1;
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function parentheticalEnd(text) {
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 1;
+      continue;
+    }
+    const close = char === "`" ? findCodeSpanEnd(text, index) : char === "{" ? findClosingBrace(text, index) : -1;
+    if (close !== -1) {
+      index = close;
+    } else if (char === "(") {
+      depth += 1;
+    } else if (char === ")" && --depth === 0) {
+      return index;
+    }
+  }
+  return -1;
+}
+function isParenthetical(token) {
+  return token.startsWith("(") && parentheticalEnd(token) !== -1;
+}
+function parentheticalGroups(tokens, limit) {
+  const groups = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    if (tokens[index].startsWith("(")) {
+      const end = parentheticalEnd(tokens.slice(index).join(" "));
+      let last = index;
+      let length = tokens[index].length;
+      while (length <= end && last + 1 < tokens.length) {
+        length += 1 + tokens[++last].length;
+      }
+      if (end !== -1 && length <= limit) {
+        groups.push({ start: index, end: last + 1 });
+        index = last;
+        continue;
+      }
+    }
+  }
+  return groups;
+}
+function bindParentheticals(tokens, limit) {
+  const groups = new Map(parentheticalGroups(tokens, limit).map((group) => [group.start, group.end]));
+  const units = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const end = groups.get(index) ?? index + 1;
+    units.push(tokens.slice(index, end).join(" "));
+    index = end - 1;
+  }
+  return units;
+}
+function endsClause(token) {
+  return CLAUSE_END.test(token) && !isAbbreviation(token);
+}
+function endsSentence(token) {
+  return SENTENCE_END.test(token) && !isAbbreviation(token);
+}
+function opensAside(token) {
+  return /^[([]/.test(token) && !/[)\]]["'`.,;:!?]*$/.test(token);
+}
+function isOrphan(previous, token) {
+  return opensAside(token) || endsClause(previous) && !CLAUSE_END.test(token);
+}
+function startsBlock(token) {
+  return /^(?:[-*+>]|\d+[.)]|#{1,6})$/.test(token) || /^(?:@[A-Za-z]|`{3}|~{3}|\||<\/?[A-Za-z])/.test(token);
+}
+function bindLineStarts(tokens, startsLine2 = startsBlock) {
+  const units = [];
+  for (const [index, token] of tokens.entries()) {
+    if (units.length > 0 && startsLine2(token, tokens[index + 1])) {
+      units[units.length - 1] += ` ${token}`;
+    } else {
+      units.push(token);
+    }
+  }
+  return units;
+}
+function breaksBefore(previous, last, next, options) {
+  return options.avoidSentenceOrphans && isOrphan(previous, last) || startsBlock(next);
+}
+function lineLength(tokens) {
+  let length = 0;
+  for (const token of tokens) {
+    length += token.length;
+  }
+  return length + Math.max(0, tokens.length - 1);
+}
+function wrapTokens(tokens, firstLimit, restLimit, options) {
+  return wrapFrom(tokens, 0, firstLimit, restLimit, options, Infinity);
+}
+function wrapFrom(tokens, from, firstLimit, restLimit, options, maxLines) {
+  const lines = [];
+  let line = [];
+  let length = 0;
+  for (let index = from; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    while (line.length > 0) {
+      const limit = lines.length === 0 ? firstLimit : restLimit;
+      const nextLength = length + 1 + token.length;
+      const extra = isParenthetical(token) ? options.parentheticalOverflow ?? 0 : 0;
+      if (nextLength <= limit + extra) {
+        break;
+      }
+      const carry = [];
+      while (line.length >= 2 && breaksBefore(line.at(-2) ?? "", line.at(-1) ?? "", carry[0] ?? token, options)) {
+        carry.unshift(line.pop() ?? "");
+      }
+      lines.push(line);
+      if (lines.length >= maxLines) {
+        return lines;
+      }
+      line = carry;
+      length = lineLength(carry);
+    }
+    line.push(token);
+    length = lineLength(line);
+  }
+  if (line.length > 0) {
+    lines.push(line);
+  }
+  return lines;
+}
+var MIN_LAST_LINE_WORDS = 3;
+function hasWidow(lines) {
+  const last = lines.at(-1) ?? [];
+  const words = last.reduce((count, token) => count + (isParenthetical(token) ? tokenize(token).length : 1), 0);
+  return lines.length >= 2 && words < MIN_LAST_LINE_WORDS;
+}
+var FULLNESS_WEIGHT = 0.07;
+var PARENTHETICAL_SPLIT_WEIGHT = 2;
+var MAX_STEP = 15;
+var EXTRA_LINES = 2;
+function fewestLines(starts, target) {
+  const total = starts.length - 1;
+  const fewest = new Int32Array(total + 1);
+  let end = total;
+  for (let index = total - 1; index >= 0; index -= 1) {
+    while (starts[end] - starts[index] - 1 > target) {
+      end -= 1;
+    }
+    fewest[index] = fewest[end] + 1;
+  }
+  return fewest;
+}
+function firstAtMost(values, limit, from) {
+  let low = from;
+  let high = values.length - 1;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (values[middle] <= limit) {
+      high = middle;
+    } else {
+      low = middle + 1;
+    }
+  }
+  return low;
+}
+function costsOfLine(input, target, line, previous, fewest) {
+  const { starts, afterOrphan } = input;
+  const offset = line === 1 ? input.offset : 0;
+  const linesLeft = input.count - line;
+  const last = starts.length - 1 - linesLeft;
+  const base = firstAtMost(fewest, linesLeft, Math.max(line, previous.low + 1));
+  const costs = [];
+  const origins = [];
+  let low = -1;
+  let high = -1;
+  for (let end = base; end <= last; end += 1) {
+    const nearest = Math.min(end - 1, previous.high);
+    if (end > previous.high && starts[end] - starts[nearest] - 1 + offset > target) {
+      break;
+    }
+    let cost = Infinity;
+    let origin = -1;
+    if (!input.blockStarts[end]) {
+      const splitCost = input.splitCosts.get(end) ?? 0;
+      for (let start = nearest; start >= previous.low; start -= 1) {
+        const length = starts[end] - starts[start] - 1 + offset;
+        if (length > target) {
+          break;
+        }
+        const before = previous.costs[start - previous.base];
+        if (before === Infinity || afterOrphan[end] && end - start >= 2) {
+          continue;
+        }
+        const candidate = before + (target - length) ** 2 + splitCost;
+        if (candidate <= cost) {
+          cost = candidate;
+          origin = start;
+        }
+      }
+    }
+    costs.push(cost);
+    origins.push(origin);
+    if (cost !== Infinity) {
+      low = low === -1 ? end : low;
+      high = end;
+    }
+  }
+  return low === -1 ? void 0 : { base, costs, origins, low, high };
+}
+function balanceTokens(tokens, firstLimit, restLimit, count, options, preferredLimit = restLimit, splitCosts = /* @__PURE__ */ new Map()) {
+  const total = tokens.length;
+  const starts = [0];
+  let longest = -Infinity;
+  for (const token of tokens) {
+    starts.push((starts.at(-1) ?? 0) + token.length + 1);
+    longest = Math.max(longest, token.length);
+  }
+  const input = {
+    starts,
+    count,
+    offset: restLimit - firstLimit,
+    blockStarts: tokens.map((token) => startsBlock(token)),
+    afterOrphan: tokens.map((_, index) => {
+      return options.avoidSentenceOrphans && index >= 2 && isOrphan(tokens[index - 2], tokens[index - 1]);
+    }),
+    splitCosts
+  };
+  const targets = [];
+  for (let target = restLimit; target >= Math.max(longest, Math.floor(restLimit / 2)); target -= 1) {
+    targets.push(target);
+  }
+  const most = starts[total] - count + input.offset;
+  let best;
+  for (const target of targets.toReversed()) {
+    const fullness = FULLNESS_WEIGHT * (count - 1) * (preferredLimit - target) ** 2;
+    const spare = (count - 1) * target - most;
+    const least = count > 1 && spare > 0 ? Math.max(spare ** 2 / (count - 1) - 1, 0) : 0;
+    if (best !== void 0 && least + fullness > best.cost) {
+      continue;
+    }
+    const fewest = fewestLines(starts, target);
+    const rows = [{ base: 0, costs: [0], origins: [-1], low: 0, high: 0 }];
+    for (let line = 1; line < count; line += 1) {
+      const row2 = costsOfLine(input, target, line, rows[line - 1], fewest);
+      if (!row2) {
+        break;
+      }
+      rows.push(row2);
+    }
+    if (rows.length < count) {
+      continue;
+    }
+    const row = rows[count - 1];
+    for (let start = row.low; start <= row.high; start += 1) {
+      const score = row.costs[start - row.base] + fullness;
+      const improves = score < (best?.cost ?? Infinity) || score === best?.cost && target > best.target;
+      if (!improves || starts[total] - starts[start] - 1 > target || hasWidow([[], tokens.slice(start)])) {
+        continue;
+      }
+      const breaks = [start];
+      for (let line = count - 1; line > 1; line -= 1) {
+        breaks.unshift(rows[line].origins[breaks[0] - rows[line].base]);
+      }
+      best = { cost: score, target, breaks };
+    }
+  }
+  if (!best) {
+    return void 0;
+  }
+  const bounds = [0, ...best.breaks, total];
+  return bounds.slice(0, -1).map((start, index) => tokens.slice(start, bounds[index + 1]));
+}
+function hasStep(lines, offset = 0) {
+  return lines.some((line, index) => {
+    if (index === 0) {
+      return false;
+    }
+    const before = lineLength(lines[index - 1]) + (index === 1 ? offset : 0);
+    return lineLength(line) - before > MAX_STEP;
+  });
+}
+function splitCostsOf(tokens, limit) {
+  const splitCosts = /* @__PURE__ */ new Map();
+  for (const group of parentheticalGroups(tokens, limit)) {
+    const length = lineLength(tokens.slice(group.start, group.end));
+    for (let at = group.start + 1; at < group.end; at += 1) {
+      splitCosts.set(at, length * PARENTHETICAL_SPLIT_WEIGHT);
+    }
+  }
+  return splitCosts;
+}
+function hasParentheticals(tokens, restLimit, options) {
+  if (options.parentheticalOverflow === void 0) {
+    return false;
+  }
+  return bindParentheticals(tokens, restLimit + options.parentheticalOverflow).some((token) => isParenthetical(token));
+}
+function layoutTokens(tokens, firstLimit, restLimit, options) {
+  const lines = layoutLines(tokens, firstLimit, restLimit, options);
+  const offset = restLimit - firstLimit;
+  if (options.keepFirstLine || options.keepSteps || !hasStep(lines, offset)) {
+    return lines;
+  }
+  const overflow = hasParentheticals(tokens, restLimit, options) ? options.parentheticalOverflow ?? 0 : 0;
+  const splitCosts = overflow > 0 ? splitCostsOf(tokens, restLimit + overflow) : /* @__PURE__ */ new Map();
+  for (let count = lines.length + 1; count <= lines.length + EXTRA_LINES; count += 1) {
+    const even = balanceTokens(
+      tokens,
+      firstLimit + overflow,
+      restLimit + overflow,
+      count,
+      options,
+      restLimit,
+      splitCosts
+    );
+    if (even && !hasStep(even, offset)) {
+      return even;
+    }
+  }
+  return lines;
+}
+function layoutLines(tokens, firstLimit, restLimit, options) {
+  if (options.parentheticalOverflow !== void 0) {
+    const grouped = bindParentheticals(tokens, restLimit + options.parentheticalOverflow);
+    if (grouped.some((token) => isParenthetical(token))) {
+      const minimumLines = Math.max(
+        2,
+        Math.ceil((lineLength(tokens) + 1 + restLimit - firstLimit) / Math.max(1, restLimit + 1))
+      );
+      let preserved = wrapTokens(grouped, firstLimit, restLimit, options);
+      if (minimumLines === 2 && preserved.length > 2) {
+        const wide = wrapTokens(
+          grouped,
+          firstLimit + options.parentheticalOverflow,
+          restLimit + options.parentheticalOverflow,
+          { ...options, parentheticalOverflow: void 0 }
+        );
+        if (wide.length === 2 && !hasWidow(wide)) {
+          preserved = wide;
+        }
+      }
+      if (preserved.length <= 2 && !hasWidow(preserved)) {
+        let cursor = 0;
+        return preserved.map((line) => {
+          const expanded = [];
+          const length = lineLength(line);
+          let used = -1;
+          while (cursor < tokens.length && used < length) {
+            const token = tokens[cursor++];
+            expanded.push(token);
+            used += token.length + 1;
+          }
+          return expanded;
+        });
+      }
+      const splitCosts = splitCostsOf(tokens, restLimit + options.parentheticalOverflow);
+      const preferred = wrapTokens(tokens, firstLimit, restLimit, { ...options, parentheticalOverflow: void 0 });
+      for (let count = minimumLines; count <= Math.max(preferred.length + 1, preserved.length); count += 1) {
+        const balanced2 = balanceTokens(
+          tokens,
+          firstLimit + options.parentheticalOverflow,
+          restLimit + options.parentheticalOverflow,
+          count,
+          options,
+          restLimit,
+          splitCosts
+        );
+        if (balanced2) {
+          return balanced2;
+        }
+      }
+    }
+  }
+  const greedy = wrapTokens(tokens, firstLimit, restLimit, options);
+  if (greedy.length < 2) {
+    return greedy;
+  }
+  if (options.keepFirstLine) {
+    const [head] = greedy;
+    const rest = layoutTokens(tokens.slice(head.length), restLimit, restLimit, { ...options, keepFirstLine: false });
+    const lines = [head, ...rest];
+    if (!hasWidow(lines)) {
+      return lines;
+    }
+  }
+  const balanced = balanceTokens(tokens, firstLimit, restLimit, greedy.length, options);
+  if (balanced) {
+    return balanced;
+  }
+  const stretched = wrapTokens(tokens, firstLimit + options.tolerance, restLimit + options.tolerance, options);
+  return hasWidow(stretched) ? greedy : stretched;
+}
+function breakAfterSentence(lines, firstLimit, restLimit, options) {
+  if (lines.length !== 2 || !options.avoidSentenceOrphans) {
+    return lines;
+  }
+  const tokens = lines.flat();
+  const offset = restLimit - firstLimit;
+  for (let end = tokens.length - 1; end > 0; end -= 1) {
+    const first = tokens.slice(0, end);
+    const second = tokens.slice(end);
+    if (endsSentence(tokens[end - 1]) && !hasWidow([first, second]) && !breaksBefore(tokens[end - 2] ?? "", tokens[end - 1], tokens[end], options) && lineLength(first) <= firstLimit && lineLength(second) <= lineLength(first) + offset) {
+      return [first, second];
+    }
+  }
+  return lines;
+}
+function findLineIssues(lines, firstLimit, restLimit, options) {
+  const issues = [];
+  const tokens = lines.flat();
+  let next = 0;
+  for (const [index, line] of lines.entries()) {
+    const limit = index === 0 ? firstLimit : restLimit;
+    const length = lineLength(line);
+    const start = next;
+    next += line.length;
+    if (line.length > 1 && length > limit + options.tolerance) {
+      issues.push({ type: "overflow", line: index });
+    }
+    if (index === lines.length - 1 || line.length === 0) {
+      continue;
+    }
+    if (options.avoidSentenceOrphans && line.length >= 2 && isOrphan(line.at(-2) ?? "", line.at(-1) ?? "")) {
+      issues.push({ type: "orphan", line: index });
+    }
+    const [expected] = wrapFrom(tokens, start, limit, restLimit, options, 1);
+    if (expected.length > line.length) {
+      issues.push({ type: "underfill", line: index });
+    }
+  }
+  return issues;
+}
+
+// src/comments/analyze.ts
+var ISSUE_TIERS = {
+  overflow: "verdict",
+  underfill: "verdict",
+  widow: "verdict",
+  unbalanced: "verdict",
+  orphan: "hint",
+  banner: "hint",
+  "em-dash": "hint",
+  semicolon: "hint",
+  "label-colon": "hint",
+  emphasis: "hint",
+  dash: "hint"
+};
+var IGNORE_DIRECTIVE = "comments-ignore";
+var FENCE = /^(?:`{3,}(?!.*`)|~{3,})/;
+var JSDOC_TAG = /^@([A-Za-z]+)/;
+var NESTED_LIST_MARKER = /^\s+(?:[-*+]|\d+[.)])\s+/;
+var PROSE_TAGS = /* @__PURE__ */ new Set([
+  "arg",
+  "argument",
+  "deprecated",
+  "description",
+  "exception",
+  "note",
+  "param",
+  "prop",
+  "property",
+  "remarks",
+  "return",
+  "returns",
+  "see",
+  "since",
+  "summary",
+  "template",
+  "throws",
+  "todo",
+  "typeParam",
+  "yields"
+]);
+var CODE_TAGS = /* @__PURE__ */ new Set(["default", "defaultValue", "example"]);
+var NAMED_TAGS = /* @__PURE__ */ new Set(["arg", "argument", "param", "prop", "property", "template", "typeParam"]);
+var LINE_DIRECTIVE = /^\s*(?:(?:eslint|oxlint|stylelint)-(?:disable(?:-next-line|-line)?|enable)\b|eslint-env\b|@ts-(?:ignore|expect-error|nocheck|check)\b|@jsx\w*\b|@vite-ignore\b|[@#]__[A-Z_]+__|@(?:vitest|jest)-environment\b|(?:istanbul|c8|v8)\s+ignore\b|prettier-ignore\b|biome-ignore\b|deno-(?:lint-ignore|fmt-ignore)(?:-file)?\b|tslint:|(?:c[sS]pell|spell-?checker)\s*:|(?:webpack|turbopack)[A-Z][a-zA-Z]*\s*:|vim?:\s|#(?:region|endregion)\b|<reference\s)/;
+var BLOCK_DIRECTIVE = /^\s*(?:eslint\s|globals?\s|exported\s|jshint\s|jslint\s|type\s*:)/;
+var LEGAL_COMMENT = /^!|@license\b|@preserve\b|\bcopyright\s+(?:\(c\)|©|\d{4})/i;
+var DEFINITION = /^(?:``|[\w$.[\]]+(?:[ -][\w$.[\]]+)?)(?: [-–]|:) \S/;
+var BOX_DRAWING = /[\u2500-\u257F]/;
+var TABLE_DELIMITER = /^\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)+\|?$/;
+var ARROWS_OR_RULES = /[▲▼◀▶→←↑↓]|-->|<--|\+-{2,}|-{3,}|={4,}/;
+var HARD_BREAK = /\S {2,}$|(?<!\\)\\(?:\\\\)*$/;
+function isProseLike(statement, source) {
+  if (statement.type === "LabeledStatement") {
+    return source[statement.end - 1] !== ";";
+  }
+  if (statement.type === "EmptyStatement") {
+    return true;
+  }
+  if (statement.type !== "ExpressionStatement") {
+    return false;
+  }
+  let { expression } = statement;
+  while (expression.type === "ParenthesizedExpression") {
+    expression = expression.expression;
+  }
+  if (expression.type === "TaggedTemplateExpression") {
+    return expression.tag.type === "Identifier";
+  }
+  return expression.type === "Identifier" || expression.type === "Literal" || expression.type === "TemplateLiteral";
+}
+function parsesAsStatements(text) {
+  if (!/[()[\]{}=;<>]/.test(text)) {
+    return false;
+  }
+  const source = `async function* comment() {
+${text}
+}`;
+  const { program, errors } = parseSync("comment.tsx", source);
+  const wrapper = program.body.at(0);
+  if (errors.length > 0 || wrapper?.type !== "FunctionDeclaration" || !wrapper.body) {
+    return false;
+  }
+  const statements = wrapper.body.body;
+  return statements.length > 0 && !statements.every((statement) => isProseLike(statement, source));
+}
+var CODE_VALUES = /* @__PURE__ */ new Set([
+  "Literal",
+  "ArrayExpression",
+  "ObjectExpression",
+  "CallExpression",
+  "NewExpression",
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "UnaryExpression",
+  "MemberExpression"
+]);
+function parsesAsProperties(text) {
+  if (!text.includes(":")) {
+    return false;
+  }
+  const { program, errors } = parseSync("comment.ts", `({
+${text}
+})`);
+  const statement = program.body.at(0);
+  if (errors.length > 0 || program.body.length !== 1 || statement?.type !== "ExpressionStatement") {
+    return false;
+  }
+  let { expression } = statement;
+  while (expression.type === "ParenthesizedExpression") {
+    expression = expression.expression;
+  }
+  if (expression.type !== "ObjectExpression" || expression.properties.length === 0) {
+    return false;
+  }
+  const { properties } = expression;
+  if (!properties.every((property) => property.type === "Property" && !property.shorthand && !property.method)) {
+    return false;
+  }
+  return properties.length > 1 || text.trimEnd().endsWith(",") || properties.some((property) => property.type === "Property" && CODE_VALUES.has(property.value.type));
+}
+function isCode(texts) {
+  const text = texts.map((line) => line.replace(LIST_MARKER, "")).join("\n");
+  return parsesAsStatements(text) || parsesAsProperties(text);
+}
+function isCodeLine(text) {
+  return text.endsWith("{") || text.endsWith(";") && (/[()[\]{}=<>]/.test(text) || !/\s/.test(text)) || /^[}\])]/.test(text) || /^(?:const|let|var)\s+[\w$]+\s*[:=]/.test(text) || /^(?:import|export)\s.*(?:\sfrom\s|[{}])/.test(text);
+}
+function layoutReason(prose, raw) {
+  if (prose.startsWith("|") || TABLE_DELIMITER.test(prose)) {
+    return "table row";
+  }
+  if (BOX_DRAWING.test(prose)) {
+    return "box drawing";
+  }
+  if (isBanner(raw)) {
+    return "repeated characters";
+  }
+  return void 0;
+}
+function isMarkup(prose) {
+  return /^#{1,6}\s/.test(prose) || /^\[[^\]]+\]:/.test(prose) || /^<\/?[a-z]/i.test(prose) || /^>(?:\s|$)/.test(prose);
+}
+function mask(text) {
+  return text.replaceAll(/[^\n]/g, "x");
+}
+function maskCode(text) {
+  let masked = text.replaceAll(CODE_SPAN, mask);
+  for (let previous = ""; previous !== masked; ) {
+    previous = masked;
+    masked = masked.replaceAll(/\{[^{}]*\}/g, mask);
+  }
+  return masked;
+}
+function hasAlignedColumns(lines) {
+  const masked = maskCode(lines.map((body) => body.text).join("\n")).split("\n");
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of masked) {
+    const columns = new Set([...line.matchAll(/[^\s.!?][^\S\n]{2,}(?=\S)/g)].map((gap) => gap.index + gap[0].length));
+    if ([...columns].some((column) => seen.has(column))) {
+      return true;
+    }
+    for (const column of columns) {
+      seen.add(column);
+    }
+  }
+  return false;
+}
+function structureOf(lines) {
+  const trimmed = lines.map((line) => line.text.trim()).join("\n");
+  const texts = replaceKeepingLines(trimmed, CODE_SPAN, "``").split("\n");
+  const proseLines = stripNonProse(trimmed).split("\n");
+  if (isCode(lines.map((line) => line.text.trim()))) {
+    return { tier: "code", reason: "code" };
+  }
+  let layout;
+  let codeLike = false;
+  let manual = lines.slice(0, -1).some((line) => line.hardBreak) ? "hard line break" : void 0;
+  for (const [position, line] of texts.entries()) {
+    const prose = proseLines[position].trim();
+    layout ??= layoutReason(prose, lines[position]?.text ?? "");
+    if (isCodeLine(line.trim())) {
+      codeLike = true;
+    } else if (isMarkup(prose)) {
+      manual ??= "markup";
+    } else if ((prose.match(/\|/g)?.length ?? 0) >= 2) {
+      manual ??= "pipes";
+    } else if (ARROWS_OR_RULES.test(prose)) {
+      manual ??= "arrows or rules";
+    }
+  }
+  layout ??= hasAlignedColumns(lines) ? "aligned columns" : void 0;
+  if (layout) {
+    return { tier: "layout", reason: layout };
+  }
+  if (codeLike) {
+    return { tier: "code-like", reason: "code-like line" };
+  }
+  if (texts.filter((text) => DEFINITION.test(text.trim())).length >= 2) {
+    manual ??= "definition-like lines";
+  }
+  return manual ? { tier: "manual", reason: manual } : void 0;
+}
+var FenceTracker = class {
+  _open;
+  isInside() {
+    return this._open !== void 0;
+  }
+  next(text) {
+    const trimmed = text.trim();
+    if (this._open === void 0) {
+      this._open = FENCE.exec(trimmed)?.[0];
+      return this._open !== void 0;
+    }
+    if (trimmed.startsWith(this._open) && new RegExp(`^\\${this._open[0]}+$`).test(trimmed)) {
+      this._open = void 0;
+    }
+    return true;
+  }
+};
+function segment(lines) {
+  const paragraphs = [];
+  const fence = new FenceTracker();
+  let current;
+  let inCodeTag = false;
+  const flush = () => {
+    if (current) {
+      while (current.lines.length > 1 && !current.lines.at(-1)?.text.trim()) {
+        current.lines.pop();
+      }
+      paragraphs.push(current);
+      current = void 0;
+    }
+  };
+  const start = (kind, line, marker = "", reason) => {
+    flush();
+    current = { kind, lines: [line], marker, reason };
+  };
+  for (const line of lines) {
+    const { text } = line;
+    if (inCodeTag) {
+      if (fence.isInside() || !JSDOC_TAG.test(text)) {
+        fence.next(text);
+        current?.lines.push(line);
+        continue;
+      }
+      inCodeTag = false;
+    }
+    if (fence.isInside()) {
+      current?.lines.push(line);
+      fence.next(text);
+      if (!fence.isInside()) {
+        flush();
+      }
+      continue;
+    }
+    if (line.verbatim) {
+      start("code", line, "", "directive");
+      flush();
+      continue;
+    }
+    if (!text.trim()) {
+      flush();
+      continue;
+    }
+    if (fence.next(text)) {
+      start("code", line, "", "code block");
+      continue;
+    }
+    if (/^\s/.test(text)) {
+      const holdsProse = current?.kind === "list" || current?.kind === "tag" && !current.reason;
+      const nested = holdsProse ? NESTED_LIST_MARKER.exec(text) : null;
+      if (nested) {
+        start("list", line, nested[0]);
+      } else if (current && (current.kind === "list" || current.kind === "tag" || current.reason === "indented")) {
+        current.lines.push(line);
+      } else {
+        start("code", line, "", "indented");
+      }
+      continue;
+    }
+    const tag = JSDOC_TAG.exec(text);
+    if (tag) {
+      start("tag", line, "", PROSE_TAGS.has(tag[1]) ? void 0 : `@${tag[1]} tag`);
+      inCodeTag = CODE_TAGS.has(tag[1]);
+      continue;
+    }
+    const marker = LIST_MARKER.exec(text);
+    if (marker) {
+      start("list", line, marker[0]);
+      continue;
+    }
+    if (current && (current.kind === "prose" || current.kind === "tag" || current.kind === "list")) {
+      current.lines.push(line);
+      continue;
+    }
+    start("prose", line);
+  }
+  flush();
+  return paragraphs;
+}
+function startsLine(token, next) {
+  return startsBlock(token) || LINE_DIRECTIVE.test(next === void 0 ? token : `${token} ${next}`);
+}
+function visualLength(text, tabWidth) {
+  return text.replaceAll("	", " ".repeat(tabWidth)).length;
+}
+function sourceLineLength(line, tabWidth) {
+  return visualLength(`${line.prefix}${line.text.trimEnd()}`, tabWidth);
+}
+function overflowIssues(lines, options) {
+  const issues = [];
+  const limit = options.maxWidth ?? options.width + options.tolerance;
+  for (const line of lines) {
+    const length = sourceLineLength(line, options.tabWidth);
+    if (length <= limit) {
+      continue;
+    }
+    if (options.maxWidth !== void 0) {
+      issues.push(lineIssue("overflow", line, options));
+      continue;
+    }
+    const prefixLength = visualLength(`${line.prefix}${/^\s*/.exec(line.text)?.[0] ?? ""}`, options.tabWidth);
+    const tokens = bindLineStarts(tokenize(line.text), startsLine);
+    if (tokens.length > 1 && tokens.every((token) => prefixLength + token.length <= limit)) {
+      issues.push(lineIssue("overflow", line, options));
+    }
+  }
+  return issues;
+}
+function lineIssue(type, line, options) {
+  return { type, tier: ISSUE_TIERS[type], line: line.index + 1, length: sourceLineLength(line, options.tabWidth) };
+}
+function stripBlockSyntax(text) {
+  return text.replace(/^\s*\/\*+/, "").replace(/\*+\/\s*$/, "").replace(/^\s*\*(?=\s|$)/, "");
+}
+function bannerIssues(paragraph, options) {
+  const verbatim = ["code block", "indented", "legal comment"];
+  if (!options.style || paragraph.reason !== void 0 && verbatim.includes(paragraph.reason)) {
+    return [];
+  }
+  const banners = paragraph.lines.filter((line) => {
+    const text = paragraph.kind === "other" ? stripBlockSyntax(line.text) : line.text;
+    return isBanner(text) || paragraph.kind === "other" && /^\s*\/\*{3,}|\*{3,}\/\s*$/.test(line.text);
+  });
+  return banners.map((line) => lineIssue("banner", line, options));
+}
+function styleIssues(paragraph, options) {
+  if (!options.style) {
+    return [];
+  }
+  const byIndex = new Map(paragraph.lines.map((line) => [line.index, line]));
+  const lines = paragraph.lines.map((line) => {
+    return { index: line.index, text: paragraph.kind === "other" ? stripBlockSyntax(line.text) : line.text };
+  });
+  return findStyleIssues(lines).flatMap((issue) => {
+    const line = byIndex.get(issue.index);
+    return line ? [lineIssue(issue.type, line, options)] : [];
+  });
+}
+function bindTagHead(tokens) {
+  let end = 1;
+  if (tokens[end]?.startsWith("{")) {
+    end += 1;
+  }
+  if (NAMED_TAGS.has(tokens[0].slice(1)) && end < tokens.length) {
+    end += 1;
+  }
+  if (tokens[end] === "-") {
+    end += 1;
+  }
+  return [tokens.slice(0, end).join(" "), ...tokens.slice(end)];
+}
+function keptIssues(paragraph, structure, options) {
+  const tier = structure?.tier ?? "manual";
+  return byLine([
+    ...tier === "manual" || tier === "code-like" ? overflowIssues(paragraph.lines, options) : [],
+    ...tier === "code" || tier === "code-like" ? [] : styleIssues(paragraph, options),
+    ...bannerIssues(paragraph, options)
+  ]);
+}
+function byLine(issues) {
+  const unique = new Map(issues.map((issue) => [`${issue.line}:${issue.type}`, issue]));
+  return [...unique.values()].toSorted((a, b) => a.line - b.line);
+}
+function sameLayout(a, b) {
+  return a.length === b.length && a.every((words, position) => words.join(" ") === b[position].join(" "));
+}
+function analyzeParagraph(paragraph, options) {
+  const first = paragraph.lines[0];
+  const last = paragraph.lines.at(-1) ?? first;
+  const base = { kind: paragraph.kind, startLine: first.index + 1, endLine: last.index + 1 };
+  if (paragraph.kind === "code") {
+    return {
+      ...base,
+      reflowable: false,
+      reason: paragraph.reason,
+      issues: bannerIssues(paragraph, options),
+      suggestion: null
+    };
+  }
+  if (paragraph.kind === "tag" && paragraph.reason) {
+    const codeTag = CODE_TAGS.has(JSDOC_TAG.exec(first.text)?.[1] ?? "");
+    const issues2 = codeTag ? [] : overflowIssues(paragraph.lines, options);
+    return { ...base, reflowable: false, reason: paragraph.reason, issues: issues2, suggestion: null };
+  }
+  if (paragraph.kind === "other") {
+    const fence = new FenceTracker();
+    const prose = {
+      ...paragraph,
+      lines: paragraph.lines.filter((line) => !fence.next(stripBlockSyntax(line.text)))
+    };
+    const structure2 = structureOf(
+      prose.lines.map((line) => {
+        return { ...line, text: stripBlockSyntax(line.text) };
+      })
+    );
+    const issues2 = keptIssues(prose, structure2, options);
+    return { ...base, reflowable: false, reason: paragraph.reason, issues: issues2, suggestion: null };
+  }
+  const keep = (structure2) => {
+    const issues2 = keptIssues(paragraph, structure2, options);
+    return { ...base, reflowable: false, reason: structure2.reason, issues: issues2, suggestion: null };
+  };
+  const structure = structureOf(paragraph.lines);
+  if (structure) {
+    return keep(structure);
+  }
+  const prefix = first.prefix;
+  const prefixLength = visualLength(prefix, options.tabWidth);
+  const hang = " ".repeat(paragraph.marker.length);
+  const firstLimit = options.width - prefixLength - paragraph.marker.length;
+  const restLimit = options.width - prefixLength - hang.length;
+  const currentLines = paragraph.lines.map(
+    (line, position) => bindLineStarts(tokenize(position === 0 ? line.text.slice(paragraph.marker.length) : line.text), startsLine)
+  );
+  const tokens = tokenize(currentLines.flat().join(" "));
+  const layoutOptions = {
+    ...options,
+    tolerance: options.maxWidth === void 0 ? options.tolerance : Math.min(options.tolerance, options.maxWidth - options.width),
+    parentheticalOverflow: options.maxWidth === void 0 ? void 0 : options.maxWidth - options.width,
+    keepFirstLine: paragraph.kind === "tag"
+  };
+  const layOut = (from, settings) => {
+    const even2 = layoutTokens(from, firstLimit, restLimit, settings);
+    return { even: even2, wrapped: breakAfterSentence(even2, firstLimit, restLimit, settings) };
+  };
+  const units = bindLineStarts(paragraph.kind === "tag" ? bindTagHead(tokens) : tokens, startsLine);
+  const hardLimit = restLimit + (options.maxWidth === void 0 ? options.tolerance : options.maxWidth - options.width);
+  const written = currentLines.map((words) => ` ${words.join(" ")} `);
+  const staysInLimit = (unit) => {
+    return unit.length <= hardLimit || written.some((line) => line.includes(` ${unit} `));
+  };
+  if (!units.every((unit) => staysInLimit(unit))) {
+    return keep({ tier: "manual", reason: "unbreakable text across lines" });
+  }
+  const bodyOf = (lines) => {
+    return lines.map((words, position) => {
+      const text = `${position === 0 ? paragraph.marker : hang}${words.join(" ")}`;
+      return { ...first, text, verbatim: false, hardBreak: HARD_BREAK.test(text) };
+    });
+  };
+  const settle = (settings) => {
+    let current = units;
+    let { even: even2, wrapped: wrapped2 } = layOut(current, settings);
+    for (; ; ) {
+      const body = bodyOf(wrapped2);
+      const rewrap = structureOf(body);
+      if (!rewrap) {
+        return { even: even2, wrapped: wrapped2 };
+      }
+      const tipping = body.findIndex((_, position) => structureOf(body.slice(0, position + 1)) !== void 0);
+      const start = wrapped2.slice(0, Math.max(tipping, 1)).flat().length;
+      const pair = `${current[start - 1]} ${current[start]}`;
+      if (body.length < 2 || !staysInLimit(pair)) {
+        const reading = rewrap.tier === "code-like" ? "code" : rewrap.reason;
+        return { tier: "manual", reason: `rewrap would read as ${reading}` };
+      }
+      current = current.toSpliced(start - 1, 2, pair);
+      ({ even: even2, wrapped: wrapped2 } = layOut(current, settings));
+    }
+  };
+  const settled = settle(layoutOptions);
+  const layout = "wrapped" in settled ? settled : settle({ ...layoutOptions, keepSteps: true });
+  if (!("wrapped" in layout)) {
+    return keep(layout);
+  }
+  const { even, wrapped } = layout;
+  const matchesLayout = sameLayout(wrapped, currentLines);
+  const lineIssues = [];
+  const overflow = options.maxWidth === void 0 ? [] : overflowIssues(paragraph.lines, options);
+  if (!matchesLayout) {
+    const hasExtraLines = currentLines.length > wrapped.length;
+    if (options.maxWidth === void 0) {
+      overflow.push(...overflowIssues(paragraph.lines, options));
+    }
+    lineIssues.push(
+      ...findLineIssues(currentLines, firstLimit, restLimit, layoutOptions).filter(
+        (issue) => issue.type !== "overflow" && (issue.type !== "underfill" || hasExtraLines)
+      )
+    );
+    if (hasWidow(currentLines) && !hasWidow(wrapped)) {
+      lineIssues.push({ type: "widow", line: currentLines.length - 1 });
+    }
+    if (lineIssues.length === 0 && overflow.length === 0 && (currentLines.length === wrapped.length || options.maxWidth !== void 0)) {
+      const line = wrapped.findIndex((words, position) => words.join(" ") !== currentLines[position]?.join(" "));
+      lineIssues.push({ type: sameLayout(even, currentLines) ? "orphan" : "unbalanced", line: Math.max(line, 0) });
+    }
+  }
+  const suggestion = wrapped.map(
+    (words, position) => `${prefix}${position === 0 ? paragraph.marker : hang}${words.join(" ")}`
+  );
+  const wrapIssues = lineIssues.map((issue) => lineIssue(issue.type, paragraph.lines[issue.line], options));
+  const issues = byLine([...overflow, ...wrapIssues, ...styleIssues(paragraph, options)]);
+  return { ...base, reflowable: true, issues, suggestion };
+}
+function computeLineStarts(source) {
+  const starts = [0];
+  for (let index = 0; index < source.length; index += 1) {
+    if (source.codePointAt(index) === 10) {
+      starts.push(index + 1);
+    }
+  }
+  return starts;
+}
+function lineOf(lineStarts, offset) {
+  let low = 0;
+  let high = lineStarts.length - 1;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (lineStarts[middle] <= offset) {
+      low = middle;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return low;
+}
+function stripCarriageReturn(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function shapeBlock(comment, sourceLines, lineStarts) {
+  const startLine = lineOf(lineStarts, comment.start);
+  const endLine = lineOf(lineStarts, comment.end - 1);
+  const kind = comment.value.startsWith("*") ? "jsdoc" : "block";
+  const lines = sourceLines.slice(startLine, endLine + 1);
+  const wholeComment = (paragraphKind, reason) => {
+    const otherLines = lines.map((text, offset) => {
+      return { index: startLine + offset, prefix: "", text, verbatim: false, hardBreak: false };
+    });
+    return { kind, startLine, endLine, paragraphs: [{ kind: paragraphKind, marker: "", reason, lines: otherLines }] };
+  };
+  const value = comment.value.replace(/^\*/, "");
+  if (LEGAL_COMMENT.test(replaceKeepingLines(comment.value, CODE_SPAN, "``"))) {
+    return wholeComment("code", "legal comment");
+  }
+  if (LINE_DIRECTIVE.test(value) || BLOCK_DIRECTIVE.test(value)) {
+    return wholeComment("code", "directive");
+  }
+  const other = () => {
+    return wholeComment(
+      "other",
+      startLine === endLine ? "single-line block comment" : "unsupported block comment layout"
+    );
+  };
+  if (startLine === endLine || !/^\s*\/\*\*?$/.test(lines[0]) || !/^\s*\*\/$/.test(lines.at(-1) ?? "")) {
+    return other();
+  }
+  const body = [];
+  const inner = lines.slice(1, -1);
+  for (const [offset, line] of inner.entries()) {
+    const match = /^(\s*\*)( ?)(.*)$/.exec(line);
+    if (!match) {
+      return other();
+    }
+    const [, star, space, text] = match;
+    body.push({
+      index: startLine + 1 + offset,
+      prefix: `${star} `,
+      text: text.trimEnd(),
+      verbatim: !space && text.length > 0 || LINE_DIRECTIVE.test(text),
+      hardBreak: HARD_BREAK.test(text)
+    });
+  }
+  return { kind, startLine, endLine, paragraphs: segment(body) };
+}
+function ownsLines(comment, source, lineStarts) {
+  const startLine = lineOf(lineStarts, comment.start);
+  const before = source.slice(lineStarts[startLine], comment.start);
+  const endLine = lineOf(lineStarts, comment.end - 1);
+  const lineEnd = lineStarts[endLine + 1] ?? source.length;
+  const after = source.slice(comment.end, lineEnd);
+  return /^[\t ]*$/.test(before) && /^[\t ]*\r?\n?$/.test(after);
+}
+function singleLineLength(paragraph, options) {
+  const [first] = paragraph.lines;
+  if (paragraph.kind === "other" && paragraph.reason === "single-line block comment") {
+    return sourceLineLength(first, options.tabWidth);
+  }
+  if (paragraph.kind !== "prose" || structureOf(paragraph.lines)) {
+    return Infinity;
+  }
+  const text = tokenize(paragraph.lines.map((line) => line.text).join(" ")).join(" ");
+  return visualLength(first.prefix, options.tabWidth) + text.length;
+}
+var BYTE_ORDER_MARK = "\uFEFF";
+function parseSource(filename, source) {
+  return parseSync(filename, source, filename.endsWith(".js") ? { lang: "jsx" } : void 0);
+}
+function describeFailure(errors, lineStarts) {
+  const [first] = errors;
+  const offset = first.labels.at(0)?.start;
+  return { message: first.message, line: offset === void 0 ? void 0 : lineOf(lineStarts, offset) + 1 };
+}
+function analyzeSource(source, filename, options) {
+  return inspectSource(source, filename, options).comments;
+}
+function inspectSource(source, filename, options) {
+  if (options.maxWidth !== void 0 && (!Number.isInteger(options.maxWidth) || options.maxWidth < options.width)) {
+    throw new Error("comments: maxWidth must be an integer at least as large as width");
+  }
+  const text = source.startsWith(BYTE_ORDER_MARK) ? source.slice(1) : source;
+  const { program, comments, errors } = parseSource(filename, text);
+  const lineStarts = computeLineStarts(text);
+  if (errors.length > 0 && program.body.length === 0) {
+    return { comments: [], syntaxError: describeFailure(errors, lineStarts) };
+  }
+  const sourceLines = text.split("\n").map((line) => stripCarriageReturn(line));
+  const parsed = comments.filter((comment) => !(comment.start === 0 && text.startsWith("#!")));
+  const reports = [];
+  const blocks = parsed.filter((comment) => {
+    return comment.type === "Block" && ownsLines(comment, text, lineStarts) && !comment.value.includes(IGNORE_DIRECTIVE);
+  });
+  for (const block of blocks) {
+    const shape = shapeBlock(block, sourceLines, lineStarts);
+    const singleLineWidth = Math.max(
+      options.width,
+      Math.min(options.singleLineWidth ?? options.width, options.maxWidth ?? Infinity)
+    );
+    const paragraphOptions = shape.paragraphs.length === 1 && singleLineLength(shape.paragraphs[0], options) <= singleLineWidth ? { ...options, width: singleLineWidth } : options;
+    const lines = sourceLines.slice(shape.startLine, shape.endLine + 1);
+    reports.push({
+      file: filename,
+      kind: shape.kind,
+      startLine: shape.startLine + 1,
+      endLine: shape.endLine + 1,
+      indent: /^[\t ]*/.exec(lines[0])?.[0] ?? "",
+      width: options.width,
+      maxWidth: options.maxWidth,
+      lengths: lines.map((line) => visualLength(line.trimEnd(), options.tabWidth)),
+      text: lines.join("\n"),
+      paragraphs: shape.paragraphs.map((paragraph) => analyzeParagraph(paragraph, paragraphOptions))
+    });
+  }
+  return { comments: reports };
+}
+function isSuspicious(report) {
+  return report.paragraphs.some((paragraph) => paragraph.issues.length > 0);
+}
+function hasVerdictIssues(report) {
+  return report.paragraphs.some((paragraph) => paragraph.issues.some((issue) => issue.tier === "verdict"));
+}
+function rewrapComment(report) {
+  const lines = report.text.split("\n");
+  const paragraphs = report.paragraphs.filter((paragraph) => paragraph.suggestion !== null).toSorted((a, b) => b.startLine - a.startLine);
+  for (const paragraph of paragraphs) {
+    const start = paragraph.startLine - report.startLine;
+    lines.splice(start, paragraph.endLine - paragraph.startLine + 1, ...paragraph.suggestion ?? []);
+  }
+  return lines.join("\n");
+}
+var POSITION_KEYS = /* @__PURE__ */ new Set(["start", "end", "range", "loc"]);
+function codeFingerprint(source, filename) {
+  const { program, errors } = parseSource(filename, source);
+  if (errors.length > 0) {
+    return JSON.stringify({ source, errors: errors.map((error) => error.message) });
+  }
+  return JSON.stringify(
+    program,
+    (key, value) => POSITION_KEYS.has(key) || typeof value === "bigint" ? void 0 : value
+  );
+}
+
+// src/comments/agent.ts
+import { spawn } from "child_process";
+import { readFileSync } from "fs";
+import path from "path";
+var DEFAULT_RULES = `
+# Comment rules
+
+## Priorities
+
+When rules pull in different directions, the earlier one wins.
+
+1. Keep code and exact text byte for byte, including every punctuation character in it. That covers code blocks, \`@example\`, code spans, identifiers, string literals like error messages, regexes, globs and other patterns like \`*test*\`, URLs, quoted text, titles, and notation like \`host:port\`.
+2. Keep the meaning. An edit may make a comment clearer, never different.
+3. Follow the style preferences below.
+4. Change as little as possible. Wording that already reads clearly stays, even when a note points at it.
+
+## Layout
+
+- After you finish, the tool rewraps prose paragraphs, list items, and JSDoc tag descriptions. The width is a preferred target. A parenthetical may extend a line up to the configured maximum so it stays together. In longer paragraphs, balanced lines take priority over keeping every parenthetical on one line. The tool also avoids short last lines where possible. Leave these line breaks to the tool, except for the sentence-orphan case below.
+- Don't end a line with the first word of a new sentence, clause, or parenthetical, like \`This\` after a period, \`the\` after a comma, or \`(the\`. Move it to the next line instead.
+- In a paragraph of two lines, the first line ends with a sentence whenever the rest fits on the second line and is no longer than the first. Don't end it with the start of the next sentence, like \`A wrap\` in \`...lay out differently. A wrap\`. Move those words to the second line instead.
+- A comment whose whole text is one paragraph stays on a single line when that line fits a separate, larger single-line width, even past the width. Only a longer comment wraps to the width.
+- Separate paragraphs with an empty comment line.
+- Never split a backtick code span across lines.
+- Keep code blocks, \`@example\`, lists, tables, box drawings, aligned columns, and Markdown hard line breaks (a line that ends with two spaces or a backslash) laid out as they are. List items wrap with their continuation lines indented to the item text, and a JSDoc tag description that doesn't fit continues on the next line without indentation.
+- The tool measures every line, taking the tolerance and the parts it keeps as written into account, and the notes on each comment list what is still wrong. Act on those notes. Don't count columns, and don't apply a stricter limit than the notes show.
+- The maximum is a hard limit for measured prose, including long tokens. If a URL, code span, or other exact text exceeds it, preserve that text and explain the unresolved overflow instead of changing its contents.
+- The tool never rewraps the parts it keeps as written, like a single-line block comment, a paragraph with hard line breaks, or lines that may be laid out by hand. When a note says one of their prose lines is too long, break or shorten it yourself. Exact text and intentional layout win over the width, so keep code, code spans, and the layout in them intact, and if a note can only be fixed by changing them, leave it and say why in your reply.
+
+## Style
+
+These are preferences for comment prose. They never apply to code or exact text (see the priorities above), and a punctuation character on its own is never a reason to edit prose that already reads clearly.
+
+- Write clear sentences that flow. Descriptions read best as complete sentences with a subject and a verb, so prefer "Returns the bytes the guest sent" over a fragment like \`Bytes from the guest.\` or \`Optional.\` Imperative or third-person verb phrases like "Resolve a hostname..." or "Aborts every channel..." are fine, since the preference is against verb-less fragments, not against concise sentences.
+- Prefer plain sentence punctuation. Where a semicolon, an em-dash (\u2014), or a spaced hyphen, en-dash, or double hyphen standing in for one only joins two thoughts, a period, a comma, parentheses, or a word like "and", "so", or "because" usually reads better. Keep the punctuation where it carries meaning or reads more clearly than the alternatives.
+- Prefer a sentence over a "Label: explanation" fragment, like \`...the socket. Optional: without it...\` or \`Default: refuse\` in the middle of prose. A colon is fine where it introduces a list, code block, or example, in a term's definition, in notation, in a quotation, and in a \`Note:\` or \`Optional:\` that starts a comment. A JSDoc tag like \`@note\` or \`@todo\` can replace a label, and \`@default\` fits a default value, not a description.
+- Avoid asterisk emphasis like \`*this*\`, and use plain wording instead. A name or pattern in asterisks, like \`*test*\` or \`*.spec.ts\`, is a pattern, so keep its asterisks and wrap it in a code span, like \`\` \`*test*\` \`\`.
+- Avoid section banner comments, i.e. dividers or headings made of dashes, equals signs, asterisks, or other repeated characters that split a file into visual sections. Let the code structure carry the grouping, or write one short, plain sentence comment (e.g. \`// handlers for control mode\`). Rules that belong to a diagram, a table, a box drawing, a Markdown document, an example, or a legal header aren't banners.
+- Block and JSDoc comments are capitalized and end with punctuation.
+- Never turn a block or JSDoc comment into \`//\` line comments, and never write a run of consecutive \`//\` lines.
+
+## Editing
+
+- Keep the wording unless it goes against a rule above. Then reword as little as needed and keep the meaning.
+- Don't reword anything else unless the instructions below allow it.
+`.trim();
+
+// src/comments/config.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { createRequire } from "module";
+import path2 from "path";
+import { pathToFileURL } from "url";
+var DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"]);
+var CONFIG_FILES = [
+  "comments.config.ts",
+  "comments.config.mts",
+  "comments.config.js",
+  "comments.config.mjs",
+  "comments.config.cjs",
+  ".commentsrc",
+  ".commentsrc.json"
+];
+var PACKAGE_JSON_KEY = "comments";
+function defineConfig(config) {
+  return config;
+}
+function readJson(filepath) {
+  try {
+    return JSON.parse(readFileSync2(filepath, "utf8"));
+  } catch (error) {
+    throw new Error(`comments: failed to parse ${filepath}: ${error.message}`, { cause: error });
+  }
+}
+async function readConfigFile(filepath) {
+  if (filepath.endsWith("rc") || filepath.endsWith(".json")) {
+    return readJson(filepath);
+  }
+  const module = await import(pathToFileURL(filepath).href);
+  return module.default ?? module;
+}
+function assertType(value, type, key, filepath) {
+  const actual = Array.isArray(value) ? "array" : typeof value;
+  if (value !== void 0 && actual !== type) {
+    throw new Error(`comments: \`${key}\` in ${filepath} must be a ${type}, got ${actual}`);
+  }
+}
+function assertStrings(value, key, filepath) {
+  if (Array.isArray(value) && !value.every((item) => typeof item === "string")) {
+    throw new Error(`comments: \`${key}\` in ${filepath} must only hold strings`);
+  }
+}
+function validateConfig(raw, filepath) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`comments: ${filepath} must export an object`);
+  }
+  const config = raw;
+  assertType(config.width, "number", "width", filepath);
+  assertType(config.maxWidth, "number", "maxWidth", filepath);
+  assertType(config.singleLineWidth, "number", "singleLineWidth", filepath);
+  assertType(config.tolerance, "number", "tolerance", filepath);
+  assertType(config.avoidSentenceOrphans, "boolean", "avoidSentenceOrphans", filepath);
+  assertType(config.style, "boolean", "style", filepath);
+  assertType(config.extensions, "array", "extensions", filepath);
+  assertType(config.ignore, "array", "ignore", filepath);
+  assertType(config.agent, "object", "agent", filepath);
+  assertType(config.hook, "object", "hook", filepath);
+  assertStrings(config.extensions, "extensions", filepath);
+  assertStrings(config.ignore, "ignore", filepath);
+  for (const key of ["width", "maxWidth", "singleLineWidth", "tolerance"]) {
+    const value = config[key];
+    const minimum = key === "tolerance" ? 0 : 1;
+    if (value !== void 0 && (!Number.isInteger(value) || value < minimum)) {
+      throw new Error(`comments: \`${key}\` in ${filepath} must be an integer of at least ${minimum}`);
+    }
+  }
+  if (typeof config.width === "number" && typeof config.maxWidth === "number" && config.maxWidth < config.width) {
+    throw new Error(`comments: \`maxWidth\` in ${filepath} must be at least \`width\``);
+  }
+  const agent = config.agent ?? {};
+  if (agent.runner !== void 0 && !["claude", "codex", "cursor"].includes(agent.runner)) {
+    throw new Error(`comments: \`agent.runner\` in ${filepath} must be one of claude, codex, cursor`);
+  }
+  assertType(agent.model, "string", "agent.model", filepath);
+  assertType(agent.args, "array", "agent.args", filepath);
+  assertType(agent.command, "array", "agent.command", filepath);
+  assertType(agent.timeout, "number", "agent.timeout", filepath);
+  assertStrings(agent.args, "agent.args", filepath);
+  assertStrings(agent.command, "agent.command", filepath);
+  if (agent.timeout !== void 0 && !(agent.timeout > 0)) {
+    throw new Error(`comments: \`agent.timeout\` in ${filepath} must be a positive number`);
+  }
+  for (const key of ["batchSize", "maxFiles", "maxAgents"]) {
+    const value = agent[key];
+    if (value !== void 0 && (!Number.isInteger(value) || value < 1)) {
+      throw new Error(`comments: \`agent.${key}\` in ${filepath} must be a positive integer`);
+    }
+  }
+  assertType(agent.rules, "string", "agent.rules", filepath);
+  assertType(agent.instructions, "string", "agent.instructions", filepath);
+  if (agent.scope !== void 0 && agent.scope !== "suspicious" && agent.scope !== "all") {
+    throw new Error(`comments: \`agent.scope\` in ${filepath} must be "suspicious" or "all"`);
+  }
+  const hook = config.hook ?? {};
+  if (hook.mode !== void 0 && !["agent", "report", "off"].includes(hook.mode)) {
+    throw new Error(`comments: \`hook.mode\` in ${filepath} must be one of agent, report, off`);
+  }
+  return config;
+}
+async function loadConfig(cwd, options = {}) {
+  if (options.explicitPath) {
+    const filepath = path2.resolve(cwd, options.explicitPath);
+    return { config: validateConfig(await readConfigFile(filepath), filepath), filepath };
+  }
+  let directory = path2.resolve(cwd);
+  for (; ; ) {
+    for (const name of CONFIG_FILES) {
+      const filepath = path2.join(directory, name);
+      if (existsSync(filepath)) {
+        return { config: validateConfig(await readConfigFile(filepath), filepath), filepath };
+      }
+    }
+    const packageJsonPath = path2.join(directory, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const value = readJson(packageJsonPath)[PACKAGE_JSON_KEY];
+      if (value !== void 0) {
+        return { config: validateConfig(value, packageJsonPath), filepath: packageJsonPath };
+      }
+    }
+    const parent = path2.dirname(directory);
+    if (directory === options.stopDir || parent === directory) {
+      return { config: {} };
+    }
+    directory = parent;
+  }
+}
+export {
+  DEFAULT_RULES,
+  analyzeSource,
+  codeFingerprint,
+  defineConfig,
+  hasVerdictIssues,
+  isSuspicious,
+  loadConfig,
+  rewrapComment,
+  tokenize,
+  wrapTokens
+};
+/**
+ * Legal comments are kept as they are. A comment is legal when it uses the same markers
+ * as bundlers like esbuild (`/*!`, `//!`, `@license`, and `@preserve`), or when it is a
+ * copyright notice like `Copyright (c) 2020 Foo`.
+ */
+// a code span only names a marker, like the `@license` in a comment that explains legal comments
+//# sourceMappingURL=comments.js.map