pagyra-js 0.0.1

package/src/pdf/font/simple-glyph-parser.ts

@@ -0,0 +1,289 @@
+import type { GlyphOutlineCmd } from "../../types/fonts.js";
+import type { DataViewReader } from "./ttf-table-provider.js";
+
+/**
+ * Represents a point in a glyph contour.
+ */
+interface Point {
+    x: number;
+    y: number;
+    onCurve: boolean;
+}
+
+/**
+ * Parses simple (non-composite) TrueType glyphs.
+ * 
+ * Simple glyphs consist of one or more contours made up of on-curve and off-curve points.
+ * Off-curve points are quadratic Bezier control points.
+ */
+export class SimpleGlyphParser {
+    constructor(private readonly reader: DataViewReader) { }
+
+    /**
+     * Parses a simple glyph from a DataView.
+     * @param view - DataView containing the glyph data starting at the glyph header
+     * @returns Array of glyph outline commands, or null if parsing fails
+     */
+    parse(view: DataView): GlyphOutlineCmd[] | null {
+        const contours = this.parseContours(view);
+        if (!contours) return null;
+
+        return this.buildOutlineCommands(contours);
+    }
+
+    /**
+     * Parses glyph contours from the DataView.
+     * @param view - DataView containing the glyph data
+     * @returns Array of contours (each contour is an array of points), or null if parsing fails
+     */
+    private parseContours(view: DataView): Point[][] | null {
+        if (view.byteLength < 10) return null;
+
+        // Read glyph header
+        const numberOfContours = view.getInt16(0, false);
+        if (numberOfContours < 0) return null; // Composite glyph, shouldn't happen here
+
+        // Read endPtsOfContours array
+        const endPtsOffset = 10;
+        const endPts: number[] = [];
+        for (let i = 0; i < numberOfContours; i++) {
+            if (endPtsOffset + i * 2 + 2 > view.byteLength) return null;
+            endPts.push(this.reader.getUint16(view, endPtsOffset + i * 2));
+        }
+
+        // Read instruction length and skip instructions
+        const instrLenOffset = endPtsOffset + numberOfContours * 2;
+        if (instrLenOffset + 2 > view.byteLength) return null;
+        const instructionLength = this.reader.getUint16(view, instrLenOffset);
+        const flagsOffset = instrLenOffset + 2 + instructionLength;
+        if (flagsOffset > view.byteLength) return null;
+
+        // Calculate number of points
+        const nPoints = endPts.length === 0 ? 0 : endPts[endPts.length - 1] + 1;
+        if (nPoints <= 0) return [];
+
+        // Parse flags
+        const flagsResult = this.parseFlags(view, nPoints, flagsOffset);
+        if (!flagsResult) return null;
+        const { flags, nextOffset: xCoordOffset } = flagsResult;
+
+        // Parse coordinates
+        const coordsResult = this.parseCoordinates(view, flags, xCoordOffset);
+        if (!coordsResult) return null;
+        const { points } = coordsResult;
+
+        // Split points into contours
+        const contours: Point[][] = [];
+        let startIndex = 0;
+        for (let c = 0; c < numberOfContours; c++) {
+            const endIndex = endPts[c];
+            if (endIndex < startIndex || endIndex >= points.length) return null;
+            contours.push(points.slice(startIndex, endIndex + 1));
+            startIndex = endIndex + 1;
+        }
+
+        return contours;
+    }
+
+    /**
+     * Parses glyph flags with run-length encoding.
+     * @param view - DataView containing the glyph data
+     * @param nPoints - Number of points to read
+     * @param offset - Starting offset for flags
+     * @returns Flags array and next offset, or null if parsing fails
+     */
+    private parseFlags(
+        view: DataView,
+        nPoints: number,
+        offset: number
+    ): { flags: number[]; nextOffset: number } | null {
+        const flags: number[] = [];
+        let p = offset;
+
+        try {
+            while (flags.length < nPoints) {
+                if (p >= view.byteLength) return null;
+                const flag = this.reader.getUint8(view, p++);
+                flags.push(flag);
+
+                // Repeat flag (bit 3 set)
+                if (flag & 0x08) {
+                    if (p >= view.byteLength) return null;
+                    const repeatCount = this.reader.getUint8(view, p++);
+                    for (let r = 0; r < repeatCount; r++) {
+                        flags.push(flag);
+                    }
+                }
+            }
+        } catch {
+            return null;
+        }
+
+        return { flags, nextOffset: p };
+    }
+
+    /**
+     * Parses glyph X and Y coordinates from delta values.
+     * @param view - DataView containing the glyph data
+     * @param flags - Flag array for each point
+     * @param offset - Starting offset for coordinates
+     * @returns Points array and next offset, or null if parsing fails
+     */
+    private parseCoordinates(
+        view: DataView,
+        flags: number[],
+        offset: number
+    ): { points: Point[]; nextOffset: number } | null {
+        const nPoints = flags.length;
+        const xs: number[] = new Array(nPoints);
+        const ys: number[] = new Array(nPoints);
+
+        let p = offset;
+
+        // Parse X coordinates (deltas)
+        try {
+            for (let i = 0; i < nPoints; i++) {
+                const f = flags[i];
+                if (f & 0x02) {
+                    // X-Short Vector: 1-byte delta
+                    if (p >= view.byteLength) return null;
+                    const val = this.reader.getUint8(view, p++);
+                    xs[i] = (f & 0x10) ? val : -val; // Bit 4: positive if set
+                } else {
+                    if (f & 0x10) {
+                        // X is same as previous (zero delta)
+                        xs[i] = 0;
+                    } else {
+                        // 2-byte signed delta
+                        if (p + 2 > view.byteLength) return null;
+                        xs[i] = this.reader.getInt16(view, p);
+                        p += 2;
+                    }
+                }
+            }
+        } catch {
+            return null;
+        }
+
+        // Parse Y coordinates (deltas)
+        try {
+            for (let i = 0; i < nPoints; i++) {
+                const f = flags[i];
+                if (f & 0x04) {
+                    // Y-Short Vector: 1-byte delta
+                    if (p >= view.byteLength) return null;
+                    const val = this.reader.getUint8(view, p++);
+                    ys[i] = (f & 0x20) ? val : -val; // Bit 5: positive if set
+                } else {
+                    if (f & 0x20) {
+                        // Y is same as previous (zero delta)
+                        ys[i] = 0;
+                    } else {
+                        // 2-byte signed delta
+                        if (p + 2 > view.byteLength) return null;
+                        ys[i] = this.reader.getInt16(view, p);
+                        p += 2;
+                    }
+                }
+            }
+        } catch {
+            return null;
+        }
+
+        // Convert deltas to absolute coordinates
+        const points: Point[] = new Array(nPoints);
+        let curX = 0;
+        let curY = 0;
+        for (let i = 0; i < nPoints; i++) {
+            curX += xs[i];
+            curY += ys[i];
+            points[i] = {
+                x: curX,
+                y: curY,
+                onCurve: !!(flags[i] & 0x01) // Bit 0: on-curve flag
+            };
+        }
+
+        return { points, nextOffset: p };
+    }
+
+    /**
+     * Converts contour points into glyph outline commands.
+     * Handles quadratic Bezier curves with consecutive off-curve points.
+     * @param contours - Array of contours
+     * @returns Array of glyph outline commands
+     */
+    private buildOutlineCommands(contours: Point[][]): GlyphOutlineCmd[] {
+        const cmds: GlyphOutlineCmd[] = [];
+
+        for (const contour of contours) {
+            if (contour.length === 0) continue;
+
+            const n = contour.length;
+            const getIdx = (i: number) => ((i % n) + n) % n; // Wrap-around index
+
+            // Find a starting on-curve point, if any
+            let startPtIndex = -1;
+            for (let i = 0; i < n; i++) {
+                if (contour[i].onCurve) {
+                    startPtIndex = i;
+                    break;
+                }
+            }
+
+            let firstPoint: Point;
+            let curIndex: number;
+
+            if (startPtIndex === -1) {
+                // No on-curve points: create implied on-curve between last and first off-curve
+                const p0 = contour[0];
+                const plast = contour[n - 1];
+                firstPoint = {
+                    x: (plast.x + p0.x) / 2,
+                    y: (plast.y + p0.y) / 2,
+                    onCurve: true
+                };
+                curIndex = 0;
+            } else {
+                firstPoint = contour[startPtIndex];
+                curIndex = startPtIndex;
+            }
+
+            cmds.push({ type: "moveTo", x: firstPoint.x, y: firstPoint.y });
+
+            // Walk through contour points
+            let i = curIndex + 1;
+            let steps = 0;
+            while (steps < n) {
+                const idx = getIdx(i);
+                const pt = contour[idx];
+                const next = contour[getIdx(i + 1)];
+
+                if (pt.onCurve) {
+                    // Straight line to on-curve point
+                    cmds.push({ type: "lineTo", x: pt.x, y: pt.y });
+                } else {
+                    // Off-curve point (quadratic control point)
+                    if (next.onCurve) {
+                        // Single control point -> quadratic curve
+                        cmds.push({ type: "quadTo", cx: pt.x, cy: pt.y, x: next.x, y: next.y });
+                        i++; // Consume next point
+                        steps++;
+                    } else {
+                        // Consecutive off-curve points: create implied on-curve midpoint
+                        const midx = (pt.x + next.x) / 2;
+                        const midy = (pt.y + next.y) / 2;
+                        cmds.push({ type: "quadTo", cx: pt.x, cy: pt.y, x: midx, y: midy });
+                    }
+                }
+
+                i++;
+                steps++;
+            }
+
+            cmds.push({ type: "close" });
+        }
+
+        return cmds;
+    }
+}

