@qr-platform/qr-code.js 0.8.17

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

@@ -0,0 +1,89 @@
+export declare enum CharacterSetValueIdentifiers {
+    Cp437 = 0,
+    ISO8859_1 = 1,
+    ISO8859_2 = 2,
+    ISO8859_3 = 3,
+    ISO8859_4 = 4,
+    ISO8859_5 = 5,
+    ISO8859_6 = 6,
+    ISO8859_7 = 7,
+    ISO8859_8 = 8,
+    ISO8859_9 = 9,
+    ISO8859_10 = 10,
+    ISO8859_11 = 11,
+    ISO8859_13 = 12,
+    ISO8859_14 = 13,
+    ISO8859_15 = 14,
+    ISO8859_16 = 15,
+    SJIS = 16,
+    Cp1250 = 17,
+    Cp1251 = 18,
+    Cp1252 = 19,
+    Cp1256 = 20,
+    UnicodeBigUnmarked = 21,
+    UTF8 = 22,
+    ASCII = 23,
+    Big5 = 24,
+    GB18030 = 25,
+    EUC_KR = 26
+}
+/**
+ * Encapsulates a Character Set ECI, according to "Extended Channel Interpretations" 5.3.1.1
+ * of ISO 18004.
+ *
+ * @author Sean Owen
+ */
+export default class CharacterSetECI {
+    valueIdentifier: CharacterSetValueIdentifiers;
+    name: string;
+    private static VALUE_IDENTIFIER_TO_ECI;
+    private static VALUES_TO_ECI;
+    private static NAME_TO_ECI;
+    static readonly Cp437: CharacterSetECI;
+    static readonly ISO8859_1: CharacterSetECI;
+    static readonly ISO8859_2: CharacterSetECI;
+    static readonly ISO8859_3: CharacterSetECI;
+    static readonly ISO8859_4: CharacterSetECI;
+    static readonly ISO8859_5: CharacterSetECI;
+    static readonly ISO8859_6: CharacterSetECI;
+    static readonly ISO8859_7: CharacterSetECI;
+    static readonly ISO8859_8: CharacterSetECI;
+    static readonly ISO8859_9: CharacterSetECI;
+    static readonly ISO8859_10: CharacterSetECI;
+    static readonly ISO8859_11: CharacterSetECI;
+    static readonly ISO8859_13: CharacterSetECI;
+    static readonly ISO8859_14: CharacterSetECI;
+    static readonly ISO8859_15: CharacterSetECI;
+    static readonly ISO8859_16: CharacterSetECI;
+    static readonly SJIS: CharacterSetECI;
+    static readonly Cp1250: CharacterSetECI;
+    static readonly Cp1251: CharacterSetECI;
+    static readonly Cp1252: CharacterSetECI;
+    static readonly Cp1256: CharacterSetECI;
+    static readonly UnicodeBigUnmarked: CharacterSetECI;
+    static readonly UTF8: CharacterSetECI;
+    static readonly ASCII: CharacterSetECI;
+    static readonly Big5: CharacterSetECI;
+    static readonly GB18030: CharacterSetECI;
+    static readonly EUC_KR: CharacterSetECI;
+    values: Int32Array;
+    otherEncodingNames: string[];
+    constructor(valueIdentifier: CharacterSetValueIdentifiers, valuesParam: Int32Array | number, name: string, ...otherEncodingNames: string[]);
+    getValueIdentifier(): CharacterSetValueIdentifiers;
+    getName(): string;
+    getValue(): number;
+    /**
+     * @param value character set ECI value
+     * @return {@code CharacterSetECI} representing ECI of given value, or null if it is legal but
+     *   unsupported
+     * @throws FormatException if ECI value is invalid
+     */
+    static getCharacterSetECIByValue(value: number): CharacterSetECI;
+    /**
+     * @param name character set ECI encoding name
+     * @return CharacterSetECI representing ECI for character encoding, or null if it is legal
+     *   but unsupported
+     */
+    static getCharacterSetECIByName(name: string): CharacterSetECI;
+    equals(o: CharacterSetECI): boolean;
+}

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

