@qr-platform/qr-code.js 0.8.24 → 0.9.1

package/lib/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/lib/zxing-js/src/core/NodeLuminanceSource.d.ts

@@ -0,0 +1,33 @@
+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 constructor();
+    /**
+     * Asynchronously creates a NodeLuminanceSource from an image buffer.
+     * Can handle standard image formats (PNG/JPEG via Jimp) or raw RGBA buffers.
+     * @param bufferInput - The image data as a Buffer (PNG, JPEG, or raw RGBA).
+     * @param isPngOrJpeg - Flag indicating if the buffer is a standard format (true) or raw RGBA (false).
+     * @param width - Required width if bufferInput is raw RGBA.
+     * @param height - Required height if bufferInput is raw RGBA.
+     * @param doAutoInvert - If true, computes an inverted grayscale buffer (only relevant for grayscale conversion).
+     */
+    static create(bufferInput: Buffer, isPngOrJpeg: boolean, // Renamed from isPng for clarity
+    width?: number, // Optional width
+    height?: number, // Optional height
+    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;
+    invert(): LuminanceSource;
+}

package/lib/node/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/node/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;
+}

package/lib/node/lib/zxing-js/src/core/OutOfMemoryError.d.ts

@@ -0,0 +1,6 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class OutOfMemoryError extends Exception {
+}

package/lib/node/lib/zxing-js/src/core/Reader.d.ts

@@ -0,0 +1,49 @@
+import BinaryBitmap from './BinaryBitmap';
+import DecodeHintType from './DecodeHintType';
+import Result from './Result';
+export default Reader;
+/**
+ * Implementations of this interface can decode an image of a barcode in some format into
+ * the it: string encodes. For example, {@link com.google.zxing.qrcode.QRCodeReader} can
+ * decode a QR code. The decoder may optionally receive hints from the caller which may help
+ * it decode more quickly or accurately.
+ *
+ * See {@link MultiFormatReader}, which attempts to determine what barcode
+ * format is present within the image as well, and then decodes it accordingly.
+ *
+ * @author Sean Owen
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+interface Reader {
+    /**
+     * Locates and decodes a barcode in some format within an image.
+     *
+     * @param image image of barcode to decode
+     * @return which: string the barcode encodes
+     * @throws NotFoundException if no potential barcode is found
+     * @throws ChecksumException if a potential barcode is found but does not pass its checksum
+     * @throws FormatException if a potential barcode is found but format is invalid
+     */
+    /**
+     * Locates and decodes a barcode in some format within an image. This method also accepts
+     * hints, each possibly associated to some data, which may help the implementation decode.
+     *
+     * @param image image of barcode to decode
+     * @param hints passed as a {@link Map} from {@link DecodeHintType}
+     * to arbitrary data. The
+     * meaning of the data depends upon the hint type. The implementation may or may not do
+     * anything with these hints.
+     *
+     * @return which: string the barcode encodes
+     *
+     * @throws NotFoundException if no potential barcode is found
+     * @throws ChecksumException if a potential barcode is found but does not pass its checksum
+     * @throws FormatException if a potential barcode is found but format is invalid
+     */
+    decode(image: BinaryBitmap, hints?: Map<DecodeHintType, any> | null): Result;
+    /**
+     * Resets any internal state the implementation has after a decode, to prepare it
+     * for reuse.
+     */
+    reset(): void;
+}

package/lib/node/lib/zxing-js/src/core/ReaderException.d.ts

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

package/lib/node/lib/zxing-js/src/core/ReedSolomonException.d.ts

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

package/lib/node/lib/zxing-js/src/core/Result.d.ts

