aurochs 0.5.0 → 0.6.2

package/dist/@aurochs/pdf/src/domain/color/color-space.d.ts

@@ -0,0 +1,12 @@
+import { PdfColorSpace, PdfAlternateColorSpace } from './types';
+/**
+ * Get number of components for a color space
+ *
+ * PDF Reference 8.6:
+ * - DeviceGray: 1 component
+ * - DeviceRGB: 3 components
+ * - DeviceCMYK: 4 components
+ * - ICCBased: Determined by N value (or alternateColorSpace)
+ * - Pattern: 0 components
+ */
+export declare function getColorSpaceComponents(colorSpace: PdfColorSpace, alternateColorSpace?: PdfAlternateColorSpace): number;

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

@@ -0,0 +1,9 @@
+/**
+ * @file PDF color domain
+ *
+ * Exports types and utilities for PDF color handling.
+ */
+export type { PdfColorSpace, PdfAlternateColorSpace, PdfColor } from './types';
+export { getColorSpaceComponents } from './color-space';
+export type { RgbColor } from './primitives';
+export { grayToRgb, rgbToRgbBytes, cmykToRgb, rgbToHex, clamp01, clampByte, toByte, } from './primitives';

package/dist/@aurochs/pdf/src/domain/color/primitives.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @file Color conversion primitives
+ *
+ * Basic color conversion algorithms for PDF color spaces.
+ * These are pure functions operating on normalized values (0-1 range).
+ *
+ * Note: These are naive conversions without ICC profile support.
+ * For accurate color reproduction, ICC profile parsing would be required.
+ */
+/**
+ * RGB color tuple (0-255 range)
+ */
+export type RgbColor = readonly [r: number, g: number, b: number];
+/**
+ * Convert grayscale to RGB
+ *
+ * PDF Reference 8.6.4.2: DeviceGray uses 1 component (0=black, 1=white)
+ *
+ * @param gray - Grayscale value (0-1)
+ * @returns RGB tuple (0-255)
+ */
+export declare function grayToRgb(gray: number): RgbColor;
+/**
+ * Convert RGB components to RGB bytes
+ *
+ * PDF Reference 8.6.4.3: DeviceRGB uses 3 components (R, G, B in 0-1 range)
+ *
+ * @param r - Red (0-1)
+ * @param g - Green (0-1)
+ * @param b - Blue (0-1)
+ * @returns RGB tuple (0-255)
+ */
+export declare function rgbToRgbBytes(r: number, g: number, b: number): RgbColor;
+/**
+ * Convert CMYK to RGB using naive linear conversion.
+ *
+ * ## Formula
+ *
+ * ```
+ * R = 255 × (1 - C) × (1 - K)
+ * G = 255 × (1 - M) × (1 - K)
+ * B = 255 × (1 - Y) × (1 - K)
+ * ```
+ *
+ * ## Limitations
+ *
+ * This is a **naive conversion** that does NOT account for:
+ *
+ * 1. **ICC Profiles**: Professional print PDFs use calibrated CMYK
+ *    (e.g., FOGRA39, US Web Coated SWOP) which have non-linear
+ *    relationships with sRGB.
+ *
+ * 2. **Color Gamut**: CMYK and sRGB have different color gamuts.
+ *    Some CMYK colors cannot be accurately represented in sRGB.
+ *
+ * 3. **Black Generation**: The relationship between CMY and K
+ *    varies by printing process (GCR, UCR).
+ *
+ * ## When Accuracy Matters
+ *
+ * For accurate CMYK→RGB conversion, use:
+ * - A color management library (e.g., lcms2, ColorSync)
+ * - The PDF's embedded ICC profile
+ * - A standard print profile (FOGRA39, SWOP, etc.)
+ *
+ * ## Typical Inaccuracies
+ *
+ * | CMYK Input      | This Function | Accurate sRGB |
+ * |-----------------|---------------|---------------|
+ * | C=100 M=0 Y=0   | (0, 255, 255) | ~(0, 174, 239)|
+ * | C=0 M=100 Y=0   | (255, 0, 255) | ~(236, 0, 140)|
+ * | C=0 M=0 Y=100   | (255, 255, 0) | ~(255, 242, 0)|
+ *
+ * @see PDF Reference 1.7, Section 8.6.4.4 (DeviceCMYK Color Space)
+ * @see ISO 12647-2 (Offset printing)
+ *
+ * @param c - Cyan (0-1)
+ * @param m - Magenta (0-1)
+ * @param y - Yellow (0-1)
+ * @param k - Key/Black (0-1)
+ * @returns RGB tuple (0-255)
+ */
+export declare function cmykToRgb({ c, m, y, k, }: {
+    readonly c: number;
+    readonly m: number;
+    readonly y: number;
+    readonly k: number;
+}): RgbColor;
+/**
+ * Convert RGB to hex string
+ *
+ * @param r - Red (0-255)
+ * @param g - Green (0-255)
+ * @param b - Blue (0-255)
+ * @returns Hex string (e.g., "FF00FF")
+ */
+export declare function rgbToHex(r: number, g: number, b: number): string;
+/**
+ * Clamp value to 0-1 range
+ */
+export declare function clamp01(value: number): number;
+/**
+ * Clamp value to 0-255 range
+ */
+export declare function clampByte(value: number): number;
+/**
+ * Convert 0-1 component to 0-255 byte
+ */
+export declare function toByte(component01: number): number;