@@ -0,0 +1,64 @@
+/**
+ * <p>Encapsulates the result of decoding a matrix of bits. This typically
+ * applies to 2D barcode formats. For now it contains the raw bytes obtained,
+ * as well as a String interpretation of those bytes, if applicable.</p>
+ *
+ * @author Sean Owen
+ */
+export default class DecoderResult {
+    private rawBytes;
+    private text;
+    private byteSegments;
+    private ecLevel;
+    private structuredAppendSequenceNumber;
+    private structuredAppendParity;
+    private numBits;
+    private errorsCorrected;
+    private erasures;
+    private other;
+    constructor(rawBytes: Uint8Array, text: string, byteSegments: Uint8Array[], ecLevel: string, structuredAppendSequenceNumber?: number, structuredAppendParity?: number);
+    /**
+     * @return raw bytes representing the result, or {@code null} if not applicable
+     */
+    getRawBytes(): Uint8Array;
+    /**
+     * @return how many bits of {@link #getRawBytes()} are valid; typically 8 times its length
+     * @since 3.3.0
+     */
+    getNumBits(): number;
+    /**
+     * @param numBits overrides the number of bits that are valid in {@link #getRawBytes()}
+     * @since 3.3.0
+     */
+    setNumBits(numBits: number): void;
+    /**
+     * @return text representation of the result
+     */
+    getText(): string;
+    /**
+     * @return list of byte segments in the result, or {@code null} if not applicable
+     */
+    getByteSegments(): Uint8Array[];
+    /**
+     * @return name of error correction level used, or {@code null} if not applicable
+     */
+    getECLevel(): string;
+    /**
+     * @return number of errors corrected, or {@code null} if not applicable
+     */
+    getErrorsCorrected(): number | undefined;
+    setErrorsCorrected(errorsCorrected: number): void;
+    /**
+     * @return number of erasures corrected, or {@code null} if not applicable
+     */
+    getErasures(): number | undefined;
+    setErasures(erasures: number): void;
+    /**
+     * @return arbitrary additional metadata
+     */
+    getOther(): any;
+    setOther(other: any): void;
+    hasStructuredAppend(): boolean;
+    getStructuredAppendParity(): number;
+    getStructuredAppendSequenceNumber(): number;
+}

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

@@ -0,0 +1,10 @@
+import BitMatrix from './BitMatrix';
+import GridSampler from './GridSampler';
+import PerspectiveTransform from './PerspectiveTransform';
+/**
+ * @author Sean Owen
+ */
+export default class DefaultGridSampler extends GridSampler {
+    sampleGrid(image: BitMatrix, dimensionX: number, dimensionY: number, p1ToX: number, p1ToY: number, p2ToX: number, p2ToY: number, p3ToX: number, p3ToY: number, p4ToX: number, p4ToY: number, p1FromX: number, p1FromY: number, p2FromX: number, p2FromY: number, p3FromX: number, p3FromY: number, p4FromX: number, p4FromY: number): BitMatrix;
+    sampleGridWithTransform(image: BitMatrix, dimensionX: number, dimensionY: number, transform: PerspectiveTransform): BitMatrix;
+}

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

