papilot 0.0.0-stage → 0.1.0

package/vendor/latex-review/src/render/pdf.ts

@@ -0,0 +1,281 @@
+import fs from "node:fs";
+import * as mupdf from "mupdf";
+import type { Rect } from "../types.ts";
+export { mupdf };
+export const union = (a: Rect, b: Rect): Rect => [
+  Math.min(a[0], b[0]),
+  Math.min(a[1], b[1]),
+  Math.max(a[2], b[2]),
+  Math.max(a[3], b[3]),
+];
+export const intersect = (a: Rect, b: Rect): Rect => [
+  Math.max(a[0], b[0]),
+  Math.max(a[1], b[1]),
+  Math.min(a[2], b[2]),
+  Math.min(a[3], b[3]),
+];
+export const intersects = (a: Rect, b: Rect) =>
+  a[0] < b[2] && a[2] > b[0] && a[1] < b[3] && a[3] > b[1];
+export const containsCenter = (a: Rect, b: Rect) =>
+  a[0] <= (b[0] + b[2]) / 2 &&
+  (b[0] + b[2]) / 2 <= a[2] &&
+  a[1] <= (b[1] + b[3]) / 2 &&
+  (b[1] + b[3]) / 2 <= a[3];
+export interface Character {
+  text: string;
+  rect: Rect;
+}
+export interface Word {
+  text: string;
+  rect: Rect;
+}
+export interface Line {
+  text: string;
+  rect: Rect;
+  chars: Character[];
+}
+export interface TextBlock {
+  text: string;
+  rect: Rect;
+  lines: Line[];
+}
+export interface OutlineEntry {
+  level: number;
+  title: string;
+  uri: string;
+  name: string;
+  page: number;
+  y: number;
+}
+export interface Raster {
+  width: number;
+  height: number;
+  channels: number;
+  stride: number;
+  pixels: Uint8Array;
+}
+export class PdfPage {
+  private columns?: boolean;
+  raw: mupdf.Page;
+  bounds: Rect;
+  blocks: TextBlock[] = [];
+  lines: Line[] = [];
+  words: Word[] = [];
+  label: string;
+  constructor(
+    document: mupdf.Document,
+    public number: number,
+  ) {
+    this.raw = document.loadPage(number);
+    this.bounds = this.raw.getBounds();
+    this.label = this.raw.getLabel() || String(number + 1);
+    const text = this.raw.toStructuredText(
+      "preserve-whitespace,preserve-ligatures",
+    );
+    let block: TextBlock, line: Line;
+    text.walk({
+      beginTextBlock: (rect) => {
+        block = { rect, text: "", lines: [] };
+        this.blocks.push(block);
+      },
+      beginLine: (rect) => {
+        line = { rect, text: "", chars: [] };
+        block.lines.push(line);
+        this.lines.push(line);
+      },
+      onChar: (c, _origin, _font, _size, quad) => {
+        const xs = [quad[0], quad[2], quad[4], quad[6]],
+          ys = [quad[1], quad[3], quad[5], quad[7]];
+        line.chars.push({
+          text: c,
+          rect: [
+            Math.min(...xs),
+            Math.min(...ys),
+            Math.max(...xs),
+            Math.max(...ys),
+          ],
+        });
+        line.text += c;
+      },
+      endLine: () => {
+        block.text += line.text + "\n";
+        let word: Word | null = null;
+        for (const char of line.chars) {
+          if (/\s/u.test(char.text)) word = null;
+          else if (word) {
+            word.text += char.text;
+            word.rect = union(word.rect, char.rect);
+          } else {
+            word = { text: char.text, rect: [...char.rect] };
+            this.words.push(word);
+          }
+        }
+      },
+    });
+    text.destroy();
+  }
+  get width() {
+    return this.bounds[2] - this.bounds[0];
+  }
+  get twoColumns() {
+    if (this.columns === undefined) {
+      const middle = this.bounds[0] + this.width / 2;
+      const prose = this.lines.filter(
+        (l) =>
+          l.text.trim().split(/\s+/).length >= 5 &&
+          l.rect[2] - l.rect[0] > this.width * 0.25,
+      );
+      const left = prose.filter((l) => l.rect[2] < middle),
+        right = prose.filter((l) => l.rect[0] > middle);
+      this.columns =
+        left.filter((a) =>
+          right.some(
+            (b) =>
+              Math.min(a.rect[3], b.rect[3]) - Math.max(a.rect[1], b.rect[1]) >
+              3,
+          ),
+        ).length >= 3;
+    }
+    return this.columns;
+  }
+  column(rect: Rect) {
+    if (!this.twoColumns) return -1;
+    const middle = this.bounds[0] + this.width / 2;
+    return rect[2] <= middle ? 0 : rect[0] >= middle ? 1 : -1;
+  }
+  columnBounds(column: number): [number, number] {
+    const middle = this.bounds[0] + this.width / 2;
+    return column === 0
+      ? [this.bounds[0], middle]
+      : column === 1
+        ? [middle, this.bounds[2]]
+        : [this.bounds[0], this.bounds[2]];
+  }
+  get height() {
+    return this.bounds[3] - this.bounds[1];
+  }
+  search(needle: string): Rect[] {
+    return this.raw
+      .search(needle, {})
+      .flat()
+      .map((q) => [
+        Math.min(q[0], q[2], q[4], q[6]),
+        Math.min(q[1], q[3], q[5], q[7]),
+        Math.max(q[0], q[2], q[4], q[6]),
+        Math.max(q[1], q[3], q[5], q[7]),
+      ]);
+  }
+  text(clip: Rect = this.bounds) {
+    return this.lines
+      .map((l) =>
+        l.chars
+          .filter((c) => containsCenter(clip, c.rect))
+          .map((c) => c.text)
+          .join(""),
+      )
+      .filter(Boolean)
+      .join("\n");
+  }
+  raster(clip: Rect, scale = 2, gray = false): Raster {
+    const matrix: mupdf.Matrix = [scale, 0, 0, scale, 0, 0],
+      rect: Rect = [
+        Math.floor(clip[0] * scale),
+        Math.floor(clip[1] * scale),
+        Math.ceil(clip[2] * scale),
+        Math.ceil(clip[3] * scale),
+      ],
+      pixmap = new mupdf.Pixmap(
+        gray ? mupdf.ColorSpace.DeviceGray : mupdf.ColorSpace.DeviceRGB,
+        rect,
+        false,
+      );
+    pixmap.clear(255);
+    const device = new mupdf.DrawDevice(mupdf.Matrix.identity, pixmap);
+    this.raw.run(device, matrix);
+    device.close();
+    device.destroy();
+    const result = {
+      width: pixmap.getWidth(),
+      height: pixmap.getHeight(),
+      channels: pixmap.getNumberOfComponents(),
+      stride: pixmap.getStride(),
+      pixels: new Uint8Array(pixmap.getPixels()),
+    };
+    pixmap.destroy();
+    return result;
+  }
+  svg(top: number, bottom: number) {
+    const buffer = new mupdf.Buffer(),
+      writer = new mupdf.DocumentWriter(buffer, "svg", "text=path"),
+      device = writer.beginPage([0, 0, this.width, bottom - top]);
+    this.raw.run(device, [1, 0, 0, 1, 0, -top]);
+    writer.endPage();
+    writer.close();
+    const svg = buffer.asString();
+    device.destroy();
+    writer.destroy();
+    buffer.destroy();
+    return svg;
+  }
+  close() {
+    this.raw.destroy();
+  }
+}
+export class PdfDocument {
+  raw: mupdf.Document;
+  private pages = new Map<number, PdfPage>();
+  outline: OutlineEntry[] = [];
+  constructor(input: string | Uint8Array) {
+    this.raw = mupdf.Document.openDocument(
+      typeof input === "string" ? fs.readFileSync(input) : input,
+      "application/pdf",
+    );
+    const walk = (
+      items: NonNullable<ReturnType<mupdf.Document["loadOutline"]>>,
+      level: number,
+    ) => {
+      for (const item of items) {
+        const uri = item.uri ?? "",
+          dest = this.destination(uri);
+        this.outline.push({
+          level,
+          title: item.title ?? "",
+          uri,
+          name:
+            new URLSearchParams(uri.replace(/^#/, "")).get("nameddest") ?? "",
+          page: dest?.page ?? item.page ?? -1,
+          y: dest?.y ?? 0,
+        });
+        if (item.down) walk(item.down, level + 1);
+      }
+    };
+    walk(this.raw.loadOutline() ?? [], 1);
+  }
+  get length() {
+    return this.raw.countPages();
+  }
+  page(number: number) {
+    if (!this.pages.has(number))
+      this.pages.set(number, new PdfPage(this.raw, number));
+    return this.pages.get(number)!;
+  }
+  destination(uri: string) {
+    if (!uri) return null;
+    try {
+      const dest = this.raw.resolveLinkDestination(uri);
+      return dest.page >= 0
+        ? {
+            page: dest.page,
+            y: Number.isFinite(dest.y) ? dest.y : 0,
+            x: Number.isFinite(dest.x) ? dest.x : 0,
+          }
+        : null;
+    } catch {
+      return null;
+    }
+  }
+  close() {
+    for (const page of this.pages.values()) page.close();
+    this.raw.destroy();
+  }
+}

package/vendor/latex-review/src/render/pdfdiff.ts

@@ -0,0 +1,272 @@
+import { opcodes } from "../core/diff.ts";
+import type { Mark, Position, Rect } from "../types.ts";
+import { containsCenter, PdfDocument, union, type Raster } from "./pdf.ts";
+export const normalize = (text: string) =>
+  text.normalize("NFKC").replaceAll("\u00ad", "");
+interface Glyph {
+  text: string;
+  rect: Rect;
+  pair: number;
+  page: number;
+  space: boolean;
+}
+interface Word {
+  text: string;
+  rect: Rect;
+  pair: number;
+  page: number;
+}
+export function extract(
+  document: PdfDocument,
+  positions: Position[],
+): [Glyph[], Word[]] {
+  const glyphs: Glyph[] = [],
+    words: Word[] = [];
+  positions.forEach((position, pair) => {
+    const page = document.page(position.page),
+      clip = position.clip;
+    for (const line of page.lines) {
+      let space = true;
+      for (const char of line.chars) {
+        if (!containsCenter(clip, char.rect)) {
+          space = true;
+          continue;
+        }
+        for (const value of normalize(char.text)) {
+          if (/\s/u.test(value)) space = true;
+          else {
+            glyphs.push({
+              text: value,
+              rect: char.rect,
+              space,
+              pair,
+              page: position.page,
+            });
+            space = false;
+          }
+        }
+      }
+    }
+    for (const word of page.words)
+      if (containsCenter(clip, word.rect))
+        words.push({
+          text: normalize(word.text),
+          rect: word.rect,
+          pair,
+          page: position.page,
+        });
+  });
+  for (let i = glyphs.length - 2; i > 0; i--) {
+    const a = glyphs[i - 1],
+      b = glyphs[i],
+      c = glyphs[i + 1];
+    if (
+      b.text === "-" &&
+      /\p{L}/u.test(a.text) &&
+      /\p{Ll}/u.test(c.text) &&
+      (b.pair !== c.pair || c.rect[1] > b.rect[1] + 3)
+    ) {
+      c.space = false;
+      glyphs.splice(i, 1);
+    }
+  }
+  return [glyphs, words];
+}
+function tokens(glyphs: Glyph[]) {
+  const result: { text: string; start: number; end: number }[] = [];
+  let previousWord = false;
+  glyphs.forEach((glyph, i) => {
+    const word = /[\p{L}\p{N}_]/u.test(glyph.text);
+    if (result.length && word && previousWord && !glyph.space) {
+      result.at(-1)!.text += glyph.text;
+      result.at(-1)!.end = i + 1;
+    } else result.push({ text: glyph.text, start: i, end: i + 1 });
+    previousWord = word;
+  });
+  return result;
+}
+export function mergeRects(rects: Rect[]): Rect[] {
+  const result: Rect[] = [];
+  for (const rect of [...rects].sort(
+    (a, b) => Math.round(a[1] / 2) - Math.round(b[1] / 2) || a[0] - b[0],
+  )) {
+    let merged = false;
+    for (let i = result.length - 1; i >= Math.max(0, result.length - 12); i--) {
+      const previous = result[i];
+      if (
+        Math.abs(previous[1] - rect[1]) < 1.7 &&
+        Math.abs(previous[3] - rect[3]) < 2 &&
+        rect[0] - previous[2] >= -1 &&
+        rect[0] - previous[2] < 4
+      ) {
+        result[i] = union(previous, rect);
+        merged = true;
+        break;
+      }
+    }
+    if (!merged) result.push([...rect]);
+  }
+  return result;
+}
+function marks(
+  glyphs: Glyph[],
+  indices: number[],
+  words: Word[],
+  kind: Mark["kind"],
+): Record<number, Mark[]> {
+  const selected = new Map<number, Rect[]>();
+  for (const i of new Set(indices)) {
+    const g = glyphs[i];
+    if (!selected.has(g.pair)) selected.set(g.pair, []);
+    selected.get(g.pair)!.push(g.rect);
+  }
+  return Object.fromEntries(
+    [...selected].map(([pair, rects]) => {
+      const boxes = words
+        .filter(
+          (w) =>
+            w.pair === pair && rects.some((r) => containsCenter(w.rect, r)),
+        )
+        .map((w) => w.rect);
+      return [
+        pair,
+        mergeRects(boxes.length ? boxes : rects).map((rect) => ({
+          kind,
+          rect,
+        })),
+      ];
+    }),
+  );
+}
+export function joined(words: Word[]) {
+  const result: string[] = [];
+  let previous: Word | null = null;
+  for (const word of words) {
+    const last = result.at(-1) ?? "";
+    if (
+      previous &&
+      /\p{L}-$/u.test(last) &&
+      /^\p{Ll}/u.test(word.text) &&
+      (word.pair !== previous.pair || word.rect[1] > previous.rect[3] - 2)
+    )
+      result[result.length - 1] = last.slice(0, -1) + word.text;
+    else result.push(word.text);
+    previous = word;
+  }
+  return result;
+}
+export function textChanges(
+  oldDocument: PdfDocument | null,
+  newDocument: PdfDocument | null,
+  left: Position[],
+  right: Position[],
+) {
+  const [a, aw] = left.length
+      ? extract(oldDocument!, left)
+      : ([[], []] as [Glyph[], Word[]]),
+    [b, bw] = right.length
+      ? extract(newDocument!, right)
+      : ([[], []] as [Glyph[], Word[]]),
+    at = tokens(a),
+    bt = tokens(b);
+  const removed: number[] = [],
+    added: number[] = [],
+    movedA: number[] = [],
+    movedB: number[] = [];
+  const indices = (t: ReturnType<typeof tokens>, i: number, j: number) =>
+    t
+      .slice(i, j)
+      .flatMap((t) =>
+        Array.from({ length: t.end - t.start }, (_, k) => t.start + k),
+      );
+  for (const [tag, i, j, x, y] of opcodes(
+    at.map((t) => t.text),
+    bt.map((t) => t.text),
+  )) {
+    const ai = indices(at, i, j),
+      bi = indices(bt, x, y);
+    if (tag !== "equal") {
+      removed.push(...ai);
+      added.push(...bi);
+      continue;
+    }
+    ai.forEach((u, index) => {
+      const v = bi[index],
+        old = a[u],
+        next = b[v],
+        p = left[old.pair],
+        q = right[next.pair],
+        r = old.rect,
+        s = next.rect;
+      if (
+        old.pair !== next.pair ||
+        [
+          r[0] - p.clip[0] - s[0] + q.clip[0],
+          r[1] - p.clip[1] - s[1] + q.clip[1],
+          r[2] - r[0] - s[2] + s[0],
+          r[3] - r[1] - s[3] + s[1],
+        ].some((d) => Math.abs(d) > 0.65)
+      ) {
+        movedA.push(u);
+        movedB.push(v);
+      }
+    });
+  }
+  const changed = Boolean(removed.length || added.length),
+    oldWords = joined(aw),
+    newWords = joined(bw),
+    edits = changed
+      ? opcodes(oldWords, newWords)
+          .filter((o) => o[0] !== "equal")
+          .map(([, i, j, x, y]) => {
+            const old = oldWords.slice(i, j).join(" "),
+              next = newWords.slice(x, y).join(" ");
+            return {
+              old: old.slice(0, 180),
+              new: next.slice(0, 180),
+              truncated: old.length > 180 || next.length > 180,
+            };
+          })
+      : [];
+  return {
+    old_marks: marks(
+      a,
+      changed ? removed : movedA,
+      aw,
+      changed ? "removed" : "moved",
+    ),
+    new_marks: marks(
+      b,
+      changed ? added : movedB,
+      bw,
+      changed ? "added" : "moved",
+    ),
+    text_changed: changed,
+    moved: Boolean(movedA.length || movedB.length),
+    text_available: Boolean(a.length || b.length),
+    edits,
+  };
+}
+export function pixelDifference(old: Raster | null, next: Raster | null) {
+  const width = Math.max(old?.width ?? 0, next?.width ?? 0),
+    height = Math.max(old?.height ?? 0, next?.height ?? 0);
+  let count = 0;
+  for (let y = 0; y < height; y++)
+    for (let x = 0; x < width; x++) {
+      let difference = 0;
+      for (let c = 0; c < 3; c++) {
+        const value = (image: Raster | null) =>
+          image && x < image.width && y < image.height
+            ? image.pixels[
+                y * image.stride +
+                  x * image.channels +
+                  Math.min(c, image.channels - 1)
+              ]
+            : 255;
+        difference +=
+          Math.abs(value(old) - value(next)) * [0.299, 0.587, 0.114][c];
+      }
+      if (difference >= 24) count++;
+    }
+  return count;
+}