@qr-platform/qr-code.js 0.8.17

package/lib/lib/zxing-js/src/core/ArgumentException.d.ts

@@ -0,0 +1,7 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class ArgumentException extends Exception {
+    static readonly kind: string;
+}

package/lib/lib/zxing-js/src/core/ArithmeticException.d.ts

@@ -0,0 +1,7 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class ArithmeticException extends Exception {
+    static readonly kind: string;
+}

package/lib/lib/zxing-js/src/core/ArrayIndexOutOfBoundsException.d.ts

@@ -0,0 +1,10 @@
+import IndexOutOfBoundsException from './IndexOutOfBoundsException';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException {
+    index: number;
+    message: string;
+    static readonly kind: string;
+    constructor(index: number, message: string);
+}

package/lib/lib/zxing-js/src/core/BarcodeFormat.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Enumerates barcode formats known to this package. Please keep alphabetized.
+ *
+ * @author Sean Owen
+ */
+declare enum BarcodeFormat {
+    /** Aztec 2D barcode format. */
+    AZTEC = 0,
+    /** CODABAR 1D format. */
+    CODABAR = 1,
+    /** Code 39 1D format. */
+    CODE_39 = 2,
+    /** Code 93 1D format. */
+    CODE_93 = 3,
+    /** Code 128 1D format. */
+    CODE_128 = 4,
+    /** Data Matrix 2D barcode format. */
+    DATA_MATRIX = 5,
+    /** EAN-8 1D format. */
+    EAN_8 = 6,
+    /** EAN-13 1D format. */
+    EAN_13 = 7,
+    /** ITF (Interleaved Two of Five) 1D format. */
+    ITF = 8,
+    /** MaxiCode 2D barcode format. */
+    MAXICODE = 9,
+    /** PDF417 format. */
+    PDF_417 = 10,
+    /** QR Code 2D barcode format. */
+    QR_CODE = 11,
+    /** RSS 14 */
+    RSS_14 = 12,
+    /** RSS EXPANDED */
+    RSS_EXPANDED = 13,
+    /** UPC-A 1D format. */
+    UPC_A = 14,
+    /** UPC-E 1D format. */
+    UPC_E = 15,
+    /** UPC/EAN extension format. Not a stand-alone format. */
+    UPC_EAN_EXTENSION = 16
+}
+export default BarcodeFormat;

package/lib/lib/zxing-js/src/core/Binarizer.d.ts

@@ -0,0 +1,53 @@
+import BitArray from './common/BitArray';
+import BitMatrix from './common/BitMatrix';
+import LuminanceSource from './LuminanceSource';
+/**
+ * This class hierarchy provides a set of methods to convert luminance data to 1 bit data.
+ * It allows the algorithm to vary polymorphically, for example allowing a very expensive
+ * thresholding technique for servers and a fast one for mobile. It also permits the implementation
+ * to vary, e.g. a JNI version for Android and a Java fallback version for other platforms.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+declare abstract class Binarizer {
+    private source;
+    protected constructor(source: LuminanceSource);
+    getLuminanceSource(): LuminanceSource;
+    /**
+     * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+     * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+     * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+     * For callers which only examine one row of pixels at a time, the same BitArray should be reused
+     * and passed in with each call for performance. However it is legal to keep more than one row
+     * at a time if needed.
+     *
+     * @param y The row to fetch, which must be in [0, bitmap height)
+     * @param row An optional preallocated array. If null or too small, it will be ignored.
+     *            If used, the Binarizer will call BitArray.clear(). Always use the returned object.
+     * @return The array of bits for this row (true means black).
+     * @throws NotFoundException if row can't be binarized
+     */
+    abstract getBlackRow(y: number, row: BitArray): BitArray;
+    /**
+     * Converts a 2D array of luminance data to 1 bit data. As above, assume this method is expensive
+     * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+     * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+     * fetched using getBlackRow(), so don't mix and match between them.
+     *
+     * @return The 2D array of bits for the image (true means black).
+     * @throws NotFoundException if image can't be binarized to make a matrix
+     */
+    abstract getBlackMatrix(): BitMatrix;
+    /**
+     * Creates a new object with the same type as this Binarizer implementation, but with pristine
+     * state. This is needed because Binarizer implementations may be stateful, e.g. keeping a cache
+     * of 1 bit data. See Effective Java for why we can't use Java's clone() method.
+     *
+     * @param source The LuminanceSource this Binarizer will operate on.
+     * @return A new concrete Binarizer implementation object.
+     */
+    abstract createBinarizer(source: LuminanceSource): Binarizer;
+    getWidth(): number;
+    getHeight(): number;
+}
+export default Binarizer;

