aurochs 0.6.2 → 0.6.3

package/dist/@aurochs/pdf/src/domain/document/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Exports types for PDF document structure.
  */
-export type { PdfElement, PdfPage, PdfDocument, PdfEmbeddedFont } from './types';
+export type { PdfElement, PdfPage, PdfDocument, PdfEmbeddedFont, PdfFontToUnicode, PdfFontMetrics } from './types';
 export { PDF_UNITS, isPdfPath, isPdfText, isPdfImage } from './types';

package/dist/@aurochs/pdf/src/domain/document/types.d.ts

@@ -1,6 +1,7 @@
 import { PdfImage } from '../image';
 import { PdfPath } from '../path';
 import { PdfText } from '../text';
+import { CIDOrdering } from '../font';
 export type PdfElement = PdfPath | PdfText | PdfImage;
 /**
  * Represents a parsed PDF page.
@@ -45,6 +46,29 @@ export type PdfPage = {
      */
     readonly elements: readonly PdfElement[];
 };
+/**
+ * ToUnicode mapping data for round-trip preservation.
+ * Used to reconstruct ToUnicode CMap when writing PDF.
+ */
+export type PdfFontToUnicode = {
+    /** Source bytes (hex) → Unicode string mapping. Key is uppercase hex (e.g., "8140" → "ア"). */
+    readonly byteMapping: ReadonlyMap<string, string>;
+    /** Source code byte lengths from codespace ranges (descending order). */
+    readonly sourceCodeByteLengths: readonly number[];
+};
+/**
+ * Font metrics for PDF writing.
+ */
+export type PdfFontMetrics = {
+    /** Ascender height in 1/1000 em units */
+    readonly ascender: number;
+    /** Descender depth in 1/1000 em units (negative) */
+    readonly descender: number;
+    /** Glyph widths: character code → width in 1/1000 em units */
+    readonly widths: ReadonlyMap<number, number>;
+    /** Default glyph width when not found in widths */
+    readonly defaultWidth: number;
+};
 /**
  * Embedded font data extracted from PDF.
  *
@@ -59,6 +83,16 @@ export type PdfEmbeddedFont = {
     readonly data: Uint8Array;
     /** MIME type */
     readonly mimeType: string;
