pdf-codec 0.0.0 → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,484 @@
+import { Color, LayoutDocument, LayoutFont } from "document-content-model";
+import { z } from "zod";
+//#region src/diagnostics.d.ts
+type PdfDiagnosticSeverity = 'info' | 'warning';
+interface PdfDiagnostic {
+  readonly code: string;
+  readonly severity: PdfDiagnosticSeverity;
+  readonly message: string;
+  readonly pageIndex?: number;
+}
+type PdfDiagnosticSink = (diagnostic: PdfDiagnostic) => void;
+declare const NOOP_DIAGNOSTIC_SINK: PdfDiagnosticSink;
+declare class PdfParseError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+declare class PdfEncryptedError extends PdfParseError {
+  constructor(message?: string);
+}
+//#endregion
+//#region src/matrix.d.ts
+interface Point {
+  readonly x: number;
+  readonly y: number;
+}
+declare function rotatePointAboutCenter(point: Point, center: Point, degrees: number): Point;
+//#endregion
+//#region src/read.d.ts
+interface ReadPdfOptions {
+  readonly sink?: PdfDiagnosticSink;
+  readonly signal?: AbortSignal;
+}
+declare function readPdf(bytes: Uint8Array<ArrayBuffer>, options?: ReadPdfOptions): LayoutDocument;
+//#endregion
+//#region src/math-types.d.ts
+interface MathColor {
+  readonly r: number;
+  readonly g: number;
+  readonly b: number;
+}
+interface MathGlyphRun {
+  readonly kind: 'glyphs';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly text: string;
+  readonly sizePt: number;
+  readonly color: MathColor;
+}
+interface MathRule {
+  readonly kind: 'rule';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly color: MathColor;
+}
+interface MathStroke {
+  readonly kind: 'stroke';
+  readonly points: readonly {
+    readonly xPt: number;
+    readonly yPt: number;
+  }[];
+  readonly widthPt: number;
+  readonly color: MathColor;
+}
+type MathLayoutItem = MathGlyphRun | MathRule | MathStroke;
+interface MathBox {
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly ascentPt: number;
+  readonly descentPt: number;
+  readonly items: readonly MathLayoutItem[];
+}
+interface MathGlyphMetrics {
+  readonly advanceWidthPt: number;
+  readonly italicCorrectionPt: number;
+  readonly topAccentXPt?: number;
+}
+interface MathFontMetrics {
+  readonly ascentPerEm: number;
+  readonly descentPerEm: number;
+  readonly axisHeightPt: number;
+  readonly fractionRuleThicknessPt: number;
+  readonly fractionNumeratorShiftUpPt: number;
+  readonly fractionNumeratorDisplayShiftUpPt: number;
+  readonly fractionDenominatorShiftDownPt: number;
+  readonly fractionDenominatorDisplayShiftDownPt: number;
+  readonly fractionNumeratorGapMinPt: number;
+  readonly fractionDenominatorGapMinPt: number;
+  readonly radicalRuleThicknessPt: number;
+  readonly radicalExtraAscenderPt: number;
+  readonly radicalVerticalGapPt: number;
+  readonly radicalKernBeforeDegreePt: number;
+  readonly radicalKernAfterDegreePt: number;
+  readonly radicalDegreeBottomRaisePercent: number;
+  readonly subscriptShiftDownPt: number;
+  readonly superscriptShiftUpPt: number;
+  readonly superscriptShiftUpCrampedPt: number;
+  readonly subSuperscriptGapMinPt: number;
+  readonly superscriptBaselineDropMaxPt: number;
+  readonly subscriptBaselineDropMinPt: number;
+  readonly spaceAfterScriptPt: number;
+  readonly upperLimitGapMinPt: number;
+  readonly upperLimitBaselineRiseMinPt: number;
+  readonly lowerLimitGapMinPt: number;
+  readonly lowerLimitBaselineDropMinPt: number;
+  readonly stackTopShiftUpPt: number;
+  readonly stackBottomShiftDownPt: number;
+  readonly stackGapMinPt: number;
+  readonly scriptPercentScaleDown: number;
+  readonly scriptScriptPercentScaleDown: number;
+  readonly defaultRuleThicknessPt: number;
+  glyph(codePoint: number, sizePt: number): MathGlyphMetrics | undefined;
+}
+//#endregion
+//#region src/formula.d.ts
+interface PositionedFormula {
+  readonly pageIndex: number;
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly box: MathBox;
+}
+//#endregion
+//#region src/afm-widths.d.ts
+type StandardFontName = 'Helvetica' | 'Helvetica-Bold' | 'Helvetica-Oblique' | 'Helvetica-BoldOblique' | 'Times-Roman' | 'Times-Bold' | 'Times-Italic' | 'Times-BoldItalic' | 'Courier' | 'Courier-Bold' | 'Courier-Oblique' | 'Courier-BoldOblique';
+interface FontMetrics {
+  readonly ascender: number;
+  readonly descender: number;
+  readonly capHeight: number;
+  readonly xHeight: number;
+  readonly italicAngle: number;
+  readonly fontBBox: readonly [number, number, number, number];
+  readonly underlinePosition: number;
+  readonly underlineThickness: number;
+  readonly lineHeightEm: number;
+  readonly fixedWidth?: number;
+  readonly widths: ReadonlyMap<string, number>;
+}
+declare const STANDARD_METRICS: Readonly<Record<StandardFontName, FontMetrics>>;
+//#endregion
+//#region src/winansi.d.ts
+interface WinAnsiSubstitution {
+  readonly from: string;
+  readonly to: string;
+}
+//#endregion
+//#region src/write.d.ts
+interface WritePdfOptions {
+  readonly compress?: boolean;
+  readonly signal?: AbortSignal;
+  readonly onSubstitution?: (substitution: WinAnsiSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+  readonly formulas?: readonly PositionedFormula[];
+}
+declare function writePdf(doc: LayoutDocument, options?: WritePdfOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/codec.d.ts
+declare const PdfBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodObject<{
+  formatVersion: z.ZodLiteral<1>;
+  metadata: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    creator: z.ZodOptional<z.ZodString>;
+    producer: z.ZodOptional<z.ZodString>;
+    createdIso: z.ZodOptional<z.ZodString>;
+    modifiedIso: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  pages: z.ZodArray<z.ZodObject<{
+    widthPt: z.ZodNumber;
+    heightPt: z.ZodNumber;
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"text">;
+      text: z.ZodString;
+      xPt: z.ZodNumber;
+      yPt: z.ZodNumber;
+      font: z.ZodObject<{
+        family: z.ZodString;
+        weight: z.ZodEnum<{
+          normal: "normal";
+          bold: "bold";
+        }>;
+        style: z.ZodEnum<{
+          normal: "normal";
+          italic: "italic";
+        }>;
+      }, z.core.$strip>;
+      sizePt: z.ZodNumber;
+      color: z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+      }, z.core.$strip>;
+      widthPt: z.ZodOptional<z.ZodNumber>;
+      rotationDeg: z.ZodOptional<z.ZodNumber>;
+      underline: z.ZodOptional<z.ZodBoolean>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"image">;
+      imageId: z.ZodString;
+      xPt: z.ZodNumber;
+      yPt: z.ZodNumber;
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+      rotationDeg: z.ZodOptional<z.ZodNumber>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"rect">;
+      xPt: z.ZodNumber;
+      yPt: z.ZodNumber;
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+      fill: z.ZodOptional<z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+      }, z.core.$strip>>;
+      stroke: z.ZodOptional<z.ZodObject<{
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        widthPt: z.ZodNumber;
+      }, z.core.$strip>>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"line">;
+      x1Pt: z.ZodNumber;
+      y1Pt: z.ZodNumber;
+      x2Pt: z.ZodNumber;
+      y2Pt: z.ZodNumber;
+      color: z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+      }, z.core.$strip>;
+      widthPt: z.ZodNumber;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"ellipse">;
+      xPt: z.ZodNumber;
+      yPt: z.ZodNumber;
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+      fill: z.ZodOptional<z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+      }, z.core.$strip>>;
+      stroke: z.ZodOptional<z.ZodObject<{
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        widthPt: z.ZodNumber;
+      }, z.core.$strip>>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"path">;
+      subpaths: z.ZodArray<z.ZodObject<{
+        startXPt: z.ZodNumber;
+        startYPt: z.ZodNumber;
+        segments: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"line">;
+          xPt: z.ZodNumber;
+          yPt: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"cubic">;
+          c1xPt: z.ZodNumber;
+          c1yPt: z.ZodNumber;
+          c2xPt: z.ZodNumber;
+          c2yPt: z.ZodNumber;
+          xPt: z.ZodNumber;
+          yPt: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+        closed: z.ZodBoolean;
+      }, z.core.$strip>>;
+      fill: z.ZodOptional<z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+      }, z.core.$strip>>;
+      fillRule: z.ZodOptional<z.ZodEnum<{
+        nonzero: "nonzero";
+        evenodd: "evenodd";
+      }>>;
+      stroke: z.ZodOptional<z.ZodObject<{
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        widthPt: z.ZodNumber;
+      }, z.core.$strip>>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"link">;
+      uri: z.ZodString;
+      xPt: z.ZodNumber;
+      yPt: z.ZodNumber;
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>;
+    notes: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  images: z.ZodRecord<z.ZodString, z.ZodObject<{
+    format: z.ZodEnum<{
+      png: "png";
+      jpeg: "jpeg";
+    }>;
+    base64: z.ZodString;
+    widthPx: z.ZodNumber;
+    heightPx: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+//#endregion
+//#region src/math-font.d.ts
+interface MathFontDescriptorMetrics {
+  readonly unitsPerEm: number;
+  readonly ascent: number;
+  readonly descent: number;
+  readonly capHeight: number;
+  readonly bboxMin: readonly [number, number];
+  readonly bboxMax: readonly [number, number];
+  readonly italicAngle: number;
+}
+interface MathFont {
+  readonly metrics: MathFontMetrics;
+  readonly cffBytes: Uint8Array<ArrayBuffer>;
+  readonly descriptor: MathFontDescriptorMetrics;
+  glyphId(codePoint: number): number | undefined;
+  glyphSpaceWidth(glyphId: number): number;
+}
+interface LoadedMathFont {
+  readonly font: MathFont;
+  readonly metricsAt: (sizePt: number) => MathFontMetrics;
+}
+declare function loadMathFont(): LoadedMathFont;
+//#endregion
+//#region src/measure.d.ts
+interface UnderlineMetrics {
+  readonly offsetPt: number;
+  readonly thicknessPt: number;
+}
+interface TextMeasurer {
+  widthOfTextAtSize(text: string, font: LayoutFont, sizePt: number): number;
+  lineHeightAtSize(font: LayoutFont, sizePt: number): number;
+  ascenderAtSize(font: LayoutFont, sizePt: number): number;
+  descenderAtSize(font: LayoutFont, sizePt: number): number;
+  underlineAtSize(font: LayoutFont, sizePt: number): UnderlineMetrics;
+  horizontalScaleFor(font: LayoutFont): number;
+}
+interface StandardFontMeasurerOptions {
+  readonly widthCorrectionByFamily?: Readonly<Record<string, number>>;
+}
+declare function createStandardFontMeasurer(options?: StandardFontMeasurerOptions): TextMeasurer;
+//#endregion
+//#region src/text-layout.d.ts
+interface StyledRun {
+  readonly text: string;
+  readonly font: LayoutFont;
+  readonly sizePt: number;
+  readonly color: Color;
+  readonly underline?: boolean;
+  readonly hyperlink?: string;
+  readonly sourcePath?: string;
+}
+interface StyledFragment {
+  readonly text: string;
+  readonly font: LayoutFont;
+  readonly sizePt: number;
+  readonly color: Color;
+  readonly underline?: boolean;
+  readonly hyperlink?: string;
+  readonly sourcePath?: string;
+}
+interface WrappedLine {
+  readonly fragments: readonly (StyledFragment & {
+    readonly xOffsetPt: number;
+  })[];
+  readonly widthPt: number;
+  readonly maxSizePt: number;
+  readonly ascentPt: number;
+  readonly descentPt: number;
+}
+interface WrapOptions {
+  readonly breakLongWords?: boolean;
+}
+declare function wrapRunsToWidth(runs: readonly StyledRun[], measurer: TextMeasurer, maxWidthPt: number, options?: WrapOptions): WrappedLine[];
+//#endregion
+//#region src/fonts.d.ts
+interface ResolvedFont {
+  readonly standardName: StandardFontName;
+  readonly matched: boolean;
+}
+declare function resolveStandardFont(family: string, bold: boolean, italic: boolean): ResolvedFont;
+//#endregion
+//#region src/bytes/crc32.d.ts
+declare function crc32(bytes: Uint8Array<ArrayBuffer>): number;
+//#endregion
+//#region src/bytes/flate.d.ts
+declare const MAX_INFLATE_OUTPUT_BYTES: number;
+type DeflateLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+declare function deflate(data: Uint8Array<ArrayBuffer>, level?: DeflateLevel): Uint8Array<ArrayBuffer>;
+declare function inflate(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+interface InflateResult {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly recovered: boolean;
+}
+declare function inflateTolerant(data: Uint8Array<ArrayBuffer>): InflateResult;
+//#endregion
+//#region src/bytes/reader.d.ts
+declare function isAsciiWhitespace(byte: number | undefined): boolean;
+declare class ByteReader {
+  private readonly bytes;
+  private position;
+  constructor(bytes: Uint8Array<ArrayBuffer>);
+  get offset(): number;
+  get length(): number;
+  atEnd(): boolean;
+  peek(aheadBy?: number): number | undefined;
+  next(): number | undefined;
+  mark(): number;
+  reset(mark: number): void;
+  seek(offset: number): void;
+  slice(start: number, end: number): Uint8Array<ArrayBuffer>;
+  skipWhitespace(): void;
+  matchKeyword(keyword: string): boolean;
+}
+//#endregion
+//#region src/bytes/writer.d.ts
+declare class ByteWriter {
+  private readonly chunks;
+  private byteLength;
+  get length(): number;
+  writeBytes(bytes: Uint8Array<ArrayBuffer>): void;
+  writeByte(byte: number): void;
+  writeAscii(text: string): void;
+  toBytes(): Uint8Array<ArrayBuffer>;
+}
+declare function concatBytes(chunks: readonly Uint8Array<ArrayBuffer>[]): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/image/jpeg-info.d.ts
+interface JpegInfo {
+  readonly width: number;
+  readonly height: number;
+  readonly components: number;
+  readonly precision: number;
+  readonly progressive: boolean;
+  readonly adobeTransform: number | undefined;
+}
+declare function readJpegInfo(bytes: Uint8Array<ArrayBuffer>): JpegInfo;
+//#endregion
+//#region src/image/png-decode.d.ts
+interface RawImage {
+  readonly width: number;
+  readonly height: number;
+  readonly channels: 1 | 3;
+  readonly data: Uint8Array<ArrayBuffer>;
+  readonly alpha?: Uint8Array<ArrayBuffer>;
+}
+interface PngDecodeOptions {
+  readonly onWarning?: (message: string) => void;
+}
+declare function decodePng(bytes: Uint8Array<ArrayBuffer>, options?: PngDecodeOptions): RawImage;
+//#endregion
+//#region src/image/png-encode.d.ts
+interface PngEncodeOptions {
+  readonly filter?: 'none' | 'adaptive';
+}
+declare function encodePng(image: RawImage, options?: PngEncodeOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/image/png-filter.d.ts
+type PngFilterType = 0 | 1 | 2 | 3 | 4;
+declare function unfilterScanlines(data: Uint8Array<ArrayBuffer>, height: number, bytesPerRow: number, bpp: number): Uint8Array<ArrayBuffer>;
+declare function filterScanlines(raw: Uint8Array<ArrayBuffer>, height: number, bytesPerRow: number, bpp: number, strategy?: 'none' | 'adaptive'): Uint8Array<ArrayBuffer>;
+//#endregion
+export { ByteReader, ByteWriter, type DeflateLevel, type FontMetrics, type InflateResult, type JpegInfo, type LoadedMathFont, MAX_INFLATE_OUTPUT_BYTES, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphMetrics, type MathGlyphRun, type MathLayoutItem, type MathRule, type MathStroke, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, type PngDecodeOptions, type PngEncodeOptions, type PngFilterType, type Point, type PositionedFormula, type RawImage, type ReadPdfOptions, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, concatBytes, crc32, createStandardFontMeasurer, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, pdfCodec, readJpegInfo, readPdf, resolveStandardFont, rotatePointAboutCenter, unfilterScanlines, wrapRunsToWidth, writePdf };