package/lib/lib/zxing-js/src/core/BinaryBitmap.d.ts

@@ -0,0 +1,78 @@
+/**
+ * This class is the core bitmap class used by ZXing to represent 1 bit data. Reader objects
+ * accept a BinaryBitmap and attempt to decode it.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+import Binarizer from './Binarizer';
+import BitArray from './common/BitArray';
+import BitMatrix from './common/BitMatrix';
+export default class BinaryBitmap {
+    private binarizer;
+    private matrix;
+    constructor(binarizer: Binarizer);
+    /**
+     * @return The width of the bitmap.
+     */
+    getWidth(): number;
+    /**
+     * @return The height of the bitmap.
+     */
+    getHeight(): number;
+    /**
+     * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+     * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+     * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+     *
+     * @param y The row to fetch, which must be in [0, bitmap height)
+     * @param row An optional preallocated array. If null or too small, it will be ignored.
+     *            If used, the Binarizer will call BitArray.clear(). Always use the returned object.
+     * @return The array of bits for this row (true means black).
+     * @throws NotFoundException if row can't be binarized
+     */
+    getBlackRow(y: number, row: BitArray): BitArray;
+    /**
+     * Converts a 2D array of luminance data to 1 bit. As above, assume this method is expensive
+     * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+     * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+     * fetched using getBlackRow(), so don't mix and match between them.
+     *
+     * @return The 2D array of bits for the image (true means black).
+     * @throws NotFoundException if image can't be binarized to make a matrix
+     */
+    getBlackMatrix(): BitMatrix;
+    /**
+     * @return Whether this bitmap can be cropped.
+     */
+    isCropSupported(): boolean;
+    /**
+     * Returns a new object with cropped image data. Implementations may keep a reference to the
+     * original data rather than a copy. Only callable if isCropSupported() is true.
+     *
+     * @param left The left coordinate, which must be in [0,getWidth())
+     * @param top The top coordinate, which must be in [0,getHeight())
+     * @param width The width of the rectangle to crop.
+     * @param height The height of the rectangle to crop.
+     * @return A cropped version of this object.
+     */
+    crop(left: number, top: number, width: number, height: number): BinaryBitmap;
+    /**
+     * @return Whether this bitmap supports counter-clockwise rotation.
+     */
+    isRotateSupported(): boolean;
+    /**
+     * Returns a new object with rotated image data by 90 degrees counterclockwise.
+     * Only callable if {@link #isRotateSupported()} is true.
+     *
+     * @return A rotated version of this object.
+     */
+    rotateCounterClockwise(): BinaryBitmap;
+    /**
+     * Returns a new object with rotated image data by 45 degrees counterclockwise.
+     * Only callable if {@link #isRotateSupported()} is true.
+     *
+     * @return A rotated version of this object.
+     */
+    rotateCounterClockwise45(): BinaryBitmap;
+    toString(): string;
+}

package/lib/lib/zxing-js/src/core/ChecksumException.d.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class ChecksumException extends Exception {
+    static readonly kind: string;
+    static getChecksumInstance(): ChecksumException;
+}