+    /** Original BaseFont name from PDF (e.g., "/ZRDQJE+Hiragino-Sans"). Includes subset prefix. */
+    readonly baseFontName?: string;
+    /** ToUnicode CMap information for round-trip preservation. */
+    readonly toUnicode?: PdfFontToUnicode;
+    /** Font metrics for accurate text layout. */
+    readonly metrics?: PdfFontMetrics;
+    /** CID ordering (Japan1, GB1, CNS1, Korea1, Identity). */
+    readonly ordering?: CIDOrdering;
+    /** Number of bytes per character code (1 for single-byte, 2 for CID fonts). */
+    readonly codeByteWidth?: 1 | 2;
 };
 export type PdfDocument = {
     readonly pages: readonly PdfPage[];

package/dist/@aurochs/pdf/src/writer/content-stream/text-operators.d.ts

@@ -1,4 +1,5 @@
 import { PdfText } from '../../domain/text';
+import { PdfEmbeddedFont } from '../../domain/document';
 /**
  * Context for text serialization.
  */
@@ -8,6 +9,11 @@ export type TextSerializationContext = {
      * e.g., "Helvetica" -> "F1"
      */
     readonly fontNameToResource: ReadonlyMap<string, string>;
+    /**
+     * Embedded fonts for CID font detection.
+     * When present, CID fonts will use hex string output.
+     */
+    readonly embeddedFonts?: readonly PdfEmbeddedFont[];
 };
 /**
  * Serialize a PdfText element to PDF content stream operators.

package/dist/@aurochs/pdf/src/writer/document/font-builder.d.ts

@@ -20,6 +20,22 @@ export declare function buildType1Font(fontName: string, tracker: PdfObjectTrack
  * @returns The font dictionary object number
  */
 export declare function buildEmbeddedFont(font: PdfEmbeddedFont, tracker: PdfObjectTracker): number;
+/**
+ * Build a Type0 CID font with Identity-H encoding.
+ *
+ * Structure:
+ * - Type0 font dictionary (top-level)
+ * - CIDFont dictionary (descendant)
+ * - FontDescriptor
+ * - CIDToGIDMap (Identity)
+ * - ToUnicode CMap stream
+ * - Embedded font file
+ *
+ * @param font - The embedded font data with CID information
+ * @param tracker - Object tracker for allocation
+ * @returns The Type0 font dictionary object number
+ */
+export declare function buildType0Font(font: PdfEmbeddedFont, tracker: PdfObjectTracker): number;
 /**
  * Build fonts for a document.
  * Returns a map of font name to object number.

package/dist/@aurochs/pdf/src/writer/document/index.d.ts

@@ -3,6 +3,7 @@
  */
 export { PdfObjectTracker, type PdfObjectEntry, } from './object-tracker';
 export { buildResourceDict, buildEmptyResourceDict, type ResourceRefs, } from './resource-builder';
-export { buildType1Font, buildEmbeddedFont, buildFonts, } from './font-builder';
+export { buildType1Font, buildEmbeddedFont, buildType0Font, buildFonts, } from './font-builder';
+export { generateToUnicodeStream, } from './tounicode-writer';
 export { buildImageXObject, buildImages, } from './image-builder';
 export { buildPage, type PageBuildResult, type BuildPageOptions, } from './page-builder';

package/dist/@aurochs/pdf/src/writer/document/page-builder.d.ts

@@ -1,4 +1,4 @@
-import { PdfPage } from '../../domain/document';
+import { PdfPage, PdfEmbeddedFont } from '../../domain/document';
 import { PdfImage } from '../../domain/image';
 import { ResourceRefs } from './resource-builder';
 import { PdfObjectTracker } from './object-tracker';
@@ -23,6 +23,8 @@ export type BuildPageOptions = {
     readonly fontObjMap: ReadonlyMap<string, number>;
     readonly imageObjMap: ReadonlyMap<number, number>;
     readonly tracker: PdfObjectTracker;
+    /** Embedded fonts for CID font text serialization. */
+    readonly embeddedFonts?: readonly PdfEmbeddedFont[];
 };
 /**
  * Build a page object.

package/dist/@aurochs/pdf/src/writer/document/tounicode-writer.d.ts

@@ -0,0 +1,8 @@
+import { PdfFontToUnicode } from '../../domain/document';
+/**
+ * Generate a ToUnicode CMap stream.
+ *
+ * @param toUnicode - The ToUnicode mapping data
+ * @returns CMap stream content as UTF-8 encoded bytes
+ */
+export declare function generateToUnicodeStream(toUnicode: PdfFontToUnicode): Uint8Array;

package/dist/_shared/{pdf-parser-CKdfZw6N.js → pdf-parser-Ciztl2kx.js}

@@ -4062,8 +4062,51 @@ function extractToUnicodeMap(page, fontDict) {
   }
   const decoded = decodePdfStream(stream);
   const cmap = new TextDecoder("latin1").decode(decoded);
-  const parsed = parseToUnicodeCMap(cmap);
-  return parsed.mapping;
+  return parseToUnicodeCMap(cmap);
+}
+function extractCIDOrdering(page, fontDict) {
+  const subtypeObj = resolve$8(page, dictGet$e(fontDict, "Subtype"));
+  const subtype = subtypeObj?.type === "name" ? subtypeObj.value : null;
+  if (subtype !== "Type0") {
+    return void 0;
+  }
+  const descendants = resolve$8(page, dictGet$e(fontDict, "DescendantFonts"));
+  const arr = asArray$a(descendants);
+  if (!arr || arr.items.length === 0) {
+    return void 0;
+  }
+  const cidFont = asDict$a(resolve$8(page, arr.items[0]));
+  if (!cidFont) {
+    return void 0;
+  }
+  const cidSystemInfo = resolveDict$4(page, dictGet$e(cidFont, "CIDSystemInfo"));
+  if (!cidSystemInfo) {
+    return void 0;
+  }
+  const orderingObj = resolve$8(page, dictGet$e(cidSystemInfo, "Ordering"));
+  if (!orderingObj) {
+    return void 0;
+  }
+  const ordering = orderingObj.type === "string" ? orderingObj.text : orderingObj.type === "name" ? orderingObj.value : null;
+  if (!ordering) {
+    return void 0;
+  }
+  if (ordering.includes("Japan1")) {
+    return "Japan1";
+  }
+  if (ordering.includes("GB1")) {
+    return "GB1";
+  }
+  if (ordering.includes("CNS1")) {
+    return "CNS1";
+  }
+  if (ordering.includes("Korea1")) {
+    return "Korea1";
+  }
+  if (ordering.includes("Identity")) {
+    return "Identity";
+  }
+  return void 0;
 }
 function getFontDescriptor(page, fontDict) {
   const subtypeObj = resolve$8(page, dictGet$e(fontDict, "Subtype"));
@@ -4103,11 +4146,20 @@ function normalizeEmbeddedFontData(args) {
   if (args.format !== "truetype") {
     return { data: args.rawData, metrics: void 0 };
   }
-  const data = repairFontForWeb(args.rawData, new Map(args.toUnicode ?? []), args.fontFamily);
+  const data = repairFontForWeb(args.rawData, new Map(args.toUnicode?.mapping ?? []), args.fontFamily);
   const rawMetrics = extractTrueTypeMetrics(data);
   const metrics = rawMetrics ? normalizeMetricsTo1000(rawMetrics) : void 0;
   return { data, metrics };
 }
+function buildEmbeddedFontToUnicode(toUnicode) {
+  if (!toUnicode || toUnicode.byteMapping.size === 0) {
+    return void 0;
+  }
+  return {
+    byteMapping: toUnicode.byteMapping,
+    sourceCodeByteLengths: toUnicode.sourceCodeByteLengths
+  };
+}
 function extractEmbeddedFontsFromNativePages(pages) {
   const fonts = [];
   const seen = /* @__PURE__ */ new Set();
@@ -4148,13 +4200,18 @@ function extractEmbeddedFontsFromNativePages(pages) {
       const fontFamily = normalizeFontFamily(baseFontRaw);
       const toUnicode = extractToUnicodeMap(page, fontDict);
       const { data, metrics } = normalizeEmbeddedFontData({ format, rawData, fontFamily, toUnicode });
+      const ordering = extractCIDOrdering(page, fontDict);
+      const codeByteWidth = toUnicode?.codeByteWidth ?? 1;
       fonts.push({
         baseFontName: baseFontRaw,
         fontFamily,
         format,
         data,
         mimeType,
-        metrics
+        metrics,
+        toUnicode: buildEmbeddedFontToUnicode(toUnicode),
+        ordering,
+        codeByteWidth
       });
     }
   }
@@ -5753,6 +5810,13 @@ const handleTextNextLine = (ctx, gfxOps) => {
     }
   };
 };