@@ -0,0 +1,16 @@
+import ResultPoint from '../ResultPoint';
+import BitMatrix from './BitMatrix';
+/**
+ * <p>Encapsulates the result of detecting a barcode in an image. This includes the raw
+ * matrix of black/white pixels corresponding to the barcode, and possibly points of interest
+ * in the image, like the location of finder patterns or corners of the barcode in the image.</p>
+ *
+ * @author Sean Owen
+ */
+export default class DetectorResult {
+    private bits;
+    private points;
+    constructor(bits: BitMatrix, points: Array<ResultPoint>);
+    getBits(): BitMatrix;
+    getPoints(): Array<ResultPoint>;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Set of CharsetEncoders for a given input string
+ *
+ * Invariants:
+ * - The list contains only encoders from CharacterSetECI (list is shorter then the list of encoders available on
+ *   the platform for which ECI values are defined).
+ * - The list contains encoders at least one encoder for every character in the input.
+ * - The first encoder in the list is always the ISO-8859-1 encoder even of no character in the input can be encoded
+ *       by it.
+ * - If the input contains a character that is not in ISO-8859-1 then the last two entries in the list will be the
+ *   UTF-8 encoder and the UTF-16BE encoder.
+ *
+ * @author Alex Geller
+ */
+import { char } from '../../customTypings';
+import Charset from '../util/Charset';
+export declare class ECIEncoderSet {
+    private readonly ENCODERS;
+    private encoders;
+    private priorityEncoderIndex;
+    /**
+     * Constructs an encoder set
+     *
+     * @param stringToEncode the string that needs to be encoded
+     * @param priorityCharset The preferred {@link Charset} or null.
+     * @param fnc1 fnc1 denotes the character in the input that represents the FNC1 character or -1 for a non-GS1 bar
+     * code. When specified, it is considered an error to pass it as argument to the methods canEncode() or encode().
+     */
+    constructor(stringToEncode: string, priorityCharset: Charset, fnc1: number);
+    length(): number;
+    getCharsetName(index: number): string;
+    getCharset(index: number): Charset;
+    getECIValue(encoderIndex: number): number;
+    getPriorityEncoderIndex(): number;
+    canEncode(c: char, encoderIndex: number): boolean;
+    encode(c: char, encoderIndex: number): Uint8Array;
+}

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

@@ -0,0 +1,79 @@
+export default interface ECIInput {
+    /**
+     * Returns the length of this input.  The length is the number
+     * of {@code byte}s in or ECIs in the sequence.
+     *
+     * @return  the number of {@code char}s in this sequence
+     */
+    length(): number;
+    /**
+     * Returns the {@code byte} value at the specified index.  An index ranges from zero
+     * to {@code length() - 1}.  The first {@code byte} value of the sequence is at
+     * index zero, the next at index one, and so on, as for array
+     * indexing.
+     *
+     * @param   index the index of the {@code byte} value to be returned
+     *
+     * @return  the specified {@code byte} value as character or the FNC1 character
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if the {@code index} argument is negative or not less than
+     *          {@code length()}
+     * @throws  IllegalArgumentException
+     *          if the value at the {@code index} argument is an ECI (@see #isECI)
+     */
+    charAt(index: number): number;
+    /**
+     * Returns a {@code CharSequence} that is a subsequence of this sequence.
+     * The subsequence starts with the {@code char} value at the specified index and
+     * ends with the {@code char} value at index {@code end - 1}.  The length
+     * (in {@code char}s) of the
+     * returned sequence is {@code end - start}, so if {@code start == end}
+     * then an empty sequence is returned.
+     *
+     * @param   start   the start index, inclusive
+     * @param   end     the end index, exclusive
+     *
+     * @return  the specified subsequence
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if {@code start} or {@code end} are negative,
+     *          if {@code end} is greater than {@code length()},
+     *          or if {@code start} is greater than {@code end}
+     * @throws  IllegalArgumentException
+     *          if a value in the range {@code start}-{@code end} is an ECI (@see #isECI)
+     */
+    subSequence(start: number, end: number): string;
+    /**
+     * Determines if a value is an ECI
+     *
+     * @param   index the index of the value
+     *
+     * @return  true if the value at position {@code index} is an ECI
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if the {@code index} argument is negative or not less than
+     *          {@code length()}
+     */
+    isECI(index: number): boolean;
+    /**
+     * Returns the {@code int} ECI value at the specified index.  An index ranges from zero
+     * to {@code length() - 1}.  The first {@code byte} value of the sequence is at
+     * index zero, the next at index one, and so on, as for array
+     * indexing.
+     *
+     * @param   index the index of the {@code int} value to be returned
+     *
+     * @return  the specified {@code int} ECI value.
+     *          The ECI specified the encoding of all bytes with a higher index until the
+     *          next ECI or until the end of the input if no other ECI follows.
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if the {@code index} argument is negative or not less than
+     *          {@code length()}
+     * @throws  IllegalArgumentException
+     *          if the value at the {@code index} argument is not an ECI (@see #isECI)
+     */
+    getECIValue(index: number): number;
+    haveNCharacters(index: number, n: number): boolean;
+}

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

@@ -0,0 +1,29 @@
+import Binarizer from '../Binarizer';
+import LuminanceSource from '../LuminanceSource';
+import BitArray from './BitArray';
+import BitMatrix from './BitMatrix';
+/**
+ * This Binarizer implementation uses the old ZXing global histogram approach. It is suitable
+ * for low-end mobile devices which don't have enough CPU or memory to use a local thresholding
+ * algorithm. However, because it picks a global black point, it cannot handle difficult shadows
+ * and gradients.
+ *
+ * Faster mobile devices and all desktop applications should probably use HybridBinarizer instead.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @author Sean Owen
+ */
+export default class GlobalHistogramBinarizer extends Binarizer {
+    private static LUMINANCE_BITS;
+    private static LUMINANCE_SHIFT;
+    private static LUMINANCE_BUCKETS;
+    private static EMPTY;
+    private luminances;
+    private buckets;
+    constructor(source: LuminanceSource);
+    getBlackRow(y: number, row: BitArray): BitArray;
+    getBlackMatrix(): BitMatrix;
+    createBinarizer(source: LuminanceSource): Binarizer;
+    private initArrays;
+    private static estimateBlackPoint;
+}

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

@@ -0,0 +1,36 @@
+import BitMatrix from './BitMatrix';
+import PerspectiveTransform from './PerspectiveTransform';
+/**
+ * Implementations of this class can, given locations of finder patterns for a QR code in an
+ * image, sample the right points in the image to reconstruct the QR code, accounting for
+ * perspective distortion. It is abstracted since it is relatively expensive and should be allowed
+ * to take advantage of platform-specific optimized implementations, like Sun's Java Advanced
+ * Imaging library, but which may not be available in other environments such as J2ME, and vice
+ * versa.
+ *
+ * The implementation used can be controlled by calling {@link #setGridSampler(GridSampler)}
+ * with an instance of a class which implements this interface.
+ *
+ * @author Sean Owen
+ */
+declare abstract class GridSampler {
+    abstract sampleGrid(image: BitMatrix, dimensionX: number, dimensionY: number, p1ToX: number, p1ToY: number, p2ToX: number, p2ToY: number, p3ToX: number, p3ToY: number, p4ToX: number, p4ToY: number, p1FromX: number, p1FromY: number, p2FromX: number, p2FromY: number, p3FromX: number, p3FromY: number, p4FromX: number, p4FromY: number): BitMatrix;
+    abstract sampleGridWithTransform(image: BitMatrix, dimensionX: number, dimensionY: number, transform: PerspectiveTransform): BitMatrix;
+    /**
+     * Checks a set of points that have been transformed to sample points on an image against
+     * the image's dimensions to see if the points are even within the image.
+     *
+     * This method will actually "nudge" the endpoints back onto the image if they are found to be
+     * barely (less than 1 pixel) off the image. This accounts for imperfect detection of finder
+     * patterns in an image where the QR Code runs all the way to the image border.
+     *
+     * For efficiency, the method will check points from either end of the line until one is found
+     * to be within the image. Because the set of points are assumed to be linear, this is valid.
+     *
+     * @param image image into which the points should map
+     * @param points actual points in x1,y1,...,xn,yn form
+     * @throws NotFoundException if an endpoint lies outside the image boundaries
+     */
+    protected static checkAndNudgePoints(image: BitMatrix, points: Float32Array): void;
+}
+export default GridSampler;

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

@@ -0,0 +1,18 @@
+import GridSampler from './GridSampler';
+export default class GridSamplerInstance {
+    private static gridSampler;
+    /**
+     * Sets the implementation of GridSampler used by the library. One global
+     * instance is stored, which may sound problematic. But, the implementation provided
+     * ought to be appropriate for the entire platform, and all uses of this library
+     * in the whole lifetime of the JVM. For instance, an Android activity can swap in
+     * an implementation that takes advantage of native platform libraries.
+     *
+     * @param newGridSampler The platform-specific object to install.
+     */
+    static setGridSampler(newGridSampler: GridSampler): void;
+    /**
+     * @return the current implementation of GridSampler
+     */
+    static getInstance(): GridSampler;
+}

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

@@ -0,0 +1,54 @@
+import Binarizer from '../Binarizer';
+import LuminanceSource from '../LuminanceSource';
+import BitMatrix from './BitMatrix';
+import GlobalHistogramBinarizer from './GlobalHistogramBinarizer';
+/**
+ * This class implements a local thresholding algorithm, which while slower than the
+ * GlobalHistogramBinarizer, is fairly efficient for what it does. It is designed for
+ * high frequency images of barcodes with black data on white backgrounds. For this application,
+ * it does a much better job than a global blackpoint with severe shadows and gradients.
+ * However it tends to produce artifacts on lower frequency images and is therefore not
+ * a good general purpose binarizer for uses outside ZXing.
+ *
+ * This class extends GlobalHistogramBinarizer, using the older histogram approach for 1D readers,
+ * and the newer local approach for 2D readers. 1D decoding using a per-row histogram is already
+ * inherently local, and only fails for horizontal gradients. We can revisit that problem later,
+ * but for now it was not a win to use local blocks for 1D.
+ *
+ * This Binarizer is the default for the unit tests and the recommended class for library users.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+export default class HybridBinarizer extends GlobalHistogramBinarizer {
+    private static BLOCK_SIZE_POWER;
+    private static BLOCK_SIZE;
+    private static BLOCK_SIZE_MASK;
+    private static MINIMUM_DIMENSION;
+    private static MIN_DYNAMIC_RANGE;
+    private matrix;
+    constructor(source: LuminanceSource);
+    /**
+     * Calculates the final BitMatrix once for all requests. This could be called once from the
+     * constructor instead, but there are some advantages to doing it lazily, such as making
+     * profiling easier, and not doing heavy lifting when callers don't expect it.
+     */
+    getBlackMatrix(): BitMatrix;
+    createBinarizer(source: LuminanceSource): Binarizer;
+    /**
+     * For each block in the image, calculate the average black point using a 5x5 grid
+     * of the blocks around it. Also handles the corner cases (fractional blocks are computed based
+     * on the last pixels in the row/column which are also used in the previous block).
+     */
+    private static calculateThresholdForBlock;
+    private static cap;
+    /**
+     * Applies a single threshold to a block of pixels.
+     */
+    private static thresholdBlock;
+    /**
+     * Calculates a single black point for each block of pixels and saves it away.
+     * See the following thread for a discussion of this algorithm:
+     *  http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
+     */
+    private static calculateBlackPoints;
+}

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

