@qr-platform/qr-code.js 0.8.17

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

@@ -0,0 +1,35 @@
+import LuminanceSource from './LuminanceSource';
+/**
+ * This object extends LuminanceSource around an array of YUV data returned from the camera driver,
+ * with the option to crop to a rectangle within the full data. This can be used to exclude
+ * superfluous pixels around the perimeter and speed up decoding.
+ *
+ * It works for any pixel format where the Y channel is planar and appears first, including
+ * YCbCr_420_SP and YCbCr_422_SP.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+export default class PlanarYUVLuminanceSource extends LuminanceSource {
+    private yuvData;
+    private dataWidth;
+    private dataHeight;
+    private left;
+    private top;
+    private static THUMBNAIL_SCALE_FACTOR;
+    constructor(yuvData: Uint8ClampedArray, dataWidth: number, dataHeight: number, left: number, top: number, width: number, height: number, reverseHorizontal: boolean);
+    getRow(y: number, row?: Uint8ClampedArray): Uint8ClampedArray;
+    getMatrix(): Uint8ClampedArray;
+    isCropSupported(): boolean;
+    crop(left: number, top: number, width: number, height: number): LuminanceSource;
+    renderThumbnail(): Int32Array;
+    /**
+     * @return width of image from {@link #renderThumbnail()}
+     */
+    getThumbnailWidth(): number;
+    /**
+     * @return height of image from {@link #renderThumbnail()}
+     */
+    getThumbnailHeight(): number;
+    private reverseHorizontal;
+    invert(): LuminanceSource;
+}

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

@@ -0,0 +1,21 @@
+import LuminanceSource from './LuminanceSource';
+/**
+ * This class is used to help decode images from files which arrive as RGB data from
+ * an ARGB pixel array. It does not support rotation.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @author Betaminos
+ */
+export default class RGBLuminanceSource extends LuminanceSource {
+    private dataWidth?;
+    private dataHeight?;
+    private left?;
+    private top?;
+    private luminances;
+    constructor(luminances: Uint8ClampedArray | Int32Array, width: number, height: number, dataWidth?: number | undefined, dataHeight?: number | undefined, left?: number | undefined, top?: number | undefined);
+    getRow(y: number, row?: Uint8ClampedArray): Uint8ClampedArray;
+    getMatrix(): Uint8ClampedArray;
+    isCropSupported(): boolean;
+    crop(left: number, top: number, width: number, height: number): LuminanceSource;
+    invert(): LuminanceSource;
+}

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

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

@@ -0,0 +1,30 @@
+import BarcodeFormat from './BarcodeFormat';
+import BitMatrix from './common/BitMatrix';
+import EncodeHintType from './EncodeHintType';
+/**
+ * The base class for all objects which encode/generate a barcode image.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+export interface Writer {
+    /**
+     * Encode a barcode using the default settings.
+     *
+     * @param contents The contents to encode in the barcode
+     * @param format The barcode format to generate
+     * @param width The preferred width in pixels
+     * @param height The preferred height in pixels
+     * @return {@link BitMatrix} representing encoded barcode image
+     * @throws WriterException if contents cannot be encoded legally in a format
+     */
+    /**
+     * @param contents The contents to encode in the barcode
+     * @param format The barcode format to generate
+     * @param width The preferred width in pixels
+     * @param height The preferred height in pixels
+     * @param hints Additional parameters to supply to the encoder
+     * @returns BitMatrix representing encoded barcode image
+     * @throws WriterException if contents cannot be encoded legally in a format
+     */
+    encode(contents: string, format: BarcodeFormat, width: number, height: number, hints: Map<EncodeHintType, any>): BitMatrix;
+}

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

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

package/lib/lib/zxing-js/src/core/common/BitArray.d.ts