package/src/pdf/font/to-unicode.ts

@@ -0,0 +1,109 @@
+/**
+ * Build ToUnicode CMap text from explicit gid->unicode mappings.
+ * Entries should be pre-sorted by gid for best compression but ordering is not required.
+ */
+export function createToUnicodeCMapText(entries: { gid: number; unicode: number }[]): string {
+  if (!entries || entries.length === 0) {
+    return `/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CIDSystemInfo <<
+  /Registry (Adobe)
+  /Ordering (UCS)
+  /Supplement 0
+>> def
+/CMapName /Adobe-Identity-UCS def
+/CMapType 2 def
+1 begincodespacerange
+<0000> <FFFF>
+endcodespacerange
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end`;
+  }
+
+  const es = entries.slice().sort((a, b) => a.gid - b.gid);
+
+  const uniToUtf16Hex = (cp: number): string => {
+    if (cp <= 0xffff) {
+      return cp.toString(16).padStart(4, "0").toUpperCase();
+    }
+    const v = cp - 0x10000;
+    const hi = 0xd800 + (v >> 10);
+    const lo = 0xdc00 + (v & 0x3ff);
+    return hi.toString(16).padStart(4, "0").toUpperCase() + lo.toString(16).padStart(4, "0").toUpperCase();
+  };
+
+  // Build mapping directives (group consecutive linear runs into ranges)
+  type Mapping = { type: "range"; startG: number; endG: number; startU: number } | { type: "char"; gid: number; unicode: number };
+  const mappings: Mapping[] = [];
+  let i = 0;
+  while (i < es.length) {
+    const start = es[i];
+    let j = i + 1;
+    while (
+      j < es.length &&
+      es[j].gid === es[j - 1].gid + 1 &&
+      es[j].unicode === es[j - 1].unicode + 1
+    ) {
+      j++;
+    }
+    const runLen = j - i;
+    if (runLen >= 2) {
+      mappings.push({ type: "range", startG: start.gid, endG: es[j - 1].gid, startU: start.unicode });
+      i = j;
+    } else {
+      mappings.push({ type: "char", gid: start.gid, unicode: start.unicode });
+      i++;
+    }
+  }
+
+  const lines: string[] = [];
+  lines.push("/CIDInit /ProcSet findresource begin");
+  lines.push("12 dict begin");
+  lines.push("begincmap");
+  lines.push("/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def");
+  lines.push("/CMapName /Adobe-Identity-UCS def");
+  lines.push("/CMapType 2 def");
+  lines.push("1 begincodespacerange");
+  lines.push("<0000> <FFFF>");
+  lines.push("endcodespacerange");
+
+  const CHUNK = 100;
+  let p = 0;
+  while (p < mappings.length) {
+    const currentType = mappings[p].type;
+    const group: Mapping[] = [];
+    while (p < mappings.length && mappings[p].type === currentType && group.length < CHUNK) {
+      group.push(mappings[p]);
+      p++;
+    }
+
+    if (currentType === "char") {
+      lines.push(`${group.length} beginbfchar`);
+      for (const m of group as { type: "char"; gid: number; unicode: number }[]) {
+        const cid = m.gid.toString(16).padStart(4, "0").toUpperCase();
+        const uniHex = uniToUtf16Hex(m.unicode);
+        lines.push(`<${cid}> <${uniHex}>`);
+      }
+      lines.push("endbfchar");
+    } else {
+      lines.push(`${group.length} beginbfrange`);
+      for (const m of group as { type: "range"; startG: number; endG: number; startU: number }[]) {
+        const startCid = m.startG.toString(16).padStart(4, "0").toUpperCase();
+        const endCid = m.endG.toString(16).padStart(4, "0").toUpperCase();
+        const startUniHex = uniToUtf16Hex(m.startU);
+        lines.push(`<${startCid}> <${endCid}> <${startUniHex}>`);
+      }
+      lines.push("endbfrange");
+    }
+  }
+
+  lines.push("endcmap");
+  lines.push("CMapName currentdict /CMap defineresource pop");
+  lines.push("end");
+  lines.push("end");
+
+  return lines.join("\n");
+}

