glossarist 0.4.50 → 0.4.52

package/src/diff/index.d.ts

@@ -1,242 +0,0 @@
-import type { GlossaristModel } from '../models/base';
-
-// ── Text diff ──────────────────────────────────────────────────────────
-
-export type HunkType = 'equal' | 'added' | 'removed';
-
-export class TextHunk extends GlossaristModel {
-  readonly type: HunkType;
-  readonly text: string;
-  toJSON(): { type: HunkType; text: string };
-  static fromJSON(data: { type: HunkType; text: string }): TextHunk;
-}
-
-export class TextDiff extends GlossaristModel {
-  readonly oldText: string;
-  readonly newText: string;
-  readonly hunks: TextHunk[];
-  readonly hasChanges: boolean;
-  readonly addedText: string;
-  readonly removedText: string;
-  toJSON(): { old_text: string; new_text: string; hunks: Array<{ type: HunkType; text: string }> };
-  static fromJSON(data: Record<string, unknown>): TextDiff;
-}
-
-export function diffText(oldText: string | null | undefined, newText: string | null | undefined): TextDiff;
-
-// ── Change types ───────────────────────────────────────────────────────
-
-export const CHANGE_ADDED: 'added';
-export const CHANGE_REMOVED: 'removed';
-export const CHANGE_CHANGED: 'changed';
-export const CHANGE_MATCHED: 'matched';
-
-export type ChangeType =
-  | typeof CHANGE_ADDED
-  | typeof CHANGE_REMOVED
-  | typeof CHANGE_CHANGED
-  | typeof CHANGE_MATCHED;
-
-export class Change extends GlossaristModel {
-  readonly type: ChangeType;
-  readonly path: string | null;
-}
-
-export class Added extends Change {
-  readonly type: 'added';
-  readonly value: unknown;
-  toJSON(): { type: 'added'; path?: string; value: unknown };
-  static fromJSON(data: Record<string, unknown>): Added;
-}
-
-export class Removed extends Change {
-  readonly type: 'removed';
-  readonly value: unknown;
-  toJSON(): { type: 'removed'; path?: string; value: unknown };
-  static fromJSON(data: Record<string, unknown>): Removed;
-}
-
-export class Changed extends Change {
-  readonly type: 'changed';
-  readonly oldValue: unknown;
-  readonly newValue: unknown;
-  readonly textDiff: TextDiff | null;
-  toJSON(): {
-    type: 'changed';
-    path?: string;
-    old_value: unknown;
-    new_value: unknown;
-    text_diff?: ReturnType<TextDiff['toJSON']>;
-  };
-  static fromJSON(data: Record<string, unknown>): Changed;
-}
-
-export class Matched extends Change {
-  readonly type: 'matched';
-  readonly value: unknown;
-  toJSON(): { type: 'matched'; path?: string; value: unknown };
-  static fromJSON(data: Record<string, unknown>): Matched;
-}
-
-export function deserializeChange(data: Record<string, unknown>): Change;
-
-// ── List diff ──────────────────────────────────────────────────────────
-
-export interface DiffListOptions {
-  identityKey?: (item: any) => string;
-  textKey?: (item: any) => string | null;
-}
-
-export class ListDiff extends GlossaristModel {
-  readonly added: Added[];
-  readonly removed: Removed[];
-  readonly changed: Changed[];
-  readonly hasChanges: boolean;
-  readonly count: number;
-  entries(): Generator<Change, void, unknown>;
-  toJSON(): {
-    added: ReturnType<Added['toJSON']>[];
-    removed: ReturnType<Removed['toJSON']>[];
-    changed: ReturnType<Changed['toJSON']>[];
-  };
-  static fromJSON(data: Record<string, unknown>): ListDiff;
-}
-
-export function diffList(oldList: unknown[], newList: unknown[], options?: DiffListOptions): ListDiff;
-export function diffSet(oldList: unknown[], newList: unknown[], options: DiffListOptions): ListDiff;
-
-// ── Concept diff ───────────────────────────────────────────────────────
-
-export interface DiffWalkEntry {
-  path: string;
-  change: Change;
-}
-
-export interface ConceptDiffWalkEntry extends DiffWalkEntry {
-  language: string;
-}
-
-export class DiffStats extends GlossaristModel {
-  readonly added: number;
-  readonly removed: number;
-  readonly changed: number;
-  readonly total: number;
-  toJSON(): { added: number; removed: number; changed: number };
-  static fromJSON(data: Record<string, unknown>): DiffStats;
-}
-
-export class MetadataDiff extends GlossaristModel {
-  readonly changes: Record<string, Changed>;
-  readonly hasChanges: boolean;
-  readonly count: number;
-  walk(section?: string): Generator<DiffWalkEntry, void, unknown>;
-  toJSON(): Record<string, ReturnType<Changed['toJSON']>>;
-  static fromJSON(data: Record<string, unknown>): MetadataDiff;
-}
-
-export class ConceptLevelDiff extends GlossaristModel {
-  readonly sources: ListDiff;
-  readonly dates: ListDiff;
-  readonly relatedConcepts: ListDiff;
-  readonly partitiveHyperedges: ListDiff;
-  readonly groups: ListDiff;
-  readonly sections: ListDiff;
-  readonly tags: ListDiff;
-  readonly metadata: MetadataDiff;
-  readonly hasChanges: boolean;
-  walk(): Generator<DiffWalkEntry, void, unknown>;
-  toJSON(): Record<string, unknown>;
-  static fromJSON(data: Record<string, unknown>): ConceptLevelDiff;
-}
-
-export class LocalizedConceptDiff extends GlossaristModel {
-  readonly languageCode: string | null;
-  readonly designations: ListDiff;
-  readonly definitions: ListDiff;
-  readonly notes: ListDiff;
-  readonly examples: ListDiff;
-  readonly sources: ListDiff;
-  readonly dates: ListDiff;
-  readonly related: ListDiff;
-  readonly metadata: MetadataDiff;
-  readonly hasChanges: boolean;
-  readonly stats: DiffStats;
-  readonly similarity: number;
-  readonly totalItems: number;
-  walk(prefix?: string): Generator<DiffWalkEntry, void, unknown>;
-  toJSON(): Record<string, unknown>;
-  static fromJSON(data: Record<string, unknown>): LocalizedConceptDiff;
-}
-
-export class ConceptDiff extends GlossaristModel {
-  readonly oldId: string | null;
-  readonly newId: string | null;
-  readonly concept: ConceptLevelDiff;
-  readonly languages: ListDiff;
-  readonly localizations: Record<string, LocalizedConceptDiff>;
-  readonly hasChanges: boolean;
-  readonly localizationLanguages: string[];
-  readonly stats: DiffStats;
-  readonly similarity: number;
-  readonly totalItems: number;
-  localization(lang: string): LocalizedConceptDiff | null;
-  walk(): Generator<ConceptDiffWalkEntry, void, unknown>;
-  toJSON(): Record<string, unknown>;
-  static fromJSON(data: Record<string, unknown>): ConceptDiff;
-}
-
-export function diffConcepts(
-  oldConcept: any | null,
-  newConcept: any | null,
-  language?: string,
-): ConceptDiff;
-
-export function diffLocalizedConcepts(
-  oldLoc: any | null,
-  newLoc: any | null,
-): LocalizedConceptDiff;
-
-// ── Collection diff ────────────────────────────────────────────────────
-
-export class ConceptCollectionDiff extends GlossaristModel {
-  readonly oldCount: number;
-  readonly newCount: number;
-  readonly matched: Matched[];
-  readonly added: Added[];
-  readonly removed: Removed[];
-  readonly conceptDiffs: Record<string, ConceptDiff>;
-  readonly changedIds: string[];
-  readonly hasChanges: boolean;
-  readonly stats: DiffStats;
-  readonly similarity: number;
-  conceptDiff(id: string): ConceptDiff | null;
-  walk(): Generator<ConceptDiffWalkEntry, void, unknown>;
-  toJSON(): Record<string, unknown>;
-  static fromJSON(data: Record<string, unknown>): ConceptCollectionDiff;
-}
-
-export function diffConceptCollections(
-  oldCollection: any | null,
-  newCollection: any | null,
-  options?: { language?: string; skipUnchanged?: boolean },
-): ConceptCollectionDiff;
-
-// ── Rendering ──────────────────────────────────────────────────────────
-
-export interface RenderOptions {
-  colors?: boolean;
-  showUnchanged?: boolean;
-}
-
-export function renderConceptDiff(diff: ConceptDiff, options?: RenderOptions): string;
-export function renderCollectionDiff(diff: ConceptCollectionDiff, options?: RenderOptions): string;
-export function renderTextDiff(textDiff: TextDiff | Record<string, unknown>, options?: RenderOptions): string;
-
-// ── Patching ───────────────────────────────────────────────────────────
-
-export function applyDiff<T extends { toJSON(): Record<string, unknown> }>(
-  oldConcept: T,
-  diff: ConceptDiff,
-): T;
-
-export function reverseDiff(diff: ConceptDiff): ConceptDiff;