package/lib/lib/zxing-js/src/core/DecodeHintType.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Encapsulates a type of hint that a caller may pass to a barcode reader to help it
+ * more quickly or accurately decode it. It is up to implementations to decide what,
+ * if anything, to do with the information that is supplied.
+ *
+ * @author Sean Owen
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @see Reader#decode(BinaryBitmap,java.util.Map)
+ */
+declare enum DecodeHintType {
+    /**
+     * Unspecified, application-specific hint. Maps to an unspecified {@link Object}.
+     */
+    OTHER = 0,
+    /**
+     * Image is a pure monochrome image of a barcode. Doesn't matter what it maps to;
+     * use {@link Boolean#TRUE}.
+     */
+    PURE_BARCODE = 1,
+    /**
+     * Image is known to be of one of a few possible formats.
+     * Maps to a {@link List} of {@link BarcodeFormat}s.
+     */
+    POSSIBLE_FORMATS = 2,
+    /**
+     * Spend more time to try to find a barcode; optimize for accuracy, not speed.
+     * Doesn't matter what it maps to; use {@link Boolean#TRUE}.
+     */
+    TRY_HARDER = 3,
+    /**
+     * Specifies what character encoding to use when decoding, where applicable (type String)
+     */
+    CHARACTER_SET = 4,
+    /**
+     * Allowed lengths of encoded data -- reject anything else. Maps to an {@code Int32Array}.
+     */
+    ALLOWED_LENGTHS = 5,
+    /**
+     * Assume Code 39 codes employ a check digit. Doesn't matter what it maps to;
+     * use {@link Boolean#TRUE}.
+     */
+    ASSUME_CODE_39_CHECK_DIGIT = 6,
+    /**
+     * Enable extended mode for Code 39 codes. Doesn't matter what it maps to;
+     * use {@link Boolean#TRUE}.
+     */
+    ENABLE_CODE_39_EXTENDED_MODE = 7,
+    /**
+     * Assume the barcode is being processed as a GS1 barcode, and modify behavior as needed.
+     * For example this affects FNC1 handling for Code 128 (aka GS1-128). Doesn't matter what it maps to;
+     * use {@link Boolean#TRUE}.
+     */
+    ASSUME_GS1 = 8,
+    /**
+     * If true, return the start and end digits in a Codabar barcode instead of stripping them. They
+     * are alpha, whereas the rest are numeric. By default, they are stripped, but this causes them
+     * to not be. Doesn't matter what it maps to; use {@link Boolean#TRUE}.
+     */
+    RETURN_CODABAR_START_END = 9,
+    /**
+     * The caller needs to be notified via callback when a possible {@link ResultPoint}
+     * is found. Maps to a {@link ResultPointCallback}.
+     */
+    NEED_RESULT_POINT_CALLBACK = 10,
+    /**
+     * Allowed extension lengths for EAN or UPC barcodes. Other formats will ignore this.
+     * Maps to an {@code Int32Array} of the allowed extension lengths, for example [2], [5], or [2, 5].
+     * If it is optional to have an extension, do not set this hint. If this is set,
+     * and a UPC or EAN barcode is found but an extension is not, then no result will be returned
+     * at all.
+     */
+    ALLOWED_EAN_EXTENSIONS 
+    /**
+     * Data type the hint is expecting.
+     * Among the possible values the {@link Void} stands out as being used for
+     * hints that do not expect a value to be supplied (flag hints). Such hints
+     * will possibly have their value ignored, or replaced by a
+     * {@link Boolean#TRUE}. Hint suppliers should probably use
+     * {@link Boolean#TRUE} as directed by the actual hint documentation.
+     */
+    = 11
+    /**
+     * Data type the hint is expecting.
+     * Among the possible values the {@link Void} stands out as being used for
+     * hints that do not expect a value to be supplied (flag hints). Such hints
+     * will possibly have their value ignored, or replaced by a
+     * {@link Boolean#TRUE}. Hint suppliers should probably use
+     * {@link Boolean#TRUE} as directed by the actual hint documentation.
+     */
+}
+export default DecodeHintType;

package/lib/lib/zxing-js/src/core/Dimension.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Simply encapsulates a width and height.
+ */
+export default class Dimension {
+    private width;
+    private height;
+    constructor(width: number, height: number);
+    getWidth(): number;
+    getHeight(): number;
+    equals(other: any): boolean;
+    hashCode(): number;
+    toString(): string;
+}

package/lib/lib/zxing-js/src/core/EncodeHintType.d.ts

