feat(core): update session, security system and QR exchange

- Removed session creation and Lightning payment logic
- Refactored security system:
  * no more restrictions
  * all systems enabled on session creation
- Improved QR code exchange for mobile devices

node_modules/html5-qrcode/es2015/camera/core-impl.d.ts

@@ -0,0 +1,7 @@
+import { Camera, CameraRenderingOptions, RenderedCamera, RenderingCallbacks } from "./core";
+export declare class CameraImpl implements Camera {
+    private readonly mediaStream;
+    private constructor();
+    render(parentElement: HTMLElement, options: CameraRenderingOptions, callbacks: RenderingCallbacks): Promise<RenderedCamera>;
+    static create(videoConstraints: MediaTrackConstraints): Promise<Camera>;
+}

node_modules/html5-qrcode/es2015/camera/core-impl.js

@@ -0,0 +1,236 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+class AbstractCameraCapability {
+    constructor(name, track) {
+        this.name = name;
+        this.track = track;
+    }
+    isSupported() {
+        if (!this.track.getCapabilities) {
+            return false;
+        }
+        return this.name in this.track.getCapabilities();
+    }
+    apply(value) {
+        let constraint = {};
+        constraint[this.name] = value;
+        let constraints = { advanced: [constraint] };
+        return this.track.applyConstraints(constraints);
+    }
+    value() {
+        let settings = this.track.getSettings();
+        if (this.name in settings) {
+            let settingValue = settings[this.name];
+            return settingValue;
+        }
+        return null;
+    }
+}
+class AbstractRangeCameraCapability extends AbstractCameraCapability {
+    constructor(name, track) {
+        super(name, track);
+    }
+    min() {
+        return this.getCapabilities().min;
+    }
+    max() {
+        return this.getCapabilities().max;
+    }
+    step() {
+        return this.getCapabilities().step;
+    }
+    apply(value) {
+        let constraint = {};
+        constraint[this.name] = value;
+        let constraints = { advanced: [constraint] };
+        return this.track.applyConstraints(constraints);
+    }
+    getCapabilities() {
+        this.failIfNotSupported();
+        let capabilities = this.track.getCapabilities();
+        let capability = capabilities[this.name];
+        return {
+            min: capability.min,
+            max: capability.max,
+            step: capability.step,
+        };
+    }
+    failIfNotSupported() {
+        if (!this.isSupported()) {
+            throw new Error(`${this.name} capability not supported`);
+        }
+    }
+}
+class ZoomFeatureImpl extends AbstractRangeCameraCapability {
+    constructor(track) {
+        super("zoom", track);
+    }
+}
+class TorchFeatureImpl extends AbstractCameraCapability {
+    constructor(track) {
+        super("torch", track);
+    }
+}
+class CameraCapabilitiesImpl {
+    constructor(track) {
+        this.track = track;
+    }
+    zoomFeature() {
+        return new ZoomFeatureImpl(this.track);
+    }
+    torchFeature() {
+        return new TorchFeatureImpl(this.track);
+    }
+}
+class RenderedCameraImpl {
+    constructor(parentElement, mediaStream, callbacks) {
+        this.isClosed = false;
+        this.parentElement = parentElement;
+        this.mediaStream = mediaStream;
+        this.callbacks = callbacks;
+        this.surface = this.createVideoElement(this.parentElement.clientWidth);
+        parentElement.append(this.surface);
+    }
+    createVideoElement(width) {
+        const videoElement = document.createElement("video");
+        videoElement.style.width = `${width}px`;
+        videoElement.style.display = "block";
+        videoElement.muted = true;
+        videoElement.setAttribute("muted", "true");
+        videoElement.playsInline = true;
+        return videoElement;
+    }
+    setupSurface() {
+        this.surface.onabort = () => {
+            throw "RenderedCameraImpl video surface onabort() called";
+        };
+        this.surface.onerror = () => {
+            throw "RenderedCameraImpl video surface onerror() called";
+        };
+        let onVideoStart = () => {
+            const videoWidth = this.surface.clientWidth;
+            const videoHeight = this.surface.clientHeight;
+            this.callbacks.onRenderSurfaceReady(videoWidth, videoHeight);
+            this.surface.removeEventListener("playing", onVideoStart);
+        };
+        this.surface.addEventListener("playing", onVideoStart);
+        this.surface.srcObject = this.mediaStream;
+        this.surface.play();
+    }
+    static create(parentElement, mediaStream, options, callbacks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let renderedCamera = new RenderedCameraImpl(parentElement, mediaStream, callbacks);
+            if (options.aspectRatio) {
+                let aspectRatioConstraint = {
+                    aspectRatio: options.aspectRatio
+                };
+                yield renderedCamera.getFirstTrackOrFail().applyConstraints(aspectRatioConstraint);
+            }
+            renderedCamera.setupSurface();
+            return renderedCamera;
+        });
+    }
+    failIfClosed() {
+        if (this.isClosed) {
+            throw "The RenderedCamera has already been closed.";
+        }
+    }
+    getFirstTrackOrFail() {
+        this.failIfClosed();
+        if (this.mediaStream.getVideoTracks().length === 0) {
+            throw "No video tracks found";
+        }
+        return this.mediaStream.getVideoTracks()[0];
+    }
+    pause() {
+        this.failIfClosed();
+        this.surface.pause();
+    }
+    resume(onResumeCallback) {
+        this.failIfClosed();
+        let $this = this;
+        const onVideoResume = () => {
+            setTimeout(onResumeCallback, 200);
+            $this.surface.removeEventListener("playing", onVideoResume);
+        };
+        this.surface.addEventListener("playing", onVideoResume);
+        this.surface.play();
+    }
+    isPaused() {
+        this.failIfClosed();
+        return this.surface.paused;
+    }
+    getSurface() {
+        this.failIfClosed();
+        return this.surface;
+    }
+    getRunningTrackCapabilities() {
+        return this.getFirstTrackOrFail().getCapabilities();
+    }
+    getRunningTrackSettings() {
+        return this.getFirstTrackOrFail().getSettings();
+    }
+    applyVideoConstraints(constraints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ("aspectRatio" in constraints) {
+                throw "Changing 'aspectRatio' in run-time is not yet supported.";
+            }
+            return this.getFirstTrackOrFail().applyConstraints(constraints);
+        });
+    }
+    close() {
+        if (this.isClosed) {
+            return Promise.resolve();
+        }
+        let $this = this;
+        return new Promise((resolve, _) => {
+            let tracks = $this.mediaStream.getVideoTracks();
+            const tracksToClose = tracks.length;
+            var tracksClosed = 0;
+            $this.mediaStream.getVideoTracks().forEach((videoTrack) => {
+                $this.mediaStream.removeTrack(videoTrack);
+                videoTrack.stop();
+                ++tracksClosed;
+                if (tracksClosed >= tracksToClose) {
+                    $this.isClosed = true;
+                    $this.parentElement.removeChild($this.surface);
+                    resolve();
+                }
+            });
+        });
+    }
+    getCapabilities() {
+        return new CameraCapabilitiesImpl(this.getFirstTrackOrFail());
+    }
+}
+export class CameraImpl {
+    constructor(mediaStream) {
+        this.mediaStream = mediaStream;
+    }
+    render(parentElement, options, callbacks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return RenderedCameraImpl.create(parentElement, this.mediaStream, options, callbacks);
+        });
+    }
+    static create(videoConstraints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!navigator.mediaDevices) {
+                throw "navigator.mediaDevices not supported";
+            }
+            let constraints = {
+                audio: false,
+                video: videoConstraints
+            };
+            let mediaStream = yield navigator.mediaDevices.getUserMedia(constraints);
+            return new CameraImpl(mediaStream);
+        });
+    }
+}
+//# sourceMappingURL=core-impl.js.map

node_modules/html5-qrcode/es2015/camera/core.d.ts

@@ -0,0 +1,41 @@
+export interface CameraDevice {
+    id: string;
+    label: string;
+}
+export interface CameraCapability<T> {
+    isSupported(): boolean;
+    apply(value: T): Promise<void>;
+    value(): T | null;
+}
+export interface RangeCameraCapability extends CameraCapability<number> {
+    min(): number;
+    max(): number;
+    step(): number;
+}
+export interface BooleanCameraCapability extends CameraCapability<boolean> {
+}
+export interface CameraCapabilities {
+    zoomFeature(): RangeCameraCapability;
+    torchFeature(): BooleanCameraCapability;
+}
+export type OnRenderSurfaceReady = (viewfinderWidth: number, viewfinderHeight: number) => void;
+export interface RenderingCallbacks {
+    onRenderSurfaceReady: OnRenderSurfaceReady;
+}
+export interface RenderedCamera {
+    getSurface(): HTMLVideoElement;
+    pause(): void;
+    resume(onResumeCallback: () => void): void;
+    isPaused(): boolean;
+    close(): Promise<void>;
+    getRunningTrackCapabilities(): MediaTrackCapabilities;
+    getRunningTrackSettings(): MediaTrackSettings;
+    applyVideoConstraints(constraints: MediaTrackConstraints): Promise<void>;
+    getCapabilities(): CameraCapabilities;
+}
+export interface CameraRenderingOptions {
+    aspectRatio?: number;
+}
+export interface Camera {
+    render(parentElement: HTMLElement, options: CameraRenderingOptions, callbacks: RenderingCallbacks): Promise<RenderedCamera>;
+}

node_modules/html5-qrcode/es2015/camera/core.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=core.js.map

node_modules/html5-qrcode/es2015/camera/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/camera/core.ts"],"names":[],"mappings":""}

node_modules/html5-qrcode/es2015/camera/factories.d.ts

@@ -0,0 +1,6 @@
+import { Camera } from "./core";
+export declare class CameraFactory {
+    static failIfNotSupported(): Promise<CameraFactory>;
+    private constructor();
+    create(videoConstraints: MediaTrackConstraints): Promise<Camera>;
+}

node_modules/html5-qrcode/es2015/camera/factories.js

@@ -0,0 +1,27 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { CameraImpl } from "./core-impl";
+export class CameraFactory {
+    static failIfNotSupported() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!navigator.mediaDevices) {
+                throw "navigator.mediaDevices not supported";
+            }
+            return new CameraFactory();
+        });
+    }
+    constructor() { }
+    create(videoConstraints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return CameraImpl.create(videoConstraints);
+        });
+    }
+}
+//# sourceMappingURL=factories.js.map

node_modules/html5-qrcode/es2015/camera/factories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.js","sourceRoot":"","sources":["../../../src/camera/factories.ts"],"names":[],"mappings":";;;;;;;;;AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,MAAM,OAAO,aAAa;IAMf,MAAM,CAAO,kBAAkB;;YAClC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE;gBACzB,MAAM,sCAAsC,CAAC;aAChD;YAED,OAAO,IAAI,aAAa,EAAE,CAAC;QAC/B,CAAC;KAAA;IAED,gBAAqC,CAAC;IAGzB,MAAM,CAAC,gBAAuC;;YAEvD,OAAO,UAAU,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAC/C,CAAC;KAAA;CACJ"}

node_modules/html5-qrcode/es2015/camera/permissions.d.ts

@@ -0,0 +1,3 @@
+export declare class CameraPermissions {
+    static hasPermissions(): Promise<boolean>;
+}

node_modules/html5-qrcode/es2015/camera/permissions.js

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class CameraPermissions {
+    static hasPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let devices = yield navigator.mediaDevices.enumerateDevices();
+            for (const device of devices) {
+                if (device.kind === "videoinput" && device.label) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+}
+//# sourceMappingURL=permissions.js.map

node_modules/html5-qrcode/es2015/camera/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../../../src/camera/permissions.ts"],"names":[],"mappings":";;;;;;;;;AAYC,MAAM,OAAO,iBAAiB;IAMpB,MAAM,CAAO,cAAc;;YAIhC,IAAI,OAAO,GAAG,MAAM,SAAS,CAAC,YAAY,CAAC,gBAAgB,EAAE,CAAC;YAC9D,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE;gBAG5B,IAAG,MAAM,CAAC,IAAI,KAAK,YAAY,IAAI,MAAM,CAAC,KAAK,EAAE;oBAC/C,OAAO,IAAI,CAAC;iBACb;aACF;YAED,OAAO,KAAK,CAAC;QACf,CAAC;KAAA;CACJ"}

node_modules/html5-qrcode/es2015/camera/retriever.d.ts

@@ -0,0 +1,8 @@
+import { CameraDevice } from "./core";
+export declare class CameraRetriever {
+    static retrieve(): Promise<Array<CameraDevice>>;
+    private static rejectWithError;
+    private static isHttpsOrLocalhost;
+    private static getCamerasFromMediaDevices;
+    private static getCamerasFromMediaStreamTrack;
+}

node_modules/html5-qrcode/es2015/camera/retriever.js

@@ -0,0 +1,80 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Html5QrcodeStrings } from "../strings";
+export class CameraRetriever {
+    static retrieve() {
+        if (navigator.mediaDevices) {
+            return CameraRetriever.getCamerasFromMediaDevices();
+        }
+        var mst = MediaStreamTrack;
+        if (MediaStreamTrack && mst.getSources) {
+            return CameraRetriever.getCamerasFromMediaStreamTrack();
+        }
+        return CameraRetriever.rejectWithError();
+    }
+    static rejectWithError() {
+        let errorMessage = Html5QrcodeStrings.unableToQuerySupportedDevices();
+        if (!CameraRetriever.isHttpsOrLocalhost()) {
+            errorMessage = Html5QrcodeStrings.insecureContextCameraQueryError();
+        }
+        return Promise.reject(errorMessage);
+    }
+    static isHttpsOrLocalhost() {
+        if (location.protocol === "https:") {
+            return true;
+        }
+        const host = location.host.split(":")[0];
+        return host === "127.0.0.1" || host === "localhost";
+    }
+    static getCamerasFromMediaDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const closeActiveStreams = (stream) => {
+                const tracks = stream.getVideoTracks();
+                for (const track of tracks) {
+                    track.enabled = false;
+                    track.stop();
+                    stream.removeTrack(track);
+                }
+            };
+            let mediaStream = yield navigator.mediaDevices.getUserMedia({ audio: false, video: true });
+            let devices = yield navigator.mediaDevices.enumerateDevices();
+            let results = [];
+            for (const device of devices) {
+                if (device.kind === "videoinput") {
+                    results.push({
+                        id: device.deviceId,
+                        label: device.label
+                    });
+                }
+            }
+            closeActiveStreams(mediaStream);
+            return results;
+        });
+    }
+    static getCamerasFromMediaStreamTrack() {
+        return new Promise((resolve, _) => {
+            const callback = (sourceInfos) => {
+                const results = [];
+                for (const sourceInfo of sourceInfos) {
+                    if (sourceInfo.kind === "video") {
+                        results.push({
+                            id: sourceInfo.id,
+                            label: sourceInfo.label
+                        });
+                    }
+                }
+                resolve(results);
+            };
+            var mst = MediaStreamTrack;
+            mst.getSources(callback);
+        });
+    }
+}
+//# sourceMappingURL=retriever.js.map

node_modules/html5-qrcode/es2015/camera/retriever.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retriever.js","sourceRoot":"","sources":["../../../src/camera/retriever.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/code-decoder.d.ts

@@ -0,0 +1,16 @@
+import { QrcodeResult, Html5QrcodeSupportedFormats, Logger, RobustQrcodeDecoderAsync } from "./core";
+export declare class Html5QrcodeShim implements RobustQrcodeDecoderAsync {
+    private verbose;
+    private primaryDecoder;
+    private secondaryDecoder;
+    private readonly EXECUTIONS_TO_REPORT_PERFORMANCE;
+    private executions;
+    private executionResults;
+    private wasPrimaryDecoderUsedInLastDecode;
+    constructor(requestedFormats: Array<Html5QrcodeSupportedFormats>, useBarCodeDetectorIfSupported: boolean, verbose: boolean, logger: Logger);
+    decodeAsync(canvas: HTMLCanvasElement): Promise<QrcodeResult>;
+    decodeRobustlyAsync(canvas: HTMLCanvasElement): Promise<QrcodeResult>;
+    private getDecoder;
+    private possiblyLogPerformance;
+    possiblyFlushPerformanceReport(): void;
+}

node_modules/html5-qrcode/es2015/code-decoder.js

@@ -0,0 +1,90 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ZXingHtml5QrcodeDecoder } from "./zxing-html5-qrcode-decoder";
+import { BarcodeDetectorDelegate } from "./native-bar-code-detector";
+export class Html5QrcodeShim {
+    constructor(requestedFormats, useBarCodeDetectorIfSupported, verbose, logger) {
+        this.EXECUTIONS_TO_REPORT_PERFORMANCE = 100;
+        this.executions = 0;
+        this.executionResults = [];
+        this.wasPrimaryDecoderUsedInLastDecode = false;
+        this.verbose = verbose;
+        if (useBarCodeDetectorIfSupported
+            && BarcodeDetectorDelegate.isSupported()) {
+            this.primaryDecoder = new BarcodeDetectorDelegate(requestedFormats, verbose, logger);
+            this.secondaryDecoder = new ZXingHtml5QrcodeDecoder(requestedFormats, verbose, logger);
+        }
+        else {
+            this.primaryDecoder = new ZXingHtml5QrcodeDecoder(requestedFormats, verbose, logger);
+        }
+    }
+    decodeAsync(canvas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let startTime = performance.now();
+            try {
+                return yield this.getDecoder().decodeAsync(canvas);
+            }
+            finally {
+                this.possiblyLogPerformance(startTime);
+            }
+        });
+    }
+    decodeRobustlyAsync(canvas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let startTime = performance.now();
+            try {
+                return yield this.primaryDecoder.decodeAsync(canvas);
+            }
+            catch (error) {
+                if (this.secondaryDecoder) {
+                    return this.secondaryDecoder.decodeAsync(canvas);
+                }
+                throw error;
+            }
+            finally {
+                this.possiblyLogPerformance(startTime);
+            }
+        });
+    }
+    getDecoder() {
+        if (!this.secondaryDecoder) {
+            return this.primaryDecoder;
+        }
+        if (this.wasPrimaryDecoderUsedInLastDecode === false) {
+            this.wasPrimaryDecoderUsedInLastDecode = true;
+            return this.primaryDecoder;
+        }
+        this.wasPrimaryDecoderUsedInLastDecode = false;
+        return this.secondaryDecoder;
+    }
+    possiblyLogPerformance(startTime) {
+        if (!this.verbose) {
+            return;
+        }
+        let executionTime = performance.now() - startTime;
+        this.executionResults.push(executionTime);
+        this.executions++;
+        this.possiblyFlushPerformanceReport();
+    }
+    possiblyFlushPerformanceReport() {
+        if (this.executions < this.EXECUTIONS_TO_REPORT_PERFORMANCE) {
+            return;
+        }
+        let sum = 0;
+        for (let executionTime of this.executionResults) {
+            sum += executionTime;
+        }
+        let mean = sum / this.executionResults.length;
+        console.log(`${mean} ms for ${this.executionResults.length} last runs.`);
+        this.executions = 0;
+        this.executionResults = [];
+    }
+}
+//# sourceMappingURL=code-decoder.js.map

node_modules/html5-qrcode/es2015/code-decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-decoder.js","sourceRoot":"","sources":["../../src/code-decoder.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/core.d.ts

@@ -0,0 +1,105 @@
+export declare enum Html5QrcodeSupportedFormats {
+    QR_CODE = 0,
+    AZTEC = 1,
+    CODABAR = 2,
+    CODE_39 = 3,
+    CODE_93 = 4,
+    CODE_128 = 5,
+    DATA_MATRIX = 6,
+    MAXICODE = 7,
+    ITF = 8,
+    EAN_13 = 9,
+    EAN_8 = 10,
+    PDF_417 = 11,
+    RSS_14 = 12,
+    RSS_EXPANDED = 13,
+    UPC_A = 14,
+    UPC_E = 15,
+    UPC_EAN_EXTENSION = 16
+}
+export declare enum DecodedTextType {
+    UNKNOWN = 0,
+    URL = 1
+}
+export declare function isValidHtml5QrcodeSupportedFormats(format: any): boolean;
+export declare enum Html5QrcodeScanType {
+    SCAN_TYPE_CAMERA = 0,
+    SCAN_TYPE_FILE = 1
+}
+export declare class Html5QrcodeConstants {
+    static GITHUB_PROJECT_URL: string;
+    static SCAN_DEFAULT_FPS: number;
+    static DEFAULT_DISABLE_FLIP: boolean;
+    static DEFAULT_REMEMBER_LAST_CAMERA_USED: boolean;
+    static DEFAULT_SUPPORTED_SCAN_TYPE: Html5QrcodeScanType[];
+}
+export interface QrDimensions {
+    width: number;
+    height: number;
+}
+export type QrDimensionFunction = (viewfinderWidth: number, viewfinderHeight: number) => QrDimensions;
+export interface QrBounds extends QrDimensions {
+    x: number;
+    y: number;
+}
+export declare class QrcodeResultFormat {
+    readonly format: Html5QrcodeSupportedFormats;
+    readonly formatName: string;
+    private constructor();
+    toString(): string;
+    static create(format: Html5QrcodeSupportedFormats): QrcodeResultFormat;
+}
+export interface QrcodeResultDebugData {
+    decoderName?: string;
+}
+export interface QrcodeResult {
+    text: string;
+    format?: QrcodeResultFormat;
+    bounds?: QrBounds;
+    decodedTextType?: DecodedTextType;
+    debugData?: QrcodeResultDebugData;
+}
+export interface Html5QrcodeResult {
+    decodedText: string;
+    result: QrcodeResult;
+}
+export declare class Html5QrcodeResultFactory {
+    static createFromText(decodedText: string): Html5QrcodeResult;
+    static createFromQrcodeResult(qrcodeResult: QrcodeResult): Html5QrcodeResult;
+}
+export declare enum Html5QrcodeErrorTypes {
+    UNKWOWN_ERROR = 0,
+    IMPLEMENTATION_ERROR = 1,
+    NO_CODE_FOUND_ERROR = 2
+}
+export interface Html5QrcodeError {
+    errorMessage: string;
+    type: Html5QrcodeErrorTypes;
+}
+export declare class Html5QrcodeErrorFactory {
+    static createFrom(error: any): Html5QrcodeError;
+}
+export type QrcodeSuccessCallback = (decodedText: string, result: Html5QrcodeResult) => void;
+export type QrcodeErrorCallback = (errorMessage: string, error: Html5QrcodeError) => void;
+export interface QrcodeDecoderAsync {
+    decodeAsync(canvas: HTMLCanvasElement): Promise<QrcodeResult>;
+}
+export interface RobustQrcodeDecoderAsync extends QrcodeDecoderAsync {
+    decodeRobustlyAsync(canvas: HTMLCanvasElement): Promise<QrcodeResult>;
+}
+export interface Logger {
+    log(message: string): void;
+    warn(message: string): void;
+    logError(message: string, isExperimental?: boolean): void;
+    logErrors(errors: Array<any>): void;
+}
+export declare class BaseLoggger implements Logger {
+    private verbose;
+    constructor(verbose: boolean);
+    log(message: string): void;
+    warn(message: string): void;
+    logError(message: string, isExperimental?: boolean): void;
+    logErrors(errors: Array<any>): void;
+}
+export declare function isNullOrUndefined(obj?: any): boolean;
+export declare function clip(value: number, minValue: number, maxValue: number): number;

