@qr-platform/qr-code.js 0.8.17

package/lib/lib/qrcode/QRUtil.d.ts

@@ -0,0 +1,25 @@
+import { ErrorCorrectLevel } from './ErrorCorrectLevel.js';
+import { Mode } from './Mode.js';
+import { Polynomial } from './Polynomial.js';
+import { QRCodeMinimal } from './QRCodeMinimal.js';
+/**
+ * QRUtil
+ *
+ * @author Kazuhiko Arase
+ */
+export declare class QRUtil {
+    constructor();
+    static getPatternPosition(typeNumber: number): number[];
+    private static PATTERN_POSITION_TABLE;
+    private static MAX_LENGTH;
+    static getMaxLength(typeNumber: number, mode: Mode, errorCorrectLevel: ErrorCorrectLevel): number;
+    static getErrorCorrectPolynomial(errorCorrectLength: number): Polynomial;
+    static getMaskFunc(maskPattern: number): (i: number, j: number) => boolean;
+    static getLostPoint(qrCode: QRCodeMinimal): number;
+    static getBCHTypeInfo(data: number): number;
+    static getBCHTypeNumber(data: number): number;
+    private static G15;
+    private static G18;
+    private static G15_MASK;
+    private static getBCHDigit;
+}

package/lib/lib/qrcode/RSBlock.d.ts

@@ -0,0 +1,16 @@
+import { ErrorCorrectLevel } from './ErrorCorrectLevel.js';
+/**
+ * RSBlock
+ *
+ * @author Kazuhiko Arase
+ */
+export declare class RSBlock {
+    private totalCount;
+    private dataCount;
+    private static RS_BLOCK_TABLE;
+    constructor(totalCount: number, dataCount: number);
+    getDataCount(): number;
+    getTotalCount(): number;
+    static getRSBlocks(typeNumber: number, errorCorrectLevel: ErrorCorrectLevel): RSBlock[];
+    private static getRsBlockTable;
+}

package/lib/lib/text/createStringToBytes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * createStringToBytes
+ *
+ * @author Kazuhiko Arase
+ * @param unicodeData base64 string of byte array.
+ * [16bit Unicode],[16bit Bytes], ...
+ * @param numChars
+ */
+export declare function createStringToBytes(unicodeData: string, numChars: number): (s: string) => number[];

package/lib/lib/text/stringToBytes_SJIS.d.ts

@@ -0,0 +1,8 @@
+/**
+ * stringToBytes_SJIS
+ *
+ * @author Kazuhiko Arase
+ */
+export declare const stringToBytes_SJIS: {
+    SJIS: (s: string) => number[];
+};

package/lib/lib/text/stringToBytes_UTF8.d.ts

@@ -0,0 +1,7 @@
+/**
+ * stringToBytes_UTF8
+ * contributed by elhigu
+ */
+export declare const stringToBytes_UTF8: {
+    UTF8: (s: string) => number[];
+};

package/lib/lib/zbar-wasm/index.d.ts

@@ -0,0 +1 @@
+declare var zbarWasm: {};

package/lib/lib/zxing-js/src/browser/BrowserCodeReader.d.ts