@@ -0,0 +1,99 @@
+/**
+ * These are a set of hints that you may pass to Writers to specify their behavior.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+declare enum EncodeHintType {
+    /**
+     * Specifies what degree of error correction to use, for example in QR Codes.
+     * Type depends on the encoder. For example for QR codes it's type
+     * {@link com.google.zxing.qrcode.decoder.ErrorCorrectionLevel ErrorCorrectionLevel}.
+     * For Aztec it is of type {@link Integer}, representing the minimal percentage of error correction words.
+     * For PDF417 it is of type {@link Integer}, valid values being 0 to 8.
+     * In all cases, it can also be a {@link String} representation of the desired value as well.
+     * Note: an Aztec symbol should have a minimum of 25% EC words.
+     */
+    ERROR_CORRECTION = 0,
+    /**
+     * Specifies what character encoding to use where applicable (type {@link String})
+     */
+    CHARACTER_SET = 1,
+    /**
+     * Specifies the matrix shape for Data Matrix (type {@link com.google.zxing.datamatrix.encoder.SymbolShapeHint})
+     */
+    DATA_MATRIX_SHAPE = 2,
+    /**
+     * Specifies whether to use compact mode for Data Matrix (type {@link Boolean}, or "true" or "false"
+     * {@link String } value).
+     * The compact encoding mode also supports the encoding of characters that are not in the ISO-8859-1
+     * character set via ECIs.
+     * Please note that in that case, the most compact character encoding is chosen for characters in
+     * the input that are not in the ISO-8859-1 character set. Based on experience, some scanners do not
+     * support encodings like cp-1256 (Arabic). In such cases the encoding can be forced to UTF-8 by
+     * means of the {@link #CHARACTER_SET} encoding hint.
+     * Compact encoding also provides GS1-FNC1 support when {@link #GS1_FORMAT} is selected. In this case
+     * group-separator character (ASCII 29 decimal) can be used to encode the positions of FNC1 codewords
+     * for the purpose of delimiting AIs.
+     * This option and {@link #FORCE_C40} are mutually exclusive.
+     */
+    DATA_MATRIX_COMPACT = 3,
+    /**
+     * Specifies a minimum barcode size (type {@link Dimension}). Only applicable to Data Matrix now.
+     *
+     * @deprecated use width/height params in
+     * {@link com.google.zxing.datamatrix.DataMatrixWriter#encode(String, BarcodeFormat, int, int)}
+     */
+    MIN_SIZE = 4,
+    /**
+     * Specifies a maximum barcode size (type {@link Dimension}). Only applicable to Data Matrix now.
+     *
+     * @deprecated without replacement
+     */
+    MAX_SIZE = 5,
+    /**
+     * Specifies margin, in pixels, to use when generating the barcode. The meaning can vary
+     * by format; for example it controls margin before and after the barcode horizontally for
+     * most 1D formats. (Type {@link Integer}, or {@link String} representation of the integer value).
+     */
+    MARGIN = 6,
+    /**
+     * Specifies whether to use compact mode for PDF417 (type {@link Boolean}, or "true" or "false"
+     * {@link String} value).
+     */
+    PDF417_COMPACT = 7,
+    /**
+     * Specifies what compaction mode to use for PDF417 (type
+     * {@link com.google.zxing.pdf417.encoder.Compaction Compaction} or {@link String} value of one of its
+     * enum values).
+     */
+    PDF417_COMPACTION = 8,
+    /**
+     * Specifies the minimum and maximum number of rows and columns for PDF417 (type
+     * {@link com.google.zxing.pdf417.encoder.Dimensions Dimensions}).
+     */
+    PDF417_DIMENSIONS = 9,
+    /**
+     * Specifies the required number of layers for an Aztec code.
+     * A negative number (-1, -2, -3, -4) specifies a compact Aztec code.
+     * 0 indicates to use the minimum number of layers (the default).
+     * A positive number (1, 2, .. 32) specifies a normal (non-compact) Aztec code.
+     * (Type {@link Integer}, or {@link String} representation of the integer value).
+     */
+    AZTEC_LAYERS = 10,
+    /**
+     * Specifies the exact version of QR code to be encoded.
+     * (Type {@link Integer}, or {@link String} representation of the integer value).
+     */
+    QR_VERSION = 11,
+    /**
+     * Specifies whether the data should be encoded to the GS1 standard (type {@link Boolean}, or "true" or "false"
+     * {@link String } value).
+     */
+    GS1_FORMAT = 12,
+    /**
+     * Forces C40 encoding for data-matrix (type {@link Boolean}, or "true" or "false") {@link String } value). This
+     * option and {@link #DATA_MATRIX_COMPACT} are mutually exclusive.
+     */
+    FORCE_C40 = 13
+}
+export default EncodeHintType;

package/lib/lib/zxing-js/src/core/Exception.d.ts

@@ -0,0 +1,17 @@
+import { CustomError } from 'ts-custom-error';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class Exception extends CustomError {
+    message: string | undefined;
+    /**
+     * It's typed as string so it can be extended and overriden.
+     */
+    static readonly kind: string;
+    /**
+     * Allows Exception to be constructed directly
+     * with some message and prototype definition.
+     */
+    constructor(message?: string | undefined);
+    getKind(): string;
+}