@@ -0,0 +1,111 @@
+/**
+ * <p>A simple, fast array of bits, represented compactly by an array of ints internally.</p>
+ *
+ * @author Sean Owen
+ */
+export default class BitArray {
+    private size;
+    private bits;
+    constructor(size?: number, bits?: Int32Array);
+    getSize(): number;
+    getSizeInBytes(): number;
+    private ensureCapacity;
+    /**
+     * @param i bit to get
+     * @return true iff bit i is set
+     */
+    get(i: number): boolean;
+    /**
+     * Sets bit i.
+     *
+     * @param i bit to set
+     */
+    set(i: number): void;
+    /**
+     * Flips bit i.
+     *
+     * @param i bit to set
+     */
+    flip(i: number): void;
+    /**
+     * @param from first bit to check
+     * @return index of first bit that is set, starting from the given index, or size if none are set
+     *  at or beyond this given index
+     * @see #getNextUnset(int)
+     */
+    getNextSet(from: number): number;
+    /**
+     * @param from index to start looking for unset bit
+     * @return index of next unset bit, or {@code size} if none are unset until the end
+     * @see #getNextSet(int)
+     */
+    getNextUnset(from: number): number;
+    /**
+     * Sets a block of 32 bits, starting at bit i.
+     *
+     * @param i first bit to set
+     * @param newBits the new value of the next 32 bits. Note again that the least-significant bit
+     * corresponds to bit i, the next-least-significant to i+1, and so on.
+     */
+    setBulk(i: number, newBits: number): void;
+    /**
+     * Sets a range of bits.
+     *
+     * @param start start of range, inclusive.
+     * @param end end of range, exclusive
+     */
+    setRange(start: number, end: number): void;
+    /**
+     * Clears all bits (sets to false).
+     */
+    clear(): void;
+    /**
+     * Efficient method to check if a range of bits is set, or not set.
+     *
+     * @param start start of range, inclusive.
+     * @param end end of range, exclusive
+     * @param value if true, checks that bits in range are set, otherwise checks that they are not set
+     * @return true iff all bits are set or not set in range, according to value argument
+     * @throws IllegalArgumentException if end is less than start or the range is not contained in the array
+     */
+    isRange(start: number, end: number, value: boolean): boolean;
+    appendBit(bit: boolean): void;
+    /**
+     * Appends the least-significant bits, from value, in order from most-significant to
+     * least-significant. For example, appending 6 bits from 0x000001E will append the bits
+     * 0, 1, 1, 1, 1, 0 in that order.
+     *
+     * @param value {@code int} containing bits to append
+     * @param numBits bits from value to append
+     */
+    appendBits(value: number, numBits: number): void;
+    appendBitArray(other: BitArray): void;
+    xor(other: BitArray): void;
+    /**
+     *
+     * @param bitOffset first bit to start writing
+     * @param array array to write into. Bytes are written most-significant byte first. This is the opposite
+     *  of the internal representation, which is exposed by {@link #getBitArray()}
+     * @param offset position in array to start writing
+     * @param numBytes how many bytes to write
+     */
+    toBytes(bitOffset: number, array: Uint8Array, offset: number, numBytes: number): void;
+    /**
+     * @return underlying array of ints. The first element holds the first 32 bits, and the least
+     *         significant bit is bit 0.
+     */
+    getBitArray(): Int32Array;
+    /**
+     * Reverses all bits in the array.
+     */
+    reverse(): void;
+    private static makeArray;
+    equals(o: any): boolean;
+    hashCode(): number;
+    toString(): string;
+    clone(): BitArray;
+    /**
+     * converts to boolean array.
+     */
+    toArray(): Array<boolean>;
+}

package/lib/lib/zxing-js/src/core/common/BitMatrix.d.ts

