chaffjs 0.17.0 → 0.18.0

package/src/template-syntax.ts

@@ -0,0 +1,164 @@
+import { spanOf, type MarkdownNode } from "./markdown-node.ts";
+import type { Span } from "./plugin.ts";
+
+/** `closer` finds where each `close` starts. */
+type Delimiters = { readonly open: string; readonly close: string; readonly closer: RegExp };
+
+/**
+ * Template and MDX syntax written into the text: Liquid and Jinja tags (`{% ifversion %}`,
+ * `{% data variables.product.github %}`), outputs (`{{ page.title }}`, which also covers Hugo's shortcodes
+ * `{{< note >}}` and `{{% alert %}}`) and comments (`{# … #}`), and MDX comments (a block comment in braces).
+ */
+const DELIMITERS: readonly Delimiters[] = [
+  { open: "{%", close: "%}", closer: /%\}/gu },
+  { open: "{{", close: "}}", closer: /\}\}/gu },
+  { open: "{#", close: "#}", closer: /#\}/gu },
+  { open: "{/*", close: "*/}", closer: /\*\/\}/gu },
+];
+
+const OPENER = /\{(?=[{%#]|\/\*)/gu;
+
+// A tag never runs past a blank line: an unclosed `{{` is a character in the text, not a tag that swallows the page.
+const BLANK_LINE = /\n[ \t]*\n/gu;
+
+const stretchesOf = (text: string): Span[] => {
+  const breaks = [...text.matchAll(BLANK_LINE)];
+  const starts = [0, ...breaks.map((blank) => blank.index + blank[0].length)];
+  return starts.map((start, index) => ({ start, end: breaks[index]?.index ?? text.length }));
+};
+
+/** The first of the sorted `positions` at or after `from`. */
+const firstAtOrAfter = (positions: readonly number[], from: number, low = 0, high = positions.length): number | undefined => {
+  if (low >= high) return positions[low];
+  const middle = (low + high) >> 1;
+  return (positions[middle] ?? from) >= from ? firstAtOrAfter(positions, from, low, middle) : firstAtOrAfter(positions, from, middle + 1, high);
+};
+
+/**
+ * The tags in one stretch, left to right: each opener closes at the first closer after it, and an opener inside a tag
+ * opens nothing. Each opener looks its closer up instead of scanning for it, so a line of unclosed openers is linear.
+ */
+const tagsIn = (stretch: string): Span[] => {
+  const closers = DELIMITERS.map(({ closer }) => [...stretch.matchAll(closer)].map((match) => match.index));
+  return [...stretch.matchAll(OPENER)].reduce<Span[]>((tags, { index }) => {
+    if (index < (tags.at(-1)?.end ?? 0)) return tags;
+    const kind = DELIMITERS.findIndex(({ open }) => stretch.startsWith(open, index));
+    const delimiters = DELIMITERS[kind];
+    const close = delimiters === undefined ? undefined : firstAtOrAfter(closers[kind] ?? [], index + delimiters.open.length);
+    if (delimiters !== undefined && close !== undefined) tags.push({ start: index, end: close + delimiters.close.length });
+    return tags;
+  }, []);
+};
+
+/** Where the template syntax stands. Read `code` with code already blanked, so a `{{` inside backticks opens nothing. */
+export const templateSpans = (code: string): Span[] =>
+  stretchesOf(code).flatMap((stretch) =>
+    tagsIn(code.slice(stretch.start, stretch.end)).map((tag) => ({ start: stretch.start + tag.start, end: stretch.start + tag.end })),
+  );
+
+/** A line that starts with a JSX element's tag (`<Tabs>`, `</Tabs>`). HTML's tags are lower case and stay HTML. */
+const COMPONENT_START = /^[ \t]*<\/?[A-Z][^\n]*$/gmu;
+
+const QUOTED = /"[^"\n]*"|'[^'\n]*'/gu;
+
+/** Tags and nothing else, once quoted values are emptied and expressions taken out: `<TabItem value= label=>`. */
+const TAGS_ONLY = /^[ \t]*(?:<\/?[A-Za-z][\w.:-]*(?:[ \t][^<>{}]*)?>[ \t]*)+$/u;
+
+/** The line without its brace expressions, however deeply they nest; undefined when its braces do not balance. */
+const withoutExpressions = (line: string): string | undefined => {
+  const kept: string[] = [];
+  const depth = [...line.replace(QUOTED, '""')].reduce((level, char) => {
+    if (level < 0) return level;
+    if (char === "{") return level + 1;
+    if (char === "}") return level - 1;
+    if (level === 0) kept.push(char);
+    return level;
+  }, 0);
+  return depth === 0 ? kept.join("") : undefined;
+};
+
+const isComponentLine = (line: string): boolean => {
+  const bare = withoutExpressions(line);
+  return bare !== undefined && TAGS_ONLY.test(bare);
+};
+
+/**
+ * Lines of nothing but JSX tags. MDX reads such a line as a block of its own, so the text on the next line is a
+ * paragraph; CommonMark reads it as the start of an HTML block that runs to the next blank line and hides that text.
+ */
+export const componentLines = (source: string): Span[] =>
+  [...source.matchAll(COMPONENT_START)]
+    .filter((match) => isComponentLine(match[0]))
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+const IMPORT_START = /^import(?:\s|\{)/u;
+// The module's name in quotes ends the statement: "import data from 'CSV' before review." goes on, so it is prose.
+const IMPORT_FROM = /(?:[\s}*]from\s*|^import\s*)["'][^"'\n]*["'];?[ \t]*(?:\n|$)/u;
+
+/** JavaScript's shapes of `export`, read on the first line, so that "export default reports from…" stays a sentence. */
+const EXPORT_SHAPES: readonly RegExp[] = [
+  /^export\s+(?:async\s+)?function\b/u,
+  /^export\s+class\s+[\w$]/u,
+  /^export\s+(?:const|let|var)\s+[\w${[][^=]*=/u,
+  /^export\s+default\s+(?:async\s+)?(?:function|class)\b/u,
+  /^export\s+default\s*[{(["'`<]/u,
+  /^export\s+default\s+[\w$.]+\s*\(/u,
+  /^export\s+default\s+[\w$]+(?:\.[\w$]+)*;?\s*$/u,
+  /^export\s*[{*]/u,
+];
+
+const isExport = (paragraph: string): boolean => {
+  const firstLine = paragraph.split("\n", 1)[0] ?? "";
+  return EXPORT_SHAPES.some((shape) => shape.test(firstLine));
+};
+
+/** A paragraph that is MDX's `import`/`export` block: JavaScript, which MDX runs to the next blank line. */
+const isModuleBlock = (paragraph: string): boolean => (IMPORT_START.test(paragraph) && IMPORT_FROM.test(paragraph)) || isExport(paragraph);
+
+/** MDX's `import`/`export` lines: JavaScript, and only at the top level of the page. */
+export const moduleBlocks = (root: MarkdownNode, source: string): Span[] =>
+  (root.children ?? []).flatMap((node) => {
+    const span = node.type === "paragraph" ? spanOf(node) : undefined;
+    return span !== undefined && isModuleBlock(source.slice(span.start, span.end)) ? [span] : [];
+  });
+
+/** `[!NOTE]` and the like opening a quote: a GitHub alert (Obsidian's callouts write the same). */
+const alertMarkerAt = (source: string, start: number): Span | undefined => {
+  const marker = /\[![A-Za-z]+\][^\n]*/uy;
+  marker.lastIndex = start;
+  return marker.test(source) ? { start, end: marker.lastIndex } : undefined;
+};
+
+const QUOTE_MARK = /^[ \t]*>[ \t]?/gmu;
+
+/** The `>` that opens each line of a quote spanning `quote`: the quote's own mark, not its text. */
+const quoteMarks = (source: string, quote: Span): Span[] =>
+  [...source.slice(quote.start, quote.end).matchAll(QUOTE_MARK)].map((match) => ({
+    start: quote.start + match.index,
+    end: quote.start + match.index + match[0].length,
+  }));
+
+/**
+ * A GitHub alert (`> [!NOTE]`) is the writer's own text set in a box, not a quote: only its marker line and the `>` of
+ * each line are not prose. Undefined when the quote is not an alert.
+ */
+const alertMarks = (quote: MarkdownNode, whole: Span, source: string): Span[] | undefined => {
+  const first = quote.children?.[0];
+  const start = first?.type === "paragraph" ? spanOf(first)?.start : undefined;
+  const marker = start === undefined ? undefined : alertMarkerAt(source, start);
+  return marker === undefined ? undefined : [marker, ...quoteMarks(source, whole)];
+};
+
+/**
+ * Reads the alerts of one walk over the tree in pre-order: the marks of each alert, undefined for any other node. A
+ * quote inside a quote is quoted, even one that opens like an alert; pre-order meets the outer quote first.
+ */
+export const alertReader = (source: string): ((node: MarkdownNode) => Span[] | undefined) => {
+  const outer = { end: -1 };
+  return (node) => {
+    const quote = node.type === "blockquote" ? spanOf(node) : undefined;
+    if (quote === undefined || quote.start < outer.end) return undefined;
+    outer.end = quote.end;
+    return alertMarks(node, quote, source);
+  };
+};

package/src/text-above.ts

@@ -0,0 +1,49 @@
+/**
+ * 箇条書きや表のすぐ上に書いた文の塊。予告の文（以下の3点）や、割合の表の説明（売上の構成比）を読む rule が使う。
+ * 文書の頭まで読み返さないので、箇条書きや表の多い長い文書でも行数に比例する。
+ */
+export type TextBlock = { readonly start: number; readonly text: string };
+
+const BLANK = /^[ \t]*$/u;
+const LIST_MARKER = /^[ \t]*(?:[-*+]|\d{1,3}[.)])[ \t]/u;
+
+export const isBlank = (text: string): boolean => BLANK.test(text);
+
+/** 位置 end の改行で終わる行。 */
+const lineEndingAt = (source: string, end: number): TextBlock => {
+  const start = end === 0 ? 0 : source.lastIndexOf("\n", end - 1) + 1;
+  return { start, text: source.slice(start, end) };
+};
+
+/** start の行の一つ上の行。文書の最初の行なら undefined。 */
+export const lineAbove = (source: string, start: number): TextBlock | undefined => {
+  if (start === 0) return undefined;
+  const end = source.lastIndexOf("\n", start - 1);
+  return end < 0 ? undefined : lineEndingAt(source, end);
+};
+
+/**
+ * start の行より上の塊を、下の行から上へ。passed に当たる行（表の見出しの行など）と空行は、塊に着くまで飛ばす。
+ * 塊は次の空行まで。箇条書きの印で始まる行（親の項目）はそこで止める。下の行から順に返す。
+ */
+export const linesAbove = (source: string, start: number, passed: (text: string) => boolean = () => false): TextBlock[] => {
+  const block: TextBlock[] = [];
+  let line = lineAbove(source, start);
+  while (line !== undefined) {
+    if (isBlank(line.text) || (block.length === 0 && passed(line.text))) {
+      if (block.length > 0) break;
+    } else {
+      block.push(line);
+      if (LIST_MARKER.test(line.text)) break;
+    }
+    line = lineAbove(source, line.start);
+  }
+  return block;
+};
+
+/** 下の行から並べた塊を、一続きの文字列にする。 */
+export const joined = (source: string, lines: readonly TextBlock[]): TextBlock | undefined => {
+  const top = lines.at(-1);
+  const bottom = lines[0];
+  return top === undefined || bottom === undefined ? undefined : { start: top.start, text: source.slice(top.start, bottom.start + bottom.text.length) };
+};

package/src/text-figures.ts

@@ -0,0 +1,147 @@
+import type { Span } from "./plugin.ts";
+import { mergeSpans } from "./span-merge.ts";
+import { spansOfType } from "./markdown-read.ts";
+import type { MarkdownNode } from "./markdown-node.ts";
+
+/**
+ * 線と矢印で描いた図（RFC の状態遷移図、やり取りの図、枠の表）。文ではないので、コードブロックと同じく本文から外す。
+ *
+ * 見分けるのは形だけ。線の文字が多いか、語のあいだを 3 字以上空けて桁をそろえた行で、文の句読点が無いもの。
+ * そういう行が続く塊（行のあいだの空行は 1 行まで）のうち、2 行以上あり、線の行を 1 行でも含むものを図とする。
+ * 句読点の無い短い行（図の中の「(Close)」）は、図の行に挟まれていれば図に入る。塊の端にあれば入らない。
+ * 語の多い行は、句読点が無くても文の行（折り返した文の途中）として塊を切る。
+ * 桁をそろえただけの語の表は、線が無ければ本文のまま読む。
+ */
+
+/** 線を引く文字。ASCII の + - | / \ < > ^ = と、U+2500 台の罫線・U+25A0 台の図形（▶ ▼）。 */
+const LINE_CHAR = /[+\-|/\\<>^=\u2500-\u25FF]/gu;
+/** 下向きの矢印として一文字で立つ v。語の中の v は数えない。 */
+const ARROW_V = /(?<=^|\s)[vV](?=\s|$)/gu;
+/** 線の文字が 3 つ続けば線（-->、+---+、<==）。 */
+const LINE_RUN = /[+\-|/\\<>^=\u2500-\u25FF]{3,}/gu;
+/** ただし「---」ちょうどは、語のあいだのダッシュ（47.041 --- Engineering）。 */
+const DASH = /^-{3}$/u;
+/** 行の空白以外の文字のうち、この割合以上が線の文字なら線の行。「== Community ==」のような見出しの印は半分に届かない。 */
+const LINE_SHARE = 0.5;
+/** 割合で線の行と読むのに要る、線の文字の数。箇条書きの「- EU」は印が 1 つだけ。 */
+const MIN_LINE_CHARS = 2;
+/** 語のあいだの 3 字以上の空白は、桁をそろえた印。文の区切りの空白は 2 字まで（RFC は文のあいだを 2 字空ける）。 */
+const COLUMN_GAP = /\S {3,}\S/u;
+/** 文の印: 語の直後の句読点に、次の語が続く（"reply. It"、"link, then"）。日本語は句点か読点があれば文。 */
+const SENTENCE = /\p{L}\p{L}[.,;:?!]["')\]]?\s+\p{L}|[。、]/u;
+/**
+ * 行末で終わる文（"alpha  Sends requests."、"beta  Uses TCP."）。見るのは最後の桁で、小文字の語があり . ? ! で終わるもの。
+ * 括弧で閉じた注記（"(return to LISTEN!)"）と省略の点（"..."）は図の中の書き方で、文の終わりではない。
+ */
+const SENTENCE_END = /[^.][.?!]["'”’]?$/u;
+const LOWER_WORD = /\p{Ll}\p{Ll}/u;
+const LAST_CELL = / {3,}/u;
+
+const endsSentence = (text: string): boolean => {
+  const cell = text.trim().split(LAST_CELL).at(-1) ?? "";
+  return SENTENCE_END.test(cell) && LOWER_WORD.test(cell);
+};
+/**
+ * 同じ線の文字だけの行（-----、==== ====）。見出しの下線や段の区切りで、図の中にあってもよいが図の印にはならない。
+ * 印にすると、区切りの線 2 本に挟まれた題（===== / Title / =====）や、下線を引いた見出しの前の箇条書きまで図になる。
+ */
+const RULE_LINE = /^\s*([-=_~*])\1*(?:\s+\1+)*\s*$/u;
+/** 行頭の箇条書きの印（-、*、+、1.、a)）。印の後ろの空白は桁そろえではない。 */
+const LIST_MARK = /^\s*(?:[-*+]|\p{N}{1,3}[.)]|\p{L}[.)])(?=\s)/u;
+/** 語。句読点の無い行でも、語が多ければ文の一部（折り返した文の行）で、図の中の注記ではない。 */
+const WORD = /\p{L}[\p{L}\p{N}'-]*/gu;
+/** 図の中の注記（「(Close)」「(2 MSL)」「CLOSED」）の語の数の上限。 */
+const MAX_PLAIN_WORDS = 4;
+/** 図の中で、行と行のあいだに置ける空行の数。 */
+const MAX_BLANK_RUN = 1;
+/** 図と読むのに要る行の数。区切りの線 1 行は図ではない。 */
+const MIN_FIGURE_LINES = 2;
+
+/** line は線の行、column は桁そろえの行、plain は句読点の無い行と区切りの線（図の中にあってよい）、text は文の行。 */
+type Kind = "line" | "column" | "plain" | "blank" | "text";
+
+type Row = { readonly start: number; readonly end: number; readonly kind: Kind };
+
+const matchesOf = (text: string, pattern: RegExp): string[] => [...text.matchAll(pattern)].map((match) => match[0]);
+
+const count = (text: string, pattern: RegExp): number => matchesOf(text, pattern).length;
+
+/** 箇条書きの印は線に数えない（「- /」はパンくずの区切り）。 */
+const isLineArt = (text: string): boolean => {
+  const body = text.replace(LIST_MARK, "");
+  const visible = body.replace(/\s/gu, "").length;
+  const drawn = count(body, LINE_CHAR) + count(body, ARROW_V);
+  return matchesOf(body, LINE_RUN).some((run) => !DASH.test(run)) || (drawn >= MIN_LINE_CHARS && drawn >= visible * LINE_SHARE);
+};
+
+const kindOf = (text: string): Kind => {
+  if (text.trim() === "") return "blank";
+  if (SENTENCE.test(text) || endsSentence(text)) return "text";
+  if (RULE_LINE.test(text)) return "plain";
+  if (isLineArt(text)) return "line";
+  if (COLUMN_GAP.test(text.replace(LIST_MARK, "").trimStart())) return "column";
+  return count(text, WORD) > MAX_PLAIN_WORDS ? "text" : "plain";
+};
+
+/** skip の中で始まる行は、文の行と同じく塊を切る。行も範囲も先頭から順に進むので、行ごとに範囲を全部なめない。 */
+const rowsOf = (source: string, skip: readonly Span[]): Row[] => {
+  const regions = mergeSpans(skip, false);
+  const scan = { start: 0, region: 0 };
+  return source.split("\n").map((text) => {
+    while ((regions[scan.region]?.end ?? Number.POSITIVE_INFINITY) <= scan.start) scan.region += 1;
+    const region = regions[scan.region];
+    const skipped = region !== undefined && region.start <= scan.start;
+    const row: Row = { start: scan.start, end: scan.start + text.length, kind: skipped ? "text" : kindOf(text) };
+    scan.start = row.end + 1;
+    return row;
+  });
+};
+
+/** 図の行の塊。空行が MAX_BLANK_RUN を超えて続くか、文の行が来たら切れる。塊の端の空行と句読点の無い行は入れない。 */
+const runsOf = (rows: readonly Row[]): Row[][] => {
+  // 行ごとに配列を作り直すと、何万行の文書で行数の二乗になる。塊は押し足していく。
+  const runs: Row[][] = [[]];
+  const scan = { blanks: 0 };
+  const cut = (): void => {
+    if ((runs.at(-1) ?? []).length > 0) runs.push([]);
+  };
+  rows.forEach((row) => {
+    if (row.kind === "blank") {
+      scan.blanks += 1;
+      if (scan.blanks > MAX_BLANK_RUN) cut();
+      return;
+    }
+    scan.blanks = 0;
+    if (row.kind === "text") cut();
+    else runs.at(-1)?.push(row);
+  });
+  return runs.map(trimPlain).filter((run) => run.length > 0);
+};
+
+const isDrawn = (row: Row): boolean => row.kind === "line" || row.kind === "column";
+
+const trimPlain = (run: readonly Row[]): Row[] => {
+  const first = run.findIndex(isDrawn);
+  return first === -1 ? [] : run.slice(first, run.findLastIndex(isDrawn) + 1);
+};
+
+const isFigure = (run: readonly Row[]): boolean => run.filter(isDrawn).length >= MIN_FIGURE_LINES && run.some((row) => row.kind === "line");
+
+/**
+ * テキストの図の範囲。最初の行の頭から最後の行の終わりまで（あいだの空行も入る）。source は LF でそろえたもの。
+ * skip は図と別に読む範囲（Markdown のコード・表・HTML・見出し）。その中の行は図の行に数えない。
+ */
+export const textFigures = (source: string, skip: readonly Span[] = []): Span[] =>
+  runsOf(rowsOf(source, skip))
+    .filter(isFigure)
+    .map((run) => ({ start: run[0]?.start ?? 0, end: run.at(-1)?.end ?? 0 }));
+
+/** Markdown が図と別に読む塊。この中の線は図として探さない（コードはもともと本文でなく、表の区切りの行は表、見出しは見出し）。 */
+const NOT_FIGURE = ["code", "table", "html", "heading"];
+
+/** Markdown の図。コード・表・HTML・見出しの外に描かれたものだけ。 */
+export const markdownFigures = (root: MarkdownNode, source: string): Span[] =>
+  textFigures(
+    source,
+    NOT_FIGURE.flatMap((type) => spansOfType(root, type)),
+  );

package/src/trailing-aside.ts

@@ -0,0 +1,50 @@
+/**
+ * 文末に添えた括弧（「最優先制約とする（§17）。」の（§17））を除いた、文そのものの終わり。
+ * 括弧が注記そのもの（文全体が括弧か、終わった文の後ろで「。）」と閉じる）なら、文末はその中にある。
+ * 述語に続く括弧は、中で文が終わっていても添え物（「費用（…を除く。）」）。続けて添えた括弧は全部除く。
+ *
+ * 後ろから一度だけ読む。法令の文は数千字あり、添えた括弧が何百も続くことがある。
+ */
+const OPEN = new Set(["(", "（"]);
+const CLOSE = new Set([")", "）"]);
+const STOPS = new Set(["。", "．", "！", "？", "!", "?"]);
+const LINE_BREAKS = new Set(["\n", "\r"]);
+const isSpace = (unit: string): boolean => /\s/u.test(unit);
+const isInlineSpace = (unit: string): boolean => unit === " " || unit === "\t" || unit === "　";
+
+/** before より前で、skip に当たらない最後の位置。無ければ -1。 */
+const lastBefore = (text: string, before: number, skip: (unit: string) => boolean): number => {
+  let index = before - 1;
+  while (index >= 0 && skip(text.charAt(index))) index -= 1;
+  return index;
+};
+
+/** closeAt の閉じ括弧と対になる開き括弧の位置。対が無ければ undefined。 */
+const openingOf = (text: string, closeAt: number): number | undefined => {
+  let depth = 0;
+  for (let index = closeAt - 1; index >= 0; index -= 1) {
+    const unit = text.charAt(index);
+    if (CLOSE.has(unit)) depth += 1;
+    else if (OPEN.has(unit) && depth === 0) return index;
+    else if (OPEN.has(unit)) depth -= 1;
+  }
+  return undefined;
+};
+
+/** open から closeAt までの括弧が注記そのもの: 文の頭にあるか、終わった文の後ろで、中の文が終わっている。 */
+const isNote = (text: string, open: number, closeAt: number): boolean => {
+  if (lastBefore(text, open, isSpace) === -1) return true;
+  const previous = text.charAt(lastBefore(text, open, isInlineSpace));
+  const inner = lastBefore(text, closeAt, isSpace);
+  return (STOPS.has(previous) || LINE_BREAKS.has(previous)) && inner > open && STOPS.has(text.charAt(inner));
+};
+
+export const ownEnd = (text: string): number => {
+  let limit = text.length;
+  for (;;) {
+    const closeAt = lastBefore(text, limit, (unit) => isSpace(unit) || STOPS.has(unit));
+    const open = CLOSE.has(text.charAt(closeAt)) ? openingOf(text, closeAt) : undefined;
+    if (open === undefined) return limit;
+    limit = isNote(text, open, closeAt) ? closeAt : open;
+  }
+};

package/src/tree-walk.ts

@@ -0,0 +1,48 @@
+/**
+ * Walks over the Markdown tree and the structure tree. Both keep their own stack instead of recursing:
+ * a blockquote nested ten thousand levels deep is valid Markdown, and one call per level overflows the call stack.
+ */
+
+type Branching<T> = { readonly children?: readonly T[] | undefined };
+
+/** Each node before its children, children from the left: the order a recursive walk visits them. */
+export const eachPreOrder = <T extends Branching<T>>(root: T, visit: (node: T) => void): void => {
+  const pending: T[] = [root];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (node === undefined) return;
+    visit(node);
+    (node.children ?? []).toReversed().forEach((child) => pending.push(child));
+  }
+};
+
+/** The nodes in pre-order. */
+export const preOrder = <T extends Branching<T>>(root: T): T[] => {
+  const nodes: T[] = [];
+  eachPreOrder(root, (node) => nodes.push(node));
+  return nodes;
+};
+
+type Frame<T, R> = { readonly node: T; readonly children: readonly T[]; readonly results: R[] };
+
+/**
+ * Each node's value from its children's values: children first, from the left, then the node. depth is 0 at the root.
+ * The same calls in the same order as `combine(node, childrenOf(node).map(recurse), depth)`.
+ */
+export const foldPostOrder = <T, R>(root: T, childrenOf: (node: T) => readonly T[], combine: (node: T, children: readonly R[], depth: number) => R): R => {
+  const frames: Frame<T, R>[] = [{ node: root, children: childrenOf(root), results: [] }];
+  for (;;) {
+    const frame = frames.at(-1);
+    if (frame === undefined) throw new Error("foldPostOrder lost its root");
+    const next = frame.children[frame.results.length];
+    if (next !== undefined) {
+      frames.push({ node: next, children: childrenOf(next), results: [] });
+      continue;
+    }
+    frames.pop();
+    const value = combine(frame.node, frame.results, frames.length);
+    const parent = frames.at(-1);
+    if (parent === undefined) return value;
+    parent.results.push(value);
+  }
+};

package/styles/bunkacho.yaml

@@ -0,0 +1,25 @@
+# 文化庁「外来語の表記」（平成 3 年内閣告示第 2 号）の長音の書き方。chaff.yaml に style: bunkacho と書くと使える。
+# JIS Z 8301:2019 も外来語の表記をこれによるとした。告示は「慣用に応じて「ー」を省くことができる」とも書くので、
+# 省いた語は、辞書が「ー」付きで知る語と、文書がほかで「ー」付きで書く語だけを見る（katakana-long-vowel の keep）。
+id: bunkacho
+
+name:
+  ja: 文化庁「外来語の表記」
+  en: The Agency for Cultural Affairs' 外来語の表記 (Cabinet notice, 1991)
+
+summary:
+  ja: 英語の語末の -er、-or、-ar などは、長音として「ー」を付けます（コンピューター、エレベーター）。
+  en: Writes the English endings -er, -or, -ar and the like as a long vowel with ー (コンピューター, エレベーター).
+
+source:
+  title:
+    ja: 外来語の表記（平成 3 年 6 月 28 日 内閣告示第 2 号）留意事項その 2（細則的な事項）Ⅲ 3 注 3
+    en: 外来語の表記 (Cabinet notice No. 2 of 28 June 1991), detailed notes (留意事項その2), III 3, note 3
+  url: https://www.bunka.go.jp/kokugo_nihongo/sisaku/joho/joho/kijun/naikaku/gairai/honbun06.html
+
+rules:
+  katakana-long-vowel: normal
+
+options:
+  katakana-long-vowel:
+    ending: keep

package/styles/ieice.yaml

@@ -0,0 +1,29 @@
+# 電子情報通信学会（IEICE）の和文論文誌の書き方。chaff.yaml に style: ieice と書くと使える。
+# ここに置くのは、案内が言っていることだけ。案内に無いことは足さない。
+#
+# 投稿のしおり 2.4 (b) は、用語を文部省「学術用語集 電気工学編」などによるとする。学術用語集のカタカナ語は、
+# 3 音以上の語の語末の「ー」を省く（コンピュータ、レーザ、プリンタ）。2 音以下の語（カー）は付ける。
+# 2.4 (d) は、句読点を全角の「．」「，」とする。句読点を見る rule が chaff にまだ無いので、ここでは決めない。
+id: ieice
+
+name:
+  ja: 電子情報通信学会 和文論文誌
+  en: IEICE Transactions (papers in Japanese)
+
+summary:
+  ja: 3 音以上のカタカナ語は語末の「ー」を省きます（コンピュータ、プリンタ）。2 音以下の語（カー）は付けます。
+  en: Drops the final ー of katakana words of three morae or more (コンピュータ, プリンタ) and keeps it on shorter words (カー).
+
+source:
+  title:
+    ja: 電子情報通信学会「和文論文誌 投稿のしおり」2.4 用字と用語について (b)。用語は文部省「学術用語集 電気工学編」による
+    en: IEICE, 和文論文誌 投稿のしおり (submission guide for papers in Japanese), 2.4 (b); terms follow 学術用語集 電気工学編
+  url: https://www.ieice.org/jpn/shiori/cs_2.html
+
+rules:
+  katakana-long-vowel: normal
+
+options:
+  katakana-long-vowel:
+    ending: drop
+    min_morae: 3

package/styles/jis-z8301-2011.yaml

@@ -0,0 +1,25 @@
+# JIS Z 8301:2011「規格票の様式及び作成方法」の外来語の書き方。chaff.yaml に style: jis-z8301-2011 と書くと使える。
+# 2019 年版はこの原則を外し、「外来語の表記」（平成 3 年内閣告示第 2 号）によるとした。2019 年版に合わせるなら style: bunkacho。
+id: jis-z8301-2011
+
+name:
+  ja: JIS Z 8301:2011 規格票の様式及び作成方法
+  en: JIS Z 8301:2011, rules for the structure and drafting of standards
+
+summary:
+  ja: 3 音以上の外来語は語末の「ー」を省き（コンピュータ）、2 音以下は付けます（カー）。2019 年版はこの原則を外しました。
+  en: Drops the final ー of loanwords of three morae or more (コンピュータ) and keeps it on shorter ones (カー). The 2019 edition dropped this principle.
+
+source:
+  title:
+    ja: JIS Z 8301:2011 附属書 G 表 G.3「外来語の表記に語尾の長音符号を省く場合の原則」
+    en: JIS Z 8301:2011 Annex G, Table G.3 (the principle for omitting the final long-vowel mark of loanwords)
+  url: https://www.jisc.go.jp/
+
+rules:
+  katakana-long-vowel: normal
+
+options:
+  katakana-long-vowel:
+    ending: drop
+    min_morae: 3