package/dist/@aurochs/pdf/src/domain/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file PDF-related constants
+ *
+ * Contains constants used in PDF parsing and conversion.
+ * All values are derived from official specifications.
+ */
+/**
+ * Conversion factor from PDF points to CSS pixels.
+ *
+ * Derivation:
+ * - PDF Reference 1.7, Appendix C.2: 1 point = 1/72 inch
+ * - CSS Values and Units Module Level 3: 1px = 1/96 inch (reference pixel)
+ * - Therefore: 1pt = (1/72) inch × (96 px/inch) = 96/72 px ≈ 1.333px
+ *
+ * Note: This is the standard CSS reference pixel at 96 DPI.
+ * The actual physical size depends on the device's pixel density.
+ */
+export declare const PT_TO_PX: number;
+/**
+ * Conversion factor from CSS pixels to PDF points.
+ *
+ * Inverse of PT_TO_PX.
+ */
+export declare const PX_TO_PT: number;

package/dist/@aurochs/pdf/src/domain/content-stream/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file PDF content stream domain
+ *
+ * PDF content stream tokenizer and types.
+ * PDF Reference Chapter 7.
+ */
+export type { PdfTokenType, PdfToken } from './tokenizer';
+export { tokenizeContentStream } from './tokenizer';

package/dist/@aurochs/pdf/src/domain/content-stream/tokenizer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file PDF content stream tokenizer
+ *
+ * Parses PDF content stream into tokens for further processing.
+ * PDF Reference Chapter 7 - Content Stream Syntax
+ *
+ * Content stream elements:
+ * - Numbers: 123, -45.67, .5
+ * - Strings: (Hello), <48656C6C6F>
+ * - Names: /Name
+ * - Operators: m, l, c, S, f, BT, ET, etc.
+ * - Arrays: [...]
+ * - Dictionaries: <<...>>
+ */
+export type PdfTokenType = "number" | "string" | "name" | "operator" | "array_start" | "array_end" | "dict_start" | "dict_end";
+export type PdfToken = {
+    readonly type: PdfTokenType;
+    readonly value: string | number;
+    readonly raw: string;
+};
+/**
+ * Tokenize a PDF content stream
+ */
+export declare function tokenizeContentStream(content: string): PdfToken[];

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