@@ -0,0 +1,410 @@
+import BinaryBitmap from '../core/BinaryBitmap';
+import DecodeHintType from '../core/DecodeHintType';
+import Reader from '../core/Reader';
+import Result from '../core/Result';
+import { DecodeContinuouslyCallback } from './DecodeContinuouslyCallback';
+import { HTMLVisualMediaElement } from './HTMLVisualMediaElement';
+import { VideoInputDevice } from './VideoInputDevice';
+/**
+ *
+ * Base class for browser code reader.
+ */
+export declare class BrowserCodeReader {
+    protected readonly reader: Reader;
+    protected timeBetweenScansMillis: number;
+    protected _hints?: Map<DecodeHintType, any> | undefined;
+    /**
+     * If navigator is present.
+     */
+    get hasNavigator(): boolean;
+    /**
+     * If mediaDevices under navigator is supported.
+     */
+    get isMediaDevicesSuported(): boolean;
+    /**
+     * If enumerateDevices under navigator is supported.
+     */
+    get canEnumerateDevices(): boolean;
+    /**
+     * This will break the loop.
+     */
+    private _stopContinuousDecode;
+    /**
+     * This will break the loop.
+     */
+    private _stopAsyncDecode;
+    /**
+     * Delay time between decode attempts made by the scanner.
+     */
+    protected _timeBetweenDecodingAttempts: number;
+    /** Time between two decoding tries in milli seconds. */
+    get timeBetweenDecodingAttempts(): number;
+    /**
+     * Change the time span the decoder waits between two decoding tries.
+     *
+     * @param {number} millis Time between two decoding tries in milli seconds.
+     */
+    set timeBetweenDecodingAttempts(millis: number);
+    /**
+     * The HTML canvas element, used to draw the video or image's frame for decoding.
+     */
+    protected captureCanvas: HTMLCanvasElement;
+    /**
+     * The HTML canvas element context.
+     */
+    protected captureCanvasContext: CanvasRenderingContext2D;
+    /**
+     * The HTML image element, used as a fallback for the video element when decoding.
+     */
+    protected imageElement: HTMLImageElement;
+    /**
+     * Should contain the current registered listener for image loading,
+     * used to unregister that listener when needed.
+     */
+    protected imageLoadedListener: EventListener;
+    /**
+     * The stream output from camera.
+     */
+    protected stream: MediaStream;
+    /**
+     * The HTML video element, used to display the camera stream.
+     */
+    protected videoElement: HTMLVideoElement;
+    /**
+     * Should contain the current registered listener for video loaded-metadata,
+     * used to unregister that listener when needed.
+     */
+    protected videoCanPlayListener: EventListener;
+    /**
+     * Should contain the current registered listener for video play-ended,
+     * used to unregister that listener when needed.
+     */
+    protected videoEndedListener: EventListener;
+    /**
+     * Should contain the current registered listener for video playing,
+     * used to unregister that listener when needed.
+     */
+    protected videoPlayingEventListener: EventListener;
+    /**
+     * Sets the hints.
+     */
+    set hints(hints: Map<DecodeHintType, any>);
+    /**
+     * Sets the hints.
+     */
+    get hints(): Map<DecodeHintType, any>;
+    /**
+     * Creates an instance of BrowserCodeReader.
+     * @param {Reader} reader The reader instance to decode the barcode
+     * @param {number} [timeBetweenScansMillis=500] the time delay between subsequent successful decode tries
+     *
+     * @memberOf BrowserCodeReader
+     */
+    constructor(reader: Reader, timeBetweenScansMillis?: number, _hints?: Map<DecodeHintType, any> | undefined);
+    /**
+     * Lists all the available video input devices.
+     */
+    listVideoInputDevices(): Promise<MediaDeviceInfo[]>;
+    /**
+     * Obtain the list of available devices with type 'videoinput'.
+     *
+     * @returns {Promise<VideoInputDevice[]>} an array of available video input devices
+     *
+     * @memberOf BrowserCodeReader
+     *
+     * @deprecated Use `listVideoInputDevices` instead.
+     */
+    getVideoInputDevices(): Promise<VideoInputDevice[]>;
+    /**
+     * Let's you find a device using it's Id.
+     */
+    findDeviceById(deviceId: string): Promise<MediaDeviceInfo>;
+    /**
+     * Decodes the barcode from the device specified by deviceId while showing the video in the specified video element.
+     *
+     * @param deviceId the id of one of the devices obtained after calling getVideoInputDevices. Can be undefined, in this case it will decode from one of the available devices, preffering the main camera (environment facing) if available.
+     * @param video the video element in page where to show the video while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, in which case no video will be shown.
+     * @returns The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     *
+     * @deprecated Use `decodeOnceFromVideoDevice` instead.
+     */
+    decodeFromInputVideoDevice(deviceId?: string, videoSource?: string | HTMLVideoElement): Promise<Result>;
+    /**
+     * In one attempt, tries to decode the barcode from the device specified by deviceId while showing the video in the specified video element.
+     *
+     * @param deviceId the id of one of the devices obtained after calling getVideoInputDevices. Can be undefined, in this case it will decode from one of the available devices, preffering the main camera (environment facing) if available.
+     * @param video the video element in page where to show the video while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, in which case no video will be shown.
+     * @returns The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    decodeOnceFromVideoDevice(deviceId?: string, videoSource?: string | HTMLVideoElement): Promise<Result>;
+    /**
+     * In one attempt, tries to decode the barcode from a stream obtained from the given constraints while showing the video in the specified video element.
+     *
+     * @param constraints the media stream constraints to get s valid media stream to decode from
+     * @param video the video element in page where to show the video while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, in which case no video will be shown.
+     * @returns The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    decodeOnceFromConstraints(constraints: MediaStreamConstraints, videoSource?: string | HTMLVideoElement): Promise<Result>;
+    /**
+     * In one attempt, tries to decode the barcode from a stream obtained from the given constraints while showing the video in the specified video element.
+     *
+     * @param {MediaStream} [constraints] the media stream constraints to get s valid media stream to decode from
+     * @param {string|HTMLVideoElement} [video] the video element in page where to show the video while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, in which case no video will be shown.
+     * @returns {Promise<Result>} The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    decodeOnceFromStream(stream: MediaStream, videoSource?: string | HTMLVideoElement): Promise<Result>;
+    /**
+     * Continuously decodes the barcode from the device specified by device while showing the video in the specified video element.
+     *
+     * @param {string|null} [deviceId] the id of one of the devices obtained after calling getVideoInputDevices. Can be undefined, in this case it will decode from one of the available devices, preffering the main camera (environment facing) if available.
+     * @param {string|HTMLVideoElement|null} [video] the video element in page where to show the video while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, in which case no video will be shown.
+     * @returns {Promise<void>}
+     *
+     * @memberOf BrowserCodeReader
+     *
+     * @deprecated Use `decodeFromVideoDevice` instead.
+     */
+    decodeFromInputVideoDeviceContinuously(deviceId: string | null, videoSource: string | HTMLVideoElement | null, callbackFn: DecodeContinuouslyCallback): Promise<void>;
+    /**
+     * Continuously tries to decode the barcode from the device specified by device while showing the video in the specified video element.
+     *
+     * @param {string|null} [deviceId] the id of one of the devices obtained after calling getVideoInputDevices. Can be undefined, in this case it will decode from one of the available devices, preffering the main camera (environment facing) if available.
+     * @param {string|HTMLVideoElement|null} [video] the video element in page where to show the video while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, in which case no video will be shown.
+     * @returns {Promise<void>}
+     *
+     * @memberOf BrowserCodeReader
+     */
+    decodeFromVideoDevice(deviceId: string | null, videoSource: string | HTMLVideoElement | null, callbackFn: DecodeContinuouslyCallback): Promise<void>;
+    /**
+     * Continuously tries to decode the barcode from a stream obtained from the given constraints while showing the video in the specified video element.
+     *
+     * @param {MediaStream} [constraints] the media stream constraints to get s valid media stream to decode from
+     * @param {string|HTMLVideoElement} [video] the video element in page where to show the video while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, in which case no video will be shown.
+     * @returns {Promise<Result>} The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    decodeFromConstraints(constraints: MediaStreamConstraints, videoSource: string | HTMLVideoElement, callbackFn: DecodeContinuouslyCallback): Promise<void>;
+    /**
+     * In one attempt, tries to decode the barcode from a stream obtained from the given constraints while showing the video in the specified video element.
+     *
+     * @param {MediaStream} [constraints] the media stream constraints to get s valid media stream to decode from
+     * @param {string|HTMLVideoElement} [video] the video element in page where to show the video while decoding. Can be either an element id or directly an HTMLVideoElement. Can be undefined, in which case no video will be shown.
+     * @returns {Promise<Result>} The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    decodeFromStream(stream: MediaStream, videoSource: string | HTMLVideoElement, callbackFn: DecodeContinuouslyCallback): Promise<void>;
+    /**
+     * Breaks the decoding loop.
+     */
+    stopAsyncDecode(): void;
+    /**
+     * Breaks the decoding loop.
+     */
+    stopContinuousDecode(): void;
+    /**
+     * Sets the new stream and request a new decoding-with-delay.
+     *
+     * @param stream The stream to be shown in the video element.
+     * @param decodeFn A callback for the decode method.
+     */
+    protected attachStreamToVideo(stream: MediaStream, videoSource: string | HTMLVideoElement): Promise<HTMLVideoElement>;
+    /**
+     *
+     * @param videoElement
+     */
+    protected playVideoOnLoadAsync(videoElement: HTMLVideoElement): Promise<void>;
+    /**
+     * Binds listeners and callbacks to the videoElement.
+     *
+     * @param element
+     * @param callbackFn
+     */
+    protected playVideoOnLoad(element: HTMLVideoElement, callbackFn: EventListener): void;
+    /**
+     * Checks if the given video element is currently playing.
+     */
+    isVideoPlaying(video: HTMLVideoElement): boolean;
+    /**
+     * Just tries to play the video and logs any errors.
+     * The play call is only made is the video is not already playing.
+     */
+    tryPlayVideo(videoElement: HTMLVideoElement): Promise<void>;
+    /**
+     * Searches and validates a media element.
+     */
+    getMediaElement(mediaElementId: string, type: string): HTMLVisualMediaElement;
+    /**
+     * Decodes the barcode from an image.
+     *
+     * @param {(string|HTMLImageElement)} [source] The image element that can be either an element id or the element itself. Can be undefined in which case the decoding will be done from the imageUrl parameter.
+     * @param {string} [url]
+     * @returns {Promise<Result>} The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    decodeFromImage(source?: string | HTMLImageElement, url?: string): Promise<Result>;
+    /**
+     * Decodes the barcode from a video.
+     *
+     * @param {(string|HTMLImageElement)} [source] The image element that can be either an element id or the element itself. Can be undefined in which case the decoding will be done from the imageUrl parameter.
+     * @param {string} [url]
+     * @returns {Promise<Result>} The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    decodeFromVideo(source?: string | HTMLVideoElement, url?: string): Promise<Result>;
+    /**
+     * Decodes continuously the barcode from a video.
+     *
+     * @param {(string|HTMLImageElement)} [source] The image element that can be either an element id or the element itself. Can be undefined in which case the decoding will be done from the imageUrl parameter.
+     * @param {string} [url]
+     * @returns {Promise<Result>} The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     *
+     * @experimental
+     */
+    decodeFromVideoContinuously(source: string | HTMLVideoElement | null, url: string | null, callbackFn: DecodeContinuouslyCallback): Promise<void>;
+    /**
+     * Decodes something from an image HTML element.
+     */
+    decodeFromImageElement(source: string | HTMLImageElement): Promise<Result>;
+    /**
+     * Decodes something from an image HTML element.
+     */
+    decodeFromVideoElement(source: string | HTMLVideoElement): Promise<Result>;
+    /**
+     * Decodes something from an image HTML element.
+     */
+    decodeFromVideoElementContinuously(source: string | HTMLVideoElement, callbackFn: DecodeContinuouslyCallback): Promise<void>;
+    /**
+     * Sets up the video source so it can be decoded when loaded.
+     *
+     * @param source The video source element.
+     */
+    private _decodeFromVideoElementSetup;
+    /**
+     * Decodes an image from a URL.
+     */
+    decodeFromImageUrl(url?: string): Promise<Result>;
+    /**
+     * Decodes an image from a URL.
+     */
+    decodeFromVideoUrl(url: string): Promise<Result>;
+    /**
+     * Decodes an image from a URL.
+     *
+     * @experimental
+     */
+    decodeFromVideoUrlContinuously(url: string, callbackFn: DecodeContinuouslyCallback): Promise<void>;
+    private _decodeOnLoadImage;
+    private _decodeOnLoadVideo;
+    private _decodeOnLoadVideoContinuously;
+    isImageLoaded(img: HTMLImageElement): boolean;
+    prepareImageElement(imageSource?: HTMLImageElement | string): HTMLImageElement;
+    /**
+     * Sets a HTMLVideoElement for scanning or creates a new one.
+     *
+     * @param videoSource The HTMLVideoElement to be set.
+     */
+    prepareVideoElement(videoSource?: HTMLVideoElement | string): HTMLVideoElement;
+    /**
+     * Tries to decode from the video input until it finds some value.
+     */
+    decodeOnce(element: HTMLVisualMediaElement, retryIfNotFound?: boolean, retryIfChecksumOrFormatError?: boolean): Promise<Result>;
+    /**
+     * Continuously decodes from video input.
+     */
+    decodeContinuously(element: HTMLVideoElement, callbackFn: DecodeContinuouslyCallback): void;
+    /**
+     * Gets the BinaryBitmap for ya! (and decodes it)
+     */
+    decode(element: HTMLVisualMediaElement): Result;
+    /**
+     * Creates a binaryBitmap based in some image source.
+     *
+     * @param mediaElement HTML element containing drawable image source.
+     */
+    createBinaryBitmap(mediaElement: HTMLVisualMediaElement): BinaryBitmap;
+    /**
+     *
+     */
+    protected getCaptureCanvasContext(mediaElement?: HTMLVisualMediaElement): CanvasRenderingContext2D;
+    /**
+     *
+     */
+    protected getCaptureCanvas(mediaElement?: HTMLVisualMediaElement): HTMLCanvasElement;
+    /**
+     * Overwriting this allows you to manipulate the next frame in anyway you want before decode.
+     */
+    drawFrameOnCanvas(srcElement: HTMLVideoElement, dimensions?: {
+        sx: number;
+        sy: number;
+        sWidth: number;
+        sHeight: number;
+        dx: number;
+        dy: number;
+        dWidth: number;
+        dHeight: number;
+    }, canvasElementContext?: CanvasRenderingContext2D): void;
+    /**
+     * Ovewriting this allows you to manipulate the snapshot image in anyway you want before decode.
+     */
+    drawImageOnCanvas(srcElement: HTMLImageElement, dimensions?: {
+        sx: number;
+        sy: number;
+        sWidth: number;
+        sHeight: number;
+        dx: number;
+        dy: number;
+        dWidth: number;
+        dHeight: number;
+    }, canvasElementContext?: CanvasRenderingContext2D): void;
+    /**
+     * Call the encapsulated readers decode
+     */
+    decodeBitmap(binaryBitmap: BinaryBitmap): Result;
+    /**
+     * 🖌 Prepares the canvas for capture and scan frames.
+     */
+    createCaptureCanvas(mediaElement?: HTMLVisualMediaElement): HTMLCanvasElement;
+    /**
+     * Stops the continuous scan and cleans the stream.
+     */
+    protected stopStreams(): void;
+    /**
+     * Resets the code reader to the initial state. Cancels any ongoing barcode scanning from video or camera.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    reset(): void;
+    private _destroyVideoElement;
+    private _destroyImageElement;
+    /**
+     * Cleans canvas references 🖌
+     */
+    private _destroyCaptureCanvas;
+    /**
+     * Defines what the videoElement src will be.
+     *
+     * @param videoElement
+     * @param stream
+     */
+    addVideoSource(videoElement: HTMLVideoElement, stream: MediaStream): void;
+    /**
+     * Unbinds a HTML video src property.
+     *
+     * @param videoElement
+     */
+    private cleanVideoSource;
+}

