extract-pdf 0.1.20 → 0.1.22

package/src/models/line-converter.ts

@@ -1,224 +1,224 @@
-/**
- * @description Converts an array of spatially-grouped TextItems (one line) into a single
- * LineItem by detecting inline formatting (bold, italic), footnote superscripts, footnote
- * anchors, and hyperlinks. WordFormat carries HTML open/close symbols; WordType carries
- * rendering helpers for links and footnotes. The inner WordDetectionStream extends
- * StashingStream to buffer consecutive same-format items before flushing them as Word nodes.
- */
-import TextItem from "./text-item";
-import Word, { WordFormatEntry, WordTypeEntry } from "./word";
-import LineItem from "./line-item";
-import StashingStream from "./stashing-stream";
-import ParsedElements from "./parsed-elements";
-import { isNumber, isListItemCharacter } from "../utils/string-functions";
-import { sortByX } from "../utils/page-item-functions";
-
-export const WordFormat: Record<string, WordFormatEntry> = {
-  BOLD: {
-    name: "BOLD",
-    startSymbol: "<strong>",
-    endSymbol: "</strong>",
-  },
-
-  OBLIQUE: {
-    name: "OBLIQUE",
-    startSymbol: "<em>",
-    endSymbol: "</em>",
-  },
-
-  BOLD_OBLIQUE: {
-    name: "BOLD_OBLIQUE",
-    startSymbol: "<strong><em>",
-    endSymbol: "</em></strong>",
-  },
-};
-
-export const WordType: Record<string, WordTypeEntry> = {
-  LINK: {
-    name: "LINK",
-    toText(string: string) {
-      return `<a href="${string}">${string}</a>`;
-    },
-  },
-
-  FOOTNOTE_LINK: {
-    name: "FOOTNOTE_LINK",
-    attachWithoutWhitespace: true,
-    plainTextFormat: true,
-    toText(string: string) {
-      return `<sup><a href="#${string}">${string}</a></sup>`;
-    },
-  },
-
-  FOOTNOTE: {
-    name: "FOOTNOTE",
-    toText(string: string) {
-      return `<p id="${string}">^${string}</p>`;
-    },
-  },
-};
-
-export default class LineConverter {
-  fontToFormats: Map<string, string>;
-
-  constructor(fontToFormats: Map<string, string>) {
-    this.fontToFormats = fontToFormats;
-  }
-
-  compact(textItems: TextItem[]): LineItem {
-    sortByX(textItems);
-
-    const wordStream = new WordDetectionStream(this.fontToFormats);
-    wordStream.consumeAll(textItems.map((item) => new TextItem({ ...item })));
-    const words = wordStream.complete();
-
-    var maxHeight = 0;
-    var widthSum = 0;
-    textItems.forEach((item) => {
-      maxHeight = Math.max(maxHeight, item.height);
-      widthSum += item.width;
-    });
-    return new LineItem({
-      x: textItems[0].x,
-      y: textItems[0].y,
-      height: maxHeight,
-      width: widthSum,
-      words: words,
-      parsedElements: new ParsedElements({
-        footnoteLinks: wordStream.footnoteLinks,
-        footnotes: wordStream.footnotes,
-        containLinks: wordStream.containLinks,
-        formattedWords: wordStream.formattedWords,
-      }),
-    });
-  }
-}
-
-class WordDetectionStream extends StashingStream {
-  fontToFormats: Map<string, string>;
-  footnoteLinks: number[];
-  footnotes: string[];
-  formattedWords: number;
-  containLinks: boolean;
-  stashedNumber: boolean;
-  firstY?: number;
-  currentItem: TextItem | null;
-
-  constructor(fontToFormats: Map<string, string>) {
-    super();
-    this.fontToFormats = fontToFormats;
-    this.footnoteLinks = [];
-    this.footnotes = [];
-    this.formattedWords = 0;
-    this.containLinks = false;
-    this.stashedNumber = false;
-    this.currentItem = null;
-  }
-
-  shouldStash(item: any): boolean {
-    if (!this.firstY) {
-      this.firstY = item.y;
-    }
-    this.currentItem = item;
-    return true;
-  }
-
-  onPushOnStash(item: any): void {
-    this.stashedNumber = isNumber(item.text.trim());
-  }
-
-  doMatchesStash(lastItem: any, item: any): boolean {
-    const lastItemFormat = this.fontToFormats.get(lastItem.font);
-    const itemFormat = this.fontToFormats.get(item.font);
-    if (lastItemFormat !== itemFormat) {
-      return false;
-    }
-    const itemIsANumber = isNumber(item.text.trim());
-    return this.stashedNumber === itemIsANumber;
-  }
-
-  doFlushStash(stash: any[], results: any[]): void {
-    if (this.stashedNumber) {
-      const joinedNumber = stash
-        .map((item: any) => item.text)
-        .join("")
-        .trim();
-      if (stash[0].y > this.firstY) {
-        results.push(
-          new Word({
-            string: `${joinedNumber}`,
-            type: WordType.FOOTNOTE_LINK,
-          }),
-        );
-        this.footnoteLinks.push(parseInt(joinedNumber));
-      } else if (this.currentItem && this.currentItem.y < stash[0].y) {
-        results.push(
-          new Word({
-            string: `${joinedNumber}`,
-            type: WordType.FOOTNOTE,
-          }),
-        );
-        this.footnotes.push(joinedNumber);
-      } else {
-        this.copyStashItemsAsText(stash, results);
-      }
-    } else {
-      this.copyStashItemsAsText(stash, results);
-    }
-  }
-
-  copyStashItemsAsText(stash: any[], results: any[]): void {
-    const format = this.fontToFormats.get(stash[0].font);
-    results.push(...this.itemsToWords(stash, format));
-  }
-
-  itemsToWords(items: TextItem[], formatName: string | null): Word[] {
-    const combinedText = combineText(items);
-    const words = combinedText.split(" ");
-    const format = formatName ? WordFormat[formatName] : null;
-    return words
-      .filter((w) => w.trim().length > 0)
-      .map((word) => {
-        var type: WordTypeEntry | null = null;
-        if (word.startsWith("http:")) {
-          this.containLinks = true;
-          type = WordType.LINK;
-        } else if (word.startsWith("www.")) {
-          this.containLinks = true;
-          word = `http://${word}`;
-          type = WordType.LINK;
-        }
-
-        if (format) {
-          this.formattedWords++;
-        }
-        return new Word({ string: word, type, format });
-      });
-  }
-}
-
-function combineText(textItems: TextItem[]): string {
-  var text = "";
-  var lastItem: TextItem | null = null;
-  textItems.forEach((textItem) => {
-    var textToAdd = textItem.text;
-    if (!text.endsWith(" ") && !textToAdd.startsWith(" ")) {
-      if (lastItem) {
-        const xDistance = textItem.x - lastItem.x - lastItem.width;
-        if (xDistance > 5) {
-          text += " ";
-        }
-      } else {
-        if (isListItemCharacter(textItem.text)) {
-          textToAdd += " ";
-        }
-      }
-    }
-    text += textToAdd;
-    lastItem = textItem;
-  });
-  return text;
-}
-
-
-
+/**
+ * @description Converts an array of spatially-grouped TextItems (one line) into a single
+ * LineItem by detecting inline formatting (bold, italic), footnote superscripts, footnote
+ * anchors, and hyperlinks. WordFormat carries HTML open/close symbols; WordType carries
+ * rendering helpers for links and footnotes. The inner WordDetectionStream extends
+ * StashingStream to buffer consecutive same-format items before flushing them as Word nodes.
+ */
+import TextItem from "./text-item";
+import Word, { WordFormatEntry, WordTypeEntry } from "./word";
+import LineItem from "./line-item";
+import StashingStream from "./stashing-stream";
+import ParsedElements from "./parsed-elements";
+import { isNumber, isListItemCharacter } from "../utils/string-functions";
+import { sortByX } from "../utils/page-item-functions";
+
+export const WordFormat: Record<string, WordFormatEntry> = {
+  BOLD: {
+    name: "BOLD",
+    startSymbol: "<strong>",
+    endSymbol: "</strong>",
+  },
+
+  OBLIQUE: {
+    name: "OBLIQUE",
+    startSymbol: "<em>",
+    endSymbol: "</em>",
+  },
+
+  BOLD_OBLIQUE: {
+    name: "BOLD_OBLIQUE",
+    startSymbol: "<strong><em>",
+    endSymbol: "</em></strong>",
+  },
+};
+
+export const WordType: Record<string, WordTypeEntry> = {
+  LINK: {
+    name: "LINK",
+    toText(string: string) {
+      return `<a href="${string}">${string}</a>`;
+    },
+  },
+
+  FOOTNOTE_LINK: {
+    name: "FOOTNOTE_LINK",
+    attachWithoutWhitespace: true,
+    plainTextFormat: true,
+    toText(string: string) {
+      return `<sup><a href="#${string}">${string}</a></sup>`;
+    },
+  },
+
+  FOOTNOTE: {
+    name: "FOOTNOTE",
+    toText(string: string) {
+      return `<p id="${string}">^${string}</p>`;
+    },
+  },
+};
+
+export default class LineConverter {
+  fontToFormats: Map<string, string>;
+
+  constructor(fontToFormats: Map<string, string>) {
+    this.fontToFormats = fontToFormats;
+  }
+
+  compact(textItems: TextItem[]): LineItem {
+    sortByX(textItems);
+
+    const wordStream = new WordDetectionStream(this.fontToFormats);
+    wordStream.consumeAll(textItems.map((item) => new TextItem({ ...item })));
+    const words = wordStream.complete();
+
+    var maxHeight = 0;
+    var widthSum = 0;
+    textItems.forEach((item) => {
+      maxHeight = Math.max(maxHeight, item.height);
+      widthSum += item.width;
+    });
+    return new LineItem({
+      x: textItems[0].x,
+      y: textItems[0].y,
+      height: maxHeight,
+      width: widthSum,
+      words: words,
+      parsedElements: new ParsedElements({
+        footnoteLinks: wordStream.footnoteLinks,
+        footnotes: wordStream.footnotes,
+        containLinks: wordStream.containLinks,
+        formattedWords: wordStream.formattedWords,
+      }),
+    });
+  }
+}
+
+class WordDetectionStream extends StashingStream {
+  fontToFormats: Map<string, string>;
+  footnoteLinks: number[];
+  footnotes: string[];
+  formattedWords: number;
+  containLinks: boolean;
+  stashedNumber: boolean;
+  firstY?: number;
+  currentItem: TextItem | null;
+
+  constructor(fontToFormats: Map<string, string>) {
+    super();
+    this.fontToFormats = fontToFormats;
+    this.footnoteLinks = [];
+    this.footnotes = [];
+    this.formattedWords = 0;
+    this.containLinks = false;
+    this.stashedNumber = false;
+    this.currentItem = null;
+  }
+
+  shouldStash(item: any): boolean {
+    if (!this.firstY) {
+      this.firstY = item.y;
+    }
+    this.currentItem = item;
+    return true;
+  }
+
+  onPushOnStash(item: any): void {
+    this.stashedNumber = isNumber(item.text.trim());
+  }
+
+  doMatchesStash(lastItem: any, item: any): boolean {
+    const lastItemFormat = this.fontToFormats.get(lastItem.font);
+    const itemFormat = this.fontToFormats.get(item.font);
+    if (lastItemFormat !== itemFormat) {
+      return false;
+    }
+    const itemIsANumber = isNumber(item.text.trim());
+    return this.stashedNumber === itemIsANumber;
+  }
+
+  doFlushStash(stash: any[], results: any[]): void {
+    if (this.stashedNumber) {
+      const joinedNumber = stash
+        .map((item: any) => item.text)
+        .join("")
+        .trim();
+      if (stash[0].y > this.firstY) {
+        results.push(
+          new Word({
+            string: `${joinedNumber}`,
+            type: WordType.FOOTNOTE_LINK,
+          }),
+        );
+        this.footnoteLinks.push(parseInt(joinedNumber));
+      } else if (this.currentItem && this.currentItem.y < stash[0].y) {
+        results.push(
+          new Word({
+            string: `${joinedNumber}`,
+            type: WordType.FOOTNOTE,
+          }),
+        );
+        this.footnotes.push(joinedNumber);
+      } else {
+        this.copyStashItemsAsText(stash, results);
+      }
+    } else {
+      this.copyStashItemsAsText(stash, results);
+    }
+  }
+
+  copyStashItemsAsText(stash: any[], results: any[]): void {
+    const format = this.fontToFormats.get(stash[0].font);
+    results.push(...this.itemsToWords(stash, format));
+  }
+
+  itemsToWords(items: TextItem[], formatName: string | null): Word[] {
+    const combinedText = combineText(items);
+    const words = combinedText.split(" ");
+    const format = formatName ? WordFormat[formatName] : null;
+    return words
+      .filter((w) => w.trim().length > 0)
+      .map((word) => {
+        var type: WordTypeEntry | null = null;
+        if (word.startsWith("http:")) {
+          this.containLinks = true;
+          type = WordType.LINK;
+        } else if (word.startsWith("www.")) {
+          this.containLinks = true;
+          word = `http://${word}`;
+          type = WordType.LINK;
+        }
+
+        if (format) {
+          this.formattedWords++;
+        }
+        return new Word({ string: word, type, format });
+      });
+  }
+}
+
+function combineText(textItems: TextItem[]): string {
+  var text = "";
+  var lastItem: TextItem | null = null;
+  textItems.forEach((textItem) => {
+    var textToAdd = textItem.text;
+    if (!text.endsWith(" ") && !textToAdd.startsWith(" ")) {
+      if (lastItem) {
+        const xDistance = textItem.x - lastItem.x - lastItem.width;
+        if (xDistance > 5) {
+          text += " ";
+        }
+      } else {
+        if (isListItemCharacter(textItem.text)) {
+          textToAdd += " ";
+        }
+      }
+    }
+    text += textToAdd;
+    lastItem = textItem;
+  });
+  return text;
+}
+
+
+