@@ -0,0 +1,8 @@
+/**
+ * @file PDF coordinate domain
+ *
+ * Exports types and utilities for PDF coordinate system handling.
+ */
+export type { PdfPoint, PdfBBox, PdfMatrix } from './types';
+export { IDENTITY_MATRIX, multiplyMatrices, transformPoint, invertMatrix, translationMatrix, scalingMatrix, rotationMatrix, isIdentityMatrix, isSimpleTransform, getMatrixScale, getMatrixRotation, decomposeMatrix, hasShear, } from './matrix';
+export type { MatrixDecomposition } from './matrix';

package/dist/@aurochs/pdf/src/domain/coordinate/matrix.d.ts

@@ -0,0 +1,81 @@
+import { PdfMatrix, PdfPoint } from './types';
+export declare const IDENTITY_MATRIX: PdfMatrix;
+/**
+ * Multiply two transformation matrices
+ * Result = a * b
+ */
+export declare function multiplyMatrices(a: PdfMatrix, b: PdfMatrix): PdfMatrix;
+/**
+ * Transform a point by a matrix
+ */
+export declare function transformPoint(point: PdfPoint, matrix: PdfMatrix): PdfPoint;
+/**
+ * Calculate the inverse of a matrix
+ * Returns null if matrix is singular
+ */
+export declare function invertMatrix(matrix: PdfMatrix): PdfMatrix | null;
+/**
+ * Create a translation matrix
+ */
+export declare function translationMatrix(tx: number, ty: number): PdfMatrix;
+/**
+ * Create a scaling matrix
+ */
+export declare function scalingMatrix(sx: number, sy: number): PdfMatrix;
+/**
+ * Create a rotation matrix (angle in radians)
+ */
+export declare function rotationMatrix(angle: number): PdfMatrix;
+/**
+ * Check if a matrix is (approximately) the identity matrix
+ */
+export declare function isIdentityMatrix(matrix: PdfMatrix): boolean;
+/**
+ * Check if a matrix contains only scale and translation (no rotation/skew)
+ */
+export declare function isSimpleTransform(matrix: PdfMatrix): boolean;
+/**
+ * Extract scale factors from a matrix
+ */
+export declare function getMatrixScale(matrix: PdfMatrix): {
+    scaleX: number;
+    scaleY: number;
+};
+/**
+ * Extract rotation angle from a matrix (in radians)
+ */
+export declare function getMatrixRotation(matrix: PdfMatrix): number;
+/**
+ * Complete matrix decomposition result
+ */
+export type MatrixDecomposition = {
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly rotation: number;
+    readonly shearX: number;
+    readonly shearY: number;
+    readonly translateX: number;
+    readonly translateY: number;
+    readonly isSimple: boolean;
+    readonly hasRotation: boolean;
+    readonly hasScale: boolean;
+};
+/**
+ * Decompose a transformation matrix into its components
+ *
+ * A 2D affine transformation matrix [a, b, c, d, e, f] can be decomposed as:
+ * - Translation: (e, f)
+ * - Rotation: atan2(b, a)
+ * - Scale: (scaleX, scaleY)
+ * - Shear: shearX, shearY
+ *
+ * The matrix represents: [scaleX*cos(r) + shearY*sin(r), scaleX*sin(r) - shearY*cos(r),
+ *                         shearX*cos(r) + scaleY*sin(r), shearX*sin(r) - scaleY*cos(r), e, f]
+ *
+ * For shear detection, we check if the matrix can be represented as pure scale + rotation
+ */
+export declare function decomposeMatrix(matrix: PdfMatrix): MatrixDecomposition;
+/**
+ * Check if a matrix has shear (skew) transformation
+ */
+export declare function hasShear(matrix: PdfMatrix): boolean;

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

@@ -0,0 +1,7 @@
+/**
+ * @file PDF document domain
+ *
+ * Exports types for PDF document structure.
+ */
+export type { PdfElement, PdfPage, PdfDocument, PdfEmbeddedFont } from './types';
+export { PDF_UNITS, isPdfPath, isPdfText, isPdfImage } from './types';

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

