@hoshomoh/react-native-document-scanner 1.2.0

package/ios/Options.swift

@@ -0,0 +1,109 @@
+import Foundation
+import UIKit
+
+/**
+ Base options shared by both Scan and Process operations.
+ Contains configuration for image output and OCR processing.
+ */
+public class BaseOptions {
+    public let quality: CGFloat
+    public let format: String
+    public let filter: String
+    public let includeBase64: Bool
+    public let includeText: Bool
+    public let textVersion: Int
+
+    init(quality: CGFloat, format: String, filter: String, includeBase64: Bool, includeText: Bool, textVersion: Int) {
+        self.quality = quality
+        self.format = format
+        self.filter = filter
+        self.includeBase64 = includeBase64
+        self.includeText = includeText
+        self.textVersion = textVersion
+    }
+
+    /**
+     Reads an integer option from the bridge dictionary.
+     Covers NSNumber, Int, and Double — all three bridging representations that can appear
+     depending on whether the call comes through the old bridge or JSI (new arch).
+     */
+    static func intOption(from dictionary: [String: Any]?, key: String, fallback: Int) -> Int {
+        guard let raw = dictionary?[key] else { return fallback }
+        if let n = raw as? NSNumber { return n.intValue }
+        if let i = raw as? Int { return i }
+        if let d = raw as? Double { return Int(d) }
+        return fallback
+    }
+
+    /**
+     Convenience initializer to parse common options from a dictionary.
+     - Parameters:
+       - dictionary: Raw options dictionary.
+       - defaultIncludeText: Default value for includeText (Scan defaults to false, Process to true).
+     */
+    init(from dictionary: [String: Any]?, defaultIncludeText: Bool) {
+        /* Quality: Clamp [0.1, 1.0] */
+        let q = dictionary?["quality"] as? CGFloat ?? 1.0
+        self.quality = max(0.1, min(1.0, q))
+
+        /* Format: whitelist [jpg, png] */
+        let f = dictionary?["format"] as? String ?? "jpg"
+        self.format = (f == "png") ? "png" : "jpg"
+
+        /* Filter: whitelist supported types */
+        let filterInput = dictionary?["filter"] as? String ?? "color"
+        let validFilters = ["color", "grayscale", "monochrome", "denoise", "sharpen", "ocrOptimized"]
+        self.filter = validFilters.contains(filterInput) ? filterInput : "color"
+
+        self.includeBase64 = dictionary?["includeBase64"] as? Bool ?? false
+        self.includeText = dictionary?["includeText"] as? Bool ?? defaultIncludeText
+
+        /* Text Version: allow [1, 2]. */
+        let rawVersion = BaseOptions.intOption(from: dictionary, key: "textVersion", fallback: 2)
+        self.textVersion = (rawVersion == 1) ? 1 : 2
+    }
+}
+
+/**
+ Strongly-typed representation of scan options.
+ Parses the raw dictionary from React Native and provides defaults.
+ */
+public class ScanOptions: BaseOptions {
+    public let maxPageCount: Int
+
+    /**
+     Initializes ScanOptions from a raw dictionary.
+     - Parameters:
+       - dictionary: The options dictionary from React Native.
+       - fallbackPageCount: Default page count if not specified.
+     */
+    public init(from dictionary: [String: Any]?, fallbackPageCount: Int) {
+        /* Max Page Count: Clamp [0, 100]. 0 = unlimited. */
+        let rawMax = BaseOptions.intOption(from: dictionary, key: "maxPageCount", fallback: fallbackPageCount)
+        self.maxPageCount = max(0, min(100, rawMax))
+
+        super.init(from: dictionary, defaultIncludeText: false)
+    }
+}
+
+/**
+ Strongly-typed representation of process options.
+ Parses the raw dictionary from React Native for processDocuments.
+ */
+public class ProcessOptions: BaseOptions {
+    public let images: [String]
+
+    /**
+     Initializes ProcessOptions from a raw dictionary.
+     - Parameter dictionary: The options dictionary from React Native.
+     - Returns: nil if 'images' array is missing.
+     */
+    public init?(from dictionary: [String: Any]?) {
+        guard let dict = dictionary,
+              let images = dict["images"] as? [String] else {
+            return nil
+        }
+        self.images = images
+        super.init(from: dictionary, defaultIncludeText: true)
+    }
+}

package/ios/ResponseUtil.swift