node_modules/html5-qrcode/es2015/core.js

@@ -0,0 +1,149 @@
+export var Html5QrcodeSupportedFormats;
+(function (Html5QrcodeSupportedFormats) {
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["QR_CODE"] = 0] = "QR_CODE";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["AZTEC"] = 1] = "AZTEC";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["CODABAR"] = 2] = "CODABAR";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["CODE_39"] = 3] = "CODE_39";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["CODE_93"] = 4] = "CODE_93";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["CODE_128"] = 5] = "CODE_128";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["DATA_MATRIX"] = 6] = "DATA_MATRIX";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["MAXICODE"] = 7] = "MAXICODE";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["ITF"] = 8] = "ITF";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["EAN_13"] = 9] = "EAN_13";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["EAN_8"] = 10] = "EAN_8";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["PDF_417"] = 11] = "PDF_417";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["RSS_14"] = 12] = "RSS_14";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["RSS_EXPANDED"] = 13] = "RSS_EXPANDED";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["UPC_A"] = 14] = "UPC_A";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["UPC_E"] = 15] = "UPC_E";
+    Html5QrcodeSupportedFormats[Html5QrcodeSupportedFormats["UPC_EAN_EXTENSION"] = 16] = "UPC_EAN_EXTENSION";
+})(Html5QrcodeSupportedFormats || (Html5QrcodeSupportedFormats = {}));
+const html5QrcodeSupportedFormatsTextMap = new Map([
+    [Html5QrcodeSupportedFormats.QR_CODE, "QR_CODE"],
+    [Html5QrcodeSupportedFormats.AZTEC, "AZTEC"],
+    [Html5QrcodeSupportedFormats.CODABAR, "CODABAR"],
+    [Html5QrcodeSupportedFormats.CODE_39, "CODE_39"],
+    [Html5QrcodeSupportedFormats.CODE_93, "CODE_93"],
+    [Html5QrcodeSupportedFormats.CODE_128, "CODE_128"],
+    [Html5QrcodeSupportedFormats.DATA_MATRIX, "DATA_MATRIX"],
+    [Html5QrcodeSupportedFormats.MAXICODE, "MAXICODE"],
+    [Html5QrcodeSupportedFormats.ITF, "ITF"],
+    [Html5QrcodeSupportedFormats.EAN_13, "EAN_13"],
+    [Html5QrcodeSupportedFormats.EAN_8, "EAN_8"],
+    [Html5QrcodeSupportedFormats.PDF_417, "PDF_417"],
+    [Html5QrcodeSupportedFormats.RSS_14, "RSS_14"],
+    [Html5QrcodeSupportedFormats.RSS_EXPANDED, "RSS_EXPANDED"],
+    [Html5QrcodeSupportedFormats.UPC_A, "UPC_A"],
+    [Html5QrcodeSupportedFormats.UPC_E, "UPC_E"],
+    [Html5QrcodeSupportedFormats.UPC_EAN_EXTENSION, "UPC_EAN_EXTENSION"]
+]);
+export var DecodedTextType;
+(function (DecodedTextType) {
+    DecodedTextType[DecodedTextType["UNKNOWN"] = 0] = "UNKNOWN";
+    DecodedTextType[DecodedTextType["URL"] = 1] = "URL";
+})(DecodedTextType || (DecodedTextType = {}));
+export function isValidHtml5QrcodeSupportedFormats(format) {
+    return Object.values(Html5QrcodeSupportedFormats).includes(format);
+}
+export var Html5QrcodeScanType;
+(function (Html5QrcodeScanType) {
+    Html5QrcodeScanType[Html5QrcodeScanType["SCAN_TYPE_CAMERA"] = 0] = "SCAN_TYPE_CAMERA";
+    Html5QrcodeScanType[Html5QrcodeScanType["SCAN_TYPE_FILE"] = 1] = "SCAN_TYPE_FILE";
+})(Html5QrcodeScanType || (Html5QrcodeScanType = {}));
+export class Html5QrcodeConstants {
+}
+Html5QrcodeConstants.GITHUB_PROJECT_URL = "https://github.com/mebjas/html5-qrcode";
+Html5QrcodeConstants.SCAN_DEFAULT_FPS = 2;
+Html5QrcodeConstants.DEFAULT_DISABLE_FLIP = false;
+Html5QrcodeConstants.DEFAULT_REMEMBER_LAST_CAMERA_USED = true;
+Html5QrcodeConstants.DEFAULT_SUPPORTED_SCAN_TYPE = [
+    Html5QrcodeScanType.SCAN_TYPE_CAMERA,
+    Html5QrcodeScanType.SCAN_TYPE_FILE
+];
+export class QrcodeResultFormat {
+    constructor(format, formatName) {
+        this.format = format;
+        this.formatName = formatName;
+    }
+    toString() {
+        return this.formatName;
+    }
+    static create(format) {
+        if (!html5QrcodeSupportedFormatsTextMap.has(format)) {
+            throw `${format} not in html5QrcodeSupportedFormatsTextMap`;
+        }
+        return new QrcodeResultFormat(format, html5QrcodeSupportedFormatsTextMap.get(format));
+    }
+}
+export class Html5QrcodeResultFactory {
+    static createFromText(decodedText) {
+        let qrcodeResult = {
+            text: decodedText
+        };
+        return {
+            decodedText: decodedText,
+            result: qrcodeResult
+        };
+    }
+    static createFromQrcodeResult(qrcodeResult) {
+        return {
+            decodedText: qrcodeResult.text,
+            result: qrcodeResult
+        };
+    }
+}
+export var Html5QrcodeErrorTypes;
+(function (Html5QrcodeErrorTypes) {
+    Html5QrcodeErrorTypes[Html5QrcodeErrorTypes["UNKWOWN_ERROR"] = 0] = "UNKWOWN_ERROR";
+    Html5QrcodeErrorTypes[Html5QrcodeErrorTypes["IMPLEMENTATION_ERROR"] = 1] = "IMPLEMENTATION_ERROR";
+    Html5QrcodeErrorTypes[Html5QrcodeErrorTypes["NO_CODE_FOUND_ERROR"] = 2] = "NO_CODE_FOUND_ERROR";
+})(Html5QrcodeErrorTypes || (Html5QrcodeErrorTypes = {}));
+export class Html5QrcodeErrorFactory {
+    static createFrom(error) {
+        return {
+            errorMessage: error,
+            type: Html5QrcodeErrorTypes.UNKWOWN_ERROR
+        };
+    }
+}
+export class BaseLoggger {
+    constructor(verbose) {
+        this.verbose = verbose;
+    }
+    log(message) {
+        if (this.verbose) {
+            console.log(message);
+        }
+    }
+    warn(message) {
+        if (this.verbose) {
+            console.warn(message);
+        }
+    }
+    logError(message, isExperimental) {
+        if (this.verbose || isExperimental === true) {
+            console.error(message);
+        }
+    }
+    logErrors(errors) {
+        if (errors.length === 0) {
+            throw "Logger#logError called without arguments";
+        }
+        if (this.verbose) {
+            console.error(errors);
+        }
+    }
+}
+export function isNullOrUndefined(obj) {
+    return (typeof obj === "undefined") || obj === null;
+}
+export function clip(value, minValue, maxValue) {
+    if (value > maxValue) {
+        return maxValue;
+    }
+    if (value < minValue) {
+        return minValue;
+    }
+    return value;
+}
+//# sourceMappingURL=core.js.map

node_modules/html5-qrcode/es2015/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../src/core.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/experimental-features.d.ts

@@ -0,0 +1,3 @@
+export interface ExperimentalFeaturesConfig {
+    useBarCodeDetectorIfSupported?: boolean | undefined;
+}

node_modules/html5-qrcode/es2015/experimental-features.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=experimental-features.js.map

node_modules/html5-qrcode/es2015/experimental-features.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"experimental-features.js","sourceRoot":"","sources":["../../src/experimental-features.ts"],"names":[],"mappings":""}

node_modules/html5-qrcode/es2015/html5-qrcode-scanner.d.ts

@@ -0,0 +1,67 @@
+import { Html5QrcodeScanType, QrcodeSuccessCallback, QrcodeErrorCallback } from "./core";
+import { Html5QrcodeConfigs, Html5QrcodeCameraScanConfig } from "./html5-qrcode";
+import { Html5QrcodeScannerState } from "./state-manager";
+export interface Html5QrcodeScannerConfig extends Html5QrcodeCameraScanConfig, Html5QrcodeConfigs {
+    rememberLastUsedCamera?: boolean | undefined;
+    supportedScanTypes?: Array<Html5QrcodeScanType> | [];
+    showTorchButtonIfSupported?: boolean | undefined;
+    showZoomSliderIfSupported?: boolean | undefined;
+    defaultZoomValueIfSupported?: number | undefined;
+}
+export declare class Html5QrcodeScanner {
+    private elementId;
+    private config;
+    private verbose;
+    private currentScanType;
+    private sectionSwapAllowed;
+    private persistedDataManager;
+    private scanTypeSelector;
+    private logger;
+    private html5Qrcode;
+    private qrCodeSuccessCallback;
+    private qrCodeErrorCallback;
+    private lastMatchFound;
+    private cameraScanImage;
+    private fileScanImage;
+    private fileSelectionUi;
+    constructor(elementId: string, config: Html5QrcodeScannerConfig | undefined, verbose: boolean | undefined);
+    render(qrCodeSuccessCallback: QrcodeSuccessCallback, qrCodeErrorCallback: QrcodeErrorCallback | undefined): void;
+    pause(shouldPauseVideo?: boolean): void;
+    resume(): void;
+    getState(): Html5QrcodeScannerState;
+    clear(): Promise<void>;
+    getRunningTrackCapabilities(): MediaTrackCapabilities;
+    getRunningTrackSettings(): MediaTrackSettings;
+    applyVideoConstraints(videoConstaints: MediaTrackConstraints): Promise<void>;
+    private getHtml5QrcodeOrFail;
+    private createConfig;
+    private createBasicLayout;
+    private resetBasicLayout;
+    private setupInitialDashboard;
+    private createHeader;
+    private createSection;
+    private createCameraListUi;
+    private createPermissionButton;
+    private createPermissionsUi;
+    private createSectionControlPanel;
+    private renderFileScanUi;
+    private renderCameraSelection;
+    private createSectionSwap;
+    private startCameraScanIfPermissionExistsOnSwap;
+    private resetHeaderMessage;
+    private setHeaderMessage;
+    private showHideScanTypeSwapLink;
+    private insertCameraScanImageToScanRegion;
+    private insertFileScanImageToScanRegion;
+    private clearScanRegion;
+    private getDashboardSectionId;
+    private getDashboardSectionCameraScanRegionId;
+    private getDashboardSectionSwapLinkId;
+    private getScanRegionId;
+    private getDashboardId;
+    private getHeaderMessageContainerId;
+    private getCameraPermissionButtonId;
+    private getCameraScanRegion;
+    private getDashboardSectionSwapLink;
+    private getHeaderMessageDiv;
+}

node_modules/html5-qrcode/es2015/html5-qrcode-scanner.js