@@ -0,0 +1,114 @@
+import { PdfImage } from '../image';
+import { PdfPath } from '../path';
+import { PdfText } from '../text';
+export type PdfElement = PdfPath | PdfText | PdfImage;
+/**
+ * Represents a parsed PDF page.
+ *
+ * ## Coordinate System
+ *
+ * PDF uses a coordinate system where:
+ * - Origin is at the bottom-left corner
+ * - X increases to the right
+ * - Y increases upward
+ * - Default unit is the "point" (1 point = 1/72 inch)
+ *
+ * @see PDF Reference 1.7, Section 4.2 (Coordinate Systems)
+ */
+export type PdfPage = {
+    /**
+     * 1-indexed page number.
+     */
+    readonly pageNumber: number;
+    /**
+     * Page width in PDF points (1 point = 1/72 inch).
+     *
+     * Common values:
+     * - A4 portrait: 595.28 points (210mm)
+     * - A4 landscape: 841.89 points (297mm)
+     * - US Letter portrait: 612 points (8.5 inches)
+     * - US Letter landscape: 792 points (11 inches)
+     */
+    readonly width: number;
+    /**
+     * Page height in PDF points (1 point = 1/72 inch).
+     *
+     * Common values:
+     * - A4 portrait: 841.89 points (297mm)
+     * - A4 landscape: 595.28 points (210mm)
+     * - US Letter portrait: 792 points (11 inches)
+     * - US Letter landscape: 612 points (8.5 inches)
+     */
+    readonly height: number;
+    /**
+     * Visual elements on this page (text, paths, images).
+     */
+    readonly elements: readonly PdfElement[];
+};
+/**
+ * Embedded font data extracted from PDF.
+ *
+ * @see ISO 32000-1:2008 Section 9.9 (Embedded Font Programs)
+ */
+export type PdfEmbeddedFont = {
+    /** Font family name (e.g., "Hiragino Sans") */
+    readonly fontFamily: string;
+    /** Font format */
+    readonly format: "opentype" | "truetype" | "type1" | "cff";
+    /** Raw font data */
+    readonly data: Uint8Array;
+    /** MIME type */
+    readonly mimeType: string;
+};
+export type PdfDocument = {
+    readonly pages: readonly PdfPage[];
+    readonly metadata?: {
+        readonly title?: string;
+        readonly author?: string;
+        readonly subject?: string;
+    };
+    /**
+     * Embedded fonts extracted from PDF.
+     * Only present if PDF contains embedded font programs.
+     */
+    readonly embeddedFonts?: readonly PdfEmbeddedFont[];
+};
+/**
+ * PDF coordinate system unit conversions.
+ *
+ * PDF "user space" default unit is the point: 1 point = 1/72 inch.
+ */
+export declare const PDF_UNITS: {
+    /**
+     * Points per inch (PDF default unit).
+     * 1 inch = 72 points.
+     */
+    readonly POINTS_PER_INCH: 72;
+    /**
+     * Points per millimeter.
+     * 1mm ≈ 2.8346 points.
+     */
+    readonly POINTS_PER_MM: number;
+    /**
+     * Convert PDF points to inches.
+     */
+    readonly pointsToInches: (points: number) => number;
+    /**
+     * Convert PDF points to millimeters.
+     */
+    readonly pointsToMm: (points: number) => number;
+    /**
+     * Convert inches to PDF points.
+     */
+    readonly inchesToPoints: (inches: number) => number;
+    /**
+     * Convert millimeters to PDF points.
+     */
+    readonly mmToPoints: (mm: number) => number;
+};
+/** Type guard for `PdfPath` elements. */
+export declare function isPdfPath(element: PdfElement): element is PdfPath;
+/** Type guard for `PdfText` elements. */
+export declare function isPdfText(element: PdfElement): element is PdfText;
+/** Type guard for `PdfImage` elements. */
+export declare function isPdfImage(element: PdfElement): element is PdfImage;