package/src/models/metadata.ts

@@ -1,29 +1,29 @@
-/**
- * @description Normalised PDF document metadata (title, author, creator, producer).
- * Handles both the modern XMP `metadata` API and the legacy `info` dictionary
- * returned by pdfjs, so callers always receive a consistent shape regardless of
- * which metadata format the PDF uses.
- */
-// Metadata of the PDF document
-export default class Metadata {
-  title?: string;
-  creator?: string;
-  producer?: string;
-  author?: string;
-
-  constructor(originalMetadata: {
-    metadata?: { get(key: string): string | undefined };
-    info?: { Title?: string; Author?: string; Creator?: string; Producer?: string };
-  }) {
-    if (originalMetadata.metadata) {
-      this.title = originalMetadata.metadata.get("dc:title");
-      this.creator = originalMetadata.metadata.get("xap:creatortool");
-      this.producer = originalMetadata.metadata.get("pdf:producer");
-    } else {
-      this.title = originalMetadata.info?.Title;
-      this.author = originalMetadata.info?.Author;
-      this.creator = originalMetadata.info?.Creator;
-      this.producer = originalMetadata.info?.Producer;
-    }
-  }
-}
+/**
+ * @description Normalised PDF document metadata (title, author, creator, producer).
+ * Handles both the modern XMP `metadata` API and the legacy `info` dictionary
+ * returned by pdfjs, so callers always receive a consistent shape regardless of
+ * which metadata format the PDF uses.
+ */
+// Metadata of the PDF document
+export default class Metadata {
+  title?: string;
+  creator?: string;
+  producer?: string;
+  author?: string;
+
+  constructor(originalMetadata: {
+    metadata?: { get(key: string): string | undefined };
+    info?: { Title?: string; Author?: string; Creator?: string; Producer?: string };
+  }) {
+    if (originalMetadata.metadata) {
+      this.title = originalMetadata.metadata.get("dc:title");
+      this.creator = originalMetadata.metadata.get("xap:creatortool");
+      this.producer = originalMetadata.metadata.get("pdf:producer");
+    } else {
+      this.title = originalMetadata.info?.Title;
+      this.author = originalMetadata.info?.Author;
+      this.creator = originalMetadata.info?.Creator;
+      this.producer = originalMetadata.info?.Producer;
+    }
+  }
+}