package/lib/lib/zxing-js/src/browser/BrowserQRCodeReader.d.ts

@@ -0,0 +1,29 @@
+import BinaryBitmap from '../core/BinaryBitmap';
+import Result from '../core/Result';
+import { BrowserCodeReader } from './BrowserCodeReader';
+/**
+ * QR Code reader to use from browser with improved error handling.
+ * This implementation properly handles promise rejections when QR codes can't be decoded.
+ */
+export declare class BrowserQRCodeReader extends BrowserCodeReader {
+    private qrReader;
+    private inProgressDecodes;
+    constructor(timeBetweenScansMillis?: number);
+    /**
+     * Safely reset the reader without causing message channel issues
+     */
+    private safeReset;
+    /**
+     * Overrides the decodeBitmap method to ensure proper error handling and reader reset.
+     * This makes BrowserQRCodeReader behave consistently with BrowserMultiFormatReader.
+     */
+    decodeBitmap(binaryBitmap: BinaryBitmap): Result;
+    /**
+     * Overrides decodeFromImageUrl to ensure proper resource handling
+     */
+    decodeFromImageUrl(url: string): Promise<Result>;
+    /**
+     * Override the reset method to safely clean up resources
+     */
+    reset(): void;
+}

package/lib/lib/zxing-js/src/browser/BrowserQRCodeSvgWriter.d.ts