@@ -0,0 +1,25 @@
+import Foundation
+import UIKit
+
+/** Utility class for constructing the response objects for React Native. */
+public class ResponseUtil {
+    
+    /**
+     Constructs the ScanResult struct.
+     - Parameters:
+       - uri: The local file path.
+       - text: Optional OCR text.
+       - blocks: Optional OCR blocks.
+       - base64: Optional Base64 string.
+     - Returns: A `ScanResult` struct.
+     */
+    public static func buildResult(uri: String?, base64: String?, text: String?, blocks: [TextBlock]?, metadata: ScanMetadata) -> ScanResult {
+        return ScanResult(
+            uri: uri,
+            base64: base64,
+            text: text,
+            blocks: blocks,
+            metadata: metadata
+        )
+    }
+}

package/ios/ScanModels.swift

@@ -0,0 +1,84 @@
+import Foundation
+
+/** Describes which OCR engine and configuration produced a ScanResult. */
+public struct ScanMetadata: Encodable {
+    /// Platform identifier. Always "ios".
+    public let platform: String
+    /// OCR version requested (1 = Raw, 2 = Heuristic / RecognizeDocuments on iOS 26+).
+    public let textVersion: Int
+    /// Image filter that was applied to the image before OCR.
+    public let filter: String
+    /// The specific OCR engine used, or "none" if OCR was not requested.
+    /// - "RecognizeDocumentsRequest": iOS 26+ native document understanding (V2).
+    /// - "VNRecognizeTextRequest": Vision framework text request (V1 or V2 on iOS < 26).
+    /// - "none": OCR was not performed (includeText was false).
+    public let ocrEngine: String
+}
+
+/** Represents the geometric bounds of a text block in normalized coordinates (0.0 - 1.0). */
+public struct Frame: Encodable {
+    /// Horizontal position of the top-left corner.
+    public let x: Double
+    /// Vertical position of the top-left corner.
+    public let y: Double
+    /// Width of the bounding box.
+    public let width: Double
+    /// Height of the bounding box.
+    public let height: Double
+}
+
+/** Represents a recognized block of text with its position and confidence level. */
+public struct TextBlock: Encodable {
+    /// The recognized text string.
+    public let text: String
+    /// The bounding box of the text.
+    public let frame: Frame
+    /// The confidence level of the recognition (0.0 - 1.0).
+    public let confidence: Double?
+}
+
+/** Represents the final result of a scanned page. */
+public struct ScanResult: Encodable {
+    public let uri: String?
+    public let base64: String?
+    public let text: String?
+    public let blocks: [TextBlock]?
+    public let metadata: ScanMetadata
+
+    /** Converts the struct to a Dictionary for React Native bridge. */
+    public var dictionary: [String: Any] {
+        var dict: [String: Any] = [:]
+
+        if let uri = uri { dict["uri"] = uri }
+        if let base64 = base64 { dict["base64"] = base64 }
+        if let text = text { dict["text"] = text }
+
+        if let blocks = blocks {
+            /* Manually map blocks to ensure correct structure. */
+            dict["blocks"] = blocks.map { block in
+                var blockDict: [String: Any] = [
+                    "text": block.text,
+                    "frame": [
+                        "x": block.frame.x,
+                        "y": block.frame.y,
+                        "width": block.frame.width,
+                        "height": block.frame.height
+                    ]
+                ]
+                if let confidence = block.confidence {
+                    blockDict["confidence"] = confidence
+                }
+                return blockDict
+            }
+        }
+
+        dict["metadata"] = [
+            "platform": metadata.platform,
+            "textVersion": metadata.textVersion,
+            "filter": metadata.filter,
+            "ocrEngine": metadata.ocrEngine
+        ]
+
+        return dict
+    }
+}

package/ios/TextRecognizer.swift