@@ -0,0 +1,652 @@
+import { Html5QrcodeConstants, Html5QrcodeScanType, Html5QrcodeErrorFactory, BaseLoggger, isNullOrUndefined, clip, } from "./core";
+import { Html5Qrcode, } from "./html5-qrcode";
+import { Html5QrcodeScannerStrings, } from "./strings";
+import { ASSET_FILE_SCAN, ASSET_CAMERA_SCAN, } from "./image-assets";
+import { PersistedDataManager } from "./storage";
+import { LibraryInfoContainer } from "./ui";
+import { CameraPermissions } from "./camera/permissions";
+import { ScanTypeSelector } from "./ui/scanner/scan-type-selector";
+import { TorchButton } from "./ui/scanner/torch-button";
+import { FileSelectionUi } from "./ui/scanner/file-selection-ui";
+import { BaseUiElementFactory, PublicUiElementIdAndClasses } from "./ui/scanner/base";
+import { CameraSelectionUi } from "./ui/scanner/camera-selection-ui";
+import { CameraZoomUi } from "./ui/scanner/camera-zoom-ui";
+var Html5QrcodeScannerStatus;
+(function (Html5QrcodeScannerStatus) {
+    Html5QrcodeScannerStatus[Html5QrcodeScannerStatus["STATUS_DEFAULT"] = 0] = "STATUS_DEFAULT";
+    Html5QrcodeScannerStatus[Html5QrcodeScannerStatus["STATUS_SUCCESS"] = 1] = "STATUS_SUCCESS";
+    Html5QrcodeScannerStatus[Html5QrcodeScannerStatus["STATUS_WARNING"] = 2] = "STATUS_WARNING";
+    Html5QrcodeScannerStatus[Html5QrcodeScannerStatus["STATUS_REQUESTING_PERMISSION"] = 3] = "STATUS_REQUESTING_PERMISSION";
+})(Html5QrcodeScannerStatus || (Html5QrcodeScannerStatus = {}));
+function toHtml5QrcodeCameraScanConfig(config) {
+    return {
+        fps: config.fps,
+        qrbox: config.qrbox,
+        aspectRatio: config.aspectRatio,
+        disableFlip: config.disableFlip,
+        videoConstraints: config.videoConstraints
+    };
+}
+function toHtml5QrcodeFullConfig(config, verbose) {
+    return {
+        formatsToSupport: config.formatsToSupport,
+        useBarCodeDetectorIfSupported: config.useBarCodeDetectorIfSupported,
+        experimentalFeatures: config.experimentalFeatures,
+        verbose: verbose
+    };
+}
+export class Html5QrcodeScanner {
+    constructor(elementId, config, verbose) {
+        this.lastMatchFound = null;
+        this.cameraScanImage = null;
+        this.fileScanImage = null;
+        this.fileSelectionUi = null;
+        this.elementId = elementId;
+        this.config = this.createConfig(config);
+        this.verbose = verbose === true;
+        if (!document.getElementById(elementId)) {
+            throw `HTML Element with id=${elementId} not found`;
+        }
+        this.scanTypeSelector = new ScanTypeSelector(this.config.supportedScanTypes);
+        this.currentScanType = this.scanTypeSelector.getDefaultScanType();
+        this.sectionSwapAllowed = true;
+        this.logger = new BaseLoggger(this.verbose);
+        this.persistedDataManager = new PersistedDataManager();
+        if (config.rememberLastUsedCamera !== true) {
+            this.persistedDataManager.reset();
+        }
+    }
+    render(qrCodeSuccessCallback, qrCodeErrorCallback) {
+        this.lastMatchFound = null;
+        this.qrCodeSuccessCallback
+            = (decodedText, result) => {
+                if (qrCodeSuccessCallback) {
+                    qrCodeSuccessCallback(decodedText, result);
+                }
+                else {
+                    if (this.lastMatchFound === decodedText) {
+                        return;
+                    }
+                    this.lastMatchFound = decodedText;
+                    this.setHeaderMessage(Html5QrcodeScannerStrings.lastMatch(decodedText), Html5QrcodeScannerStatus.STATUS_SUCCESS);
+                }
+            };
+        this.qrCodeErrorCallback =
+            (errorMessage, error) => {
+                if (qrCodeErrorCallback) {
+                    qrCodeErrorCallback(errorMessage, error);
+                }
+            };
+        const container = document.getElementById(this.elementId);
+        if (!container) {
+            throw `HTML Element with id=${this.elementId} not found`;
+        }
+        container.innerHTML = "";
+        this.createBasicLayout(container);
+        this.html5Qrcode = new Html5Qrcode(this.getScanRegionId(), toHtml5QrcodeFullConfig(this.config, this.verbose));
+    }
+    pause(shouldPauseVideo) {
+        if (isNullOrUndefined(shouldPauseVideo) || shouldPauseVideo !== true) {
+            shouldPauseVideo = false;
+        }
+        this.getHtml5QrcodeOrFail().pause(shouldPauseVideo);
+    }
+    resume() {
+        this.getHtml5QrcodeOrFail().resume();
+    }
+    getState() {
+        return this.getHtml5QrcodeOrFail().getState();
+    }
+    clear() {
+        const emptyHtmlContainer = () => {
+            const mainContainer = document.getElementById(this.elementId);
+            if (mainContainer) {
+                mainContainer.innerHTML = "";
+                this.resetBasicLayout(mainContainer);
+            }
+        };
+        if (this.html5Qrcode) {
+            return new Promise((resolve, reject) => {
+                if (!this.html5Qrcode) {
+                    resolve();
+                    return;
+                }
+                if (this.html5Qrcode.isScanning) {
+                    this.html5Qrcode.stop().then((_) => {
+                        if (!this.html5Qrcode) {
+                            resolve();
+                            return;
+                        }
+                        this.html5Qrcode.clear();
+                        emptyHtmlContainer();
+                        resolve();
+                    }).catch((error) => {
+                        if (this.verbose) {
+                            this.logger.logError("Unable to stop qrcode scanner", error);
+                        }
+                        reject(error);
+                    });
+                }
+                else {
+                    this.html5Qrcode.clear();
+                    emptyHtmlContainer();
+                    resolve();
+                }
+            });
+        }
+        return Promise.resolve();
+    }
+    getRunningTrackCapabilities() {
+        return this.getHtml5QrcodeOrFail().getRunningTrackCapabilities();
+    }
+    getRunningTrackSettings() {
+        return this.getHtml5QrcodeOrFail().getRunningTrackSettings();
+    }
+    applyVideoConstraints(videoConstaints) {
+        return this.getHtml5QrcodeOrFail().applyVideoConstraints(videoConstaints);
+    }
+    getHtml5QrcodeOrFail() {
+        if (!this.html5Qrcode) {
+            throw "Code scanner not initialized.";
+        }
+        return this.html5Qrcode;
+    }
+    createConfig(config) {
+        if (config) {
+            if (!config.fps) {
+                config.fps = Html5QrcodeConstants.SCAN_DEFAULT_FPS;
+            }
+            if (config.rememberLastUsedCamera !== (!Html5QrcodeConstants.DEFAULT_REMEMBER_LAST_CAMERA_USED)) {
+                config.rememberLastUsedCamera
+                    = Html5QrcodeConstants.DEFAULT_REMEMBER_LAST_CAMERA_USED;
+            }
+            if (!config.supportedScanTypes) {
+                config.supportedScanTypes
+                    = Html5QrcodeConstants.DEFAULT_SUPPORTED_SCAN_TYPE;
+            }
+            return config;
+        }
+        return {
+            fps: Html5QrcodeConstants.SCAN_DEFAULT_FPS,
+            rememberLastUsedCamera: Html5QrcodeConstants.DEFAULT_REMEMBER_LAST_CAMERA_USED,
+            supportedScanTypes: Html5QrcodeConstants.DEFAULT_SUPPORTED_SCAN_TYPE
+        };
+    }
+    createBasicLayout(parent) {
+        parent.style.position = "relative";
+        parent.style.padding = "0px";
+        parent.style.border = "1px solid silver";
+        this.createHeader(parent);
+        const qrCodeScanRegion = document.createElement("div");
+        const scanRegionId = this.getScanRegionId();
+        qrCodeScanRegion.id = scanRegionId;
+        qrCodeScanRegion.style.width = "100%";
+        qrCodeScanRegion.style.minHeight = "100px";
+        qrCodeScanRegion.style.textAlign = "center";
+        parent.appendChild(qrCodeScanRegion);
+        if (ScanTypeSelector.isCameraScanType(this.currentScanType)) {
+            this.insertCameraScanImageToScanRegion();
+        }
+        else {
+            this.insertFileScanImageToScanRegion();
+        }
+        const qrCodeDashboard = document.createElement("div");
+        const dashboardId = this.getDashboardId();
+        qrCodeDashboard.id = dashboardId;
+        qrCodeDashboard.style.width = "100%";
+        parent.appendChild(qrCodeDashboard);
+        this.setupInitialDashboard(qrCodeDashboard);
+    }
+    resetBasicLayout(mainContainer) {
+        mainContainer.style.border = "none";
+    }
+    setupInitialDashboard(dashboard) {
+        this.createSection(dashboard);
+        this.createSectionControlPanel();
+        if (this.scanTypeSelector.hasMoreThanOneScanType()) {
+            this.createSectionSwap();
+        }
+    }
+    createHeader(dashboard) {
+        const header = document.createElement("div");
+        header.style.textAlign = "left";
+        header.style.margin = "0px";
+        dashboard.appendChild(header);
+        let libraryInfo = new LibraryInfoContainer();
+        libraryInfo.renderInto(header);
+        const headerMessageContainer = document.createElement("div");
+        headerMessageContainer.id = this.getHeaderMessageContainerId();
+        headerMessageContainer.style.display = "none";
+        headerMessageContainer.style.textAlign = "center";
+        headerMessageContainer.style.fontSize = "14px";
+        headerMessageContainer.style.padding = "2px 10px";
+        headerMessageContainer.style.margin = "4px";
+        headerMessageContainer.style.borderTop = "1px solid #f6f6f6";
+        header.appendChild(headerMessageContainer);
+    }
+    createSection(dashboard) {
+        const section = document.createElement("div");
+        section.id = this.getDashboardSectionId();
+        section.style.width = "100%";
+        section.style.padding = "10px 0px 10px 0px";
+        section.style.textAlign = "left";
+        dashboard.appendChild(section);
+    }
+    createCameraListUi(scpCameraScanRegion, requestPermissionContainer, requestPermissionButton) {
+        const $this = this;
+        $this.showHideScanTypeSwapLink(false);
+        $this.setHeaderMessage(Html5QrcodeScannerStrings.cameraPermissionRequesting());
+        const createPermissionButtonIfNotExists = () => {
+            if (!requestPermissionButton) {
+                $this.createPermissionButton(scpCameraScanRegion, requestPermissionContainer);
+            }
+        };
+        Html5Qrcode.getCameras().then((cameras) => {
+            $this.persistedDataManager.setHasPermission(true);
+            $this.showHideScanTypeSwapLink(true);
+            $this.resetHeaderMessage();
+            if (cameras && cameras.length > 0) {
+                scpCameraScanRegion.removeChild(requestPermissionContainer);
+                $this.renderCameraSelection(cameras);
+            }
+            else {
+                $this.setHeaderMessage(Html5QrcodeScannerStrings.noCameraFound(), Html5QrcodeScannerStatus.STATUS_WARNING);
+                createPermissionButtonIfNotExists();
+            }
+        }).catch((error) => {
+            $this.persistedDataManager.setHasPermission(false);
+            if (requestPermissionButton) {
+                requestPermissionButton.disabled = false;
+            }
+            else {
+                createPermissionButtonIfNotExists();
+            }
+            $this.setHeaderMessage(error, Html5QrcodeScannerStatus.STATUS_WARNING);
+            $this.showHideScanTypeSwapLink(true);
+        });
+    }
+    createPermissionButton(scpCameraScanRegion, requestPermissionContainer) {
+        const $this = this;
+        const requestPermissionButton = BaseUiElementFactory
+            .createElement("button", this.getCameraPermissionButtonId());
+        requestPermissionButton.innerText
+            = Html5QrcodeScannerStrings.cameraPermissionTitle();
+        requestPermissionButton.addEventListener("click", function () {
+            requestPermissionButton.disabled = true;
+            $this.createCameraListUi(scpCameraScanRegion, requestPermissionContainer, requestPermissionButton);
+        });
+        requestPermissionContainer.appendChild(requestPermissionButton);
+    }
+    createPermissionsUi(scpCameraScanRegion, requestPermissionContainer) {
+        const $this = this;
+        if (ScanTypeSelector.isCameraScanType(this.currentScanType)
+            && this.persistedDataManager.hasCameraPermissions()) {
+            CameraPermissions.hasPermissions().then((hasPermissions) => {
+                if (hasPermissions) {
+                    $this.createCameraListUi(scpCameraScanRegion, requestPermissionContainer);
+                }
+                else {
+                    $this.persistedDataManager.setHasPermission(false);
+                    $this.createPermissionButton(scpCameraScanRegion, requestPermissionContainer);
+                }
+            }).catch((_) => {
+                $this.persistedDataManager.setHasPermission(false);
+                $this.createPermissionButton(scpCameraScanRegion, requestPermissionContainer);
+            });
+            return;
+        }
+        this.createPermissionButton(scpCameraScanRegion, requestPermissionContainer);
+    }
+    createSectionControlPanel() {
+        const section = document.getElementById(this.getDashboardSectionId());
+        const sectionControlPanel = document.createElement("div");
+        section.appendChild(sectionControlPanel);
+        const scpCameraScanRegion = document.createElement("div");
+        scpCameraScanRegion.id = this.getDashboardSectionCameraScanRegionId();
+        scpCameraScanRegion.style.display
+            = ScanTypeSelector.isCameraScanType(this.currentScanType)
+                ? "block" : "none";
+        sectionControlPanel.appendChild(scpCameraScanRegion);
+        const requestPermissionContainer = document.createElement("div");
+        requestPermissionContainer.style.textAlign = "center";
+        scpCameraScanRegion.appendChild(requestPermissionContainer);
+        if (this.scanTypeSelector.isCameraScanRequired()) {
+            this.createPermissionsUi(scpCameraScanRegion, requestPermissionContainer);
+        }
+        this.renderFileScanUi(sectionControlPanel);
+    }
+    renderFileScanUi(parent) {
+        let showOnRender = ScanTypeSelector.isFileScanType(this.currentScanType);
+        const $this = this;
+        let onFileSelected = (file) => {
+            if (!$this.html5Qrcode) {
+                throw "html5Qrcode not defined";
+            }
+            if (!ScanTypeSelector.isFileScanType($this.currentScanType)) {
+                return;
+            }
+            $this.setHeaderMessage(Html5QrcodeScannerStrings.loadingImage());
+            $this.html5Qrcode.scanFileV2(file, true)
+                .then((html5qrcodeResult) => {
+                $this.resetHeaderMessage();
+                $this.qrCodeSuccessCallback(html5qrcodeResult.decodedText, html5qrcodeResult);
+            })
+                .catch((error) => {
+                $this.setHeaderMessage(error, Html5QrcodeScannerStatus.STATUS_WARNING);
+                $this.qrCodeErrorCallback(error, Html5QrcodeErrorFactory.createFrom(error));
+            });
+        };
+        this.fileSelectionUi = FileSelectionUi.create(parent, showOnRender, onFileSelected);
+    }
+    renderCameraSelection(cameras) {
+        const $this = this;
+        const scpCameraScanRegion = document.getElementById(this.getDashboardSectionCameraScanRegionId());
+        scpCameraScanRegion.style.textAlign = "center";
+        let cameraZoomUi = CameraZoomUi.create(scpCameraScanRegion, false);
+        const renderCameraZoomUiIfSupported = (cameraCapabilities) => {
+            let zoomCapability = cameraCapabilities.zoomFeature();
+            if (!zoomCapability.isSupported()) {
+                return;
+            }
+            cameraZoomUi.setOnCameraZoomValueChangeCallback((zoomValue) => {
+                zoomCapability.apply(zoomValue);
+            });
+            let defaultZoom = 1;
+            if (this.config.defaultZoomValueIfSupported) {
+                defaultZoom = this.config.defaultZoomValueIfSupported;
+            }
+            defaultZoom = clip(defaultZoom, zoomCapability.min(), zoomCapability.max());
+            cameraZoomUi.setValues(zoomCapability.min(), zoomCapability.max(), defaultZoom, zoomCapability.step());
+            cameraZoomUi.show();
+        };
+        let cameraSelectUi = CameraSelectionUi.create(scpCameraScanRegion, cameras);
+        const cameraActionContainer = document.createElement("span");
+        const cameraActionStartButton = BaseUiElementFactory.createElement("button", PublicUiElementIdAndClasses.CAMERA_START_BUTTON_ID);
+        cameraActionStartButton.innerText
+            = Html5QrcodeScannerStrings.scanButtonStartScanningText();
+        cameraActionContainer.appendChild(cameraActionStartButton);
+        const cameraActionStopButton = BaseUiElementFactory.createElement("button", PublicUiElementIdAndClasses.CAMERA_STOP_BUTTON_ID);
+        cameraActionStopButton.innerText
+            = Html5QrcodeScannerStrings.scanButtonStopScanningText();
+        cameraActionStopButton.style.display = "none";
+        cameraActionStopButton.disabled = true;
+        cameraActionContainer.appendChild(cameraActionStopButton);
+        let torchButton;
+        const createAndShowTorchButtonIfSupported = (cameraCapabilities) => {
+            if (!cameraCapabilities.torchFeature().isSupported()) {
+                if (torchButton) {
+                    torchButton.hide();
+                }
+                return;
+            }
+            if (!torchButton) {
+                torchButton = TorchButton.create(cameraActionContainer, cameraCapabilities.torchFeature(), { display: "none", marginLeft: "5px" }, (errorMessage) => {
+                    $this.setHeaderMessage(errorMessage, Html5QrcodeScannerStatus.STATUS_WARNING);
+                });
+            }
+            else {
+                torchButton.updateTorchCapability(cameraCapabilities.torchFeature());
+            }
+            torchButton.show();
+        };
+        scpCameraScanRegion.appendChild(cameraActionContainer);
+        const resetCameraActionStartButton = (shouldShow) => {
+            if (!shouldShow) {
+                cameraActionStartButton.style.display = "none";
+            }
+            cameraActionStartButton.innerText
+                = Html5QrcodeScannerStrings
+                    .scanButtonStartScanningText();
+            cameraActionStartButton.style.opacity = "1";
+            cameraActionStartButton.disabled = false;
+            if (shouldShow) {
+                cameraActionStartButton.style.display = "inline-block";
+            }
+        };
+        cameraActionStartButton.addEventListener("click", (_) => {
+            cameraActionStartButton.innerText
+                = Html5QrcodeScannerStrings.scanButtonScanningStarting();
+            cameraSelectUi.disable();
+            cameraActionStartButton.disabled = true;
+            cameraActionStartButton.style.opacity = "0.5";
+            if (this.scanTypeSelector.hasMoreThanOneScanType()) {
+                $this.showHideScanTypeSwapLink(false);
+            }
+            $this.resetHeaderMessage();
+            const cameraId = cameraSelectUi.getValue();
+            $this.persistedDataManager.setLastUsedCameraId(cameraId);
+            $this.html5Qrcode.start(cameraId, toHtml5QrcodeCameraScanConfig($this.config), $this.qrCodeSuccessCallback, $this.qrCodeErrorCallback)
+                .then((_) => {
+                cameraActionStopButton.disabled = false;
+                cameraActionStopButton.style.display = "inline-block";
+                resetCameraActionStartButton(false);
+                const cameraCapabilities = $this.html5Qrcode.getRunningTrackCameraCapabilities();
+                if (this.config.showTorchButtonIfSupported === true) {
+                    createAndShowTorchButtonIfSupported(cameraCapabilities);
+                }
+                if (this.config.showZoomSliderIfSupported === true) {
+                    renderCameraZoomUiIfSupported(cameraCapabilities);
+                }
+            })
+                .catch((error) => {
+                $this.showHideScanTypeSwapLink(true);
+                cameraSelectUi.enable();
+                resetCameraActionStartButton(true);
+                $this.setHeaderMessage(error, Html5QrcodeScannerStatus.STATUS_WARNING);
+            });
+        });
+        if (cameraSelectUi.hasSingleItem()) {
+            cameraActionStartButton.click();
+        }
+        cameraActionStopButton.addEventListener("click", (_) => {
+            if (!$this.html5Qrcode) {
+                throw "html5Qrcode not defined";
+            }
+            cameraActionStopButton.disabled = true;
+            $this.html5Qrcode.stop()
+                .then((_) => {
+                if (this.scanTypeSelector.hasMoreThanOneScanType()) {
+                    $this.showHideScanTypeSwapLink(true);
+                }
+                cameraSelectUi.enable();
+                cameraActionStartButton.disabled = false;
+                cameraActionStopButton.style.display = "none";
+                cameraActionStartButton.style.display = "inline-block";
+                if (torchButton) {
+                    torchButton.reset();
+                    torchButton.hide();
+                }
+                cameraZoomUi.removeOnCameraZoomValueChangeCallback();
+                cameraZoomUi.hide();
+                $this.insertCameraScanImageToScanRegion();
+            }).catch((error) => {
+                cameraActionStopButton.disabled = false;
+                $this.setHeaderMessage(error, Html5QrcodeScannerStatus.STATUS_WARNING);
+            });
+        });
+        if ($this.persistedDataManager.getLastUsedCameraId()) {
+            const cameraId = $this.persistedDataManager.getLastUsedCameraId();
+            if (cameraSelectUi.hasValue(cameraId)) {
+                cameraSelectUi.setValue(cameraId);
+                cameraActionStartButton.click();
+            }
+            else {
+                $this.persistedDataManager.resetLastUsedCameraId();
+            }
+        }
+    }
+    createSectionSwap() {
+        const $this = this;
+        const TEXT_IF_CAMERA_SCAN_SELECTED = Html5QrcodeScannerStrings.textIfCameraScanSelected();
+        const TEXT_IF_FILE_SCAN_SELECTED = Html5QrcodeScannerStrings.textIfFileScanSelected();
+        const section = document.getElementById(this.getDashboardSectionId());
+        const switchContainer = document.createElement("div");
+        switchContainer.style.textAlign = "center";
+        const switchScanTypeLink = BaseUiElementFactory.createElement("span", this.getDashboardSectionSwapLinkId());
+        switchScanTypeLink.style.textDecoration = "underline";
+        switchScanTypeLink.style.cursor = "pointer";
+        switchScanTypeLink.innerText
+            = ScanTypeSelector.isCameraScanType(this.currentScanType)
+                ? TEXT_IF_CAMERA_SCAN_SELECTED : TEXT_IF_FILE_SCAN_SELECTED;
+        switchScanTypeLink.addEventListener("click", function () {
+            if (!$this.sectionSwapAllowed) {
+                if ($this.verbose) {
+                    $this.logger.logError("Section swap called when not allowed");
+                }
+                return;
+            }
+            $this.resetHeaderMessage();
+            $this.fileSelectionUi.resetValue();
+            $this.sectionSwapAllowed = false;
+            if (ScanTypeSelector.isCameraScanType($this.currentScanType)) {
+                $this.clearScanRegion();
+                $this.getCameraScanRegion().style.display = "none";
+                $this.fileSelectionUi.show();
+                switchScanTypeLink.innerText = TEXT_IF_FILE_SCAN_SELECTED;
+                $this.currentScanType = Html5QrcodeScanType.SCAN_TYPE_FILE;
+                $this.insertFileScanImageToScanRegion();
+            }
+            else {
+                $this.clearScanRegion();
+                $this.getCameraScanRegion().style.display = "block";
+                $this.fileSelectionUi.hide();
+                switchScanTypeLink.innerText = TEXT_IF_CAMERA_SCAN_SELECTED;
+                $this.currentScanType = Html5QrcodeScanType.SCAN_TYPE_CAMERA;
+                $this.insertCameraScanImageToScanRegion();
+                $this.startCameraScanIfPermissionExistsOnSwap();
+            }
+            $this.sectionSwapAllowed = true;
+        });
+        switchContainer.appendChild(switchScanTypeLink);
+        section.appendChild(switchContainer);
+    }
+    startCameraScanIfPermissionExistsOnSwap() {
+        const $this = this;
+        if (this.persistedDataManager.hasCameraPermissions()) {
+            CameraPermissions.hasPermissions().then((hasPermissions) => {
+                if (hasPermissions) {
+                    let permissionButton = document.getElementById($this.getCameraPermissionButtonId());
+                    if (!permissionButton) {
+                        this.logger.logError("Permission button not found, fail;");
+                        throw "Permission button not found";
+                    }
+                    permissionButton.click();
+                }
+                else {
+                    $this.persistedDataManager.setHasPermission(false);
+                }
+            }).catch((_) => {
+                $this.persistedDataManager.setHasPermission(false);
+            });
+            return;
+        }
+    }
+    resetHeaderMessage() {
+        const messageDiv = document.getElementById(this.getHeaderMessageContainerId());
+        messageDiv.style.display = "none";
+    }
+    setHeaderMessage(messageText, scannerStatus) {
+        if (!scannerStatus) {
+            scannerStatus = Html5QrcodeScannerStatus.STATUS_DEFAULT;
+        }
+        const messageDiv = this.getHeaderMessageDiv();
+        messageDiv.innerText = messageText;
+        messageDiv.style.display = "block";
+        switch (scannerStatus) {
+            case Html5QrcodeScannerStatus.STATUS_SUCCESS:
+                messageDiv.style.background = "rgba(106, 175, 80, 0.26)";
+                messageDiv.style.color = "#477735";
+                break;
+            case Html5QrcodeScannerStatus.STATUS_WARNING:
+                messageDiv.style.background = "rgba(203, 36, 49, 0.14)";
+                messageDiv.style.color = "#cb2431";
+                break;
+            case Html5QrcodeScannerStatus.STATUS_DEFAULT:
+            default:
+                messageDiv.style.background = "rgba(0, 0, 0, 0)";
+                messageDiv.style.color = "rgb(17, 17, 17)";
+                break;
+        }
+    }
+    showHideScanTypeSwapLink(shouldDisplay) {
+        if (this.scanTypeSelector.hasMoreThanOneScanType()) {
+            if (shouldDisplay !== true) {
+                shouldDisplay = false;
+            }
+            this.sectionSwapAllowed = shouldDisplay;
+            this.getDashboardSectionSwapLink().style.display
+                = shouldDisplay ? "inline-block" : "none";
+        }
+    }
+    insertCameraScanImageToScanRegion() {
+        const $this = this;
+        const qrCodeScanRegion = document.getElementById(this.getScanRegionId());
+        if (this.cameraScanImage) {
+            qrCodeScanRegion.innerHTML = "<br>";
+            qrCodeScanRegion.appendChild(this.cameraScanImage);
+            return;
+        }
+        this.cameraScanImage = new Image;
+        this.cameraScanImage.onload = (_) => {
+            qrCodeScanRegion.innerHTML = "<br>";
+            qrCodeScanRegion.appendChild($this.cameraScanImage);
+        };
+        this.cameraScanImage.width = 64;
+        this.cameraScanImage.style.opacity = "0.8";
+        this.cameraScanImage.src = ASSET_CAMERA_SCAN;
+        this.cameraScanImage.alt = Html5QrcodeScannerStrings.cameraScanAltText();
+    }
+    insertFileScanImageToScanRegion() {
+        const $this = this;
+        const qrCodeScanRegion = document.getElementById(this.getScanRegionId());
+        if (this.fileScanImage) {
+            qrCodeScanRegion.innerHTML = "<br>";
+            qrCodeScanRegion.appendChild(this.fileScanImage);
+            return;
+        }
+        this.fileScanImage = new Image;
+        this.fileScanImage.onload = (_) => {
+            qrCodeScanRegion.innerHTML = "<br>";
+            qrCodeScanRegion.appendChild($this.fileScanImage);
+        };
+        this.fileScanImage.width = 64;
+        this.fileScanImage.style.opacity = "0.8";
+        this.fileScanImage.src = ASSET_FILE_SCAN;
+        this.fileScanImage.alt = Html5QrcodeScannerStrings.fileScanAltText();
+    }
+    clearScanRegion() {
+        const qrCodeScanRegion = document.getElementById(this.getScanRegionId());
+        qrCodeScanRegion.innerHTML = "";
+    }
+    getDashboardSectionId() {
+        return `${this.elementId}__dashboard_section`;
+    }
+    getDashboardSectionCameraScanRegionId() {
+        return `${this.elementId}__dashboard_section_csr`;
+    }
+    getDashboardSectionSwapLinkId() {
+        return PublicUiElementIdAndClasses.SCAN_TYPE_CHANGE_ANCHOR_ID;
+    }
+    getScanRegionId() {
+        return `${this.elementId}__scan_region`;
+    }
+    getDashboardId() {
+        return `${this.elementId}__dashboard`;
+    }
+    getHeaderMessageContainerId() {
+        return `${this.elementId}__header_message`;
+    }
+    getCameraPermissionButtonId() {
+        return PublicUiElementIdAndClasses.CAMERA_PERMISSION_BUTTON_ID;
+    }
+    getCameraScanRegion() {
+        return document.getElementById(this.getDashboardSectionCameraScanRegionId());
+    }
+    getDashboardSectionSwapLink() {
+        return document.getElementById(this.getDashboardSectionSwapLinkId());
+    }
+    getHeaderMessageDiv() {
+        return document.getElementById(this.getHeaderMessageContainerId());
+    }
+}
+//# sourceMappingURL=html5-qrcode-scanner.js.map

node_modules/html5-qrcode/es2015/html5-qrcode.d.ts