@@ -0,0 +1,46 @@
+import EncodeHintType from '../core/EncodeHintType';
+/**
+ * @deprecated Moving to @zxing/browser
+ */
+declare class BrowserQRCodeSvgWriter {
+    private static readonly QUIET_ZONE_SIZE;
+    /**
+     * SVG markup NameSpace
+     */
+    private static readonly SVG_NS;
+    /**
+     * Writes and renders a QRCode SVG element.
+     *
+     * @param contents
+     * @param width
+     * @param height
+     * @param hints
+     */
+    write(contents: string, width: number, height: number, hints?: Map<EncodeHintType, any>): SVGSVGElement;
+    /**
+     * Renders the result and then appends it to the DOM.
+     */
+    writeToDom(containerElement: string | HTMLElement, contents: string, width: number, height: number, hints?: Map<EncodeHintType, any>): void;
+    /**
+     * Note that the input matrix uses 0 == white, 1 == black.
+     * The output matrix uses 0 == black, 255 == white (i.e. an 8 bit greyscale bitmap).
+     */
+    private renderResult;
+    /**
+     * Creates a SVG element.
+     *
+     * @param w SVG's width attribute
+     * @param h SVG's height attribute
+     */
+    private createSVGElement;
+    /**
+     * Creates a SVG rect element.
+     *
+     * @param x Element's x coordinate
+     * @param y Element's y coordinate
+     * @param w Element's width attribute
+     * @param h Element's height attribute
+     */
+    private createSvgRectElement;
+}
+export { BrowserQRCodeSvgWriter };