package/dist/@aurochs/pdf/src/domain/font/cff/cff-cid-parser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file Minimal CFF CID-keyed charset parser.
+ */
+type CffCidCharsetParseResult = Readonly<{
+    gidToCid: ReadonlyMap<number, number>;
+    glyphCount: number;
+    ros?: Readonly<{
+        registrySid: number;
+        orderingSid: number;
+        supplement: number;
+        registry?: string;
+        ordering?: string;
+    }>;
+}>;
+/**
+ * Parse CID-keyed CFF bytes and extract GID->CID map from charset.
+ */
+export declare function parseCffCidCharset(fontData: Uint8Array): CffCidCharsetParseResult | null;
+export {};

package/dist/@aurochs/pdf/src/domain/font/cid/adobe-japan1-cid-to-unicode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @file Adobe-Japan1 CID → Unicode mapping (embedded)
+ *
+ * This table is generated from Poppler's "cidToUnicode/Adobe-Japan1" data file
+ * (Adobe-Japan1-7 character collection).
+ *
+ * License (from the upstream CMap resources / Poppler data):
+ * - Copyright 1990-2022 Adobe. All rights reserved.
+ * - Redistribution and use in source and binary forms, with or without modification,
+ *   are permitted subject to the license terms included in Adobe's CMap resources.
+ */
+/** Decode an Adobe-Japan1 CID to its corresponding Unicode string. */
+export declare function decodeAdobeJapan1CidToUnicode(cid: number): string | null;

package/dist/@aurochs/pdf/src/domain/font/cid/cid-ordering.d.ts

@@ -0,0 +1,26 @@
+import { CIDOrdering } from '../types';
+/**
+ * CID-to-Unicode fallback mapping
+ */
+export type CIDFallbackMapping = ReadonlyMap<number, string>;
+/**
+ * Get fallback mapping for a given CID ordering
+ *
+ * Returns a combined mapping of ASCII range plus ordering-specific mappings.
+ */
+export declare function getCIDFallbackMapping(ordering: CIDOrdering): CIDFallbackMapping;
+/**
+ * Detect CID ordering from font ordering string
+ *
+ * The Ordering string in CIDSystemInfo typically contains the ordering name.
+ *
+ * - Adobe character collections: Japan1, GB1, CNS1, Korea1 (provide script type)
+ * - Identity: Modern generic encoding (no script type info, ISO 32000-1 Section 9.7.5)
+ */
+export declare function detectCIDOrdering(ordering: string): CIDOrdering | null;
+/**
+ * Try to decode a CID using fallback mapping
+ *
+ * Returns the Unicode character if found, or null if no mapping exists.
+ */
+export declare function decodeCIDFallback(cid: number, ordering: CIDOrdering | null): string | null;

package/dist/@aurochs/pdf/src/domain/font/cid/japan1-kanji-mappings.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @file src/pdf/domain/font/japan1-kanji-mappings.ts
+ */
+export declare const JAPAN1_KANJI_MAPPINGS: ReadonlyMap<number, string>;

package/dist/@aurochs/pdf/src/domain/font/cmap/cmap-parser.d.ts