package/src/pdf/font/transformation-matrix.ts

@@ -0,0 +1,136 @@
+import type { GlyphOutlineCmd } from "../../types/fonts.js";
+
+/**
+ * Represents a 2D affine transformation matrix with translation.
+ * Used for transforming composite glyph components in TrueType fonts.
+ * 
+ * Matrix form:
+ * | mxx  myx  tx |
+ * | mxy  myy  ty |
+ * |  0    0    1 |
+ */
+export class TransformationMatrix {
+    constructor(
+        public readonly mxx: number = 1,
+        public readonly mxy: number = 0,
+        public readonly myx: number = 0,
+        public readonly myy: number = 1,
+        public readonly tx: number = 0,
+        public readonly ty: number = 0
+    ) { }
+
+    /**
+     * Creates an identity transformation matrix (no transformation).
+     */
+    static identity(): TransformationMatrix {
+        return new TransformationMatrix();
+    }
+
+    /**
+     * Creates a uniform scale transformation matrix.
+     * @param s - Scale factor for both X and Y axes
+     */
+    static scale(s: number): TransformationMatrix {
+        return new TransformationMatrix(s, 0, 0, s, 0, 0);
+    }
+
+    /**
+     * Creates a non-uniform scale transformation matrix.
+     * @param sx - Scale factor for X axis
+     * @param sy - Scale factor for Y axis
+     */
+    static scaleXY(sx: number, sy: number): TransformationMatrix {
+        return new TransformationMatrix(sx, 0, 0, sy, 0, 0);
+    }
+
+    /**
+     * Creates a translation transformation matrix.
+     * @param tx - Translation along X axis
+     * @param ty - Translation along Y axis
+     */
+    static translate(tx: number, ty: number): TransformationMatrix {
+        return new TransformationMatrix(1, 0, 0, 1, tx, ty);
+    }
+
+    /**
+     * Creates a transformation matrix from TrueType component transform data.
+     * @param tx - Translation X
+     * @param ty - Translation Y
+     * @param mxx - Matrix element (1,1)
+     * @param mxy - Matrix element (1,2)
+     * @param myx - Matrix element (2,1)
+     * @param myy - Matrix element (2,2)
+     */
+    static fromComponents(
+        tx: number,
+        ty: number,
+        mxx: number = 1,
+        mxy: number = 0,
+        myx: number = 0,
+        myy: number = 1
+    ): TransformationMatrix {
+        return new TransformationMatrix(mxx, mxy, myx, myy, tx, ty);
+    }
+
+    /**
+     * Transforms a single point using this matrix.
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @returns Transformed coordinates
+     */
+    transformPoint(x: number, y: number): { x: number; y: number } {
+        return {
+            x: x * this.mxx + y * this.myx + this.tx,
+            y: x * this.mxy + y * this.myy + this.ty
+        };
+    }
+
+    /**
+     * Applies this transformation to a list of glyph outline commands.
+     * Creates new command objects with transformed coordinates.
+     * @param cmds - Original glyph outline commands
+     * @returns New array of transformed commands
+     */
+    applyToCommands(cmds: GlyphOutlineCmd[]): GlyphOutlineCmd[] {
+        const out: GlyphOutlineCmd[] = [];
+
+        for (const c of cmds) {
+            switch (c.type) {
+                case "moveTo": {
+                    const { x, y } = this.transformPoint(c.x, c.y);
+                    out.push({ type: "moveTo", x, y });
+                    break;
+                }
+                case "lineTo": {
+                    const { x, y } = this.transformPoint(c.x, c.y);
+                    out.push({ type: "lineTo", x, y });
+                    break;
+                }
+                case "quadTo": {
+                    const cp = this.transformPoint(c.cx, c.cy);
+                    const ep = this.transformPoint(c.x, c.y);
+                    out.push({ type: "quadTo", cx: cp.x, cy: cp.y, x: ep.x, y: ep.y });
+                    break;
+                }
+                case "cubicTo": {
+                    const cp1 = this.transformPoint(c.cx1, c.cy1);
+                    const cp2 = this.transformPoint(c.cx2, c.cy2);
+                    const ep = this.transformPoint(c.x, c.y);
+                    out.push({
+                        type: "cubicTo",
+                        cx1: cp1.x, cy1: cp1.y,
+                        cx2: cp2.x, cy2: cp2.y,
+                        x: ep.x, y: ep.y
+                    });
+                    break;
+                }
+                case "close": {
+                    out.push({ type: "close" });
+                    break;
+                }
+            }
+        }
+
+        return out;
+    }
+}