@@ -0,0 +1,134 @@
+import Foundation
+import Vision
+import UIKit
+
+/**
+ A robust utility class for performing Optical Character Recognition (OCR)
+ using Apple's Vision framework.
+
+ Acts as a Facade delegating to versioned implementations:
+ - TextRecognizerV1 (Raw)
+ - TextRecognizerV2 (Heuristic, or native document understanding on iOS 26+)
+ */
+@available(iOS 13.0, *)
+public class TextRecognizer {
+
+  /**
+   Extracts text from an image using Apple's Vision Framework.
+
+   - Parameter image: `UIImage` object to process.
+   - Parameter version: OCR engine version (1 = Raw, 2 = Heuristic).
+   - Returns: A tuple containing the structured text and raw blocks.
+   */
+  public static func recognizeText(from image: UIImage, version: Int = 2) async -> (text: String, blocks: [TextBlock])? {
+
+      guard let cgImage = image.cgImage else {
+        Logger.warn("Could not retrieve CGImage from input.")
+        return nil
+      }
+
+      /* iOS 26+: Use RecognizeDocumentsRequest for V2 — native document structure, no heuristics needed */
+      if version == 2, #available(iOS 26.0, *) {
+          return await recognizeWithDocumentRequest(cgImage: cgImage)
+      }
+
+      /* Configure the Vision Request */
+      let request = VNRecognizeTextRequest()
+      request.recognitionLevel = .accurate
+
+      /*
+       V1 (Raw) uses standard language correction for general text.
+       V2 (Heuristic) disables it to preserve document layout and prevent over-merging.
+       */
+      request.usesLanguageCorrection = (version == 1)
+
+      /* Filter out noise and tiny text artifacts */
+      request.minimumTextHeight = 0.01
+
+      /* Enable automatic language detection for multilingual documents (iOS 16+) */
+      if #available(iOS 16.0, *) {
+          request.automaticallyDetectsLanguage = true
+      }
+
+      let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
+
+      do {
+        /* Perform text recognition — blocking CPU-bound call, safe on background task */
+        try handler.perform([request])
+
+        guard let observations = request.results else {
+          Logger.info("No text found in image.")
+          return nil
+        }
+
+        if version == 1 {
+            return TextRecognizerV1.recognize(observations)
+        } else {
+            return TextRecognizerV2.recognize(observations)
+        }
+
+      } catch {
+        Logger.error("Text recognition request failed: \(error.localizedDescription)")
+        return nil
+      }
+  }
+
+  /**
+   Returns the name of the OCR engine that will be used for the given version on the current OS.
+   Used by ImageProcessor to populate ScanResult metadata.
+   */
+  public static func engineName(for version: Int) -> String {
+      if version == 2, #available(iOS 26.0, *) {
+          return "RecognizeDocumentsRequest"
+      }
+      return "VNRecognizeTextRequest"
+  }
+
+  /**
+   iOS 26+ fast path using RecognizeDocumentsRequest.
+   Returns native document structure (paragraphs) mapped to the same
+   (text, blocks) format used by the heuristic path, so callers see no difference.
+   One block per paragraph — for structured documents each paragraph is typically one visual line.
+   */
+  @available(iOS 26.0, *)
+  private static func recognizeWithDocumentRequest(cgImage: CGImage) async -> (text: String, blocks: [TextBlock])? {
+      do {
+          let request = RecognizeDocumentsRequest()
+          let observations = try await request.perform(on: cgImage)
+
+          guard let document = observations.first?.document else {
+              Logger.info("No document structure found in image.")
+              return nil
+          }
+
+          var lines: [String] = []
+          var blocks: [TextBlock] = []
+
+          for paragraph in document.paragraphs {
+              let paragraphText = paragraph.transcript
+              lines.append(paragraphText)
+
+              /* Map bounding region to normalised top-left origin coordinates.
+                 boundingRegion is NormalizedRegion (Contour) → .boundingBox gives NormalizedRect → .cgRect gives CGRect.
+                 Vision uses bottom-left origin — convert to top-left: 1 - y - height */
+              let box = paragraph.boundingRegion.boundingBox.cgRect
+              let androidStyleY = 1.0 - box.origin.y - box.size.height
+              let frame = Frame(
+                  x: Double(box.origin.x),
+                  y: Double(androidStyleY),
+                  width: Double(box.size.width),
+                  height: Double(box.size.height)
+              )
+
+              blocks.append(TextBlock(text: paragraphText, frame: frame, confidence: nil))
+          }
+
+          let text = lines.isEmpty ? "" : lines.joined(separator: "\n") + "\n"
+          return (text: text, blocks: blocks)
+
+      } catch {
+          Logger.error("RecognizeDocumentsRequest failed: \(error.localizedDescription)")
+          return nil
+      }
+  }
+}

package/ios/TextRecognizerV1.swift