package/lib/lib/zxing-js/src/core/FormatException.d.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class FormatException extends Exception {
+    static readonly kind: string;
+    static getFormatInstance(): FormatException;
+}

package/lib/lib/zxing-js/src/core/HighContrastLuminanceSource.d.ts

@@ -0,0 +1,27 @@
+import LuminanceSource from './LuminanceSource';
+/**
+ * A wrapper implementation of LuminanceSource which converts the source image
+ * into a high contrast (binary) image using a fixed threshold. Pixels with a value
+ * below the threshold become black (0) and those equal to or above become white (255).
+ */
+export default class HighContrastLuminanceSource extends LuminanceSource {
+    private delegate;
+    private threshold;
+    constructor(delegate: LuminanceSource, threshold?: number);
+    getRow(y: number, row?: Uint8ClampedArray): Uint8ClampedArray;
+    getMatrix(): Uint8ClampedArray;
+    isCropSupported(): boolean;
+    crop(left: number, top: number, width: number, height: number): LuminanceSource;
+    isRotateSupported(): boolean;
+    rotateCounterClockwise(): LuminanceSource;
+    rotateCounterClockwise45(): LuminanceSource;
+    /**
+     * Inverts the high contrast image. This wraps the current instance with InvertedLuminanceSource,
+     * which effectively swaps black and white.
+     */
+    invert(): LuminanceSource;
+    /**
+     * Since this source is already high contrast, calling highContrast() returns itself.
+     */
+    highContrast(): LuminanceSource;
+}

package/lib/lib/zxing-js/src/core/IllegalArgumentException.d.ts

@@ -0,0 +1,7 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class IllegalArgumentException extends Exception {
+    static readonly kind: string;
+}

package/lib/lib/zxing-js/src/core/IllegalStateException.d.ts

@@ -0,0 +1,7 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class IllegalStateException extends Exception {
+    static readonly kind: string;
+}

package/lib/lib/zxing-js/src/core/IndexOutOfBoundsException.d.ts

@@ -0,0 +1,7 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class IndexOutOfBoundsException extends Exception {
+    static readonly kind: string;
+}

package/lib/lib/zxing-js/src/core/InvertedLuminanceSource.d.ts

@@ -0,0 +1,22 @@
+import LuminanceSource from './LuminanceSource';
+/**
+ * A wrapper implementation of {@link LuminanceSource} which inverts the luminances it returns -- black becomes
+ * white and vice versa, and each value becomes (255-value).
+ *
+ * @author Sean Owen
+ */
+export default class InvertedLuminanceSource extends LuminanceSource {
+    private delegate;
+    constructor(delegate: LuminanceSource);
+    getRow(y: number, row?: Uint8ClampedArray): Uint8ClampedArray;
+    getMatrix(): Uint8ClampedArray;
+    isCropSupported(): boolean;
+    crop(left: number, top: number, width: number, height: number): LuminanceSource;
+    isRotateSupported(): boolean;
+    /**
+     * @return original delegate {@link LuminanceSource} since invert undoes itself
+     */
+    invert(): LuminanceSource;
+    rotateCounterClockwise(): LuminanceSource;
+    rotateCounterClockwise45(): LuminanceSource;
+}