package/src/models/page.ts

@@ -1,16 +1,16 @@
-/**
- * @description Simple container for a single PDF page. Holds a 0-based `index`
- * and an `items` array whose element type evolves through the transformation
- * pipeline: raw `TextItem[]` → compacted `LineItem[]` → grouped `LineItemBlock[]`
- * → final serialized text objects.
- */
-// A page which holds PageItems displayable via PdfPageView
-export default class Page {
-  index: number;
-  items: any[];
-
-  constructor(options: { index: number; items?: any[] }) {
-    this.index = options.index;
-    this.items = options.items || [];
-  }
-}
+/**
+ * @description Simple container for a single PDF page. Holds a 0-based `index`
+ * and an `items` array whose element type evolves through the transformation
+ * pipeline: raw `TextItem[]` → compacted `LineItem[]` → grouped `LineItemBlock[]`
+ * → final serialized text objects.
+ */
+// A page which holds PageItems displayable via PdfPageView
+export default class Page {
+  index: number;
+  items: any[];
+
+  constructor(options: { index: number; items?: any[] }) {
+    this.index = options.index;
+    this.items = options.items || [];
+  }
+}

package/src/models/parse-result.ts

@@ -1,32 +1,32 @@
-/**
- * @description Immutable value object passed between every pipeline stage.
- * `pages` holds the document's page array (items mutate in type each stage),
- * `globals` holds cross-page statistics computed by `CalculateGlobalStats`
- * (most-used height, font, line distance, font-format map), and `messages`
- * carries diagnostic strings emitted by each transformation for debugging.
- */
-import Page from "./page";
-
-export interface ParseGlobals {
-  mostUsedHeight?: number;
-  mostUsedFont?: string;
-  mostUsedDistance?: number;
-  maxHeight?: number;
-  maxHeightFont?: string;
-  fontToFormats?: Map<string, string>;
-  tocPages?: number[];
-  headlineTypeToHeightRange?: Record<string, { min: number; max: number }>;
-}
-
-// The result of a PDF parse respectively a Transformation
-export default class ParseResult {
-  pages: Page[];
-  globals: ParseGlobals;
-  messages: string[];
-
-  constructor(options: { pages?: Page[]; globals?: ParseGlobals; messages?: string[] }) {
-    this.pages = options.pages || [];
-    this.globals = options.globals || {};
-    this.messages = options.messages || [];
-  }
-}
+/**
+ * @description Immutable value object passed between every pipeline stage.
+ * `pages` holds the document's page array (items mutate in type each stage),
+ * `globals` holds cross-page statistics computed by `CalculateGlobalStats`
+ * (most-used height, font, line distance, font-format map), and `messages`
+ * carries diagnostic strings emitted by each transformation for debugging.
+ */
+import Page from "./page";
+
+export interface ParseGlobals {
+  mostUsedHeight?: number;
+  mostUsedFont?: string;
+  mostUsedDistance?: number;
+  maxHeight?: number;
+  maxHeightFont?: string;
+  fontToFormats?: Map<string, string>;
+  tocPages?: number[];
+  headlineTypeToHeightRange?: Record<string, { min: number; max: number }>;
+}
+
+// The result of a PDF parse respectively a Transformation
+export default class ParseResult {
+  pages: Page[];
+  globals: ParseGlobals;
+  messages: string[];
+
+  constructor(options: { pages?: Page[]; globals?: ParseGlobals; messages?: string[] }) {
+    this.pages = options.pages || [];
+    this.globals = options.globals || {};
+    this.messages = options.messages || [];
+  }
+}