@@ -0,0 +1,56 @@
+import Foundation
+import Vision
+
+/**
+ Version 1: Raw Output (Standard Vision Behavior)
+ */
+@available(iOS 13.0, *)
+public class TextRecognizerV1 {
+    
+    /**
+     Performs raw text recognition from Vision observations.
+     - Parameter observations: Raw results from VNRecognizeTextRequest.
+     - Returns: Concatenated text and structured blocks.
+     */
+    public static func recognize(_ observations: [VNRecognizedTextObservation]) -> (text: String, blocks: [TextBlock]) {
+        var fullText = ""
+        
+        var blocks: [TextBlock] = []
+
+        for obs in observations {
+            guard let candidate = obs.topCandidates(1).first else { continue }
+            
+            let box = obs.boundingBox
+            
+            /* 
+             Vision uses bottom-left origin. 
+             Convert to Android-style top-left origin: 1.0 - y - height 
+             */
+            let androidStyleY = 1.0 - box.origin.y - box.size.height
+            
+            let frame = Frame(
+                x: box.origin.x,
+                y: androidStyleY,
+                width: box.size.width,
+                height: box.size.height
+            )
+            
+            blocks.append(TextBlock(
+                text: candidate.string,
+                frame: frame,
+                confidence: Double(candidate.confidence)
+            ))
+        }
+        
+        /* 
+         Sort top-to-bottom using the converted Y (top-left origin).
+         Smaller Y values are higher on the page.
+         */
+        let sortedBlocks = blocks.sorted { $0.frame.y < $1.frame.y }
+        
+        /* Concatenate text based on reading order sort */
+        fullText = sortedBlocks.map { $0.text }.joined(separator: "\n")
+        
+        return (text: fullText, blocks: sortedBlocks)
+    }
+}

package/ios/TextRecognizerV2.swift