package/lib/lib/zxing-js/src/browser/BrowserSvgCodeWriter.d.ts

@@ -0,0 +1,49 @@
+import EncodeHintType from '../core/EncodeHintType';
+/**
+ * @deprecated Moving to @zxing/browser
+ */
+declare abstract class BrowserSvgCodeWriter {
+    /**
+     * Default quiet zone in pixels.
+     */
+    private static readonly QUIET_ZONE_SIZE;
+    /**
+     * SVG markup NameSpace
+     */
+    private static readonly SVG_NS;
+    /**
+     * A HTML container element for the image.
+     */
+    private containerElement;
+    /**
+     * Constructs. 😉
+     */
+    constructor(containerElement: string | HTMLElement);
+    /**
+     * Writes the QR code to a SVG and renders it in the container.
+     */
+    write(contents: string, width: number, height: number, hints?: Map<EncodeHintType, any>): SVGSVGElement;
+    /**
+     * Encodes the content to a Barcode type.
+     */
+    private encode;
+    /**
+     * Renders the SVG in the container.
+     *
+     * @note the input matrix uses 0 == white, 1 == black. The output matrix uses 0 == black, 255 == white (i.e. an 8 bit greyscale bitmap).
+     */
+    private renderResult;
+    /**
+     * Creates a SVG element.
+     */
+    protected createSVGElement(w: number, h: number): SVGSVGElement;
+    /**
+     * Creates a SVG rect.
+     */
+    protected createSvgPathPlaceholderElement(w: number, h: number): SVGPathElement;
+    /**
+     * Creates a SVG rect.
+     */
+    protected createSvgRectElement(x: number, y: number, w: number, h: number): SVGRectElement;
+}
+export { BrowserSvgCodeWriter };

