@cj-tech-master/excelts 9.4.1 → 9.4.2

package/dist/browser/modules/pdf/font/system-fonts.js

@@ -0,0 +1,188 @@
+/**
+ * System font discovery for PDF generation.
+ *
+ * When no embedded font is provided and the document contains non-WinAnsi
+ * characters, this module searches standard system font directories for a
+ * TrueType font (.ttf or .ttc) with broad Unicode coverage.
+ *
+ * This is a Node.js-only feature — browser environments do not have
+ * file system access and must always provide fonts explicitly.
+ *
+ * .ttc (TrueType Collection) files are supported — parseTtf() extracts
+ * the first font from the collection automatically.
+ *
+ * Results are cached: the filesystem search runs only once per process.
+ */
+import { fileExistsSync, readFileBytesSync, traverseDirectorySync } from "../../../utils/fs.browser.js";
+// =============================================================================
+// Platform Font Directories
+// =============================================================================
+function getSystemFontDirs() {
+    const platform = typeof process !== "undefined" ? process.platform : "";
+    const home = typeof process !== "undefined" ? (process.env.HOME ?? process.env.USERPROFILE ?? "") : "";
+    const dirs = [];
+    switch (platform) {
+        case "darwin":
+            dirs.push("/System/Library/Fonts", "/System/Library/Fonts/Supplemental", "/Library/Fonts", `${home}/Library/Fonts`);
+            break;
+        case "win32": {
+            const winDir = process.env.WINDIR ?? process.env.SystemRoot ?? "C:\\Windows";
+            dirs.push(`${winDir}\\Fonts`, `${process.env.LOCALAPPDATA ?? ""}\\Microsoft\\Windows\\Fonts`);
+            break;
+        }
+        case "linux":
+        default:
+            dirs.push("/usr/share/fonts", "/usr/local/share/fonts", "/usr/share/fonts/truetype", "/usr/share/fonts/opentype", "/usr/share/fonts/TTF", "/usr/share/fonts/noto", "/usr/share/fonts/noto-cjk", "/usr/share/fonts/google-noto", "/usr/share/fonts/google-noto-cjk", "/usr/share/fonts/truetype/noto", "/usr/share/fonts/truetype/dejavu", "/usr/share/fonts/truetype/liberation", "/usr/share/fonts/truetype/droid", "/usr/share/fonts/wqy", `${home}/.local/share/fonts`, `${home}/.fonts`);
+            break;
+    }
+    return dirs;
+}
+// =============================================================================
+// Preferred Font Names (ordered by preference — first match wins)
+// =============================================================================
+const PREFERRED_FONTS = [
+    // Noto Sans CJK — broadest open-source coverage
+    "NotoSansCJKsc-Regular.ttf",
+    "NotoSansCJK-Regular.ttc",
+    "NotoSansCJKSC-Regular.otf",
+    "NotoSansSC-Regular.ttf",
+    "NotoSansTC-Regular.ttf",
+    "NotoSansJP-Regular.ttf",
+    "NotoSansKR-Regular.ttf",
+    "NotoSans-Regular.ttf",
+    // Arial Unicode MS
+    "Arial Unicode.ttf",
+    "Arial Unicode MS.ttf",
+    "ArialUnicode.ttf",
+    "arialuni.ttf",
+    // macOS
+    "PingFang.ttc",
+    "Hiragino Sans GB.ttc",
+    "STHeiti Light.ttc",
+    "STHeiti Medium.ttc",
+    "Songti.ttc",
+    "AppleSDGothicNeo.ttc",
+    // Windows
+    "msyh.ttc",
+    "msyhbd.ttc",
+    "msjh.ttc",
+    "simsun.ttc",
+    "simhei.ttf",
+    "malgun.ttf",
+    "meiryo.ttc",
+    "yugothic.ttf",
+    "segoeui.ttf",
+    "arial.ttf",
+    // Linux
+    "DejaVuSans.ttf",
+    "LiberationSans-Regular.ttf",
+    "FreeSans.ttf",
+    "DroidSansFallbackFull.ttf",
+    "DroidSansFallback.ttf",
+    "wqy-microhei.ttc",
+    "wqy-zenhei.ttc",
+    "uming.ttc",
+    "NanumGothic.ttf",
+    "IPAexGothic.ttf"
+];
+// =============================================================================
+// Font Discovery
+// =============================================================================
+let _cachedCandidates;
+/**
+ * Return all discoverable system font candidates, ordered by preference.
+ *
+ * Each entry is the raw font file bytes of a `.ttf` or `.ttc` file.
+ * The caller decides which candidate to use (e.g. by checking cmap coverage).
+ *
+ * Results are cached — the filesystem scan runs only once per process.
+ */
+export function discoverSystemFontCandidates() {
+    if (_cachedCandidates !== undefined) {
+        return _cachedCandidates;
+    }
+    if (typeof process === "undefined" || !process.platform) {
+        _cachedCandidates = [];
+        return _cachedCandidates;
+    }
+    const candidates = [];
+    const seen = new Set(); // dedupe by path
+    const dirs = getSystemFontDirs();
+    // Strategy 1: Check preferred font filenames (in order)
+    for (const fontName of PREFERRED_FONTS) {
+        for (const dir of dirs) {
+            const fontPath = `${dir}/${fontName}`;
+            if (seen.has(fontPath)) {
+                continue;
+            }
+            if (fileExistsSync(fontPath)) {
+                const data = tryReadFont(fontPath);
+                if (data) {
+                    candidates.push(data);
+                    seen.add(fontPath);
+                }
+            }
+        }
+    }
+    // Strategy 2: Scan directories for any .ttf/.ttc not already found
+    const broadRe = /noto|unicode|cjk|yahei|heiti|gothic|sans|serif|ming|song|dejavu|liberation|droid|wqy/i;
+    for (const dir of dirs) {
+        try {
+            const entries = traverseDirectorySync(dir, { recursive: true, filter: e => !e.isDirectory });
+            const fonts = entries.filter(e => /\.tt[cf]$/i.test(e.absolutePath) && !seen.has(e.absolutePath));
+            // Broad-coverage names first, then large files
+            const broad = fonts.filter(e => broadRe.test(e.absolutePath));
+            const rest = fonts.filter(e => !broadRe.test(e.absolutePath) && e.size > 50000);
+            for (const entry of [...broad, ...rest]) {
+                if (seen.has(entry.absolutePath)) {
+                    continue;
+                }
+                const data = tryReadFont(entry.absolutePath);
+                if (data) {
+                    candidates.push(data);
+                    seen.add(entry.absolutePath);
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or not readable
+        }
+    }
+    _cachedCandidates = candidates;
+    return candidates;
+}
+/**
+ * Search for a system font suitable for Unicode rendering.
+ *
+ * Returns the raw font file bytes of the highest-priority candidate,
+ * or `null` if no font was found. This is a convenience wrapper around
+ * {@link discoverSystemFontCandidates}.
+ */
+export function discoverSystemFont() {
+    const candidates = discoverSystemFontCandidates();
+    return candidates.length > 0 ? candidates[0] : null;
+}
+/**
+ * Reset the cached font discovery result (for testing).
+ */
+export function resetFontDiscoveryCache() {
+    _cachedCandidates = undefined;
+}
+/**
+ * Override the cached candidates with a custom list (for testing).
+ * Call {@link resetFontDiscoveryCache} to clear the override.
+ */
+export function _setCandidatesForTest(candidates) {
+    _cachedCandidates = candidates;
+}
+// =============================================================================
+// Internal
+// =============================================================================
+function tryReadFont(fontPath) {
+    try {
+        return readFileBytesSync(fontPath);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/browser/modules/pdf/font/ttf-parser.js

@@ -111,8 +111,36 @@ class BEReader {
  */
 export function parseTtf(data) {
     const r = new BEReader(data);
+    // --- Check for TTC (TrueType Collection) ---
+    const magic = r.u32();
+    if (magic === 0x74746366) {
+        // 'ttcf' — TrueType Collection
+        // Read the offset of the first font and restart parsing from there
+        r.skip(4); // majorVersion, minorVersion
+        const numFonts = r.u32();
+        if (numFonts === 0) {
+            throw new PdfFontError("TrueType Collection is empty (0 fonts)");
+        }
+        const firstFontOffset = r.u32();
+        return parseTtfAtOffset(data, firstFontOffset);
+    }
+    // Not TTC — parse as regular TTF starting from the magic we already read
+    return parseTtfFromMagic(data, r, magic);
+}
+/**
+ * Parse a TTF font starting at a given byte offset within the data.
+ * Used for TTC collections where each font starts at a different offset.
+ */
+function parseTtfAtOffset(data, offset) {
+    const r = new BEReader(data, offset);
+    const magic = r.u32();
+    return parseTtfFromMagic(data, r, magic);
+}
+/**
+ * Core TTF parsing after the first 4 bytes (sfVersion) have been read.
+ */
+function parseTtfFromMagic(data, r, sfVersion) {
     // --- Offset table ---
-    const sfVersion = r.u32();
     // TrueType: 0x00010000 or 'true' (0x74727565)
     // OpenType with CFF: 'OTTO' (0x4F54544F) — not supported for subsetting
     if (sfVersion !== 0x00010000 && sfVersion !== 0x74727565) {

package/dist/browser/modules/pdf/font/type3-font.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Type3 fallback font builder.
+ *
+ * Produces a PDF Type3 font object that contains vector-drawn glyphs for
+ * Unicode characters that cannot be represented by standard Type1 fonts
+ * (WinAnsi encoding).
+ *
+ * A single Type3 font supports up to 256 glyphs (single-byte encoding).
+ * When more than 256 distinct non-WinAnsi characters appear in a document,
+ * multiple Type3 fonts are created automatically.
+ *
+ * @see PDF Reference 1.7, §5.5.4 — Type 3 Fonts
+ */
+import type { PdfWriter } from "../core/pdf-writer.js";
+/** Result of writing Type3 font(s) to the PDF. */
+export interface Type3FontResult {
+    /** Map from Type3 resource name → PDF object number. */
+    fontObjects: Map<string, number>;
+    /** Map from Unicode code point → { resourceName, charCode }. */
+    encoding: Map<number, {
+        resourceName: string;
+        charCode: number;
+    }>;
+    /** Advance widths: resourceName → Map<charCode, width in 1/1000 em>. */
+    widths: Map<string, Map<number, number>>;
+}
+/**
+ * Build and write Type3 fallback fonts to the PDF for the given code points.
+ *
+ * @param writer - The PdfWriter to add objects to.
+ * @param codePoints - Set of Unicode code points that need Type3 rendering.
+ * @param resourcePrefix - Prefix for resource names (e.g. "T3F").
+ * @returns Encoding and object info for use by FontManager.
+ */
+export declare function writeType3Fonts(writer: PdfWriter, codePoints: Set<number>, resourcePrefix?: string): Type3FontResult;

package/dist/browser/modules/pdf/font/type3-font.js

@@ -0,0 +1,228 @@
+/**
+ * Type3 fallback font builder.
+ *
+ * Produces a PDF Type3 font object that contains vector-drawn glyphs for
+ * Unicode characters that cannot be represented by standard Type1 fonts
+ * (WinAnsi encoding).
+ *
+ * A single Type3 font supports up to 256 glyphs (single-byte encoding).
+ * When more than 256 distinct non-WinAnsi characters appear in a document,
+ * multiple Type3 fonts are created automatically.
+ *
+ * @see PDF Reference 1.7, §5.5.4 — Type 3 Fonts
+ */
+import { PdfDict, pdfName, pdfRef, pdfNumber, pdfArray } from "../core/pdf-object.js";
+import { PdfContentStream } from "../core/pdf-stream.js";
+import { lookupGlyph, NOTDEF_GLYPH } from "./type3-glyphs.js";
+// =============================================================================
+// Constants
+// =============================================================================
+/**
+ * Type3 fonts use a FontMatrix to map glyph coordinates to text space.
+ * With a 1000-unit em square, FontMatrix = [0.001 0 0 0.001 0 0].
+ */
+const UNITS_PER_EM = 1000;
+/** Maximum glyphs per Type3 font (single-byte encoding limit). */
+const MAX_GLYPHS_PER_FONT = 256;
+// First usable encoding slot (0x00 = .notdef, start user glyphs at 0x01).
+const FIRST_SLOT = 1;
+/**
+ * Build and write Type3 fallback fonts to the PDF for the given code points.
+ *
+ * @param writer - The PdfWriter to add objects to.
+ * @param codePoints - Set of Unicode code points that need Type3 rendering.
+ * @param resourcePrefix - Prefix for resource names (e.g. "T3F").
+ * @returns Encoding and object info for use by FontManager.
+ */
+export function writeType3Fonts(writer, codePoints, resourcePrefix = "T3F") {
+    const encoding = new Map();
+    const fontObjects = new Map();
+    const widths = new Map();
+    if (codePoints.size === 0) {
+        return { fontObjects, encoding, widths };
+    }
+    // Sort code points for deterministic output
+    const sorted = [...codePoints].sort((a, b) => a - b);
+    // Partition into chunks of MAX_GLYPHS_PER_FONT - 1 (slot 0 is .notdef)
+    const maxPerFont = MAX_GLYPHS_PER_FONT - FIRST_SLOT;
+    let fontIndex = 1;
+    for (let offset = 0; offset < sorted.length; offset += maxPerFont) {
+        const chunk = sorted.slice(offset, offset + maxPerFont);
+        const resourceName = `${resourcePrefix}${fontIndex}`;
+        fontIndex++;
+        const { objNum, fontWidths } = writeSingleType3Font(writer, chunk, resourceName);
+        fontObjects.set(resourceName, objNum);
+        widths.set(resourceName, fontWidths);
+        // Record encoding for each code point
+        for (let i = 0; i < chunk.length; i++) {
+            encoding.set(chunk[i], { resourceName, charCode: FIRST_SLOT + i });
+        }
+    }
+    return { fontObjects, encoding, widths };
+}
+// =============================================================================
+// Internal — Single Type3 Font
+// =============================================================================
+function writeSingleType3Font(writer, codePoints, resourceName) {
+    // Build CharProcs: each glyph is a content stream
+    const charProcRefs = [];
+    const encodingNames = [];
+    const widthValues = new Array(FIRST_SLOT + codePoints.length).fill(0);
+    const fontWidths = new Map();
+    // Slot 0: .notdef
+    const notdefObj = writeGlyphStream(writer, NOTDEF_GLYPH);
+    charProcRefs.push({ name: ".notdef", objNum: notdefObj });
+    widthValues[0] = NOTDEF_GLYPH.width;
+    for (let i = 0; i < codePoints.length; i++) {
+        const cp = codePoints[i];
+        const glyphDef = lookupGlyph(cp) ?? NOTDEF_GLYPH;
+        const glyphName = `uni${cp.toString(16).toUpperCase().padStart(4, "0")}`;
+        const objNum = writeGlyphStream(writer, glyphDef);
+        charProcRefs.push({ name: glyphName, objNum });
+        encodingNames.push(glyphName);
+        const slot = FIRST_SLOT + i;
+        widthValues[slot] = glyphDef.width;
+        fontWidths.set(slot, glyphDef.width);
+    }
+    // Build CharProcs dictionary
+    const charProcsEntries = [];
+    for (const { name, objNum } of charProcRefs) {
+        charProcsEntries.push(`${pdfName(name)} ${pdfRef(objNum)}`);
+    }
+    const charProcsDict = `<<\n${charProcsEntries.join("\n")}\n>>`;
+    // Build Encoding dictionary
+    const differences = [];
+    differences.push(`${FIRST_SLOT}`);
+    for (const name of encodingNames) {
+        differences.push(pdfName(name));
+    }
+    const encodingObjNum = writer.allocObject();
+    const encodingDict = new PdfDict()
+        .set("Type", "/Encoding")
+        .set("Differences", `[${differences.join(" ")}]`);
+    writer.addObject(encodingObjNum, encodingDict);
+    // Build ToUnicode CMap
+    const toUnicodeObjNum = writeToUnicodeCMap(writer, codePoints);
+    // Build the Type3 font dictionary
+    const fontObjNum = writer.allocObject();
+    const fontBBox = `[0 0 ${UNITS_PER_EM} ${UNITS_PER_EM}]`;
+    const fontMatrix = "[0.001 0 0 0.001 0 0]";
+    const fontDict = new PdfDict()
+        .set("Type", "/Font")
+        .set("Subtype", "/Type3")
+        .set("Name", pdfName(resourceName))
+        .set("FontBBox", fontBBox)
+        .set("FontMatrix", fontMatrix)
+        .set("FirstChar", pdfNumber(0))
+        .set("LastChar", pdfNumber(widthValues.length - 1))
+        .set("Widths", pdfArray(widthValues.map(w => pdfNumber(w))))
+        .set("CharProcs", charProcsDict)
+        .set("Encoding", pdfRef(encodingObjNum))
+        .set("ToUnicode", pdfRef(toUnicodeObjNum));
+    writer.addObject(fontObjNum, fontDict);
+    return { objNum: fontObjNum, fontWidths };
+}
+// =============================================================================
+// Glyph Stream Writer
+// =============================================================================
+function writeGlyphStream(writer, glyph) {
+    const stream = new PdfContentStream();
+    // d1 operator: wx wy llx lly urx ury — sets glyph width and bounding box
+    // This tells the PDF viewer the advance width and clip region
+    stream.raw(`${glyph.width} 0 0 0 ${UNITS_PER_EM} ${UNITS_PER_EM} d1`);
+    // Draw the glyph using the pen adapter
+    const pen = createPen(stream);
+    glyph.draw(pen);
+    const objNum = writer.allocObject();
+    writer.addStreamObject(objNum, new PdfDict(), stream);
+    return objNum;
+}
+/**
+ * Create a GlyphPen backed by a PdfContentStream.
+ */
+function createPen(stream) {
+    return {
+        M: (x, y) => {
+            stream.moveTo(x, y);
+        },
+        L: (x, y) => {
+            stream.lineTo(x, y);
+        },
+        C: (x1, y1, x2, y2, x3, y3) => {
+            stream.curveTo(x1, y1, x2, y2, x3, y3);
+        },
+        Z: () => {
+            stream.closePath();
+        },
+        rect: (x, y, w, h) => {
+            stream.rect(x, y, w, h);
+        },
+        circle: (cx, cy, r) => {
+            stream.circle(cx, cy, r);
+        },
+        ellipse: (cx, cy, rx, ry) => {
+            stream.ellipse(cx, cy, rx, ry);
+        },
+        stroke: () => {
+            stream.stroke();
+        },
+        fill: () => {
+            stream.fill();
+        },
+        fillStroke: () => {
+            stream.fillAndStroke();
+        },
+        lineWidth: w => {
+            stream.setLineWidth(w);
+        }
+    };
+}
+// =============================================================================
+// ToUnicode CMap
+// =============================================================================
+function writeToUnicodeCMap(writer, codePoints) {
+    const lines = [];
+    lines.push("/CIDInit /ProcSet findresource begin");
+    lines.push("12 dict begin");
+    lines.push("begincmap");
+    lines.push("/CIDSystemInfo");
+    lines.push("<< /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("<00> <FF>");
+    lines.push("endcodespacerange");
+    // Write mappings in chunks of 100 (PDF limit per beginbfchar block)
+    for (let offset = 0; offset < codePoints.length; offset += 100) {
+        const chunk = codePoints.slice(offset, offset + 100);
+        lines.push(`${chunk.length} beginbfchar`);
+        for (let i = 0; i < chunk.length; i++) {
+            const slot = FIRST_SLOT + offset + i;
+            const cp = chunk[i];
+            const slotHex = slot.toString(16).toUpperCase().padStart(2, "0");
+            if (cp > 0xffff) {
+                // Supplementary character — encode as UTF-16 surrogate pair
+                const hi = Math.floor((cp - 0x10000) / 0x400) + 0xd800;
+                const lo = ((cp - 0x10000) % 0x400) + 0xdc00;
+                const hiHex = hi.toString(16).toUpperCase().padStart(4, "0");
+                const loHex = lo.toString(16).toUpperCase().padStart(4, "0");
+                lines.push(`<${slotHex}> <${hiHex}${loHex}>`);
+            }
+            else {
+                const cpHex = cp.toString(16).toUpperCase().padStart(4, "0");
+                lines.push(`<${slotHex}> <${cpHex}>`);
+            }
+        }
+        lines.push("endbfchar");
+    }
+    lines.push("endcmap");
+    lines.push("CMapName currentdict /CMap defineresource pop");
+    lines.push("end");
+    lines.push("end");
+    const cmapStr = lines.join("\n");
+    const encoder = new TextEncoder();
+    const data = encoder.encode(cmapStr);
+    const objNum = writer.allocObject();
+    writer.addStreamObject(objNum, new PdfDict(), data);
+    return objNum;
+}

package/dist/browser/modules/pdf/font/type3-glyphs-extended.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Extended Type3 glyph definitions — programmatically generated blocks
+ * and additional hand-crafted symbols.
+ *
+ * This file supplements type3-glyphs.ts with:
+ *  - Box Drawing        (U+2500–U+257F)  128 chars — algorithmic
+ *  - Block Elements     (U+2580–U+259F)   32 chars — algorithmic
+ *  - Braille Patterns   (U+2800–U+28FF)  256 chars — algorithmic
+ *  - Letterlike Symbols  (U+2100–U+214F)  hand-crafted
+ *  - Number Forms        (U+2150–U+218F)  hand-crafted
+ *  - Enclosed Alphanumerics (U+2460–U+24FF) programmatic
+ *  - General Punctuation extras (U+2000–U+206F)
+ *  - Additional Arrows, Math, Dingbats, Misc Symbols, Currency, Technical
+ */
+import type { GlyphDef } from "./type3-glyphs.js";
+export declare const BOX_FULL: Record<number, GlyphDef>;
+export declare const BLOCK_FULL: Record<number, GlyphDef>;
+export declare const BRAILLE: Record<number, GlyphDef>;
+export declare const LETTERLIKE: Record<number, GlyphDef>;
+export declare const NUMBER_FORMS: Record<number, GlyphDef>;
+export declare const ENCLOSED: Record<number, GlyphDef>;
+export declare const PUNCT_EXT: Record<number, GlyphDef>;
+export declare const ARROWS_EXT: Record<number, GlyphDef>;
+export declare const MATH_EXT: Record<number, GlyphDef>;
+export declare const MISC_EXT: Record<number, GlyphDef>;
+export declare const DING_EXT: Record<number, GlyphDef>;
+export declare const TECH_EXT: Record<number, GlyphDef>;
+export declare const CURRENCY_EXT: Record<number, GlyphDef>;
+export declare const MATH_SYM_A: Record<number, GlyphDef>;
+export declare const SUP_ARROWS_A: Record<number, GlyphDef>;
+export declare const GEOMETRIC_EXT: Record<number, GlyphDef>;
+export declare const ROMAN_NUMERALS: Record<number, GlyphDef>;
+export declare const ENCLOSED_EXT: Record<number, GlyphDef>;