package/src/diff/index.ts

@@ -1,50 +0,0 @@
-export {
-  TextHunk,
-  TextDiff,
-  diffText,
-} from './text-diff.js';
-
-export {
-  Change,
-  Added,
-  Removed,
-  Changed,
-  Matched,
-  CHANGE_ADDED,
-  CHANGE_REMOVED,
-  CHANGE_CHANGED,
-  CHANGE_MATCHED,
-  deserializeChange,
-} from './change.js';
-
-export {
-  ListDiff,
-  diffList,
-  diffSet,
-} from './list-diff.js';
-
-export {
-  DiffStats,
-  MetadataDiff,
-  ConceptLevelDiff,
-  LocalizedConceptDiff,
-  ConceptDiff,
-  diffConcepts,
-  diffLocalizedConcepts,
-} from './concept-diff.js';
-
-export {
-  ConceptCollectionDiff,
-  diffConceptCollections,
-} from './collection-diff.js';
-
-export {
-  renderConceptDiff,
-  renderCollectionDiff,
-  renderTextDiff,
-} from './diff-renderer.js';
-
-export {
-  applyDiff,
-  reverseDiff,
-} from './diff-patch.js';

package/src/diff/list-diff.ts

@@ -1,231 +0,0 @@
-import { GlossaristModel } from '../models/base.js';
-import { Added, Removed, Changed, deserializeChange } from './change.js';
-import type { ChangeJson, ChangedConstructorData } from './change.js';
-import { diffText } from './text-diff.js';
-import { identityOf } from './identity.js';
-
-export interface ListDiffJson {
-  added?: ReadonlyArray<ChangeJson | Added>;
-  removed?: ReadonlyArray<ChangeJson | Removed>;
-  changed?: ReadonlyArray<ChangeJson | Changed>;
-}
-
-interface ListDiffOptions {
-  identityKey?: (item: unknown) => string;
-  textKey?: ((item: unknown) => string | null) | null;
-}
-
-export class ListDiff extends GlossaristModel {
-  private readonly _added: ReadonlyArray<Added>;
-  private readonly _removed: ReadonlyArray<Removed>;
-  private readonly _changed: ReadonlyArray<Changed>;
-
-  constructor(data: ListDiffJson = {}) {
-    super();
-    this._added = (data.added ?? []).map((c) =>
-      c instanceof Added ? c : Added.fromJSON(c),
-    ) as ReadonlyArray<Added>;
-    this._removed = (data.removed ?? []).map((c) =>
-      c instanceof Removed ? c : Removed.fromJSON(c),
-    ) as ReadonlyArray<Removed>;
-    this._changed = (data.changed ?? []).map((c) => {
-      if (c instanceof Changed) return c;
-      return deserializeChange(c) as Changed;
-    }) as ReadonlyArray<Changed>;
-  }
-
-  get added(): ReadonlyArray<Added> { return this._added; }
-  get removed(): ReadonlyArray<Removed> { return this._removed; }
-  get changed(): ReadonlyArray<Changed> { return this._changed; }
-
-  get hasChanges(): boolean {
-    return this._added.length > 0 || this._removed.length > 0 || this._changed.length > 0;
-  }
-
-  get count(): number {
-    return this._added.length + this._removed.length + this._changed.length;
-  }
-
-  *entries(): Generator<Added | Removed | Changed> {
-    yield* this._added;
-    yield* this._removed;
-    yield* this._changed;
-  }
-
-  override toJSON(): ListDiffJson {
-    return {
-      added: this._added.map((c) => c.toJSON()),
-      removed: this._removed.map((c) => c.toJSON()),
-      changed: this._changed.map((c) => c.toJSON()),
-    };
-  }
-
-  static override fromJSON(data: ListDiffJson): ListDiff {
-    return new ListDiff(data);
-  }
-}
-
-/**
- * Diff two ordered lists using LCS alignment.
- */
-export function diffList(
-  oldList: ReadonlyArray<unknown> = [],
-  newList: ReadonlyArray<unknown> = [],
-  options: ListDiffOptions = {},
-): ListDiff {
-  const identityKey = options.identityKey ?? defaultIdentityKey;
-  const textKey = options.textKey ?? null;
-
-  const oldArr = [...oldList];
-  const newArr = [...newList];
-
-  const oldKeys = oldArr.map(identityKey);
-  const newKeys = newArr.map(identityKey);
-
-  const dp = lcsTable(oldKeys, newKeys);
-  const ops = backtrackOps(dp, oldKeys, newKeys);
-
-  const added: Added[] = [];
-  const removed: Removed[] = [];
-  const changed: Changed[] = [];
-
-  for (let k = 0; k < ops.length; k++) {
-    const op = ops[k]!;
-    if (op.type === 'equal') continue;
-
-    if (op.type === 'remove' && k + 1 < ops.length && ops[k + 1]!.type === 'add') {
-      const next = ops[k + 1]!;
-      changed.push(buildChanged(oldArr[op.i]!, newArr[next.j]!, textKey));
-      k++;
-    } else if (op.type === 'add' && k + 1 < ops.length && ops[k + 1]!.type === 'remove') {
-      const next = ops[k + 1]!;
-      changed.push(buildChanged(oldArr[next.i]!, newArr[op.j]!, textKey));
-      k++;
-    } else if (op.type === 'remove') {
-      removed.push(new Removed({ value: oldArr[op.i] }));
-    } else if (op.type === 'add') {
-      added.push(new Added({ value: newArr[op.j] }));
-    }
-  }
-
-  return new ListDiff({ added, removed, changed });
-}
-
-/**
- * Diff two unordered collections by identity key (set-based).
- */
-export function diffSet(
-  oldList: ReadonlyArray<unknown> = [],
-  newList: ReadonlyArray<unknown> = [],
-  options: ListDiffOptions = {},
-): ListDiff {
-  const identityKey = options.identityKey ?? defaultIdentityKey;
-  const textKey = options.textKey ?? null;
-
-  const oldMap = new Map<string, unknown>();
-  for (const item of oldList) {
-    oldMap.set(identityKey(item), item);
-  }
-
-  const seenKeys = new Set<string>();
-  const added: Added[] = [];
-  const changed: Changed[] = [];
-
-  for (const item of newList) {
-    const key = identityKey(item);
-    seenKeys.add(key);
-    if (oldMap.has(key)) {
-      const oldItem = oldMap.get(key);
-      if (oldItem !== undefined && !itemsEqual(oldItem, item)) {
-        changed.push(buildChanged(oldItem, item, textKey));
-      }
-    } else {
-      added.push(new Added({ value: item }));
-    }
-  }
-
-  const removed: Removed[] = [];
-  for (const item of oldList) {
-    if (!seenKeys.has(identityKey(item))) {
-      removed.push(new Removed({ value: item }));
-    }
-  }
-
-  return new ListDiff({ added, removed, changed });
-}
-
-function buildChanged(
-  oldItem: unknown,
-  newItem: unknown,
-  textKey: ((item: unknown) => string | null) | null,
-): Changed {
-  const opts: ChangedConstructorData = {
-    oldValue: oldItem,
-    newValue: newItem,
-  };
-  if (textKey) {
-    const oldText = textKey(oldItem);
-    const newText = textKey(newItem);
-    if (oldText != null || newText != null) {
-      opts.textDiff = diffText(oldText ?? '', newText ?? '');
-    }
-  }
-  return new Changed(opts);
-}
-
-function itemsEqual(a: unknown, b: unknown): boolean {
-  if (a === b) return true;
-  if (a instanceof GlossaristModel && b instanceof GlossaristModel) {
-    return a.equals(b as never);
-  }
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-
-function defaultIdentityKey(item: unknown): string {
-  return identityOf(item);
-}
-
-type Op = { type: 'equal' | 'add' | 'remove'; i: number; j: number };
-
-function lcsTable(aKeys: string[], bKeys: string[]): Uint32Array[] {
-  const m = aKeys.length;
-  const n = bKeys.length;
-  const dp = Array.from({ length: m + 1 }, () => new Uint32Array(n + 1));
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      dp[i]![j]! =
-        aKeys[i - 1] === bKeys[j - 1]
-          ? dp[i - 1]![j - 1]! + 1
-          : Math.max(dp[i - 1]![j]!, dp[i]![j - 1]!);
-    }
-  }
-  return dp;
-}
-
-function backtrackOps(dp: Uint32Array[], aKeys: string[], bKeys: string[]): Op[] {
-  const ops: Op[] = [];
-  let i = aKeys.length;
-  let j = bKeys.length;
-  while (i > 0 && j > 0) {
-    if (aKeys[i - 1] === bKeys[j - 1]) {
-      ops.push({ type: 'equal', i: i - 1, j: j - 1 });
-      i--; j--;
-    } else if ((dp[i - 1]![j] ?? 0) >= (dp[i]![j - 1] ?? 0)) {
-      ops.push({ type: 'remove', i: i - 1, j });
-      i--;
-    } else {
-      ops.push({ type: 'add', i, j: j - 1 });
-      j--;
-    }
-  }
-  while (i > 0) {
-    ops.push({ type: 'remove', i: i - 1, j });
-    i--;
-  }
-  while (j > 0) {
-    ops.push({ type: 'add', i, j: j - 1 });
-    j--;
-  }
-  ops.reverse();
-  return ops;
-}