@@ -0,0 +1,123 @@
+import Charset from '../util/Charset';
+import { ECIEncoderSet } from './ECIEncoderSet';
+import ECIInput from './ECIInput';
+export declare class MinimalECIInput implements ECIInput {
+    private bytes?;
+    private fnc1;
+    /**
+     * Constructs a minimal input
+     *
+     * @param stringToEncode the character string to encode
+     * @param priorityCharset The preferred {@link Charset}. When the value of the argument is null, the algorithm
+     *   chooses charsets that leads to a minimal representation. Otherwise the algorithm will use the priority
+     *   charset to encode any character in the input that can be encoded by it if the charset is among the
+     *   supported charsets.
+     * @param fnc1 denotes the character in the input that represents the FNC1 character or -1 if this is not GS1
+     *   input.
+     */
+    constructor(stringToEncode: string, priorityCharset: Charset, fnc1: number);
+    getFNC1Character(): number;
+    /**
+     * Returns the length of this input.  The length is the number
+     * of {@code byte}s, FNC1 characters or ECIs in the sequence.
+     *
+     * @return  the number of {@code char}s in this sequence
+     */
+    length(): number;
+    haveNCharacters(index: number, n: number): boolean;
+    /**
+     * Returns the {@code byte} value at the specified index.  An index ranges from zero
+     * to {@code length() - 1}.  The first {@code byte} value of the sequence is at
+     * index zero, the next at index one, and so on, as for array
+     * indexing.
+     *
+     * @param   index the index of the {@code byte} value to be returned
+     *
+     * @return  the specified {@code byte} value as character or the FNC1 character
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if the {@code index} argument is negative or not less than
+     *          {@code length()}
+     * @throws  IllegalArgumentException
+     *          if the value at the {@code index} argument is an ECI (@see #isECI)
+     */
+    charAt(index: number): number;
+    /**
+     * Returns a {@code CharSequence} that is a subsequence of this sequence.
+     * The subsequence starts with the {@code char} value at the specified index and
+     * ends with the {@code char} value at index {@code end - 1}.  The length
+     * (in {@code char}s) of the
+     * returned sequence is {@code end - start}, so if {@code start == end}
+     * then an empty sequence is returned.
+     *
+     * @param   start   the start index, inclusive
+     * @param   end     the end index, exclusive
+     *
+     * @return  the specified subsequence
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if {@code start} or {@code end} are negative,
+     *          if {@code end} is greater than {@code length()},
+     *          or if {@code start} is greater than {@code end}
+     * @throws  IllegalArgumentException
+     *          if a value in the range {@code start}-{@code end} is an ECI (@see #isECI)
+     */
+    subSequence(start: number, end: number): string;
+    /**
+     * Determines if a value is an ECI
+     *
+     * @param   index the index of the value
+     *
+     * @return  true if the value at position {@code index} is an ECI
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if the {@code index} argument is negative or not less than
+     *          {@code length()}
+     */
+    isECI(index: number): boolean;
+    /**
+     * Determines if a value is the FNC1 character
+     *
+     * @param   index the index of the value
+     *
+     * @return  true if the value at position {@code index} is the FNC1 character
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if the {@code index} argument is negative or not less than
+     *          {@code length()}
+     */
+    isFNC1(index: number): boolean;
+    /**
+     * Returns the {@code int} ECI value at the specified index.  An index ranges from zero
+     * to {@code length() - 1}.  The first {@code byte} value of the sequence is at
+     * index zero, the next at index one, and so on, as for array
+     * indexing.
+     *
+     * @param   index the index of the {@code int} value to be returned
+     *
+     * @return  the specified {@code int} ECI value.
+     *          The ECI specified the encoding of all bytes with a higher index until the
+     *          next ECI or until the end of the input if no other ECI follows.
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if the {@code index} argument is negative or not less than
+     *          {@code length()}
+     * @throws  IllegalArgumentException
+     *          if the value at the {@code index} argument is not an ECI (@see #isECI)
+     */
+    getECIValue(index: number): number;
+    addEdge(edges: InputEdge[][], to: number, edge: InputEdge): void;
+    addEdges(stringToEncode: string, encoderSet: ECIEncoderSet, edges: InputEdge[][], from: number, previous: InputEdge, fnc1: number): void;
+    encodeMinimally(stringToEncode: string, encoderSet: ECIEncoderSet, fnc1: number): number[];
+}
+declare class InputEdge {
+    readonly c: char;
+    readonly encoderSet: ECIEncoderSet;
+    readonly encoderIndex: number;
+    readonly previous: InputEdge;
+    readonly fnc1: number;
+    readonly cachedTotalSize: number;
+    constructor(c: char, encoderSet: ECIEncoderSet, encoderIndex: number, previous: InputEdge, fnc1: number);
+    isFNC1(): boolean;
+}
+export {};

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