+function rawTextToBytes(rawText) {
+  const bytes = new Uint8Array(rawText.length);
+  for (let i2 = 0; i2 < rawText.length; i2++) {
+    bytes[i2] = rawText.charCodeAt(i2) & 255;
+  }
+  return bytes;
+}
 function createTextRun(text, textState, gfxState) {
   const { ctm, textRise, charSpacing, wordSpacing, horizontalScaling, graphicsState } = gfxState;
   const { textMatrix, currentFont, currentBaseFont, currentFontInfo, currentFontSize, currentFontMetrics, currentCodeByteWidth } = textState;
@@ -5790,6 +5854,7 @@ function createTextRun(text, textState, gfxState) {
   const effectiveFontSize = calculateEffectiveFontSize(currentFontSize, textMatrix, ctm);
   const run = {
     text,
+    rawBytes: rawTextToBytes(text),
     textMatrix,
     x: startPos.x,
     y: startPos.y,
@@ -21405,7 +21470,20 @@ function buildEmbeddedFonts(embeddedFontsRaw) {
     fontFamily: f2.fontFamily,
     format: f2.format,
     data: f2.data,
-    mimeType: f2.mimeType
+    mimeType: f2.mimeType,
+    baseFontName: f2.baseFontName,
+    toUnicode: f2.toUnicode ? {
+      byteMapping: f2.toUnicode.byteMapping,
+      sourceCodeByteLengths: f2.toUnicode.sourceCodeByteLengths
+    } : void 0,
+    metrics: f2.metrics ? {
+      ascender: f2.metrics.ascender,
+      descender: f2.metrics.descender,
+      widths: f2.metrics.widths ?? /* @__PURE__ */ new Map(),
+      defaultWidth: f2.metrics.defaultWidth ?? 500
+    } : void 0,
+    ordering: f2.ordering,
+    codeByteWidth: f2.codeByteWidth
   }));
 }
 async function parsePageSource({ page, pageNumber, parseOptions, embeddedFontMetrics }) {
@@ -22023,4 +22101,4 @@ export {
   calculateTextDisplacement as y,
   rasterizeSoftMaskedFillPath as z
 };
-//# sourceMappingURL=pdf-parser-CKdfZw6N.js.map
+//# sourceMappingURL=pdf-parser-Ciztl2kx.js.map