@f-o-t/pdf 0.1.0

package/dist/shared/chunk-37mjkw9w.js

@@ -0,0 +1,492 @@
+import {
+  createArray,
+  createDictionary,
+  createName,
+  createRef,
+  createStream
+} from "./chunk-6dengthp.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/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/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/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/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 infoDict = createDictionary({ ...this.metadata });
+      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}
+%âãÏÓ
+`);
+    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=D1F9D9F23EC0B1AD64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/schemas.ts", "src/generation/fonts.ts", "src/generation/page.ts", "src/generation/writer.ts", "src/generation/document.ts"],
  "sourcesContent": [
    "import { z } from \"zod\";\n\n/**\n * PDF Reference schema\n */\nexport const PDFRefSchema = z.object({\n   objectNumber: z.number().int().positive(),\n   generation: z.number().int().nonnegative(),\n});\n\n/**\n * PDF Name schema\n */\nexport const PDFNameSchema = z.object({\n   type: z.literal(\"name\"),\n   value: z.string(),\n});\n\n/**\n * Page size schema\n */\nexport const PageSizeSchema = z.union([\n   z.enum([\"A4\", \"Letter\", \"Legal\", \"A3\", \"A5\", \"Tabloid\"]),\n   z.object({\n      width: z.number().positive(),\n      height: z.number().positive(),\n   }),\n]);\n\n/**\n * RGB color schema\n */\nexport const RGBColorSchema = z.object({\n   type: z.literal(\"rgb\"),\n   r: z.number().min(0).max(1),\n   g: z.number().min(0).max(1),\n   b: z.number().min(0).max(1),\n});\n\n/**\n * CMYK color schema\n */\nexport const CMYKColorSchema = z.object({\n   type: z.literal(\"cmyk\"),\n   c: z.number().min(0).max(1),\n   m: z.number().min(0).max(1),\n   y: z.number().min(0).max(1),\n   k: z.number().min(0).max(1),\n});\n\n/**\n * Gray color schema\n */\nexport const GrayColorSchema = z.object({\n   type: z.literal(\"gray\"),\n   gray: z.number().min(0).max(1),\n});\n\n/**\n * PDF Color schema\n */\nexport const PDFColorSchema = z.union([\n   RGBColorSchema,\n   CMYKColorSchema,\n   GrayColorSchema,\n]);\n\n/**\n * Text options schema\n */\nexport const TextOptionsSchema = z.object({\n   x: z.number(),\n   y: z.number(),\n   size: z.number().positive().optional(),\n   font: z.string().optional(),\n   color: PDFColorSchema.optional(),\n   align: z.enum([\"left\", \"center\", \"right\"]).optional(),\n});\n\n/**\n * Rectangle options schema\n */\nexport const RectOptionsSchema = z.object({\n   x: z.number(),\n   y: z.number(),\n   width: z.number().positive(),\n   height: z.number().positive(),\n   fill: PDFColorSchema.optional(),\n   stroke: PDFColorSchema.optional(),\n   lineWidth: z.number().positive().optional(),\n});\n\n/**\n * Line options schema\n */\nexport const LineOptionsSchema = z.object({\n   x1: z.number(),\n   y1: z.number(),\n   x2: z.number(),\n   y2: z.number(),\n   color: PDFColorSchema.optional(),\n   lineWidth: z.number().positive().optional(),\n});\n\n/**\n * PDF metadata schema\n */\nexport const PDFMetadataSchema = z.object({\n   title: z.string().optional(),\n   author: z.string().optional(),\n   subject: z.string().optional(),\n   keywords: z.array(z.string()).optional(),\n   creator: z.string().optional(),\n   producer: z.string().optional(),\n   creationDate: z.date().optional(),\n   modificationDate: z.date().optional(),\n});\n\n/**\n * PDF Dictionary schema (recursive)\n */\nexport const PDFDictionarySchema: z.ZodType<Record<string, any>> = z.lazy(() =>\n   z.record(z.string(), PDFValueSchema),\n);\n\n/**\n * PDF Array schema (recursive)\n */\nexport const PDFArraySchema: z.ZodType<any[]> = z.lazy(() =>\n   z.array(PDFValueSchema),\n);\n\n/**\n * PDF Stream schema\n */\nexport const PDFStreamSchema = z.object({\n   dictionary: PDFDictionarySchema,\n   data: z.instanceof(Uint8Array),\n});\n\n/**\n * PDF Value schema (recursive union)\n */\nexport const PDFValueSchema: z.ZodType<any> = z.lazy(() =>\n   z.union([\n      z.boolean(),\n      z.number(),\n      z.string(),\n      PDFNameSchema,\n      PDFArraySchema,\n      PDFDictionarySchema,\n      PDFStreamSchema,\n      z.null(),\n      PDFRefSchema,\n   ]),\n);\n\n/**\n * PDF Indirect Object schema\n */\nexport const PDFIndirectObjectSchema = z.object({\n   ref: PDFRefSchema,\n   value: PDFValueSchema,\n});\n\n/**\n * PDF Object Type schema\n */\nexport const PDFObjectTypeSchema = z.enum([\n   \"boolean\",\n   \"number\",\n   \"string\",\n   \"name\",\n   \"array\",\n   \"dictionary\",\n   \"stream\",\n   \"null\",\n   \"indirect\",\n]);\n\n/**\n * PDF version schema\n */\nexport const PDFVersionSchema = z.enum([\"1.4\", \"1.5\", \"1.6\", \"1.7\"]);\n",
    "/**\n * PDF Standard 14 Fonts\n * These fonts are guaranteed to be available in all PDF readers\n */\nexport const STANDARD_FONTS = {\n   // Serif fonts\n   \"Times-Roman\": \"Times-Roman\",\n   \"Times-Bold\": \"Times-Bold\",\n   \"Times-Italic\": \"Times-Italic\",\n   \"Times-BoldItalic\": \"Times-BoldItalic\",\n\n   // Sans-serif fonts\n   Helvetica: \"Helvetica\",\n   \"Helvetica-Bold\": \"Helvetica-Bold\",\n   \"Helvetica-Oblique\": \"Helvetica-Oblique\",\n   \"Helvetica-BoldOblique\": \"Helvetica-BoldOblique\",\n\n   // Monospace fonts\n   Courier: \"Courier\",\n   \"Courier-Bold\": \"Courier-Bold\",\n   \"Courier-Oblique\": \"Courier-Oblique\",\n   \"Courier-BoldOblique\": \"Courier-BoldOblique\",\n\n   // Symbol fonts\n   Symbol: \"Symbol\",\n   ZapfDingbats: \"ZapfDingbats\",\n} as const;\n\nexport type StandardFont = keyof typeof STANDARD_FONTS;\n\n/**\n * Font families for convenience\n */\nexport const FONT_FAMILIES = {\n   times: {\n      regular: \"Times-Roman\" as StandardFont,\n      bold: \"Times-Bold\" as StandardFont,\n      italic: \"Times-Italic\" as StandardFont,\n      boldItalic: \"Times-BoldItalic\" as StandardFont,\n   },\n   helvetica: {\n      regular: \"Helvetica\" as StandardFont,\n      bold: \"Helvetica-Bold\" as StandardFont,\n      oblique: \"Helvetica-Oblique\" as StandardFont,\n      boldOblique: \"Helvetica-BoldOblique\" as StandardFont,\n   },\n   courier: {\n      regular: \"Courier\" as StandardFont,\n      bold: \"Courier-Bold\" as StandardFont,\n      oblique: \"Courier-Oblique\" as StandardFont,\n      boldOblique: \"Courier-BoldOblique\" as StandardFont,\n   },\n   symbol: {\n      regular: \"Symbol\" as StandardFont,\n   },\n   zapfDingbats: {\n      regular: \"ZapfDingbats\" as StandardFont,\n   },\n};\n\n/**\n * Check if a font is a standard PDF font\n */\nexport function isStandardFont(font: string): font is StandardFont {\n   return font in STANDARD_FONTS;\n}\n\n/**\n * Get font object reference name\n */\nexport function getFontRefName(font: StandardFont): string {\n   return `F${Object.keys(STANDARD_FONTS).indexOf(font) + 1}`;\n}\n",
    "import type { PDFRef, PDFDictionary, PageSize, TextOptions, RectOptions, LineOptions, PDFColor, PDFStream } from \"../types.ts\";\nimport {\n   createDictionary,\n   createName,\n   createArray,\n   createRef,\n   createStream,\n} from \"../core/objects.ts\";\nimport { PageSizeSchema, TextOptionsSchema, RectOptionsSchema, LineOptionsSchema } from \"../schemas.ts\";\nimport { STANDARD_FONTS, isStandardFont, getFontRefName, type StandardFont } from \"./fonts.ts\";\n\nexport type PDFPageOptions = {\n   size?: PageSize;\n   parent?: PDFRef;\n};\n\n// Standard page sizes in points (1/72 inch)\nconst PAGE_SIZES = {\n   A4: { width: 595, height: 842 },\n   Letter: { width: 612, height: 792 },\n   Legal: { width: 612, height: 1008 },\n   A3: { width: 842, height: 1191 },\n   A5: { width: 420, height: 595 },\n   Tabloid: { width: 792, height: 1224 },\n};\n\n/**\n * PDF Page class\n */\nexport class PDFPage {\n   ref: PDFRef;\n   size: PageSize;\n   parent?: PDFRef;\n   contentStream: string[] = [];\n   private resources: PDFDictionary;\n\n   constructor(ref: PDFRef, options: PDFPageOptions = {}) {\n      this.ref = ref;\n      this.size = PageSizeSchema.parse(options.size ?? \"A4\");\n      this.parent = options.parent;\n      this.resources = createDictionary({\n         Font: createDictionary(),\n      });\n   }\n\n   /**\n    * Get page dimensions in points\n    */\n   getDimensions(): { width: number; height: number } {\n      if (typeof this.size === \"string\") {\n         return PAGE_SIZES[this.size];\n      }\n      return this.size;\n   }\n\n   /**\n    * Set fill color\n    */\n   private setFillColor(color: PDFColor): void {\n      if (color.type === \"rgb\") {\n         this.contentStream.push(`${color.r} ${color.g} ${color.b} rg`);\n      } else if (color.type === \"cmyk\") {\n         this.contentStream.push(\n            `${color.c} ${color.m} ${color.y} ${color.k} k`,\n         );\n      } else if (color.type === \"gray\") {\n         this.contentStream.push(`${color.gray} g`);\n      }\n   }\n\n   /**\n    * Set stroke color\n    */\n   private setStrokeColor(color: PDFColor): void {\n      if (color.type === \"rgb\") {\n         this.contentStream.push(`${color.r} ${color.g} ${color.b} RG`);\n      } else if (color.type === \"cmyk\") {\n         this.contentStream.push(\n            `${color.c} ${color.m} ${color.y} ${color.k} K`,\n         );\n      } else if (color.type === \"gray\") {\n         this.contentStream.push(`${color.gray} G`);\n      }\n   }\n\n   /**\n    * Draw text on the page\n    */\n   drawText(text: string, options: TextOptions): void {\n      const validOptions = TextOptionsSchema.parse(options);\n      const { x, y, size = 12, font = \"Helvetica\", color, align = \"left\" } = validOptions;\n\n      // Register font in resources\n      const fontName = font || \"Helvetica\";\n      if (!isStandardFont(fontName)) {\n         throw new Error(\n            `Font \"${fontName}\" is not a standard PDF font. Use one of: ${Object.keys(STANDARD_FONTS).join(\", \")}`,\n         );\n      }\n\n      const fontRefName = getFontRefName(fontName);\n      const fontDict = this.resources.Font as PDFDictionary;\n      if (!fontDict[fontRefName]) {\n         // Create font object\n         const fontObj = createDictionary({\n            Type: createName(\"Font\"),\n            Subtype: createName(\"Type1\"),\n            BaseFont: createName(fontName),\n         });\n         fontDict[fontRefName] = fontObj;\n      }\n\n      // Calculate text position based on alignment\n      let xPos = x;\n      if (align === \"center\") {\n         // Approximate centering (proper calculation needs font metrics)\n         xPos = x - text.length * size * 0.3;\n      } else if (align === \"right\") {\n         xPos = x - text.length * size * 0.6;\n      }\n\n      // Set color if provided\n      if (color) {\n         this.setFillColor(color);\n      }\n\n      // Draw text\n      this.contentStream.push(\"BT\"); // Begin text\n      this.contentStream.push(`/${fontRefName} ${size} Tf`); // Set font and size\n      this.contentStream.push(`${xPos} ${y} Td`); // Position\n\n      // Escape special characters in text\n      const escapedText = text\n         .replace(/\\\\/g, \"\\\\\\\\\")\n         .replace(/\\(/g, \"\\\\(\")\n         .replace(/\\)/g, \"\\\\)\");\n      this.contentStream.push(`(${escapedText}) Tj`); // Show text\n      this.contentStream.push(\"ET\"); // End text\n   }\n\n   /**\n    * Draw a rectangle\n    */\n   drawRectangle(options: RectOptions): void {\n      const validOptions = RectOptionsSchema.parse(options);\n      const { x, y, width, height, fill, stroke, lineWidth = 1 } = validOptions;\n\n      // Set graphics state\n      if (lineWidth && stroke) {\n         this.contentStream.push(`${lineWidth} w`);\n      }\n\n      if (fill) {\n         this.setFillColor(fill);\n      }\n\n      if (stroke) {\n         this.setStrokeColor(stroke);\n      }\n\n      // Draw rectangle\n      this.contentStream.push(`${x} ${y} ${width} ${height} re`);\n\n      // Fill, stroke, or both\n      if (fill && stroke) {\n         this.contentStream.push(\"B\"); // Fill and stroke\n      } else if (fill) {\n         this.contentStream.push(\"f\"); // Fill only\n      } else if (stroke) {\n         this.contentStream.push(\"S\"); // Stroke only\n      } else {\n         this.contentStream.push(\"S\"); // Default to stroke\n      }\n   }\n\n   /**\n    * Draw a line\n    */\n   drawLine(options: LineOptions): void {\n      const validOptions = LineOptionsSchema.parse(options);\n      const { x1, y1, x2, y2, color, lineWidth = 1 } = validOptions;\n\n      // Set graphics state\n      if (lineWidth) {\n         this.contentStream.push(`${lineWidth} w`);\n      }\n\n      if (color) {\n         this.setStrokeColor(color);\n      }\n\n      // Draw line\n      this.contentStream.push(`${x1} ${y1} m`); // Move to start\n      this.contentStream.push(`${x2} ${y2} l`); // Line to end\n      this.contentStream.push(\"S\"); // Stroke\n   }\n\n   /**\n    * Get content stream reference\n    */\n   getContentStreamRef(): PDFRef {\n      // Content stream ref is page ref + 1\n      return createRef(this.ref.objectNumber + 1, 0);\n   }\n\n   /**\n    * Generate content stream as PDFStream\n    */\n   toContentStream(): PDFStream {\n      const content = this.contentStream.join(\"\\n\");\n      const data = new TextEncoder().encode(content);\n      \n      const dict = createDictionary({\n         Length: data.length,\n      });\n\n      return createStream(data, dict);\n   }\n\n   /**\n    * Convert page to PDF dictionary\n    */\n   toDictionary(): PDFDictionary {\n      const dims = this.getDimensions();\n      const dict = createDictionary({\n         Type: createName(\"Page\"),\n         MediaBox: createArray([0, 0, dims.width, dims.height]),\n         Contents: this.getContentStreamRef(),\n         Resources: this.resources,\n      });\n\n      if (this.parent) {\n         dict.Parent = this.parent;\n      }\n\n      return dict;\n   }\n}\n",
    "import type { PDFValue, PDFDictionary, PDFRef, PDFStream, PDFArray, PDFName } from \"../types.ts\";\n\n/**\n * Serialize a PDF value to string\n */\nexport function serializeValue(value: PDFValue): string {\n   if (value === null) {\n      return \"null\";\n   }\n   if (typeof value === \"boolean\") {\n      return value ? \"true\" : \"false\";\n   }\n   if (typeof value === \"number\") {\n      return value.toString();\n   }\n   if (typeof value === \"string\") {\n      // Escape special characters\n      const escaped = value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\(/g, \"\\\\(\").replace(/\\)/g, \"\\\\)\");\n      return `(${escaped})`;\n   }\n   if (isName(value)) {\n      return `/${value.value}`;\n   }\n   if (isRef(value)) {\n      return `${value.objectNumber} ${value.generation} R`;\n   }\n   if (Array.isArray(value)) {\n      return `[${value.map(serializeValue).join(\" \")}]`;\n   }\n   if (typeof value === \"object\" && !Array.isArray(value)) {\n      // Dictionary\n      const dict = value as Record<string, PDFValue>;\n      const entries = Object.entries(dict)\n         .map(([key, val]) => `/${key} ${serializeValue(val)}`)\n         .join(\"\\n\");\n      return `<<\\n${entries}\\n>>`;\n   }\n   return \"\";\n}\n\n/**\n * Serialize a PDF stream\n */\nexport function serializeStream(stream: PDFStream): Uint8Array {\n   const dictStr = serializeValue(stream.dictionary);\n   const header = new TextEncoder().encode(`${dictStr}\\nstream\\n`);\n   const footer = new TextEncoder().encode(\"\\nendstream\");\n\n   // Combine header, data, footer\n   const result = new Uint8Array(header.length + stream.data.length + footer.length);\n   result.set(header, 0);\n   result.set(stream.data, header.length);\n   result.set(footer, header.length + stream.data.length);\n\n   return result;\n}\n\n/**\n * Serialize an indirect object\n */\nexport function serializeObject(objectNumber: number, generation: number, value: any): Uint8Array {\n   const header = `${objectNumber} ${generation} obj\\n`;\n   let body: Uint8Array;\n\n   if (isStream(value)) {\n      body = serializeStream(value);\n   } else {\n      body = new TextEncoder().encode(serializeValue(value));\n   }\n\n   const footer = new TextEncoder().encode(\"\\nendobj\\n\");\n\n   const result = new Uint8Array(header.length + body.length + footer.length);\n   result.set(new TextEncoder().encode(header), 0);\n   result.set(body, header.length);\n   result.set(footer, header.length + body.length);\n\n   return result;\n}\n\n// Type guards\nfunction isName(value: any): value is PDFName {\n   return typeof value === \"object\" && value !== null && value.type === \"name\";\n}\n\nfunction isRef(value: any): value is PDFRef {\n   return typeof value === \"object\" && value !== null && \"objectNumber\" in value && \"generation\" in value;\n}\n\nfunction isStream(value: any): value is PDFStream {\n   return typeof value === \"object\" && value !== null && \"data\" in value && value.data instanceof Uint8Array;\n}\n",
    "import {\n   createArray,\n   createDictionary,\n   createName,\n   createRef,\n} from \"../core/objects.ts\";\nimport { PDFMetadataSchema, PDFVersionSchema } from \"../schemas.ts\";\nimport type { PDFMetadata, PDFRef, PDFVersion } from \"../types.ts\";\nimport { PDFPage } from \"./page.ts\";\nimport { serializeValue, serializeObject } from \"./writer.ts\";\n\nexport type PDFDocumentOptions = {\n   version?: PDFVersion;\n   metadata?: PDFMetadata;\n};\n\nexport type { PDFPageOptions } from \"./page.ts\";\n\n/**\n * Main PDF Document class for generation\n *\n * @property version - PDF version (1.4, 1.5, 1.6, or 1.7)\n * @property metadata - Document metadata (title, author, etc.)\n * @property catalog - Reference to the document catalog\n * @property pages - Reference to the pages tree root\n */\nexport class PDFDocument {\n   version: PDFVersion;\n   metadata: PDFMetadata;\n   private objects: Map<number, PDFDictionary> = new Map();\n   private nextObjectNumber = 1;\n\n   catalog: PDFRef;\n   pages: PDFRef;\n   private pagesArray: PDFPage[] = [];\n\n   constructor(options: PDFDocumentOptions = {}) {\n      this.version = PDFVersionSchema.parse(options.version ?? \"1.7\");\n      this.metadata = PDFMetadataSchema.parse(options.metadata ?? {});\n\n      // Create catalog\n      this.catalog = this.allocateRef();\n\n      // Create pages tree\n      this.pages = this.allocateRef();\n\n      // Initialize catalog dictionary\n      const catalogDict = createDictionary({\n         Type: createName(\"Catalog\"),\n         Pages: this.pages,\n      });\n      this.objects.set(this.catalog.objectNumber, catalogDict);\n\n      // Initialize pages dictionary\n      const pagesDict = createDictionary({\n         Type: createName(\"Pages\"),\n         Kids: createArray([]),\n         Count: 0,\n      });\n      this.objects.set(this.pages.objectNumber, pagesDict);\n\n      // Store metadata if provided (will be serialized in future tasks)\n      if (Object.keys(this.metadata).length > 0) {\n         const infoRef = this.allocateRef();\n         const infoDict = createDictionary({ ...this.metadata });\n         this.objects.set(infoRef.objectNumber, infoDict);\n      }\n   }\n\n   /**\n    * Allocate a new object reference\n    */\n   private allocateRef(): PDFRef {\n      return createRef(this.nextObjectNumber++, 0);\n   }\n\n   /**\n    * Add a page to the document\n    */\n   addPage(options?: import(\"./page.ts\").PDFPageOptions): PDFPage {\n      const pageRef = this.allocateRef();\n      const contentStreamRef = this.allocateRef(); // Allocate content stream ref\n      \n      const page = new PDFPage(pageRef, { ...options, parent: this.pages });\n      this.pagesArray.push(page);\n\n      // Update pages dictionary\n      const pagesDict = this.objects.get(\n         this.pages.objectNumber,\n      ) as import(\"../types.ts\").PDFDictionary;\n      const kids = pagesDict.Kids as PDFRef[];\n      kids.push(pageRef);\n      pagesDict.Count = (pagesDict.Count as number) + 1;\n\n      // Store page dictionary\n      this.objects.set(pageRef.objectNumber, page.toDictionary());\n\n      // Store content stream\n      this.objects.set(contentStreamRef.objectNumber, page.toContentStream());\n\n      return page;\n   }\n\n   /**\n    * Save PDF to bytes\n    */\n   save(): Uint8Array {\n      // Refresh all objects (pages might have changed)\n      for (const page of this.pagesArray) {\n         this.objects.set(page.ref.objectNumber, page.toDictionary());\n         const contentStreamRef = page.getContentStreamRef();\n         this.objects.set(contentStreamRef.objectNumber, page.toContentStream());\n      }\n\n      const parts: Uint8Array[] = [];\n\n      // 1. PDF Header with binary marker\n      const header = new TextEncoder().encode(`%PDF-${this.version}\\n%\\xE2\\xE3\\xCF\\xD3\\n`);\n      parts.push(header);\n\n      // 2. Write objects and track byte offsets\n      const offsets: number[] = [0]; // Object 0 is always at offset 0\n      let currentOffset = header.length;\n\n      // Sort object numbers to write in order\n      const objectNumbers = Array.from(this.objects.keys()).sort((a, b) => a - b);\n\n      for (const objNum of objectNumbers) {\n         const obj = this.objects.get(objNum);\n         const objBytes = serializeObject(objNum, 0, obj);\n         parts.push(objBytes);\n         offsets[objNum] = currentOffset;\n         currentOffset += objBytes.length;\n      }\n\n      // 3. Cross-reference table\n      const xrefStart = currentOffset;\n      const xrefLines = [`xref\\n0 ${offsets.length}\\n`];\n\n      // Object 0 entry (free)\n      xrefLines.push(\"0000000000 65535 f \\n\");\n\n      // In-use objects\n      for (let i = 1; i < offsets.length; i++) {\n         const offset = offsets[i] || 0;\n         const offsetStr = offset.toString().padStart(10, \"0\");\n         xrefLines.push(`${offsetStr} 00000 n \\n`);\n      }\n\n      const xref = new TextEncoder().encode(xrefLines.join(\"\"));\n      parts.push(xref);\n\n      // 4. Trailer\n      const trailerDict = serializeValue(\n         createDictionary({\n            Size: offsets.length,\n            Root: this.catalog,\n         })\n      );\n      const trailer = new TextEncoder().encode(\n         `trailer\\n${trailerDict}\\nstartxref\\n${xrefStart}\\n%%EOF\\n`\n      );\n      parts.push(trailer);\n\n      // 5. Combine all parts\n      const totalLength = parts.reduce((sum, part) => sum + part.length, 0);\n      const result = new Uint8Array(totalLength);\n      let position = 0;\n      for (const part of parts) {\n         result.set(part, position);\n         position += part.length;\n      }\n\n      return result;\n   }\n}\n"
  ],
  "mappings": "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",
  "debugId": "D1F9D9F23EC0B1AD64756E2164756E21",
  "names": []
}

package/dist/shared/chunk-6dengthp.js

@@ -0,0 +1,48 @@
+// 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=8CD2E6AB52D9F7AE64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,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