@f-o-t/pdf 0.1.0 → 0.1.4

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./objects.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/core/objects.d.ts

@@ -0,0 +1,42 @@
+import type { PDFArray, PDFDictionary, PDFName, PDFRef, PDFStream, PDFValue } from "../types.ts";
+/**
+ * Create a PDF Name object
+ */
+export declare function createName(value: string): PDFName;
+/**
+ * Create a PDF Reference
+ */
+export declare function createRef(objectNumber: number, generation?: number): PDFRef;
+/**
+ * Create a PDF Dictionary
+ */
+export declare function createDictionary(entries?: Record<string, PDFValue>): PDFDictionary;
+/**
+ * Create a PDF Array
+ */
+export declare function createArray(values?: PDFValue[]): PDFArray;
+/**
+ * Create a PDF Stream
+ */
+export declare function createStream(data: Uint8Array, dictionary?: PDFDictionary): PDFStream;
+/**
+ * Type guard for PDF Reference
+ */
+export declare function isRef(value: unknown): value is PDFRef;
+/**
+ * Type guard for PDF Name
+ */
+export declare function isName(value: unknown): value is PDFName;
+/**
+ * Type guard for PDF Dictionary
+ */
+export declare function isDictionary(value: unknown): value is PDFDictionary;
+/**
+ * Type guard for PDF Stream
+ */
+export declare function isStream(value: unknown): value is PDFStream;
+/**
+ * Type guard for PDF Array
+ */
+export declare function isArray(value: unknown): value is PDFArray;
+//# sourceMappingURL=objects.d.ts.map

package/dist/core/objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../src/core/objects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACT,QAAQ,EACR,aAAa,EACb,OAAO,EACP,MAAM,EACN,SAAS,EACT,QAAQ,EACV,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,SAAI,GAAG,MAAM,CAUtE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAClC,aAAa,CAKf;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,GAAE,QAAQ,EAAO,GAAG,QAAQ,CAE7D;AAED;;GAEG;AACH,wBAAgB,YAAY,CACzB,IAAI,EAAE,UAAU,EAChB,UAAU,CAAC,EAAE,aAAa,GAC1B,SAAS,CAKX;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CASrD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CASvD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CASnE;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAU3D;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAEzD"}