package/src/diff/similarity.ts

@@ -1,20 +0,0 @@
-// Similarity scoring for the diff layer.
-//
-// `computeSimilarity(changeCount, totalItems)` returns a value in
-// [0, 1] rounded to SIMILARITY_PRECISION_DECIMALS decimal places. The
-// rounding matches what glossarist-ruby's diff layer produces.
-
-export const SIMILARITY_PRECISION_DECIMALS = 4;
-const _SCALE = 10 ** SIMILARITY_PRECISION_DECIMALS;
-
-export function computeSimilarity(changeCount: number, totalItems: number): number {
-  if (totalItems <= 0) return 1.0;
-  const ratio = Math.min(changeCount / totalItems, 1);
-  return Math.round((1 - ratio) * _SCALE) / _SCALE;
-}
-
-export function averageSimilarity(values: ReadonlyArray<number>): number {
-  if (values.length === 0) return 1.0;
-  const sum = values.reduce((a, b) => a + b, 0);
-  return Math.round((sum / values.length) * _SCALE) / _SCALE;
-}

package/src/diff/text-diff.ts

@@ -1,167 +0,0 @@
-import { GlossaristModel } from '../models/base.js';
-
-const HUNK_EQUAL = 'equal';
-const HUNK_ADDED = 'added';
-const HUNK_REMOVED = 'removed';
-
-export type TextHunkType = typeof HUNK_EQUAL | typeof HUNK_ADDED | typeof HUNK_REMOVED;
-
-const TOKEN_RE = /(\s+)|(\S+)/g;
-
-export interface TextHunkJson {
-  type: TextHunkType;
-  text: string;
-}
-
-export class TextHunk extends GlossaristModel {
-  readonly type: TextHunkType;
-  readonly text: string;
-
-  constructor(data: TextHunkJson = { type: HUNK_EQUAL, text: '' }) {
-    super();
-    if (![HUNK_EQUAL, HUNK_ADDED, HUNK_REMOVED].includes(data.type)) {
-      throw new Error(`TextHunk type must be 'equal', 'added', or 'removed' (got ${data.type})`);
-    }
-    this.type = data.type;
-    this.text = data.text ?? '';
-  }
-
-  override toJSON(): TextHunkJson {
-    return { type: this.type, text: this.text };
-  }
-
-  static override fromJSON(data: TextHunkJson): TextHunk {
-    return new TextHunk(data);
-  }
-}
-
-export interface TextDiffJson {
-  oldText?: string;
-  old_text?: string;
-  newText?: string;
-  new_text?: string;
-  hunks?: ReadonlyArray<TextHunkJson | TextHunk>;
-}
-
-export class TextDiff extends GlossaristModel {
-  readonly oldText: string;
-  readonly newText: string;
-  private readonly _hunks: ReadonlyArray<TextHunk>;
-
-  constructor(data: TextDiffJson = {}) {
-    super();
-    this.oldText = data.oldText ?? data.old_text ?? '';
-    this.newText = data.newText ?? data.new_text ?? '';
-    this._hunks = (data.hunks ?? []).map((h) =>
-      h instanceof TextHunk ? h : new TextHunk(h),
-    );
-  }
-
-  get hunks(): ReadonlyArray<TextHunk> {
-    return this._hunks;
-  }
-
-  get hasChanges(): boolean {
-    return this._hunks.some((h) => h.type !== HUNK_EQUAL);
-  }
-
-  get addedText(): string {
-    return this._hunks
-      .filter((h) => h.type === HUNK_ADDED)
-      .map((h) => h.text)
-      .join('');
-  }
-
-  get removedText(): string {
-    return this._hunks
-      .filter((h) => h.type === HUNK_REMOVED)
-      .map((h) => h.text)
-      .join('');
-  }
-
-  override toJSON(): TextDiffJson & { old_text: string; new_text: string; hunks: ReadonlyArray<TextHunkJson> } {
-    return {
-      old_text: this.oldText,
-      new_text: this.newText,
-      hunks: this._hunks.map((h) => h.toJSON()),
-    };
-  }
-
-  static override fromJSON(data: TextDiffJson): TextDiff {
-    return new TextDiff(data);
-  }
-}
-
-export function diffText(oldText: string | null | undefined, newText: string | null | undefined): TextDiff {
-  const oldStr = String(oldText ?? '');
-  const newStr = String(newText ?? '');
-  const oldTokens = tokenize(oldStr);
-  const newTokens = tokenize(newStr);
-  const hunks = lcsHunks(oldTokens, newTokens);
-  return new TextDiff({ oldText: oldStr, newText: newStr, hunks });
-}
-
-function tokenize(text: string): string[] {
-  if (text.length === 0) return [];
-  return text.match(TOKEN_RE) ?? [];
-}
-
-function lcsHunks(a: string[], b: string[]): TextHunk[] {
-  const n = a.length;
-  const m = b.length;
-
-  if (n === 0) return m === 0 ? [] : [new TextHunk({ type: HUNK_ADDED, text: b.join('') })];
-  if (m === 0) return [new TextHunk({ type: HUNK_REMOVED, text: a.join('') })];
-
-  const dp = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
-  for (let i = 1; i <= n; i++) {
-    for (let j = 1; j <= m; j++) {
-      dp[i]![j]! =
-        a[i - 1] === b[j - 1]
-          ? dp[i - 1]![j - 1]! + 1
-          : Math.max(dp[i - 1]![j]!, dp[i]![j - 1]!);
-    }
-  }
-
-  const raw: Array<{ type: TextHunkType; text: string }> = [];
-  let i = n;
-  let j = m;
-  while (i > 0 && j > 0) {
-    if (a[i - 1] === b[j - 1]) {
-      raw.push({ type: HUNK_EQUAL, text: a[i - 1]! });
-      i--; j--;
-    } else if ((dp[i - 1]![j] ?? 0) >= (dp[i]![j - 1] ?? 0)) {
-      raw.push({ type: HUNK_REMOVED, text: a[i - 1]! });
-      i--;
-    } else {
-      raw.push({ type: HUNK_ADDED, text: b[j - 1]! });
-      j--;
-    }
-  }
-  while (i > 0) {
-    raw.push({ type: HUNK_REMOVED, text: a[i - 1]! });
-    i--;
-  }
-  while (j > 0) {
-    raw.push({ type: HUNK_ADDED, text: b[j - 1]! });
-    j--;
-  }
-  raw.reverse();
-
-  return coalesce(raw).map((h) => new TextHunk(h));
-}
-
-function coalesce(
-  raw: ReadonlyArray<{ type: TextHunkType; text: string }>,
-): Array<{ type: TextHunkType; text: string }> {
-  const out: Array<{ type: TextHunkType; text: string }> = [];
-  for (const r of raw) {
-    const last = out[out.length - 1];
-    if (last && last.type === r.type) {
-      last.text += r.text;
-    } else {
-      out.push({ type: r.type, text: r.text });
-    }
-  }
-  return out;
-}