@@ -0,0 +1,26 @@
+/**
+ * <p>This class implements a perspective transform in two dimensions. Given four source and four
+ * destination points, it will compute the transformation implied between them. The code is based
+ * directly upon section 3.4.2 of George Wolberg's "Digital Image Warping"; see pages 54-56.</p>
+ *
+ * @author Sean Owen
+ */
+export default class PerspectiveTransform {
+    private a11;
+    private a21;
+    private a31;
+    private a12;
+    private a22;
+    private a32;
+    private a13;
+    private a23;
+    private a33;
+    private constructor();
+    static quadrilateralToQuadrilateral(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x0p: number, y0p: number, x1p: number, y1p: number, x2p: number, y2p: number, x3p: number, y3p: number): PerspectiveTransform;
+    transformPoints(points: Float32Array): void;
+    transformPointsWithValues(xValues: Float32Array, yValues: Float32Array): void;
+    static squareToQuadrilateral(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): PerspectiveTransform;
+    static quadrilateralToSquare(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): PerspectiveTransform;
+    protected buildAdjoint(): PerspectiveTransform;
+    protected times(other: PerspectiveTransform): PerspectiveTransform;
+}

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

@@ -0,0 +1,48 @@
+import { int } from '../../customTypings';
+import DecodeHintType from '../DecodeHintType';
+import Charset from '../util/Charset';
+import CharacterSetECI from './CharacterSetECI';
+/**
+ * Common string-related functions.
+ *
+ * @author Sean Owen
+ * @author Alex Dupre
+ */
+export default class StringUtils {
+    static SHIFT_JIS: string;
+    static GB2312: string;
+    static ISO88591: string;
+    private static EUC_JP;
+    private static UTF8;
+    private static PLATFORM_DEFAULT_ENCODING;
+    private static ASSUME_SHIFT_JIS;
+    static castAsNonUtf8Char(code: number, encoding?: Charset): string;
+    /**
+     * @param bytes bytes encoding a string, whose encoding should be guessed
+     * @param hints decode hints if applicable
+     * @return name of guessed encoding; at the moment will only guess one of:
+     *  {@link #SHIFT_JIS}, {@link #UTF8}, {@link #ISO88591}, or the platform
+     *  default encoding if none of these can possibly be correct
+     */
+    static guessEncoding(bytes: Uint8Array, hints: Map<DecodeHintType, any>): string;
+    /**
+     *
+     * @see https://stackoverflow.com/a/13439711/4367683
+     *
+     * @param append The new string to append.
+     * @param args Argumets values to be formated.
+     */
+    static format(append: string, ...args: any[]): string;
+    /**
+     *
+     */
+    static getBytes(str: string, encoding: CharacterSetECI): Uint8Array;
+    /**
+     * Returns the charcode at the specified index or at index zero.
+     */
+    static getCharCode(str: string, index?: number): int;
+    /**
+     * Returns char for given charcode
+     */
+    static getCharAt(charCode: number): string;
+}

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

@@ -0,0 +1,35 @@
+import BitMatrix from '../../common/BitMatrix';
+import ResultPoint from '../../ResultPoint';
+/**
+ * @author Mariusz Dąbrowski
+ */
+export default class CornerDetector {
+    private image;
+    private height;
+    private width;
+    private leftInit;
+    private rightInit;
+    private downInit;
+    private upInit;
+    private targetMatrixSize;
+    /**
+     * @throws NotFoundException if image is too small to accommodate {@code initSize}
+     */
+    constructor(image: BitMatrix, initSize: number, x: number, y: number, targetMatrixSize: number);
+    /**
+     * @throws NotFoundException if no Data Matrix Code can be found
+     */
+    detect(): ResultPoint[];
+    private findCorners;
+    private getCornerFromArea;
+    /**
+     * Determines whether a segment contains a black point
+     *
+     * @param a          min value of the scanned coordinate
+     * @param b          max value of the scanned coordinate
+     * @param fixed      value of fixed coordinate
+     * @param horizontal set to true if scan must be horizontal, false if vertical
+     * @return true if a black point has been found, else false.
+     */
+    private containsBlackPoint;
+}