@f-o-t/pdf 0.1.0

package/dist/shared/chunk-10ftnz45.js

@@ -0,0 +1,572 @@
+import {
+  createArray,
+  createDictionary,
+  createName,
+  createRef,
+  createStream
+} from "./chunk-6dengthp.js";
+
+// src/parsing/lexer.ts
+var TokenType;
+((TokenType2) => {
+  TokenType2["NUMBER"] = "NUMBER";
+  TokenType2["STRING"] = "STRING";
+  TokenType2["NAME"] = "NAME";
+  TokenType2["BOOLEAN"] = "BOOLEAN";
+  TokenType2["NULL"] = "NULL";
+  TokenType2["ARRAY_START"] = "ARRAY_START";
+  TokenType2["ARRAY_END"] = "ARRAY_END";
+  TokenType2["DICT_START"] = "DICT_START";
+  TokenType2["DICT_END"] = "DICT_END";
+  TokenType2["OBJ"] = "OBJ";
+  TokenType2["ENDOBJ"] = "ENDOBJ";
+  TokenType2["STREAM"] = "STREAM";
+  TokenType2["ENDSTREAM"] = "ENDSTREAM";
+  TokenType2["XREF"] = "XREF";
+  TokenType2["TRAILER"] = "TRAILER";
+  TokenType2["STARTXREF"] = "STARTXREF";
+  TokenType2["R"] = "R";
+  TokenType2["EOF"] = "EOF";
+})(TokenType ||= {});
+
+class PDFLexer {
+  data;
+  position = 0;
+  constructor(data) {
+    this.data = data;
+  }
+  nextToken() {
+    this.skipWhitespace();
+    if (this.position >= this.data.length) {
+      return { type: "EOF" /* EOF */, value: null, position: this.position };
+    }
+    const char = String.fromCharCode(this.data[this.position]);
+    if (char === "[") {
+      this.position++;
+      return { type: "ARRAY_START" /* ARRAY_START */, value: "[", position: this.position - 1 };
+    }
+    if (char === "]") {
+      this.position++;
+      return { type: "ARRAY_END" /* ARRAY_END */, value: "]", position: this.position - 1 };
+    }
+    if (char === "<" && this.peek() === "<") {
+      this.position += 2;
+      return { type: "DICT_START" /* DICT_START */, value: "<<", position: this.position - 2 };
+    }
+    if (char === ">" && this.peek() === ">") {
+      this.position += 2;
+      return { type: "DICT_END" /* DICT_END */, value: ">>", position: this.position - 2 };
+    }
+    if (char === "/") {
+      return this.readName();
+    }
+    if (char === "(") {
+      return this.readString();
+    }
+    if (char === "-" || char === "+" || char === "." || char >= "0" && char <= "9") {
+      return this.readNumber();
+    }
+    return this.readKeyword();
+  }
+  peek() {
+    if (this.position + 1 >= this.data.length)
+      return "";
+    return String.fromCharCode(this.data[this.position + 1]);
+  }
+  skipWhitespace() {
+    while (this.position < this.data.length) {
+      const char = this.data[this.position];
+      if (char === 32 || char === 9 || char === 10 || char === 13 || char === 0) {
+        this.position++;
+        continue;
+      }
+      if (char === 37) {
+        while (this.position < this.data.length && this.data[this.position] !== 10 && this.data[this.position] !== 13) {
+          this.position++;
+        }
+        continue;
+      }
+      break;
+    }
+  }
+  readName() {
+    const start = this.position;
+    this.position++;
+    let value = "";
+    while (this.position < this.data.length) {
+      const char = String.fromCharCode(this.data[this.position]);
+      if (this.isDelimiter(char) || this.isWhitespace(this.data[this.position])) {
+        break;
+      }
+      value += char;
+      this.position++;
+    }
+    return { type: "NAME" /* NAME */, value, position: start };
+  }
+  readString() {
+    const start = this.position;
+    this.position++;
+    let value = "";
+    let depth = 1;
+    while (this.position < this.data.length && depth > 0) {
+      const char = String.fromCharCode(this.data[this.position]);
+      if (char === "\\") {
+        this.position++;
+        if (this.position < this.data.length) {
+          const escaped = String.fromCharCode(this.data[this.position]);
+          value += escaped === "n" ? `
+` : escaped === "r" ? "\r" : escaped === "t" ? "\t" : escaped;
+        }
+      } else if (char === "(") {
+        depth++;
+        value += char;
+      } else if (char === ")") {
+        depth--;
+        if (depth > 0)
+          value += char;
+      } else {
+        value += char;
+      }
+      this.position++;
+    }
+    return { type: "STRING" /* STRING */, value, position: start };
+  }
+  readNumber() {
+    const start = this.position;
+    let value = "";
+    while (this.position < this.data.length) {
+      const char = String.fromCharCode(this.data[this.position]);
+      if (char === "-" || char === "+" || char === "." || char >= "0" && char <= "9") {
+        value += char;
+        this.position++;
+      } else {
+        break;
+      }
+    }
+    return { type: "NUMBER" /* NUMBER */, value: value.includes(".") ? parseFloat(value) : parseInt(value, 10), position: start };
+  }
+  readKeyword() {
+    const start = this.position;
+    let value = "";
+    while (this.position < this.data.length) {
+      const char = String.fromCharCode(this.data[this.position]);
+      if (this.isDelimiter(char) || this.isWhitespace(this.data[this.position])) {
+        break;
+      }
+      value += char;
+      this.position++;
+    }
+    const upper = value.toUpperCase();
+    if (upper === "OBJ")
+      return { type: "OBJ" /* OBJ */, value, position: start };
+    if (upper === "ENDOBJ")
+      return { type: "ENDOBJ" /* ENDOBJ */, value, position: start };
+    if (upper === "STREAM")
+      return { type: "STREAM" /* STREAM */, value, position: start };
+    if (upper === "ENDSTREAM")
+      return { type: "ENDSTREAM" /* ENDSTREAM */, value, position: start };
+    if (upper === "XREF")
+      return { type: "XREF" /* XREF */, value, position: start };
+    if (upper === "TRAILER")
+      return { type: "TRAILER" /* TRAILER */, value, position: start };
+    if (upper === "STARTXREF")
+      return { type: "STARTXREF" /* STARTXREF */, value, position: start };
+    if (upper === "R")
+      return { type: "R" /* R */, value, position: start };
+    if (upper === "TRUE")
+      return { type: "BOOLEAN" /* BOOLEAN */, value: true, position: start };
+    if (upper === "FALSE")
+      return { type: "BOOLEAN" /* BOOLEAN */, value: false, position: start };
+    if (upper === "NULL")
+      return { type: "NULL" /* NULL */, value: null, position: start };
+    return { type: "NAME" /* NAME */, value, position: start };
+  }
+  isDelimiter(char) {
+    return ["(", ")", "<", ">", "[", "]", "{", "}", "/", "%"].includes(char);
+  }
+  isWhitespace(byte) {
+    return byte === 32 || byte === 9 || byte === 10 || byte === 13 || byte === 0;
+  }
+}
+// src/parsing/parser.ts
+class PDFParser {
+  lexer;
+  currentToken;
+  nextToken = null;
+  data;
+  constructor(data) {
+    this.data = data;
+    this.lexer = new PDFLexer(data);
+    this.currentToken = this.lexer.nextToken();
+  }
+  parseValue() {
+    switch (this.currentToken.type) {
+      case "NUMBER" /* NUMBER */:
+        return this.parseNumberOrRef();
+      case "STRING" /* STRING */:
+        return this.parseString();
+      case "NAME" /* NAME */:
+        return this.parseName();
+      case "BOOLEAN" /* BOOLEAN */:
+        return this.parseBoolean();
+      case "NULL" /* NULL */:
+        return this.parseNull();
+      case "ARRAY_START" /* ARRAY_START */:
+        return this.parseArray();
+      case "DICT_START" /* DICT_START */:
+        return this.parseDictionary();
+      default:
+        throw new Error(`Unexpected token: ${this.currentToken.type}`);
+    }
+  }
+  parseNumberOrRef() {
+    const first = this.currentToken.value;
+    this.advance();
+    if (this.currentToken.type === "NUMBER" /* NUMBER */) {
+      const second = this.currentToken.value;
+      this.advance();
+      if (this.currentToken.type === "R" /* R */) {
+        this.advance();
+        return createRef(first, second);
+      }
+      const thirdToken = this.currentToken;
+      this.currentToken = { type: "NUMBER" /* NUMBER */, value: second, position: 0 };
+      this.nextToken = thirdToken;
+      return first;
+    }
+    return first;
+  }
+  parseString() {
+    const value = this.currentToken.value;
+    this.advance();
+    return value;
+  }
+  parseName() {
+    const value = this.currentToken.value;
+    this.advance();
+    return createName(value);
+  }
+  parseBoolean() {
+    const value = this.currentToken.value;
+    this.advance();
+    return value;
+  }
+  parseNull() {
+    this.advance();
+    return null;
+  }
+  parseArray() {
+    this.advance();
+    const values = [];
+    while (this.currentToken.type !== "ARRAY_END" /* ARRAY_END */) {
+      if (this.currentToken.type === "EOF" /* EOF */) {
+        throw new Error("Unexpected EOF in array");
+      }
+      values.push(this.parseValue());
+    }
+    this.advance();
+    return createArray(values);
+  }
+  parseDictionary() {
+    this.advance();
+    const entries = {};
+    while (this.currentToken.type !== "DICT_END" /* DICT_END */) {
+      if (this.currentToken.type === "EOF" /* EOF */) {
+        throw new Error("Unexpected EOF in dictionary");
+      }
+      if (this.currentToken.type !== "NAME" /* NAME */) {
+        throw new Error(`Expected name in dictionary, got ${this.currentToken.type}`);
+      }
+      const key = this.currentToken.value;
+      this.advance();
+      const value = this.parseValue();
+      entries[key] = value;
+    }
+    this.advance();
+    return createDictionary(entries);
+  }
+  parseIndirectObject() {
+    if (this.currentToken.type !== "NUMBER" /* NUMBER */) {
+      throw new Error("Expected object number");
+    }
+    const objectNumber = this.currentToken.value;
+    this.advance();
+    if (this.currentToken.type !== "NUMBER" /* NUMBER */) {
+      throw new Error("Expected generation number");
+    }
+    const generation = this.currentToken.value;
+    this.advance();
+    if (this.currentToken.type !== "OBJ" /* OBJ */) {
+      throw new Error("Expected 'obj' keyword");
+    }
+    this.advance();
+    let value = this.parseValue();
+    if (this.currentToken.type === "STREAM" /* STREAM */) {
+      value = this.parseStream(value);
+    }
+    if (this.currentToken.type !== "ENDOBJ" /* ENDOBJ */) {
+      throw new Error("Expected 'endobj' keyword");
+    }
+    this.advance();
+    return {
+      ref: createRef(objectNumber, generation),
+      value
+    };
+  }
+  parseStream(dictionary) {
+    const streamKeywordPos = this.currentToken.position;
+    this.advance();
+    let streamDataStart = streamKeywordPos + 6;
+    while (streamDataStart < this.data.length) {
+      const byte = this.data[streamDataStart];
+      if (byte === 13 || byte === 10) {
+        streamDataStart++;
+        if (byte === 13 && this.data[streamDataStart] === 10) {
+          streamDataStart++;
+        }
+        break;
+      }
+      streamDataStart++;
+    }
+    const length = dictionary.Length;
+    if (typeof length !== "number") {
+      throw new Error("Stream dictionary missing Length");
+    }
+    const data = this.data.slice(streamDataStart, streamDataStart + length);
+    while (this.currentToken.type !== "ENDSTREAM" /* ENDSTREAM */ && this.currentToken.type !== "EOF" /* EOF */) {
+      this.advance();
+    }
+    if (this.currentToken.type !== "ENDSTREAM" /* ENDSTREAM */) {
+      throw new Error("Expected 'endstream' keyword");
+    }
+    this.advance();
+    return createStream(data, dictionary);
+  }
+  advance() {
+    if (this.nextToken !== null) {
+      this.currentToken = this.nextToken;
+      this.nextToken = null;
+    } else {
+      this.currentToken = this.lexer.nextToken();
+    }
+  }
+  hasMore() {
+    return this.currentToken.type !== "EOF" /* EOF */;
+  }
+}
+// src/errors.ts
+class PDFError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PDFError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+class PDFParseError extends PDFError {
+  offset;
+  constructor(message, offset) {
+    super(message);
+    this.offset = offset;
+    this.name = "PDFParseError";
+  }
+}
+
+class PDFGenerationError extends PDFError {
+  constructor(message) {
+    super(message);
+    this.name = "PDFGenerationError";
+  }
+}
+
+class InvalidPDFObjectError extends PDFError {
+  objectType;
+  constructor(objectType, reason) {
+    super(`Invalid ${objectType}: ${reason}`);
+    this.objectType = objectType;
+    this.name = "InvalidPDFObjectError";
+  }
+}
+
+class FontNotFoundError extends PDFError {
+  fontName;
+  constructor(fontName) {
+    super(`Font not found: ${fontName}`);
+    this.fontName = fontName;
+    this.name = "FontNotFoundError";
+  }
+}
+
+class InvalidImageError extends PDFError {
+  constructor(reason) {
+    super(`Invalid image: ${reason}`);
+    this.name = "InvalidImageError";
+  }
+}
+
+class PDFSignatureError extends PDFError {
+  constructor(reason) {
+    super(`PDF signature error: ${reason}`);
+    this.name = "PDFSignatureError";
+  }
+}
+
+class PDFEncryptionError extends PDFError {
+  constructor(reason) {
+    super(`PDF encryption error: ${reason}`);
+    this.name = "PDFEncryptionError";
+  }
+}
+
+class NotImplementedError extends PDFError {
+  constructor(feature) {
+    super(`Feature not yet implemented: ${feature}`);
+    this.name = "NotImplementedError";
+  }
+}
+
+// src/parsing/reader.ts
+class PDFReader {
+  data;
+  objects = new Map;
+  constructor(data) {
+    this.data = data;
+  }
+  parse() {
+    const xrefOffset = this.findStartXRef();
+    const xrefTable = this.parseXRefTable(xrefOffset);
+    const trailer = this.parseTrailer(xrefOffset);
+    const catalogRef = trailer.Root;
+    this.readObjects(xrefTable);
+    const version = this.parseVersion();
+    const pages = this.parsePages(catalogRef);
+    return {
+      version,
+      catalog: catalogRef,
+      pages,
+      objects: this.objects
+    };
+  }
+  findStartXRef() {
+    const decoder = new TextDecoder;
+    const content = decoder.decode(this.data);
+    const match = content.match(/startxref\s+(\d+)/);
+    if (!match) {
+      throw new PDFParseError("Could not find startxref");
+    }
+    return parseInt(match[1], 10);
+  }
+  parseXRefTable(offset) {
+    const decoder = new TextDecoder;
+    const content = decoder.decode(this.data.slice(offset));
+    const lines = content.split(`
+`);
+    const xref = new Map;
+    let i = 0;
+    while (i < lines.length && !lines[i].trim().startsWith("xref"))
+      i++;
+    i++;
+    while (i < lines.length && !lines[i].trim().startsWith("trailer")) {
+      const subsection = lines[i].trim().split(/\s+/);
+      if (subsection.length === 2) {
+        const start = parseInt(subsection[0], 10);
+        const count = parseInt(subsection[1], 10);
+        i++;
+        for (let j = 0;j < count; j++) {
+          const entry = lines[i].trim().split(/\s+/);
+          if (entry.length >= 3 && entry[2] === "n") {
+            const offset2 = parseInt(entry[0], 10);
+            xref.set(start + j, offset2);
+          }
+          i++;
+        }
+      } else {
+        i++;
+      }
+    }
+    return xref;
+  }
+  parseTrailer(xrefOffset) {
+    const decoder = new TextDecoder;
+    const content = decoder.decode(this.data.slice(xrefOffset));
+    const trailerMatch = content.match(/trailer\s*<<[\s\S]*?>>/);
+    if (!trailerMatch) {
+      throw new PDFParseError("Could not find trailer");
+    }
+    const parser = new PDFParser(new TextEncoder().encode(trailerMatch[0].replace("trailer", "")));
+    return parser.parseValue();
+  }
+  readObjects(xrefTable) {
+    for (const [objectNum, offset] of xrefTable) {
+      try {
+        const objData = this.data.slice(offset);
+        const parser = new PDFParser(objData);
+        const obj = parser.parseIndirectObject();
+        this.objects.set(objectNum, obj.value);
+      } catch (error) {}
+    }
+  }
+  parseVersion() {
+    const decoder = new TextDecoder;
+    const header = decoder.decode(this.data.slice(0, 20));
+    const match = header.match(/%PDF-(\d+\.\d+)/);
+    return match ? match[1] : "1.7";
+  }
+  parsePages(catalogRef) {
+    const catalog = this.objects.get(catalogRef.objectNumber);
+    if (!catalog) {
+      throw new PDFParseError("Catalog not found");
+    }
+    const pagesRef = catalog.Pages;
+    const pagesTree = this.objects.get(pagesRef.objectNumber);
+    if (!pagesTree) {
+      throw new PDFParseError("Pages tree not found");
+    }
+    const kids = pagesTree.Kids;
+    const pages = [];
+    for (const kidRef of kids) {
+      if (typeof kidRef === "object" && "objectNumber" in kidRef) {
+        const page = this.parsePage(kidRef);
+        if (page)
+          pages.push(page);
+      }
+    }
+    return pages;
+  }
+  parsePage(ref) {
+    const pageDict = this.objects.get(ref.objectNumber);
+    if (!pageDict)
+      return null;
+    const mediaBox = pageDict.MediaBox;
+    const size = {
+      width: mediaBox[2],
+      height: mediaBox[3]
+    };
+    let content = "";
+    const contentsRef = pageDict.Contents;
+    if (contentsRef && typeof contentsRef === "object" && "objectNumber" in contentsRef) {
+      content = this.extractText(contentsRef);
+    }
+    return { ref, size, content };
+  }
+  extractText(ref) {
+    const stream = this.objects.get(ref.objectNumber);
+    if (!stream || !stream.data)
+      return "";
+    const decoder = new TextDecoder;
+    const content = decoder.decode(stream.data);
+    const texts = [];
+    const regex = /\(([^)]*)\)\s*Tj/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      texts.push(match[1]);
+    }
+    return texts.join(" ");
+  }
+}
+export { PDFError, PDFParseError, PDFGenerationError, InvalidPDFObjectError, FontNotFoundError, InvalidImageError, PDFSignatureError, PDFEncryptionError, NotImplementedError, TokenType, PDFLexer, PDFParser, PDFReader };
+
+//# debugId=2D25678A9DC8958E64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/parsing/lexer.ts", "src/parsing/parser.ts", "src/errors.ts", "src/parsing/reader.ts"],
  "sourcesContent": [
    "/**\n * PDF token types\n */\nexport enum TokenType {\n   // Primitives\n   NUMBER = \"NUMBER\",\n   STRING = \"STRING\",\n   NAME = \"NAME\",\n   BOOLEAN = \"BOOLEAN\",\n   NULL = \"NULL\",\n\n   // Delimiters\n   ARRAY_START = \"ARRAY_START\",     // [\n   ARRAY_END = \"ARRAY_END\",         // ]\n   DICT_START = \"DICT_START\",       // <<\n   DICT_END = \"DICT_END\",           // >>\n\n   // Keywords\n   OBJ = \"OBJ\",                     // obj\n   ENDOBJ = \"ENDOBJ\",               // endobj\n   STREAM = \"STREAM\",               // stream\n   ENDSTREAM = \"ENDSTREAM\",         // endstream\n   XREF = \"XREF\",                   // xref\n   TRAILER = \"TRAILER\",             // trailer\n   STARTXREF = \"STARTXREF\",         // startxref\n   R = \"R\",                         // R (reference)\n\n   // Special\n   EOF = \"EOF\",\n}\n\n/**\n * PDF token\n */\nexport interface Token {\n   type: TokenType;\n   value: any;\n   position: number;\n}\n\n/**\n * PDF Lexer\n */\nexport class PDFLexer {\n   private data: Uint8Array;\n   private position: number = 0;\n\n   constructor(data: Uint8Array) {\n      this.data = data;\n   }\n\n   /**\n    * Get next token\n    */\n   nextToken(): Token {\n      this.skipWhitespace();\n\n      if (this.position >= this.data.length) {\n         return { type: TokenType.EOF, value: null, position: this.position };\n      }\n\n      const char = String.fromCharCode(this.data[this.position]);\n\n      // Delimiters\n      if (char === \"[\") {\n         this.position++;\n         return { type: TokenType.ARRAY_START, value: \"[\", position: this.position - 1 };\n      }\n      if (char === \"]\") {\n         this.position++;\n         return { type: TokenType.ARRAY_END, value: \"]\", position: this.position - 1 };\n      }\n      if (char === \"<\" && this.peek() === \"<\") {\n         this.position += 2;\n         return { type: TokenType.DICT_START, value: \"<<\", position: this.position - 2 };\n      }\n      if (char === \">\" && this.peek() === \">\") {\n         this.position += 2;\n         return { type: TokenType.DICT_END, value: \">>\", position: this.position - 2 };\n      }\n\n      // Name (starts with /)\n      if (char === \"/\") {\n         return this.readName();\n      }\n\n      // String (starts with ()\n      if (char === \"(\") {\n         return this.readString();\n      }\n\n      // Number or keyword\n      if (char === \"-\" || char === \"+\" || char === \".\" || (char >= \"0\" && char <= \"9\")) {\n         return this.readNumber();\n      }\n\n      // Keyword or boolean\n      return this.readKeyword();\n   }\n\n   /**\n    * Peek at next character without consuming\n    */\n   private peek(): string {\n      if (this.position + 1 >= this.data.length) return \"\";\n      return String.fromCharCode(this.data[this.position + 1]);\n   }\n\n   /**\n    * Skip whitespace and comments\n    */\n   private skipWhitespace(): void {\n      while (this.position < this.data.length) {\n         const char = this.data[this.position];\n\n         // Whitespace\n         if (char === 0x20 || char === 0x09 || char === 0x0A || char === 0x0D || char === 0x00) {\n            this.position++;\n            continue;\n         }\n\n         // Comment (starts with %)\n         if (char === 0x25) {\n            while (this.position < this.data.length && this.data[this.position] !== 0x0A && this.data[this.position] !== 0x0D) {\n               this.position++;\n            }\n            continue;\n         }\n\n         break;\n      }\n   }\n\n   /**\n    * Read a name token\n    */\n   private readName(): Token {\n      const start = this.position;\n      this.position++; // Skip /\n\n      let value = \"\";\n      while (this.position < this.data.length) {\n         const char = String.fromCharCode(this.data[this.position]);\n         if (this.isDelimiter(char) || this.isWhitespace(this.data[this.position])) {\n            break;\n         }\n         value += char;\n         this.position++;\n      }\n\n      return { type: TokenType.NAME, value, position: start };\n   }\n\n   /**\n    * Read a string token\n    */\n   private readString(): Token {\n      const start = this.position;\n      this.position++; // Skip (\n\n      let value = \"\";\n      let depth = 1;\n\n      while (this.position < this.data.length && depth > 0) {\n         const char = String.fromCharCode(this.data[this.position]);\n\n         if (char === \"\\\\\") {\n            // Escape sequence\n            this.position++;\n            if (this.position < this.data.length) {\n               const escaped = String.fromCharCode(this.data[this.position]);\n               value += escaped === \"n\" ? \"\\n\" : escaped === \"r\" ? \"\\r\" : escaped === \"t\" ? \"\\t\" : escaped;\n            }\n         } else if (char === \"(\") {\n            depth++;\n            value += char;\n         } else if (char === \")\") {\n            depth--;\n            if (depth > 0) value += char;\n         } else {\n            value += char;\n         }\n\n         this.position++;\n      }\n\n      return { type: TokenType.STRING, value, position: start };\n   }\n\n   /**\n    * Read a number token\n    */\n   private readNumber(): Token {\n      const start = this.position;\n      let value = \"\";\n\n      while (this.position < this.data.length) {\n         const char = String.fromCharCode(this.data[this.position]);\n         if (char === \"-\" || char === \"+\" || char === \".\" || (char >= \"0\" && char <= \"9\")) {\n            value += char;\n            this.position++;\n         } else {\n            break;\n         }\n      }\n\n      return { type: TokenType.NUMBER, value: value.includes(\".\") ? parseFloat(value) : parseInt(value, 10), position: start };\n   }\n\n   /**\n    * Read a keyword token\n    */\n   private readKeyword(): Token {\n      const start = this.position;\n      let value = \"\";\n\n      while (this.position < this.data.length) {\n         const char = String.fromCharCode(this.data[this.position]);\n         if (this.isDelimiter(char) || this.isWhitespace(this.data[this.position])) {\n            break;\n         }\n         value += char;\n         this.position++;\n      }\n\n      // Check for keywords\n      const upper = value.toUpperCase();\n      if (upper === \"OBJ\") return { type: TokenType.OBJ, value, position: start };\n      if (upper === \"ENDOBJ\") return { type: TokenType.ENDOBJ, value, position: start };\n      if (upper === \"STREAM\") return { type: TokenType.STREAM, value, position: start };\n      if (upper === \"ENDSTREAM\") return { type: TokenType.ENDSTREAM, value, position: start };\n      if (upper === \"XREF\") return { type: TokenType.XREF, value, position: start };\n      if (upper === \"TRAILER\") return { type: TokenType.TRAILER, value, position: start };\n      if (upper === \"STARTXREF\") return { type: TokenType.STARTXREF, value, position: start };\n      if (upper === \"R\") return { type: TokenType.R, value, position: start };\n      if (upper === \"TRUE\") return { type: TokenType.BOOLEAN, value: true, position: start };\n      if (upper === \"FALSE\") return { type: TokenType.BOOLEAN, value: false, position: start };\n      if (upper === \"NULL\") return { type: TokenType.NULL, value: null, position: start };\n\n      // Unknown keyword - treat as name without /\n      return { type: TokenType.NAME, value, position: start };\n   }\n\n   /**\n    * Check if character is delimiter\n    */\n   private isDelimiter(char: string): boolean {\n      return [\"(\", \")\", \"<\", \">\", \"[\", \"]\", \"{\", \"}\", \"/\", \"%\"].includes(char);\n   }\n\n   /**\n    * Check if byte is whitespace\n    */\n   private isWhitespace(byte: number): boolean {\n      return byte === 0x20 || byte === 0x09 || byte === 0x0A || byte === 0x0D || byte === 0x00;\n   }\n}\n",
    "import { PDFLexer, TokenType, type Token } from \"./lexer.ts\";\nimport type { PDFValue, PDFDictionary, PDFArray, PDFRef, PDFStream } from \"../types.ts\";\nimport { createDictionary, createArray, createRef, createName, createStream } from \"../core/objects.ts\";\n\n/**\n * PDF Parser\n */\nexport class PDFParser {\n   private lexer: PDFLexer;\n   private currentToken: Token;\n   private nextToken: Token | null = null;\n   private data: Uint8Array;\n\n   constructor(data: Uint8Array) {\n      this.data = data;\n      this.lexer = new PDFLexer(data);\n      this.currentToken = this.lexer.nextToken();\n   }\n\n   /**\n    * Parse a PDF value\n    */\n   parseValue(): PDFValue {\n      switch (this.currentToken.type) {\n         case TokenType.NUMBER:\n            return this.parseNumberOrRef();\n         case TokenType.STRING:\n            return this.parseString();\n         case TokenType.NAME:\n            return this.parseName();\n         case TokenType.BOOLEAN:\n            return this.parseBoolean();\n         case TokenType.NULL:\n            return this.parseNull();\n         case TokenType.ARRAY_START:\n            return this.parseArray();\n         case TokenType.DICT_START:\n            return this.parseDictionary();\n         default:\n            throw new Error(`Unexpected token: ${this.currentToken.type}`);\n      }\n   }\n\n   /**\n    * Parse number or reference (number number R)\n    */\n   private parseNumberOrRef(): number | PDFRef {\n      const first = this.currentToken.value as number;\n      this.advance();\n\n      // Check if this is a reference (two numbers followed by R)\n      if (this.currentToken.type === TokenType.NUMBER) {\n         const second = this.currentToken.value as number;\n         this.advance();\n\n         if (this.currentToken.type === TokenType.R) {\n            this.advance();\n            return createRef(first, second);\n         }\n\n         // Not a reference - we consumed the second number, need to put it back\n         // Put the current token (third token) into nextToken buffer\n         // Then restore second number as current token\n         const thirdToken = this.currentToken;\n         this.currentToken = { type: TokenType.NUMBER, value: second, position: 0 };\n         this.nextToken = thirdToken;\n         return first;\n      }\n\n      return first;\n   }\n\n   /**\n    * Parse string\n    */\n   private parseString(): string {\n      const value = this.currentToken.value as string;\n      this.advance();\n      return value;\n   }\n\n   /**\n    * Parse name\n    */\n   private parseName(): PDFValue {\n      const value = this.currentToken.value as string;\n      this.advance();\n      return createName(value);\n   }\n\n   /**\n    * Parse boolean\n    */\n   private parseBoolean(): boolean {\n      const value = this.currentToken.value as boolean;\n      this.advance();\n      return value;\n   }\n\n   /**\n    * Parse null\n    */\n   private parseNull(): null {\n      this.advance();\n      return null;\n   }\n\n   /**\n    * Parse array\n    */\n   private parseArray(): PDFArray {\n      this.advance(); // Skip [\n      const values: PDFValue[] = [];\n\n      while (this.currentToken.type !== TokenType.ARRAY_END) {\n         if (this.currentToken.type === TokenType.EOF) {\n            throw new Error(\"Unexpected EOF in array\");\n         }\n         values.push(this.parseValue());\n      }\n\n      this.advance(); // Skip ]\n      return createArray(values);\n   }\n\n   /**\n    * Parse dictionary\n    */\n   private parseDictionary(): PDFDictionary {\n      this.advance(); // Skip <<\n      const entries: Record<string, PDFValue> = {};\n\n      while (this.currentToken.type !== TokenType.DICT_END) {\n         if (this.currentToken.type === TokenType.EOF) {\n            throw new Error(\"Unexpected EOF in dictionary\");\n         }\n\n         // Key must be a name\n         if (this.currentToken.type !== TokenType.NAME) {\n            throw new Error(`Expected name in dictionary, got ${this.currentToken.type}`);\n         }\n         const key = this.currentToken.value as string;\n         this.advance();\n\n         // Value\n         const value = this.parseValue();\n         entries[key] = value;\n      }\n\n      this.advance(); // Skip >>\n      return createDictionary(entries);\n   }\n\n   /**\n    * Parse indirect object\n    */\n   parseIndirectObject(): { ref: PDFRef; value: PDFValue } {\n      // Parse: objectNumber generation obj\n      if (this.currentToken.type !== TokenType.NUMBER) {\n         throw new Error(\"Expected object number\");\n      }\n      const objectNumber = this.currentToken.value as number;\n      this.advance();\n\n      if (this.currentToken.type !== TokenType.NUMBER) {\n         throw new Error(\"Expected generation number\");\n      }\n      const generation = this.currentToken.value as number;\n      this.advance();\n\n      if (this.currentToken.type !== TokenType.OBJ) {\n         throw new Error(\"Expected 'obj' keyword\");\n      }\n      this.advance();\n\n      // Parse object value\n      let value: PDFValue = this.parseValue();\n\n      // Check for stream\n      if (this.currentToken.type === TokenType.STREAM) {\n         value = this.parseStream(value as PDFDictionary);\n      }\n\n      // Expect endobj\n      if (this.currentToken.type !== TokenType.ENDOBJ) {\n         throw new Error(\"Expected 'endobj' keyword\");\n      }\n      this.advance();\n\n      return {\n         ref: createRef(objectNumber, generation),\n         value,\n      };\n   }\n\n   /**\n    * Parse stream (dictionary already parsed)\n    */\n   private parseStream(dictionary: PDFDictionary): PDFStream {\n      // Get current position where 'stream' keyword is\n      const streamKeywordPos = this.currentToken.position;\n      this.advance(); // Skip 'stream'\n\n      // Find the actual start of stream data (after 'stream' keyword and newline)\n      // The stream keyword is followed by either \\n or \\r\\n\n      let streamDataStart = streamKeywordPos + 6; // 'stream' is 6 characters\n      \n      // Skip the newline after 'stream'\n      while (streamDataStart < this.data.length) {\n         const byte = this.data[streamDataStart];\n         if (byte === 0x0D || byte === 0x0A) { // \\r or \\n\n            streamDataStart++;\n            // Handle \\r\\n\n            if (byte === 0x0D && this.data[streamDataStart] === 0x0A) {\n               streamDataStart++;\n            }\n            break;\n         }\n         streamDataStart++;\n      }\n\n      // Get stream length\n      const length = dictionary.Length as number;\n      if (typeof length !== \"number\") {\n         throw new Error(\"Stream dictionary missing Length\");\n      }\n\n      // Extract stream data\n      const data = this.data.slice(streamDataStart, streamDataStart + length);\n\n      // Skip to endstream\n      while (this.currentToken.type !== TokenType.ENDSTREAM && this.currentToken.type !== TokenType.EOF) {\n         this.advance();\n      }\n\n      if (this.currentToken.type !== TokenType.ENDSTREAM) {\n         throw new Error(\"Expected 'endstream' keyword\");\n      }\n      this.advance();\n\n      return createStream(data, dictionary);\n   }\n\n   /**\n    * Advance to next token\n    */\n   private advance(): void {\n      if (this.nextToken !== null) {\n         this.currentToken = this.nextToken;\n         this.nextToken = null;\n      } else {\n         this.currentToken = this.lexer.nextToken();\n      }\n   }\n\n   /**\n    * Check if more tokens available\n    */\n   hasMore(): boolean {\n      return this.currentToken.type !== TokenType.EOF;\n   }\n}\n",
    "/**\n * Base error class for all PDF errors\n */\nexport class PDFError extends Error {\n   constructor(message: string) {\n      super(message);\n      this.name = \"PDFError\";\n      if (Error.captureStackTrace) {\n         Error.captureStackTrace(this, this.constructor);\n      }\n   }\n}\n\n/**\n * Error thrown when PDF parsing fails\n */\nexport class PDFParseError extends PDFError {\n   constructor(\n      message: string,\n      public readonly offset?: number,\n   ) {\n      super(message);\n      this.name = \"PDFParseError\";\n   }\n}\n\n/**\n * Error thrown when PDF generation fails\n */\nexport class PDFGenerationError extends PDFError {\n   constructor(message: string) {\n      super(message);\n      this.name = \"PDFGenerationError\";\n   }\n}\n\n/**\n * Error thrown when PDF object is invalid\n */\nexport class InvalidPDFObjectError extends PDFError {\n   constructor(\n      public readonly objectType: string,\n      reason: string,\n   ) {\n      super(`Invalid ${objectType}: ${reason}`);\n      this.name = \"InvalidPDFObjectError\";\n   }\n}\n\n/**\n * Error thrown when font is not found\n */\nexport class FontNotFoundError extends PDFError {\n   constructor(public readonly fontName: string) {\n      super(`Font not found: ${fontName}`);\n      this.name = \"FontNotFoundError\";\n   }\n}\n\n/**\n * Error thrown when image is invalid\n */\nexport class InvalidImageError extends PDFError {\n   constructor(reason: string) {\n      super(`Invalid image: ${reason}`);\n      this.name = \"InvalidImageError\";\n   }\n}\n\n/**\n * Error thrown when PDF signature fails\n */\nexport class PDFSignatureError extends PDFError {\n   constructor(reason: string) {\n      super(`PDF signature error: ${reason}`);\n      this.name = \"PDFSignatureError\";\n   }\n}\n\n/**\n * Error thrown when PDF encryption fails\n */\nexport class PDFEncryptionError extends PDFError {\n   constructor(reason: string) {\n      super(`PDF encryption error: ${reason}`);\n      this.name = \"PDFEncryptionError\";\n   }\n}\n\n/**\n * Error thrown when required feature is not implemented\n */\nexport class NotImplementedError extends PDFError {\n   constructor(feature: string) {\n      super(`Feature not yet implemented: ${feature}`);\n      this.name = \"NotImplementedError\";\n   }\n}\n",
    "import { PDFParser } from \"./parser.ts\";\nimport type { PDFDictionary, PDFRef, PDFArray } from \"../types.ts\";\nimport { PDFParseError } from \"../errors.ts\";\n\n/**\n * Parsed PDF Document\n */\nexport interface ParsedPDF {\n   version: string;\n   catalog: PDFRef;\n   pages: PDFPage[];\n   objects: Map<number, any>;\n}\n\n/**\n * Parsed PDF Page\n */\nexport interface PDFPage {\n   ref: PDFRef;\n   size: { width: number; height: number };\n   content: string;\n}\n\n/**\n * PDF Reader - reads and parses existing PDFs\n */\nexport class PDFReader {\n   private data: Uint8Array;\n   private objects: Map<number, any> = new Map();\n\n   constructor(data: Uint8Array) {\n      this.data = data;\n   }\n\n   /**\n    * Parse PDF file\n    */\n   parse(): ParsedPDF {\n      // 1. Find and parse xref table\n      const xrefOffset = this.findStartXRef();\n      const xrefTable = this.parseXRefTable(xrefOffset);\n\n      // 2. Parse trailer\n      const trailer = this.parseTrailer(xrefOffset);\n      const catalogRef = trailer.Root as PDFRef;\n\n      // 3. Read all objects using xref table\n      this.readObjects(xrefTable);\n\n      // 4. Get PDF version from header\n      const version = this.parseVersion();\n\n      // 5. Parse pages\n      const pages = this.parsePages(catalogRef);\n\n      return {\n         version,\n         catalog: catalogRef,\n         pages,\n         objects: this.objects,\n      };\n   }\n\n   /**\n    * Find startxref offset\n    */\n   private findStartXRef(): number {\n      const decoder = new TextDecoder();\n      const content = decoder.decode(this.data);\n      const match = content.match(/startxref\\s+(\\d+)/);\n      if (!match) {\n         throw new PDFParseError(\"Could not find startxref\");\n      }\n      return parseInt(match[1], 10);\n   }\n\n   /**\n    * Parse xref table\n    */\n   private parseXRefTable(offset: number): Map<number, number> {\n      const decoder = new TextDecoder();\n      const content = decoder.decode(this.data.slice(offset));\n      const lines = content.split(\"\\n\");\n\n      const xref = new Map<number, number>();\n      let i = 0;\n\n      // Skip \"xref\" keyword\n      while (i < lines.length && !lines[i].trim().startsWith(\"xref\")) i++;\n      i++;\n\n      // Parse subsections\n      while (i < lines.length && !lines[i].trim().startsWith(\"trailer\")) {\n         const subsection = lines[i].trim().split(/\\s+/);\n         if (subsection.length === 2) {\n            const start = parseInt(subsection[0], 10);\n            const count = parseInt(subsection[1], 10);\n            i++;\n\n            // Parse entries\n            for (let j = 0; j < count; j++) {\n               const entry = lines[i].trim().split(/\\s+/);\n               if (entry.length >= 3 && entry[2] === \"n\") {\n                  const offset = parseInt(entry[0], 10);\n                  xref.set(start + j, offset);\n               }\n               i++;\n            }\n         } else {\n            i++;\n         }\n      }\n\n      return xref;\n   }\n\n   /**\n    * Parse trailer dictionary\n    */\n   private parseTrailer(xrefOffset: number): PDFDictionary {\n      const decoder = new TextDecoder();\n      const content = decoder.decode(this.data.slice(xrefOffset));\n      const trailerMatch = content.match(/trailer\\s*<<[\\s\\S]*?>>/);\n      if (!trailerMatch) {\n         throw new PDFParseError(\"Could not find trailer\");\n      }\n\n      const parser = new PDFParser(new TextEncoder().encode(trailerMatch[0].replace(\"trailer\", \"\")));\n      return parser.parseValue() as PDFDictionary;\n   }\n\n   /**\n    * Read all objects from xref table\n    */\n   private readObjects(xrefTable: Map<number, number>): void {\n      for (const [objectNum, offset] of xrefTable) {\n         try {\n           const objData = this.data.slice(offset);\n           const parser = new PDFParser(objData);\n           const obj = parser.parseIndirectObject();\n           this.objects.set(objectNum, obj.value);\n         } catch (error) {\n           // Skip malformed objects\n         }\n      }\n   }\n\n   /**\n    * Parse PDF version from header\n    */\n   private parseVersion(): string {\n      const decoder = new TextDecoder();\n      const header = decoder.decode(this.data.slice(0, 20));\n      const match = header.match(/%PDF-(\\d+\\.\\d+)/);\n      return match ? match[1] : \"1.7\";\n   }\n\n   /**\n    * Parse pages from catalog\n    */\n   private parsePages(catalogRef: PDFRef): PDFPage[] {\n      const catalog = this.objects.get(catalogRef.objectNumber) as PDFDictionary;\n      if (!catalog) {\n         throw new PDFParseError(\"Catalog not found\");\n      }\n\n      const pagesRef = catalog.Pages as PDFRef;\n      const pagesTree = this.objects.get(pagesRef.objectNumber) as PDFDictionary;\n      if (!pagesTree) {\n         throw new PDFParseError(\"Pages tree not found\");\n      }\n\n      const kids = pagesTree.Kids as PDFArray;\n      const pages: PDFPage[] = [];\n\n      for (const kidRef of kids) {\n         if (typeof kidRef === \"object\" && \"objectNumber\" in kidRef) {\n            const page = this.parsePage(kidRef as PDFRef);\n            if (page) pages.push(page);\n         }\n      }\n\n      return pages;\n   }\n\n   /**\n    * Parse a single page\n    */\n   private parsePage(ref: PDFRef): PDFPage | null {\n      const pageDict = this.objects.get(ref.objectNumber) as PDFDictionary;\n      if (!pageDict) return null;\n\n      const mediaBox = pageDict.MediaBox as PDFArray;\n      const size = {\n         width: mediaBox[2] as number,\n         height: mediaBox[3] as number,\n      };\n\n      // Extract content\n      let content = \"\";\n      const contentsRef = pageDict.Contents as PDFRef;\n      if (contentsRef && typeof contentsRef === \"object\" && \"objectNumber\" in contentsRef) {\n         content = this.extractText(contentsRef);\n      }\n\n      return { ref, size, content };\n   }\n\n   /**\n    * Extract text from content stream\n    */\n   private extractText(ref: PDFRef): string {\n      const stream = this.objects.get(ref.objectNumber);\n      if (!stream || !stream.data) return \"\";\n\n      const decoder = new TextDecoder();\n      const content = decoder.decode(stream.data);\n\n      // Simple text extraction - look for (text) Tj patterns\n      const texts: string[] = [];\n      const regex = /\\(([^)]*)\\)\\s*Tj/g;\n      let match;\n      while ((match = regex.exec(content)) !== null) {\n         texts.push(match[1]);\n      }\n\n      return texts.join(\" \");\n   }\n}\n"
  ],
  "mappings": "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",
  "debugId": "2D25678A9DC8958E64756E2164756E21",
  "names": []
}