@@ -0,0 +1,75 @@
+import { QrcodeErrorCallback, QrcodeSuccessCallback, Html5QrcodeSupportedFormats, Html5QrcodeResult, QrDimensions, QrDimensionFunction } from "./core";
+import { CameraDevice, CameraCapabilities } from "./camera/core";
+import { ExperimentalFeaturesConfig } from "./experimental-features";
+import { Html5QrcodeScannerState } from "./state-manager";
+export interface Html5QrcodeConfigs {
+    formatsToSupport?: Array<Html5QrcodeSupportedFormats> | undefined;
+    useBarCodeDetectorIfSupported?: boolean | undefined;
+    experimentalFeatures?: ExperimentalFeaturesConfig | undefined;
+}
+export interface Html5QrcodeFullConfig extends Html5QrcodeConfigs {
+    verbose: boolean | undefined;
+}
+export interface Html5QrcodeCameraScanConfig {
+    fps: number | undefined;
+    qrbox?: number | QrDimensions | QrDimensionFunction | undefined;
+    aspectRatio?: number | undefined;
+    disableFlip?: boolean | undefined;
+    videoConstraints?: MediaTrackConstraints | undefined;
+}
+export declare class Html5Qrcode {
+    private readonly logger;
+    private readonly elementId;
+    private readonly verbose;
+    private readonly qrcode;
+    private shouldScan;
+    private element;
+    private canvasElement;
+    private scannerPausedUiElement;
+    private hasBorderShaders;
+    private borderShaders;
+    private qrMatch;
+    private renderedCamera;
+    private foreverScanTimeout;
+    private qrRegion;
+    private context;
+    private lastScanImageFile;
+    private stateManagerProxy;
+    isScanning: boolean;
+    constructor(elementId: string, configOrVerbosityFlag?: boolean | Html5QrcodeFullConfig | undefined);
+    start(cameraIdOrConfig: string | MediaTrackConstraints, configuration: Html5QrcodeCameraScanConfig | undefined, qrCodeSuccessCallback: QrcodeSuccessCallback | undefined, qrCodeErrorCallback: QrcodeErrorCallback | undefined): Promise<null>;
+    pause(shouldPauseVideo?: boolean): void;
+    resume(): void;
+    getState(): Html5QrcodeScannerState;
+    stop(): Promise<void>;
+    scanFile(imageFile: File, showImage?: boolean): Promise<string>;
+    scanFileV2(imageFile: File, showImage?: boolean): Promise<Html5QrcodeResult>;
+    clear(): void;
+    static getCameras(): Promise<Array<CameraDevice>>;
+    getRunningTrackCapabilities(): MediaTrackCapabilities;
+    getRunningTrackSettings(): MediaTrackSettings;
+    getRunningTrackCameraCapabilities(): CameraCapabilities;
+    applyVideoConstraints(videoConstaints: MediaTrackConstraints): Promise<void>;
+    private getRenderedCameraOrFail;
+    private getSupportedFormats;
+    private getUseBarCodeDetectorIfSupported;
+    private validateQrboxSize;
+    private validateQrboxConfig;
+    private toQrdimensions;
+    private setupUi;
+    private createScannerPausedUiElement;
+    private scanContext;
+    private foreverScan;
+    private createVideoConstraints;
+    private computeCanvasDrawConfig;
+    private clearElement;
+    private possiblyUpdateShaders;
+    private possiblyCloseLastScanImageFile;
+    private createCanvasElement;
+    private getShadedRegionBounds;
+    private possiblyInsertShadingElement;
+    private insertShaderBorders;
+    private showPausedState;
+    private hidePausedState;
+    private getTimeoutFps;
+}

node_modules/html5-qrcode/es2015/html5-qrcode.js

@@ -0,0 +1,810 @@
+import { BaseLoggger, Html5QrcodeResultFactory, Html5QrcodeErrorFactory, Html5QrcodeSupportedFormats, isValidHtml5QrcodeSupportedFormats, Html5QrcodeConstants, isNullOrUndefined } from "./core";
+import { Html5QrcodeStrings } from "./strings";
+import { VideoConstraintsUtil } from "./utils";
+import { Html5QrcodeShim } from "./code-decoder";
+import { CameraFactory } from "./camera/factories";
+import { CameraRetriever } from "./camera/retriever";
+import { StateManagerFactory, Html5QrcodeScannerState } from "./state-manager";
+class Constants extends Html5QrcodeConstants {
+}
+Constants.DEFAULT_WIDTH = 300;
+Constants.DEFAULT_WIDTH_OFFSET = 2;
+Constants.FILE_SCAN_MIN_HEIGHT = 300;
+Constants.FILE_SCAN_HIDDEN_CANVAS_PADDING = 100;
+Constants.MIN_QR_BOX_SIZE = 50;
+Constants.SHADED_LEFT = 1;
+Constants.SHADED_RIGHT = 2;
+Constants.SHADED_TOP = 3;
+Constants.SHADED_BOTTOM = 4;
+Constants.SHADED_REGION_ELEMENT_ID = "qr-shaded-region";
+Constants.VERBOSE = false;
+Constants.BORDER_SHADER_DEFAULT_COLOR = "#ffffff";
+Constants.BORDER_SHADER_MATCH_COLOR = "rgb(90, 193, 56)";
+class InternalHtml5QrcodeConfig {
+    constructor(config, logger) {
+        this.logger = logger;
+        this.fps = Constants.SCAN_DEFAULT_FPS;
+        if (!config) {
+            this.disableFlip = Constants.DEFAULT_DISABLE_FLIP;
+        }
+        else {
+            if (config.fps) {
+                this.fps = config.fps;
+            }
+            this.disableFlip = config.disableFlip === true;
+            this.qrbox = config.qrbox;
+            this.aspectRatio = config.aspectRatio;
+            this.videoConstraints = config.videoConstraints;
+        }
+    }
+    isMediaStreamConstraintsValid() {
+        if (!this.videoConstraints) {
+            this.logger.logError("Empty videoConstraints", true);
+            return false;
+        }
+        return VideoConstraintsUtil.isMediaStreamConstraintsValid(this.videoConstraints, this.logger);
+    }
+    isShadedBoxEnabled() {
+        return !isNullOrUndefined(this.qrbox);
+    }
+    static create(config, logger) {
+        return new InternalHtml5QrcodeConfig(config, logger);
+    }
+}
+export class Html5Qrcode {
+    constructor(elementId, configOrVerbosityFlag) {
+        this.element = null;
+        this.canvasElement = null;
+        this.scannerPausedUiElement = null;
+        this.hasBorderShaders = null;
+        this.borderShaders = null;
+        this.qrMatch = null;
+        this.renderedCamera = null;
+        this.qrRegion = null;
+        this.context = null;
+        this.lastScanImageFile = null;
+        this.isScanning = false;
+        if (!document.getElementById(elementId)) {
+            throw `HTML Element with id=${elementId} not found`;
+        }
+        this.elementId = elementId;
+        this.verbose = false;
+        let experimentalFeatureConfig;
+        let configObject;
+        if (typeof configOrVerbosityFlag == "boolean") {
+            this.verbose = configOrVerbosityFlag === true;
+        }
+        else if (configOrVerbosityFlag) {
+            configObject = configOrVerbosityFlag;
+            this.verbose = configObject.verbose === true;
+            experimentalFeatureConfig = configObject.experimentalFeatures;
+        }
+        this.logger = new BaseLoggger(this.verbose);
+        this.qrcode = new Html5QrcodeShim(this.getSupportedFormats(configOrVerbosityFlag), this.getUseBarCodeDetectorIfSupported(configObject), this.verbose, this.logger);
+        this.foreverScanTimeout;
+        this.shouldScan = true;
+        this.stateManagerProxy = StateManagerFactory.create();
+    }
+    start(cameraIdOrConfig, configuration, qrCodeSuccessCallback, qrCodeErrorCallback) {
+        if (!cameraIdOrConfig) {
+            throw "cameraIdOrConfig is required";
+        }
+        if (!qrCodeSuccessCallback
+            || typeof qrCodeSuccessCallback != "function") {
+            throw "qrCodeSuccessCallback is required and should be a function.";
+        }
+        let qrCodeErrorCallbackInternal;
+        if (qrCodeErrorCallback) {
+            qrCodeErrorCallbackInternal = qrCodeErrorCallback;
+        }
+        else {
+            qrCodeErrorCallbackInternal
+                = this.verbose ? this.logger.log : () => { };
+        }
+        const internalConfig = InternalHtml5QrcodeConfig.create(configuration, this.logger);
+        this.clearElement();
+        let videoConstraintsAvailableAndValid = false;
+        if (internalConfig.videoConstraints) {
+            if (!internalConfig.isMediaStreamConstraintsValid()) {
+                this.logger.logError("'videoConstraints' is not valid 'MediaStreamConstraints, "
+                    + "it will be ignored.'", true);
+            }
+            else {
+                videoConstraintsAvailableAndValid = true;
+            }
+        }
+        const areVideoConstraintsEnabled = videoConstraintsAvailableAndValid;
+        const element = document.getElementById(this.elementId);
+        const rootElementWidth = element.clientWidth
+            ? element.clientWidth : Constants.DEFAULT_WIDTH;
+        element.style.position = "relative";
+        this.shouldScan = true;
+        this.element = element;
+        const $this = this;
+        const toScanningStateChangeTransaction = this.stateManagerProxy.startTransition(Html5QrcodeScannerState.SCANNING);
+        return new Promise((resolve, reject) => {
+            const videoConstraints = areVideoConstraintsEnabled
+                ? internalConfig.videoConstraints
+                : $this.createVideoConstraints(cameraIdOrConfig);
+            if (!videoConstraints) {
+                toScanningStateChangeTransaction.cancel();
+                reject("videoConstraints should be defined");
+                return;
+            }
+            let cameraRenderingOptions = {};
+            if (!areVideoConstraintsEnabled || internalConfig.aspectRatio) {
+                cameraRenderingOptions.aspectRatio = internalConfig.aspectRatio;
+            }
+            let renderingCallbacks = {
+                onRenderSurfaceReady: (viewfinderWidth, viewfinderHeight) => {
+                    $this.setupUi(viewfinderWidth, viewfinderHeight, internalConfig);
+                    $this.isScanning = true;
+                    $this.foreverScan(internalConfig, qrCodeSuccessCallback, qrCodeErrorCallbackInternal);
+                }
+            };
+            CameraFactory.failIfNotSupported().then((factory) => {
+                factory.create(videoConstraints).then((camera) => {
+                    return camera.render(this.element, cameraRenderingOptions, renderingCallbacks)
+                        .then((renderedCamera) => {
+                        $this.renderedCamera = renderedCamera;
+                        toScanningStateChangeTransaction.execute();
+                        resolve(null);
+                    })
+                        .catch((error) => {
+                        toScanningStateChangeTransaction.cancel();
+                        reject(error);
+                    });
+                }).catch((error) => {
+                    toScanningStateChangeTransaction.cancel();
+                    reject(Html5QrcodeStrings.errorGettingUserMedia(error));
+                });
+            }).catch((_) => {
+                toScanningStateChangeTransaction.cancel();
+                reject(Html5QrcodeStrings.cameraStreamingNotSupported());
+            });
+        });
+    }
+    pause(shouldPauseVideo) {
+        if (!this.stateManagerProxy.isStrictlyScanning()) {
+            throw "Cannot pause, scanner is not scanning.";
+        }
+        this.stateManagerProxy.directTransition(Html5QrcodeScannerState.PAUSED);
+        this.showPausedState();
+        if (isNullOrUndefined(shouldPauseVideo) || shouldPauseVideo !== true) {
+            shouldPauseVideo = false;
+        }
+        if (shouldPauseVideo && this.renderedCamera) {
+            this.renderedCamera.pause();
+        }
+    }
+    resume() {
+        if (!this.stateManagerProxy.isPaused()) {
+            throw "Cannot result, scanner is not paused.";
+        }
+        if (!this.renderedCamera) {
+            throw "renderedCamera doesn't exist while trying resume()";
+        }
+        const $this = this;
+        const transitionToScanning = () => {
+            $this.stateManagerProxy.directTransition(Html5QrcodeScannerState.SCANNING);
+            $this.hidePausedState();
+        };
+        if (!this.renderedCamera.isPaused()) {
+            transitionToScanning();
+            return;
+        }
+        this.renderedCamera.resume(() => {
+            transitionToScanning();
+        });
+    }
+    getState() {
+        return this.stateManagerProxy.getState();
+    }
+    stop() {
+        if (!this.stateManagerProxy.isScanning()) {
+            throw "Cannot stop, scanner is not running or paused.";
+        }
+        const toStoppedStateTransaction = this.stateManagerProxy.startTransition(Html5QrcodeScannerState.NOT_STARTED);
+        this.shouldScan = false;
+        if (this.foreverScanTimeout) {
+            clearTimeout(this.foreverScanTimeout);
+        }
+        const removeQrRegion = () => {
+            if (!this.element) {
+                return;
+            }
+            let childElement = document.getElementById(Constants.SHADED_REGION_ELEMENT_ID);
+            if (childElement) {
+                this.element.removeChild(childElement);
+            }
+        };
+        let $this = this;
+        return this.renderedCamera.close().then(() => {
+            $this.renderedCamera = null;
+            if ($this.element) {
+                $this.element.removeChild($this.canvasElement);
+                $this.canvasElement = null;
+            }
+            removeQrRegion();
+            if ($this.qrRegion) {
+                $this.qrRegion = null;
+            }
+            if ($this.context) {
+                $this.context = null;
+            }
+            toStoppedStateTransaction.execute();
+            $this.hidePausedState();
+            $this.isScanning = false;
+            return Promise.resolve();
+        });
+    }
+    scanFile(imageFile, showImage) {
+        return this.scanFileV2(imageFile, showImage)
+            .then((html5qrcodeResult) => html5qrcodeResult.decodedText);
+    }
+    scanFileV2(imageFile, showImage) {
+        if (!imageFile || !(imageFile instanceof File)) {
+            throw "imageFile argument is mandatory and should be instance "
+                + "of File. Use 'event.target.files[0]'.";
+        }
+        if (isNullOrUndefined(showImage)) {
+            showImage = true;
+        }
+        if (!this.stateManagerProxy.canScanFile()) {
+            throw "Cannot start file scan - ongoing camera scan";
+        }
+        return new Promise((resolve, reject) => {
+            this.possiblyCloseLastScanImageFile();
+            this.clearElement();
+            this.lastScanImageFile = URL.createObjectURL(imageFile);
+            const inputImage = new Image;
+            inputImage.onload = () => {
+                const imageWidth = inputImage.width;
+                const imageHeight = inputImage.height;
+                const element = document.getElementById(this.elementId);
+                const containerWidth = element.clientWidth
+                    ? element.clientWidth : Constants.DEFAULT_WIDTH;
+                const containerHeight = Math.max(element.clientHeight ? element.clientHeight : imageHeight, Constants.FILE_SCAN_MIN_HEIGHT);
+                const config = this.computeCanvasDrawConfig(imageWidth, imageHeight, containerWidth, containerHeight);
+                if (showImage) {
+                    const visibleCanvas = this.createCanvasElement(containerWidth, containerHeight, "qr-canvas-visible");
+                    visibleCanvas.style.display = "inline-block";
+                    element.appendChild(visibleCanvas);
+                    const context = visibleCanvas.getContext("2d");
+                    if (!context) {
+                        throw "Unable to get 2d context from canvas";
+                    }
+                    context.canvas.width = containerWidth;
+                    context.canvas.height = containerHeight;
+                    context.drawImage(inputImage, 0, 0, imageWidth, imageHeight, config.x, config.y, config.width, config.height);
+                }
+                let padding = Constants.FILE_SCAN_HIDDEN_CANVAS_PADDING;
+                let hiddenImageWidth = Math.max(inputImage.width, config.width);
+                let hiddenImageHeight = Math.max(inputImage.height, config.height);
+                let hiddenCanvasWidth = hiddenImageWidth + 2 * padding;
+                let hiddenCanvasHeight = hiddenImageHeight + 2 * padding;
+                const hiddenCanvas = this.createCanvasElement(hiddenCanvasWidth, hiddenCanvasHeight);
+                element.appendChild(hiddenCanvas);
+                const context = hiddenCanvas.getContext("2d");
+                if (!context) {
+                    throw "Unable to get 2d context from canvas";
+                }
+                context.canvas.width = hiddenCanvasWidth;
+                context.canvas.height = hiddenCanvasHeight;
+                context.drawImage(inputImage, 0, 0, imageWidth, imageHeight, padding, padding, hiddenImageWidth, hiddenImageHeight);
+                try {
+                    this.qrcode.decodeRobustlyAsync(hiddenCanvas)
+                        .then((result) => {
+                        resolve(Html5QrcodeResultFactory.createFromQrcodeResult(result));
+                    })
+                        .catch(reject);
+                }
+                catch (exception) {
+                    reject(`QR code parse error, error = ${exception}`);
+                }
+            };
+            inputImage.onerror = reject;
+            inputImage.onabort = reject;
+            inputImage.onstalled = reject;
+            inputImage.onsuspend = reject;
+            inputImage.src = URL.createObjectURL(imageFile);
+        });
+    }
+    clear() {
+        this.clearElement();
+    }
+    static getCameras() {
+        return CameraRetriever.retrieve();
+    }
+    getRunningTrackCapabilities() {
+        return this.getRenderedCameraOrFail().getRunningTrackCapabilities();
+    }
+    getRunningTrackSettings() {
+        return this.getRenderedCameraOrFail().getRunningTrackSettings();
+    }
+    getRunningTrackCameraCapabilities() {
+        return this.getRenderedCameraOrFail().getCapabilities();
+    }
+    applyVideoConstraints(videoConstaints) {
+        if (!videoConstaints) {
+            throw "videoConstaints is required argument.";
+        }
+        else if (!VideoConstraintsUtil.isMediaStreamConstraintsValid(videoConstaints, this.logger)) {
+            throw "invalid videoConstaints passed, check logs for more details";
+        }
+        return this.getRenderedCameraOrFail().applyVideoConstraints(videoConstaints);
+    }
+    getRenderedCameraOrFail() {
+        if (this.renderedCamera == null) {
+            throw "Scanning is not in running state, call this API only when"
+                + " QR code scanning using camera is in running state.";
+        }
+        return this.renderedCamera;
+    }
+    getSupportedFormats(configOrVerbosityFlag) {
+        const allFormats = [
+            Html5QrcodeSupportedFormats.QR_CODE,
+            Html5QrcodeSupportedFormats.AZTEC,
+            Html5QrcodeSupportedFormats.CODABAR,
+            Html5QrcodeSupportedFormats.CODE_39,
+            Html5QrcodeSupportedFormats.CODE_93,
+            Html5QrcodeSupportedFormats.CODE_128,
+            Html5QrcodeSupportedFormats.DATA_MATRIX,
+            Html5QrcodeSupportedFormats.MAXICODE,
+            Html5QrcodeSupportedFormats.ITF,
+            Html5QrcodeSupportedFormats.EAN_13,
+            Html5QrcodeSupportedFormats.EAN_8,
+            Html5QrcodeSupportedFormats.PDF_417,
+            Html5QrcodeSupportedFormats.RSS_14,
+            Html5QrcodeSupportedFormats.RSS_EXPANDED,
+            Html5QrcodeSupportedFormats.UPC_A,
+            Html5QrcodeSupportedFormats.UPC_E,
+            Html5QrcodeSupportedFormats.UPC_EAN_EXTENSION,
+        ];
+        if (!configOrVerbosityFlag
+            || typeof configOrVerbosityFlag == "boolean") {
+            return allFormats;
+        }
+        if (!configOrVerbosityFlag.formatsToSupport) {
+            return allFormats;
+        }
+        if (!Array.isArray(configOrVerbosityFlag.formatsToSupport)) {
+            throw "configOrVerbosityFlag.formatsToSupport should be undefined "
+                + "or an array.";
+        }
+        if (configOrVerbosityFlag.formatsToSupport.length === 0) {
+            throw "Atleast 1 formatsToSupport is needed.";
+        }
+        const supportedFormats = [];
+        for (const format of configOrVerbosityFlag.formatsToSupport) {
+            if (isValidHtml5QrcodeSupportedFormats(format)) {
+                supportedFormats.push(format);
+            }
+            else {
+                this.logger.warn(`Invalid format: ${format} passed in config, ignoring.`);
+            }
+        }
+        if (supportedFormats.length === 0) {
+            throw "None of formatsToSupport match supported values.";
+        }
+        return supportedFormats;
+    }
+    getUseBarCodeDetectorIfSupported(config) {
+        if (isNullOrUndefined(config)) {
+            return true;
+        }
+        if (!isNullOrUndefined(config.useBarCodeDetectorIfSupported)) {
+            return config.useBarCodeDetectorIfSupported !== false;
+        }
+        if (isNullOrUndefined(config.experimentalFeatures)) {
+            return true;
+        }
+        let experimentalFeatures = config.experimentalFeatures;
+        if (isNullOrUndefined(experimentalFeatures.useBarCodeDetectorIfSupported)) {
+            return true;
+        }
+        return experimentalFeatures.useBarCodeDetectorIfSupported !== false;
+    }
+    validateQrboxSize(viewfinderWidth, viewfinderHeight, internalConfig) {
+        const qrboxSize = internalConfig.qrbox;
+        this.validateQrboxConfig(qrboxSize);
+        let qrDimensions = this.toQrdimensions(viewfinderWidth, viewfinderHeight, qrboxSize);
+        const validateMinSize = (size) => {
+            if (size < Constants.MIN_QR_BOX_SIZE) {
+                throw "minimum size of 'config.qrbox' dimension value is"
+                    + ` ${Constants.MIN_QR_BOX_SIZE}px.`;
+            }
+        };
+        const correctWidthBasedOnRootElementSize = (configWidth) => {
+            if (configWidth > viewfinderWidth) {
+                this.logger.warn("`qrbox.width` or `qrbox` is larger than the"
+                    + " width of the root element. The width will be truncated"
+                    + " to the width of root element.");
+                configWidth = viewfinderWidth;
+            }
+            return configWidth;
+        };
+        validateMinSize(qrDimensions.width);
+        validateMinSize(qrDimensions.height);
+        qrDimensions.width = correctWidthBasedOnRootElementSize(qrDimensions.width);
+    }
+    validateQrboxConfig(qrboxSize) {
+        if (typeof qrboxSize === "number") {
+            return;
+        }
+        if (typeof qrboxSize === "function") {
+            return;
+        }
+        if (qrboxSize.width === undefined || qrboxSize.height === undefined) {
+            throw "Invalid instance of QrDimensions passed for "
+                + "'config.qrbox'. Both 'width' and 'height' should be set.";
+        }
+    }
+    toQrdimensions(viewfinderWidth, viewfinderHeight, qrboxSize) {
+        if (typeof qrboxSize === "number") {
+            return { width: qrboxSize, height: qrboxSize };
+        }
+        else if (typeof qrboxSize === "function") {
+            try {
+                return qrboxSize(viewfinderWidth, viewfinderHeight);
+            }
+            catch (error) {
+                throw new Error("qrbox config was passed as a function but it failed with "
+                    + "unknown error" + error);
+            }
+        }
+        return qrboxSize;
+    }
+    setupUi(viewfinderWidth, viewfinderHeight, internalConfig) {
+        if (internalConfig.isShadedBoxEnabled()) {
+            this.validateQrboxSize(viewfinderWidth, viewfinderHeight, internalConfig);
+        }
+        const qrboxSize = isNullOrUndefined(internalConfig.qrbox) ?
+            { width: viewfinderWidth, height: viewfinderHeight } : internalConfig.qrbox;
+        this.validateQrboxConfig(qrboxSize);
+        let qrDimensions = this.toQrdimensions(viewfinderWidth, viewfinderHeight, qrboxSize);
+        if (qrDimensions.height > viewfinderHeight) {
+            this.logger.warn("[Html5Qrcode] config.qrbox has height that is"
+                + "greater than the height of the video stream. Shading will be"
+                + " ignored");
+        }
+        const shouldShadingBeApplied = internalConfig.isShadedBoxEnabled()
+            && qrDimensions.height <= viewfinderHeight;
+        const defaultQrRegion = {
+            x: 0,
+            y: 0,
+            width: viewfinderWidth,
+            height: viewfinderHeight
+        };
+        const qrRegion = shouldShadingBeApplied
+            ? this.getShadedRegionBounds(viewfinderWidth, viewfinderHeight, qrDimensions)
+            : defaultQrRegion;
+        const canvasElement = this.createCanvasElement(qrRegion.width, qrRegion.height);
+        const contextAttributes = { willReadFrequently: true };
+        const context = canvasElement.getContext("2d", contextAttributes);
+        context.canvas.width = qrRegion.width;
+        context.canvas.height = qrRegion.height;
+        this.element.append(canvasElement);
+        if (shouldShadingBeApplied) {
+            this.possiblyInsertShadingElement(this.element, viewfinderWidth, viewfinderHeight, qrDimensions);
+        }
+        this.createScannerPausedUiElement(this.element);
+        this.qrRegion = qrRegion;
+        this.context = context;
+        this.canvasElement = canvasElement;
+    }
+    createScannerPausedUiElement(rootElement) {
+        const scannerPausedUiElement = document.createElement("div");
+        scannerPausedUiElement.innerText = Html5QrcodeStrings.scannerPaused();
+        scannerPausedUiElement.style.display = "none";
+        scannerPausedUiElement.style.position = "absolute";
+        scannerPausedUiElement.style.top = "0px";
+        scannerPausedUiElement.style.zIndex = "1";
+        scannerPausedUiElement.style.background = "rgba(9, 9, 9, 0.46)";
+        scannerPausedUiElement.style.color = "#FFECEC";
+        scannerPausedUiElement.style.textAlign = "center";
+        scannerPausedUiElement.style.width = "100%";
+        rootElement.appendChild(scannerPausedUiElement);
+        this.scannerPausedUiElement = scannerPausedUiElement;
+    }
+    scanContext(qrCodeSuccessCallback, qrCodeErrorCallback) {
+        if (this.stateManagerProxy.isPaused()) {
+            return Promise.resolve(false);
+        }
+        return this.qrcode.decodeAsync(this.canvasElement)
+            .then((result) => {
+            qrCodeSuccessCallback(result.text, Html5QrcodeResultFactory.createFromQrcodeResult(result));
+            this.possiblyUpdateShaders(true);
+            return true;
+        }).catch((error) => {
+            this.possiblyUpdateShaders(false);
+            let errorMessage = Html5QrcodeStrings.codeParseError(error);
+            qrCodeErrorCallback(errorMessage, Html5QrcodeErrorFactory.createFrom(errorMessage));
+            return false;
+        });
+    }
+    foreverScan(internalConfig, qrCodeSuccessCallback, qrCodeErrorCallback) {
+        if (!this.shouldScan) {
+            return;
+        }
+        if (!this.renderedCamera) {
+            return;
+        }
+        const videoElement = this.renderedCamera.getSurface();
+        const widthRatio = videoElement.videoWidth / videoElement.clientWidth;
+        const heightRatio = videoElement.videoHeight / videoElement.clientHeight;
+        if (!this.qrRegion) {
+            throw "qrRegion undefined when localMediaStream is ready.";
+        }
+        const sWidthOffset = this.qrRegion.width * widthRatio;
+        const sHeightOffset = this.qrRegion.height * heightRatio;
+        const sxOffset = this.qrRegion.x * widthRatio;
+        const syOffset = this.qrRegion.y * heightRatio;
+        this.context.drawImage(videoElement, sxOffset, syOffset, sWidthOffset, sHeightOffset, 0, 0, this.qrRegion.width, this.qrRegion.height);
+        const triggerNextScan = () => {
+            this.foreverScanTimeout = setTimeout(() => {
+                this.foreverScan(internalConfig, qrCodeSuccessCallback, qrCodeErrorCallback);
+            }, this.getTimeoutFps(internalConfig.fps));
+        };
+        this.scanContext(qrCodeSuccessCallback, qrCodeErrorCallback)
+            .then((isSuccessfull) => {
+            if (!isSuccessfull && internalConfig.disableFlip !== true) {
+                this.context.translate(this.context.canvas.width, 0);
+                this.context.scale(-1, 1);
+                this.scanContext(qrCodeSuccessCallback, qrCodeErrorCallback)
+                    .finally(() => {
+                    triggerNextScan();
+                });
+            }
+            else {
+                triggerNextScan();
+            }
+        }).catch((error) => {
+            this.logger.logError("Error happend while scanning context", error);
+            triggerNextScan();
+        });
+    }
+    createVideoConstraints(cameraIdOrConfig) {
+        if (typeof cameraIdOrConfig == "string") {
+            return { deviceId: { exact: cameraIdOrConfig } };
+        }
+        else if (typeof cameraIdOrConfig == "object") {
+            const facingModeKey = "facingMode";
+            const deviceIdKey = "deviceId";
+            const allowedFacingModeValues = { "user": true, "environment": true };
+            const exactKey = "exact";
+            const isValidFacingModeValue = (value) => {
+                if (value in allowedFacingModeValues) {
+                    return true;
+                }
+                else {
+                    throw "config has invalid 'facingMode' value = "
+                        + `'${value}'`;
+                }
+            };
+            const keys = Object.keys(cameraIdOrConfig);
+            if (keys.length !== 1) {
+                throw "'cameraIdOrConfig' object should have exactly 1 key,"
+                    + ` if passed as an object, found ${keys.length} keys`;
+            }
+            const key = Object.keys(cameraIdOrConfig)[0];
+            if (key !== facingModeKey && key !== deviceIdKey) {
+                throw `Only '${facingModeKey}' and '${deviceIdKey}' `
+                    + " are supported for 'cameraIdOrConfig'";
+            }
+            if (key === facingModeKey) {
+                const facingMode = cameraIdOrConfig.facingMode;
+                if (typeof facingMode == "string") {
+                    if (isValidFacingModeValue(facingMode)) {
+                        return { facingMode: facingMode };
+                    }
+                }
+                else if (typeof facingMode == "object") {
+                    if (exactKey in facingMode) {
+                        if (isValidFacingModeValue(facingMode[`${exactKey}`])) {
+                            return {
+                                facingMode: {
+                                    exact: facingMode[`${exactKey}`]
+                                }
+                            };
+                        }
+                    }
+                    else {
+                        throw "'facingMode' should be string or object with"
+                            + ` ${exactKey} as key.`;
+                    }
+                }
+                else {
+                    const type = (typeof facingMode);
+                    throw `Invalid type of 'facingMode' = ${type}`;
+                }
+            }
+            else {
+                const deviceId = cameraIdOrConfig.deviceId;
+                if (typeof deviceId == "string") {
+                    return { deviceId: deviceId };
+                }
+                else if (typeof deviceId == "object") {
+                    if (exactKey in deviceId) {
+                        return {
+                            deviceId: { exact: deviceId[`${exactKey}`] }
+                        };
+                    }
+                    else {
+                        throw "'deviceId' should be string or object with"
+                            + ` ${exactKey} as key.`;
+                    }
+                }
+                else {
+                    const type = (typeof deviceId);
+                    throw `Invalid type of 'deviceId' = ${type}`;
+                }
+            }
+        }
+        const type = (typeof cameraIdOrConfig);
+        throw `Invalid type of 'cameraIdOrConfig' = ${type}`;
+    }
+    computeCanvasDrawConfig(imageWidth, imageHeight, containerWidth, containerHeight) {
+        if (imageWidth <= containerWidth
+            && imageHeight <= containerHeight) {
+            const xoffset = (containerWidth - imageWidth) / 2;
+            const yoffset = (containerHeight - imageHeight) / 2;
+            return {
+                x: xoffset,
+                y: yoffset,
+                width: imageWidth,
+                height: imageHeight
+            };
+        }
+        else {
+            const formerImageWidth = imageWidth;
+            const formerImageHeight = imageHeight;
+            if (imageWidth > containerWidth) {
+                imageHeight = (containerWidth / imageWidth) * imageHeight;
+                imageWidth = containerWidth;
+            }
+            if (imageHeight > containerHeight) {
+                imageWidth = (containerHeight / imageHeight) * imageWidth;
+                imageHeight = containerHeight;
+            }
+            this.logger.log("Image downsampled from "
+                + `${formerImageWidth}X${formerImageHeight}`
+                + ` to ${imageWidth}X${imageHeight}.`);
+            return this.computeCanvasDrawConfig(imageWidth, imageHeight, containerWidth, containerHeight);
+        }
+    }
+    clearElement() {
+        if (this.stateManagerProxy.isScanning()) {
+            throw "Cannot clear while scan is ongoing, close it first.";
+        }
+        const element = document.getElementById(this.elementId);
+        if (element) {
+            element.innerHTML = "";
+        }
+    }
+    possiblyUpdateShaders(qrMatch) {
+        if (this.qrMatch === qrMatch) {
+            return;
+        }
+        if (this.hasBorderShaders
+            && this.borderShaders
+            && this.borderShaders.length) {
+            this.borderShaders.forEach((shader) => {
+                shader.style.backgroundColor = qrMatch
+                    ? Constants.BORDER_SHADER_MATCH_COLOR
+                    : Constants.BORDER_SHADER_DEFAULT_COLOR;
+            });
+        }
+        this.qrMatch = qrMatch;
+    }
+    possiblyCloseLastScanImageFile() {
+        if (this.lastScanImageFile) {
+            URL.revokeObjectURL(this.lastScanImageFile);
+            this.lastScanImageFile = null;
+        }
+    }
+    createCanvasElement(width, height, customId) {
+        const canvasWidth = width;
+        const canvasHeight = height;
+        const canvasElement = document.createElement("canvas");
+        canvasElement.style.width = `${canvasWidth}px`;
+        canvasElement.style.height = `${canvasHeight}px`;
+        canvasElement.style.display = "none";
+        canvasElement.id = isNullOrUndefined(customId)
+            ? "qr-canvas" : customId;
+        return canvasElement;
+    }
+    getShadedRegionBounds(width, height, qrboxSize) {
+        if (qrboxSize.width > width || qrboxSize.height > height) {
+            throw "'config.qrbox' dimensions should not be greater than the "
+                + "dimensions of the root HTML element.";
+        }
+        return {
+            x: (width - qrboxSize.width) / 2,
+            y: (height - qrboxSize.height) / 2,
+            width: qrboxSize.width,
+            height: qrboxSize.height
+        };
+    }
+    possiblyInsertShadingElement(element, width, height, qrboxSize) {
+        if ((width - qrboxSize.width) < 1 || (height - qrboxSize.height) < 1) {
+            return;
+        }
+        const shadingElement = document.createElement("div");
+        shadingElement.style.position = "absolute";
+        const rightLeftBorderSize = (width - qrboxSize.width) / 2;
+        const topBottomBorderSize = (height - qrboxSize.height) / 2;
+        shadingElement.style.borderLeft
+            = `${rightLeftBorderSize}px solid rgba(0, 0, 0, 0.48)`;
+        shadingElement.style.borderRight
+            = `${rightLeftBorderSize}px solid rgba(0, 0, 0, 0.48)`;
+        shadingElement.style.borderTop
+            = `${topBottomBorderSize}px solid rgba(0, 0, 0, 0.48)`;
+        shadingElement.style.borderBottom
+            = `${topBottomBorderSize}px solid rgba(0, 0, 0, 0.48)`;
+        shadingElement.style.boxSizing = "border-box";
+        shadingElement.style.top = "0px";
+        shadingElement.style.bottom = "0px";
+        shadingElement.style.left = "0px";
+        shadingElement.style.right = "0px";
+        shadingElement.id = `${Constants.SHADED_REGION_ELEMENT_ID}`;
+        if ((width - qrboxSize.width) < 11
+            || (height - qrboxSize.height) < 11) {
+            this.hasBorderShaders = false;
+        }
+        else {
+            const smallSize = 5;
+            const largeSize = 40;
+            this.insertShaderBorders(shadingElement, largeSize, smallSize, -smallSize, null, 0, true);
+            this.insertShaderBorders(shadingElement, largeSize, smallSize, -smallSize, null, 0, false);
+            this.insertShaderBorders(shadingElement, largeSize, smallSize, null, -smallSize, 0, true);
+            this.insertShaderBorders(shadingElement, largeSize, smallSize, null, -smallSize, 0, false);
+            this.insertShaderBorders(shadingElement, smallSize, largeSize + smallSize, -smallSize, null, -smallSize, true);
+            this.insertShaderBorders(shadingElement, smallSize, largeSize + smallSize, null, -smallSize, -smallSize, true);
+            this.insertShaderBorders(shadingElement, smallSize, largeSize + smallSize, -smallSize, null, -smallSize, false);
+            this.insertShaderBorders(shadingElement, smallSize, largeSize + smallSize, null, -smallSize, -smallSize, false);
+            this.hasBorderShaders = true;
+        }
+        element.append(shadingElement);
+    }
+    insertShaderBorders(shaderElem, width, height, top, bottom, side, isLeft) {
+        const elem = document.createElement("div");
+        elem.style.position = "absolute";
+        elem.style.backgroundColor = Constants.BORDER_SHADER_DEFAULT_COLOR;
+        elem.style.width = `${width}px`;
+        elem.style.height = `${height}px`;
+        if (top !== null) {
+            elem.style.top = `${top}px`;
+        }
+        if (bottom !== null) {
+            elem.style.bottom = `${bottom}px`;
+        }
+        if (isLeft) {
+            elem.style.left = `${side}px`;
+        }
+        else {
+            elem.style.right = `${side}px`;
+        }
+        if (!this.borderShaders) {
+            this.borderShaders = [];
+        }
+        this.borderShaders.push(elem);
+        shaderElem.appendChild(elem);
+    }
+    showPausedState() {
+        if (!this.scannerPausedUiElement) {
+            throw "[internal error] scanner paused UI element not found";
+        }
+        this.scannerPausedUiElement.style.display = "block";
+    }
+    hidePausedState() {
+        if (!this.scannerPausedUiElement) {
+            throw "[internal error] scanner paused UI element not found";
+        }
+        this.scannerPausedUiElement.style.display = "none";
+    }
+    getTimeoutFps(fps) {
+        return 1000 / fps;
+    }
+}
+//# sourceMappingURL=html5-qrcode.js.map