@@ -0,0 +1,169 @@
+import Foundation
+import Vision
+import UIKit
+
+/**
+ Version 2: Heuristic Enhanced (Line Clustering for Layout Preservation)
+ */
+@available(iOS 13.0, *)
+public class TextRecognizerV2 {
+
+    public static func recognize(_ observations: [VNRecognizedTextObservation]) -> (text: String, blocks: [TextBlock]) {
+
+        /* 1. LineCluster Strategy */
+        struct LineCluster {
+            var observations: [VNRecognizedTextObservation]
+            var unionBoundingBox: CGRect
+            var heights: [CGFloat]
+            var centerYs: [CGFloat]
+
+            var medianHeight: CGFloat {
+                let sorted = heights.sorted()
+                if sorted.isEmpty { return 0 }
+                let mid = sorted.count / 2
+                return sorted.count % 2 == 0
+                    ? (sorted[mid - 1] + sorted[mid]) / 2.0
+                    : sorted[mid]
+            }
+
+            var medianCenterY: CGFloat {
+                let sorted = centerYs.sorted()
+                if sorted.isEmpty { return 0 }
+                let mid = sorted.count / 2
+                return sorted.count % 2 == 0
+                    ? (sorted[mid - 1] + sorted[mid]) / 2.0
+                    : sorted[mid]
+            }
+        }
+
+        /*
+         Sort observations top-to-bottom for clustering.
+         In RAW Vision space, higher on page means BIGGER Y.
+         */
+        let sortedObservations = observations.sorted { $0.boundingBox.midY > $1.boundingBox.midY }
+        var clusters: [LineCluster] = []
+
+        for obs in sortedObservations {
+            let obsBox = obs.boundingBox
+            let obsHeight = obsBox.height
+            let obsCenterY = obsBox.midY
+
+            var bestClusterIndex: Int? = nil
+            var bestOverlapRatio: CGFloat = 0.0
+            var bestCenterDistance: CGFloat = .greatestFiniteMagnitude
+
+            for (index, cluster) in clusters.enumerated() {
+                let clusterBox = cluster.unionBoundingBox
+
+                /* Heuristic: Height Compatibility — use median height, not union bbox height */
+                let minH = min(cluster.medianHeight, obsHeight)
+                let maxH = max(cluster.medianHeight, obsHeight)
+                if (minH / maxH) < OCRConfiguration.heightCompatibilityThreshold { continue }
+
+                /* Heuristic: Overlap & Centerline — use median centerY, not union bbox midY */
+                let intersection = clusterBox.intersection(obsBox)
+                let overlapHeight = max(0, intersection.height)
+                let overlapRatio = overlapHeight / minH
+
+                let centerDistance = abs(cluster.medianCenterY - obsCenterY)
+                let typicalLineHeight = max(cluster.medianHeight, obsHeight)
+
+                let isOverlapGood = overlapRatio >= OCRConfiguration.overlapRatioThreshold
+                let isCenterClose = centerDistance <= (OCRConfiguration.centerlineDistanceFactor * typicalLineHeight)
+
+                if (isOverlapGood || isCenterClose) {
+                    /* Heuristic: Adaptive Cluster Growth Constraint */
+                    let intersectX = max(0, min(clusterBox.maxX, obsBox.maxX) - max(clusterBox.minX, obsBox.minX))
+                    let isStacked = intersectX > 0
+
+                    let growthLimit = isStacked ? OCRConfiguration.stackedGrowthLimit : OCRConfiguration.skewedGrowthLimit
+
+                    let newUnion = clusterBox.union(obsBox)
+                    if newUnion.height <= (CGFloat(growthLimit) * typicalLineHeight) {
+                        /* Score this cluster */
+                        if overlapRatio > bestOverlapRatio {
+                            bestOverlapRatio = overlapRatio
+                            bestCenterDistance = centerDistance
+                            bestClusterIndex = index
+                        } else if abs(overlapRatio - bestOverlapRatio) < 0.01 && centerDistance < bestCenterDistance {
+                            bestCenterDistance = centerDistance
+                            bestClusterIndex = index
+                        }
+                    }
+                }
+            }
+
+            if let idx = bestClusterIndex {
+                clusters[idx].observations.append(obs)
+                clusters[idx].unionBoundingBox = clusters[idx].unionBoundingBox.union(obsBox)
+                clusters[idx].heights.append(obsHeight)
+                clusters[idx].centerYs.append(obsCenterY)
+            } else {
+                clusters.append(LineCluster(
+                    observations: [obs],
+                    unionBoundingBox: obsBox,
+                    heights: [obsHeight],
+                    centerYs: [obsCenterY]
+                ))
+            }
+        }
+
+        /*
+         Sort clusters top-to-bottom for final output.
+         In RAW Vision space, higher on page means BIGGER Y.
+         */
+        clusters.sort { $0.unionBoundingBox.midY > $1.unionBoundingBox.midY }
+
+        /* 2. Column Reconstruction (Adaptive Spacing) + Cluster-Based Blocks */
+        var structuredText = ""
+        var clusterBlocks: [TextBlock] = []
+
+        for cluster in clusters {
+            /* Sort line elements left-to-right */
+            let lineObs = cluster.observations.sorted { $0.boundingBox.origin.x < $1.boundingBox.origin.x }
+            let medianH = cluster.medianHeight
+
+            var lineString = ""
+            var lastXEnd: CGFloat = 0.0
+
+            for (index, obs) in lineObs.enumerated() {
+                guard let candidate = obs.topCandidates(1).first else { continue }
+                let xStart = obs.boundingBox.origin.x
+
+                if index > 0 {
+                    let gap = xStart - lastXEnd
+                    /* Spacing Heuristic */
+                    if gap > (medianH * CGFloat(OCRConfiguration.adaptiveSpacingFactor)) {
+                        let spaceWidth = medianH * CGFloat(OCRConfiguration.spaceWidthFactor)
+                        let spaces = max(1, Int(gap / spaceWidth))
+                        lineString += String(repeating: " ", count: min(spaces, OCRConfiguration.maxSpaces))
+                    } else {
+                        lineString += " "
+                    }
+                }
+
+                lineString += candidate.string
+                lastXEnd = xStart + obs.boundingBox.width
+            }
+
+            structuredText += lineString + "\n"
+
+            /* Build one block per cluster (line-level, aligned with text output) */
+            let unionBox = cluster.unionBoundingBox
+            let androidStyleY = 1.0 - unionBox.origin.y - unionBox.size.height
+            let frame = Frame(
+                x: Double(unionBox.origin.x),
+                y: Double(androidStyleY),
+                width: Double(unionBox.size.width),
+                height: Double(unionBox.size.height)
+            )
+            let confidences = cluster.observations.compactMap { obs -> Double? in
+                obs.topCandidates(1).first.map { Double($0.confidence) }
+            }
+            let avgConfidence = confidences.isEmpty ? nil : confidences.reduce(0.0, +) / Double(confidences.count)
+            clusterBlocks.append(TextBlock(text: lineString, frame: frame, confidence: avgConfidence))
+        }
+
+        return (text: structuredText, blocks: clusterBlocks)
+    }
+}

package/lib/module/NativeDocumentScanner.js