package/lib/lib/zxing-js/src/browser/DecodeContinuouslyCallback.d.ts

@@ -0,0 +1,6 @@
+import Exception from '../core/Exception';
+import Result from '../core/Result';
+/**
+ * Callback format for continuous decode scan.
+ */
+export type DecodeContinuouslyCallback = (result: Result, error?: Exception) => any;

package/lib/lib/zxing-js/src/browser/HTMLCanvasElementLuminanceSource.d.ts

@@ -0,0 +1,27 @@
+import LuminanceSource from '../core/LuminanceSource';
+export declare class HTMLCanvasElementLuminanceSource extends LuminanceSource {
+    private canvas;
+    private buffer;
+    private static DEGREE_TO_RADIANS;
+    private static FRAME_INDEX;
+    private tempCanvasElement;
+    constructor(canvas: HTMLCanvasElement, doAutoInvert?: boolean);
+    private static makeBufferFromCanvasImageData;
+    private static toGrayscaleBuffer;
+    getRow(y: number, row: Uint8ClampedArray): Uint8ClampedArray;
+    getMatrix(): Uint8ClampedArray;
+    isCropSupported(): boolean;
+    crop(left: number, top: number, width: number, height: number): LuminanceSource;
+    /**
+     * This is always true, since the image is a gray-scale image.
+     *
+     * @return true
+     */
+    isRotateSupported(): boolean;
+    rotateCounterClockwise(): LuminanceSource;
+    rotateCounterClockwise45(): LuminanceSource;
+    private getTempCanvasElement;
+    private rotate;
+    invert(): LuminanceSource;
+    hightContrast(threshold?: number): LuminanceSource;
+}