@@ -0,0 +1,64 @@
+import { FontMapping } from '../types';
+/**
+ * Diagnostics captured while parsing ToUnicode CMaps.
+ */
+export type CMapParseDiagnostics = {
+    /** Number of malformed entries ignored during parsing. */
+    readonly invalidEntryCount: number;
+    /** Number of `bfrange` entries truncated by configured limits. */
+    readonly truncatedRangeCount: number;
+    /** Number of mappings whose source-byte length is outside declared codespace lengths. */
+    readonly sourceLengthOutsideCodeSpaceCount: number;
+    /** Number of final mappings whose destination contains U+FFFD. */
+    readonly replacementCharMapCount: number;
+    /** Number of final mappings whose destination contains private-use characters. */
+    readonly privateUseCharMapCount: number;
+    /** Final mapping counts grouped by source code byte length. */
+    readonly sourceCodeLengthHistogram: ReadonlyMap<number, number>;
+};
+/**
+ * CMap parse result containing mapping, source code metadata, and diagnostics.
+ */
+export type CMapParseResult = {
+    /** Legacy numeric mapping used by existing single-byte / two-byte decoders. */
+    readonly mapping: FontMapping;
+    /** Exact source-byte mapping. Key is uppercase hex without separators (e.g. `8140`). */
+    readonly byteMapping: ReadonlyMap<string, string>;
+    /** Source code byte lengths observed from mappings and codespace ranges (descending). */
+    readonly sourceCodeByteLengths: readonly number[];
+    /**
+     * Legacy byte-width hint used by existing layout code.
+     * Kept as 1|2 for backward compatibility.
+     */
+    readonly codeByteWidth: 1 | 2;
+    readonly diagnostics: CMapParseDiagnostics;
+};
+export type CMapParserOptions = {
+    /**
+     * Maximum entries generated from one `bfrange` statement.
+     *
+     * Default: 65536 (full 2-byte CID space).
+     */
+    readonly maxRangeEntries?: number;
+};
+/**
+ * Parse ToUnicode CMap data and detect source code lengths.
+ */
+export declare function parseToUnicodeCMap(data: string, options?: CMapParserOptions): CMapParseResult;
+/**
+ * Parse beginbfchar sections.
+ * Format: `<source> <destination>`
+ * Returns maximum source hex length found.
+ */
+export declare function parseBfChar(data: string, mapping: FontMapping): number;
+/**
+ * Parse beginbfrange sections.
+ * Format: `<start> <end> <destStart>` or `<start> <end> [<dest1> <dest2> ...]`
+ * Returns maximum source hex length found.
+ */
+export declare function parseBfRange(data: string, mapping: FontMapping, options?: CMapParserOptions): number;
+/**
+ * Convert destination hex string to Unicode string.
+ * Destination is interpreted as UTF-16BE code units.
+ */
+export declare function hexToString(hex: string): string | null;

package/dist/@aurochs/pdf/src/domain/font/decoding/cid-glyph-fallback.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file CID -> Unicode supplemental fallback mapping helpers.
+ */
+export type CidToGidMapping = {
+    readonly kind: "identity";
+} | {
+    readonly kind: "table";
+    readonly bytes: Uint8Array;
+};
+/**
+ * Extract glyphId -> Unicode map from raw cmap table bytes.
+ */
+export declare function extractGlyphIdToUnicodeFromCmapTable(cmapTable: Uint8Array): ReadonlyMap<number, string>;
+/**
+ * Extract glyphId -> Unicode map from a TrueType/OpenType font program.
+ */
+export declare function extractGlyphIdToUnicodeFromTrueTypeLikeFont(fontData: Uint8Array): ReadonlyMap<number, string>;
+/**
+ * Build CID code -> Unicode fallback map from CIDToGID mapping and glyph cmap.
+ */
+export declare function buildCidCodeToUnicodeFallbackMap(args: {
+    readonly cidToGid: CidToGidMapping;
+    readonly glyphIdToUnicode: ReadonlyMap<number, string>;
+}): ReadonlyMap<number, string>;

package/dist/@aurochs/pdf/src/domain/font/decoding/text-decoder.d.ts

@@ -0,0 +1,7 @@
+import { FontInfo, FontMappings } from '../types';
+/**
+ * Decode text using font mapping
+ */
+export declare function decodeText(rawText: string, fontName: string, mappings: FontMappings): string;
+/** Decode raw PDF text string using font encoding and mapping information. */
+export declare function decodeTextWithFontInfo(rawText: string, fontInfo: FontInfo): string;

package/dist/@aurochs/pdf/src/domain/font/defaults.d.ts