@@ -0,0 +1,98 @@
+import { int } from '../../customTypings';
+import BitArray from './BitArray';
+export default class BitMatrix {
+    private width;
+    private height?;
+    private rowSize?;
+    private bits?;
+    constructor(width: number, height?: number | undefined, rowSize?: number | undefined, bits?: Int32Array | undefined);
+    /**
+     * Interprets a 2D array of booleans as a BitMatrix, where "true" means an "on" bit.
+     */
+    static parseFromBooleanArray(image: boolean[][]): BitMatrix;
+    /**
+     * Parses a string representation of the bit matrix.
+     */
+    static parseFromString(stringRepresentation: string, setString: string, unsetString: string): BitMatrix;
+    /**
+     * Gets the bit at position (x, y).
+     */
+    get(x: number, y: number): boolean;
+    /**
+     * Sets the bit at position (x, y) to true.
+     */
+    set(x: number, y: number): void;
+    /**
+     * Unsets the bit at position (x, y) (sets it to false).
+     */
+    unset(x: number, y: number): void;
+    /**
+     * Flips the bit at position (x, y).
+     */
+    flip(x: number, y: number): void;
+    /**
+     * XORs this matrix with another matrix.
+     */
+    xor(mask: BitMatrix): void;
+    /**
+     * Clears all bits (sets to false).
+     */
+    clear(): void;
+    /**
+     * Sets a square region of the matrix to true.
+     */
+    setRegion(left: number, top: number, width: number, height: number): void;
+    /**
+     * Retrieves a row as a BitArray.
+     */
+    getRow(y: number, row?: BitArray): BitArray;
+    /**
+     * Sets a row from a BitArray.
+     */
+    setRow(y: number, row: BitArray): void;
+    /**
+     * Rotates the matrix 180 degrees.
+     */
+    rotate180(): void;
+    /**
+     * Returns the smallest rectangle that encloses all set bits.
+     */
+    getEnclosingRectangle(): Int32Array;
+    /**
+     * Returns the coordinate of the top-left set bit.
+     */
+    getTopLeftOnBit(): Int32Array;
+    /**
+     * Returns the coordinate of the bottom-right set bit.
+     */
+    getBottomRightOnBit(): Int32Array;
+    /**
+     * Returns the width of the matrix.
+     */
+    getWidth(): number;
+    /**
+     * Returns the height of the matrix.
+     */
+    getHeight(): number;
+    /**
+     * Returns the row size of the matrix.
+     */
+    getRowSize(): number;
+    /**
+     * Checks equality with another BitMatrix.
+     */
+    equals(o: Object): boolean;
+    /**
+     * Computes the hash code.
+     */
+    hashCode(): int;
+    /**
+     * Returns a string representation of the matrix.
+     */
+    toString(setString?: string, unsetString?: string, lineSeparator?: string): string;
+    private buildToString;
+    /**
+     * Returns a clone of this BitMatrix.
+     */
+    clone(): BitMatrix;
+}

package/lib/lib/zxing-js/src/core/common/BitSource.d.ts

@@ -0,0 +1,38 @@
+/**
+ * <p>This provides an easy abstraction to read bits at a time from a sequence of bytes, where the
+ * number of bits read is not often a multiple of 8.</p>
+ *
+ * <p>This class is thread-safe but not reentrant -- unless the caller modifies the bytes array
+ * it passed in, in which case all bets are off.</p>
+ *
+ * @author Sean Owen
+ */
+export default class BitSource {
+    private bytes;
+    private byteOffset;
+    private bitOffset;
+    /**
+     * @param bytes bytes from which this will read bits. Bits will be read from the first byte first.
+     * Bits are read within a byte from most-significant to least-significant bit.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * @return index of next bit in current byte which would be read by the next call to {@link #readBits(int)}.
+     */
+    getBitOffset(): number;
+    /**
+     * @return index of next byte in input byte array which would be read by the next call to {@link #readBits(int)}.
+     */
+    getByteOffset(): number;
+    /**
+     * @param numBits number of bits to read
+     * @return int representing the bits read. The bits will appear as the least-significant
+     *         bits of the int
+     * @throws IllegalArgumentException if numBits isn't in [1,32] or more than is available
+     */
+    readBits(numBits: number): number;
+    /**
+     * @return number of bits that can be read successfully
+     */
+    available(): number;
+}