extract-pdf 0.1.21 → 0.1.23

package/src/transforms/block/detect-code-quote-blocks.ts

@@ -1,57 +1,57 @@
-/**
- * @description Block-level transformation that marks blocks as `BlockType.CODE`
- * when all constituent lines are indented beyond the page's leftmost x position
- * and the text height matches body-text height. Heuristically distinguishes
- * indented code/blockquote sections from regular paragraphs without relying on
- * font metadata.
- */
-
-import ToLineItemBlockTransformation from '../base/to-line-item-block-transform'
-import ParseResult from '../../models/parse-result'
-import { DETECTED_ANNOTATION } from '../../models/annotation'
-import BlockType from '../../models/block-type'
-import { minXFromBlocks } from '../../utils/page-item-functions'
-
-// Detect items which are code/quote blocks
-export default class DetectCodeQuoteBlocks extends ToLineItemBlockTransformation {
-  constructor () {
-    super('$1')
-  }
-
-  transform(parseResult: ParseResult): ParseResult {
-    const mostUsedHeight = parseResult.globals.mostUsedHeight ?? 0
-    var foundCodeItems = 0
-    parseResult.pages.forEach(page => {
-      var minX = minXFromBlocks(page.items)
-      page.items.forEach(block => {
-        if (!block.type && looksLikeCodeBlock(minX, block.items, mostUsedHeight)) {
-          block.annotation = DETECTED_ANNOTATION
-          block.type = BlockType.CODE
-          foundCodeItems++
-        }
-      })
-    })
-
-    return new ParseResult({
-      ...parseResult,
-      messages: [
-        'Detected ' + foundCodeItems + ' code/quote items.',
-      ],
-    })
-  }
-}
-
-function looksLikeCodeBlock(minX: number, items: any[], mostUsedHeight: number): boolean {
-  if (items.length === 0) {
-    return false
-  }
-  if (items.length === 1) {
-    return items[0].x > minX && items[0].height <= mostUsedHeight + 1
-  }
-  for (var item of items) {
-    if (item.x === minX) {
-      return false
-    }
-  }
-  return true
-}
+/**
+ * @description Block-level transformation that marks blocks as `BlockType.CODE`
+ * when all constituent lines are indented beyond the page's leftmost x position
+ * and the text height matches body-text height. Heuristically distinguishes
+ * indented code/blockquote sections from regular paragraphs without relying on
+ * font metadata.
+ */
+
+import ToLineItemBlockTransformation from '../base/to-line-item-block-transform'
+import ParseResult from '../../models/parse-result'
+import { DETECTED_ANNOTATION } from '../../models/annotation'
+import BlockType from '../../models/block-type'
+import { minXFromBlocks } from '../../utils/page-item-functions'
+
+// Detect items which are code/quote blocks
+export default class DetectCodeQuoteBlocks extends ToLineItemBlockTransformation {
+  constructor () {
+    super('$1')
+  }
+
+  transform(parseResult: ParseResult): ParseResult {
+    const mostUsedHeight = parseResult.globals.mostUsedHeight ?? 0
+    var foundCodeItems = 0
+    parseResult.pages.forEach(page => {
+      var minX = minXFromBlocks(page.items)
+      page.items.forEach(block => {
+        if (!block.type && looksLikeCodeBlock(minX, block.items, mostUsedHeight)) {
+          block.annotation = DETECTED_ANNOTATION
+          block.type = BlockType.CODE
+          foundCodeItems++
+        }
+      })
+    })
+
+    return new ParseResult({
+      ...parseResult,
+      messages: [
+        'Detected ' + foundCodeItems + ' code/quote items.',
+      ],
+    })
+  }
+}
+
+function looksLikeCodeBlock(minX: number, items: any[], mostUsedHeight: number): boolean {
+  if (items.length === 0) {
+    return false
+  }
+  if (items.length === 1) {
+    return items[0].x > minX && items[0].height <= mostUsedHeight + 1
+  }
+  for (var item of items) {
+    if (item.x === minX) {
+      return false
+    }
+  }
+  return true
+}

package/src/transforms/block/detect-list-levels.ts