package/dist/errors.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Base error class for all PDF errors
+ */
+export declare class PDFError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when PDF parsing fails
+ */
+export declare class PDFParseError extends PDFError {
+    readonly offset?: number | undefined;
+    constructor(message: string, offset?: number | undefined);
+}
+/**
+ * Error thrown when PDF generation fails
+ */
+export declare class PDFGenerationError extends PDFError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when PDF object is invalid
+ */
+export declare class InvalidPDFObjectError extends PDFError {
+    readonly objectType: string;
+    constructor(objectType: string, reason: string);
+}
+/**
+ * Error thrown when font is not found
+ */
+export declare class FontNotFoundError extends PDFError {
+    readonly fontName: string;
+    constructor(fontName: string);
+}
+/**
+ * Error thrown when image is invalid
+ */
+export declare class InvalidImageError extends PDFError {
+    constructor(reason: string);
+}
+/**
+ * Error thrown when PDF signature fails
+ */
+export declare class PDFSignatureError extends PDFError {
+    constructor(reason: string);
+}
+/**
+ * Error thrown when PDF encryption fails
+ */
+export declare class PDFEncryptionError extends PDFError {
+    constructor(reason: string);
+}
+/**
+ * Error thrown when required feature is not implemented
+ */
+export declare class NotImplementedError extends PDFError {
+    constructor(feature: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,QAAS,SAAQ,KAAK;gBACpB,OAAO,EAAE,MAAM;CAO7B;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,QAAQ;aAGrB,MAAM,CAAC,EAAE,MAAM;gBAD/B,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,MAAM,YAAA;CAKpC;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,QAAQ;gBACjC,OAAO,EAAE,MAAM;CAI7B;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,QAAQ;aAE7B,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM,EAClC,MAAM,EAAE,MAAM;CAKnB;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,QAAQ;aAChB,QAAQ,EAAE,MAAM;gBAAhB,QAAQ,EAAE,MAAM;CAI9C;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,QAAQ;gBAChC,MAAM,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,QAAQ;gBAChC,MAAM,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,QAAQ;gBACjC,MAAM,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,QAAQ;gBAClC,OAAO,EAAE,MAAM;CAI7B"}

package/dist/index-4jtcmpfh.js

@@ -0,0 +1,48 @@
+// @bun
+// src/core/objects.ts
+function createName(value) {
+  return { type: "name", value };
+}
+function createRef(objectNumber, generation = 0) {
+  if (objectNumber < 1) {
+    throw new Error(`Object number must be positive, got ${objectNumber}`);
+  }
+  if (generation < 0 || generation > 65535) {
+    throw new Error(`Generation number must be between 0 and 65535, got ${generation}`);
+  }
+  return { objectNumber, generation };
+}
+function createDictionary(entries) {
+  if (entries) {
+    return { ...entries };
+  }
+  return {};
+}
+function createArray(values = []) {
+  return values;
+}
+function createStream(data, dictionary) {
+  return {
+    dictionary: dictionary ?? createDictionary(),
+    data
+  };
+}
+function isRef(value) {
+  return typeof value === "object" && value !== null && "objectNumber" in value && "generation" in value && typeof value.objectNumber === "number" && typeof value.generation === "number";
+}
+function isName(value) {
+  return typeof value === "object" && value !== null && "type" in value && value.type === "name" && "value" in value && typeof value.value === "string";
+}
+function isDictionary(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !isRef(value) && !isName(value) && !isStream(value);
+}
+function isStream(value) {
+  return typeof value === "object" && value !== null && "dictionary" in value && "data" in value && typeof value.dictionary === "object" && value.dictionary !== null && value.data instanceof Uint8Array;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+
+export { createName, createRef, createDictionary, createArray, createStream, isRef, isName, isDictionary, isStream, isArray };
+
+//# debugId=EFECF6FCAFD31BCA64756E2164756E21

package/dist/index-4jtcmpfh.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/core/objects.ts"],
+  "sourcesContent": [
+    "import type {\n   PDFArray,\n   PDFDictionary,\n   PDFName,\n   PDFRef,\n   PDFStream,\n   PDFValue,\n} from \"../types.ts\";\n\n/**\n * Create a PDF Name object\n */\nexport function createName(value: string): PDFName {\n   return { type: \"name\", value };\n}\n\n/**\n * Create a PDF Reference\n */\nexport function createRef(objectNumber: number, generation = 0): PDFRef {\n   if (objectNumber < 1) {\n      throw new Error(`Object number must be positive, got ${objectNumber}`);\n   }\n   if (generation < 0 || generation > 65535) {\n      throw new Error(\n         `Generation number must be between 0 and 65535, got ${generation}`,\n      );\n   }\n   return { objectNumber, generation };\n}\n\n/**\n * Create a PDF Dictionary\n */\nexport function createDictionary(\n   entries?: Record<string, PDFValue>,\n): PDFDictionary {\n   if (entries) {\n      return { ...entries };\n   }\n   return {};\n}\n\n/**\n * Create a PDF Array\n */\nexport function createArray(values: PDFValue[] = []): PDFArray {\n   return values;\n}\n\n/**\n * Create a PDF Stream\n */\nexport function createStream(\n   data: Uint8Array,\n   dictionary?: PDFDictionary,\n): PDFStream {\n   return {\n      dictionary: dictionary ?? createDictionary(),\n      data,\n   };\n}\n\n/**\n * Type guard for PDF Reference\n */\nexport function isRef(value: unknown): value is PDFRef {\n   return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"objectNumber\" in value &&\n      \"generation\" in value &&\n      typeof (value as PDFRef).objectNumber === \"number\" &&\n      typeof (value as PDFRef).generation === \"number\"\n   );\n}\n\n/**\n * Type guard for PDF Name\n */\nexport function isName(value: unknown): value is PDFName {\n   return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"type\" in value &&\n      (value as PDFName).type === \"name\" &&\n      \"value\" in value &&\n      typeof (value as PDFName).value === \"string\"\n   );\n}\n\n/**\n * Type guard for PDF Dictionary\n */\nexport function isDictionary(value: unknown): value is PDFDictionary {\n   return (\n      typeof value === \"object\" &&\n      value !== null &&\n      !Array.isArray(value) &&\n      !isRef(value) &&\n      !isName(value) &&\n      !isStream(value)\n   );\n}\n\n/**\n * Type guard for PDF Stream\n */\nexport function isStream(value: unknown): value is PDFStream {\n   return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"dictionary\" in value &&\n      \"data\" in value &&\n      typeof (value as PDFStream).dictionary === \"object\" &&\n      (value as PDFStream).dictionary !== null &&\n      (value as PDFStream).data instanceof Uint8Array\n   );\n}\n\n/**\n * Type guard for PDF Array\n */\nexport function isArray(value: unknown): value is PDFArray {\n   return Array.isArray(value);\n}\n"
+  ],
+  "mappings": ";;AAYO,SAAS,UAAU,CAAC,OAAwB;AAAA,EAChD,OAAO,EAAE,MAAM,QAAQ,MAAM;AAAA;AAMzB,SAAS,SAAS,CAAC,cAAsB,aAAa,GAAW;AAAA,EACrE,IAAI,eAAe,GAAG;AAAA,IACnB,MAAM,IAAI,MAAM,uCAAuC,cAAc;AAAA,EACxE;AAAA,EACA,IAAI,aAAa,KAAK,aAAa,OAAO;AAAA,IACvC,MAAM,IAAI,MACP,sDAAsD,YACzD;AAAA,EACH;AAAA,EACA,OAAO,EAAE,cAAc,WAAW;AAAA;AAM9B,SAAS,gBAAgB,CAC7B,SACc;AAAA,EACd,IAAI,SAAS;AAAA,IACV,OAAO,KAAK,QAAQ;AAAA,EACvB;AAAA,EACA,OAAO,CAAC;AAAA;AAMJ,SAAS,WAAW,CAAC,SAAqB,CAAC,GAAa;AAAA,EAC5D,OAAO;AAAA;AAMH,SAAS,YAAY,CACzB,MACA,YACU;AAAA,EACV,OAAO;AAAA,IACJ,YAAY,cAAc,iBAAiB;AAAA,IAC3C;AAAA,EACH;AAAA;AAMI,SAAS,KAAK,CAAC,OAAiC;AAAA,EACpD,OACG,OAAO,UAAU,YACjB,UAAU,QACV,kBAAkB,SAClB,gBAAgB,SAChB,OAAQ,MAAiB,iBAAiB,YAC1C,OAAQ,MAAiB,eAAe;AAAA;AAOvC,SAAS,MAAM,CAAC,OAAkC;AAAA,EACtD,OACG,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAAkB,SAAS,UAC5B,WAAW,SACX,OAAQ,MAAkB,UAAU;AAAA;AAOnC,SAAS,YAAY,CAAC,OAAwC;AAAA,EAClE,OACG,OAAO,UAAU,YACjB,UAAU,QACV,CAAC,MAAM,QAAQ,KAAK,KACpB,CAAC,MAAM,KAAK,KACZ,CAAC,OAAO,KAAK,KACb,CAAC,SAAS,KAAK;AAAA;AAOd,SAAS,QAAQ,CAAC,OAAoC;AAAA,EAC1D,OACG,OAAO,UAAU,YACjB,UAAU,QACV,gBAAgB,SAChB,UAAU,SACV,OAAQ,MAAoB,eAAe,YAC1C,MAAoB,eAAe,QACnC,MAAoB,gBAAgB;AAAA;AAOpC,SAAS,OAAO,CAAC,OAAmC;AAAA,EACxD,OAAO,MAAM,QAAQ,KAAK;AAAA;",
+  "debugId": "EFECF6FCAFD31BCA64756E2164756E21",
+  "names": []
+}

package/dist/index-jsfksnj3.js

@@ -0,0 +1,503 @@
+// @bun
+import {
+  createArray,
+  createDictionary,
+  createName,
+  createRef,
+  createStream
+} from "./index-4jtcmpfh.js";
+
+// src/schemas.ts
+import { z } from "zod";
+var PDFRefSchema = z.object({
+  objectNumber: z.number().int().positive(),
+  generation: z.number().int().nonnegative()
+});
+var PDFNameSchema = z.object({
+  type: z.literal("name"),
+  value: z.string()
+});
+var PageSizeSchema = z.union([
+  z.enum(["A4", "Letter", "Legal", "A3", "A5", "Tabloid"]),
+  z.object({
+    width: z.number().positive(),
+    height: z.number().positive()
+  })
+]);
+var RGBColorSchema = z.object({
+  type: z.literal("rgb"),
+  r: z.number().min(0).max(1),
+  g: z.number().min(0).max(1),
+  b: z.number().min(0).max(1)
+});
+var CMYKColorSchema = z.object({
+  type: z.literal("cmyk"),
+  c: z.number().min(0).max(1),
+  m: z.number().min(0).max(1),
+  y: z.number().min(0).max(1),
+  k: z.number().min(0).max(1)
+});
+var GrayColorSchema = z.object({
+  type: z.literal("gray"),
+  gray: z.number().min(0).max(1)
+});
+var PDFColorSchema = z.union([
+  RGBColorSchema,
+  CMYKColorSchema,
+  GrayColorSchema
+]);
+var TextOptionsSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  size: z.number().positive().optional(),
+  font: z.string().optional(),
+  color: PDFColorSchema.optional(),
+  align: z.enum(["left", "center", "right"]).optional()
+});
+var RectOptionsSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  width: z.number().positive(),
+  height: z.number().positive(),
+  fill: PDFColorSchema.optional(),
+  stroke: PDFColorSchema.optional(),
+  lineWidth: z.number().positive().optional()
+});
+var LineOptionsSchema = z.object({
+  x1: z.number(),
+  y1: z.number(),
+  x2: z.number(),
+  y2: z.number(),
+  color: PDFColorSchema.optional(),
+  lineWidth: z.number().positive().optional()
+});
+var PDFMetadataSchema = z.object({
+  title: z.string().optional(),
+  author: z.string().optional(),
+  subject: z.string().optional(),
+  keywords: z.array(z.string()).optional(),
+  creator: z.string().optional(),
+  producer: z.string().optional(),
+  creationDate: z.date().optional(),
+  modificationDate: z.date().optional()
+});
+var PDFDictionarySchema = z.lazy(() => z.record(z.string(), PDFValueSchema));
+var PDFArraySchema = z.lazy(() => z.array(PDFValueSchema));
+var PDFStreamSchema = z.object({
+  dictionary: PDFDictionarySchema,
+  data: z.instanceof(Uint8Array)
+});
+var PDFValueSchema = z.lazy(() => z.union([
+  z.boolean(),
+  z.number(),
+  z.string(),
+  PDFNameSchema,
+  PDFArraySchema,
+  PDFDictionarySchema,
+  PDFStreamSchema,
+  z.null(),
+  PDFRefSchema
+]));
+var PDFIndirectObjectSchema = z.object({
+  ref: PDFRefSchema,
+  value: PDFValueSchema
+});
+var PDFObjectTypeSchema = z.enum([
+  "boolean",
+  "number",
+  "string",
+  "name",
+  "array",
+  "dictionary",
+  "stream",
+  "null",
+  "indirect"
+]);
+var PDFVersionSchema = z.enum(["1.4", "1.5", "1.6", "1.7"]);
+
+// src/plugins/generation/fonts.ts
+var STANDARD_FONTS = {
+  "Times-Roman": "Times-Roman",
+  "Times-Bold": "Times-Bold",
+  "Times-Italic": "Times-Italic",
+  "Times-BoldItalic": "Times-BoldItalic",
+  Helvetica: "Helvetica",
+  "Helvetica-Bold": "Helvetica-Bold",
+  "Helvetica-Oblique": "Helvetica-Oblique",
+  "Helvetica-BoldOblique": "Helvetica-BoldOblique",
+  Courier: "Courier",
+  "Courier-Bold": "Courier-Bold",
+  "Courier-Oblique": "Courier-Oblique",
+  "Courier-BoldOblique": "Courier-BoldOblique",
+  Symbol: "Symbol",
+  ZapfDingbats: "ZapfDingbats"
+};
+var FONT_FAMILIES = {
+  times: {
+    regular: "Times-Roman",
+    bold: "Times-Bold",
+    italic: "Times-Italic",
+    boldItalic: "Times-BoldItalic"
+  },
+  helvetica: {
+    regular: "Helvetica",
+    bold: "Helvetica-Bold",
+    oblique: "Helvetica-Oblique",
+    boldOblique: "Helvetica-BoldOblique"
+  },
+  courier: {
+    regular: "Courier",
+    bold: "Courier-Bold",
+    oblique: "Courier-Oblique",
+    boldOblique: "Courier-BoldOblique"
+  },
+  symbol: {
+    regular: "Symbol"
+  },
+  zapfDingbats: {
+    regular: "ZapfDingbats"
+  }
+};
+function isStandardFont(font) {
+  return font in STANDARD_FONTS;
+}
+function getFontRefName(font) {
+  return `F${Object.keys(STANDARD_FONTS).indexOf(font) + 1}`;
+}
+
+// src/plugins/generation/page.ts
+var PAGE_SIZES = {
+  A4: { width: 595, height: 842 },
+  Letter: { width: 612, height: 792 },
+  Legal: { width: 612, height: 1008 },
+  A3: { width: 842, height: 1191 },
+  A5: { width: 420, height: 595 },
+  Tabloid: { width: 792, height: 1224 }
+};
+
+class PDFPage {
+  ref;
+  size;
+  parent;
+  contentStream = [];
+  resources;
+  constructor(ref, options = {}) {
+    this.ref = ref;
+    this.size = PageSizeSchema.parse(options.size ?? "A4");
+    this.parent = options.parent;
+    this.resources = createDictionary({
+      Font: createDictionary()
+    });
+  }
+  getDimensions() {
+    if (typeof this.size === "string") {
+      return PAGE_SIZES[this.size];
+    }
+    return this.size;
+  }
+  setFillColor(color) {
+    if (color.type === "rgb") {
+      this.contentStream.push(`${color.r} ${color.g} ${color.b} rg`);
+    } else if (color.type === "cmyk") {
+      this.contentStream.push(`${color.c} ${color.m} ${color.y} ${color.k} k`);
+    } else if (color.type === "gray") {
+      this.contentStream.push(`${color.gray} g`);
+    }
+  }
+  setStrokeColor(color) {
+    if (color.type === "rgb") {
+      this.contentStream.push(`${color.r} ${color.g} ${color.b} RG`);
+    } else if (color.type === "cmyk") {
+      this.contentStream.push(`${color.c} ${color.m} ${color.y} ${color.k} K`);
+    } else if (color.type === "gray") {
+      this.contentStream.push(`${color.gray} G`);
+    }
+  }
+  drawText(text, options) {
+    const validOptions = TextOptionsSchema.parse(options);
+    const { x, y, size = 12, font = "Helvetica", color, align = "left" } = validOptions;
+    const fontName = font || "Helvetica";
+    if (!isStandardFont(fontName)) {
+      throw new Error(`Font "${fontName}" is not a standard PDF font. Use one of: ${Object.keys(STANDARD_FONTS).join(", ")}`);
+    }
+    const fontRefName = getFontRefName(fontName);
+    const fontDict = this.resources.Font;
+    if (!fontDict[fontRefName]) {
+      const fontObj = createDictionary({
+        Type: createName("Font"),
+        Subtype: createName("Type1"),
+        BaseFont: createName(fontName)
+      });
+      fontDict[fontRefName] = fontObj;
+    }
+    let xPos = x;
+    if (align === "center") {
+      xPos = x - text.length * size * 0.3;
+    } else if (align === "right") {
+      xPos = x - text.length * size * 0.6;
+    }
+    if (color) {
+      this.setFillColor(color);
+    }
+    this.contentStream.push("BT");
+    this.contentStream.push(`/${fontRefName} ${size} Tf`);
+    this.contentStream.push(`${xPos} ${y} Td`);
+    const escapedText = text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+    this.contentStream.push(`(${escapedText}) Tj`);
+    this.contentStream.push("ET");
+  }
+  drawRectangle(options) {
+    const validOptions = RectOptionsSchema.parse(options);
+    const { x, y, width, height, fill, stroke, lineWidth = 1 } = validOptions;
+    if (lineWidth && stroke) {
+      this.contentStream.push(`${lineWidth} w`);
+    }
+    if (fill) {
+      this.setFillColor(fill);
+    }
+    if (stroke) {
+      this.setStrokeColor(stroke);
+    }
+    this.contentStream.push(`${x} ${y} ${width} ${height} re`);
+    if (fill && stroke) {
+      this.contentStream.push("B");
+    } else if (fill) {
+      this.contentStream.push("f");
+    } else if (stroke) {
+      this.contentStream.push("S");
+    } else {
+      this.contentStream.push("S");
+    }
+  }
+  drawLine(options) {
+    const validOptions = LineOptionsSchema.parse(options);
+    const { x1, y1, x2, y2, color, lineWidth = 1 } = validOptions;
+    if (lineWidth) {
+      this.contentStream.push(`${lineWidth} w`);
+    }
+    if (color) {
+      this.setStrokeColor(color);
+    }
+    this.contentStream.push(`${x1} ${y1} m`);
+    this.contentStream.push(`${x2} ${y2} l`);
+    this.contentStream.push("S");
+  }
+  getContentStreamRef() {
+    return createRef(this.ref.objectNumber + 1, 0);
+  }
+  toContentStream() {
+    const content = this.contentStream.join(`
+`);
+    const data = new TextEncoder().encode(content);
+    const dict = createDictionary({
+      Length: data.length
+    });
+    return createStream(data, dict);
+  }
+  toDictionary() {
+    const dims = this.getDimensions();
+    const dict = createDictionary({
+      Type: createName("Page"),
+      MediaBox: createArray([0, 0, dims.width, dims.height]),
+      Contents: this.getContentStreamRef(),
+      Resources: this.resources
+    });
+    if (this.parent) {
+      dict.Parent = this.parent;
+    }
+    return dict;
+  }
+}
+
+// src/plugins/generation/writer.ts
+function serializeValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "string") {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+    return `(${escaped})`;
+  }
+  if (isName(value)) {
+    return `/${value.value}`;
+  }
+  if (isRef(value)) {
+    return `${value.objectNumber} ${value.generation} R`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(serializeValue).join(" ")}]`;
+  }
+  if (typeof value === "object" && !Array.isArray(value)) {
+    const dict = value;
+    const entries = Object.entries(dict).map(([key, val]) => `/${key} ${serializeValue(val)}`).join(`
+`);
+    return `<<
+${entries}
+>>`;
+  }
+  return "";
+}
+function serializeStream(stream) {
+  const dictStr = serializeValue(stream.dictionary);
+  const header = new TextEncoder().encode(`${dictStr}
+stream
+`);
+  const footer = new TextEncoder().encode(`
+endstream`);
+  const result = new Uint8Array(header.length + stream.data.length + footer.length);
+  result.set(header, 0);
+  result.set(stream.data, header.length);
+  result.set(footer, header.length + stream.data.length);
+  return result;
+}
+function serializeObject(objectNumber, generation, value) {
+  const header = `${objectNumber} ${generation} obj
+`;
+  let body;
+  if (isStream(value)) {
+    body = serializeStream(value);
+  } else {
+    body = new TextEncoder().encode(serializeValue(value));
+  }
+  const footer = new TextEncoder().encode(`
+endobj
+`);
+  const result = new Uint8Array(header.length + body.length + footer.length);
+  result.set(new TextEncoder().encode(header), 0);
+  result.set(body, header.length);
+  result.set(footer, header.length + body.length);
+  return result;
+}
+function isName(value) {
+  return typeof value === "object" && value !== null && value.type === "name";
+}
+function isRef(value) {
+  return typeof value === "object" && value !== null && "objectNumber" in value && "generation" in value;
+}
+function isStream(value) {
+  return typeof value === "object" && value !== null && "data" in value && value.data instanceof Uint8Array;
+}
+
+// src/plugins/generation/document.ts
+class PDFDocument {
+  version;
+  metadata;
+  objects = new Map;
+  nextObjectNumber = 1;
+  catalog;
+  pages;
+  pagesArray = [];
+  constructor(options = {}) {
+    this.version = PDFVersionSchema.parse(options.version ?? "1.7");
+    this.metadata = PDFMetadataSchema.parse(options.metadata ?? {});
+    this.catalog = this.allocateRef();
+    this.pages = this.allocateRef();
+    const catalogDict = createDictionary({
+      Type: createName("Catalog"),
+      Pages: this.pages
+    });
+    this.objects.set(this.catalog.objectNumber, catalogDict);
+    const pagesDict = createDictionary({
+      Type: createName("Pages"),
+      Kids: createArray([]),
+      Count: 0
+    });
+    this.objects.set(this.pages.objectNumber, pagesDict);
+    if (Object.keys(this.metadata).length > 0) {
+      const infoRef = this.allocateRef();
+      const metadataDict = {};
+      if (this.metadata.title)
+        metadataDict.Title = this.metadata.title;
+      if (this.metadata.author)
+        metadataDict.Author = this.metadata.author;
+      if (this.metadata.subject)
+        metadataDict.Subject = this.metadata.subject;
+      if (this.metadata.creator)
+        metadataDict.Creator = this.metadata.creator;
+      if (this.metadata.producer)
+        metadataDict.Producer = this.metadata.producer;
+      const infoDict = createDictionary(metadataDict);
+      this.objects.set(infoRef.objectNumber, infoDict);
+    }
+  }
+  allocateRef() {
+    return createRef(this.nextObjectNumber++, 0);
+  }
+  addPage(options) {
+    const pageRef = this.allocateRef();
+    const contentStreamRef = this.allocateRef();
+    const page = new PDFPage(pageRef, { ...options, parent: this.pages });
+    this.pagesArray.push(page);
+    const pagesDict = this.objects.get(this.pages.objectNumber);
+    const kids = pagesDict.Kids;
+    kids.push(pageRef);
+    pagesDict.Count = pagesDict.Count + 1;
+    this.objects.set(pageRef.objectNumber, page.toDictionary());
+    this.objects.set(contentStreamRef.objectNumber, page.toContentStream());
+    return page;
+  }
+  save() {
+    for (const page of this.pagesArray) {
+      this.objects.set(page.ref.objectNumber, page.toDictionary());
+      const contentStreamRef = page.getContentStreamRef();
+      this.objects.set(contentStreamRef.objectNumber, page.toContentStream());
+    }
+    const parts = [];
+    const header = new TextEncoder().encode(`%PDF-${this.version}
+%\xE2\xE3\xCF\xD3
+`);
+    parts.push(header);
+    const offsets = [0];
+    let currentOffset = header.length;
+    const objectNumbers = Array.from(this.objects.keys()).sort((a, b) => a - b);
+    for (const objNum of objectNumbers) {
+      const obj = this.objects.get(objNum);
+      const objBytes = serializeObject(objNum, 0, obj);
+      parts.push(objBytes);
+      offsets[objNum] = currentOffset;
+      currentOffset += objBytes.length;
+    }
+    const xrefStart = currentOffset;
+    const xrefLines = [`xref
+0 ${offsets.length}
+`];
+    xrefLines.push(`0000000000 65535 f 
+`);
+    for (let i = 1;i < offsets.length; i++) {
+      const offset = offsets[i] || 0;
+      const offsetStr = offset.toString().padStart(10, "0");
+      xrefLines.push(`${offsetStr} 00000 n 
+`);
+    }
+    const xref = new TextEncoder().encode(xrefLines.join(""));
+    parts.push(xref);
+    const trailerDict = serializeValue(createDictionary({
+      Size: offsets.length,
+      Root: this.catalog
+    }));
+    const trailer = new TextEncoder().encode(`trailer
+${trailerDict}
+startxref
+${xrefStart}
+%%EOF
+`);
+    parts.push(trailer);
+    const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+    const result = new Uint8Array(totalLength);
+    let position = 0;
+    for (const part of parts) {
+      result.set(part, position);
+      position += part.length;
+    }
+    return result;
+  }
+}
+export { PDFRefSchema, PDFNameSchema, PageSizeSchema, RGBColorSchema, CMYKColorSchema, GrayColorSchema, PDFColorSchema, TextOptionsSchema, RectOptionsSchema, LineOptionsSchema, PDFMetadataSchema, PDFDictionarySchema, PDFArraySchema, PDFStreamSchema, PDFValueSchema, PDFIndirectObjectSchema, PDFObjectTypeSchema, PDFVersionSchema, STANDARD_FONTS, FONT_FAMILIES, isStandardFont, getFontRefName, PDFPage, serializeValue, serializeStream, serializeObject, PDFDocument };
+
+//# debugId=CC23B1DD7B3E218A64756E2164756E21