@@ -0,0 +1,52 @@
+import BarcodeFormat from './BarcodeFormat';
+import ResultMetadataType from './ResultMetadataType';
+import ResultPoint from './ResultPoint';
+/**
+ * <p>Encapsulates the result of decoding a barcode within an image.</p>
+ *
+ * @author Sean Owen
+ */
+export default class Result {
+    text: string | null;
+    rawBytes: Uint8Array;
+    private numBits;
+    private resultPoints;
+    format: BarcodeFormat;
+    private timestamp;
+    private resultMetadata;
+    constructor(text: string | null | undefined, rawBytes: Uint8Array, numBits: number | undefined, resultPoints: ResultPoint[], format: BarcodeFormat, timestamp?: number);
+    /**
+     * @return raw text encoded by the barcode
+     */
+    getText(): string | null;
+    /**
+     * @return raw bytes encoded by the barcode, if applicable, otherwise {@code null}
+     */
+    getRawBytes(): Uint8Array;
+    /**
+     * @return how many bits of {@link #getRawBytes()} are valid; typically 8 times its length
+     * @since 3.3.0
+     */
+    getNumBits(): number;
+    /**
+     * @return points related to the barcode in the image. These are typically points
+     *         identifying finder patterns or the corners of the barcode. The exact meaning is
+     *         specific to the type of barcode that was decoded.
+     */
+    getResultPoints(): ResultPoint[];
+    /**
+     * @return The format of the barcode that was decoded
+     */
+    getBarcodeFormat(): BarcodeFormat;
+    /**
+     * @return Mapping keys to values. May be
+     *   This contains optional metadata about what was detected about the barcode,
+     *   like orientation.
+     */
+    getResultMetadata(): Map<ResultMetadataType, object>;
+    putMetadata(type: ResultMetadataType, value: object): void;
+    putAllMetadata(metadata: Map<ResultMetadataType, object>): void;
+    addResultPoints(newPoints: ResultPoint[]): void;
+    getTimestamp(): number;
+    toString(): string | null;
+}

package/lib/node/lib/zxing-js/src/core/ResultMetadataType.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Represents some type of metadata about the result of the decoding that the decoder
+ * wishes to communicate back to the caller.
+ *
+ * @author Sean Owen
+ */
+declare enum ResultMetadataType {
+    /**
+     * Unspecified, application-specific metadata. Maps to an unspecified {@link Object}.
+     */
+    OTHER = 0,
+    /**
+     * Denotes the likely approximate orientation of the barcode in the image. This value
+     * is given as degrees rotated clockwise from the normal, upright orientation.
+     * For example a 1D barcode which was found by reading top-to-bottom would be
+     * said to have orientation "90". This key maps to an {@link Integer} whose
+     * value is in the range [0,360).
+     */
+    ORIENTATION = 1,
+    /**
+     * <p>2D barcode formats typically encode text, but allow for a sort of 'byte mode'
+     * which is sometimes used to encode binary data. While {@link Result} makes available
+     * the complete raw bytes in the barcode for these formats, it does not offer the bytes
+     * from the byte segments alone.</p>
+     *
+     * <p>This maps to a {@link java.util.List} of byte arrays corresponding to the
+     * raw bytes in the byte segments in the barcode, in order.</p>
+     */
+    BYTE_SEGMENTS = 2,
+    /**
+     * Error correction level used, if applicable. The value type depends on the
+     * format, but is typically a String.
+     */
+    ERROR_CORRECTION_LEVEL = 3,
+    /**
+     * For some periodicals, indicates the issue number as an {@link Integer}.
+     */
+    ISSUE_NUMBER = 4,
+    /**
+     * For some products, indicates the suggested retail price in the barcode as a
+     * formatted {@link String}.
+     */
+    SUGGESTED_PRICE = 5,
+    /**
+     * For some products, the possible country of manufacture as a {@link String} denoting the
+     * ISO country code. Some map to multiple possible countries, like "US/CA".
+     */
+    POSSIBLE_COUNTRY = 6,
+    /**
+     * For some products, the extension text
+     */
+    UPC_EAN_EXTENSION = 7,
+    /**
+     * PDF417-specific metadata
+     */
+    PDF417_EXTRA_METADATA = 8,
+    /**
+     * If the code format supports structured append and the current scanned code is part of one then the
+     * sequence number is given with it.
+     */
+    STRUCTURED_APPEND_SEQUENCE = 9,
+    /**
+     * If the code format supports structured append and the current scanned code is part of one then the
+     * parity is given with it.
+     */
+    STRUCTURED_APPEND_PARITY = 10
+}
+export default ResultMetadataType;