@@ -1,64 +1,64 @@
-/**
- * @description Block-level transformation that adds hierarchical indentation to
- * nested list items within `BlockType.LIST` blocks. Tracks nesting level by
- * comparing each item's x position to the previous item's — deeper x means a
- * new sub-level — and prepends spaces proportional to the level so the HTML
- * output reflects the original visual hierarchy.
- */
-import ToLineItemBlockTransformation from '../base/to-line-item-block-transform'
-import ParseResult from '../../models/parse-result'
-import Word from '../../models/word'
-import { MODIFIED_ANNOTATION, UNCHANGED_ANNOTATION } from '../../models/annotation'
-import BlockType from '../../models/block-type'
-
-// Cares for proper sub-item spacing/leveling
-export default class DetectListLevels extends ToLineItemBlockTransformation {
-  constructor () {
-    super('Level Lists')
-  }
-
-  transform(parseResult: ParseResult): ParseResult {
-    var listBlocks = 0
-    var modifiedBlocks = 0
-    parseResult.pages.forEach(page => {
-      page.items.filter(block => block.type === BlockType.LIST).forEach(listBlock => {
-        var lastItemX: number | undefined
-        var currentLevel = 0
-        const xByLevel: Record<number, number> = {}
-        var modifiedBlock = false
-        listBlock.items.forEach(item => {
-          const isListItem = true
-          if (lastItemX && isListItem) {
-            if (item.x > lastItemX) {
-              currentLevel++
-              xByLevel[item.x] = currentLevel
-            } else if (item.x < lastItemX) {
-              currentLevel = xByLevel[item.x]
-            }
-          } else {
-            xByLevel[item.x] = 0
-          }
-          if (currentLevel > 0) {
-            item.words = [
-              new Word({ string: ' '.repeat(currentLevel * 3) }),
-            ].concat(item.words)
-            modifiedBlock = true
-          }
-          lastItemX = item.x
-        })
-        listBlocks++
-        if (modifiedBlock) {
-          modifiedBlocks++
-          listBlock.annotation = MODIFIED_ANNOTATION
-        } else {
-          listBlock.annotation = UNCHANGED_ANNOTATION
-        }
-      })
-    })
-
-    return new ParseResult({
-      ...parseResult,
-      messages: ['Modified ' + modifiedBlocks + ' / ' + listBlocks + ' list blocks.'],
-    })
-  }
-}
+/**
+ * @description Block-level transformation that adds hierarchical indentation to
+ * nested list items within `BlockType.LIST` blocks. Tracks nesting level by
+ * comparing each item's x position to the previous item's — deeper x means a
+ * new sub-level — and prepends spaces proportional to the level so the HTML
+ * output reflects the original visual hierarchy.
+ */
+import ToLineItemBlockTransformation from '../base/to-line-item-block-transform'
+import ParseResult from '../../models/parse-result'
+import Word from '../../models/word'
+import { MODIFIED_ANNOTATION, UNCHANGED_ANNOTATION } from '../../models/annotation'
+import BlockType from '../../models/block-type'
+
+// Cares for proper sub-item spacing/leveling
+export default class DetectListLevels extends ToLineItemBlockTransformation {
+  constructor () {
+    super('Level Lists')
+  }
+
+  transform(parseResult: ParseResult): ParseResult {
+    var listBlocks = 0
+    var modifiedBlocks = 0
+    parseResult.pages.forEach(page => {
+      page.items.filter(block => block.type === BlockType.LIST).forEach(listBlock => {
+        var lastItemX: number | undefined
+        var currentLevel = 0
+        const xByLevel: Record<number, number> = {}
+        var modifiedBlock = false
+        listBlock.items.forEach(item => {
+          const isListItem = true
+          if (lastItemX && isListItem) {
+            if (item.x > lastItemX) {
+              currentLevel++
+              xByLevel[item.x] = currentLevel
+            } else if (item.x < lastItemX) {
+              currentLevel = xByLevel[item.x]
+            }
+          } else {
+            xByLevel[item.x] = 0
+          }
+          if (currentLevel > 0) {
+            item.words = [
+              new Word({ string: ' '.repeat(currentLevel * 3) }),
+            ].concat(item.words)
+            modifiedBlock = true
+          }
+          lastItemX = item.x
+        })
+        listBlocks++
+        if (modifiedBlock) {
+          modifiedBlocks++
+          listBlock.annotation = MODIFIED_ANNOTATION
+        } else {
+          listBlock.annotation = UNCHANGED_ANNOTATION
+        }
+      })
+    })
+
+    return new ParseResult({
+      ...parseResult,
+      messages: ['Modified ' + modifiedBlocks + ' / ' + listBlocks + ' list blocks.'],
+    })
+  }
+}