package/lib/lib/zxing-js/src/browser/HTMLVisualMediaElement.d.ts

@@ -0,0 +1,4 @@
+/**
+ * HTML elements that can be decoded.
+ */
+export type HTMLVisualMediaElement = HTMLVideoElement | HTMLImageElement;

package/lib/lib/zxing-js/src/browser/VideoInputDevice.d.ts

@@ -0,0 +1,22 @@
+export declare class VideoInputDevice implements MediaDeviceInfo {
+    deviceId: string;
+    label: string;
+    /** @inheritdoc */
+    readonly kind = "videoinput";
+    /** @inheritdoc */
+    readonly groupId: string;
+    /**
+     * Creates an instance of VideoInputDevice.
+     *
+     * @param {string} deviceId the video input device id
+     * @param {string} label the label of the device if available
+     */
+    constructor(deviceId: string, label: string, groupId?: string);
+    /** @inheritdoc */
+    toJSON(): {
+        kind: string;
+        groupId: string;
+        deviceId: string;
+        label: string;
+    };
+}

package/lib/lib/zxing-js/src/browser.d.ts

@@ -0,0 +1,3 @@
+export * from './browser/BrowserQRCodeReader';
+export * from './browser/HTMLCanvasElementLuminanceSource';
+export * from './core/UniversalLuminanceSource';