package/src/models/parsed-elements.ts

@@ -1,29 +1,29 @@
-/**
- * @description Aggregated inline-element metadata for a `LineItem` or
- * `LineItemBlock`. Tracks detected footnote link numbers, footnote definitions,
- * whether any hyperlinks are present, and a count of bold/italic formatted words.
- * The `add()` method merges a child item's `ParsedElements` into the parent
- * block's running totals as lines are gathered into blocks.
- */
-export default class ParsedElements {
-  footnoteLinks: number[];
-  footnotes: string[];
-  containLinks: boolean;
-  formattedWords: number;
-
-  constructor(options: { footnoteLinks?: number[]; footnotes?: string[]; containLinks?: boolean; formattedWords?: number }) {
-    this.footnoteLinks = options.footnoteLinks || [];
-    this.footnotes = options.footnotes || [];
-    this.containLinks = options.containLinks ?? false;
-    this.formattedWords = options.formattedWords ?? 0;
-  }
-
-  add(parsedElements: ParsedElements): void {
-    this.footnoteLinks = this.footnoteLinks.concat(
-      parsedElements.footnoteLinks,
-    );
-    this.footnotes = this.footnotes.concat(parsedElements.footnotes);
-    this.containLinks = this.containLinks || parsedElements.containLinks;
-    this.formattedWords += parsedElements.formattedWords;
-  }
-}
+/**
+ * @description Aggregated inline-element metadata for a `LineItem` or
+ * `LineItemBlock`. Tracks detected footnote link numbers, footnote definitions,
+ * whether any hyperlinks are present, and a count of bold/italic formatted words.
+ * The `add()` method merges a child item's `ParsedElements` into the parent
+ * block's running totals as lines are gathered into blocks.
+ */
+export default class ParsedElements {
+  footnoteLinks: number[];
+  footnotes: string[];
+  containLinks: boolean;
+  formattedWords: number;
+
+  constructor(options: { footnoteLinks?: number[]; footnotes?: string[]; containLinks?: boolean; formattedWords?: number }) {
+    this.footnoteLinks = options.footnoteLinks || [];
+    this.footnotes = options.footnotes || [];
+    this.containLinks = options.containLinks ?? false;
+    this.formattedWords = options.formattedWords ?? 0;
+  }
+
+  add(parsedElements: ParsedElements): void {
+    this.footnoteLinks = this.footnoteLinks.concat(
+      parsedElements.footnoteLinks,
+    );
+    this.footnotes = this.footnotes.concat(parsedElements.footnotes);
+    this.containLinks = this.containLinks || parsedElements.containLinks;
+    this.formattedWords += parsedElements.formattedWords;
+  }
+}