package/src/transforms/block/gather-blocks.ts

@@ -1,113 +1,113 @@
-/**
- * @description Block-level transformation that merges consecutive `LineItem`s into
- * `LineItemBlock`s. Flushes the current block when the item type changes or the
- * vertical gap exceeds `mostUsedDistance`, while respecting per-type merge flags
- * (`mergeToBlock`, `mergeFollowingNonTypedItems`,
- * `mergeFollowingNonTypedItemsWithSmallDistance`) to handle lists and footnotes correctly.
- */
-
-import ToLineItemBlockTransformation from "../base/to-line-item-block-transform";
-import ParseResult from "../../models/parse-result";
-import LineItemBlock from "../../models/line-item-block";
-import { DETECTED_ANNOTATION } from "../../models/annotation";
-import { minXFromPageItems } from "../../utils/page-item-functions";
-
-// Gathers lines to blocks
-export default class GatherBlocks extends ToLineItemBlockTransformation {
-  constructor() {
-    super("Gather Blocks");
-  }
-
-  transform(parseResult: ParseResult): ParseResult {
-    const { mostUsedDistance } = parseResult.globals;
-    var createdBlocks = 0;
-    var lineItemCount = 0;
-    parseResult.pages.map((page) => {
-      lineItemCount += page.items.length;
-      const blocks = [];
-      var stashedBlock = new LineItemBlock({});
-      const flushStashedItems = () => {
-        if (stashedBlock.items.length > 1) {
-          stashedBlock.annotation = DETECTED_ANNOTATION;
-        }
-
-        blocks.push(stashedBlock);
-        stashedBlock = new LineItemBlock({});
-        createdBlocks++;
-      };
-
-      var minX = minXFromPageItems(page.items);
-      page.items.forEach((item) => {
-        if (
-          stashedBlock.items.length > 0 &&
-          shouldFlushBlock(stashedBlock, item, minX, mostUsedDistance)
-        ) {
-          flushStashedItems();
-        }
-        stashedBlock.addItem(item);
-      });
-      if (stashedBlock.items.length > 0) {
-        flushStashedItems();
-      }
-      page.items = blocks;
-    });
-
-    return new ParseResult({
-      ...parseResult,
-      messages: [
-        "Gathered " +
-          createdBlocks +
-          " blocks out of " +
-          lineItemCount +
-          " line items",
-      ],
-    });
-  }
-}
-
-function shouldFlushBlock(stashedBlock: any, item: any, minX: number, mostUsedDistance: number): boolean {
-  if (
-    stashedBlock.type &&
-    stashedBlock.type.mergeFollowingNonTypedItems &&
-    !item.type
-  ) {
-    return false;
-  }
-  const lastItem = stashedBlock.items[stashedBlock.items.length - 1];
-  const hasBigDistance = bigDistance(lastItem, item, minX, mostUsedDistance);
-  if (
-    stashedBlock.type &&
-    stashedBlock.type.mergeFollowingNonTypedItemsWithSmallDistance &&
-    !item.type &&
-    !hasBigDistance
-  ) {
-    return false;
-  }
-  if (item.type !== stashedBlock.type) {
-    return true;
-  }
-  if (item.type) {
-    return !item.type.mergeToBlock;
-  } else {
-    return hasBigDistance;
-  }
-}
-
-function bigDistance(lastItem: any, item: any, minX: number, mostUsedDistance: number): boolean {
-  const distance = lastItem.y - item.y;
-  if (distance < 0 - mostUsedDistance / 2) {
-    // distance is negative - and not only a bit
-    return true;
-  }
-  var allowedDisctance = mostUsedDistance + 1;
-  if (lastItem.x > minX && item.x > minX) {
-    // intended elements like lists often have greater spacing
-    allowedDisctance = mostUsedDistance + mostUsedDistance / 2;
-  }
-  if (distance > allowedDisctance) {
-    return true;
-  }
-  return false;
-}
-
-
+/**
+ * @description Block-level transformation that merges consecutive `LineItem`s into
+ * `LineItemBlock`s. Flushes the current block when the item type changes or the
+ * vertical gap exceeds `mostUsedDistance`, while respecting per-type merge flags
+ * (`mergeToBlock`, `mergeFollowingNonTypedItems`,
+ * `mergeFollowingNonTypedItemsWithSmallDistance`) to handle lists and footnotes correctly.
+ */
+
+import ToLineItemBlockTransformation from "../base/to-line-item-block-transform";
+import ParseResult from "../../models/parse-result";
+import LineItemBlock from "../../models/line-item-block";
+import { DETECTED_ANNOTATION } from "../../models/annotation";
+import { minXFromPageItems } from "../../utils/page-item-functions";
+
+// Gathers lines to blocks
+export default class GatherBlocks extends ToLineItemBlockTransformation {
+  constructor() {
+    super("Gather Blocks");
+  }
+
+  transform(parseResult: ParseResult): ParseResult {
+    const { mostUsedDistance } = parseResult.globals;
+    var createdBlocks = 0;
+    var lineItemCount = 0;
+    parseResult.pages.map((page) => {
+      lineItemCount += page.items.length;
+      const blocks = [];
+      var stashedBlock = new LineItemBlock({});
+      const flushStashedItems = () => {
+        if (stashedBlock.items.length > 1) {
+          stashedBlock.annotation = DETECTED_ANNOTATION;
+        }
+
+        blocks.push(stashedBlock);
+        stashedBlock = new LineItemBlock({});
+        createdBlocks++;
+      };
+
+      var minX = minXFromPageItems(page.items);
+      page.items.forEach((item) => {
+        if (
+          stashedBlock.items.length > 0 &&
+          shouldFlushBlock(stashedBlock, item, minX, mostUsedDistance)
+        ) {
+          flushStashedItems();
+        }
+        stashedBlock.addItem(item);
+      });
+      if (stashedBlock.items.length > 0) {
+        flushStashedItems();
+      }
+      page.items = blocks;
+    });
+
+    return new ParseResult({
+      ...parseResult,
+      messages: [
+        "Gathered " +
+          createdBlocks +
+          " blocks out of " +
+          lineItemCount +
+          " line items",
+      ],
+    });
+  }
+}
+
+function shouldFlushBlock(stashedBlock: any, item: any, minX: number, mostUsedDistance: number): boolean {
+  if (
+    stashedBlock.type &&
+    stashedBlock.type.mergeFollowingNonTypedItems &&
+    !item.type
+  ) {
+    return false;
+  }
+  const lastItem = stashedBlock.items[stashedBlock.items.length - 1];
+  const hasBigDistance = bigDistance(lastItem, item, minX, mostUsedDistance);
+  if (
+    stashedBlock.type &&
+    stashedBlock.type.mergeFollowingNonTypedItemsWithSmallDistance &&
+    !item.type &&
+    !hasBigDistance
+  ) {
+    return false;
+  }
+  if (item.type !== stashedBlock.type) {
+    return true;
+  }
+  if (item.type) {
+    return !item.type.mergeToBlock;
+  } else {
+    return hasBigDistance;
+  }
+}
+
+function bigDistance(lastItem: any, item: any, minX: number, mostUsedDistance: number): boolean {
+  const distance = lastItem.y - item.y;
+  if (distance < 0 - mostUsedDistance / 2) {
+    // distance is negative - and not only a bit
+    return true;
+  }
+  var allowedDisctance = mostUsedDistance + 1;
+  if (lastItem.x > minX && item.x > minX) {
+    // intended elements like lists often have greater spacing
+    allowedDisctance = mostUsedDistance + mostUsedDistance / 2;
+  }
+  if (distance > allowedDisctance) {
+    return true;
+  }
+  return false;
+}
+
+