package/lib/lib/zxing-js/src/core/LuminanceSource.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The purpose of this class hierarchy is to abstract different bitmap implementations across
+ * platforms into a standard interface for requesting greyscale luminance values. The interface
+ * only provides immutable methods; therefore crop and rotation create copies. This is to ensure
+ * that one Reader does not modify the original luminance source and leave it in an unknown state
+ * for other Readers in the chain.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+declare abstract class LuminanceSource {
+    private width;
+    private height;
+    protected constructor(width: number, height: number);
+    /**
+     * Fetches one row of luminance data from the underlying platform's bitmap. Values range from
+     * 0 (black) to 255 (white). Because Java does not have an unsigned byte type, callers will have
+     * to bitwise and with 0xff for each value. It is preferable for implementations of this method
+     * to only fetch this row rather than the whole image, since no 2D Readers may be installed and
+     * getMatrix() may never be called.
+     *
+     * @param y The row to fetch, which must be in [0,getHeight())
+     * @param row An optional preallocated array. If null or too small, it will be ignored.
+     *            Always use the returned object, and ignore the .length of the array.
+     * @return An array containing the luminance data.
+     */
+    abstract getRow(y: number, row?: Uint8ClampedArray): Uint8ClampedArray;
+    /**
+     * Fetches luminance data for the underlying bitmap. Values should be fetched using:
+     * {@code int luminance = array[y * width + x] & 0xff}
+     *
+     * @return A row-major 2D array of luminance values. Do not use result.length as it may be
+     *         larger than width * height bytes on some platforms. Do not modify the contents
+     *         of the result.
+     */
+    abstract getMatrix(): Uint8ClampedArray;
+    /**
+     * @return The width of the bitmap.
+     */
+    getWidth(): number;
+    /**
+     * @return The height of the bitmap.
+     */
+    getHeight(): number;
+    /**
+     * @return Whether this subclass supports cropping.
+     */
+    isCropSupported(): boolean;
+    /**
+     * Returns a new object with cropped image data. Implementations may keep a reference to the
+     * original data rather than a copy. Only callable if isCropSupported() is true.
+     *
+     * @param left The left coordinate, which must be in [0,getWidth())
+     * @param top The top coordinate, which must be in [0,getHeight())
+     * @param width The width of the rectangle to crop.
+     * @param height The height of the rectangle to crop.
+     * @return A cropped version of this object.
+     */
+    crop(left: number, top: number, width: number, height: number): LuminanceSource;
+    /**
+     * @return Whether this subclass supports counter-clockwise rotation.
+     */
+    isRotateSupported(): boolean;
+    /**
+     * @return a wrapper of this {@code LuminanceSource} which inverts the luminances it returns -- black becomes
+     *  white and vice versa, and each value becomes (255-value).
+     */
+    abstract invert(): LuminanceSource;
+    /**
+     * Returns a new object with rotated image data by 90 degrees counterclockwise.
+     * Only callable if {@link #isRotateSupported()} is true.
+     *
+     * @return A rotated version of this object.
+     */
+    rotateCounterClockwise(): LuminanceSource;
+    /**
+     * Returns a new object with rotated image data by 45 degrees counterclockwise.
+     * Only callable if {@link #isRotateSupported()} is true.
+     *
+     * @return A rotated version of this object.
+     */
+    rotateCounterClockwise45(): LuminanceSource;
+    toString(): string;
+}
+export default LuminanceSource;

package/lib/lib/zxing-js/src/core/NodeLuminanceSource.d.ts

@@ -0,0 +1,36 @@
+import LuminanceSource from './LuminanceSource';
+/**
+ * NodeLuminanceSource replicates the behavior of HTMLCanvasElementLuminanceSource
+ * but uses Sharp to obtain image data from a Buffer.
+ */
+export declare class NodeLuminanceSource extends LuminanceSource {
+    private buffer;
+    private _width;
+    private _height;
+    private constructor();
+    /**
+     * Asynchronously creates a NodeLuminanceSource from an image buffer.
+     * @param imageBuffer - The image data (e.g. from fs.readFile) as a Buffer.
+     * @param doAutoInvert - If true, computes an inverted grayscale buffer.
+     */
+    static create(imageBuffer: Buffer, doAutoInvert?: boolean): Promise<NodeLuminanceSource>;
+    /**
+     * Converts raw RGBA data to a grayscale buffer.
+     * If doAutoInvert is true, each computed luminance is inverted.
+     */
+    private static toGrayscaleBuffer;
+    getRow(y: number, row?: Uint8ClampedArray): Uint8ClampedArray;
+    getMatrix(): Uint8ClampedArray;
+    isCropSupported(): boolean;
+    crop(left: number, top: number, width: number, height: number): LuminanceSource;
+    isRotateSupported(): boolean;
+    rotateCounterClockwise(): LuminanceSource;
+    rotateCounterClockwise45(): LuminanceSource;
+    /**
+     * Rotates the image by the specified angle (in degrees) using Sharp.
+     * This method creates a temporary RGBA image from the grayscale data,
+     * rotates it, then re-converts to grayscale.
+     */
+    private rotate;
+    invert(): LuminanceSource;
+}

package/lib/lib/zxing-js/src/core/NotFoundException.d.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class NotFoundException extends Exception {
+    static readonly kind: string;
+    static getNotFoundInstance(): NotFoundException;
+}

package/lib/lib/zxing-js/src/core/NullPointerException.d.ts

@@ -0,0 +1,7 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class NullPointerException extends Exception {
+    static readonly kind: string;
+}