node_modules/html5-qrcode/es2015/image-assets.d.ts

@@ -0,0 +1,4 @@
+export declare const ASSET_CAMERA_SCAN: string;
+export declare const ASSET_FILE_SCAN: string;
+export declare const ASSET_INFO_ICON_16PX: string;
+export declare const ASSET_CLOSE_ICON_16PX: string;

node_modules/html5-qrcode/es2015/image-assets.js

@@ -0,0 +1,6 @@
+const SVG_XML_PREFIX = "data:image/svg+xml;base64,";
+export const ASSET_CAMERA_SCAN = SVG_XML_PREFIX + "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";
+export const ASSET_FILE_SCAN = SVG_XML_PREFIX + "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA1OS4wMTggNTkuMDE4IiBzdHlsZT0iZW5hYmxlLWJhY2tncm91bmQ6bmV3IDAgMCA1OS4wMTggNTkuMDE4IiB4bWw6c3BhY2U9InByZXNlcnZlIj48cGF0aCBkPSJtNTguNzQxIDU0LjgwOS01Ljk2OS02LjI0NGExMC43NCAxMC43NCAwIDAgMCAyLjgyLTcuMjVjMC01Ljk1My00Ljg0My0xMC43OTYtMTAuNzk2LTEwLjc5NlMzNCAzNS4zNjEgMzQgNDEuMzE0IDM4Ljg0MyA1Mi4xMSA0NC43OTYgNTIuMTFjMi40NDEgMCA0LjY4OC0uODI0IDYuNDk5LTIuMTk2bDYuMDAxIDYuMjc3YS45OTguOTk4IDAgMCAwIDEuNDE0LjAzMiAxIDEgMCAwIDAgLjAzMS0xLjQxNHpNMzYgNDEuMzE0YzAtNC44NSAzLjk0Ni04Ljc5NiA4Ljc5Ni04Ljc5NnM4Ljc5NiAzLjk0NiA4Ljc5NiA4Ljc5Ni0zLjk0NiA4Ljc5Ni04Ljc5NiA4Ljc5NlMzNiA0Ni4xNjQgMzYgNDEuMzE0ek0xMC40MzEgMTYuMDg4YzAgMy4wNyAyLjQ5OCA1LjU2OCA1LjU2OSA1LjU2OHM1LjU2OS0yLjQ5OCA1LjU2OS01LjU2OGMwLTMuMDcxLTIuNDk4LTUuNTY5LTUuNTY5LTUuNTY5cy01LjU2OSAyLjQ5OC01LjU2OSA1LjU2OXptOS4xMzggMGMwIDEuOTY4LTEuNjAyIDMuNTY4LTMuNTY5IDMuNTY4cy0zLjU2OS0xLjYwMS0zLjU2OS0zLjU2OCAxLjYwMi0zLjU2OSAzLjU2OS0zLjU2OSAzLjU2OSAxLjYwMSAzLjU2OSAzLjU2OXoiLz48cGF0aCBkPSJtMzAuODgyIDI4Ljk4NyA5LjE4LTEwLjA1NCAxMS4yNjIgMTAuMzIzYTEgMSAwIDAgMCAxLjM1MS0xLjQ3NWwtMTItMTFhMSAxIDAgMCAwLTEuNDE0LjA2M2wtOS43OTQgMTAuNzI3LTQuNzQzLTQuNzQzYTEuMDAzIDEuMDAzIDAgMCAwLTEuMzY4LS4wNDRMNi4zMzkgMzcuNzY4YTEgMSAwIDEgMCAxLjMyMiAxLjUwMWwxNi4zMTMtMTQuMzYyIDcuMzE5IDcuMzE4YS45OTkuOTk5IDAgMSAwIDEuNDE0LTEuNDE0bC0xLjgyNS0xLjgyNHoiLz48cGF0aCBkPSJNMzAgNDYuNTE4SDJ2LTQyaDU0djI4YTEgMSAwIDEgMCAyIDB2LTI5YTEgMSAwIDAgMC0xLTFIMWExIDEgMCAwIDAtMSAxdjQ0YTEgMSAwIDAgMCAxIDFoMjlhMSAxIDAgMSAwIDAtMnoiLz48L3N2Zz4=";
+export const ASSET_INFO_ICON_16PX = SVG_XML_PREFIX + "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0NjAgNDYwIiBzdHlsZT0iZW5hYmxlLWJhY2tncm91bmQ6bmV3IDAgMCA0NjAgNDYwIiB4bWw6c3BhY2U9InByZXNlcnZlIj48cGF0aCBkPSJNMjMwIDBDMTAyLjk3NSAwIDAgMTAyLjk3NSAwIDIzMHMxMDIuOTc1IDIzMCAyMzAgMjMwIDIzMC0xMDIuOTc0IDIzMC0yMzBTMzU3LjAyNSAwIDIzMCAwem0zOC4zMzMgMzc3LjM2YzAgOC42NzYtNy4wMzQgMTUuNzEtMTUuNzEgMTUuNzFoLTQzLjEwMWMtOC42NzYgMC0xNS43MS03LjAzNC0xNS43MS0xNS43MVYyMDIuNDc3YzAtOC42NzYgNy4wMzMtMTUuNzEgMTUuNzEtMTUuNzFoNDMuMTAxYzguNjc2IDAgMTUuNzEgNy4wMzMgMTUuNzEgMTUuNzFWMzc3LjM2ek0yMzAgMTU3Yy0yMS41MzkgMC0zOS0xNy40NjEtMzktMzlzMTcuNDYxLTM5IDM5LTM5IDM5IDE3LjQ2MSAzOSAzOS0xNy40NjEgMzktMzkgMzl6Ii8+PC9zdmc+";
+export const ASSET_CLOSE_ICON_16PX = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAAQgAAAEIBarqQRAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAE1SURBVDiNfdI7S0NBEAXgLya1otFgpbYSbISAgpXYi6CmiH9KCAiChaVga6OiWPgfRDQ+0itaGVNosXtluWwcuMzePfM4M3sq8lbHBubwg1dc4m1E/J/N4ghDPOIsfk/4xiEao5KX0McFljN4C9d4QTPXuY99jP3DsIoDPGM6BY5i5yI5R7O4q+ImFkJY2DCh3cAH2klyB+9J1xUMMAG7eCh1a+Mr+k48b5diXrFVwwLuS+BJ9MfR7+G0FHOHhTHhnXNWS87VDF4pcnfQK4Ep7XScNLmPTZgURNKKYENYWDpzW1BhscS1WHS8CDgURFJQrWcoF3c13KKbgg1BYQfy8xZWEzTTw1QZbAoKu8FqJnktdu5hcVSHmchiILzzuaDQvjBzV2m8yohCE1jHfPx/xhU+y4G/D75ELlRJsSYAAAAASUVORK5CYII=";
+//# sourceMappingURL=image-assets.js.map