@@ -0,0 +1,23 @@
+import { FontMetrics } from './types';
+/**
+ * Default font metrics when no font information is available
+ *
+ * PDF Reference 5.2.3, 5.7.1:
+ * Font metrics are expressed in units of 1/1000 of the em-square.
+ * The em-square is traditionally 1000 units for most fonts.
+ *
+ * Default values are based on common Latin font metrics:
+ * - PDF standard 14 fonts (Helvetica, Times, Courier) have:
+ *   - Helvetica: ascender ~718, descender ~-207
+ *   - Times-Roman: ascender ~683, descender ~-217
+ *   - Courier: ascender ~629, descender ~-157
+ *
+ * - We use slightly larger defaults (800/-200) to accommodate:
+ *   - Fonts with taller ascenders (many display fonts)
+ *   - CJK fonts which often extend higher
+ *   - Conservative estimates that avoid clipping
+ *
+ * Total glyph height = ascender - descender = 800 - (-200) = 1000 units
+ * This matches the standard em-square size.
+ */
+export declare const DEFAULT_FONT_METRICS: FontMetrics;

package/dist/@aurochs/pdf/src/domain/font/encoding-maps.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @file PDF Font Encoding Maps
+ *
+ * Standard character encodings used in PDF fonts (ISO 32000-1, Annex D).
+ * These mappings convert single-byte character codes to Unicode strings.
+ *
+ * PDF supports several predefined encodings:
+ * - WinAnsiEncoding: Windows code page 1252 (most common for Western PDFs)
+ * - MacRomanEncoding: Mac OS Roman character set
+ * - StandardEncoding: Adobe Standard Encoding (PostScript Type 1 default)
+ *
+ * When a font has an /Encoding entry with one of these names, the corresponding
+ * mapping is used instead of ToUnicode CMap for character decoding.
+ */
+/**
+ * WinAnsiEncoding (Windows Code Page 1252)
+ *
+ * Most commonly used encoding for Western PDFs created on Windows.
+ * ISO 32000-1, Annex D, Table D.1
+ *
+ * Character codes 0x00-0x1F and 0x7F are control characters (pass through).
+ * Character codes 0x80-0x9F contain special characters (Euro, quotes, etc.).
+ */
+export declare const WINANSI_ENCODING: ReadonlyMap<number, string>;
+/**
+ * MacRomanEncoding (Mac OS Roman)
+ *
+ * Character encoding used on classic Mac OS systems.
+ * ISO 32000-1, Annex D, Table D.2
+ */
+export declare const MACROMAN_ENCODING: ReadonlyMap<number, string>;
+/**
+ * StandardEncoding (Adobe Standard Encoding)
+ *
+ * Default encoding for Type 1 fonts without explicit encoding.
+ * ISO 32000-1, Annex D, Table D.3
+ */
+export declare const STANDARD_ENCODING: ReadonlyMap<number, string>;
+/**
+ * PDF Encoding type identifier
+ */
+export type PdfEncodingName = "WinAnsiEncoding" | "MacRomanEncoding" | "StandardEncoding";
+/**
+ * Get an encoding map by name.
+ *
+ * @param name - The encoding name (with or without leading slash)
+ * @returns The encoding map, or undefined if not recognized
+ */
+export declare function getEncodingByName(name: string): ReadonlyMap<number, string> | undefined;
+/**
+ * Apply Differences array to a base encoding map.
+ *
+ * The Differences array in PDF encoding dictionaries allows customization
+ * of character mappings. Format: [code name1 name2 ... code name ...]
+ *
+ * @param baseEncoding - The base encoding map to modify
+ * @param differences - The Differences array entries
+ * @returns A new map with the differences applied
+ */
+export declare function applyEncodingDifferences(baseEncoding: ReadonlyMap<number, string>, differences: readonly (number | string)[]): Map<number, string>;
+/**
+ * Convert Adobe glyph name to Unicode string.
+ *
+ * Supports common glyph names used in PDF fonts.
+ * This is a subset of the Adobe Glyph List.
+ *
+ * @param name - The glyph name (with or without leading slash)
+ * @returns The Unicode string, or undefined if not recognized
+ */
+export declare function glyphNameToUnicode(name: string): string | undefined;