@@ -0,0 +1,51 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+
+/**
+ * Type union of all available filter values.
+ * Required for React Native Codegen compatibility.
+ */
+
+/**
+ * Type union of all available format values.
+ * Required for React Native Codegen compatibility.
+ */
+
+/**
+ * Represents a discrete block of text recognized by the OCR engine.
+ * Useful for mapping text to specific regions on the image.
+ */
+
+/**
+ * Describes the OCR engine and configuration used to produce a ScanResult.
+ * Pass the parent `ScanResult` directly to `reconstructText` — it reads
+ * `metadata` internally to select the right reconstruction strategy.
+ */
+
+/**
+ * The result of a single scanned page.
+ */
+
+/**
+ * Base configuration options shared by scan and process operations.
+ */
+
+/**
+ * Configuration options for the Document Scanner.
+ * Fields are listed explicitly (not via extends) for React Native Codegen compatibility —
+ * Codegen only generates struct fields declared directly on the interface.
+ */
+
+/**
+ * Configuration options for processing existing images.
+ * Fields are listed explicitly (not via extends) for React Native Codegen compatibility —
+ * Codegen only generates struct fields declared directly on the interface.
+ */
+
+/**
+ * TurboModule Specification for the Document Scanner.
+ */
+
+export default TurboModuleRegistry.getEnforcing('DocumentScanner');
+//# sourceMappingURL=NativeDocumentScanner.js.map

package/lib/module/NativeDocumentScanner.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeDocumentScanner.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;;AAEpE;AACA;AACA;AACA;;AASA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;;AAkBA;AACA;AACA;AACA;AACA;;AAsBA;AACA;AACA;;AAcA;AACA;AACA;;AA4BA;AACA;AACA;AACA;AACA;;AA8BA;AACA;AACA;AACA;AACA;;AAkCA;AACA;AACA;;AAiBA,eAAeA,mBAAmB,CAACC,YAAY,CAAO,iBAAiB,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+import DocumentScanner from "./NativeDocumentScanner.js";
+
+/**
+ * Available image filters.
+ * Use these constants instead of raw strings for type safety.
+ */
+export const Filter = {
+  /** No filter (original colors) */
+  COLOR: 'color',
+  /** Desaturated image */
+  GRAYSCALE: 'grayscale',
+  /** High-contrast black & white */
+  MONOCHROME: 'monochrome',
+  /** Noise reduction (for noisy photos) */
+  DENOISE: 'denoise',
+  /** Edge enhancement (for blurry text) */
+  SHARPEN: 'sharpen',
+  /** Full OCR pipeline: denoise → sharpen → monochrome */
+  OCR_OPTIMIZED: 'ocrOptimized'
+};
+
+/**
+ * Available output formats.
+ */
+export const Format = {
+  /** JPEG format (smaller file size) */
+  JPG: 'jpg',
+  /** PNG format (lossless) */
+  PNG: 'png'
+};
+export function scanDocuments(options) {
+  return DocumentScanner.scanDocuments(options);
+}
+export function processDocuments(options) {
+  return DocumentScanner.processDocuments(options);
+}
+export { reconstructText } from "./textReconstructor.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DocumentScanner","Filter","COLOR","GRAYSCALE","MONOCHROME","DENOISE","SHARPEN","OCR_OPTIMIZED","Format","JPG","PNG","scanDocuments","options","processDocuments","reconstructText"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,OAAOA,eAAe,MAQf,4BAAyB;;AAEhC;AACA;AACA;AACA;AACA,OAAO,MAAMC,MAAM,GAAG;EACpB;EACAC,KAAK,EAAE,OAAO;EACd;EACAC,SAAS,EAAE,WAAW;EACtB;EACAC,UAAU,EAAE,YAAY;EACxB;EACAC,OAAO,EAAE,SAAS;EAClB;EACAC,OAAO,EAAE,SAAS;EAClB;EACAC,aAAa,EAAE;AACjB,CAAU;;AAEV;AACA;AACA;AACA,OAAO,MAAMC,MAAM,GAAG;EACpB;EACAC,GAAG,EAAE,KAAK;EACV;EACAC,GAAG,EAAE;AACP,CAAU;AAEV,OAAO,SAASC,aAAaA,CAACC,OAAqB,EAAyB;EAC1E,OAAOZ,eAAe,CAACW,aAAa,CAACC,OAAO,CAAC;AAC/C;AAEA,OAAO,SAASC,gBAAgBA,CAC9BD,OAAuB,EACA;EACvB,OAAOZ,eAAe,CAACa,gBAAgB,CAACD,OAAO,CAAC;AAClD;AAEA,SAASE,eAAe,QAAQ,wBAAqB","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}