node_modules/html5-qrcode/es2015/image-assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-assets.js","sourceRoot":"","sources":["../../src/image-assets.ts"],"names":[],"mappings":"AASA,MAAM,cAAc,GAAG,4BAA4B,CAAC;AAEpD,MAAM,CAAC,MAAM,iBAAiB,GAAW,cAAc,GAAG,82GAA82G,CAAC;AAEz6G,MAAM,CAAC,MAAM,eAAe,GAAW,cAAc,GAAG,s8CAAs8C,CAAC;AAE//C,MAAM,CAAC,MAAM,oBAAoB,GAAY,cAAc,GAAG,8oBAA8oB,CAAC;AAE7sB,MAAM,CAAC,MAAM,qBAAqB,GAAY,omBAAomB,CAAC"}

node_modules/html5-qrcode/es2015/index.d.ts

@@ -0,0 +1,6 @@
+export { Html5Qrcode, Html5QrcodeFullConfig, Html5QrcodeCameraScanConfig } from "./html5-qrcode";
+export { Html5QrcodeScanner } from "./html5-qrcode-scanner";
+export { Html5QrcodeSupportedFormats, Html5QrcodeResult, QrcodeSuccessCallback, QrcodeErrorCallback } from "./core";
+export { Html5QrcodeScannerState } from "./state-manager";
+export { Html5QrcodeScanType } from "./core";
+export { CameraCapabilities, CameraDevice } from "./camera/core";

node_modules/html5-qrcode/es2015/index.js

@@ -0,0 +1,6 @@
+export { Html5Qrcode } from "./html5-qrcode";
+export { Html5QrcodeScanner } from "./html5-qrcode-scanner";
+export { Html5QrcodeSupportedFormats } from "./core";
+export { Html5QrcodeScannerState } from "./state-manager";
+export { Html5QrcodeScanType } from "./core";
+//# sourceMappingURL=index.js.map

node_modules/html5-qrcode/es2015/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAcA,OAAO,EACH,WAAW,EAGd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EACH,2BAA2B,EAI9B,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC"}

node_modules/html5-qrcode/es2015/native-bar-code-detector.d.ts

@@ -0,0 +1,16 @@
+import { QrcodeResult, Html5QrcodeSupportedFormats, QrcodeDecoderAsync, Logger } from "./core";
+export declare class BarcodeDetectorDelegate implements QrcodeDecoderAsync {
+    private readonly formatMap;
+    private readonly reverseFormatMap;
+    private verbose;
+    private logger;
+    private detector;
+    static isSupported(): boolean;
+    constructor(requestedFormats: Array<Html5QrcodeSupportedFormats>, verbose: boolean, logger: Logger);
+    decodeAsync(canvas: HTMLCanvasElement): Promise<QrcodeResult>;
+    private selectLargestBarcode;
+    private createBarcodeDetectorFormats;
+    private toHtml5QrcodeSupportedFormats;
+    private createReverseFormatMap;
+    private createDebugData;
+}

node_modules/html5-qrcode/es2015/native-bar-code-detector.js

@@ -0,0 +1,107 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { QrcodeResultFormat, Html5QrcodeSupportedFormats } from "./core";
+export class BarcodeDetectorDelegate {
+    static isSupported() {
+        if (!("BarcodeDetector" in window)) {
+            return false;
+        }
+        const dummyDetector = new BarcodeDetector({ formats: ["qr_code"] });
+        return typeof dummyDetector !== "undefined";
+    }
+    constructor(requestedFormats, verbose, logger) {
+        this.formatMap = new Map([
+            [Html5QrcodeSupportedFormats.QR_CODE, "qr_code"],
+            [Html5QrcodeSupportedFormats.AZTEC, "aztec"],
+            [Html5QrcodeSupportedFormats.CODABAR, "codabar"],
+            [Html5QrcodeSupportedFormats.CODE_39, "code_39"],
+            [Html5QrcodeSupportedFormats.CODE_93, "code_93"],
+            [Html5QrcodeSupportedFormats.CODE_128, "code_128"],
+            [Html5QrcodeSupportedFormats.DATA_MATRIX, "data_matrix"],
+            [Html5QrcodeSupportedFormats.ITF, "itf"],
+            [Html5QrcodeSupportedFormats.EAN_13, "ean_13"],
+            [Html5QrcodeSupportedFormats.EAN_8, "ean_8"],
+            [Html5QrcodeSupportedFormats.PDF_417, "pdf417"],
+            [Html5QrcodeSupportedFormats.UPC_A, "upc_a"],
+            [Html5QrcodeSupportedFormats.UPC_E, "upc_e"]
+        ]);
+        this.reverseFormatMap = this.createReverseFormatMap();
+        if (!BarcodeDetectorDelegate.isSupported()) {
+            throw "Use html5qrcode.min.js without edit, Use "
+                + "BarcodeDetectorDelegate only if it isSupported();";
+        }
+        this.verbose = verbose;
+        this.logger = logger;
+        const formats = this.createBarcodeDetectorFormats(requestedFormats);
+        this.detector = new BarcodeDetector(formats);
+        if (!this.detector) {
+            throw "BarcodeDetector detector not supported";
+        }
+    }
+    decodeAsync(canvas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const barcodes = yield this.detector.detect(canvas);
+            if (!barcodes || barcodes.length === 0) {
+                throw "No barcode or QR code detected.";
+            }
+            let largestBarcode = this.selectLargestBarcode(barcodes);
+            return {
+                text: largestBarcode.rawValue,
+                format: QrcodeResultFormat.create(this.toHtml5QrcodeSupportedFormats(largestBarcode.format)),
+                debugData: this.createDebugData()
+            };
+        });
+    }
+    selectLargestBarcode(barcodes) {
+        let largestBarcode = null;
+        let maxArea = 0;
+        for (let barcode of barcodes) {
+            let area = barcode.boundingBox.width * barcode.boundingBox.height;
+            if (area > maxArea) {
+                maxArea = area;
+                largestBarcode = barcode;
+            }
+        }
+        if (!largestBarcode) {
+            throw "No largest barcode found";
+        }
+        return largestBarcode;
+    }
+    createBarcodeDetectorFormats(requestedFormats) {
+        let formats = [];
+        for (const requestedFormat of requestedFormats) {
+            if (this.formatMap.has(requestedFormat)) {
+                formats.push(this.formatMap.get(requestedFormat));
+            }
+            else {
+                this.logger.warn(`${requestedFormat} is not supported by`
+                    + "BarcodeDetectorDelegate");
+            }
+        }
+        return { formats: formats };
+    }
+    toHtml5QrcodeSupportedFormats(barcodeDetectorFormat) {
+        if (!this.reverseFormatMap.has(barcodeDetectorFormat)) {
+            throw `reverseFormatMap doesn't have ${barcodeDetectorFormat}`;
+        }
+        return this.reverseFormatMap.get(barcodeDetectorFormat);
+    }
+    createReverseFormatMap() {
+        let result = new Map();
+        this.formatMap.forEach((value, key, _) => {
+            result.set(value, key);
+        });
+        return result;
+    }
+    createDebugData() {
+        return { decoderName: "BarcodeDetector" };
+    }
+}
+//# sourceMappingURL=native-bar-code-detector.js.map

node_modules/html5-qrcode/es2015/native-bar-code-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-bar-code-detector.js","sourceRoot":"","sources":["../../src/native-bar-code-detector.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/state-manager.d.ts

@@ -0,0 +1,29 @@
+export declare enum Html5QrcodeScannerState {
+    UNKNOWN = 0,
+    NOT_STARTED = 1,
+    SCANNING = 2,
+    PAUSED = 3
+}
+export interface StateManagerTransaction {
+    execute(): void;
+    cancel(): void;
+}
+export interface StateManager {
+    startTransition(newState: Html5QrcodeScannerState): StateManagerTransaction;
+    directTransition(newState: Html5QrcodeScannerState): void;
+    getState(): Html5QrcodeScannerState;
+}
+export declare class StateManagerProxy {
+    private stateManager;
+    constructor(stateManager: StateManager);
+    startTransition(newState: Html5QrcodeScannerState): StateManagerTransaction;
+    directTransition(newState: Html5QrcodeScannerState): void;
+    getState(): Html5QrcodeScannerState;
+    canScanFile(): boolean;
+    isScanning(): boolean;
+    isStrictlyScanning(): boolean;
+    isPaused(): boolean;
+}
+export declare class StateManagerFactory {
+    static create(): StateManagerProxy;
+}

node_modules/html5-qrcode/es2015/state-manager.js

@@ -0,0 +1,101 @@
+export var Html5QrcodeScannerState;
+(function (Html5QrcodeScannerState) {
+    Html5QrcodeScannerState[Html5QrcodeScannerState["UNKNOWN"] = 0] = "UNKNOWN";
+    Html5QrcodeScannerState[Html5QrcodeScannerState["NOT_STARTED"] = 1] = "NOT_STARTED";
+    Html5QrcodeScannerState[Html5QrcodeScannerState["SCANNING"] = 2] = "SCANNING";
+    Html5QrcodeScannerState[Html5QrcodeScannerState["PAUSED"] = 3] = "PAUSED";
+})(Html5QrcodeScannerState || (Html5QrcodeScannerState = {}));
+class StateManagerImpl {
+    constructor() {
+        this.state = Html5QrcodeScannerState.NOT_STARTED;
+        this.onGoingTransactionNewState = Html5QrcodeScannerState.UNKNOWN;
+    }
+    directTransition(newState) {
+        this.failIfTransitionOngoing();
+        this.validateTransition(newState);
+        this.state = newState;
+    }
+    startTransition(newState) {
+        this.failIfTransitionOngoing();
+        this.validateTransition(newState);
+        this.onGoingTransactionNewState = newState;
+        return this;
+    }
+    execute() {
+        if (this.onGoingTransactionNewState
+            === Html5QrcodeScannerState.UNKNOWN) {
+            throw "Transaction is already cancelled, cannot execute().";
+        }
+        const tempNewState = this.onGoingTransactionNewState;
+        this.onGoingTransactionNewState = Html5QrcodeScannerState.UNKNOWN;
+        this.directTransition(tempNewState);
+    }
+    cancel() {
+        if (this.onGoingTransactionNewState
+            === Html5QrcodeScannerState.UNKNOWN) {
+            throw "Transaction is already cancelled, cannot cancel().";
+        }
+        this.onGoingTransactionNewState = Html5QrcodeScannerState.UNKNOWN;
+    }
+    getState() {
+        return this.state;
+    }
+    failIfTransitionOngoing() {
+        if (this.onGoingTransactionNewState
+            !== Html5QrcodeScannerState.UNKNOWN) {
+            throw "Cannot transition to a new state, already under transition";
+        }
+    }
+    validateTransition(newState) {
+        switch (this.state) {
+            case Html5QrcodeScannerState.UNKNOWN:
+                throw "Transition from unknown is not allowed";
+            case Html5QrcodeScannerState.NOT_STARTED:
+                this.failIfNewStateIs(newState, [Html5QrcodeScannerState.PAUSED]);
+                break;
+            case Html5QrcodeScannerState.SCANNING:
+                break;
+            case Html5QrcodeScannerState.PAUSED:
+                break;
+        }
+    }
+    failIfNewStateIs(newState, disallowedStatesToTransition) {
+        for (const disallowedState of disallowedStatesToTransition) {
+            if (newState === disallowedState) {
+                throw `Cannot transition from ${this.state} to ${newState}`;
+            }
+        }
+    }
+}
+export class StateManagerProxy {
+    constructor(stateManager) {
+        this.stateManager = stateManager;
+    }
+    startTransition(newState) {
+        return this.stateManager.startTransition(newState);
+    }
+    directTransition(newState) {
+        this.stateManager.directTransition(newState);
+    }
+    getState() {
+        return this.stateManager.getState();
+    }
+    canScanFile() {
+        return this.stateManager.getState() === Html5QrcodeScannerState.NOT_STARTED;
+    }
+    isScanning() {
+        return this.stateManager.getState() !== Html5QrcodeScannerState.NOT_STARTED;
+    }
+    isStrictlyScanning() {
+        return this.stateManager.getState() === Html5QrcodeScannerState.SCANNING;
+    }
+    isPaused() {
+        return this.stateManager.getState() === Html5QrcodeScannerState.PAUSED;
+    }
+}
+export class StateManagerFactory {
+    static create() {
+        return new StateManagerProxy(new StateManagerImpl());
+    }
+}
+//# sourceMappingURL=state-manager.js.map

node_modules/html5-qrcode/es2015/state-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-manager.js","sourceRoot":"","sources":["../../src/state-manager.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/storage.d.ts

@@ -0,0 +1,12 @@
+export declare class PersistedDataManager {
+    private data;
+    private static LOCAL_STORAGE_KEY;
+    constructor();
+    hasCameraPermissions(): boolean;
+    getLastUsedCameraId(): string | null;
+    setHasPermission(hasPermission: boolean): void;
+    setLastUsedCameraId(lastUsedCameraId: string): void;
+    resetLastUsedCameraId(): void;
+    reset(): void;
+    private flush;
+}

node_modules/html5-qrcode/es2015/storage.js

@@ -0,0 +1,47 @@
+class PersistedDataFactory {
+    static createDefault() {
+        return {
+            hasPermission: false,
+            lastUsedCameraId: null
+        };
+    }
+}
+export class PersistedDataManager {
+    constructor() {
+        this.data = PersistedDataFactory.createDefault();
+        let data = localStorage.getItem(PersistedDataManager.LOCAL_STORAGE_KEY);
+        if (!data) {
+            this.reset();
+        }
+        else {
+            this.data = JSON.parse(data);
+        }
+    }
+    hasCameraPermissions() {
+        return this.data.hasPermission;
+    }
+    getLastUsedCameraId() {
+        return this.data.lastUsedCameraId;
+    }
+    setHasPermission(hasPermission) {
+        this.data.hasPermission = hasPermission;
+        this.flush();
+    }
+    setLastUsedCameraId(lastUsedCameraId) {
+        this.data.lastUsedCameraId = lastUsedCameraId;
+        this.flush();
+    }
+    resetLastUsedCameraId() {
+        this.data.lastUsedCameraId = null;
+        this.flush();
+    }
+    reset() {
+        this.data = PersistedDataFactory.createDefault();
+        this.flush();
+    }
+    flush() {
+        localStorage.setItem(PersistedDataManager.LOCAL_STORAGE_KEY, JSON.stringify(this.data));
+    }
+}
+PersistedDataManager.LOCAL_STORAGE_KEY = "HTML5_QRCODE_DATA";
+//# sourceMappingURL=storage.js.map

node_modules/html5-qrcode/es2015/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/storage.ts"],"names":[],"mappings":"AAeA,MAAM,oBAAoB;IACtB,MAAM,CAAC,aAAa;QAChB,OAAO;YACH,aAAa,EAAE,KAAK;YACpB,gBAAgB,EAAE,IAAI;SACzB,CAAC;IACN,CAAC;CACJ;AAED,MAAM,OAAO,oBAAoB;IAK7B;QAHQ,SAAI,GAAkB,oBAAoB,CAAC,aAAa,EAAE,CAAC;QAI/D,IAAI,IAAI,GAAG,YAAY,CAAC,OAAO,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,CAAC;QACxE,IAAI,CAAC,IAAI,EAAE;YACP,IAAI,CAAC,KAAK,EAAE,CAAC;SAChB;aAAM;YACH,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;SAChC;IACL,CAAC;IAEM,oBAAoB;QACvB,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;IACnC,CAAC;IAEM,mBAAmB;QACtB,OAAO,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC;IACtC,CAAC;IAEM,gBAAgB,CAAC,aAAsB;QAC1C,IAAI,CAAC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACxC,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAEM,mBAAmB,CAAC,gBAAwB;QAC/C,IAAI,CAAC,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;QAC9C,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAEM,qBAAqB;QACxB,IAAI,CAAC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAClC,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAEM,KAAK;QACR,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC,aAAa,EAAE,CAAC;QACjD,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAEO,KAAK;QACT,YAAY,CAAC,OAAO,CAChB,oBAAoB,CAAC,iBAAiB,EACtC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACnC,CAAC;;AA3Cc,sCAAiB,GAAW,mBAAmB,CAAC"}

node_modules/html5-qrcode/es2015/strings.d.ts

@@ -0,0 +1,45 @@
+export declare class Html5QrcodeStrings {
+    static codeParseError(exception: any): string;
+    static errorGettingUserMedia(error: any): string;
+    static onlyDeviceSupportedError(): string;
+    static cameraStreamingNotSupported(): string;
+    static unableToQuerySupportedDevices(): string;
+    static insecureContextCameraQueryError(): string;
+    static scannerPaused(): string;
+}
+export declare class Html5QrcodeScannerStrings {
+    static scanningStatus(): string;
+    static idleStatus(): string;
+    static errorStatus(): string;
+    static permissionStatus(): string;
+    static noCameraFoundErrorStatus(): string;
+    static lastMatch(decodedText: string): string;
+    static codeScannerTitle(): string;
+    static cameraPermissionTitle(): string;
+    static cameraPermissionRequesting(): string;
+    static noCameraFound(): string;
+    static scanButtonStopScanningText(): string;
+    static scanButtonStartScanningText(): string;
+    static torchOnButton(): string;
+    static torchOffButton(): string;
+    static torchOnFailedMessage(): string;
+    static torchOffFailedMessage(): string;
+    static scanButtonScanningStarting(): string;
+    static textIfCameraScanSelected(): string;
+    static textIfFileScanSelected(): string;
+    static selectCamera(): string;
+    static fileSelectionChooseImage(): string;
+    static fileSelectionChooseAnother(): string;
+    static fileSelectionNoImageSelected(): string;
+    static anonymousCameraPrefix(): string;
+    static dragAndDropMessage(): string;
+    static dragAndDropMessageOnlyImages(): string;
+    static zoom(): string;
+    static loadingImage(): string;
+    static cameraScanAltText(): string;
+    static fileScanAltText(): string;
+}
+export declare class LibraryInfoStrings {
+    static poweredBy(): string;
+    static reportIssues(): string;
+}

node_modules/html5-qrcode/es2015/strings.js

@@ -0,0 +1,127 @@
+export class Html5QrcodeStrings {
+    static codeParseError(exception) {
+        return `QR code parse error, error = ${exception}`;
+    }
+    static errorGettingUserMedia(error) {
+        return `Error getting userMedia, error = ${error}`;
+    }
+    static onlyDeviceSupportedError() {
+        return "The device doesn't support navigator.mediaDevices , only "
+            + "supported cameraIdOrConfig in this case is deviceId parameter "
+            + "(string).";
+    }
+    static cameraStreamingNotSupported() {
+        return "Camera streaming not supported by the browser.";
+    }
+    static unableToQuerySupportedDevices() {
+        return "Unable to query supported devices, unknown error.";
+    }
+    static insecureContextCameraQueryError() {
+        return "Camera access is only supported in secure context like https "
+            + "or localhost.";
+    }
+    static scannerPaused() {
+        return "Scanner paused";
+    }
+}
+export class Html5QrcodeScannerStrings {
+    static scanningStatus() {
+        return "Scanning";
+    }
+    static idleStatus() {
+        return "Idle";
+    }
+    static errorStatus() {
+        return "Error";
+    }
+    static permissionStatus() {
+        return "Permission";
+    }
+    static noCameraFoundErrorStatus() {
+        return "No Cameras";
+    }
+    static lastMatch(decodedText) {
+        return `Last Match: ${decodedText}`;
+    }
+    static codeScannerTitle() {
+        return "Code Scanner";
+    }
+    static cameraPermissionTitle() {
+        return "Request Camera Permissions";
+    }
+    static cameraPermissionRequesting() {
+        return "Requesting camera permissions...";
+    }
+    static noCameraFound() {
+        return "No camera found";
+    }
+    static scanButtonStopScanningText() {
+        return "Stop Scanning";
+    }
+    static scanButtonStartScanningText() {
+        return "Start Scanning";
+    }
+    static torchOnButton() {
+        return "Switch On Torch";
+    }
+    static torchOffButton() {
+        return "Switch Off Torch";
+    }
+    static torchOnFailedMessage() {
+        return "Failed to turn on torch";
+    }
+    static torchOffFailedMessage() {
+        return "Failed to turn off torch";
+    }
+    static scanButtonScanningStarting() {
+        return "Launching Camera...";
+    }
+    static textIfCameraScanSelected() {
+        return "Scan an Image File";
+    }
+    static textIfFileScanSelected() {
+        return "Scan using camera directly";
+    }
+    static selectCamera() {
+        return "Select Camera";
+    }
+    static fileSelectionChooseImage() {
+        return "Choose Image";
+    }
+    static fileSelectionChooseAnother() {
+        return "Choose Another";
+    }
+    static fileSelectionNoImageSelected() {
+        return "No image choosen";
+    }
+    static anonymousCameraPrefix() {
+        return "Anonymous Camera";
+    }
+    static dragAndDropMessage() {
+        return "Or drop an image to scan";
+    }
+    static dragAndDropMessageOnlyImages() {
+        return "Or drop an image to scan (other files not supported)";
+    }
+    static zoom() {
+        return "zoom";
+    }
+    static loadingImage() {
+        return "Loading image...";
+    }
+    static cameraScanAltText() {
+        return "Camera based scan";
+    }
+    static fileScanAltText() {
+        return "Fule based scan";
+    }
+}
+export class LibraryInfoStrings {
+    static poweredBy() {
+        return "Powered by ";
+    }
+    static reportIssues() {
+        return "Report issues";
+    }
+}
+//# sourceMappingURL=strings.js.map

node_modules/html5-qrcode/es2015/strings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.js","sourceRoot":"","sources":["../../src/strings.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/ui.d.ts

@@ -0,0 +1,6 @@
+export declare class LibraryInfoContainer {
+    private infoDiv;
+    private infoIcon;
+    constructor();
+    renderInto(parent: HTMLElement): void;
+}

node_modules/html5-qrcode/es2015/ui.js