package/lib/node/lib/zxing-js/src/core/ResultPoint.d.ts

@@ -0,0 +1,34 @@
+import { float, int } from '../customTypings';
+/**
+ * <p>Encapsulates a point of interest in an image containing a barcode. Typically, this
+ * would be the location of a finder pattern or the corner of the barcode, for example.</p>
+ *
+ * @author Sean Owen
+ */
+export default class ResultPoint {
+    private x;
+    private y;
+    constructor(x: float, y: float);
+    getX(): float;
+    getY(): float;
+    equals(other: object): boolean;
+    hashCode(): int;
+    toString(): string;
+    /**
+     * Orders an array of three ResultPoints in an order [A,B,C] such that AB is less than AC
+     * and BC is less than AC, and the angle between BC and BA is less than 180 degrees.
+     *
+     * @param patterns array of three {@code ResultPoint} to order
+     */
+    static orderBestPatterns(patterns: ResultPoint[]): void;
+    /**
+     * @param pattern1 first pattern
+     * @param pattern2 second pattern
+     * @return distance between two points
+     */
+    static distance(pattern1: ResultPoint, pattern2: ResultPoint): float;
+    /**
+     * Returns the z component of the cross product between vectors BC and BA.
+     */
+    private static crossProductZ;
+}

package/lib/node/lib/zxing-js/src/core/ResultPointCallback.d.ts

@@ -0,0 +1,11 @@
+import ResultPoint from './ResultPoint';
+export default ResultPointCallback;
+/**
+ * Callback which is invoked when a possible result point (significant
+ * point in the barcode image such as a corner) is found.
+ *
+ * @see DecodeHintType#NEED_RESULT_POINT_CALLBACK
+ */
+interface ResultPointCallback {
+    foundPossibleResultPoint(point: ResultPoint): void;
+}

package/lib/node/lib/zxing-js/src/core/UniversalLuminanceSource.d.ts

@@ -0,0 +1,46 @@
+import LuminanceSource from './LuminanceSource';
+/**
+ * NodeLuminanceSource replicates the behavior of a LuminanceSource
+ * but does NOT use sharp. Instead, you provide raw RGBA data and
+ * we convert it to grayscale internally.
+ */
+export declare class UniversalLuminanceSource extends LuminanceSource {
+    private buffer;
+    private _width;
+    private _height;
+    /**
+     * Private constructor; use the static createFromRawRGBA() method below.
+     */
+    constructor(width: number, height: number, buffer: Uint8ClampedArray);
+    /**
+     * Create a NodeLuminanceSource from raw RGBA data.
+     * @param rgbaData - A Uint8ClampedArray of RGBA bytes (length = width * height * 4).
+     * @param width - Image width in pixels.
+     * @param height - Image height in pixels.
+     * @param doAutoInvert - If true, invert each computed luminance.
+     */
+    static createFromRawRGBA(rgbaData: Uint8ClampedArray, width: number, height: number, doAutoInvert?: boolean): UniversalLuminanceSource;
+    /**
+     * Converts raw RGBA data to a grayscale buffer (single channel).
+     * If doAutoInvert is true, each computed luminance is inverted.
+     */
+    private static toGrayscaleBuffer;
+    getWidth(): number;
+    getHeight(): number;
+    getRow(y: number, row?: Uint8ClampedArray): Uint8ClampedArray;
+    getMatrix(): Uint8ClampedArray;
+    isCropSupported(): boolean;
+    /**
+     * Crops a region from the grayscale buffer.
+     */
+    crop(left: number, top: number, width: number, height: number): LuminanceSource;
+    isRotateSupported(): boolean;
+    rotateCounterClockwise(): LuminanceSource;
+    rotateCounterClockwise45(): LuminanceSource;
+    invert(): LuminanceSource;
+    /**
+     * Rotates the grayscale buffer by the specified angle in degrees.
+     * Supports multiples of 90 only. Throws otherwise.
+     */
+    private rotate;
+}

package/lib/node/lib/zxing-js/src/core/UnsupportedOperationException.d.ts

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