@@ -0,0 +1,109 @@
+import { ASSET_CLOSE_ICON_16PX, ASSET_INFO_ICON_16PX } from "./image-assets";
+import { LibraryInfoStrings } from "./strings";
+class LibraryInfoDiv {
+    constructor() {
+        this.infoDiv = document.createElement("div");
+    }
+    renderInto(parent) {
+        this.infoDiv.style.position = "absolute";
+        this.infoDiv.style.top = "10px";
+        this.infoDiv.style.right = "10px";
+        this.infoDiv.style.zIndex = "2";
+        this.infoDiv.style.display = "none";
+        this.infoDiv.style.padding = "5pt";
+        this.infoDiv.style.border = "1px solid #171717";
+        this.infoDiv.style.fontSize = "10pt";
+        this.infoDiv.style.background = "rgb(0 0 0 / 69%)";
+        this.infoDiv.style.borderRadius = "5px";
+        this.infoDiv.style.textAlign = "center";
+        this.infoDiv.style.fontWeight = "400";
+        this.infoDiv.style.color = "white";
+        this.infoDiv.innerText = LibraryInfoStrings.poweredBy();
+        const projectLink = document.createElement("a");
+        projectLink.innerText = "ScanApp";
+        projectLink.href = "https://scanapp.org";
+        projectLink.target = "new";
+        projectLink.style.color = "white";
+        this.infoDiv.appendChild(projectLink);
+        const breakElemFirst = document.createElement("br");
+        const breakElemSecond = document.createElement("br");
+        this.infoDiv.appendChild(breakElemFirst);
+        this.infoDiv.appendChild(breakElemSecond);
+        const reportIssueLink = document.createElement("a");
+        reportIssueLink.innerText = LibraryInfoStrings.reportIssues();
+        reportIssueLink.href = "https://github.com/mebjas/html5-qrcode/issues";
+        reportIssueLink.target = "new";
+        reportIssueLink.style.color = "white";
+        this.infoDiv.appendChild(reportIssueLink);
+        parent.appendChild(this.infoDiv);
+    }
+    show() {
+        this.infoDiv.style.display = "block";
+    }
+    hide() {
+        this.infoDiv.style.display = "none";
+    }
+}
+class LibraryInfoIcon {
+    constructor(onTapIn, onTapOut) {
+        this.isShowingInfoIcon = true;
+        this.onTapIn = onTapIn;
+        this.onTapOut = onTapOut;
+        this.infoIcon = document.createElement("img");
+    }
+    renderInto(parent) {
+        this.infoIcon.alt = "Info icon";
+        this.infoIcon.src = ASSET_INFO_ICON_16PX;
+        this.infoIcon.style.position = "absolute";
+        this.infoIcon.style.top = "4px";
+        this.infoIcon.style.right = "4px";
+        this.infoIcon.style.opacity = "0.6";
+        this.infoIcon.style.cursor = "pointer";
+        this.infoIcon.style.zIndex = "2";
+        this.infoIcon.style.width = "16px";
+        this.infoIcon.style.height = "16px";
+        this.infoIcon.onmouseover = (_) => this.onHoverIn();
+        this.infoIcon.onmouseout = (_) => this.onHoverOut();
+        this.infoIcon.onclick = (_) => this.onClick();
+        parent.appendChild(this.infoIcon);
+    }
+    onHoverIn() {
+        if (this.isShowingInfoIcon) {
+            this.infoIcon.style.opacity = "1";
+        }
+    }
+    onHoverOut() {
+        if (this.isShowingInfoIcon) {
+            this.infoIcon.style.opacity = "0.6";
+        }
+    }
+    onClick() {
+        if (this.isShowingInfoIcon) {
+            this.isShowingInfoIcon = false;
+            this.onTapIn();
+            this.infoIcon.src = ASSET_CLOSE_ICON_16PX;
+            this.infoIcon.style.opacity = "1";
+        }
+        else {
+            this.isShowingInfoIcon = true;
+            this.onTapOut();
+            this.infoIcon.src = ASSET_INFO_ICON_16PX;
+            this.infoIcon.style.opacity = "0.6";
+        }
+    }
+}
+export class LibraryInfoContainer {
+    constructor() {
+        this.infoDiv = new LibraryInfoDiv();
+        this.infoIcon = new LibraryInfoIcon(() => {
+            this.infoDiv.show();
+        }, () => {
+            this.infoDiv.hide();
+        });
+    }
+    renderInto(parent) {
+        this.infoDiv.renderInto(parent);
+        this.infoIcon.renderInto(parent);
+    }
+}
+//# sourceMappingURL=ui.js.map

node_modules/html5-qrcode/es2015/ui.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.js","sourceRoot":"","sources":["../../src/ui.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/ui/scanner/base.d.ts

@@ -0,0 +1,16 @@
+export declare class PublicUiElementIdAndClasses {
+    static ALL_ELEMENT_CLASS: string;
+    static CAMERA_PERMISSION_BUTTON_ID: string;
+    static CAMERA_START_BUTTON_ID: string;
+    static CAMERA_STOP_BUTTON_ID: string;
+    static TORCH_BUTTON_ID: string;
+    static CAMERA_SELECTION_SELECT_ID: string;
+    static FILE_SELECTION_BUTTON_ID: string;
+    static ZOOM_SLIDER_ID: string;
+    static SCAN_TYPE_CHANGE_ANCHOR_ID: string;
+    static TORCH_BUTTON_CLASS_TORCH_ON: string;
+    static TORCH_BUTTON_CLASS_TORCH_OFF: string;
+}
+export declare class BaseUiElementFactory {
+    static createElement<Type extends HTMLElement>(elementType: string, elementId: string): Type;
+}

node_modules/html5-qrcode/es2015/ui/scanner/base.js

@@ -0,0 +1,25 @@
+export class PublicUiElementIdAndClasses {
+}
+PublicUiElementIdAndClasses.ALL_ELEMENT_CLASS = "html5-qrcode-element";
+PublicUiElementIdAndClasses.CAMERA_PERMISSION_BUTTON_ID = "html5-qrcode-button-camera-permission";
+PublicUiElementIdAndClasses.CAMERA_START_BUTTON_ID = "html5-qrcode-button-camera-start";
+PublicUiElementIdAndClasses.CAMERA_STOP_BUTTON_ID = "html5-qrcode-button-camera-stop";
+PublicUiElementIdAndClasses.TORCH_BUTTON_ID = "html5-qrcode-button-torch";
+PublicUiElementIdAndClasses.CAMERA_SELECTION_SELECT_ID = "html5-qrcode-select-camera";
+PublicUiElementIdAndClasses.FILE_SELECTION_BUTTON_ID = "html5-qrcode-button-file-selection";
+PublicUiElementIdAndClasses.ZOOM_SLIDER_ID = "html5-qrcode-input-range-zoom";
+PublicUiElementIdAndClasses.SCAN_TYPE_CHANGE_ANCHOR_ID = "html5-qrcode-anchor-scan-type-change";
+PublicUiElementIdAndClasses.TORCH_BUTTON_CLASS_TORCH_ON = "html5-qrcode-button-torch-on";
+PublicUiElementIdAndClasses.TORCH_BUTTON_CLASS_TORCH_OFF = "html5-qrcode-button-torch-off";
+export class BaseUiElementFactory {
+    static createElement(elementType, elementId) {
+        let element = (document.createElement(elementType));
+        element.id = elementId;
+        element.classList.add(PublicUiElementIdAndClasses.ALL_ELEMENT_CLASS);
+        if (elementType === "button") {
+            element.setAttribute("type", "button");
+        }
+        return element;
+    }
+}
+//# sourceMappingURL=base.js.map

node_modules/html5-qrcode/es2015/ui/scanner/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../src/ui/scanner/base.ts"],"names":[],"mappings":"AAcA,MAAM,OAAO,2BAA2B;;AAI7B,6CAAiB,GAAG,sBAAsB,CAAC;AAG3C,uDAA2B,GAAG,uCAAuC,CAAC;AAGtE,kDAAsB,GAAG,kCAAkC,CAAC;AAG5D,iDAAqB,GAAG,iCAAiC,CAAC;AAG1D,2CAAe,GAAG,2BAA2B,CAAC;AAG9C,sDAA0B,GAAG,4BAA4B,CAAC;AAG1D,oDAAwB,GAAG,oCAAoC,CAAC;AAGhE,0CAAc,GAAG,+BAA+B,CAAC;AAMjD,sDAA0B,GAAG,sCAAsC,CAAC;AAOpE,uDAA2B,GAAG,8BAA8B,CAAC;AAG7D,wDAA4B,GAAG,+BAA+B,CAAC;AAQ1E,MAAM,OAAO,oBAAoB;IAMtB,MAAM,CAAC,aAAa,CACvB,WAAmB,EAAE,SAAiB;QAEtC,IAAI,OAAO,GAAe,CAAC,QAAQ,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC;QAChE,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;QACvB,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,2BAA2B,CAAC,iBAAiB,CAAC,CAAC;QACrE,IAAI,WAAW,KAAK,QAAQ,EAAE;YAC1B,OAAO,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;SAC1C;QACD,OAAO,OAAO,CAAC;IACnB,CAAC;CACJ"}

node_modules/html5-qrcode/es2015/ui/scanner/camera-selection-ui.d.ts

@@ -0,0 +1,17 @@
+import { CameraDevice } from "../../camera/core";
+export declare class CameraSelectionUi {
+    private readonly selectElement;
+    private readonly options;
+    private readonly cameras;
+    private constructor();
+    private render;
+    disable(): void;
+    isDisabled(): boolean;
+    enable(): void;
+    getValue(): string;
+    hasValue(value: string): boolean;
+    setValue(value: string): void;
+    hasSingleItem(): boolean;
+    numCameras(): number;
+    static create(parentElement: HTMLElement, cameras: Array<CameraDevice>): CameraSelectionUi;
+}

node_modules/html5-qrcode/es2015/ui/scanner/camera-selection-ui.js

@@ -0,0 +1,82 @@
+import { BaseUiElementFactory, PublicUiElementIdAndClasses } from "./base";
+import { Html5QrcodeScannerStrings } from "../../strings";
+export class CameraSelectionUi {
+    constructor(cameras) {
+        this.selectElement = BaseUiElementFactory
+            .createElement("select", PublicUiElementIdAndClasses.CAMERA_SELECTION_SELECT_ID);
+        this.cameras = cameras;
+        this.options = [];
+    }
+    render(parentElement) {
+        const cameraSelectionContainer = document.createElement("span");
+        cameraSelectionContainer.style.marginRight = "10px";
+        const numCameras = this.cameras.length;
+        if (numCameras === 0) {
+            throw new Error("No cameras found");
+        }
+        if (numCameras === 1) {
+            cameraSelectionContainer.style.display = "none";
+        }
+        else {
+            const selectCameraString = Html5QrcodeScannerStrings.selectCamera();
+            cameraSelectionContainer.innerText
+                = `${selectCameraString} (${this.cameras.length})  `;
+        }
+        let anonymousCameraId = 1;
+        for (const camera of this.cameras) {
+            const value = camera.id;
+            let name = camera.label == null ? value : camera.label;
+            if (!name || name === "") {
+                name = [
+                    Html5QrcodeScannerStrings.anonymousCameraPrefix(),
+                    anonymousCameraId++
+                ].join(" ");
+            }
+            const option = document.createElement("option");
+            option.value = value;
+            option.innerText = name;
+            this.options.push(option);
+            this.selectElement.appendChild(option);
+        }
+        cameraSelectionContainer.appendChild(this.selectElement);
+        parentElement.appendChild(cameraSelectionContainer);
+    }
+    disable() {
+        this.selectElement.disabled = true;
+    }
+    isDisabled() {
+        return this.selectElement.disabled === true;
+    }
+    enable() {
+        this.selectElement.disabled = false;
+    }
+    getValue() {
+        return this.selectElement.value;
+    }
+    hasValue(value) {
+        for (const option of this.options) {
+            if (option.value === value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    setValue(value) {
+        if (!this.hasValue(value)) {
+            throw new Error(`${value} is not present in the camera list.`);
+        }
+        this.selectElement.value = value;
+    }
+    hasSingleItem() {
+        return this.cameras.length === 1;
+    }
+    numCameras() {
+        return this.cameras.length;
+    }
+    static create(parentElement, cameras) {
+        let cameraSelectUi = new CameraSelectionUi(cameras);
+        cameraSelectUi.render(parentElement);
+        return cameraSelectUi;
+    }
+}
+//# sourceMappingURL=camera-selection-ui.js.map

node_modules/html5-qrcode/es2015/ui/scanner/camera-selection-ui.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-selection-ui.js","sourceRoot":"","sources":["../../../../src/ui/scanner/camera-selection-ui.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/ui/scanner/camera-zoom-ui.d.ts

@@ -0,0 +1,16 @@
+export type OnCameraZoomValueChangeCallback = (zoomValue: number) => void;
+export declare class CameraZoomUi {
+    private zoomElementContainer;
+    private rangeInput;
+    private rangeText;
+    private onChangeCallback;
+    private constructor();
+    private render;
+    private onValueChange;
+    setValues(minValue: number, maxValue: number, defaultValue: number, step: number): void;
+    show(): void;
+    hide(): void;
+    setOnCameraZoomValueChangeCallback(onChangeCallback: OnCameraZoomValueChangeCallback): void;
+    removeOnCameraZoomValueChangeCallback(): void;
+    static create(parentElement: HTMLElement, renderOnCreate: boolean): CameraZoomUi;
+}

node_modules/html5-qrcode/es2015/ui/scanner/camera-zoom-ui.js

@@ -0,0 +1,68 @@
+import { BaseUiElementFactory, PublicUiElementIdAndClasses } from "./base";
+import { Html5QrcodeScannerStrings } from "../../strings";
+export class CameraZoomUi {
+    constructor() {
+        this.onChangeCallback = null;
+        this.zoomElementContainer = document.createElement("div");
+        this.rangeInput = BaseUiElementFactory.createElement("input", PublicUiElementIdAndClasses.ZOOM_SLIDER_ID);
+        this.rangeInput.type = "range";
+        this.rangeText = document.createElement("span");
+        this.rangeInput.min = "1";
+        this.rangeInput.max = "5";
+        this.rangeInput.value = "1";
+        this.rangeInput.step = "0.1";
+    }
+    render(parentElement, renderOnCreate) {
+        this.zoomElementContainer.style.display
+            = renderOnCreate ? "block" : "none";
+        this.zoomElementContainer.style.padding = "5px 10px";
+        this.zoomElementContainer.style.textAlign = "center";
+        parentElement.appendChild(this.zoomElementContainer);
+        this.rangeInput.style.display = "inline-block";
+        this.rangeInput.style.width = "50%";
+        this.rangeInput.style.height = "5px";
+        this.rangeInput.style.background = "#d3d3d3";
+        this.rangeInput.style.outline = "none";
+        this.rangeInput.style.opacity = "0.7";
+        let zoomString = Html5QrcodeScannerStrings.zoom();
+        this.rangeText.innerText = `${this.rangeInput.value}x ${zoomString}`;
+        this.rangeText.style.marginRight = "10px";
+        let $this = this;
+        this.rangeInput.addEventListener("input", () => $this.onValueChange());
+        this.rangeInput.addEventListener("change", () => $this.onValueChange());
+        this.zoomElementContainer.appendChild(this.rangeInput);
+        this.zoomElementContainer.appendChild(this.rangeText);
+    }
+    onValueChange() {
+        let zoomString = Html5QrcodeScannerStrings.zoom();
+        this.rangeText.innerText = `${this.rangeInput.value}x ${zoomString}`;
+        if (this.onChangeCallback) {
+            this.onChangeCallback(parseFloat(this.rangeInput.value));
+        }
+    }
+    setValues(minValue, maxValue, defaultValue, step) {
+        this.rangeInput.min = minValue.toString();
+        this.rangeInput.max = maxValue.toString();
+        this.rangeInput.step = step.toString();
+        this.rangeInput.value = defaultValue.toString();
+        this.onValueChange();
+    }
+    show() {
+        this.zoomElementContainer.style.display = "block";
+    }
+    hide() {
+        this.zoomElementContainer.style.display = "none";
+    }
+    setOnCameraZoomValueChangeCallback(onChangeCallback) {
+        this.onChangeCallback = onChangeCallback;
+    }
+    removeOnCameraZoomValueChangeCallback() {
+        this.onChangeCallback = null;
+    }
+    static create(parentElement, renderOnCreate) {
+        let cameraZoomUi = new CameraZoomUi();
+        cameraZoomUi.render(parentElement, renderOnCreate);
+        return cameraZoomUi;
+    }
+}
+//# sourceMappingURL=camera-zoom-ui.js.map

node_modules/html5-qrcode/es2015/ui/scanner/camera-zoom-ui.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-zoom-ui.js","sourceRoot":"","sources":["../../../../src/ui/scanner/camera-zoom-ui.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/ui/scanner/file-selection-ui.d.ts

@@ -0,0 +1,19 @@
+export type OnFileSelected = (file: File) => void;
+export declare class FileSelectionUi {
+    private readonly fileBasedScanRegion;
+    private readonly fileScanInput;
+    private readonly fileSelectionButton;
+    private constructor();
+    hide(): void;
+    show(): void;
+    isShowing(): boolean;
+    resetValue(): void;
+    private createFileBasedScanRegion;
+    private fileBasedScanRegionDefaultBorder;
+    private fileBasedScanRegionActiveBorder;
+    private createDragAndDropMessage;
+    private setImageNameToButton;
+    private setInitialValueToButton;
+    private getFileScanInputId;
+    static create(parentElement: HTMLDivElement, showOnRender: boolean, onFileSelected: OnFileSelected): FileSelectionUi;
+}

node_modules/html5-qrcode/es2015/ui/scanner/file-selection-ui.js

@@ -0,0 +1,165 @@
+import { Html5QrcodeScannerStrings } from "../../strings";
+import { BaseUiElementFactory, PublicUiElementIdAndClasses } from "./base";
+export class FileSelectionUi {
+    constructor(parentElement, showOnRender, onFileSelected) {
+        this.fileBasedScanRegion = this.createFileBasedScanRegion();
+        this.fileBasedScanRegion.style.display
+            = showOnRender ? "block" : "none";
+        parentElement.appendChild(this.fileBasedScanRegion);
+        let fileScanLabel = document.createElement("label");
+        fileScanLabel.setAttribute("for", this.getFileScanInputId());
+        fileScanLabel.style.display = "inline-block";
+        this.fileBasedScanRegion.appendChild(fileScanLabel);
+        this.fileSelectionButton
+            = BaseUiElementFactory.createElement("button", PublicUiElementIdAndClasses.FILE_SELECTION_BUTTON_ID);
+        this.setInitialValueToButton();
+        this.fileSelectionButton.addEventListener("click", (_) => {
+            fileScanLabel.click();
+        });
+        fileScanLabel.append(this.fileSelectionButton);
+        this.fileScanInput
+            = BaseUiElementFactory.createElement("input", this.getFileScanInputId());
+        this.fileScanInput.type = "file";
+        this.fileScanInput.accept = "image/*";
+        this.fileScanInput.style.display = "none";
+        fileScanLabel.appendChild(this.fileScanInput);
+        let $this = this;
+        this.fileScanInput.addEventListener("change", (e) => {
+            if (e == null || e.target == null) {
+                return;
+            }
+            let target = e.target;
+            if (target.files && target.files.length === 0) {
+                return;
+            }
+            let fileList = target.files;
+            const file = fileList[0];
+            let fileName = file.name;
+            $this.setImageNameToButton(fileName);
+            onFileSelected(file);
+        });
+        let dragAndDropMessage = this.createDragAndDropMessage();
+        this.fileBasedScanRegion.appendChild(dragAndDropMessage);
+        this.fileBasedScanRegion.addEventListener("dragenter", function (event) {
+            $this.fileBasedScanRegion.style.border
+                = $this.fileBasedScanRegionActiveBorder();
+            event.stopPropagation();
+            event.preventDefault();
+        });
+        this.fileBasedScanRegion.addEventListener("dragleave", function (event) {
+            $this.fileBasedScanRegion.style.border
+                = $this.fileBasedScanRegionDefaultBorder();
+            event.stopPropagation();
+            event.preventDefault();
+        });
+        this.fileBasedScanRegion.addEventListener("dragover", function (event) {
+            $this.fileBasedScanRegion.style.border
+                = $this.fileBasedScanRegionActiveBorder();
+            event.stopPropagation();
+            event.preventDefault();
+        });
+        this.fileBasedScanRegion.addEventListener("drop", function (event) {
+            event.stopPropagation();
+            event.preventDefault();
+            $this.fileBasedScanRegion.style.border
+                = $this.fileBasedScanRegionDefaultBorder();
+            var dataTransfer = event.dataTransfer;
+            if (dataTransfer) {
+                let files = dataTransfer.files;
+                if (!files || files.length === 0) {
+                    return;
+                }
+                let isAnyFileImage = false;
+                for (let i = 0; i < files.length; ++i) {
+                    let file = files.item(i);
+                    if (!file) {
+                        continue;
+                    }
+                    let imageType = /image.*/;
+                    if (!file.type.match(imageType)) {
+                        continue;
+                    }
+                    isAnyFileImage = true;
+                    let fileName = file.name;
+                    $this.setImageNameToButton(fileName);
+                    onFileSelected(file);
+                    dragAndDropMessage.innerText
+                        = Html5QrcodeScannerStrings.dragAndDropMessage();
+                    break;
+                }
+                if (!isAnyFileImage) {
+                    dragAndDropMessage.innerText
+                        = Html5QrcodeScannerStrings
+                            .dragAndDropMessageOnlyImages();
+                }
+            }
+        });
+    }
+    hide() {
+        this.fileBasedScanRegion.style.display = "none";
+        this.fileScanInput.disabled = true;
+    }
+    show() {
+        this.fileBasedScanRegion.style.display = "block";
+        this.fileScanInput.disabled = false;
+    }
+    isShowing() {
+        return this.fileBasedScanRegion.style.display === "block";
+    }
+    resetValue() {
+        this.fileScanInput.value = "";
+        this.setInitialValueToButton();
+    }
+    createFileBasedScanRegion() {
+        let fileBasedScanRegion = document.createElement("div");
+        fileBasedScanRegion.style.textAlign = "center";
+        fileBasedScanRegion.style.margin = "auto";
+        fileBasedScanRegion.style.width = "80%";
+        fileBasedScanRegion.style.maxWidth = "600px";
+        fileBasedScanRegion.style.border
+            = this.fileBasedScanRegionDefaultBorder();
+        fileBasedScanRegion.style.padding = "10px";
+        fileBasedScanRegion.style.marginBottom = "10px";
+        return fileBasedScanRegion;
+    }
+    fileBasedScanRegionDefaultBorder() {
+        return "6px dashed #ebebeb";
+    }
+    fileBasedScanRegionActiveBorder() {
+        return "6px dashed rgb(153 151 151)";
+    }
+    createDragAndDropMessage() {
+        let dragAndDropMessage = document.createElement("div");
+        dragAndDropMessage.innerText
+            = Html5QrcodeScannerStrings.dragAndDropMessage();
+        dragAndDropMessage.style.fontWeight = "400";
+        return dragAndDropMessage;
+    }
+    setImageNameToButton(imageFileName) {
+        const MAX_CHARS = 20;
+        if (imageFileName.length > MAX_CHARS) {
+            let start8Chars = imageFileName.substring(0, 8);
+            let length = imageFileName.length;
+            let last8Chars = imageFileName.substring(length - 8, length);
+            imageFileName = `${start8Chars}....${last8Chars}`;
+        }
+        let newText = Html5QrcodeScannerStrings.fileSelectionChooseAnother()
+            + " - "
+            + imageFileName;
+        this.fileSelectionButton.innerText = newText;
+    }
+    setInitialValueToButton() {
+        let initialText = Html5QrcodeScannerStrings.fileSelectionChooseImage()
+            + " - "
+            + Html5QrcodeScannerStrings.fileSelectionNoImageSelected();
+        this.fileSelectionButton.innerText = initialText;
+    }
+    getFileScanInputId() {
+        return "html5-qrcode-private-filescan-input";
+    }
+    static create(parentElement, showOnRender, onFileSelected) {
+        let button = new FileSelectionUi(parentElement, showOnRender, onFileSelected);
+        return button;
+    }
+}
+//# sourceMappingURL=file-selection-ui.js.map

node_modules/html5-qrcode/es2015/ui/scanner/scan-type-selector.d.ts

@@ -0,0 +1,11 @@
+import { Html5QrcodeScanType } from "../../core";
+export declare class ScanTypeSelector {
+    private supportedScanTypes;
+    constructor(supportedScanTypes?: Array<Html5QrcodeScanType> | []);
+    getDefaultScanType(): Html5QrcodeScanType;
+    hasMoreThanOneScanType(): boolean;
+    isCameraScanRequired(): boolean;
+    static isCameraScanType(scanType: Html5QrcodeScanType): boolean;
+    static isFileScanType(scanType: Html5QrcodeScanType): boolean;
+    private validateAndReturnScanTypes;
+}

node_modules/html5-qrcode/es2015/ui/scanner/scan-type-selector.js

@@ -0,0 +1,44 @@
+import { Html5QrcodeScanType, Html5QrcodeConstants } from "../../core";
+export class ScanTypeSelector {
+    constructor(supportedScanTypes) {
+        this.supportedScanTypes = this.validateAndReturnScanTypes(supportedScanTypes);
+    }
+    getDefaultScanType() {
+        return this.supportedScanTypes[0];
+    }
+    hasMoreThanOneScanType() {
+        return this.supportedScanTypes.length > 1;
+    }
+    isCameraScanRequired() {
+        for (const scanType of this.supportedScanTypes) {
+            if (ScanTypeSelector.isCameraScanType(scanType)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static isCameraScanType(scanType) {
+        return scanType === Html5QrcodeScanType.SCAN_TYPE_CAMERA;
+    }
+    static isFileScanType(scanType) {
+        return scanType === Html5QrcodeScanType.SCAN_TYPE_FILE;
+    }
+    validateAndReturnScanTypes(supportedScanTypes) {
+        if (!supportedScanTypes || supportedScanTypes.length === 0) {
+            return Html5QrcodeConstants.DEFAULT_SUPPORTED_SCAN_TYPE;
+        }
+        let maxExpectedValues = Html5QrcodeConstants.DEFAULT_SUPPORTED_SCAN_TYPE.length;
+        if (supportedScanTypes.length > maxExpectedValues) {
+            throw `Max ${maxExpectedValues} values expected for `
+                + "supportedScanTypes";
+        }
+        for (const scanType of supportedScanTypes) {
+            if (!Html5QrcodeConstants.DEFAULT_SUPPORTED_SCAN_TYPE
+                .includes(scanType)) {
+                throw `Unsupported scan type ${scanType}`;
+            }
+        }
+        return supportedScanTypes;
+    }
+}
+//# sourceMappingURL=scan-type-selector.js.map

node_modules/html5-qrcode/es2015/ui/scanner/scan-type-selector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-type-selector.js","sourceRoot":"","sources":["../../../../src/ui/scanner/scan-type-selector.ts"],"names":[],"mappings":"AAUA,OAAO,EACH,mBAAmB,EACnB,oBAAoB,EACvB,MAAM,YAAY,CAAC;AAGpB,MAAM,OAAO,gBAAgB;IAGzB,YAAY,kBAAoD;QAC5D,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,0BAA0B,CACrD,kBAAkB,CAAC,CAAC;IAC5B,CAAC;IAMM,kBAAkB;QACrB,OAAO,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IACtC,CAAC;IAMM,sBAAsB;QACzB,OAAO,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC;IAC9C,CAAC;IAGM,oBAAoB;QACvB,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAC5C,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE;gBAC7C,OAAO,IAAI,CAAC;aACf;SACJ;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAGM,MAAM,CAAC,gBAAgB,CAAC,QAA6B;QACxD,OAAO,QAAQ,KAAK,mBAAmB,CAAC,gBAAgB,CAAC;IAC7D,CAAC;IAGM,MAAM,CAAC,cAAc,CAAC,QAA6B;QACtD,OAAO,QAAQ,KAAK,mBAAmB,CAAC,cAAc,CAAC;IAC3D,CAAC;IAQO,0BAA0B,CAC9B,kBAA8C;QAG9C,IAAI,CAAC,kBAAkB,IAAI,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE;YACxD,OAAO,oBAAoB,CAAC,2BAA2B,CAAC;SAC3D;QAGD,IAAI,iBAAiB,GACf,oBAAoB,CAAC,2BAA2B,CAAC,MAAM,CAAC;QAC9D,IAAI,kBAAkB,CAAC,MAAM,GAAG,iBAAiB,EAAE;YAC/C,MAAM,OAAO,iBAAiB,uBAAuB;kBAC/C,oBAAoB,CAAC;SAC9B;QAGD,KAAK,MAAM,QAAQ,IAAI,kBAAkB,EAAE;YACvC,IAAI,CAAC,oBAAoB,CAAC,2BAA2B;iBAC5C,QAAQ,CAAC,QAAQ,CAAC,EAAE;gBACzB,MAAM,yBAAyB,QAAQ,EAAE,CAAC;aAC7C;SACJ;QAED,OAAO,kBAAkB,CAAC;IAC9B,CAAC;CAEJ"}

node_modules/html5-qrcode/es2015/ui/scanner/torch-button.d.ts

@@ -0,0 +1,28 @@
+import { BooleanCameraCapability } from "../../camera/core";
+export type OnTorchActionFailureCallback = (failureMessage: string) => void;
+interface TorchButtonController {
+    disable(): void;
+    enable(): void;
+    setText(text: string): void;
+}
+export interface TorchButtonOptions {
+    display: string;
+    marginLeft: string;
+}
+export declare class TorchButton implements TorchButtonController {
+    private readonly torchButton;
+    private readonly onTorchActionFailureCallback;
+    private torchController;
+    private constructor();
+    private render;
+    updateTorchCapability(torchCapability: BooleanCameraCapability): void;
+    getTorchButton(): HTMLButtonElement;
+    hide(): void;
+    show(): void;
+    disable(): void;
+    enable(): void;
+    setText(text: string): void;
+    reset(): void;
+    static create(parentElement: HTMLElement, torchCapability: BooleanCameraCapability, torchButtonOptions: TorchButtonOptions, onTorchActionFailureCallback: OnTorchActionFailureCallback): TorchButton;
+}
+export {};

node_modules/html5-qrcode/es2015/ui/scanner/torch-button.js

@@ -0,0 +1,118 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Html5QrcodeScannerStrings } from "../../strings";
+import { BaseUiElementFactory, PublicUiElementIdAndClasses } from "./base";
+class TorchController {
+    constructor(torchCapability, buttonController, onTorchActionFailureCallback) {
+        this.isTorchOn = false;
+        this.torchCapability = torchCapability;
+        this.buttonController = buttonController;
+        this.onTorchActionFailureCallback = onTorchActionFailureCallback;
+    }
+    isTorchEnabled() {
+        return this.isTorchOn;
+    }
+    flipState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.buttonController.disable();
+            let isTorchOnExpected = !this.isTorchOn;
+            try {
+                yield this.torchCapability.apply(isTorchOnExpected);
+                this.updateUiBasedOnLatestSettings(this.torchCapability.value(), isTorchOnExpected);
+            }
+            catch (error) {
+                this.propagateFailure(isTorchOnExpected, error);
+                this.buttonController.enable();
+            }
+        });
+    }
+    updateUiBasedOnLatestSettings(isTorchOn, isTorchOnExpected) {
+        if (isTorchOn === isTorchOnExpected) {
+            this.buttonController.setText(isTorchOnExpected
+                ? Html5QrcodeScannerStrings.torchOffButton()
+                : Html5QrcodeScannerStrings.torchOnButton());
+            this.isTorchOn = isTorchOnExpected;
+        }
+        else {
+            this.propagateFailure(isTorchOnExpected);
+        }
+        this.buttonController.enable();
+    }
+    propagateFailure(isTorchOnExpected, error) {
+        let errorMessage = isTorchOnExpected
+            ? Html5QrcodeScannerStrings.torchOnFailedMessage()
+            : Html5QrcodeScannerStrings.torchOffFailedMessage();
+        if (error) {
+            errorMessage += "; Error = " + error;
+        }
+        this.onTorchActionFailureCallback(errorMessage);
+    }
+    reset() {
+        this.isTorchOn = false;
+    }
+}
+export class TorchButton {
+    constructor(torchCapability, onTorchActionFailureCallback) {
+        this.onTorchActionFailureCallback = onTorchActionFailureCallback;
+        this.torchButton
+            = BaseUiElementFactory.createElement("button", PublicUiElementIdAndClasses.TORCH_BUTTON_ID);
+        this.torchController = new TorchController(torchCapability, this, onTorchActionFailureCallback);
+    }
+    render(parentElement, torchButtonOptions) {
+        this.torchButton.innerText
+            = Html5QrcodeScannerStrings.torchOnButton();
+        this.torchButton.style.display = torchButtonOptions.display;
+        this.torchButton.style.marginLeft = torchButtonOptions.marginLeft;
+        let $this = this;
+        this.torchButton.addEventListener("click", (_) => __awaiter(this, void 0, void 0, function* () {
+            yield $this.torchController.flipState();
+            if ($this.torchController.isTorchEnabled()) {
+                $this.torchButton.classList.remove(PublicUiElementIdAndClasses.TORCH_BUTTON_CLASS_TORCH_OFF);
+                $this.torchButton.classList.add(PublicUiElementIdAndClasses.TORCH_BUTTON_CLASS_TORCH_ON);
+            }
+            else {
+                $this.torchButton.classList.remove(PublicUiElementIdAndClasses.TORCH_BUTTON_CLASS_TORCH_ON);
+                $this.torchButton.classList.add(PublicUiElementIdAndClasses.TORCH_BUTTON_CLASS_TORCH_OFF);
+            }
+        }));
+        parentElement.appendChild(this.torchButton);
+    }
+    updateTorchCapability(torchCapability) {
+        this.torchController = new TorchController(torchCapability, this, this.onTorchActionFailureCallback);
+    }
+    getTorchButton() {
+        return this.torchButton;
+    }
+    hide() {
+        this.torchButton.style.display = "none";
+    }
+    show() {
+        this.torchButton.style.display = "inline-block";
+    }
+    disable() {
+        this.torchButton.disabled = true;
+    }
+    enable() {
+        this.torchButton.disabled = false;
+    }
+    setText(text) {
+        this.torchButton.innerText = text;
+    }
+    reset() {
+        this.torchButton.innerText = Html5QrcodeScannerStrings.torchOnButton();
+        this.torchController.reset();
+    }
+    static create(parentElement, torchCapability, torchButtonOptions, onTorchActionFailureCallback) {
+        let button = new TorchButton(torchCapability, onTorchActionFailureCallback);
+        button.render(parentElement, torchButtonOptions);
+        return button;
+    }
+}
+//# sourceMappingURL=torch-button.js.map

node_modules/html5-qrcode/es2015/ui/scanner/torch-button.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"torch-button.js","sourceRoot":"","sources":["../../../../src/ui/scanner/torch-button.ts"],"names":[],"mappings":"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"}

node_modules/html5-qrcode/es2015/utils.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from "./core";
+export declare class VideoConstraintsUtil {
+    static isMediaStreamConstraintsValid(videoConstraints: MediaTrackConstraints, logger: Logger): boolean;
+}

node_modules/html5-qrcode/es2015/utils.js

@@ -0,0 +1,30 @@
+export class VideoConstraintsUtil {
+    static isMediaStreamConstraintsValid(videoConstraints, logger) {
+        if (typeof videoConstraints !== "object") {
+            const typeofVideoConstraints = typeof videoConstraints;
+            logger.logError("videoConstraints should be of type object, the "
+                + `object passed is of type ${typeofVideoConstraints}.`, true);
+            return false;
+        }
+        const bannedKeys = [
+            "autoGainControl",
+            "channelCount",
+            "echoCancellation",
+            "latency",
+            "noiseSuppression",
+            "sampleRate",
+            "sampleSize",
+            "volume"
+        ];
+        const bannedkeysSet = new Set(bannedKeys);
+        const keysInVideoConstraints = Object.keys(videoConstraints);
+        for (const key of keysInVideoConstraints) {
+            if (bannedkeysSet.has(key)) {
+                logger.logError(`${key} is not supported videoConstaints.`, true);
+                return false;
+            }
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=utils.js.map

node_modules/html5-qrcode/es2015/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAeA,MAAM,OAAO,oBAAoB;IACtB,MAAM,CAAC,6BAA6B,CACvC,gBAAuC,EACvC,MAAc;QACd,IAAI,OAAO,gBAAgB,KAAK,QAAQ,EAAE;YACtC,MAAM,sBAAsB,GAAG,OAAO,gBAAgB,CAAC;YACvD,MAAM,CAAC,QAAQ,CACX,iDAAiD;kBAC3C,4BAA4B,sBAAsB,GAAG,EACvC,IAAI,CAAC,CAAC;YAC9B,OAAO,KAAK,CAAC;SAChB;QAGD,MAAM,UAAU,GAAG;YACf,iBAAiB;YACjB,cAAc;YACd,kBAAkB;YAClB,SAAS;YACT,kBAAkB;YAClB,YAAY;YACZ,YAAY;YACZ,QAAQ;SACX,CAAC;QACF,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC;QAC1C,MAAM,sBAAsB,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC7D,KAAK,MAAM,GAAG,IAAI,sBAAsB,EAAE;YACtC,IAAI,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBACxB,MAAM,CAAC,QAAQ,CACX,GAAG,GAAG,oCAAoC,EACtB,IAAI,CAAC,CAAC;gBAC9B,OAAO,KAAK,CAAC;aAChB;SACJ;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ"}

node_modules/html5-qrcode/es2015/zxing-html5-qrcode-decoder.d.ts

@@ -0,0 +1,15 @@
+import { QrcodeResult, Html5QrcodeSupportedFormats, Logger, QrcodeDecoderAsync } from "./core";
+export declare class ZXingHtml5QrcodeDecoder implements QrcodeDecoderAsync {
+    private readonly formatMap;
+    private readonly reverseFormatMap;
+    private hints;
+    private verbose;
+    private logger;
+    constructor(requestedFormats: Array<Html5QrcodeSupportedFormats>, verbose: boolean, logger: Logger);
+    decodeAsync(canvas: HTMLCanvasElement): Promise<QrcodeResult>;
+    private decode;
+    private createReverseFormatMap;
+    private toHtml5QrcodeSupportedFormats;
+    private createZXingFormats;
+    private createDebugData;
+}

node_modules/html5-qrcode/es2015/zxing-html5-qrcode-decoder.js

@@ -0,0 +1,102 @@
+import * as ZXing from "../third_party/zxing-js.umd";
+import { QrcodeResultFormat, Html5QrcodeSupportedFormats } from "./core";
+export class ZXingHtml5QrcodeDecoder {
+    constructor(requestedFormats, verbose, logger) {
+        this.formatMap = new Map([
+            [Html5QrcodeSupportedFormats.QR_CODE, ZXing.BarcodeFormat.QR_CODE],
+            [Html5QrcodeSupportedFormats.AZTEC, ZXing.BarcodeFormat.AZTEC],
+            [Html5QrcodeSupportedFormats.CODABAR, ZXing.BarcodeFormat.CODABAR],
+            [Html5QrcodeSupportedFormats.CODE_39, ZXing.BarcodeFormat.CODE_39],
+            [Html5QrcodeSupportedFormats.CODE_93, ZXing.BarcodeFormat.CODE_93],
+            [
+                Html5QrcodeSupportedFormats.CODE_128,
+                ZXing.BarcodeFormat.CODE_128
+            ],
+            [
+                Html5QrcodeSupportedFormats.DATA_MATRIX,
+                ZXing.BarcodeFormat.DATA_MATRIX
+            ],
+            [
+                Html5QrcodeSupportedFormats.MAXICODE,
+                ZXing.BarcodeFormat.MAXICODE
+            ],
+            [Html5QrcodeSupportedFormats.ITF, ZXing.BarcodeFormat.ITF],
+            [Html5QrcodeSupportedFormats.EAN_13, ZXing.BarcodeFormat.EAN_13],
+            [Html5QrcodeSupportedFormats.EAN_8, ZXing.BarcodeFormat.EAN_8],
+            [Html5QrcodeSupportedFormats.PDF_417, ZXing.BarcodeFormat.PDF_417],
+            [Html5QrcodeSupportedFormats.RSS_14, ZXing.BarcodeFormat.RSS_14],
+            [
+                Html5QrcodeSupportedFormats.RSS_EXPANDED,
+                ZXing.BarcodeFormat.RSS_EXPANDED
+            ],
+            [Html5QrcodeSupportedFormats.UPC_A, ZXing.BarcodeFormat.UPC_A],
+            [Html5QrcodeSupportedFormats.UPC_E, ZXing.BarcodeFormat.UPC_E],
+            [
+                Html5QrcodeSupportedFormats.UPC_EAN_EXTENSION,
+                ZXing.BarcodeFormat.UPC_EAN_EXTENSION
+            ]
+        ]);
+        this.reverseFormatMap = this.createReverseFormatMap();
+        if (!ZXing) {
+            throw "Use html5qrcode.min.js without edit, ZXing not found.";
+        }
+        this.verbose = verbose;
+        this.logger = logger;
+        const formats = this.createZXingFormats(requestedFormats);
+        const hints = new Map();
+        hints.set(ZXing.DecodeHintType.POSSIBLE_FORMATS, formats);
+        hints.set(ZXing.DecodeHintType.TRY_HARDER, false);
+        this.hints = hints;
+    }
+    decodeAsync(canvas) {
+        return new Promise((resolve, reject) => {
+            try {
+                resolve(this.decode(canvas));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    decode(canvas) {
+        const zxingDecoder = new ZXing.MultiFormatReader(this.verbose, this.hints);
+        const luminanceSource = new ZXing.HTMLCanvasElementLuminanceSource(canvas);
+        const binaryBitmap = new ZXing.BinaryBitmap(new ZXing.HybridBinarizer(luminanceSource));
+        let result = zxingDecoder.decode(binaryBitmap);
+        return {
+            text: result.text,
+            format: QrcodeResultFormat.create(this.toHtml5QrcodeSupportedFormats(result.format)),
+            debugData: this.createDebugData()
+        };
+    }
+    createReverseFormatMap() {
+        let result = new Map();
+        this.formatMap.forEach((value, key, _) => {
+            result.set(value, key);
+        });
+        return result;
+    }
+    toHtml5QrcodeSupportedFormats(zxingFormat) {
+        if (!this.reverseFormatMap.has(zxingFormat)) {
+            throw `reverseFormatMap doesn't have ${zxingFormat}`;
+        }
+        return this.reverseFormatMap.get(zxingFormat);
+    }
+    createZXingFormats(requestedFormats) {
+        let zxingFormats = [];
+        for (const requestedFormat of requestedFormats) {
+            if (this.formatMap.has(requestedFormat)) {
+                zxingFormats.push(this.formatMap.get(requestedFormat));
+            }
+            else {
+                this.logger.logError(`${requestedFormat} is not supported by`
+                    + "ZXingHtml5QrcodeShim");
+            }
+        }
+        return zxingFormats;
+    }
+    createDebugData() {
+        return { decoderName: "zxing-js" };
+    }
+}
+//# sourceMappingURL=zxing-html5-qrcode-decoder.js.map

node_modules/html5-qrcode/es2015/zxing-html5-qrcode-decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zxing-html5-qrcode-decoder.js","sourceRoot":"","sources":["../../src/zxing-html5-qrcode-decoder.ts"],"names":[],"mappings":"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"}