diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 00000000..9498e50b
Binary files /dev/null and b/.DS_Store differ
diff --git a/.babelrc b/.babelrc
index 09b5e3c3..feccf134 100644
--- a/.babelrc
+++ b/.babelrc
@@ -1,33 +1,31 @@
{
+ "presets": [
+ "@babel/env",
+ "@babel/typescript"
+ ],
"plugins": [
- "check-es2015-constants",
- "transform-es2015-arrow-functions",
- "transform-es2015-block-scoped-functions",
- "transform-es2015-block-scoping",
- ["transform-es2015-classes", { "loose": true }],
- ["transform-es2015-computed-properties", { "loose": true }],
- ["transform-es2015-destructuring", { "loose": true }],
- ["transform-es2015-for-of", { "loose": true }],
- "transform-es2015-function-name",
- "transform-es2015-literals",
-
- "transform-es2015-object-super",
- "transform-es2015-parameters",
- "transform-es2015-shorthand-properties",
- ["transform-es2015-spread", { "loose": true }],
- "transform-es2015-sticky-regex",
- ["transform-es2015-template-literals", { "loose": true }],
- "transform-es2015-unicode-regex",
- "transform-es2015-typeof-symbol",
- "transform-object-rest-spread",
- "lodash"
-],
-"env": {
- "commonjs": {
+ "@babel/proposal-class-properties",
+ "@babel/proposal-object-rest-spread",
+ "@babel/transform-runtime"
+ ],
+ "env": {
+ "node": {
"plugins": [
- ["transform-es2015-modules-commonjs", { "loose": true }],
- "add-module-exports"
+ "add-module-exports"
+ ]
+ },
+ "test": {
+ "plugins": [
+ "add-module-exports",
+ [
+ "istanbul",
+ {
+ "exclude": [
+ "**/*.spec.js"
+ ]
+ }
+ ]
]
}
}
-}
+}
\ No newline at end of file
diff --git a/.eslintrc b/.eslintrc
index 628f4846..623e6d00 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -1,35 +1,21 @@
{
- "settings" : {
- "ecmascript": 6,
- "jsx": true
+ "extends": "eslint:recommended",
+ "parserOptions": {
+ "ecmaVersion": 2018,
+ "sourceType": "module"
},
"env": {
"browser": true,
+ "es6": true,
"node": true
},
- "ecmaFeatures": {
- "blockBindings": true,
- "forOf": true,
- "defaultParams": true,
- "globalReturn": false,
- "modules": true,
- "objectLiteralShorthandMethods": true,
- "objectLiteralShorthandProperties": true,
- "templateStrings": true,
- "spread": true,
- "jsx": true,
- "arrowFunctions": true,
- "classes": true,
- "destructuring": true,
- "objectLiteralComputedProperties": true
- },
"globals": {
- "ENV": true,
- "beforeEach": true,
- "describe": true,
- "it": true,
- "expect": true,
- "sinon": true
+ "ENV": "readonly",
+ "beforeEach": "readonly",
+ "describe": "readonly",
+ "it": "readonly",
+ "expect": "readonly",
+ "sinon": "readonly"
},
"rules": {
"no-unused-expressions": 1,
@@ -42,7 +28,10 @@
"eqeqeq": 2,
"guard-for-in": 2,
"wrap-iife": 0,
- "no-use-before-define": [1, "nofunc"],
+ "no-use-before-define": [
+ 1,
+ "nofunc"
+ ],
"new-cap": 2,
"quotes": 0,
"strict": 0,
@@ -52,18 +41,44 @@
"no-plusplus": 0,
"no-unused-vars": 1,
"no-trailing-spaces": 2,
-
// STYLE
- "max-params": [2, 7],
- "key-spacing": [1, {
- beforeColon: false,
- afterColon: true
- }],
- "indent": [2, 4],
- "brace-style": [2, "1tbs"],
- "comma-spacing": [2, {before: false, after: true}],
- "comma-style": [2, "last"],
- "consistent-this": [1, "self"],
+ "max-params": [
+ 2,
+ 7
+ ],
+ "key-spacing": [
+ 1,
+ {
+ "beforeColon": false,
+ "afterColon": true
+ }
+ ],
+ "indent": [
+ "error",
+ 4,
+ {
+ "SwitchCase": 1
+ }
+ ],
+ "brace-style": [
+ 2,
+ "1tbs"
+ ],
+ "comma-spacing": [
+ 2,
+ {
+ "before": false,
+ "after": true
+ }
+ ],
+ "comma-style": [
+ 2,
+ "last"
+ ],
+ "consistent-this": [
+ 1,
+ "self"
+ ],
"eol-last": 0,
"new-parens": 2,
"no-array-constructor": 2,
@@ -74,12 +89,20 @@
"no-spaced-func": 1,
"no-shadow": 2,
"no-undef": 2,
- "padded-blocks": [2, "never"],
- "semi": [2, "always"],
- "space-after-keywords": [2, "always"],
+ "padded-blocks": [
+ 2,
+ "never"
+ ],
+ "semi": [
+ 2,
+ "always"
+ ],
"space-infix-ops": 2,
- "max-len" : [1, 120],
+ "max-len": [
+ 1,
+ 120
+ ],
"consistent-return": 2,
"yoda": 2
}
-}
+}
\ No newline at end of file
diff --git a/Gruntfile.js b/Gruntfile.js
deleted file mode 100644
index a57c82d8..00000000
--- a/Gruntfile.js
+++ /dev/null
@@ -1,21 +0,0 @@
-module.exports = function(grunt) {
- // Project configuration.
- grunt.initConfig({
- pkg: grunt.file.readJSON('package.json'),
- karma: {
- unit: {
- configFile: 'karma.conf.js'
- },
- integration: {
- configFile: 'karma-integration.conf.js'
- }
- }
- });
-
- grunt.loadNpmTasks('grunt-karma');
-
- grunt.loadTasks('tasks');
-
- grunt.registerTask('test', ['karma']);
- grunt.registerTask('integrationtest', ['karma:integration']);
-};
diff --git a/README.md b/README.md
index b14c8cf2..00b086b8 100644
--- a/README.md
+++ b/README.md
@@ -91,12 +91,11 @@ The above condition evaluates to:
| Chrome | `true` |
| Firefox | `true` |
| IE 11 | `false` |
-| Safari iOS | `true` |
+| Safari iOS | `true` |
## Installing
-QuaggaJS can be installed using __npm__, __bower__, or by including it with
-the __script__ tag.
+QuaggaJS can be installed using __npm__ or by including it with the __script__ tag.
### NPM
@@ -115,14 +114,6 @@ Currently, the full functionality is only available through the browser. When
using QuaggaJS within __node__, only file-based decoding is available. See the
example for [node_examples](#node-example).
-### Bower
-
-You can also install QuaggaJS through __bower__:
-
-```console
-> bower install quagga
-```
-
### Script-Tag Anno 1998
You can simply include `dist/quagga.min.js` in your project and you are ready
@@ -181,19 +172,19 @@ node.
```javascript
Quagga.init({
inputStream : {
- name : "Live",
- type : "LiveStream",
+ name : 'Live',
+ type : 'LiveStream',
target: document.querySelector('#yourElement') // Or '#yourElement' (optional)
},
decoder : {
- readers : ["code_128_reader"]
+ readers : ['code_128_reader']
}
- }, function(err) {
+ }, function (err) {
if (err) {
console.log(err);
return
}
- console.log("Initialization finished. Ready to start");
+ console.log('Initialization finished. Ready to start');
Quagga.start();
});
```
@@ -475,7 +466,7 @@ supplements you have to provide them in the configuration as followed:
```javascript
decoder: {
readers: [{
- format: "ean_reader",
+ format: 'ean_reader',
config: {
supplements: [
'ean_5_reader', 'ean_2_reader'
@@ -508,7 +499,7 @@ Only two properties are relevant for the use in Quagga (`halfSample` and
```javascript
{
halfSample: true,
- patchSize: "medium", // x-small, small, medium, large, x-large
+ patchSize: 'medium', // x-small, small, medium, large, x-large
debug: {
showCanvas: false,
showPatches: false,
@@ -552,43 +543,43 @@ locating-mechanism for more robust results.
```javascript
Quagga.decodeSingle({
decoder: {
- readers: ["code_128_reader"] // List of active readers
+ readers: ['code_128_reader'] // List of active readers
},
locate: true, // try to locate the barcode in the image
src: '/test/fixtures/code_128/image-001.jpg' // or 'data:image/jpg;base64,' + data
-}, function(result){
- if(result.codeResult) {
- console.log("result", result.codeResult.code);
+}, function (result) {
+ if (result.codeResult) {
+ console.log('result', result.codeResult.code);
} else {
- console.log("not detected");
+ console.log('not detected');
}
});
```
### Using node
-The following example illustrates the use of QuaggaJS within a node
-environment. It's almost identical to the browser version with the difference
-that node does not support web-workers out of the box. Therefore the config
+The following example illustrates the use of QuaggaJS within a node environment.
+It's almost identical to the browser version with the difference
+that node does not support web workers out of the box. Therefore the config
property `numOfWorkers` must be explicitly set to `0`.
```javascript
var Quagga = require('quagga').default;
Quagga.decodeSingle({
- src: "image-abc-123.jpg",
+ src: 'image-abc-123.jpg',
numOfWorkers: 0, // Needs to be 0 when used within node
inputStream: {
- size: 800 // restrict input-size to be 800px in width (long-side)
+ size: 800 // restrict input size to be 800px in width (long side)
},
decoder: {
- readers: ["code_128_reader"] // List of active readers
+ readers: ['code_128_reader'] // List of active readers
},
}, function(result) {
if(result.codeResult) {
- console.log("result", result.codeResult.code);
+ console.log('result', result.codeResult.code);
} else {
- console.log("not detected");
+ console.log('not detected');
}
});
```
@@ -601,11 +592,11 @@ A growing collection of tips & tricks to improve the various aspects of Quagga.
Barcodes too far away from the camera, or a lens too close to the object
result in poor recognition rates and Quagga might respond with a lot of
-false-positives.
+false positives.
Starting in Chrome 59 you can now make use of `capabilities` and directly
control the zoom of the camera. Head over to the
-[web-cam demo](https://serratus.github.io/quaggaJS/examples/live_w_locator.html)
+[web cam demo](https://serratus.github.io/quaggaJS/examples/live_w_locator.html)
and check out the __Zoom__ feature.
You can read more about those `capabilities` in
@@ -618,7 +609,7 @@ recognition logic.
Since Chrome 59 you can turn on/off the __Torch__ of our device and vastly
improve the quality of the images. Head over to the
-[web-cam demo](https://serratus.github.io/quaggaJS/examples/live_w_locator.html)
+[web cam demo](https://serratus.github.io/quaggaJS/examples/live_w_locator.html)
and check out the __Torch__ feature.
To find out more about this feature [read on](https://www.oberhofer.co/mediastreamtrack-and-its-capabilities).
@@ -626,8 +617,8 @@ To find out more about this feature [read on](https://www.oberhofer.co/mediastre
## Tests
Unit Tests can be run with [Karma][karmaUrl] and written using
-[Mocha][mochaUrl], [Chai][chaiUrl] and [SinonJS][sinonUrl]. Coverage reports are
-automatically generated in the coverage/ folder.
+[Mocha][mochaUrl], [Chai][chaiUrl] and [SinonJS][sinonUrl].
+Coverage reports are automatically generated in the coverage/ folder.
```console
> npm install
@@ -639,7 +630,7 @@ In case you want to take a deeper dive into the inner workings of Quagga, get to
know the _debugging_ capabilities of the current implementation. The various
flags exposed through the `config` object give you the abilily to visualize
almost every step in the processing. Because of the introduction of the
-web-workers, and their restriction not to have access to the DOM, the
+web workers, and their restriction not to have access to the DOM, the
configuration must be explicitly set to `config.numOfWorkers = 0` in order to
work.
@@ -652,19 +643,19 @@ bugs in the implementation.
### Creating a ``ResultCollector``
-You can easily create a new ``ResultCollector`` by calling its ``create``
-method with a configuration.
+You can easily create a new ``ResultCollector`` by calling its constructor
+with a configuration.
```javascript
-var resultCollector = Quagga.ResultCollector.create({
+const resultCollector = new Quagga.ResultCollector({
capture: true, // keep track of the image producing this result
capacity: 20, // maximum number of results to store
blacklist: [ // list containing codes which should not be recorded
- {code: "3574660239843", format: "ean_13"}],
- filter: function(codeResult) {
+ {code: '3574660239843', format: 'ean_13'}],
+ filter: function (codeResult) {
// only store results which match this constraint
// returns true/false
- // e.g.: return codeResult.format === "ean_13";
+ // e.g.: return codeResult.format === 'ean_13';
return true;
}
});
@@ -684,7 +675,7 @@ do not fit into a certain schema. Calling ``getResults`` on the
```javascript
{
codeResult: {}, // same as in onDetected event
- frame: "data:image/png;base64,iVBOR..." // dataURL of the gray-scaled image
+ frame: 'data:image/png;base64,iVBOR...' // dataURL of the gray-scaled image
}
```
@@ -705,6 +696,18 @@ on the ``singleChannel`` flag in the configuration when using ``decodeSingle``.
## Changelog
+### 2019-07-31
+- Internal Changes
+ - Converted to TypeScript
+ - Upgraded tooling to Webpack 4.38, Babel 7.5, Karma 4.2, Chai 4.2, Sinon 7.3
+ - Removed redundant files
+- Improvements
+ - Removed all 3rd party dependencies for Web version
+ - Changed ImageDebug API
+ - Changed ``Box`` interface to be ``[Point, Point, Point, Point]``
+ - Improved performance by utilizing ES2015+ features, bitwise operators, etc.
+ - Added support for ``area`` measured in pixels (px)
+
### 2017-06-07
- Improvements
- added `muted` and `playsinline` to `` to make it work for Safari 11
@@ -759,18 +762,15 @@ Take a look at the release-notes (
[0.10.0](https://github.com/serratus/quaggaJS/releases/tag/v0.10.0))
### 2016-02-18
-
- Internal Changes
- Restructuring into meaningful folders
- Removing debug-code in production build
-
### 2016-02-15
Take a look at the release-notes (
[0.9.0](https://github.com/serratus/quaggaJS/releases/tag/v0.9.0))
### 2015-11-22
-
- Fixes
- Fixed inconsistencies for Code 128 decoding (See
[\#76](https://github.com/serratus/quaggaJS/issues/76))
diff --git a/bower.json b/bower.json
deleted file mode 100644
index ef8b1a98..00000000
--- a/bower.json
+++ /dev/null
@@ -1,68 +0,0 @@
-{
- "name": "quagga",
- "version": "0.12.1",
- "description": "An advanced barcode-scanner written in JavaScript",
- "main": "dist/quagga.js",
- "ignore": [
- "build",
- "doc",
- "spec",
- "src",
- "tasks",
- "test",
- ".gitignore",
- ".npmignore",
- "Gruntfile.js",
- "karma-integration.conf.js",
- "karma.conf.js",
- "package.json",
- "test-main.js"
- ],
- "devDependencies": {
- "async": "^0.9.0",
- "grunt": "~0.4.5",
- "grunt-contrib-jshint": "~0.10.0",
- "grunt-contrib-nodeunit": "~0.4.1",
- "grunt-contrib-uglify": "~0.5.0",
- "grunt-karma": "^0.9.0",
- "grunt-requirejs": "^0.4.2",
- "karma": "latest",
- "karma-chai": "latest",
- "karma-chrome-launcher": "^0.1.12",
- "karma-coverage": "^0.3.1",
- "karma-mocha": "latest",
- "karma-phantomjs-launcher": "^0.1.4",
- "karma-requirejs": "^0.2.2",
- "karma-sinon": "^1.0.4",
- "karma-sinon-chai": "^0.2.0",
- "sinon": "^1.12.1"
- },
- "directories": {
- "doc": "doc"
- },
- "scripts": {
- "test": "karma start"
- },
- "repository": {
- "type": "git",
- "url": "https://github.com/serratus/quaggaJS.git"
- },
- "bugs": {
- "url": "https://github.com/serratus/quaggaJS/issues"
- },
- "keywords": [
- "quagga",
- "quaggajs",
- "barcode",
- "ean",
- "code128",
- "code39",
- "codabar",
- "i2of5",
- "upc",
- "getusermedia",
- "imageprocessing"
- ],
- "author": "Christoph Oberhofer ",
- "license": "MIT"
-}
diff --git a/build/end.frag b/build/end.frag
deleted file mode 100644
index c1167bbc..00000000
--- a/build/end.frag
+++ /dev/null
@@ -1,2 +0,0 @@
- return require('quagga');
-}));
\ No newline at end of file
diff --git a/build/start.frag b/build/start.frag
deleted file mode 100644
index 73729274..00000000
--- a/build/start.frag
+++ /dev/null
@@ -1,11 +0,0 @@
-(function (root, factory) {
- var factorySource = factory.toString();
-
- if (typeof module !== 'undefined') {
- module.exports = factory(factorySource);
- } else {
- //Browser globals case. Just assign the
- //result to a property on the global.
- root.Quagga = factory(factorySource);
- }
-}(this, function (__factorySource__) {
\ No newline at end of file
diff --git a/dist/quagga.d.ts b/dist/quagga.d.ts
new file mode 100644
index 00000000..f6c7e908
--- /dev/null
+++ b/dist/quagga.d.ts
@@ -0,0 +1,1115 @@
+declare module "common/polyfills" {
+ export function polyfills(): void;
+ const _default: void;
+ export default _default;
+}
+declare module "common/point" {
+ export interface Point {
+ x: number;
+ y: number;
+ }
+}
+declare module "common/image-debug" {
+ import { Point } from "common/point";
+ export const ImageDebug: {
+ drawPath(path: Point[], context: CanvasRenderingContext2D, color: string, lineWidth: number): void;
+ drawImage(imageData: Uint8Array, width: number, height: number, context: CanvasRenderingContext2D): boolean;
+ };
+}
+declare module "common/box" {
+ import { Point } from "common/point";
+ export type Box = [Point, Point, Point, Point];
+}
+declare module "common/moment" {
+ export interface Moment {
+ x?: number;
+ y?: number;
+ m00?: number;
+ m01?: number;
+ m10?: number;
+ m11?: number;
+ m02?: number;
+ m20?: number;
+ theta?: number;
+ rad?: number;
+ }
+}
+declare module "common/hsv2rgb" {
+ export type HSV = [number, number, number];
+ export type RGB = [number, number, number];
+ export function hsv2rgb(hsv: HSV, rgb?: RGB): RGB;
+}
+declare module "common/image-wrapper" {
+ import { Moment } from "common/moment";
+ import { Point } from "common/point";
+ type ArrayType = Array | Uint8Array | Int32Array;
+ /**
+ * Represents a basic image combining the data and size.
+ * In addition, some methods for manipulation are contained.
+ */
+ export class ImageWrapper {
+ data: T | Uint8Array;
+ size: Point;
+ /**
+ * @param size The size of the image in pixel
+ * @param data If given, a flat array containing the pixel data
+ * @param arrayType If given, the desired DataType of the Array (may be typed/non-typed)
+ * @param initialize Indicating if the array should be initialized on creation.
+ */
+ constructor(size: Point, data?: T, arrayType?: {
+ new (_: number): T | Uint8Array;
+ }, initialize?: boolean);
+ /**
+ * Tests if a position is within the image with a given offset
+ * @param point The location to test
+ * @param border The padding value in pixels
+ * @returns true if location inside the image's border, false otherwise
+ * @see cvd/image.h
+ */
+ inImageWithBorder(point: Point, border: number): boolean;
+ /**
+ * Creates an {ImageWrapper) and copies the needed underlying image-data area
+ * @param imageWrapper The target {ImageWrapper} where the data should be copied
+ * @param fromX The horizontal position where to copy from
+ * @param fromY The vertical position where to copy from
+ */
+ subImageAsCopy(imageWrapper: ImageWrapper, fromX: number, fromY: number): void;
+ /**
+ * Retrieves a given pixel position from the image
+ * @param x The x-position
+ * @param y The y-position
+ * @returns The grayscale value at the pixel-position
+ */
+ get(x: number, y: number): number;
+ /**
+ * Sets a given pixel position in the image
+ * @param x The x-position
+ * @param y The y-position
+ * @param value The grayscale value to set
+ * @returns The Image itself (for possible chaining)
+ */
+ set(x: number, y: number, value: number): ImageWrapper;
+ /**
+ * Sets the border of the image (1 pixel) to zero
+ */
+ zeroBorder(): void;
+ /**
+ * Inverts a binary image in place
+ */
+ invert(): void;
+ moments(labelCount: number): Array;
+ /**
+ * Displays the {ImageWrapper} in a given canvas
+ * @param context The rendering context to write to
+ * @param scale Scale which is applied to each pixel-value
+ */
+ show(context: CanvasRenderingContext2D, scale: number): void;
+ /**
+ * Displays the part of the image in a given canvas
+ * @param context The rendering context to write to
+ * @param scale Scale which is applied to each pixel-value
+ * @param fromX The horizontal position where to overlay from
+ * @param fromY The vertical position where to overlay from
+ */
+ overlay(context: CanvasRenderingContext2D, scale: number, fromX: number, fromY: number): void;
+ }
+}
+declare module "reader/barcode-reader" {
+ export enum BarcodeDirection {
+ Forward = 1,
+ Reverse = -1
+ }
+ export type BarcodeFormat = string;
+ export type BarcodeReaderType = string;
+ export type BarcodeReaderDeclaration = BarcodeReaderType | {
+ format: BarcodeReaderType;
+ config: BarcodeReaderConfig;
+ };
+ export interface BarcodeReaderConfig {
+ normalizeBarSpaceWidth?: boolean;
+ supplements?: Array;
+ }
+ export interface BarcodeCorrection {
+ bar: number;
+ space: number;
+ }
+ export interface BarcodeInfo {
+ code?: number;
+ correction?: BarcodeCorrection;
+ end?: number;
+ endCounter?: number;
+ error?: number;
+ start?: number;
+ startCounter?: number;
+ }
+ export interface Barcode {
+ code?: string;
+ codeset?: number;
+ correction?: BarcodeCorrection;
+ decodedCodes?: Array;
+ direction?: BarcodeDirection;
+ end?: number;
+ endInfo?: BarcodeInfo;
+ format?: BarcodeFormat;
+ start?: number;
+ startInfo?: BarcodeInfo;
+ supplement?: Barcode;
+ }
+ export abstract class BarcodeReader {
+ protected _singleCodeError: number;
+ protected _averageCodeError: number;
+ protected _format: BarcodeFormat;
+ protected _row: Array;
+ config: BarcodeReaderConfig;
+ supplements: Array;
+ static readonly Exception: {
+ StartNotFoundException: string;
+ CodeNotFoundException: string;
+ PatternNotFoundException: string;
+ };
+ readonly SINGLE_CODE_ERROR: number;
+ readonly AVERAGE_CODE_ERROR: number;
+ readonly FORMAT: BarcodeFormat;
+ constructor(config?: BarcodeReaderConfig, supplements?: Array);
+ abstract decode(row?: Array, start?: number): Barcode;
+ protected _findPattern(pattern: ReadonlyArray, offset: number, isWhite: 0 | 1, tryHarder: boolean): BarcodeInfo;
+ protected _nextUnset(line: ReadonlyArray, start?: number): number;
+ protected _nextSet(line: ReadonlyArray, start?: number): number;
+ protected _matchRange(start: number, end: number, value: number): boolean;
+ protected _matchPattern(counter: ReadonlyArray, code: ReadonlyArray, maxSingleError?: number): number;
+ protected _correctBars(counter: Array, correction: number, indices: Array): void;
+ decodePattern(pattern: Array): Barcode;
+ _fillCounters(offset: number, end: number, isWhite: 0 | 1): Array;
+ protected _toCounters(start: number, counters: Uint16Array): Uint16Array;
+ }
+}
+declare module "reader/code-128-reader" {
+ import { Barcode, BarcodeCorrection, BarcodeInfo, BarcodeReader } from "reader/barcode-reader";
+ export class Code128Reader extends BarcodeReader {
+ constructor();
+ protected _decodeCode(start: number, correction: BarcodeCorrection): BarcodeInfo;
+ private _correct;
+ protected _findStart(): {
+ error: number;
+ code: number;
+ start: number;
+ end: number;
+ correction: {
+ bar: number;
+ space: number;
+ };
+ };
+ decode(): Barcode;
+ protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
+ private _calculateCorrection;
+ }
+}
+declare module "reader/code-39-reader" {
+ import { Barcode, BarcodeInfo, BarcodeReader } from "reader/barcode-reader";
+ export class Code39Reader extends BarcodeReader {
+ constructor();
+ decode(): Barcode;
+ protected _patternToChar(pattern: any): string;
+ private _verifyTrailingWhitespace;
+ private _findNextWidth;
+ private _toPattern;
+ protected _findStart(): BarcodeInfo;
+ }
+}
+declare module "reader/code-39-vin-reader" {
+ import { Barcode } from "reader/barcode-reader";
+ import { Code39Reader } from "reader/code-39-reader";
+ export class Code39VINReader extends Code39Reader {
+ constructor();
+ /**
+ * @borrows
+ * https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/client/result/VINResultParser.java
+ */
+ decode(): Barcode;
+ private _checkChecksum;
+ }
+}
+declare module "reader/codabar-reader" {
+ import { Barcode, BarcodeInfo, BarcodeReader } from "reader/barcode-reader";
+ export class CodabarReader extends BarcodeReader {
+ private _counters;
+ constructor();
+ decode(): Barcode;
+ protected _verifyWhitespace(startCounter: number, endCounter: number): boolean;
+ private _calculatePatternLength;
+ private _thresholdResultPattern;
+ private _charToPattern;
+ private _validateResult;
+ private _patternToChar;
+ private _computeAlternatingThreshold;
+ private _toPattern;
+ private _sumCounters;
+ protected _findStart(): BarcodeInfo;
+ }
+}
+declare module "common/merge" {
+ /**
+ * Performs a deep merge of objects and returns new object.
+ * Does not modify objects (immutable).
+ * @see https://stackoverflow.com/a/48218209
+ *
+ * @param objects - Objects to merge
+ * @returns New object with merged key/values
+ */
+ export function merge(...objects: ReadonlyArray): object;
+}
+declare module "reader/ean-reader" {
+ import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
+ export class EANReader extends BarcodeReader {
+ readonly CODE_L_START: number;
+ readonly CODE_G_START: number;
+ readonly START_PATTERN: Array;
+ readonly STOP_PATTERN: Array;
+ readonly MIDDLE_PATTERN: Array;
+ constructor(config?: BarcodeReaderConfig, supplements?: Array);
+ protected _decodeCode(start: number, coderange?: number): BarcodeInfo;
+ protected _findStart(): BarcodeInfo;
+ protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
+ protected _findEnd(offset: number, isWhite: 0 | 1): BarcodeInfo;
+ private _calculateFirstDigit;
+ protected _decodePayload(code: BarcodeInfo, result: Array, decodedCodes: Array): BarcodeInfo;
+ decode(): Barcode;
+ private _decodeExtensions;
+ protected _checksum(result: Array): boolean;
+ }
+}
+declare module "reader/ean-8-reader" {
+ import { BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
+ import { EANReader } from "reader/ean-reader";
+ export class EAN8Reader extends EANReader {
+ constructor(config?: BarcodeReaderConfig, supplements?: Array);
+ protected _decodePayload(code: BarcodeInfo, result: Array, decodedCodes: Array): BarcodeInfo;
+ }
+}
+declare module "reader/ean-2-reader" {
+ import { Barcode, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
+ import { EANReader } from "reader/ean-reader";
+ export class EAN2Reader extends EANReader {
+ constructor(config?: BarcodeReaderConfig, supplements?: Array);
+ decode(row?: Array, start?: number): Barcode;
+ }
+}
+declare module "reader/ean-5-reader" {
+ import { Barcode, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
+ import { EANReader } from "reader/ean-reader";
+ export class EAN5Reader extends EANReader {
+ readonly CHECK_DIGIT_ENCODINGS: Array;
+ constructor(config?: BarcodeReaderConfig, supplements?: Array);
+ decode(row?: Array, start?: number): Barcode;
+ private _determineCheckDigit;
+ private _extensionChecksum;
+ }
+}
+declare module "reader/upc-reader" {
+ import { Barcode, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
+ import { EANReader } from "reader/ean-reader";
+ export class UPCReader extends EANReader {
+ constructor(config?: BarcodeReaderConfig, supplements?: Array);
+ decode(): Barcode;
+ }
+}
+declare module "reader/upc-e-reader" {
+ import { BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
+ import { EANReader } from "reader/ean-reader";
+ export class UPCEReader extends EANReader {
+ readonly STOP_PATTERN: number[];
+ constructor(config?: BarcodeReaderConfig, supplements?: Array);
+ protected _decodePayload(code: BarcodeInfo, result: Array, decodedCodes: Array): BarcodeInfo;
+ private _determineParity;
+ private _convertToUPCA;
+ protected _checksum(result: Array): boolean;
+ protected _findEnd(offset: number, isWhite: 0 | 1): BarcodeInfo;
+ protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
+ }
+}
+declare module "reader/i2of5-reader" {
+ import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
+ export class I2of5Reader extends BarcodeReader {
+ private _barSpaceRatio;
+ constructor(config?: BarcodeReaderConfig);
+ decode(): Barcode;
+ protected _matchPattern(counter: Array, code: ReadonlyArray): number;
+ protected _findStart(): BarcodeInfo;
+ protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
+ protected _findEnd(): BarcodeInfo;
+ protected _decodeCode(counter: Array): BarcodeInfo;
+ protected _decodePayload(counters: ReadonlyArray, result: Array, decodedCodes: Array): [BarcodeInfo, BarcodeInfo];
+ }
+}
+declare module "reader/2of5-reader" {
+ import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from "reader/barcode-reader";
+ export class TwoOfFiveReader extends BarcodeReader {
+ private _barSpaceRatio;
+ constructor(config?: BarcodeReaderConfig);
+ decode(): Barcode;
+ protected _findStart(): BarcodeInfo;
+ protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo;
+ protected _findEnd(): BarcodeInfo;
+ protected _decodeCode(counter: ReadonlyArray): BarcodeInfo;
+ protected _decodePayload(counters: ReadonlyArray, result: Array, decodedCodes: Array): BarcodeInfo;
+ }
+}
+declare module "reader/code-93-reader" {
+ import { Barcode, BarcodeReader } from "reader/barcode-reader";
+ export class Code93Reader extends BarcodeReader {
+ constructor();
+ decode(): Barcode;
+ protected _patternToChar(pattern: number): string;
+ private _verifyEnd;
+ private _toPattern;
+ private _findStart;
+ private _decodeExtended;
+ private _verifyChecksums;
+ private _matchCheckChar;
+ }
+}
+declare module "reader/index" {
+ import { Code128Reader } from "reader/code-128-reader";
+ import { Code39Reader } from "reader/code-39-reader";
+ import { Code39VINReader } from "reader/code-39-vin-reader";
+ import { CodabarReader } from "reader/codabar-reader";
+ import { EANReader } from "reader/ean-reader";
+ import { EAN8Reader } from "reader/ean-8-reader";
+ import { EAN2Reader } from "reader/ean-2-reader";
+ import { EAN5Reader } from "reader/ean-5-reader";
+ import { UPCReader } from "reader/upc-reader";
+ import { UPCEReader } from "reader/upc-e-reader";
+ import { I2of5Reader } from "reader/i2of5-reader";
+ import { TwoOfFiveReader } from "reader/2of5-reader";
+ import { Code93Reader } from "reader/code-93-reader";
+ export const Readers: {
+ code_128_reader: typeof Code128Reader;
+ ean_reader: typeof EANReader;
+ ean_5_reader: typeof EAN5Reader;
+ ean_2_reader: typeof EAN2Reader;
+ ean_8_reader: typeof EAN8Reader;
+ code_39_reader: typeof Code39Reader;
+ code_39_vin_reader: typeof Code39VINReader;
+ codabar_reader: typeof CodabarReader;
+ upc_reader: typeof UPCReader;
+ upc_e_reader: typeof UPCEReader;
+ i2of5_reader: typeof I2of5Reader;
+ '2of5_reader': typeof TwoOfFiveReader;
+ code_93_reader: typeof Code93Reader;
+ };
+}
+declare module "decoder/bresenham" {
+ import { Point } from "common/point";
+ import { ImageWrapper } from "common/image-wrapper";
+ export interface BarcodeLine {
+ line: Array;
+ max?: number;
+ min?: number;
+ threshold?: number;
+ }
+ export const Bresenham: {
+ /**
+ * Scans a line of the given image from point p1 to p2 and returns a result object containing
+ * gray-scale values (0-255) of the underlying pixels in addition to the min and max values.
+ * @param imageWrapper
+ * @param p1 The start point {x,y}
+ * @param p2 The end point {x,y}
+ * @returns {line, min, max}
+ */
+ getBarcodeLine(imageWrapper: ImageWrapper, p1: Point, p2: Point): BarcodeLine;
+ /**
+ * Converts the result from getBarcodeLine into a binary representation
+ * also considering the frequency and slope of the signal for more robust results
+ * @param result {line, min, max}
+ */
+ toBinaryLine(result: BarcodeLine): BarcodeLine;
+ };
+}
+declare module "decoder/barcode-decoder" {
+ import { Box } from "common/box";
+ import { ImageWrapper } from "common/image-wrapper";
+ import { Point } from "common/point";
+ import { Barcode, BarcodeReaderDeclaration } from "reader/barcode-reader";
+ export interface BarcodeDecoderConfig {
+ debug?: {
+ drawBoundingBox?: boolean;
+ drawScanline?: boolean;
+ showFrequency?: boolean;
+ showPattern?: boolean;
+ };
+ multiple?: boolean;
+ readers?: Array;
+ }
+ type Line = [Point, Point];
+ export interface QuaggaBarcode {
+ angle?: number;
+ barcodes?: Array;
+ box?: Box;
+ boxes?: Array;
+ codeResult?: Barcode;
+ frame?: string;
+ line?: Line;
+ pattern?: Array;
+ threshold?: number;
+ }
+ export class BarcodeDecoder {
+ private _config;
+ private _inputImageWrapper;
+ private _frequencyCanvas;
+ private _patternCanvas;
+ private _overlayContext;
+ private _barcodeReaders;
+ constructor(config: BarcodeDecoderConfig, inputImageWrapper: ImageWrapper);
+ decodeFromBoundingBoxes(boxes: Array): QuaggaBarcode;
+ /**
+ * With the help of the configured readers this function tries to detect
+ * a valid barcode pattern within the given area.
+ * @param box The area to search in
+ * @returns The result {codeResult, line, angle, pattern, threshold}
+ */
+ decodeFromBoundingBox(box: Box): QuaggaBarcode;
+ setReaders(readers: Array): void;
+ private _initReaders;
+ /**
+ * extend the line on both ends
+ * @param line
+ * @param angle
+ */
+ private _getExtendedLine;
+ private _getLine;
+ private _tryDecode;
+ /**
+ * This method slices the given area apart and tries to detect a barcode-pattern for each slice.
+ * It returns the decoded barcode, or null if nothing was found
+ * @param box
+ * @param line
+ * @param lineAngle
+ */
+ private _tryDecodeBruteForce;
+ /**
+ * Used for development only
+ */
+ private _printFrequency;
+ /**
+ * Used for development only
+ */
+ private _printPattern;
+ private _drawPath;
+ }
+}
+declare module "analytics/result-collector" {
+ import { QuaggaBarcode } from "decoder/barcode-decoder";
+ import { Barcode } from "reader/barcode-reader";
+ export interface ResultCollectorConfig {
+ capacity?: number;
+ capture?: boolean;
+ blacklist?: Array;
+ filter?: (item: Barcode) => boolean;
+ }
+ export class ResultCollector {
+ private _canvas;
+ private _context;
+ private _config;
+ private _capacity;
+ private _capture;
+ private _results;
+ constructor(config: ResultCollectorConfig);
+ addResult(data: Uint8Array, imageWidth: number, imageHeight: number, codeResult: Barcode): void;
+ getResults(): Array;
+ private _contains;
+ private _passesFilter;
+ }
+}
+declare module "common/events" {
+ export interface EventCallback {
+ (data: any): void;
+ }
+ export interface EventSubscription {
+ callback: EventCallback;
+ async?: boolean;
+ once?: boolean;
+ }
+ export class Events {
+ static subscribe(event: string, callback: EventSubscription | EventCallback, async?: boolean): void;
+ static publish(type: string, data?: any): void;
+ static once(event: string, callback: EventCallback, async?: boolean): void;
+ static unsubscribe(eventName?: string, callback?: EventCallback): void;
+ }
+}
+declare module "locator/barcode-locator-config" {
+ export type PatchSizeConfig = number | 'x-small' | 'small' | 'medium' | 'large' | 'x-large';
+ export interface BarcodeLocatorDebugConfig {
+ /**
+ * @default false
+ */
+ showCanvas?: boolean;
+ /**
+ * @default false
+ */
+ showPatches?: boolean;
+ /**
+ * @default false
+ */
+ showFoundPatches?: boolean;
+ /**
+ * @default false
+ */
+ showSkeleton?: boolean;
+ /**
+ * @default false
+ */
+ showLabels?: boolean;
+ /**
+ * @default false
+ */
+ showPatchLabels?: boolean;
+ /**
+ * @default false
+ */
+ showRemainingPatchLabels?: boolean;
+ boxFromPatches?: {
+ /**
+ * @default false
+ */
+ showTransformed?: boolean;
+ /**
+ * @default false
+ */
+ showTransformedBox?: boolean;
+ /**
+ * @default false
+ */
+ showBB?: boolean;
+ };
+ }
+ export interface BarcodeLocatorConfig {
+ debug?: BarcodeLocatorDebugConfig;
+ /**
+ * @default true
+ */
+ halfSample?: boolean;
+ /**
+ * @default 'medium'
+ */
+ patchSize?: PatchSizeConfig;
+ useWorker?: boolean;
+ }
+}
+declare module "input/input-stream-config" {
+ type InputStreamType = 'ImageStream' | 'LiveStream' | 'VideoStream';
+ export interface AreaConfig {
+ bottom?: string;
+ left?: string;
+ right?: string;
+ top?: string;
+ }
+ export interface InputStreamConfig {
+ area?: AreaConfig;
+ constraints?: MediaTrackConstraints;
+ halfSample?: boolean;
+ length?: number;
+ mime?: string;
+ name?: string;
+ sequence?: boolean;
+ singleChannel?: boolean;
+ size?: number;
+ src?: string;
+ target?: HTMLElement | string;
+ type?: InputStreamType;
+ }
+}
+declare module "config/config" {
+ import { BarcodeDecoderConfig } from "decoder/barcode-decoder";
+ import { BarcodeLocatorConfig } from "locator/barcode-locator-config";
+ import { InputStreamConfig } from "input/input-stream-config";
+ interface DebugConfig {
+ }
+ export interface QuaggaConfig {
+ debug?: DebugConfig;
+ decoder?: BarcodeDecoderConfig;
+ frequency?: number;
+ inputStream?: InputStreamConfig;
+ locate?: boolean;
+ locator?: BarcodeLocatorConfig;
+ numOfWorkers?: number;
+ src?: string;
+ }
+ export const config: QuaggaConfig;
+}
+declare module "common/media-devices" {
+ export function enumerateDevices(): Promise>;
+ export function getUserMedia(constraints: MediaStreamConstraints): Promise;
+}
+declare module "input/camera-access" {
+ export const CameraAccess: {
+ /**
+ * Attempts to attach the camera-stream to a given video element
+ * and calls the callback function when the content is ready
+ * @param video
+ * @param videoConstraints
+ */
+ request(video: HTMLVideoElement, videoConstraints: MediaTrackConstraints): Promise;
+ release(): void;
+ enumerateVideoDevices(): Promise;
+ getActiveStreamLabel(): string;
+ getActiveTrack(): MediaStreamTrack;
+ pickConstraints(videoConstraints: MediaTrackConstraints): MediaStreamConstraints;
+ };
+}
+declare module "input/exif-helper" {
+ export const AvailableTags: Array;
+ export interface Tags {
+ [key: string]: number | string;
+ }
+ export function findTagsInObjectURL(src: string, tags?: string[]): Promise;
+ export function findTagsInBuffer(file: ArrayBuffer, selectedTags?: Array): Tags;
+}
+declare module "input/image-loader" {
+ import { Tags } from "input/exif-helper";
+ export interface ImageInfo {
+ image: HTMLImageElement;
+ tags?: Tags;
+ }
+ export class ImageLoader {
+ static load(baseUri: string, callback: (_: Array) => void, offset: number, size: number, sequence: boolean): Promise;
+ }
+}
+declare module "input/input-stream" {
+ import { Point } from "common/point";
+ import { ImageInfo } from "input/image-loader";
+ import { InputStreamConfig } from "input/input-stream-config";
+ export abstract class InputStream {
+ protected _calculatedHeight: number;
+ protected _calculatedWidth: number;
+ protected _canvasHeight: number;
+ protected _canvasWidth: number;
+ protected _config: InputStreamConfig;
+ protected _eventNames: Array;
+ protected _eventHandlers: Map>;
+ protected _topLeft: Point;
+ constructor();
+ abstract readonly realHeight: number;
+ abstract readonly realWidth: number;
+ height: number;
+ width: number;
+ topLeft: Point;
+ setCanvasSize(width: number, height: number): void;
+ readonly canvasHeight: number;
+ readonly canvasWidth: number;
+ abstract config: InputStreamConfig;
+ abstract readonly ended: boolean;
+ abstract setAttribute(name: string, value: string): void;
+ abstract pause(): void;
+ abstract play(): void;
+ abstract currentTime: number;
+ addEventListener(event: string, listener: EventListener, _options?: boolean): void;
+ clearEventHandlers(): void;
+ trigger(eventName: string, argArray?: any): void;
+ abstract getFrame(): HTMLVideoElement | ImageInfo;
+ }
+}
+declare module "input/frame-grabber" {
+ import { InputStream } from "input/input-stream";
+ export class FrameGrabber {
+ private _inputStream;
+ private _streamConfig;
+ private _canvas;
+ private _context;
+ private _data;
+ private _canvasHeight;
+ private _canvasWidth;
+ private _height;
+ private _width;
+ private _topLeft;
+ constructor(inputStream: InputStream, canvas: HTMLCanvasElement);
+ /**
+ * Fetches a frame from the input stream and puts into the frame buffer.
+ * The image data is converted to gray scale and then half-sampled if configured.
+ */
+ grab(data: Uint8Array): boolean;
+ private _adjustCanvasSize;
+ private _grayAndHalfSampleFromCanvasData;
+ private _computeGray;
+ }
+}
+declare module "input/image-stream" {
+ import { ImageInfo } from "input/image-loader";
+ import { InputStream } from "input/input-stream";
+ import { InputStreamConfig } from "input/input-stream-config";
+ export class ImageStream extends InputStream {
+ private _baseUrl;
+ private _ended;
+ private _frameIndex;
+ private _height;
+ private _images;
+ private _loaded;
+ private _offset;
+ private _paused;
+ private _size;
+ private _width;
+ constructor();
+ readonly realHeight: number;
+ readonly realWidth: number;
+ config: InputStreamConfig;
+ readonly ended: boolean;
+ setAttribute(): void;
+ pause(): void;
+ play(): void;
+ currentTime: number;
+ getFrame(): HTMLVideoElement | ImageInfo;
+ private _loadImages;
+ }
+}
+declare module "input/video-stream" {
+ import { ImageInfo } from "input/image-loader";
+ import { InputStream } from "input/input-stream";
+ import { InputStreamConfig } from "input/input-stream-config";
+ export class VideoStream extends InputStream {
+ private _video;
+ constructor(video: HTMLVideoElement);
+ readonly realHeight: number;
+ readonly realWidth: number;
+ config: InputStreamConfig;
+ readonly ended: boolean;
+ setAttribute(name: string, value: string): void;
+ pause(): void;
+ play(): void;
+ currentTime: number;
+ addEventListener(event: string, listener: EventListener, options?: boolean): void;
+ clearEventHandlers(): void;
+ trigger(eventName: string, argArray?: any): void;
+ getFrame(): HTMLVideoElement | ImageInfo;
+ private _initSize;
+ }
+ export class LiveStream extends VideoStream {
+ constructor(video: HTMLVideoElement);
+ readonly ended: boolean;
+ }
+}
+declare module "input/live-stream" {
+ import { VideoStream } from "input/video-stream";
+ export class LiveStream extends VideoStream {
+ constructor(video: HTMLVideoElement);
+ readonly ended: boolean;
+ }
+}
+declare module "input/input-stream-utils" {
+ import { Point } from "common/point";
+ import { BarcodeLocatorConfig, PatchSizeConfig } from "locator/barcode-locator-config";
+ import { InputStream } from "input/input-stream";
+ import { AreaConfig } from "input/input-stream-config";
+ export interface Dimension {
+ unit: '%' | 'px';
+ value: number;
+ }
+ export function calculatePatchSize(patchSize: PatchSizeConfig, { x, y }: Point): Point;
+ export function checkImageConstraints(inputStream: InputStream, config: BarcodeLocatorConfig): boolean;
+ export function _parseCssDimensionValues(value: string): Dimension;
+ export const _dimensionsConverters: {
+ bottom: (dimension: Dimension, { height }: {
+ height: any;
+ }) => any;
+ left: (dimension: Dimension, { width }: {
+ width: any;
+ }) => number;
+ right: (dimension: Dimension, { width }: {
+ width: any;
+ }) => any;
+ top: (dimension: Dimension, { height }: {
+ height: any;
+ }) => number;
+ };
+ export function computeImageArea(inputWidth: number, inputHeight: number, area: AreaConfig): {
+ topLeft: {
+ x: number;
+ y: number;
+ };
+ width: number;
+ height: number;
+ };
+}
+declare module "common/cluster" {
+ import { Moment } from "common/moment";
+ /**
+ * Creates a cluster for grouping similar orientations of moments
+ */
+ export class Cluster {
+ private _threshold;
+ private _moments;
+ private _center;
+ static clusterize(moments: Array, threshold: number): Array;
+ constructor(threshold: number, moment: Moment);
+ add(point: Moment): void;
+ fits(moment: Moment): boolean;
+ readonly moments: Moment[];
+ }
+}
+declare module "locator/barcode-locator-utils" {
+ import { ImageWrapper } from "common/image-wrapper";
+ import { Point } from "common/point";
+ /**
+ * Invert matrix
+ * @param matrix the matrix to invert
+ * @returns the inverted matrix
+ */
+ export function invert(matrix: Float32Array): Float32Array;
+ /**
+ * Transforms the vector with a matrix
+ * @param { x, y } vector to transform
+ * @param matrix matrix to transform with
+ * @returns the transformed vector
+ */
+ export function transformWithMatrix({ x, y }: Point, matrix: Float32Array): Point;
+ export function otsuThreshold(imageWrapper: ImageWrapper, targetWrapper: ImageWrapper): number;
+ /**
+ * @param imageWrapper input image to be sampled
+ * @param outImageWrapper {ImageWrapper} to be stored in
+ */
+ export function halfSample(imageWrapper: ImageWrapper, outImageWrapper: ImageWrapper): void;
+}
+declare module "locator/tracer" {
+ import { ImageWrapper } from "common/image-wrapper";
+ /**
+ * @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
+ */
+ type Direction = number;
+ export const SearchDirections: Array>;
+ export interface ContourVertex {
+ x: number;
+ y: number;
+ dir: Direction;
+ next: ContourVertex;
+ prev: ContourVertex;
+ }
+ interface Current {
+ cx: number;
+ cy: number;
+ dir: Direction;
+ }
+ export class Tracer {
+ private _imageData;
+ private _labelData;
+ private _width;
+ constructor(imageWrapper: ImageWrapper, labelWrapper: ImageWrapper>);
+ trace(current: Current, color: number, label: number, edgeLabel: number): boolean;
+ contourTracing(sy: number, sx: number, label: number, color: number, edgeLabel: number): ContourVertex;
+ }
+}
+declare module "locator/rasterizer" {
+ /**
+ * @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
+ */
+ import { ImageWrapper } from "common/image-wrapper";
+ import { ContourVertex } from "locator/tracer";
+ enum ContourDirection {
+ CW = 0,
+ CCW = 1,
+ Unknown = 2
+ }
+ interface Contour {
+ dir: ContourDirection;
+ index: number;
+ firstVertex: ContourVertex;
+ previousPeer?: Contour;
+ nextPeer?: Contour;
+ insideContours: Contour;
+ }
+ export interface RasterResult {
+ cc: Contour;
+ count: number;
+ }
+ export class Rasterizer {
+ private _width;
+ private _height;
+ private _tracer;
+ private _imageData;
+ private _labelData;
+ constructor(imageWrapper: ImageWrapper, labelWrapper: ImageWrapper>);
+ rasterize(depthLabel: number): RasterResult;
+ drawContour(canvas: HTMLCanvasElement, firstContour: Contour): void;
+ }
+}
+declare module "locator/barcode-locator" {
+ import { ImageWrapper } from "common/image-wrapper";
+ import { Point } from "common/point";
+ import { BarcodeLocatorConfig } from "locator/barcode-locator-config";
+ export class BarcodeLocator {
+ private _config;
+ private _inputImageWrapper;
+ private _currentImageWrapper;
+ private _skelImageWrapper;
+ private _subImageWrapper;
+ private _labelImageWrapper;
+ private _binaryImageWrapper;
+ private _patchGrid;
+ private _patchLabelGrid;
+ private _imageToPatchGrid;
+ private _patchSize;
+ private _binaryContext;
+ private _numPatches;
+ private _skeletonizer;
+ constructor(inputImageWrapper: ImageWrapper, config: BarcodeLocatorConfig);
+ locate(): [Point, Point, Point, Point][];
+ private _initBuffers;
+ private _initCanvas;
+ /**
+ * Creates a bounding box which encloses all the given patches
+ * @returns The minimal bounding box
+ */
+ private _boxFromPatches;
+ /**
+ * Creates a binary image of the current image
+ */
+ private _binarizeImage;
+ /**
+ * Iterate over the entire image, extract patches
+ */
+ private _findPatches;
+ /**
+ * Finds those connected areas which contain at least 6 patches
+ * and returns them ordered DESC by the number of contained patches
+ * @param maxLabel
+ */
+ private _findBiggestConnectedAreas;
+ /**
+ *
+ */
+ private _findBoxes;
+ /**
+ * Find similar moments (via cluster)
+ * @param moments
+ */
+ private _similarMoments;
+ private _skeletonize;
+ /**
+ * Extracts and describes those patches which seem to contain a barcode pattern
+ * @param moments
+ * @param index
+ * @param x
+ * @param y
+ * @returns list of patches
+ */
+ private _describePatch;
+ private _notYetProcessed;
+ private _trace;
+ /**
+ * Finds patches which are connected and share the same orientation
+ * @param patchesFound
+ */
+ private _rasterizeAngularSimilarity;
+ private _drawRect;
+ private _drawPath;
+ }
+}
+declare module "quagga" {
+ import { ResultCollector } from "analytics/result-collector";
+ import { EventCallback, EventSubscription } from "common/events";
+ import { ImageWrapper } from "common/image-wrapper";
+ import { Point } from "common/point";
+ import { QuaggaConfig } from "config/config";
+ import { QuaggaBarcode } from "decoder/barcode-decoder";
+ import { BarcodeReaderDeclaration } from "reader/barcode-reader";
+ export interface QuaggaCanvasContainer {
+ ctx: {
+ image: CanvasRenderingContext2D;
+ overlay: CanvasRenderingContext2D;
+ };
+ dom: {
+ image: HTMLCanvasElement;
+ overlay: HTMLCanvasElement;
+ };
+ }
+ const _default_1: {
+ init(config: QuaggaConfig, cb: () => void, imageWrapper?: ImageWrapper): void;
+ CameraAccess: {
+ request(video: HTMLVideoElement, videoConstraints: MediaTrackConstraints): Promise;
+ release(): void;
+ enumerateVideoDevices(): Promise;
+ getActiveStreamLabel(): string;
+ getActiveTrack(): MediaStreamTrack;
+ pickConstraints(videoConstraints: MediaTrackConstraints): MediaStreamConstraints;
+ };
+ ImageDebug: {
+ drawPath(path: Point[], context: CanvasRenderingContext2D, color: string, lineWidth: number): void;
+ drawImage(imageData: Uint8Array, width: number, height: number, context: CanvasRenderingContext2D): boolean;
+ };
+ ImageWrapper: typeof ImageWrapper;
+ ResultCollector: typeof ResultCollector;
+ readonly canvas: QuaggaCanvasContainer;
+ start(): void;
+ stop(): void;
+ decodeSingle(config: QuaggaConfig, resultCallback: (_: QuaggaBarcode) => void): void;
+ pause(): void;
+ onDetected(callback: EventCallback | EventSubscription): void;
+ offDetected(callback: EventCallback): void;
+ onProcessed(callback: EventCallback | EventSubscription): void;
+ offProcessed(callback: EventCallback): void;
+ setReaders(readers: BarcodeReaderDeclaration[]): void;
+ registerResultCollector(resultCollector: ResultCollector): void;
+ };
+ export default _default_1;
+}
+declare module "config/config.dev" {
+ import { QuaggaConfig } from "config/config";
+ export const config: QuaggaConfig;
+}
+declare module "config/config.node" {
+ import { QuaggaConfig } from "config/config";
+ export const config: QuaggaConfig;
+}
+declare module "input/frame-grabber.node" {
+ import { InputStream } from "input/input-stream";
+ export class FrameGrabber {
+ private _inputStream;
+ private _streamConfig;
+ private _data;
+ private _canvasData;
+ private _grayData;
+ private _canvasImageArray;
+ private _grayImageArray;
+ private _targetImageArray;
+ private _canvasHeight;
+ private _canvasWidth;
+ private _videoHeight;
+ private _videoWidth;
+ private _height;
+ private _width;
+ private _stepSizeX;
+ private _stepSizeY;
+ private _topLeft;
+ constructor(inputStream: InputStream);
+ /**
+ * Fetches a frame from the input stream and puts into the frame buffer.
+ * The image data is converted to gray scale and then half-sampled if configured.
+ */
+ grab(data: Uint8Array): boolean;
+ private _scaleAndCrop;
+ private _computeGray;
+ }
+}
+declare module "input/image-stream.node" {
+ import { ImageInfo } from "input/image-loader";
+ import { InputStream } from "input/input-stream";
+ import { InputStreamConfig } from "input/input-stream-config";
+ export class ImageStream extends InputStream {
+ private _baseUrl;
+ private _ended;
+ private _frame;
+ private _height;
+ private _loaded;
+ private _offset;
+ private _size;
+ private _width;
+ constructor();
+ readonly realHeight: number;
+ readonly realWidth: number;
+ config: InputStreamConfig;
+ readonly ended: boolean;
+ setAttribute(): void;
+ pause(): void;
+ play(): void;
+ currentTime: number;
+ getFrame(): HTMLVideoElement | ImageInfo;
+ private _loadImages;
+ }
+}
diff --git a/dist/quagga.js b/dist/quagga.js
index a99b4289..9a2a682d 100644
--- a/dist/quagga.js
+++ b/dist/quagga.js
@@ -1,12 +1,15 @@
+var Quagga =
+
(function webpackUniversalModuleDefinition(root, factory) {
- if(typeof exports === 'object' && typeof module === 'object')
- module.exports = factory(factory.toString()).default;
- else if(typeof exports === 'object')
- exports["Quagga"] = factory(factory.toString()).default;
- else
- root["Quagga"] = factory(factory.toString()).default;
+ if (typeof exports === 'object' && typeof module === 'object') {
+ module.exports = factory(factory.toString()).default;
+ } else if (typeof exports === 'object') {
+ exports["Quagga"] = factory(factory.toString()).default;
+ } else {
+ root["Quagga"] = factory(factory.toString()).default;
+ }
})(this, function(__factorySource__) {
-return /******/ (function(modules) { // webpackBootstrap
+ return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
@@ -14,9 +17,9 @@ return /******/ (function(modules) { // webpackBootstrap
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
-/******/ if(installedModules[moduleId])
+/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
-/******/
+/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
@@ -41,18 +44,35 @@ return /******/ (function(modules) { // webpackBootstrap
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
-/******/ // identity function for calling harmony imports with the correct context
-/******/ __webpack_require__.i = function(value) { return value; };
-/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
-/******/ Object.defineProperty(exports, name, {
-/******/ configurable: false,
-/******/ enumerable: true,
-/******/ get: getter
-/******/ });
+/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ }
+/******/ };
+/******/
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = function(exports) {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/
+/******/ // create a fake namespace object
+/******/ // mode & 1: value is a module id, require it
+/******/ // mode & 2: merge all properties of value into the ns
+/******/ // mode & 4: return value when already ns object
+/******/ // mode & 8|1: behave like require
+/******/ __webpack_require__.t = function(value, mode) {
+/******/ if(mode & 1) value = __webpack_require__(value);
+/******/ if(mode & 8) return value;
+/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ var ns = Object.create(null);
+/******/ __webpack_require__.r(ns);
+/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
@@ -70,11514 +90,9261 @@ return /******/ (function(modules) { // webpackBootstrap
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "/";
/******/
+/******/
/******/ // Load entry module and return exports
-/******/ return __webpack_require__(__webpack_require__.s = 166);
+/******/ return __webpack_require__(__webpack_require__.s = "./src/quagga.ts");
/******/ })
/************************************************************************/
-/******/ ([
-/* 0 */
+/******/ ({
+
+/***/ "../../node_modules/@babel/runtime/helpers/arrayWithoutHoles.js":
+/*!***********************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
/***/ (function(module, exports) {
-/**
- * Checks if `value` is the
- * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
- * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an object, else `false`.
- * @example
- *
- * _.isObject({});
- * // => true
- *
- * _.isObject([1, 2, 3]);
- * // => true
- *
- * _.isObject(_.noop);
- * // => true
- *
- * _.isObject(null);
- * // => false
- */
-function isObject(value) {
- var type = typeof value;
- return value != null && (type == 'object' || type == 'function');
+function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr)) {
+ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+ arr2[i] = arr[i];
+ }
+
+ return arr2;
+ }
}
-module.exports = isObject;
+module.exports = _arrayWithoutHoles;
+
+/***/ }),
+
+/***/ "../../node_modules/@babel/runtime/helpers/assertThisInitialized.js":
+/*!***************************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/assertThisInitialized.js ***!
+ \***************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+function _assertThisInitialized(self) {
+ if (self === void 0) {
+ throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ }
+
+ return self;
+}
+module.exports = _assertThisInitialized;
/***/ }),
-/* 1 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__common_array_helper__ = __webpack_require__(3);
+/***/ "../../node_modules/@babel/runtime/helpers/asyncToGenerator.js":
+/*!**********************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/asyncToGenerator.js ***!
+ \**********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+ try {
+ var info = gen[key](arg);
+ var value = info.value;
+ } catch (error) {
+ reject(error);
+ return;
+ }
-function BarcodeReader(config, supplements) {
- this._row = [];
- this.config = config || {};
- this.supplements = supplements;
- return this;
+ if (info.done) {
+ resolve(value);
+ } else {
+ Promise.resolve(value).then(_next, _throw);
+ }
}
-BarcodeReader.prototype._nextUnset = function (line, start) {
- var i;
+function _asyncToGenerator(fn) {
+ return function () {
+ var self = this,
+ args = arguments;
+ return new Promise(function (resolve, reject) {
+ var gen = fn.apply(self, args);
- if (start === undefined) {
- start = 0;
- }
- for (i = start; i < line.length; i++) {
- if (!line[i]) {
- return i;
- }
- }
- return line.length;
-};
+ function _next(value) {
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+ }
-BarcodeReader.prototype._matchPattern = function (counter, code, maxSingleError) {
- var i,
- error = 0,
- singleError = 0,
- sum = 0,
- modulo = 0,
- barWidth,
- count,
- scaled;
+ function _throw(err) {
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+ }
- maxSingleError = maxSingleError || this.SINGLE_CODE_ERROR || 1;
+ _next(undefined);
+ });
+ };
+}
- for (i = 0; i < counter.length; i++) {
- sum += counter[i];
- modulo += code[i];
- }
- if (sum < modulo) {
- return Number.MAX_VALUE;
- }
- barWidth = sum / modulo;
- maxSingleError *= barWidth;
+module.exports = _asyncToGenerator;
- for (i = 0; i < counter.length; i++) {
- count = counter[i];
- scaled = code[i] * barWidth;
- singleError = Math.abs(count - scaled) / scaled;
- if (singleError > maxSingleError) {
- return Number.MAX_VALUE;
- }
- error += singleError;
- }
- return error / modulo;
-};
+/***/ }),
-BarcodeReader.prototype._nextSet = function (line, offset) {
- var i;
+/***/ "../../node_modules/@babel/runtime/helpers/classCallCheck.js":
+/*!********************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/classCallCheck.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
- offset = offset || 0;
- for (i = offset; i < line.length; i++) {
- if (line[i]) {
- return i;
- }
- }
- return line.length;
-};
+function _classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+}
-BarcodeReader.prototype._correctBars = function (counter, correction, indices) {
- var length = indices.length,
- tmp = 0;
- while (length--) {
- tmp = counter[indices[length]] * (1 - (1 - correction) / 2);
- if (tmp > 1) {
- counter[indices[length]] = tmp;
- }
- }
-};
+module.exports = _classCallCheck;
-BarcodeReader.prototype._matchTrace = function (cmpCounter, epsilon) {
- var counter = [],
- i,
- self = this,
- offset = self._nextSet(self._row),
- isWhite = !self._row[offset],
- counterPos = 0,
- bestMatch = {
- error: Number.MAX_VALUE,
- code: -1,
- start: 0
- },
- error;
+/***/ }),
- if (cmpCounter) {
- for (i = 0; i < cmpCounter.length; i++) {
- counter.push(0);
- }
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- if (counterPos === counter.length - 1) {
- error = self._matchPattern(counter, cmpCounter);
-
- if (error < epsilon) {
- bestMatch.start = i - offset;
- bestMatch.end = i;
- bestMatch.counter = counter;
- return bestMatch;
- } else {
- return null;
- }
- } else {
- counterPos++;
- }
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- } else {
- counter.push(0);
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- counterPos++;
- counter.push(0);
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- }
+/***/ "../../node_modules/@babel/runtime/helpers/createClass.js":
+/*!*****************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/createClass.js ***!
+ \*****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
- // if cmpCounter was not given
- bestMatch.start = offset;
- bestMatch.end = self._row.length - 1;
- bestMatch.counter = counter;
- return bestMatch;
-};
+function _defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+}
-BarcodeReader.prototype.decodePattern = function (pattern) {
- var self = this,
- result;
+function _createClass(Constructor, protoProps, staticProps) {
+ if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) _defineProperties(Constructor, staticProps);
+ return Constructor;
+}
- self._row = pattern;
- result = self._decode();
- if (result === null) {
- self._row.reverse();
- result = self._decode();
- if (result) {
- result.direction = BarcodeReader.DIRECTION.REVERSE;
- result.start = self._row.length - result.start;
- result.end = self._row.length - result.end;
- }
- } else {
- result.direction = BarcodeReader.DIRECTION.FORWARD;
- }
- if (result) {
- result.format = self.FORMAT;
- }
- return result;
-};
+module.exports = _createClass;
-BarcodeReader.prototype._matchRange = function (start, end, value) {
- var i;
+/***/ }),
- start = start < 0 ? 0 : start;
- for (i = start; i < end; i++) {
- if (this._row[i] !== value) {
- return false;
- }
- }
- return true;
-};
+/***/ "../../node_modules/@babel/runtime/helpers/defineProperty.js":
+/*!********************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/defineProperty.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
-BarcodeReader.prototype._fillCounters = function (offset, end, isWhite) {
- var self = this,
- counterPos = 0,
- i,
- counters = [];
-
- isWhite = typeof isWhite !== 'undefined' ? isWhite : true;
- offset = typeof offset !== 'undefined' ? offset : self._nextUnset(self._row);
- end = end || self._row.length;
-
- counters[counterPos] = 0;
- for (i = offset; i < end; i++) {
- if (self._row[i] ^ isWhite) {
- counters[counterPos]++;
- } else {
- counterPos++;
- counters[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- return counters;
-};
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
-BarcodeReader.prototype._toCounters = function (start, counter) {
- var self = this,
- numCounters = counter.length,
- end = self._row.length,
- isWhite = !self._row[start],
- i,
- counterPos = 0;
+ return obj;
+}
- __WEBPACK_IMPORTED_MODULE_0__common_array_helper__["a" /* default */].init(counter, 0);
+module.exports = _defineProperty;
- for (i = start; i < end; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- counterPos++;
- if (counterPos === numCounters) {
- break;
- } else {
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- }
+/***/ }),
- return counter;
-};
+/***/ "../../node_modules/@babel/runtime/helpers/get.js":
+/*!*********************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/get.js ***!
+ \*********************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
-Object.defineProperty(BarcodeReader.prototype, "FORMAT", {
- value: 'unknown',
- writeable: false
-});
+var getPrototypeOf = __webpack_require__(/*! ./getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
-BarcodeReader.DIRECTION = {
- FORWARD: 1,
- REVERSE: -1
-};
+var superPropBase = __webpack_require__(/*! ./superPropBase */ "../../node_modules/@babel/runtime/helpers/superPropBase.js");
-BarcodeReader.Exception = {
- StartNotFoundException: "Start-Info was not found!",
- CodeNotFoundException: "Code could not be found!",
- PatternNotFoundException: "Pattern could not be found!"
-};
+function _get(target, property, receiver) {
+ if (typeof Reflect !== "undefined" && Reflect.get) {
+ module.exports = _get = Reflect.get;
+ } else {
+ module.exports = _get = function _get(target, property, receiver) {
+ var base = superPropBase(target, property);
+ if (!base) return;
+ var desc = Object.getOwnPropertyDescriptor(base, property);
+
+ if (desc.get) {
+ return desc.get.call(receiver);
+ }
-BarcodeReader.CONFIG_KEYS = {};
+ return desc.value;
+ };
+ }
+
+ return _get(target, property, receiver || target);
+}
-/* harmony default export */ __webpack_exports__["a"] = BarcodeReader;
+module.exports = _get;
/***/ }),
-/* 2 */
-/***/ (function(module, exports) {
-/**
- * Checks if `value` is classified as an `Array` object.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an array, else `false`.
- * @example
- *
- * _.isArray([1, 2, 3]);
- * // => true
- *
- * _.isArray(document.body.children);
- * // => false
- *
- * _.isArray('abc');
- * // => false
- *
- * _.isArray(_.noop);
- * // => false
- */
-var isArray = Array.isArray;
+/***/ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js":
+/*!********************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/getPrototypeOf.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
-module.exports = isArray;
+function _getPrototypeOf(o) {
+ module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+ return o.__proto__ || Object.getPrototypeOf(o);
+ };
+ return _getPrototypeOf(o);
+}
+module.exports = _getPrototypeOf;
/***/ }),
-/* 3 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony default export */ __webpack_exports__["a"] = {
- init: function init(arr, val) {
- var l = arr.length;
- while (l--) {
- arr[l] = val;
- }
- },
+/***/ "../../node_modules/@babel/runtime/helpers/inherits.js":
+/*!**************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/inherits.js ***!
+ \**************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
- /**
- * Shuffles the content of an array
- * @return {Array} the array itself shuffled
- */
- shuffle: function shuffle(arr) {
- var i = arr.length - 1,
- j,
- x;
- for (i; i >= 0; i--) {
- j = Math.floor(Math.random() * i);
- x = arr[i];
- arr[i] = arr[j];
- arr[j] = x;
- }
- return arr;
- },
+var setPrototypeOf = __webpack_require__(/*! ./setPrototypeOf */ "../../node_modules/@babel/runtime/helpers/setPrototypeOf.js");
- toPointList: function toPointList(arr) {
- var i,
- j,
- row = [],
- rows = [];
- for (i = 0; i < arr.length; i++) {
- row = [];
- for (j = 0; j < arr[i].length; j++) {
- row[j] = arr[i][j];
- }
- rows[i] = "[" + row.join(",") + "]";
- }
- return "[" + rows.join(",\r\n") + "]";
- },
+function _inherits(subClass, superClass) {
+ if (typeof superClass !== "function" && superClass !== null) {
+ throw new TypeError("Super expression must either be null or a function");
+ }
- /**
- * returns the elements which's score is bigger than the threshold
- * @return {Array} the reduced array
- */
- threshold: function threshold(arr, _threshold, scoreFunc) {
- var i,
- queue = [];
- for (i = 0; i < arr.length; i++) {
- if (scoreFunc.apply(arr, [arr[i]]) >= _threshold) {
- queue.push(arr[i]);
- }
- }
- return queue;
- },
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ writable: true,
+ configurable: true
+ }
+ });
+ if (superClass) setPrototypeOf(subClass, superClass);
+}
- maxIndex: function maxIndex(arr) {
- var i,
- max = 0;
- for (i = 0; i < arr.length; i++) {
- if (arr[i] > arr[max]) {
- max = i;
- }
- }
- return max;
- },
+module.exports = _inherits;
- max: function max(arr) {
- var i,
- max = 0;
- for (i = 0; i < arr.length; i++) {
- if (arr[i] > max) {
- max = arr[i];
- }
- }
- return max;
- },
+/***/ }),
- sum: function sum(arr) {
- var length = arr.length,
- sum = 0;
+/***/ "../../node_modules/@babel/runtime/helpers/iterableToArray.js":
+/*!*********************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/iterableToArray.js ***!
+ \*********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
- while (length--) {
- sum += arr[length];
- }
- return sum;
- }
-};
+function _iterableToArray(iter) {
+ if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}
+
+module.exports = _iterableToArray;
/***/ }),
-/* 4 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge__ = __webpack_require__(28);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_merge__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__barcode_reader__ = __webpack_require__(1);
+/***/ "../../node_modules/@babel/runtime/helpers/nonIterableSpread.js":
+/*!***********************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/nonIterableSpread.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
-var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+module.exports = _nonIterableSpread;
+/***/ }),
+/***/ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js":
+/*!*******************************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js ***!
+ \*******************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+var _typeof = __webpack_require__(/*! ../helpers/typeof */ "../../node_modules/@babel/runtime/helpers/typeof.js");
-function EANReader(opts, supplements) {
- opts = __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default()(getDefaulConfig(), opts);
- __WEBPACK_IMPORTED_MODULE_1__barcode_reader__["a" /* default */].call(this, opts, supplements);
-}
+var assertThisInitialized = __webpack_require__(/*! ./assertThisInitialized */ "../../node_modules/@babel/runtime/helpers/assertThisInitialized.js");
-function getDefaulConfig() {
- var config = {};
+function _possibleConstructorReturn(self, call) {
+ if (call && (_typeof(call) === "object" || typeof call === "function")) {
+ return call;
+ }
- Object.keys(EANReader.CONFIG_KEYS).forEach(function (key) {
- config[key] = EANReader.CONFIG_KEYS[key].default;
- });
- return config;
+ return assertThisInitialized(self);
}
-var properties = {
- CODE_L_START: { value: 0 },
- CODE_G_START: { value: 10 },
- START_PATTERN: { value: [1, 1, 1] },
- STOP_PATTERN: { value: [1, 1, 1] },
- MIDDLE_PATTERN: { value: [1, 1, 1, 1, 1] },
- EXTENSION_START_PATTERN: { value: [1, 1, 2] },
- CODE_PATTERN: { value: [[3, 2, 1, 1], [2, 2, 2, 1], [2, 1, 2, 2], [1, 4, 1, 1], [1, 1, 3, 2], [1, 2, 3, 1], [1, 1, 1, 4], [1, 3, 1, 2], [1, 2, 1, 3], [3, 1, 1, 2], [1, 1, 2, 3], [1, 2, 2, 2], [2, 2, 1, 2], [1, 1, 4, 1], [2, 3, 1, 1], [1, 3, 2, 1], [4, 1, 1, 1], [2, 1, 3, 1], [3, 1, 2, 1], [2, 1, 1, 3]] },
- CODE_FREQUENCY: { value: [0, 11, 13, 14, 19, 25, 28, 21, 22, 26] },
- SINGLE_CODE_ERROR: { value: 0.70 },
- AVG_CODE_ERROR: { value: 0.48 },
- FORMAT: { value: "ean_13", writeable: false }
-};
+module.exports = _possibleConstructorReturn;
-EANReader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_1__barcode_reader__["a" /* default */].prototype, properties);
-EANReader.prototype.constructor = EANReader;
-
-EANReader.prototype._decodeCode = function (start, coderange) {
- var counter = [0, 0, 0, 0],
- i,
- self = this,
- offset = start,
- isWhite = !self._row[offset],
- counterPos = 0,
- bestMatch = {
- error: Number.MAX_VALUE,
- code: -1,
- start: start,
- end: start
- },
- code,
- error;
+/***/ }),
- if (!coderange) {
- coderange = self.CODE_PATTERN.length;
- }
+/***/ "../../node_modules/@babel/runtime/helpers/setPrototypeOf.js":
+/*!********************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/setPrototypeOf.js ***!
+ \********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- if (counterPos === counter.length - 1) {
- for (code = 0; code < coderange; code++) {
- error = self._matchPattern(counter, self.CODE_PATTERN[code]);
- if (error < bestMatch.error) {
- bestMatch.code = code;
- bestMatch.error = error;
- }
- }
- bestMatch.end = i;
- if (bestMatch.error > self.AVG_CODE_ERROR) {
- return null;
- }
- return bestMatch;
- } else {
- counterPos++;
- }
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- return null;
-};
+function _setPrototypeOf(o, p) {
+ module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+ o.__proto__ = p;
+ return o;
+ };
-EANReader.prototype._findPattern = function (pattern, offset, isWhite, tryHarder, epsilon) {
- var counter = [],
- self = this,
- i,
- counterPos = 0,
- bestMatch = {
- error: Number.MAX_VALUE,
- code: -1,
- start: 0,
- end: 0
- },
- error,
- j,
- sum;
+ return _setPrototypeOf(o, p);
+}
- if (!offset) {
- offset = self._nextSet(self._row);
- }
+module.exports = _setPrototypeOf;
- if (isWhite === undefined) {
- isWhite = false;
- }
+/***/ }),
- if (tryHarder === undefined) {
- tryHarder = true;
- }
+/***/ "../../node_modules/@babel/runtime/helpers/superPropBase.js":
+/*!*******************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/superPropBase.js ***!
+ \*******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
- if (epsilon === undefined) {
- epsilon = self.AVG_CODE_ERROR;
- }
+var getPrototypeOf = __webpack_require__(/*! ./getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
- for (i = 0; i < pattern.length; i++) {
- counter[i] = 0;
- }
+function _superPropBase(object, property) {
+ while (!Object.prototype.hasOwnProperty.call(object, property)) {
+ object = getPrototypeOf(object);
+ if (object === null) break;
+ }
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- if (counterPos === counter.length - 1) {
- sum = 0;
- for (j = 0; j < counter.length; j++) {
- sum += counter[j];
- }
- error = self._matchPattern(counter, pattern);
+ return object;
+}
- if (error < epsilon) {
- bestMatch.error = error;
- bestMatch.start = i - sum;
- bestMatch.end = i;
- return bestMatch;
- }
- if (tryHarder) {
- for (j = 0; j < counter.length - 2; j++) {
- counter[j] = counter[j + 2];
- }
- counter[counter.length - 2] = 0;
- counter[counter.length - 1] = 0;
- counterPos--;
- } else {
- return null;
- }
- } else {
- counterPos++;
- }
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- return null;
-};
+module.exports = _superPropBase;
-EANReader.prototype._findStart = function () {
- var self = this,
- leadingWhitespaceStart,
- offset = self._nextSet(self._row),
- startInfo;
+/***/ }),
- while (!startInfo) {
- startInfo = self._findPattern(self.START_PATTERN, offset);
- if (!startInfo) {
- return null;
- }
- leadingWhitespaceStart = startInfo.start - (startInfo.end - startInfo.start);
- if (leadingWhitespaceStart >= 0) {
- if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {
- return startInfo;
- }
- }
- offset = startInfo.end;
- startInfo = null;
- }
-};
-
-EANReader.prototype._verifyTrailingWhitespace = function (endInfo) {
- var self = this,
- trailingWhitespaceEnd;
-
- trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start);
- if (trailingWhitespaceEnd < self._row.length) {
- if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
- return endInfo;
- }
- }
- return null;
-};
-
-EANReader.prototype._findEnd = function (offset, isWhite) {
- var self = this,
- endInfo = self._findPattern(self.STOP_PATTERN, offset, isWhite, false);
-
- return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;
-};
-
-EANReader.prototype._calculateFirstDigit = function (codeFrequency) {
- var i,
- self = this;
+/***/ "../../node_modules/@babel/runtime/helpers/toConsumableArray.js":
+/*!***********************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/toConsumableArray.js ***!
+ \***********************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
- for (i = 0; i < self.CODE_FREQUENCY.length; i++) {
- if (codeFrequency === self.CODE_FREQUENCY[i]) {
- return i;
- }
- }
- return null;
-};
+var arrayWithoutHoles = __webpack_require__(/*! ./arrayWithoutHoles */ "../../node_modules/@babel/runtime/helpers/arrayWithoutHoles.js");
-EANReader.prototype._decodePayload = function (code, result, decodedCodes) {
- var i,
- self = this,
- codeFrequency = 0x0,
- firstDigit;
+var iterableToArray = __webpack_require__(/*! ./iterableToArray */ "../../node_modules/@babel/runtime/helpers/iterableToArray.js");
- for (i = 0; i < 6; i++) {
- code = self._decodeCode(code.end);
- if (!code) {
- return null;
- }
- if (code.code >= self.CODE_G_START) {
- code.code = code.code - self.CODE_G_START;
- codeFrequency |= 1 << 5 - i;
- } else {
- codeFrequency |= 0 << 5 - i;
- }
- result.push(code.code);
- decodedCodes.push(code);
- }
+var nonIterableSpread = __webpack_require__(/*! ./nonIterableSpread */ "../../node_modules/@babel/runtime/helpers/nonIterableSpread.js");
- firstDigit = self._calculateFirstDigit(codeFrequency);
- if (firstDigit === null) {
- return null;
- }
- result.unshift(firstDigit);
+function _toConsumableArray(arr) {
+ return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+}
- code = self._findPattern(self.MIDDLE_PATTERN, code.end, true, false);
- if (code === null) {
- return null;
- }
- decodedCodes.push(code);
+module.exports = _toConsumableArray;
- for (i = 0; i < 6; i++) {
- code = self._decodeCode(code.end, self.CODE_G_START);
- if (!code) {
- return null;
- }
- decodedCodes.push(code);
- result.push(code.code);
- }
+/***/ }),
- return code;
-};
+/***/ "../../node_modules/@babel/runtime/helpers/typeof.js":
+/*!************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/helpers/typeof.js ***!
+ \************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
-EANReader.prototype._decode = function () {
- var startInfo,
- self = this,
- code,
- result = [],
- decodedCodes = [],
- resultInfo = {};
+function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
- startInfo = self._findStart();
- if (!startInfo) {
- return null;
- }
- code = {
- code: startInfo.code,
- start: startInfo.start,
- end: startInfo.end
+function _typeof(obj) {
+ if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
+ module.exports = _typeof = function _typeof(obj) {
+ return _typeof2(obj);
};
- decodedCodes.push(code);
- code = self._decodePayload(code, result, decodedCodes);
- if (!code) {
- return null;
- }
- code = self._findEnd(code.end, false);
- if (!code) {
- return null;
- }
-
- decodedCodes.push(code);
+ } else {
+ module.exports = _typeof = function _typeof(obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
+ };
+ }
- // Checksum
- if (!self._checksum(result)) {
- return null;
- }
+ return _typeof(obj);
+}
- if (this.supplements.length > 0) {
- var ext = this._decodeExtensions(code.end);
- if (!ext) {
- return null;
- }
- var lastCode = ext.decodedCodes[ext.decodedCodes.length - 1],
- endInfo = {
- start: lastCode.start + ((lastCode.end - lastCode.start) / 2 | 0),
- end: lastCode.end
- };
- if (!self._verifyTrailingWhitespace(endInfo)) {
- return null;
- }
- resultInfo = {
- supplement: ext,
- code: result.join("") + ext.code
- };
- }
+module.exports = _typeof;
- return _extends({
- code: result.join(""),
- start: startInfo.start,
- end: code.end,
- codeset: "",
- startInfo: startInfo,
- decodedCodes: decodedCodes
- }, resultInfo);
-};
+/***/ }),
-EANReader.prototype._decodeExtensions = function (offset) {
- var i,
- start = this._nextSet(this._row, offset),
- startInfo = this._findPattern(this.EXTENSION_START_PATTERN, start, false, false),
- result;
+/***/ "../../node_modules/@babel/runtime/regenerator/index.js":
+/*!***************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/@babel/runtime/regenerator/index.js ***!
+ \***************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
- if (startInfo === null) {
- return null;
- }
+module.exports = __webpack_require__(/*! regenerator-runtime */ "../../node_modules/regenerator-runtime/runtime-module.js");
- for (i = 0; i < this.supplements.length; i++) {
- result = this.supplements[i].decode(this._row, startInfo.end);
- if (result !== null) {
- return {
- code: result.code,
- start: start,
- startInfo: startInfo,
- end: result.end,
- codeset: "",
- decodedCodes: result.decodedCodes
- };
- }
- }
- return null;
-};
-EANReader.prototype._checksum = function (result) {
- var sum = 0,
- i;
+/***/ }),
- for (i = result.length - 2; i >= 0; i -= 2) {
- sum += result[i];
- }
- sum *= 3;
- for (i = result.length - 1; i >= 0; i -= 2) {
- sum += result[i];
- }
- return sum % 10 === 0;
-};
+/***/ "../../node_modules/regenerator-runtime/runtime-module.js":
+/*!*****************************************************************************!*\
+ !*** /Users/adomratchev/node_modules/regenerator-runtime/runtime-module.js ***!
+ \*****************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
-EANReader.CONFIG_KEYS = {
- supplements: {
- 'type': 'arrayOf(string)',
- 'default': [],
- 'description': 'Allowed extensions to be decoded (2 and/or 5)'
- }
-};
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
-/* harmony default export */ __webpack_exports__["a"] = EANReader;
+// This method of obtaining a reference to the global object needs to be
+// kept identical to the way it is obtained in runtime.js
+var g = (function() {
+ return this || (typeof self === "object" && self);
+})() || Function("return this")();
-/***/ }),
-/* 5 */
-/***/ (function(module, exports, __webpack_require__) {
+// Use `getOwnPropertyNames` because not all browsers support calling
+// `hasOwnProperty` on the global `self` object in a worker. See #183.
+var hadRuntime = g.regeneratorRuntime &&
+ Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime") >= 0;
-var freeGlobal = __webpack_require__(38);
+// Save the old regeneratorRuntime in case it needs to be restored later.
+var oldRuntime = hadRuntime && g.regeneratorRuntime;
-/** Detect free variable `self`. */
-var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+// Force reevalutation of runtime.js.
+g.regeneratorRuntime = undefined;
-/** Used as a reference to the global object. */
-var root = freeGlobal || freeSelf || Function('return this')();
+module.exports = __webpack_require__(/*! ./runtime */ "../../node_modules/regenerator-runtime/runtime.js");
-module.exports = root;
+if (hadRuntime) {
+ // Restore the original runtime.
+ g.regeneratorRuntime = oldRuntime;
+} else {
+ // Remove the global property added by runtime.js.
+ try {
+ delete g.regeneratorRuntime;
+ } catch(e) {
+ g.regeneratorRuntime = undefined;
+ }
+}
/***/ }),
-/* 6 */
+
+/***/ "../../node_modules/regenerator-runtime/runtime.js":
+/*!**********************************************************************!*\
+ !*** /Users/adomratchev/node_modules/regenerator-runtime/runtime.js ***!
+ \**********************************************************************/
+/*! no static exports found */
/***/ (function(module, exports) {
/**
- * Checks if `value` is object-like. A value is object-like if it's not `null`
- * and has a `typeof` result of "object".
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
- * @example
- *
- * _.isObjectLike({});
- * // => true
- *
- * _.isObjectLike([1, 2, 3]);
- * // => true
+ * Copyright (c) 2014-present, Facebook, Inc.
*
- * _.isObjectLike(_.noop);
- * // => false
- *
- * _.isObjectLike(null);
- * // => false
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
*/
-function isObjectLike(value) {
- return value != null && typeof value == 'object';
-}
-module.exports = isObjectLike;
+!(function(global) {
+ "use strict";
+ var Op = Object.prototype;
+ var hasOwn = Op.hasOwnProperty;
+ var undefined; // More compressible than void 0.
+ var $Symbol = typeof Symbol === "function" ? Symbol : {};
+ var iteratorSymbol = $Symbol.iterator || "@@iterator";
+ var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+ var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-/***/ }),
-/* 7 */
-/***/ (function(module, exports) {
+ var inModule = typeof module === "object";
+ var runtime = global.regeneratorRuntime;
+ if (runtime) {
+ if (inModule) {
+ // If regeneratorRuntime is defined globally and we're in a module,
+ // make the exports object identical to regeneratorRuntime.
+ module.exports = runtime;
+ }
+ // Don't bother evaluating the rest of this file if the runtime was
+ // already defined globally.
+ return;
+ }
-module.exports = clone
+ // Define the runtime globally (as expected by generated code) as either
+ // module.exports (if we're in a module) or a new, empty object.
+ runtime = global.regeneratorRuntime = inModule ? module.exports : {};
-/**
- * Creates a new vec2 initialized with values from an existing vector
- *
- * @param {vec2} a vector to clone
- * @returns {vec2} a new 2D vector
- */
-function clone(a) {
- var out = new Float32Array(2)
- out[0] = a[0]
- out[1] = a[1]
- return out
-}
+ function wrap(innerFn, outerFn, self, tryLocsList) {
+ // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
+ var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+ var generator = Object.create(protoGenerator.prototype);
+ var context = new Context(tryLocsList || []);
-/***/ }),
-/* 8 */
-/***/ (function(module, exports, __webpack_require__) {
+ // The ._invoke method unifies the implementations of the .next,
+ // .throw, and .return methods.
+ generator._invoke = makeInvokeMethod(innerFn, self, context);
-var Symbol = __webpack_require__(11),
- getRawTag = __webpack_require__(119),
- objectToString = __webpack_require__(146);
+ return generator;
+ }
+ runtime.wrap = wrap;
+
+ // Try/catch helper to minimize deoptimizations. Returns a completion
+ // record like context.tryEntries[i].completion. This interface could
+ // have been (and was previously) designed to take a closure to be
+ // invoked without arguments, but in all the cases we care about we
+ // already have an existing method we want to call, so there's no need
+ // to create a new function object. We can even get away with assuming
+ // the method takes exactly one argument, since that happens to be true
+ // in every case, so we don't have to touch the arguments object. The
+ // only additional allocation required is the completion record, which
+ // has a stable shape and so hopefully should be cheap to allocate.
+ function tryCatch(fn, obj, arg) {
+ try {
+ return { type: "normal", arg: fn.call(obj, arg) };
+ } catch (err) {
+ return { type: "throw", arg: err };
+ }
+ }
-/** `Object#toString` result references. */
-var nullTag = '[object Null]',
- undefinedTag = '[object Undefined]';
+ var GenStateSuspendedStart = "suspendedStart";
+ var GenStateSuspendedYield = "suspendedYield";
+ var GenStateExecuting = "executing";
+ var GenStateCompleted = "completed";
+
+ // Returning this object from the innerFn has the same effect as
+ // breaking out of the dispatch switch statement.
+ var ContinueSentinel = {};
+
+ // Dummy constructor functions that we use as the .constructor and
+ // .constructor.prototype properties for functions that return Generator
+ // objects. For full spec compliance, you may wish to configure your
+ // minifier not to mangle the names of these two functions.
+ function Generator() {}
+ function GeneratorFunction() {}
+ function GeneratorFunctionPrototype() {}
+
+ // This is a polyfill for %IteratorPrototype% for environments that
+ // don't natively support it.
+ var IteratorPrototype = {};
+ IteratorPrototype[iteratorSymbol] = function () {
+ return this;
+ };
-/** Built-in value references. */
-var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+ var getProto = Object.getPrototypeOf;
+ var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+ if (NativeIteratorPrototype &&
+ NativeIteratorPrototype !== Op &&
+ hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+ // This environment has a native %IteratorPrototype%; use it instead
+ // of the polyfill.
+ IteratorPrototype = NativeIteratorPrototype;
+ }
-/**
- * The base implementation of `getTag` without fallbacks for buggy environments.
- *
- * @private
- * @param {*} value The value to query.
- * @returns {string} Returns the `toStringTag`.
- */
-function baseGetTag(value) {
- if (value == null) {
- return value === undefined ? undefinedTag : nullTag;
+ var Gp = GeneratorFunctionPrototype.prototype =
+ Generator.prototype = Object.create(IteratorPrototype);
+ GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+ GeneratorFunctionPrototype.constructor = GeneratorFunction;
+ GeneratorFunctionPrototype[toStringTagSymbol] =
+ GeneratorFunction.displayName = "GeneratorFunction";
+
+ // Helper for defining the .next, .throw, and .return methods of the
+ // Iterator interface in terms of a single ._invoke method.
+ function defineIteratorMethods(prototype) {
+ ["next", "throw", "return"].forEach(function(method) {
+ prototype[method] = function(arg) {
+ return this._invoke(method, arg);
+ };
+ });
}
- return (symToStringTag && symToStringTag in Object(value))
- ? getRawTag(value)
- : objectToString(value);
-}
-module.exports = baseGetTag;
+ runtime.isGeneratorFunction = function(genFun) {
+ var ctor = typeof genFun === "function" && genFun.constructor;
+ return ctor
+ ? ctor === GeneratorFunction ||
+ // For the native GeneratorFunction constructor, the best we can
+ // do is to check its .name property.
+ (ctor.displayName || ctor.name) === "GeneratorFunction"
+ : false;
+ };
+ runtime.mark = function(genFun) {
+ if (Object.setPrototypeOf) {
+ Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+ } else {
+ genFun.__proto__ = GeneratorFunctionPrototype;
+ if (!(toStringTagSymbol in genFun)) {
+ genFun[toStringTagSymbol] = "GeneratorFunction";
+ }
+ }
+ genFun.prototype = Object.create(Gp);
+ return genFun;
+ };
-/***/ }),
-/* 9 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ // Within the body of any async function, `await x` is transformed to
+ // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+ // `hasOwn.call(value, "__await")` to determine if the yielded value is
+ // meant to be awaited.
+ runtime.awrap = function(arg) {
+ return { __await: arg };
+ };
-"use strict";
-/* harmony default export */ __webpack_exports__["a"] = {
- drawRect: function drawRect(pos, size, ctx, style) {
- ctx.strokeStyle = style.color;
- ctx.fillStyle = style.color;
- ctx.lineWidth = 1;
- ctx.beginPath();
- ctx.strokeRect(pos.x, pos.y, size.x, size.y);
- },
- drawPath: function drawPath(path, def, ctx, style) {
- ctx.strokeStyle = style.color;
- ctx.fillStyle = style.color;
- ctx.lineWidth = style.lineWidth;
- ctx.beginPath();
- ctx.moveTo(path[0][def.x], path[0][def.y]);
- for (var j = 1; j < path.length; j++) {
- ctx.lineTo(path[j][def.x], path[j][def.y]);
- }
- ctx.closePath();
- ctx.stroke();
- },
- drawImage: function drawImage(imageData, size, ctx) {
- var canvasData = ctx.getImageData(0, 0, size.x, size.y),
- data = canvasData.data,
- imageDataPos = imageData.length,
- canvasDataPos = data.length,
- value;
-
- if (canvasDataPos / imageDataPos !== 4) {
- return false;
- }
- while (imageDataPos--) {
- value = imageData[imageDataPos];
- data[--canvasDataPos] = 255;
- data[--canvasDataPos] = value;
- data[--canvasDataPos] = value;
- data[--canvasDataPos] = value;
- }
- ctx.putImageData(canvasData, 0, 0);
- return true;
+ function AsyncIterator(generator) {
+ function invoke(method, arg, resolve, reject) {
+ var record = tryCatch(generator[method], generator, arg);
+ if (record.type === "throw") {
+ reject(record.arg);
+ } else {
+ var result = record.arg;
+ var value = result.value;
+ if (value &&
+ typeof value === "object" &&
+ hasOwn.call(value, "__await")) {
+ return Promise.resolve(value.__await).then(function(value) {
+ invoke("next", value, resolve, reject);
+ }, function(err) {
+ invoke("throw", err, resolve, reject);
+ });
+ }
+
+ return Promise.resolve(value).then(function(unwrapped) {
+ // When a yielded Promise is resolved, its final value becomes
+ // the .value of the Promise<{value,done}> result for the
+ // current iteration.
+ result.value = unwrapped;
+ resolve(result);
+ }, function(error) {
+ // If a rejected Promise was yielded, throw the rejection back
+ // into the async generator function so it can be handled there.
+ return invoke("throw", error, resolve, reject);
+ });
+ }
}
-};
-/***/ }),
-/* 10 */
-/***/ (function(module, exports, __webpack_require__) {
+ var previousPromise;
-var listCacheClear = __webpack_require__(133),
- listCacheDelete = __webpack_require__(134),
- listCacheGet = __webpack_require__(135),
- listCacheHas = __webpack_require__(136),
- listCacheSet = __webpack_require__(137);
+ function enqueue(method, arg) {
+ function callInvokeWithMethodAndArg() {
+ return new Promise(function(resolve, reject) {
+ invoke(method, arg, resolve, reject);
+ });
+ }
-/**
- * Creates an list cache object.
- *
- * @private
- * @constructor
- * @param {Array} [entries] The key-value pairs to cache.
- */
-function ListCache(entries) {
- var index = -1,
- length = entries == null ? 0 : entries.length;
-
- this.clear();
- while (++index < length) {
- var entry = entries[index];
- this.set(entry[0], entry[1]);
+ return previousPromise =
+ // If enqueue has been called before, then we want to wait until
+ // all previous Promises have been resolved before calling invoke,
+ // so that results are always delivered in the correct order. If
+ // enqueue has not been called before, then it is important to
+ // call invoke immediately, without waiting on a callback to fire,
+ // so that the async generator function has the opportunity to do
+ // any necessary setup in a predictable way. This predictability
+ // is why the Promise constructor synchronously invokes its
+ // executor callback, and why async functions synchronously
+ // execute code before the first await. Since we implement simple
+ // async functions in terms of async generators, it is especially
+ // important to get this right, even though it requires care.
+ previousPromise ? previousPromise.then(
+ callInvokeWithMethodAndArg,
+ // Avoid propagating failures to Promises returned by later
+ // invocations of the iterator.
+ callInvokeWithMethodAndArg
+ ) : callInvokeWithMethodAndArg();
+ }
+
+ // Define the unified helper method that is used to implement .next,
+ // .throw, and .return (see defineIteratorMethods).
+ this._invoke = enqueue;
}
-}
-// Add methods to `ListCache`.
-ListCache.prototype.clear = listCacheClear;
-ListCache.prototype['delete'] = listCacheDelete;
-ListCache.prototype.get = listCacheGet;
-ListCache.prototype.has = listCacheHas;
-ListCache.prototype.set = listCacheSet;
+ defineIteratorMethods(AsyncIterator.prototype);
+ AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+ return this;
+ };
+ runtime.AsyncIterator = AsyncIterator;
+
+ // Note that simple async functions are implemented on top of
+ // AsyncIterator objects; they just return a Promise for the value of
+ // the final result produced by the iterator.
+ runtime.async = function(innerFn, outerFn, self, tryLocsList) {
+ var iter = new AsyncIterator(
+ wrap(innerFn, outerFn, self, tryLocsList)
+ );
+
+ return runtime.isGeneratorFunction(outerFn)
+ ? iter // If outerFn is a generator, return the full iterator.
+ : iter.next().then(function(result) {
+ return result.done ? result.value : iter.next();
+ });
+ };
-module.exports = ListCache;
+ function makeInvokeMethod(innerFn, self, context) {
+ var state = GenStateSuspendedStart;
+ return function invoke(method, arg) {
+ if (state === GenStateExecuting) {
+ throw new Error("Generator is already running");
+ }
-/***/ }),
-/* 11 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (state === GenStateCompleted) {
+ if (method === "throw") {
+ throw arg;
+ }
-var root = __webpack_require__(5);
+ // Be forgiving, per 25.3.3.3.3 of the spec:
+ // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+ return doneResult();
+ }
-/** Built-in value references. */
-var Symbol = root.Symbol;
+ context.method = method;
+ context.arg = arg;
-module.exports = Symbol;
+ while (true) {
+ var delegate = context.delegate;
+ if (delegate) {
+ var delegateResult = maybeInvokeDelegate(delegate, context);
+ if (delegateResult) {
+ if (delegateResult === ContinueSentinel) continue;
+ return delegateResult;
+ }
+ }
+ if (context.method === "next") {
+ // Setting context._sent for legacy support of Babel's
+ // function.sent implementation.
+ context.sent = context._sent = context.arg;
-/***/ }),
-/* 12 */
-/***/ (function(module, exports, __webpack_require__) {
+ } else if (context.method === "throw") {
+ if (state === GenStateSuspendedStart) {
+ state = GenStateCompleted;
+ throw context.arg;
+ }
-var eq = __webpack_require__(17);
+ context.dispatchException(context.arg);
-/**
- * Gets the index at which the `key` is found in `array` of key-value pairs.
- *
- * @private
- * @param {Array} array The array to inspect.
- * @param {*} key The key to search for.
- * @returns {number} Returns the index of the matched value, else `-1`.
- */
-function assocIndexOf(array, key) {
- var length = array.length;
- while (length--) {
- if (eq(array[length][0], key)) {
- return length;
- }
- }
- return -1;
-}
+ } else if (context.method === "return") {
+ context.abrupt("return", context.arg);
+ }
-module.exports = assocIndexOf;
+ state = GenStateExecuting;
+ var record = tryCatch(innerFn, self, context);
+ if (record.type === "normal") {
+ // If an exception is thrown from innerFn, we leave state ===
+ // GenStateExecuting and loop back for another invocation.
+ state = context.done
+ ? GenStateCompleted
+ : GenStateSuspendedYield;
-/***/ }),
-/* 13 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (record.arg === ContinueSentinel) {
+ continue;
+ }
-var isArray = __webpack_require__(2),
- isKey = __webpack_require__(130),
- stringToPath = __webpack_require__(154),
- toString = __webpack_require__(165);
+ return {
+ value: record.arg,
+ done: context.done
+ };
-/**
- * Casts `value` to a path array if it's not one.
- *
- * @private
- * @param {*} value The value to inspect.
- * @param {Object} [object] The object to query keys on.
- * @returns {Array} Returns the cast property path array.
- */
-function castPath(value, object) {
- if (isArray(value)) {
- return value;
+ } else if (record.type === "throw") {
+ state = GenStateCompleted;
+ // Dispatch the exception by looping back around to the
+ // context.dispatchException(context.arg) call above.
+ context.method = "throw";
+ context.arg = record.arg;
+ }
+ }
+ };
}
- return isKey(value, object) ? [value] : stringToPath(toString(value));
-}
-module.exports = castPath;
+ // Call delegate.iterator[context.method](context.arg) and handle the
+ // result, either by returning a { value, done } result from the
+ // delegate iterator, or by modifying context.method and context.arg,
+ // setting context.delegate to null, and returning the ContinueSentinel.
+ function maybeInvokeDelegate(delegate, context) {
+ var method = delegate.iterator[context.method];
+ if (method === undefined) {
+ // A .throw or .return when the delegate iterator has no .throw
+ // method always terminates the yield* loop.
+ context.delegate = null;
+
+ if (context.method === "throw") {
+ if (delegate.iterator.return) {
+ // If the delegate iterator has a return method, give it a
+ // chance to clean up.
+ context.method = "return";
+ context.arg = undefined;
+ maybeInvokeDelegate(delegate, context);
+
+ if (context.method === "throw") {
+ // If maybeInvokeDelegate(context) changed context.method from
+ // "return" to "throw", let that override the TypeError below.
+ return ContinueSentinel;
+ }
+ }
+
+ context.method = "throw";
+ context.arg = new TypeError(
+ "The iterator does not provide a 'throw' method");
+ }
+ return ContinueSentinel;
+ }
-/***/ }),
-/* 14 */
-/***/ (function(module, exports, __webpack_require__) {
+ var record = tryCatch(method, delegate.iterator, context.arg);
-var isKeyable = __webpack_require__(131);
+ if (record.type === "throw") {
+ context.method = "throw";
+ context.arg = record.arg;
+ context.delegate = null;
+ return ContinueSentinel;
+ }
-/**
- * Gets the data for `map`.
- *
- * @private
- * @param {Object} map The map to query.
- * @param {string} key The reference key.
- * @returns {*} Returns the map data.
- */
-function getMapData(map, key) {
- var data = map.__data__;
- return isKeyable(key)
- ? data[typeof key == 'string' ? 'string' : 'hash']
- : data.map;
-}
+ var info = record.arg;
-module.exports = getMapData;
+ if (! info) {
+ context.method = "throw";
+ context.arg = new TypeError("iterator result is not an object");
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+ if (info.done) {
+ // Assign the result of the finished delegate to the temporary
+ // variable specified by delegate.resultName (see delegateYield).
+ context[delegate.resultName] = info.value;
-/***/ }),
-/* 15 */
-/***/ (function(module, exports) {
+ // Resume execution at the desired location (see delegateYield).
+ context.next = delegate.nextLoc;
-/** Used as references for various `Number` constants. */
-var MAX_SAFE_INTEGER = 9007199254740991;
+ // If context.method was "throw" but the delegate handled the
+ // exception, let the outer generator proceed normally. If
+ // context.method was "next", forget context.arg since it has been
+ // "consumed" by the delegate iterator. If context.method was
+ // "return", allow the original .return call to continue in the
+ // outer generator.
+ if (context.method !== "return") {
+ context.method = "next";
+ context.arg = undefined;
+ }
-/** Used to detect unsigned integer values. */
-var reIsUint = /^(?:0|[1-9]\d*)$/;
+ } else {
+ // Re-yield the result returned by the delegate method.
+ return info;
+ }
-/**
- * Checks if `value` is a valid array-like index.
- *
- * @private
- * @param {*} value The value to check.
- * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
- * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
- */
-function isIndex(value, length) {
- length = length == null ? MAX_SAFE_INTEGER : length;
- return !!length &&
- (typeof value == 'number' || reIsUint.test(value)) &&
- (value > -1 && value % 1 == 0 && value < length);
-}
+ // The delegate iterator is finished, so forget it and continue with
+ // the outer generator.
+ context.delegate = null;
+ return ContinueSentinel;
+ }
-module.exports = isIndex;
+ // Define Generator.prototype.{next,throw,return} in terms of the
+ // unified ._invoke helper method.
+ defineIteratorMethods(Gp);
+ Gp[toStringTagSymbol] = "Generator";
-/***/ }),
-/* 16 */
-/***/ (function(module, exports, __webpack_require__) {
+ // A Generator should always return itself as the iterator object when the
+ // @@iterator function is called on it. Some browsers' implementations of the
+ // iterator prototype chain incorrectly implement this, causing the Generator
+ // object to not be returned from this call. This ensures that doesn't happen.
+ // See https://github.com/facebook/regenerator/issues/274 for more details.
+ Gp[iteratorSymbol] = function() {
+ return this;
+ };
-var getNative = __webpack_require__(22);
+ Gp.toString = function() {
+ return "[object Generator]";
+ };
-/* Built-in method references that are verified to be native. */
-var nativeCreate = getNative(Object, 'create');
+ function pushTryEntry(locs) {
+ var entry = { tryLoc: locs[0] };
-module.exports = nativeCreate;
+ if (1 in locs) {
+ entry.catchLoc = locs[1];
+ }
+ if (2 in locs) {
+ entry.finallyLoc = locs[2];
+ entry.afterLoc = locs[3];
+ }
-/***/ }),
-/* 17 */
-/***/ (function(module, exports) {
+ this.tryEntries.push(entry);
+ }
-/**
- * Performs a
- * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
- * comparison between two values to determine if they are equivalent.
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to compare.
- * @param {*} other The other value to compare.
- * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
- * @example
- *
- * var object = { 'a': 1 };
- * var other = { 'a': 1 };
- *
- * _.eq(object, object);
- * // => true
- *
- * _.eq(object, other);
- * // => false
- *
- * _.eq('a', 'a');
- * // => true
- *
- * _.eq('a', Object('a'));
- * // => false
- *
- * _.eq(NaN, NaN);
- * // => true
- */
-function eq(value, other) {
- return value === other || (value !== value && other !== other);
-}
+ function resetTryEntry(entry) {
+ var record = entry.completion || {};
+ record.type = "normal";
+ delete record.arg;
+ entry.completion = record;
+ }
-module.exports = eq;
+ function Context(tryLocsList) {
+ // The root entry object (effectively a try statement without a catch
+ // or a finally block) gives us a place to store values thrown from
+ // locations where there is no enclosing try statement.
+ this.tryEntries = [{ tryLoc: "root" }];
+ tryLocsList.forEach(pushTryEntry, this);
+ this.reset(true);
+ }
+ runtime.keys = function(object) {
+ var keys = [];
+ for (var key in object) {
+ keys.push(key);
+ }
+ keys.reverse();
-/***/ }),
-/* 18 */
-/***/ (function(module, exports, __webpack_require__) {
+ // Rather than returning an object with a next method, we keep
+ // things simple and return the next function itself.
+ return function next() {
+ while (keys.length) {
+ var key = keys.pop();
+ if (key in object) {
+ next.value = key;
+ next.done = false;
+ return next;
+ }
+ }
-var baseIsArguments = __webpack_require__(96),
- isObjectLike = __webpack_require__(6);
+ // To avoid creating an additional object, we just hang the .value
+ // and .done properties off the next function object itself. This
+ // also ensures that the minifier will not anonymize the function.
+ next.done = true;
+ return next;
+ };
+ };
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
+ function values(iterable) {
+ if (iterable) {
+ var iteratorMethod = iterable[iteratorSymbol];
+ if (iteratorMethod) {
+ return iteratorMethod.call(iterable);
+ }
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+ if (typeof iterable.next === "function") {
+ return iterable;
+ }
-/** Built-in value references. */
-var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+ if (!isNaN(iterable.length)) {
+ var i = -1, next = function next() {
+ while (++i < iterable.length) {
+ if (hasOwn.call(iterable, i)) {
+ next.value = iterable[i];
+ next.done = false;
+ return next;
+ }
+ }
-/**
- * Checks if `value` is likely an `arguments` object.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an `arguments` object,
- * else `false`.
- * @example
- *
- * _.isArguments(function() { return arguments; }());
- * // => true
- *
- * _.isArguments([1, 2, 3]);
- * // => false
- */
-var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
- return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
- !propertyIsEnumerable.call(value, 'callee');
-};
+ next.value = undefined;
+ next.done = true;
-module.exports = isArguments;
+ return next;
+ };
+ return next.next = next;
+ }
+ }
-/***/ }),
-/* 19 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ // Return an iterator with no values.
+ return { next: doneResult };
+ }
+ runtime.values = values;
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__cluster__ = __webpack_require__(50);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__array_helper__ = __webpack_require__(3);
-/* harmony export (immutable) */ __webpack_exports__["b"] = imageRef;
-/* unused harmony export computeIntegralImage2 */
-/* unused harmony export computeIntegralImage */
-/* unused harmony export thresholdImage */
-/* unused harmony export computeHistogram */
-/* unused harmony export sharpenLine */
-/* unused harmony export determineOtsuThreshold */
-/* harmony export (immutable) */ __webpack_exports__["f"] = otsuThreshold;
-/* unused harmony export computeBinaryImage */
-/* harmony export (immutable) */ __webpack_exports__["g"] = cluster;
-/* unused harmony export Tracer */
-/* unused harmony export DILATE */
-/* unused harmony export ERODE */
-/* unused harmony export dilate */
-/* unused harmony export erode */
-/* unused harmony export subtract */
-/* unused harmony export bitwiseOr */
-/* unused harmony export countNonZero */
-/* harmony export (immutable) */ __webpack_exports__["h"] = topGeneric;
-/* unused harmony export grayArrayFromImage */
-/* unused harmony export grayArrayFromContext */
-/* harmony export (immutable) */ __webpack_exports__["c"] = grayAndHalfSampleFromCanvasData;
-/* harmony export (immutable) */ __webpack_exports__["d"] = computeGray;
-/* unused harmony export loadImageArray */
-/* harmony export (immutable) */ __webpack_exports__["i"] = halfSample;
-/* harmony export (immutable) */ __webpack_exports__["a"] = hsv2rgb;
-/* unused harmony export _computeDivisors */
-/* harmony export (immutable) */ __webpack_exports__["e"] = calculatePatchSize;
-/* unused harmony export _parseCSSDimensionValues */
-/* unused harmony export _dimensionsConverters */
-/* harmony export (immutable) */ __webpack_exports__["j"] = computeImageArea;
-
-
-var vec2 = {
- clone: __webpack_require__(7)
-};
-var vec3 = {
- clone: __webpack_require__(83)
-};
+ function doneResult() {
+ return { value: undefined, done: true };
+ }
-/**
- * @param x x-coordinate
- * @param y y-coordinate
- * @return ImageReference {x,y} Coordinate
- */
-function imageRef(x, y) {
- var that = {
- x: x,
- y: y,
- toVec2: function toVec2() {
- return vec2.clone([this.x, this.y]);
- },
- toVec3: function toVec3() {
- return vec3.clone([this.x, this.y, 1]);
- },
- round: function round() {
- this.x = this.x > 0.0 ? Math.floor(this.x + 0.5) : Math.floor(this.x - 0.5);
- this.y = this.y > 0.0 ? Math.floor(this.y + 0.5) : Math.floor(this.y - 0.5);
- return this;
- }
- };
- return that;
-};
+ Context.prototype = {
+ constructor: Context,
-/**
- * Computes an integral image of a given grayscale image.
- * @param imageDataContainer {ImageDataContainer} the image to be integrated
- */
-function computeIntegralImage2(imageWrapper, integralWrapper) {
- var imageData = imageWrapper.data;
- var width = imageWrapper.size.x;
- var height = imageWrapper.size.y;
- var integralImageData = integralWrapper.data;
- var sum = 0,
- posA = 0,
- posB = 0,
- posC = 0,
- posD = 0,
- x,
- y;
-
- // sum up first column
- posB = width;
- sum = 0;
- for (y = 1; y < height; y++) {
- sum += imageData[posA];
- integralImageData[posB] += sum;
- posA += width;
- posB += width;
- }
-
- posA = 0;
- posB = 1;
- sum = 0;
- for (x = 1; x < width; x++) {
- sum += imageData[posA];
- integralImageData[posB] += sum;
- posA++;
- posB++;
- }
-
- for (y = 1; y < height; y++) {
- posA = y * width + 1;
- posB = (y - 1) * width + 1;
- posC = y * width;
- posD = (y - 1) * width;
- for (x = 1; x < width; x++) {
- integralImageData[posA] += imageData[posA] + integralImageData[posB] + integralImageData[posC] - integralImageData[posD];
- posA++;
- posB++;
- posC++;
- posD++;
- }
- }
-};
+ reset: function(skipTempReset) {
+ this.prev = 0;
+ this.next = 0;
+ // Resetting context._sent for legacy support of Babel's
+ // function.sent implementation.
+ this.sent = this._sent = undefined;
+ this.done = false;
+ this.delegate = null;
-function computeIntegralImage(imageWrapper, integralWrapper) {
- var imageData = imageWrapper.data;
- var width = imageWrapper.size.x;
- var height = imageWrapper.size.y;
- var integralImageData = integralWrapper.data;
- var sum = 0;
+ this.method = "next";
+ this.arg = undefined;
- // sum up first row
- for (var i = 0; i < width; i++) {
- sum += imageData[i];
- integralImageData[i] = sum;
- }
+ this.tryEntries.forEach(resetTryEntry);
- for (var v = 1; v < height; v++) {
- sum = 0;
- for (var u = 0; u < width; u++) {
- sum += imageData[v * width + u];
- integralImageData[v * width + u] = sum + integralImageData[(v - 1) * width + u];
+ if (!skipTempReset) {
+ for (var name in this) {
+ // Not sure about the optimal order of these conditions:
+ if (name.charAt(0) === "t" &&
+ hasOwn.call(this, name) &&
+ !isNaN(+name.slice(1))) {
+ this[name] = undefined;
+ }
}
- }
-};
-
-function thresholdImage(imageWrapper, threshold, targetWrapper) {
- if (!targetWrapper) {
- targetWrapper = imageWrapper;
- }
- var imageData = imageWrapper.data,
- length = imageData.length,
- targetData = targetWrapper.data;
+ }
+ },
- while (length--) {
- targetData[length] = imageData[length] < threshold ? 1 : 0;
- }
-};
+ stop: function() {
+ this.done = true;
-function computeHistogram(imageWrapper, bitsPerPixel) {
- if (!bitsPerPixel) {
- bitsPerPixel = 8;
- }
- var imageData = imageWrapper.data,
- length = imageData.length,
- bitShift = 8 - bitsPerPixel,
- bucketCnt = 1 << bitsPerPixel,
- hist = new Int32Array(bucketCnt);
+ var rootEntry = this.tryEntries[0];
+ var rootRecord = rootEntry.completion;
+ if (rootRecord.type === "throw") {
+ throw rootRecord.arg;
+ }
- while (length--) {
- hist[imageData[length] >> bitShift]++;
- }
- return hist;
-};
+ return this.rval;
+ },
-function sharpenLine(line) {
- var i,
- length = line.length,
- left = line[0],
- center = line[1],
- right;
-
- for (i = 1; i < length - 1; i++) {
- right = line[i + 1];
- // -1 4 -1 kernel
- line[i - 1] = center * 2 - left - right & 255;
- left = center;
- center = right;
- }
- return line;
-};
+ dispatchException: function(exception) {
+ if (this.done) {
+ throw exception;
+ }
-function determineOtsuThreshold(imageWrapper, bitsPerPixel) {
- if (!bitsPerPixel) {
- bitsPerPixel = 8;
- }
- var hist,
- threshold,
- bitShift = 8 - bitsPerPixel;
+ var context = this;
+ function handle(loc, caught) {
+ record.type = "throw";
+ record.arg = exception;
+ context.next = loc;
- function px(init, end) {
- var sum = 0,
- i;
- for (i = init; i <= end; i++) {
- sum += hist[i];
+ if (caught) {
+ // If the dispatched exception was caught by a catch block,
+ // then let that catch block handle the exception normally.
+ context.method = "next";
+ context.arg = undefined;
}
- return sum;
- }
- function mx(init, end) {
- var i,
- sum = 0;
+ return !! caught;
+ }
- for (i = init; i <= end; i++) {
- sum += i * hist[i];
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ var record = entry.completion;
+
+ if (entry.tryLoc === "root") {
+ // Exception thrown outside of any try block that could handle
+ // it, so set the completion value of the entire function to
+ // throw the exception.
+ return handle("end");
}
- return sum;
- }
+ if (entry.tryLoc <= this.prev) {
+ var hasCatch = hasOwn.call(entry, "catchLoc");
+ var hasFinally = hasOwn.call(entry, "finallyLoc");
- function determineThreshold() {
- var vet = [0],
- p1,
- p2,
- p12,
- k,
- m1,
- m2,
- m12,
- max = (1 << bitsPerPixel) - 1;
+ if (hasCatch && hasFinally) {
+ if (this.prev < entry.catchLoc) {
+ return handle(entry.catchLoc, true);
+ } else if (this.prev < entry.finallyLoc) {
+ return handle(entry.finallyLoc);
+ }
+
+ } else if (hasCatch) {
+ if (this.prev < entry.catchLoc) {
+ return handle(entry.catchLoc, true);
+ }
- hist = computeHistogram(imageWrapper, bitsPerPixel);
- for (k = 1; k < max; k++) {
- p1 = px(0, k);
- p2 = px(k + 1, max);
- p12 = p1 * p2;
- if (p12 === 0) {
- p12 = 1;
+ } else if (hasFinally) {
+ if (this.prev < entry.finallyLoc) {
+ return handle(entry.finallyLoc);
}
- m1 = mx(0, k) * p2;
- m2 = mx(k + 1, max) * p1;
- m12 = m1 - m2;
- vet[k] = m12 * m12 / p12;
+
+ } else {
+ throw new Error("try statement without catch or finally");
+ }
}
- return __WEBPACK_IMPORTED_MODULE_1__array_helper__["a" /* default */].maxIndex(vet);
- }
+ }
+ },
- threshold = determineThreshold();
- return threshold << bitShift;
-};
+ abrupt: function(type, arg) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ if (entry.tryLoc <= this.prev &&
+ hasOwn.call(entry, "finallyLoc") &&
+ this.prev < entry.finallyLoc) {
+ var finallyEntry = entry;
+ break;
+ }
+ }
-function otsuThreshold(imageWrapper, targetWrapper) {
- var threshold = determineOtsuThreshold(imageWrapper);
+ if (finallyEntry &&
+ (type === "break" ||
+ type === "continue") &&
+ finallyEntry.tryLoc <= arg &&
+ arg <= finallyEntry.finallyLoc) {
+ // Ignore the finally entry if control is not jumping to a
+ // location outside the try/catch block.
+ finallyEntry = null;
+ }
- thresholdImage(imageWrapper, threshold, targetWrapper);
- return threshold;
-};
+ var record = finallyEntry ? finallyEntry.completion : {};
+ record.type = type;
+ record.arg = arg;
-// local thresholding
-function computeBinaryImage(imageWrapper, integralWrapper, targetWrapper) {
- computeIntegralImage(imageWrapper, integralWrapper);
+ if (finallyEntry) {
+ this.method = "next";
+ this.next = finallyEntry.finallyLoc;
+ return ContinueSentinel;
+ }
- if (!targetWrapper) {
- targetWrapper = imageWrapper;
- }
- var imageData = imageWrapper.data;
- var targetData = targetWrapper.data;
- var width = imageWrapper.size.x;
- var height = imageWrapper.size.y;
- var integralImageData = integralWrapper.data;
- var sum = 0,
- v,
- u,
- kernel = 3,
- A,
- B,
- C,
- D,
- avg,
- size = (kernel * 2 + 1) * (kernel * 2 + 1);
+ return this.complete(record);
+ },
- // clear out top & bottom-border
- for (v = 0; v <= kernel; v++) {
- for (u = 0; u < width; u++) {
- targetData[v * width + u] = 0;
- targetData[(height - 1 - v) * width + u] = 0;
- }
- }
+ complete: function(record, afterLoc) {
+ if (record.type === "throw") {
+ throw record.arg;
+ }
+
+ if (record.type === "break" ||
+ record.type === "continue") {
+ this.next = record.arg;
+ } else if (record.type === "return") {
+ this.rval = this.arg = record.arg;
+ this.method = "return";
+ this.next = "end";
+ } else if (record.type === "normal" && afterLoc) {
+ this.next = afterLoc;
+ }
- // clear out left & right border
- for (v = kernel; v < height - kernel; v++) {
- for (u = 0; u <= kernel; u++) {
- targetData[v * width + u] = 0;
- targetData[v * width + (width - 1 - u)] = 0;
+ return ContinueSentinel;
+ },
+
+ finish: function(finallyLoc) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ if (entry.finallyLoc === finallyLoc) {
+ this.complete(entry.completion, entry.afterLoc);
+ resetTryEntry(entry);
+ return ContinueSentinel;
}
- }
+ }
+ },
- for (v = kernel + 1; v < height - kernel - 1; v++) {
- for (u = kernel + 1; u < width - kernel; u++) {
- A = integralImageData[(v - kernel - 1) * width + (u - kernel - 1)];
- B = integralImageData[(v - kernel - 1) * width + (u + kernel)];
- C = integralImageData[(v + kernel) * width + (u - kernel - 1)];
- D = integralImageData[(v + kernel) * width + (u + kernel)];
- sum = D - C - B + A;
- avg = sum / size;
- targetData[v * width + u] = imageData[v * width + u] > avg + 5 ? 0 : 1;
+ "catch": function(tryLoc) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ if (entry.tryLoc === tryLoc) {
+ var record = entry.completion;
+ if (record.type === "throw") {
+ var thrown = record.arg;
+ resetTryEntry(entry);
+ }
+ return thrown;
}
- }
-};
+ }
-function cluster(points, threshold, property) {
- var i,
- k,
- cluster,
- point,
- clusters = [];
+ // The context.catch method must only be called with a location
+ // argument that corresponds to a known catch block.
+ throw new Error("illegal catch attempt");
+ },
- if (!property) {
- property = "rad";
- }
+ delegateYield: function(iterable, resultName, nextLoc) {
+ this.delegate = {
+ iterator: values(iterable),
+ resultName: resultName,
+ nextLoc: nextLoc
+ };
+
+ if (this.method === "next") {
+ // Deliberately forget the last sent value so that we don't
+ // accidentally pass it on to the delegate.
+ this.arg = undefined;
+ }
- function addToCluster(newPoint) {
- var found = false;
- for (k = 0; k < clusters.length; k++) {
- cluster = clusters[k];
- if (cluster.fits(newPoint)) {
- cluster.add(newPoint);
- found = true;
- }
- }
- return found;
+ return ContinueSentinel;
}
+ };
+})(
+ // In sloppy mode, unbound `this` refers to the global object, fallback to
+ // Function constructor if we're in global strict mode. That is sadly a form
+ // of indirect eval which violates Content Security Policy.
+ (function() {
+ return this || (typeof self === "object" && self);
+ })() || Function("return this")()
+);
- // iterate over each cloud
- for (i = 0; i < points.length; i++) {
- point = __WEBPACK_IMPORTED_MODULE_0__cluster__["a" /* default */].createPoint(points[i], i, property);
- if (!addToCluster(point)) {
- clusters.push(__WEBPACK_IMPORTED_MODULE_0__cluster__["a" /* default */].create(point, threshold));
- }
- }
- return clusters;
-};
-var Tracer = {
- trace: function trace(points, vec) {
- var iteration,
- maxIterations = 10,
- top = [],
- result = [],
- centerPos = 0,
- currentPos = 0;
-
- function trace(idx, forward) {
- var from,
- to,
- toIdx,
- predictedPos,
- thresholdX = 1,
- thresholdY = Math.abs(vec[1] / 10),
- found = false;
-
- function match(pos, predicted) {
- if (pos.x > predicted.x - thresholdX && pos.x < predicted.x + thresholdX && pos.y > predicted.y - thresholdY && pos.y < predicted.y + thresholdY) {
- return true;
- } else {
- return false;
- }
- }
+/***/ }),
- // check if the next index is within the vec specifications
- // if not, check as long as the threshold is met
+/***/ "./node_modules/webpack/buildin/global.js":
+/*!***********************************!*\
+ !*** (webpack)/buildin/global.js ***!
+ \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
- from = points[idx];
- if (forward) {
- predictedPos = {
- x: from.x + vec[0],
- y: from.y + vec[1]
- };
- } else {
- predictedPos = {
- x: from.x - vec[0],
- y: from.y - vec[1]
- };
- }
+var g;
- toIdx = forward ? idx + 1 : idx - 1;
- to = points[toIdx];
- while (to && (found = match(to, predictedPos)) !== true && Math.abs(to.y - from.y) < vec[1]) {
- toIdx = forward ? toIdx + 1 : toIdx - 1;
- to = points[toIdx];
- }
+// This works in non-strict mode
+g = (function() {
+ return this;
+})();
- return found ? toIdx : null;
- }
+try {
+ // This works if eval is allowed (see CSP)
+ g = g || new Function("return this")();
+} catch (e) {
+ // This works if the window reference is available
+ if (typeof window === "object") g = window;
+}
- for (iteration = 0; iteration < maxIterations; iteration++) {
- // randomly select point to start with
- centerPos = Math.floor(Math.random() * points.length);
+// g can still be undefined, but nothing to do about it...
+// We return undefined, instead of nothing here, so it's
+// easier to handle this case. if(!global) { ...}
- // trace forward
- top = [];
- currentPos = centerPos;
- top.push(points[currentPos]);
- while ((currentPos = trace(currentPos, true)) !== null) {
- top.push(points[currentPos]);
- }
- if (centerPos > 0) {
- currentPos = centerPos;
- while ((currentPos = trace(currentPos, false)) !== null) {
- top.push(points[currentPos]);
- }
- }
+module.exports = g;
- if (top.length > result.length) {
- result = top;
- }
- }
- return result;
- }
-};
-var DILATE = 1;
-var ERODE = 2;
-
-function dilate(inImageWrapper, outImageWrapper) {
- var v,
- u,
- inImageData = inImageWrapper.data,
- outImageData = outImageWrapper.data,
- height = inImageWrapper.size.y,
- width = inImageWrapper.size.x,
- sum,
- yStart1,
- yStart2,
- xStart1,
- xStart2;
-
- for (v = 1; v < height - 1; v++) {
- for (u = 1; u < width - 1; u++) {
- yStart1 = v - 1;
- yStart2 = v + 1;
- xStart1 = u - 1;
- xStart2 = u + 1;
- sum = inImageData[yStart1 * width + xStart1] + inImageData[yStart1 * width + xStart2] + inImageData[v * width + u] + inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2];
- outImageData[v * width + u] = sum > 0 ? 1 : 0;
- }
- }
-};
+/***/ }),
-function erode(inImageWrapper, outImageWrapper) {
- var v,
- u,
- inImageData = inImageWrapper.data,
- outImageData = outImageWrapper.data,
- height = inImageWrapper.size.y,
- width = inImageWrapper.size.x,
- sum,
- yStart1,
- yStart2,
- xStart1,
- xStart2;
-
- for (v = 1; v < height - 1; v++) {
- for (u = 1; u < width - 1; u++) {
- yStart1 = v - 1;
- yStart2 = v + 1;
- xStart1 = u - 1;
- xStart2 = u + 1;
- sum = inImageData[yStart1 * width + xStart1] + inImageData[yStart1 * width + xStart2] + inImageData[v * width + u] + inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2];
- outImageData[v * width + u] = sum === 5 ? 1 : 0;
- }
- }
-};
+/***/ "./src/analytics/result-collector.ts":
+/*!*******************************************!*\
+ !*** ./src/analytics/result-collector.ts ***!
+ \*******************************************/
+/*! exports provided: ResultCollector */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-function subtract(aImageWrapper, bImageWrapper, resultImageWrapper) {
- if (!resultImageWrapper) {
- resultImageWrapper = aImageWrapper;
- }
- var length = aImageWrapper.data.length,
- aImageData = aImageWrapper.data,
- bImageData = bImageWrapper.data,
- cImageData = resultImageWrapper.data;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ResultCollector", function() { return ResultCollector; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _common_image_debug__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/image-debug */ "./src/common/image-debug.ts");
- while (length--) {
- cImageData[length] = aImageData[length] - bImageData[length];
- }
-};
-function bitwiseOr(aImageWrapper, bImageWrapper, resultImageWrapper) {
- if (!resultImageWrapper) {
- resultImageWrapper = aImageWrapper;
- }
- var length = aImageWrapper.data.length,
- aImageData = aImageWrapper.data,
- bImageData = bImageWrapper.data,
- cImageData = resultImageWrapper.data;
- while (length--) {
- cImageData[length] = aImageData[length] || bImageData[length];
- }
-};
-function countNonZero(imageWrapper) {
- var length = imageWrapper.data.length,
- data = imageWrapper.data,
- sum = 0;
+var ResultCollector =
+/*#__PURE__*/
+function () {
+ function ResultCollector(config) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, ResultCollector);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_canvas", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_context", void 0);
- while (length--) {
- sum += data[length];
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_config", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_capacity", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_capture", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_results", void 0);
+
+ this._results = new Array();
+ this._config = config;
+ this._capacity = config.capacity || 20;
+ this._capture = config.capture === true;
+
+ if (this._capture) {
+ this._canvas = document.createElement('canvas');
+ this._context = this._canvas.getContext('2d');
}
- return sum;
-};
+ }
-function topGeneric(list, top, scoreFunc) {
- var i,
- minIdx = 0,
- min = 0,
- queue = [],
- score,
- hit,
- pos;
-
- for (i = 0; i < top; i++) {
- queue[i] = {
- score: 0,
- item: null
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(ResultCollector, [{
+ key: "addResult",
+ value: function addResult(data, imageWidth, imageHeight, codeResult) {
+ if (codeResult && this._capacity && !this._contains(codeResult) && this._passesFilter(codeResult)) {
+ var result = {
+ codeResult: codeResult
};
- }
+ this._capacity--;
- for (i = 0; i < list.length; i++) {
- score = scoreFunc.apply(this, [list[i]]);
- if (score > min) {
- hit = queue[minIdx];
- hit.score = score;
- hit.item = list[i];
- min = Number.MAX_VALUE;
- for (pos = 0; pos < top; pos++) {
- if (queue[pos].score < min) {
- min = queue[pos].score;
- minIdx = pos;
- }
- }
+ if (this._capture) {
+ this._canvas.width = imageWidth;
+ this._canvas.height = imageHeight;
+ _common_image_debug__WEBPACK_IMPORTED_MODULE_3__["ImageDebug"].drawImage(data, imageWidth, imageHeight, this._context);
+ result.frame = this._canvas.toDataURL();
}
+
+ this._results.push(result);
+ }
+ }
+ }, {
+ key: "getResults",
+ value: function getResults() {
+ return this._results;
+ }
+ }, {
+ key: "_contains",
+ value: function _contains(codeResult) {
+ return this._config.blacklist && this._config.blacklist.some(function (item) {
+ return Object.keys(item).every(function (key) {
+ return item[key] === codeResult[key];
+ });
+ });
+ }
+ }, {
+ key: "_passesFilter",
+ value: function _passesFilter(codeResult) {
+ return typeof this._config.filter !== 'function' || this._config.filter(codeResult);
}
+ }]);
- return queue;
-};
+ return ResultCollector;
+}();
-function grayArrayFromImage(htmlImage, offsetX, ctx, array) {
- ctx.drawImage(htmlImage, offsetX, 0, htmlImage.width, htmlImage.height);
- var ctxData = ctx.getImageData(offsetX, 0, htmlImage.width, htmlImage.height).data;
- computeGray(ctxData, array);
-};
+/***/ }),
-function grayArrayFromContext(ctx, size, offset, array) {
- var ctxData = ctx.getImageData(offset.x, offset.y, size.x, size.y).data;
- computeGray(ctxData, array);
-};
+/***/ "./src/common/cluster.ts":
+/*!*******************************!*\
+ !*** ./src/common/cluster.ts ***!
+ \*******************************/
+/*! exports provided: Cluster */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-function grayAndHalfSampleFromCanvasData(canvasData, size, outArray) {
- var topRowIdx = 0;
- var bottomRowIdx = size.x;
- var endIdx = Math.floor(canvasData.length / 4);
- var outWidth = size.x / 2;
- var outImgIdx = 0;
- var inWidth = size.x;
- var i;
-
- while (bottomRowIdx < endIdx) {
- for (i = 0; i < outWidth; i++) {
- outArray[outImgIdx] = (0.299 * canvasData[topRowIdx * 4 + 0] + 0.587 * canvasData[topRowIdx * 4 + 1] + 0.114 * canvasData[topRowIdx * 4 + 2] + (0.299 * canvasData[(topRowIdx + 1) * 4 + 0] + 0.587 * canvasData[(topRowIdx + 1) * 4 + 1] + 0.114 * canvasData[(topRowIdx + 1) * 4 + 2]) + (0.299 * canvasData[bottomRowIdx * 4 + 0] + 0.587 * canvasData[bottomRowIdx * 4 + 1] + 0.114 * canvasData[bottomRowIdx * 4 + 2]) + (0.299 * canvasData[(bottomRowIdx + 1) * 4 + 0] + 0.587 * canvasData[(bottomRowIdx + 1) * 4 + 1] + 0.114 * canvasData[(bottomRowIdx + 1) * 4 + 2])) / 4;
- outImgIdx++;
- topRowIdx = topRowIdx + 2;
- bottomRowIdx = bottomRowIdx + 2;
- }
- topRowIdx = topRowIdx + inWidth;
- bottomRowIdx = bottomRowIdx + inWidth;
- }
-};
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Cluster", function() { return Cluster; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
-function computeGray(imageData, outArray, config) {
- var l = imageData.length / 4 | 0,
- i,
- singleChannel = config && config.singleChannel === true;
- if (singleChannel) {
- for (i = 0; i < l; i++) {
- outArray[i] = imageData[i * 4 + 0];
- }
- } else {
- for (i = 0; i < l; i++) {
- outArray[i] = 0.299 * imageData[i * 4 + 0] + 0.587 * imageData[i * 4 + 1] + 0.114 * imageData[i * 4 + 2];
- }
- }
-};
-function loadImageArray(src, callback, canvas) {
- if (!canvas) {
- canvas = document.createElement('canvas');
- }
- var img = new Image();
- img.callback = callback;
- img.onload = function () {
- canvas.width = this.width;
- canvas.height = this.height;
- var ctx = canvas.getContext('2d');
- ctx.drawImage(this, 0, 0);
- var array = new Uint8Array(this.width * this.height);
- ctx.drawImage(this, 0, 0);
- var data = ctx.getImageData(0, 0, this.width, this.height).data;
- computeGray(data, array);
- this.callback(array, {
- x: this.width,
- y: this.height
- }, this);
- };
- img.src = src;
-};
/**
- * @param inImg {ImageWrapper} input image to be sampled
- * @param outImg {ImageWrapper} to be stored in
+ * Creates a cluster for grouping similar orientations of moments
*/
-function halfSample(inImgWrapper, outImgWrapper) {
- var inImg = inImgWrapper.data;
- var inWidth = inImgWrapper.size.x;
- var outImg = outImgWrapper.data;
- var topRowIdx = 0;
- var bottomRowIdx = inWidth;
- var endIdx = inImg.length;
- var outWidth = inWidth / 2;
- var outImgIdx = 0;
- while (bottomRowIdx < endIdx) {
- for (var i = 0; i < outWidth; i++) {
- outImg[outImgIdx] = Math.floor((inImg[topRowIdx] + inImg[topRowIdx + 1] + inImg[bottomRowIdx] + inImg[bottomRowIdx + 1]) / 4);
- outImgIdx++;
- topRowIdx = topRowIdx + 2;
- bottomRowIdx = bottomRowIdx + 2;
+var Cluster =
+/*#__PURE__*/
+function () {
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(Cluster, null, [{
+ key: "clusterize",
+ value: function clusterize(moments, threshold) {
+ var clusters = new Array();
+ moments.forEach(function (moment) {
+ var matchingCluster = clusters.find(function (cluster) {
+ return cluster.fits(moment);
+ });
+
+ if (matchingCluster) {
+ matchingCluster.add(moment);
+ } else {
+ clusters.push(new Cluster(threshold, moment));
}
- topRowIdx = topRowIdx + inWidth;
- bottomRowIdx = bottomRowIdx + inWidth;
+ });
+ return clusters;
}
-};
+ }]);
-function hsv2rgb(hsv, rgb) {
- var h = hsv[0],
- s = hsv[1],
- v = hsv[2],
- c = v * s,
- x = c * (1 - Math.abs(h / 60 % 2 - 1)),
- m = v - c,
- r = 0,
- g = 0,
- b = 0;
-
- rgb = rgb || [0, 0, 0];
-
- if (h < 60) {
- r = c;
- g = x;
- } else if (h < 120) {
- r = x;
- g = c;
- } else if (h < 180) {
- g = c;
- b = x;
- } else if (h < 240) {
- g = x;
- b = c;
- } else if (h < 300) {
- r = x;
- b = c;
- } else if (h < 360) {
- r = c;
- b = x;
- }
- rgb[0] = (r + m) * 255 | 0;
- rgb[1] = (g + m) * 255 | 0;
- rgb[2] = (b + m) * 255 | 0;
- return rgb;
-};
+ function Cluster(threshold, moment) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, Cluster);
-function _computeDivisors(n) {
- var largeDivisors = [],
- divisors = [],
- i;
-
- for (i = 1; i < Math.sqrt(n) + 1; i++) {
- if (n % i === 0) {
- divisors.push(i);
- if (i !== n / i) {
- largeDivisors.unshift(Math.floor(n / i));
- }
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_threshold", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_moments", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_center", void 0);
+
+ this._threshold = threshold;
+ this._moments = new Array();
+ this._center = {
+ rad: 0,
+ x: 0,
+ y: 0
+ };
+
+ if (moment) {
+ this.add(moment);
}
- return divisors.concat(largeDivisors);
-};
+ }
-function _computeIntersection(arr1, arr2) {
- var i = 0,
- j = 0,
- result = [];
-
- while (i < arr1.length && j < arr2.length) {
- if (arr1[i] === arr2[j]) {
- result.push(arr1[i]);
- i++;
- j++;
- } else if (arr1[i] > arr2[j]) {
- j++;
- } else {
- i++;
- }
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(Cluster, [{
+ key: "add",
+ value: function add(point) {
+ this._moments.push(point); // Update center
+
+
+ this._center.rad = this._moments.reduce(function (sum, p) {
+ return sum + p.rad;
+ }, 0) / this._moments.length;
+ this._center.x = Math.cos(this._center.rad);
+ this._center.y = Math.sin(this._center.rad);
}
- return result;
-};
+ }, {
+ key: "fits",
+ value: function fits(moment) {
+ // check cosine similarity to center-angle
+ var similarity = Math.abs(moment.x * this._center.x + moment.y * this._center.y);
+ return similarity > this._threshold;
+ }
+ }, {
+ key: "moments",
+ get: function get() {
+ return this._moments;
+ }
+ }]);
-function calculatePatchSize(patchSize, imgSize) {
- var divisorsX = _computeDivisors(imgSize.x),
- divisorsY = _computeDivisors(imgSize.y),
- wideSide = Math.max(imgSize.x, imgSize.y),
- common = _computeIntersection(divisorsX, divisorsY),
- nrOfPatchesList = [8, 10, 15, 20, 32, 60, 80],
- nrOfPatchesMap = {
- "x-small": 5,
- "small": 4,
- "medium": 3,
- "large": 2,
- "x-large": 1
- },
- nrOfPatchesIdx = nrOfPatchesMap[patchSize] || nrOfPatchesMap.medium,
- nrOfPatches = nrOfPatchesList[nrOfPatchesIdx],
- desiredPatchSize = Math.floor(wideSide / nrOfPatches),
- optimalPatchSize;
+ return Cluster;
+}();
- function findPatchSizeForDivisors(divisors) {
- var i = 0,
- found = divisors[Math.floor(divisors.length / 2)];
+/***/ }),
- while (i < divisors.length - 1 && divisors[i] < desiredPatchSize) {
- i++;
- }
- if (i > 0) {
- if (Math.abs(divisors[i] - desiredPatchSize) > Math.abs(divisors[i - 1] - desiredPatchSize)) {
- found = divisors[i - 1];
- } else {
- found = divisors[i];
- }
- }
- if (desiredPatchSize / found < nrOfPatchesList[nrOfPatchesIdx + 1] / nrOfPatchesList[nrOfPatchesIdx] && desiredPatchSize / found > nrOfPatchesList[nrOfPatchesIdx - 1] / nrOfPatchesList[nrOfPatchesIdx]) {
- return { x: found, y: found };
+/***/ "./src/common/events.ts":
+/*!******************************!*\
+ !*** ./src/common/events.ts ***!
+ \******************************/
+/*! exports provided: Events */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Events", function() { return Events; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+
+
+var events = {};
+var Events =
+/*#__PURE__*/
+function () {
+ function Events() {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, Events);
+ }
+
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(Events, null, [{
+ key: "subscribe",
+ value: function subscribe(event, callback, async) {
+ var subscription;
+
+ if (typeof callback === 'function') {
+ subscription = {
+ callback: callback,
+ async: async
+ };
+ } else {
+ subscription = callback;
+
+ if (!subscription.callback) {
+ throw 'Callback was not specified on options';
}
- return null;
- }
+ }
- optimalPatchSize = findPatchSizeForDivisors(common);
- if (!optimalPatchSize) {
- optimalPatchSize = findPatchSizeForDivisors(_computeDivisors(wideSide));
- if (!optimalPatchSize) {
- optimalPatchSize = findPatchSizeForDivisors(_computeDivisors(desiredPatchSize * nrOfPatches));
+ getEvent(event).subscriptions.push(subscription);
+ }
+ }, {
+ key: "publish",
+ value: function publish(type, data) {
+ var eventItem = getEvent(type);
+ var subscriptions = eventItem.subscriptions; // Publish one-time subscriptions
+
+ subscriptions.filter(function (_ref) {
+ var once = _ref.once;
+ return !!once;
+ }).forEach(function (subscription) {
+ return publishSubscription(subscription, data);
+ }); // remove them from the subscription
+
+ eventItem.subscriptions = subscriptions.filter(function (_ref2) {
+ var once = _ref2.once;
+ return !once;
+ }); // publish the rest
+
+ eventItem.subscriptions.forEach(function (subscription) {
+ return publishSubscription(subscription, data);
+ });
+ }
+ }, {
+ key: "once",
+ value: function once(event, callback, async) {
+ Events.subscribe(event, {
+ callback: callback,
+ async: async,
+ once: true
+ });
+ }
+ }, {
+ key: "unsubscribe",
+ value: function unsubscribe(eventName, callback) {
+ if (eventName) {
+ var event = getEvent(eventName);
+
+ if (event && callback) {
+ event.subscriptions = event.subscriptions.filter(function (subscription) {
+ return subscription.callback !== callback;
+ });
+ } else {
+ event.subscriptions = [];
}
+ } else {
+ events = {};
+ }
}
- return optimalPatchSize;
-};
+ }]);
+
+ return Events;
+}();
-function _parseCSSDimensionValues(value) {
- var dimension = {
- value: parseFloat(value),
- unit: value.indexOf("%") === value.length - 1 ? "%" : "%"
+function getEvent(eventName) {
+ if (!events[eventName]) {
+ events[eventName] = {
+ subscriptions: []
};
+ }
- return dimension;
-};
+ return events[eventName];
+}
-var _dimensionsConverters = {
- top: function top(dimension, context) {
- if (dimension.unit === "%") {
- return Math.floor(context.height * (dimension.value / 100));
- }
- },
- right: function right(dimension, context) {
- if (dimension.unit === "%") {
- return Math.floor(context.width - context.width * (dimension.value / 100));
- }
- },
- bottom: function bottom(dimension, context) {
- if (dimension.unit === "%") {
- return Math.floor(context.height - context.height * (dimension.value / 100));
- }
- },
- left: function left(dimension, context) {
- if (dimension.unit === "%") {
- return Math.floor(context.width * (dimension.value / 100));
- }
- }
-};
+function publishSubscription(subscription, data) {
+ if (subscription.async) {
+ setTimeout(function () {
+ subscription.callback(data);
+ }, 4);
+ } else {
+ subscription.callback(data);
+ }
+}
-function computeImageArea(inputWidth, inputHeight, area) {
- var context = { width: inputWidth, height: inputHeight };
+/***/ }),
- var parsedArea = Object.keys(area).reduce(function (result, key) {
- var value = area[key],
- parsed = _parseCSSDimensionValues(value),
- calculated = _dimensionsConverters[key](parsed, context);
+/***/ "./src/common/hsv2rgb.ts":
+/*!*******************************!*\
+ !*** ./src/common/hsv2rgb.ts ***!
+ \*******************************/
+/*! exports provided: hsv2rgb */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- result[key] = calculated;
- return result;
- }, {});
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hsv2rgb", function() { return hsv2rgb; });
+function hsv2rgb(hsv, rgb) {
+ var h = hsv[0];
+ var s = hsv[1];
+ var v = hsv[2];
+ var c = v * s;
+ var x = c * (1 - Math.abs(h / 60 % 2 - 1));
+ var m = v - c;
+ var r = 0;
+ var g = 0;
+ var b = 0;
+
+ if (h < 60) {
+ r = c;
+ g = x;
+ } else if (h < 120) {
+ r = x;
+ g = c;
+ } else if (h < 180) {
+ g = c;
+ b = x;
+ } else if (h < 240) {
+ g = x;
+ b = c;
+ } else if (h < 300) {
+ r = x;
+ b = c;
+ } else if (h < 360) {
+ r = c;
+ b = x;
+ }
- return {
- sx: parsedArea.left,
- sy: parsedArea.top,
- sw: parsedArea.right - parsedArea.left,
- sh: parsedArea.bottom - parsedArea.top
- };
+ rgb = rgb || [0, 0, 0];
+ rgb[0] = (r + m) * 255 | 0;
+ rgb[1] = (g + m) * 255 | 0;
+ rgb[2] = (b + m) * 255 | 0;
+ return rgb;
+}
+
+/***/ }),
+
+/***/ "./src/common/image-debug.ts":
+/*!***********************************!*\
+ !*** ./src/common/image-debug.ts ***!
+ \***********************************/
+/*! exports provided: ImageDebug */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ImageDebug", function() { return ImageDebug; });
+var ImageDebug = {
+ drawPath: function drawPath(path, context, color, lineWidth) {
+ if (path && path.length > 1) {
+ context.strokeStyle = color;
+ context.fillStyle = color;
+ context.lineWidth = lineWidth;
+ context.beginPath();
+ context.moveTo(path[0].x, path[0].y);
+ path.slice(1).forEach(function (_ref) {
+ var x = _ref.x,
+ y = _ref.y;
+ return context.lineTo(x, y);
+ });
+ context.closePath();
+ context.stroke();
+ }
+ },
+ drawImage: function drawImage(imageData, width, height, context) {
+ var canvasData = context.getImageData(0, 0, width, height);
+ var data = canvasData.data;
+ var imageIndex = imageData.length | 0;
+ var canvasIndex = data.length | 0;
+
+ if (canvasIndex / imageIndex !== 4) {
+ return false;
+ }
+
+ while (imageIndex--) {
+ var value = imageData[imageIndex];
+ data[--canvasIndex] = 255;
+ data[--canvasIndex] = value;
+ data[--canvasIndex] = value;
+ data[--canvasIndex] = value;
+ }
+
+ context.putImageData(canvasData, 0, 0);
+ return true;
+ }
};
/***/ }),
-/* 20 */
+
+/***/ "./src/common/image-wrapper.ts":
+/*!*************************************!*\
+ !*** ./src/common/image-wrapper.ts ***!
+ \*************************************/
+/*! exports provided: ImageWrapper */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__subImage__ = __webpack_require__(53);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_cv_utils__ = __webpack_require__(19);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__common_array_helper__ = __webpack_require__(3);
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ImageWrapper", function() { return ImageWrapper; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _hsv2rgb__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./hsv2rgb */ "./src/common/hsv2rgb.ts");
+
-var vec2 = {
- clone: __webpack_require__(7)
-};
/**
* Represents a basic image combining the data and size.
* In addition, some methods for manipulation are contained.
- * @param size {x,y} The size of the image in pixel
- * @param data {Array} If given, a flat array containing the pixel data
- * @param ArrayType {Type} If given, the desired DataType of the Array (may be typed/non-typed)
- * @param initialize {Boolean} Indicating if the array should be initialized on creation.
- * @returns {ImageWrapper}
*/
-function ImageWrapper(size, data, ArrayType, initialize) {
+var ImageWrapper =
+/*#__PURE__*/
+function () {
+ /**
+ * @param size The size of the image in pixel
+ * @param data If given, a flat array containing the pixel data
+ * @param arrayType If given, the desired DataType of the Array (may be typed/non-typed)
+ * @param initialize Indicating if the array should be initialized on creation.
+ */
+ function ImageWrapper(size, data, arrayType, initialize) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, ImageWrapper);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "data", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "size", void 0);
+
if (!data) {
- if (ArrayType) {
- this.data = new ArrayType(size.x * size.y);
- if (ArrayType === Array && initialize) {
- __WEBPACK_IMPORTED_MODULE_2__common_array_helper__["a" /* default */].init(this.data, 0);
- }
- } else {
- this.data = new Uint8Array(size.x * size.y);
- if (Uint8Array === Array && initialize) {
- __WEBPACK_IMPORTED_MODULE_2__common_array_helper__["a" /* default */].init(this.data, 0);
- }
- }
+ this.data = new (arrayType || Uint8Array)(size.x * size.y);
+
+ if (initialize) {
+ this.data.fill(0);
+ }
} else {
- this.data = data;
+ this.data = data;
}
+
this.size = size;
-}
+ }
+ /**
+ * Tests if a position is within the image with a given offset
+ * @param point The location to test
+ * @param border The padding value in pixels
+ * @returns true if location inside the image's border, false otherwise
+ * @see cvd/image.h
+ */
-/**
- * tests if a position is within the image with a given offset
- * @param imgRef {x, y} The location to test
- * @param border Number the padding value in pixel
- * @returns {Boolean} true if location inside the image's border, false otherwise
- * @see cvd/image.h
- */
-ImageWrapper.prototype.inImageWithBorder = function (imgRef, border) {
- return imgRef.x >= border && imgRef.y >= border && imgRef.x < this.size.x - border && imgRef.y < this.size.y - border;
-};
-/**
- * Performs bilinear sampling
- * @param inImg Image to extract sample from
- * @param x the x-coordinate
- * @param y the y-coordinate
- * @returns the sampled value
- * @see cvd/vision.h
- */
-ImageWrapper.sample = function (inImg, x, y) {
- var lx = Math.floor(x);
- var ly = Math.floor(y);
- var w = inImg.size.x;
- var base = ly * inImg.size.x + lx;
- var a = inImg.data[base + 0];
- var b = inImg.data[base + 1];
- var c = inImg.data[base + w];
- var d = inImg.data[base + w + 1];
- var e = a - b;
- x -= lx;
- y -= ly;
-
- var result = Math.floor(x * (y * (e - c + d) - e) + y * (c - a) + a);
- return result;
-};
-
-/**
- * Initializes a given array. Sets each element to zero.
- * @param array {Array} The array to initialize
- */
-ImageWrapper.clearArray = function (array) {
- var l = array.length;
- while (l--) {
- array[l] = 0;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(ImageWrapper, [{
+ key: "inImageWithBorder",
+ value: function inImageWithBorder(point, border) {
+ return point.x >= border && point.y >= border && point.x < this.size.x - border && point.y < this.size.y - border;
}
-};
-
-/**
- * Creates a {SubImage} from the current image ({this}).
- * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner)
- * @param size {ImageRef} The size of the resulting image
- * @returns {SubImage} A shared part of the original image
- */
-ImageWrapper.prototype.subImage = function (from, size) {
- return new __WEBPACK_IMPORTED_MODULE_0__subImage__["a" /* default */](from, size, this);
-};
-
-/**
- * Creates an {ImageWrapper) and copies the needed underlying image-data area
- * @param imageWrapper {ImageWrapper} The target {ImageWrapper} where the data should be copied
- * @param from {ImageRef} The location where to copy from (top-left location)
- */
-ImageWrapper.prototype.subImageAsCopy = function (imageWrapper, from) {
- var sizeY = imageWrapper.size.y,
- sizeX = imageWrapper.size.x;
- var x, y;
- for (x = 0; x < sizeX; x++) {
- for (y = 0; y < sizeY; y++) {
- imageWrapper.data[y * sizeX + x] = this.data[(from.y + y) * this.size.x + from.x + x];
+ /**
+ * Creates an {ImageWrapper) and copies the needed underlying image-data area
+ * @param imageWrapper The target {ImageWrapper} where the data should be copied
+ * @param fromX The horizontal position where to copy from
+ * @param fromY The vertical position where to copy from
+ */
+
+ }, {
+ key: "subImageAsCopy",
+ value: function subImageAsCopy(imageWrapper, fromX, fromY) {
+ var sizeY = imageWrapper.size.y;
+ var sizeX = imageWrapper.size.x;
+
+ for (var x = 0; x < sizeX; x++) {
+ for (var y = 0; y < sizeY; y++) {
+ imageWrapper.data[y * sizeX + x] = this.data[(fromY + y) * this.size.x + fromX + x];
}
+ }
}
-};
-
-ImageWrapper.prototype.copyTo = function (imageWrapper) {
- var length = this.data.length,
- srcData = this.data,
- dstData = imageWrapper.data;
+ /**
+ * Retrieves a given pixel position from the image
+ * @param x The x-position
+ * @param y The y-position
+ * @returns The grayscale value at the pixel-position
+ */
- while (length--) {
- dstData[length] = srcData[length];
+ }, {
+ key: "get",
+ value: function get(x, y) {
+ return this.data[y * this.size.x + x];
}
-};
-
-/**
- * Retrieves a given pixel position from the image
- * @param x {Number} The x-position
- * @param y {Number} The y-position
- * @returns {Number} The grayscale value at the pixel-position
- */
-ImageWrapper.prototype.get = function (x, y) {
- return this.data[y * this.size.x + x];
-};
-
-/**
- * Retrieves a given pixel position from the image
- * @param x {Number} The x-position
- * @param y {Number} The y-position
- * @returns {Number} The grayscale value at the pixel-position
- */
-ImageWrapper.prototype.getSafe = function (x, y) {
- var i;
+ /**
+ * Sets a given pixel position in the image
+ * @param x The x-position
+ * @param y The y-position
+ * @param value The grayscale value to set
+ * @returns The Image itself (for possible chaining)
+ */
- if (!this.indexMapping) {
- this.indexMapping = {
- x: [],
- y: []
- };
- for (i = 0; i < this.size.x; i++) {
- this.indexMapping.x[i] = i;
- this.indexMapping.x[i + this.size.x] = i;
- }
- for (i = 0; i < this.size.y; i++) {
- this.indexMapping.y[i] = i;
- this.indexMapping.y[i + this.size.y] = i;
- }
+ }, {
+ key: "set",
+ value: function set(x, y, value) {
+ this.data[y * this.size.x + x] = value;
+ return this;
}
- return this.data[this.indexMapping.y[y + this.size.y] * this.size.x + this.indexMapping.x[x + this.size.x]];
-};
+ /**
+ * Sets the border of the image (1 pixel) to zero
+ */
-/**
- * Sets a given pixel position in the image
- * @param x {Number} The x-position
- * @param y {Number} The y-position
- * @param value {Number} The grayscale value to set
- * @returns {ImageWrapper} The Image itself (for possible chaining)
- */
-ImageWrapper.prototype.set = function (x, y, value) {
- this.data[y * this.size.x + x] = value;
- return this;
-};
+ }, {
+ key: "zeroBorder",
+ value: function zeroBorder() {
+ var width = this.size.x;
+ var height = this.size.y;
+ var data = this.data;
-/**
- * Sets the border of the image (1 pixel) to zero
- */
-ImageWrapper.prototype.zeroBorder = function () {
- var i,
- width = this.size.x,
- height = this.size.y,
- data = this.data;
- for (i = 0; i < width; i++) {
+ for (var i = 0; i < width; i++) {
data[i] = data[(height - 1) * width + i] = 0;
- }
- for (i = 1; i < height - 1; i++) {
- data[i * width] = data[i * width + (width - 1)] = 0;
- }
-};
-
-/**
- * Inverts a binary image in place
- */
-ImageWrapper.prototype.invert = function () {
- var data = this.data,
- length = data.length;
+ }
- while (length--) {
- data[length] = data[length] ? 0 : 1;
+ for (var _i = 1; _i < height - 1; _i++) {
+ data[_i * width] = data[_i * width + (width - 1)] = 0;
+ }
}
-};
+ /**
+ * Inverts a binary image in place
+ */
-ImageWrapper.prototype.convolve = function (kernel) {
- var x,
- y,
- kx,
- ky,
- kSize = kernel.length / 2 | 0,
- accu = 0;
- for (y = 0; y < this.size.y; y++) {
- for (x = 0; x < this.size.x; x++) {
- accu = 0;
- for (ky = -kSize; ky <= kSize; ky++) {
- for (kx = -kSize; kx <= kSize; kx++) {
- accu += kernel[ky + kSize][kx + kSize] * this.getSafe(x + kx, y + ky);
- }
- }
- this.data[y * this.size.x + x] = accu;
- }
+ }, {
+ key: "invert",
+ value: function invert() {
+ var data = this.data;
+
+ for (var i = data.length; i--;) {
+ data[i] = data[i] ? 0 : 1;
+ }
}
-};
+ }, {
+ key: "moments",
+ value: function moments(labelCount) {
+ var height = this.size.y;
+ var width = this.size.x;
+ var labelSum = new Array();
+ var result = new Array();
-ImageWrapper.prototype.moments = function (labelcount) {
- var data = this.data,
- x,
- y,
- height = this.size.y,
- width = this.size.x,
- val,
- ysq,
- labelsum = [],
- i,
- label,
- mu11,
- mu02,
- mu20,
- x_,
- y_,
- tmp,
- result = [],
- PI = Math.PI,
- PI_4 = PI / 4;
-
- if (labelcount <= 0) {
+ if (labelCount <= 0) {
return result;
- }
+ }
- for (i = 0; i < labelcount; i++) {
- labelsum[i] = {
- m00: 0,
- m01: 0,
- m10: 0,
- m11: 0,
- m02: 0,
- m20: 0,
- theta: 0,
- rad: 0
+ for (var i = 0; i < labelCount; i++) {
+ labelSum[i] = {
+ m00: 0,
+ m01: 0,
+ m10: 0,
+ m11: 0,
+ m02: 0,
+ m20: 0,
+ theta: 0,
+ rad: 0
};
- }
+ }
- for (y = 0; y < height; y++) {
- ysq = y * y;
- for (x = 0; x < width; x++) {
- val = data[y * width + x];
- if (val > 0) {
- label = labelsum[val - 1];
- label.m00 += 1;
- label.m01 += y;
- label.m10 += x;
- label.m11 += x * y;
- label.m02 += ysq;
- label.m20 += x * x;
- }
+ for (var y = 0; y < height; y++) {
+ var ysq = y * y;
+
+ for (var x = 0; x < width; x++) {
+ var val = this.data[y * width + x];
+
+ if (val > 0) {
+ var label = labelSum[val - 1];
+ label.m00 += 1;
+ label.m01 += y;
+ label.m10 += x;
+ label.m11 += x * y;
+ label.m02 += ysq;
+ label.m20 += x * x;
+ }
}
- }
+ }
- for (i = 0; i < labelcount; i++) {
- label = labelsum[i];
- if (!isNaN(label.m00) && label.m00 !== 0) {
- x_ = label.m10 / label.m00;
- y_ = label.m01 / label.m00;
- mu11 = label.m11 / label.m00 - x_ * y_;
- mu02 = label.m02 / label.m00 - y_ * y_;
- mu20 = label.m20 / label.m00 - x_ * x_;
- tmp = (mu02 - mu20) / (2 * mu11);
- tmp = 0.5 * Math.atan(tmp) + (mu11 >= 0 ? PI_4 : -PI_4) + PI;
- label.theta = (tmp * 180 / PI + 90) % 180 - 90;
- if (label.theta < 0) {
- label.theta += 180;
- }
- label.rad = tmp > PI ? tmp - PI : tmp;
- label.vec = vec2.clone([Math.cos(tmp), Math.sin(tmp)]);
- result.push(label);
+ var PI = Math.PI;
+ var PI_4 = PI / 4;
+
+ for (var _i2 = 0; _i2 < labelCount; _i2++) {
+ var _label = labelSum[_i2];
+
+ if (!isNaN(_label.m00) && _label.m00 !== 0) {
+ var x_ = _label.m10 / _label.m00;
+ var y_ = _label.m01 / _label.m00;
+ var mu11 = _label.m11 / _label.m00 - x_ * y_;
+ var mu02 = _label.m02 / _label.m00 - y_ * y_;
+ var mu20 = _label.m20 / _label.m00 - x_ * x_;
+ var tmp = 0.5 * Math.atan((mu02 - mu20) / (2 * mu11)) + (mu11 >= 0 ? PI_4 : -PI_4) + PI;
+ _label.theta = (tmp * 180 / PI + 90) % 180 - 90;
+
+ if (_label.theta < 0) {
+ _label.theta += 180;
+ }
+
+ _label.rad = tmp > PI ? tmp - PI : tmp;
+ _label.x = Math.cos(tmp);
+ _label.y = Math.sin(tmp);
+ result.push(_label);
}
+ }
+
+ return result;
}
+ /**
+ * Displays the {ImageWrapper} in a given canvas
+ * @param context The rendering context to write to
+ * @param scale Scale which is applied to each pixel-value
+ */
- return result;
-};
+ }, {
+ key: "show",
+ value: function show(context, scale) {
+ var height = this.size.y;
+ var width = this.size.x; // const context = canvas.getContext('2d');
+ // canvas.height = height;
+ // canvas.width = width;
-/**
- * Displays the {ImageWrapper} in a given canvas
- * @param canvas {Canvas} The canvas element to write to
- * @param scale {Number} Scale which is applied to each pixel-value
- */
-ImageWrapper.prototype.show = function (canvas, scale) {
- var ctx, frame, data, current, pixel, x, y;
+ var frame = context.getImageData(0, 0, width, height);
+ var data = frame.data;
+ var current = 0;
- if (!scale) {
+ if (!scale) {
scale = 1.0;
+ }
+
+ for (var y = 0; y < height; y++) {
+ for (var x = 0; x < width; x++) {
+ var pixel = y * width + x;
+ current = this.get(x, y) * scale;
+ data[pixel * 4 + 0] = current;
+ data[pixel * 4 + 1] = current;
+ data[pixel * 4 + 2] = current;
+ data[pixel * 4 + 3] = 255;
+ }
+ } //frame.data = data;
+
+
+ context.putImageData(frame, 0, 0);
}
- ctx = canvas.getContext('2d');
- canvas.width = this.size.x;
- canvas.height = this.size.y;
- frame = ctx.getImageData(0, 0, canvas.width, canvas.height);
- data = frame.data;
- current = 0;
- for (y = 0; y < this.size.y; y++) {
- for (x = 0; x < this.size.x; x++) {
- pixel = y * this.size.x + x;
- current = this.get(x, y) * scale;
- data[pixel * 4 + 0] = current;
- data[pixel * 4 + 1] = current;
- data[pixel * 4 + 2] = current;
- data[pixel * 4 + 3] = 255;
- }
- }
- //frame.data = data;
- ctx.putImageData(frame, 0, 0);
-};
+ /**
+ * Displays the part of the image in a given canvas
+ * @param context The rendering context to write to
+ * @param scale Scale which is applied to each pixel-value
+ * @param fromX The horizontal position where to overlay from
+ * @param fromY The vertical position where to overlay from
+ */
-/**
- * Displays the {SubImage} in a given canvas
- * @param canvas {Canvas} The canvas element to write to
- * @param scale {Number} Scale which is applied to each pixel-value
- */
-ImageWrapper.prototype.overlay = function (canvas, scale, from) {
- if (!scale || scale < 0 || scale > 360) {
+ }, {
+ key: "overlay",
+ value: function overlay(context, scale, fromX, fromY) {
+ var hsv = [0, 1, 1];
+ var whiteRgb = [255, 255, 255];
+ var blackRgb = [0, 0, 0];
+ var frame = context.getImageData(fromX, fromY, this.size.x, this.size.y);
+ var data = frame.data;
+
+ if (!scale || scale < 0 || scale > 360) {
scale = 360;
- }
- var hsv = [0, 1, 1];
- var rgb = [0, 0, 0];
- var whiteRgb = [255, 255, 255];
- var blackRgb = [0, 0, 0];
- var result = [];
- var ctx = canvas.getContext('2d');
- var frame = ctx.getImageData(from.x, from.y, this.size.x, this.size.y);
- var data = frame.data;
- var length = this.data.length;
- while (length--) {
+ }
+
+ for (var length = this.data.length; length--;) {
hsv[0] = this.data[length] * scale;
- result = hsv[0] <= 0 ? whiteRgb : hsv[0] >= 360 ? blackRgb : __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["a" /* hsv2rgb */])(hsv, rgb);
- data[length * 4 + 0] = result[0];
- data[length * 4 + 1] = result[1];
- data[length * 4 + 2] = result[2];
+ var rgb = hsv[0] <= 0 ? whiteRgb : hsv[0] >= 360 ? blackRgb : Object(_hsv2rgb__WEBPACK_IMPORTED_MODULE_3__["hsv2rgb"])(hsv);
+ data[length * 4 + 0] = rgb[0];
+ data[length * 4 + 1] = rgb[1];
+ data[length * 4 + 2] = rgb[2];
data[length * 4 + 3] = 255;
+ }
+
+ context.putImageData(frame, fromX, fromY);
}
- ctx.putImageData(frame, from.x, from.y);
-};
+ }]);
-/* harmony default export */ __webpack_exports__["a"] = ImageWrapper;
+ return ImageWrapper;
+}();
/***/ }),
-/* 21 */
-/***/ (function(module, exports, __webpack_require__) {
-var defineProperty = __webpack_require__(37);
+/***/ "./src/common/media-devices.ts":
+/*!*************************************!*\
+ !*** ./src/common/media-devices.ts ***!
+ \*************************************/
+/*! exports provided: enumerateDevices, getUserMedia */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-/**
- * The base implementation of `assignValue` and `assignMergeValue` without
- * value checks.
- *
- * @private
- * @param {Object} object The object to modify.
- * @param {string} key The key of the property to assign.
- * @param {*} value The value to assign.
- */
-function baseAssignValue(object, key, value) {
- if (key == '__proto__' && defineProperty) {
- defineProperty(object, key, {
- 'configurable': true,
- 'enumerable': true,
- 'value': value,
- 'writable': true
- });
- } else {
- object[key] = value;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "enumerateDevices", function() { return enumerateDevices; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getUserMedia", function() { return getUserMedia; });
+function enumerateDevices() {
+ if (navigator.mediaDevices && typeof navigator.mediaDevices.enumerateDevices === 'function') {
+ return navigator.mediaDevices.enumerateDevices();
}
-}
-
-module.exports = baseAssignValue;
-
-
-/***/ }),
-/* 22 */
-/***/ (function(module, exports, __webpack_require__) {
-
-var baseIsNative = __webpack_require__(97),
- getValue = __webpack_require__(120);
-/**
- * Gets the native function at `key` of `object`.
- *
- * @private
- * @param {Object} object The object to query.
- * @param {string} key The key of the method to get.
- * @returns {*} Returns the function if it's native, else `undefined`.
- */
-function getNative(object, key) {
- var value = getValue(object, key);
- return baseIsNative(value) ? value : undefined;
+ return Promise.reject(new Error('enumerateDevices is not defined'));
}
+function getUserMedia(constraints) {
+ if (navigator.mediaDevices && typeof navigator.mediaDevices.getUserMedia === 'function') {
+ return navigator.mediaDevices.getUserMedia(constraints);
+ }
-module.exports = getNative;
-
+ return Promise.reject(new Error('getUserMedia is not defined'));
+}
/***/ }),
-/* 23 */
-/***/ (function(module, exports, __webpack_require__) {
-var isSymbol = __webpack_require__(27);
+/***/ "./src/common/merge.ts":
+/*!*****************************!*\
+ !*** ./src/common/merge.ts ***!
+ \*****************************/
+/*! exports provided: merge */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "merge", function() { return merge; });
+/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/typeof */ "../../node_modules/@babel/runtime/helpers/typeof.js");
+/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__);
-/** Used as references for various `Number` constants. */
-var INFINITY = 1 / 0;
/**
- * Converts `value` to a string key if it's not a string or symbol.
+ * Performs a deep merge of objects and returns new object.
+ * Does not modify objects (immutable).
+ * @see https://stackoverflow.com/a/48218209
*
- * @private
- * @param {*} value The value to inspect.
- * @returns {string|symbol} Returns the key.
+ * @param objects - Objects to merge
+ * @returns New object with merged key/values
*/
-function toKey(value) {
- if (typeof value == 'string' || isSymbol(value)) {
- return value;
+function merge() {
+ var isObject = function isObject(obj) {
+ return obj && _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default()(obj) === 'object';
+ };
+
+ for (var _len = arguments.length, objects = new Array(_len), _key = 0; _key < _len; _key++) {
+ objects[_key] = arguments[_key];
}
- var result = (value + '');
- return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
-}
-module.exports = toKey;
+ return objects.reduce(function (prev, obj) {
+ if (obj) {
+ Object.keys(obj).forEach(function (key) {
+ var pVal = prev[key];
+ var oVal = obj[key];
+
+ if (Array.isArray(pVal) && Array.isArray(oVal)) {
+ // prev[key] = pVal.concat(...oVal);
+ prev[key] = oVal;
+ } else if (isObject(pVal) && isObject(oVal)) {
+ prev[key] = merge(pVal, oVal);
+ } else {
+ prev[key] = oVal;
+ }
+ });
+ }
+ return prev;
+ }, {});
+}
/***/ }),
-/* 24 */
-/***/ (function(module, exports, __webpack_require__) {
-
-var isFunction = __webpack_require__(25),
- isLength = __webpack_require__(26);
-/**
- * Checks if `value` is array-like. A value is considered array-like if it's
- * not a function and has a `value.length` that's an integer greater than or
- * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
- * @example
- *
- * _.isArrayLike([1, 2, 3]);
- * // => true
- *
- * _.isArrayLike(document.body.children);
- * // => true
- *
- * _.isArrayLike('abc');
- * // => true
- *
- * _.isArrayLike(_.noop);
- * // => false
- */
-function isArrayLike(value) {
- return value != null && isLength(value.length) && !isFunction(value);
-}
+/***/ "./src/config/config.dev.ts":
+/*!**********************************!*\
+ !*** ./src/config/config.dev.ts ***!
+ \**********************************/
+/*! exports provided: config */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-module.exports = isArrayLike;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "config", function() { return config; });
+var config = {
+ inputStream: {
+ name: 'Live',
+ type: 'LiveStream',
+ constraints: {
+ width: 640,
+ height: 480,
+ // aspectRatio: 640/480, // optional
+ facingMode: 'environment' // or user
+ // deviceId: '38745983457387598375983759834'
+ },
+ area: {
+ top: '0%',
+ right: '0%',
+ left: '0%',
+ bottom: '0%'
+ },
+ singleChannel: false // true: only the red color-channel is read
+
+ },
+ locate: true,
+ numOfWorkers: 0,
+ decoder: {
+ readers: ['code_128_reader'],
+ debug: {
+ drawBoundingBox: false,
+ showFrequency: false,
+ drawScanline: false,
+ showPattern: false
+ }
+ },
+ locator: {
+ halfSample: true,
+ patchSize: 'medium',
+ // x-small, small, medium, large, x-large
+ debug: {
+ showCanvas: false,
+ showPatches: false,
+ showFoundPatches: false,
+ showSkeleton: false,
+ showLabels: false,
+ showPatchLabels: false,
+ showRemainingPatchLabels: false,
+ boxFromPatches: {
+ showTransformed: false,
+ showTransformedBox: false,
+ showBB: false
+ }
+ }
+ }
+};
/***/ }),
-/* 25 */
-/***/ (function(module, exports, __webpack_require__) {
-var baseGetTag = __webpack_require__(8),
- isObject = __webpack_require__(0);
+/***/ "./src/decoder/barcode-decoder.ts":
+/*!****************************************!*\
+ !*** ./src/decoder/barcode-decoder.ts ***!
+ \****************************************/
+/*! exports provided: BarcodeDecoder */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-/** `Object#toString` result references. */
-var asyncTag = '[object AsyncFunction]',
- funcTag = '[object Function]',
- genTag = '[object GeneratorFunction]',
- proxyTag = '[object Proxy]';
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BarcodeDecoder", function() { return BarcodeDecoder; });
+/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/toConsumableArray */ "../../node_modules/@babel/runtime/helpers/toConsumableArray.js");
+/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/typeof */ "../../node_modules/@babel/runtime/helpers/typeof.js");
+/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _reader_index__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../reader/index */ "./src/reader/index.ts");
+/* harmony import */ var _bresenham__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./bresenham */ "./src/decoder/bresenham.ts");
+/* harmony import */ var _common_image_debug__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../common/image-debug */ "./src/common/image-debug.ts");
-/**
- * Checks if `value` is classified as a `Function` object.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a function, else `false`.
- * @example
- *
- * _.isFunction(_);
- * // => true
- *
- * _.isFunction(/abc/);
- * // => false
- */
-function isFunction(value) {
- if (!isObject(value)) {
- return false;
- }
- // The use of `Object#toString` avoids issues with the `typeof` operator
- // in Safari 9 which returns 'object' for typed arrays and other constructors.
- var tag = baseGetTag(value);
- return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
-}
-module.exports = isFunction;
-/***/ }),
-/* 26 */
-/***/ (function(module, exports) {
-/** Used as references for various `Number` constants. */
-var MAX_SAFE_INTEGER = 9007199254740991;
-/**
- * Checks if `value` is a valid array-like length.
- *
- * **Note:** This method is loosely based on
- * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
- * @example
- *
- * _.isLength(3);
- * // => true
- *
- * _.isLength(Number.MIN_VALUE);
- * // => false
- *
- * _.isLength(Infinity);
- * // => false
- *
- * _.isLength('3');
- * // => false
- */
-function isLength(value) {
- return typeof value == 'number' &&
- value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
-}
-module.exports = isLength;
+;
+var BarcodeDecoder =
+/*#__PURE__*/
+function () {
+ function BarcodeDecoder(config, inputImageWrapper) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_2___default()(this, BarcodeDecoder);
-/***/ }),
-/* 27 */
-/***/ (function(module, exports, __webpack_require__) {
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_4___default()(this, "_config", void 0);
-var baseGetTag = __webpack_require__(8),
- isObjectLike = __webpack_require__(6);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_4___default()(this, "_inputImageWrapper", void 0);
-/** `Object#toString` result references. */
-var symbolTag = '[object Symbol]';
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_4___default()(this, "_frequencyCanvas", void 0);
-/**
- * Checks if `value` is classified as a `Symbol` primitive or object.
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
- * @example
- *
- * _.isSymbol(Symbol.iterator);
- * // => true
- *
- * _.isSymbol('abc');
- * // => false
- */
-function isSymbol(value) {
- return typeof value == 'symbol' ||
- (isObjectLike(value) && baseGetTag(value) == symbolTag);
-}
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_4___default()(this, "_patternCanvas", void 0);
-module.exports = isSymbol;
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_4___default()(this, "_overlayContext", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_4___default()(this, "_barcodeReaders", void 0);
-/***/ }),
-/* 28 */
-/***/ (function(module, exports, __webpack_require__) {
+ this._config = config;
+ this._inputImageWrapper = inputImageWrapper;
+ this._barcodeReaders = [];
-var baseMerge = __webpack_require__(100),
- createAssigner = __webpack_require__(116);
+ if ( true && this._config.debug && typeof document !== 'undefined') {
+ var debugDiv = document.querySelector('#debug.detection');
+ this._frequencyCanvas = document.querySelector('canvas.frequency');
-/**
- * This method is like `_.assign` except that it recursively merges own and
- * inherited enumerable string keyed properties of source objects into the
- * destination object. Source properties that resolve to `undefined` are
- * skipped if a destination value exists. Array and plain object properties
- * are merged recursively. Other objects and value types are overridden by
- * assignment. Source objects are applied from left to right. Subsequent
- * sources overwrite property assignments of previous sources.
- *
- * **Note:** This method mutates `object`.
- *
- * @static
- * @memberOf _
- * @since 0.5.0
- * @category Object
- * @param {Object} object The destination object.
- * @param {...Object} [sources] The source objects.
- * @returns {Object} Returns `object`.
- * @example
- *
- * var object = {
- * 'a': [{ 'b': 2 }, { 'd': 4 }]
- * };
- *
- * var other = {
- * 'a': [{ 'c': 3 }, { 'e': 5 }]
- * };
- *
- * _.merge(object, other);
- * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
- */
-var merge = createAssigner(function(object, source, srcIndex) {
- baseMerge(object, source, srcIndex);
-});
+ if (!this._frequencyCanvas) {
+ this._frequencyCanvas = document.createElement('canvas');
+ this._frequencyCanvas.className = 'frequency';
-module.exports = merge;
+ if (debugDiv) {
+ debugDiv.appendChild(this._frequencyCanvas);
+ }
+ }
+ this._frequencyCanvas.style.display = this._config.debug.showFrequency ? 'block' : 'none';
+ this._patternCanvas = document.querySelector('canvas.patternBuffer');
-/***/ }),
-/* 29 */
-/***/ (function(module, exports) {
+ if (!this._patternCanvas) {
+ this._patternCanvas = document.createElement('canvas');
+ this._patternCanvas.className = 'patternBuffer';
-module.exports = function(module) {
- if(!module.webpackPolyfill) {
- module.deprecate = function() {};
- module.paths = [];
- // module.parent = undefined by default
- if(!module.children) module.children = [];
- Object.defineProperty(module, "loaded", {
- enumerable: true,
- get: function() {
- return module.l;
- }
- });
- Object.defineProperty(module, "id", {
- enumerable: true,
- get: function() {
- return module.i;
- }
- });
- module.webpackPolyfill = 1;
- }
- return module;
-};
+ if (debugDiv) {
+ debugDiv.appendChild(this._patternCanvas);
+ }
+ }
+ this._patternCanvas.style.display = this._config.debug.showPattern ? 'block' : 'none';
+ var overlayCanvas = document.querySelector('canvas.drawingBuffer');
+ this._overlayContext = overlayCanvas ? overlayCanvas.getContext('2d') : null;
+ }
-/***/ }),
-/* 30 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ this._initReaders();
+ }
-"use strict";
-/**
- * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
- */
-var Tracer = {
- searchDirections: [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]],
- create: function create(imageWrapper, labelWrapper) {
- var imageData = imageWrapper.data,
- labelData = labelWrapper.data,
- searchDirections = this.searchDirections,
- width = imageWrapper.size.x,
- pos;
-
- function _trace(current, color, label, edgelabel) {
- var i, y, x;
-
- for (i = 0; i < 7; i++) {
- y = current.cy + searchDirections[current.dir][0];
- x = current.cx + searchDirections[current.dir][1];
- pos = y * width + x;
- if (imageData[pos] === color && (labelData[pos] === 0 || labelData[pos] === label)) {
- labelData[pos] = label;
- current.cy = y;
- current.cx = x;
- return true;
- } else {
- if (labelData[pos] === 0) {
- labelData[pos] = edgelabel;
- }
- current.dir = (current.dir + 1) % 8;
- }
- }
- return false;
- }
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3___default()(BarcodeDecoder, [{
+ key: "decodeFromBoundingBoxes",
+ value: function decodeFromBoundingBoxes(boxes) {
+ var _this = this;
- function vertex2D(x, y, dir) {
- return {
- dir: dir,
- x: x,
- y: y,
- next: null,
- prev: null
- };
- }
+ var barcode = null;
- function _contourTracing(sy, sx, label, color, edgelabel) {
- var Fv = null,
- Cv,
- P,
- ldir,
- current = {
- cx: sx,
- cy: sy,
- dir: 0
- };
+ if (boxes) {
+ if (this._config.multiple) {
+ var barcodes = boxes.map(function (box) {
+ return _this.decodeFromBoundingBox(box);
+ });
+ return {
+ barcodes: barcodes,
+ boxes: boxes
+ };
+ }
- if (_trace(current, color, label, edgelabel)) {
- Fv = vertex2D(sx, sy, current.dir);
- Cv = Fv;
- ldir = current.dir;
- P = vertex2D(current.cx, current.cy, 0);
- P.prev = Cv;
- Cv.next = P;
- P.next = null;
- Cv = P;
- do {
- current.dir = (current.dir + 6) % 8;
- _trace(current, color, label, edgelabel);
- if (ldir !== current.dir) {
- Cv.dir = current.dir;
- P = vertex2D(current.cx, current.cy, 0);
- P.prev = Cv;
- Cv.next = P;
- P.next = null;
- Cv = P;
- } else {
- Cv.dir = ldir;
- Cv.x = current.cx;
- Cv.y = current.cy;
- }
- ldir = current.dir;
- } while (current.cx !== sx || current.cy !== sy);
- Fv.prev = Cv.prev;
- Cv.prev.next = Fv;
- }
- return Fv;
+ if (boxes.some(function (box) {
+ return !!(barcode = _this.decodeFromBoundingBox(box));
+ })) {
+ barcode.boxes = boxes;
}
+ }
- return {
- trace: function trace(current, color, label, edgelabel) {
- return _trace(current, color, label, edgelabel);
- },
- contourTracing: function contourTracing(sy, sx, label, color, edgelabel) {
- return _contourTracing(sy, sx, label, color, edgelabel);
- }
- };
+ return barcode;
}
-};
-
-/* harmony default export */ __webpack_exports__["a"] = Tracer;
+ /**
+ * With the help of the configured readers this function tries to detect
+ * a valid barcode pattern within the given area.
+ * @param box The area to search in
+ * @returns The result {codeResult, line, angle, pattern, threshold}
+ */
-/***/ }),
-/* 31 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ }, {
+ key: "decodeFromBoundingBox",
+ value: function decodeFromBoundingBox(box) {
+ var debug = true && this._overlayContext && this._config.debug;
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__barcode_reader__ = __webpack_require__(1);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_array_helper__ = __webpack_require__(3);
+ if (debug && debug.drawBoundingBox) {
+ this._drawPath(box, 'blue', 2);
+ }
+ var line = this._getLine(box);
+ if (line === null) {
+ return null;
+ }
-function Code39Reader() {
- __WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].call(this);
-}
+ var angle = Math.atan2(line[1].y - line[0].y, line[1].x - line[0].x);
+ line = this._getExtendedLine(line, angle);
-var properties = {
- ALPHABETH_STRING: { value: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%" },
- ALPHABET: { value: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 45, 46, 32, 42, 36, 47, 43, 37] },
- CHARACTER_ENCODINGS: { value: [0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, 0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, 0x0A8, 0x0A2, 0x08A, 0x02A] },
- ASTERISK: { value: 0x094 },
- FORMAT: { value: "code_39", writeable: false }
-};
+ var result = this._tryDecode(line);
-Code39Reader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].prototype, properties);
-Code39Reader.prototype.constructor = Code39Reader;
+ if (result === null) {
+ result = this._tryDecodeBruteForce(box, line, angle);
+ }
-Code39Reader.prototype._decode = function () {
- var self = this,
- counters = [0, 0, 0, 0, 0, 0, 0, 0, 0],
- result = [],
- start = self._findStart(),
- decodedChar,
- lastStart,
- pattern,
- nextStart;
-
- if (!start) {
+ if (result === null) {
return null;
- }
- nextStart = self._nextSet(self._row, start.end);
+ }
- do {
- counters = self._toCounters(nextStart, counters);
- pattern = self._toPattern(counters);
- if (pattern < 0) {
- return null;
- }
- decodedChar = self._patternToChar(pattern);
- if (decodedChar < 0) {
- return null;
- }
- result.push(decodedChar);
- lastStart = nextStart;
- nextStart += __WEBPACK_IMPORTED_MODULE_1__common_array_helper__["a" /* default */].sum(counters);
- nextStart = self._nextSet(self._row, nextStart);
- } while (decodedChar !== '*');
- result.pop();
+ if (debug && debug.drawScanline) {
+ this._drawPath(line, 'red', 3);
+ }
- if (!result.length) {
- return null;
+ return {
+ angle: angle,
+ box: box,
+ codeResult: result.codeResult,
+ line: line,
+ pattern: result.barcodeLine.line,
+ threshold: result.barcodeLine.threshold
+ };
}
+ }, {
+ key: "setReaders",
+ value: function setReaders(readers) {
+ this._config.readers = readers;
+ this._barcodeReaders.length = 0;
- if (!self._verifyTrailingWhitespace(lastStart, nextStart, counters)) {
- return null;
+ this._initReaders();
}
+ }, {
+ key: "_initReaders",
+ value: function _initReaders() {
+ var _this2 = this;
- return {
- code: result.join(""),
- start: start.start,
- end: nextStart,
- startInfo: start,
- decodedCodes: result
- };
-};
+ this._config.readers.forEach(function (readerConfig) {
+ var reader;
+ var configuration = {};
+ var supplements = [];
-Code39Reader.prototype._verifyTrailingWhitespace = function (lastStart, nextStart, counters) {
- var trailingWhitespaceEnd,
- patternSize = __WEBPACK_IMPORTED_MODULE_1__common_array_helper__["a" /* default */].sum(counters);
+ if (_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_1___default()(readerConfig) === 'object') {
+ reader = readerConfig.format;
+ configuration = readerConfig.config || {};
+ } else if (typeof readerConfig === 'string') {
+ reader = readerConfig;
+ }
- trailingWhitespaceEnd = nextStart - lastStart - patternSize;
- if (trailingWhitespaceEnd * 3 >= patternSize) {
- return true;
- }
- return false;
-};
-
-Code39Reader.prototype._patternToChar = function (pattern) {
- var i,
- self = this;
+ if (true) {
+ console.log('Before registering reader:', reader);
+ }
- for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {
- if (self.CHARACTER_ENCODINGS[i] === pattern) {
- return String.fromCharCode(self.ALPHABET[i]);
+ if (configuration.supplements) {
+ supplements = configuration.supplements.map(function (supplement) {
+ return new _reader_index__WEBPACK_IMPORTED_MODULE_5__["Readers"][supplement]();
+ });
}
- }
- return -1;
-};
-Code39Reader.prototype._findNextWidth = function (counters, current) {
- var i,
- minWidth = Number.MAX_VALUE;
+ _this2._barcodeReaders.push(new _reader_index__WEBPACK_IMPORTED_MODULE_5__["Readers"][reader](configuration, supplements));
+ });
- for (i = 0; i < counters.length; i++) {
- if (counters[i] < minWidth && counters[i] > current) {
- minWidth = counters[i];
- }
+ if (true) {
+ var _console;
+
+ (_console = console).log.apply(_console, ['Registered Readers:'].concat(_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_0___default()(this._barcodeReaders.map(function (_ref) {
+ var config = _ref.config,
+ FORMAT = _ref.FORMAT;
+ return JSON.stringify({
+ config: config,
+ FORMAT: FORMAT
+ });
+ }))));
+ }
}
+ /**
+ * extend the line on both ends
+ * @param line
+ * @param angle
+ */
- return minWidth;
-};
+ }, {
+ key: "_getExtendedLine",
+ value: function _getExtendedLine(line, angle) {
+ function extendLine(amount) {
+ var extension = {
+ y: amount * Math.sin(angle),
+ x: amount * Math.cos(angle)
+ };
+ line[0].y -= extension.y;
+ line[0].x -= extension.x;
+ line[1].y += extension.y;
+ line[1].x += extension.x;
+ }
-Code39Reader.prototype._toPattern = function (counters) {
- var numCounters = counters.length,
- maxNarrowWidth = 0,
- numWideBars = numCounters,
- wideBarWidth = 0,
- self = this,
- pattern,
- i;
-
- while (numWideBars > 3) {
- maxNarrowWidth = self._findNextWidth(counters, maxNarrowWidth);
- numWideBars = 0;
- pattern = 0;
- for (i = 0; i < numCounters; i++) {
- if (counters[i] > maxNarrowWidth) {
- pattern |= 1 << numCounters - 1 - i;
- numWideBars++;
- wideBarWidth += counters[i];
- }
- }
+ var lineLength = Math.sqrt(Math.pow(line[1].y - line[0].y, 2) + Math.pow(line[1].x - line[0].x, 2));
+ var extensionLength = lineLength * 0.1 | 0;
+ extendLine(extensionLength); // check if inside image
- if (numWideBars === 3) {
- for (i = 0; i < numCounters && numWideBars > 0; i++) {
- if (counters[i] > maxNarrowWidth) {
- numWideBars--;
- if (counters[i] * 2 >= wideBarWidth) {
- return -1;
- }
- }
- }
- return pattern;
- }
+ while (extensionLength > 1 && (!this._inputImageWrapper.inImageWithBorder(line[0], 0) || !this._inputImageWrapper.inImageWithBorder(line[1], 0))) {
+ extensionLength >>= 1;
+ extendLine(-extensionLength);
+ }
+
+ return line;
+ }
+ }, {
+ key: "_getLine",
+ value: function _getLine(box) {
+ return [{
+ x: (box[1].x + box[0].x) / 2,
+ y: (box[1].y + box[0].y) / 2
+ }, {
+ x: (box[3].x + box[2].x) / 2,
+ y: (box[3].y + box[2].y) / 2
+ }];
+ }
+ }, {
+ key: "_tryDecode",
+ value: function _tryDecode(line) {
+ var debug = true && this._config.debug;
+
+ if (debug && this._overlayContext) {
+ this._drawPath(line, 'red', 3);
+ }
+
+ var barcodeLine = _bresenham__WEBPACK_IMPORTED_MODULE_6__["Bresenham"].getBarcodeLine(this._inputImageWrapper, line[0], line[1]);
+
+ if (debug && debug.showFrequency) {
+ this._printFrequency(barcodeLine.line);
+ }
+
+ barcodeLine = _bresenham__WEBPACK_IMPORTED_MODULE_6__["Bresenham"].toBinaryLine(barcodeLine);
+
+ if (debug && debug.showPattern) {
+ this._printPattern(barcodeLine.line);
+ }
+
+ var codeResult = null;
+
+ this._barcodeReaders.some(function (reader) {
+ return !!(codeResult = reader.decodePattern(barcodeLine.line));
+ });
+
+ return codeResult ? {
+ codeResult: codeResult,
+ barcodeLine: barcodeLine
+ } : null;
}
- return -1;
-};
+ /**
+ * This method slices the given area apart and tries to detect a barcode-pattern for each slice.
+ * It returns the decoded barcode, or null if nothing was found
+ * @param box
+ * @param line
+ * @param lineAngle
+ */
-Code39Reader.prototype._findStart = function () {
- var self = this,
- offset = self._nextSet(self._row),
- patternStart = offset,
- counter = [0, 0, 0, 0, 0, 0, 0, 0, 0],
- counterPos = 0,
- isWhite = false,
- i,
- j,
- whiteSpaceMustStart;
-
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- if (counterPos === counter.length - 1) {
- // find start pattern
- if (self._toPattern(counter) === self.ASTERISK) {
- whiteSpaceMustStart = Math.floor(Math.max(0, patternStart - (i - patternStart) / 4));
- if (self._matchRange(whiteSpaceMustStart, patternStart, 0)) {
- return {
- start: patternStart,
- end: i
- };
- }
- }
+ }, {
+ key: "_tryDecodeBruteForce",
+ value: function _tryDecodeBruteForce(box, line, lineAngle) {
+ var sideLength = Math.sqrt(Math.pow(box[1].x - box[0].x, 2) + Math.pow(box[1].y - box[0].y, 2));
+ var slices = 16;
+ var xdir = Math.sin(lineAngle);
+ var ydir = Math.cos(lineAngle);
- patternStart += counter[0] + counter[1];
- for (j = 0; j < 7; j++) {
- counter[j] = counter[j + 2];
- }
- counter[7] = 0;
- counter[8] = 0;
- counterPos--;
- } else {
- counterPos++;
- }
- counter[counterPos] = 1;
- isWhite = !isWhite;
+ for (var i = 1; i < slices; i++) {
+ // move line perpendicular to angle
+ var dir = sideLength / slices * i * (i % 2 === 0 ? -1 : 1);
+ line[0].y += dir * xdir;
+ line[0].x -= dir * ydir;
+ line[1].y += dir * xdir;
+ line[1].x -= dir * ydir;
+
+ var result = this._tryDecode(line);
+
+ if (result) {
+ return result;
}
- }
- return null;
-};
+ }
-/* harmony default export */ __webpack_exports__["a"] = Code39Reader;
+ return null;
+ }
+ /**
+ * Used for development only
+ */
-/***/ }),
-/* 32 */
-/***/ (function(module, exports) {
+ }, {
+ key: "_printFrequency",
+ value: function _printFrequency(line) {
+ var context = this._frequencyCanvas.getContext('2d');
-module.exports = dot
+ this._frequencyCanvas.width = line.length;
+ this._frequencyCanvas.height = 256;
+ context.beginPath();
+ context.strokeStyle = 'blue';
-/**
- * Calculates the dot product of two vec2's
- *
- * @param {vec2} a the first operand
- * @param {vec2} b the second operand
- * @returns {Number} dot product of a and b
- */
-function dot(a, b) {
- return a[0] * b[0] + a[1] * b[1]
-}
+ for (var i = 0; i < line.length; i++) {
+ context.moveTo(i, 255);
+ context.lineTo(i, 255 - line[i]);
+ }
-/***/ }),
-/* 33 */
-/***/ (function(module, exports, __webpack_require__) {
+ context.closePath();
+ context.stroke();
+ }
+ /**
+ * Used for development only
+ */
-var getNative = __webpack_require__(22),
- root = __webpack_require__(5);
+ }, {
+ key: "_printPattern",
+ value: function _printPattern(line) {
+ var context = this._patternCanvas.getContext('2d');
-/* Built-in method references that are verified to be native. */
-var Map = getNative(root, 'Map');
+ this._patternCanvas.width = line.length;
+ context.fillStyle = 'black';
-module.exports = Map;
+ for (var i = 0; i < line.length; i++) {
+ if (line[i] === 1) {
+ context.fillRect(i, 0, 1, 100);
+ }
+ }
+ }
+ }, {
+ key: "_drawPath",
+ value: function _drawPath(path, color, lineWidth) {
+ _common_image_debug__WEBPACK_IMPORTED_MODULE_7__["ImageDebug"].drawPath(path, this._overlayContext, color, lineWidth);
+ }
+ }]);
+ return BarcodeDecoder;
+}();
/***/ }),
-/* 34 */
-/***/ (function(module, exports, __webpack_require__) {
-var mapCacheClear = __webpack_require__(138),
- mapCacheDelete = __webpack_require__(139),
- mapCacheGet = __webpack_require__(140),
- mapCacheHas = __webpack_require__(141),
- mapCacheSet = __webpack_require__(142);
+/***/ "./src/decoder/bresenham.ts":
+/*!**********************************!*\
+ !*** ./src/decoder/bresenham.ts ***!
+ \**********************************/
+/*! exports provided: Bresenham */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-/**
- * Creates a map cache object to store key-value pairs.
- *
- * @private
- * @constructor
- * @param {Array} [entries] The key-value pairs to cache.
- */
-function MapCache(entries) {
- var index = -1,
- length = entries == null ? 0 : entries.length;
-
- this.clear();
- while (++index < length) {
- var entry = entries[index];
- this.set(entry[0], entry[1]);
- }
-}
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Bresenham", function() { return Bresenham; });
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__);
-// Add methods to `MapCache`.
-MapCache.prototype.clear = mapCacheClear;
-MapCache.prototype['delete'] = mapCacheDelete;
-MapCache.prototype.get = mapCacheGet;
-MapCache.prototype.has = mapCacheHas;
-MapCache.prototype.set = mapCacheSet;
-module.exports = MapCache;
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-/***/ }),
-/* 35 */
-/***/ (function(module, exports, __webpack_require__) {
+var Slope;
-var baseAssignValue = __webpack_require__(21),
- eq = __webpack_require__(17);
+(function (Slope) {
+ Slope[Slope["Up"] = 1] = "Up";
+ Slope[Slope["Down"] = -1] = "Down";
+})(Slope || (Slope = {}));
-/**
- * This function is like `assignValue` except that it doesn't assign
- * `undefined` values.
- *
- * @private
- * @param {Object} object The object to modify.
- * @param {string} key The key of the property to assign.
- * @param {*} value The value to assign.
- */
-function assignMergeValue(object, key, value) {
- if ((value !== undefined && !eq(object[key], value)) ||
- (value === undefined && !(key in object))) {
- baseAssignValue(object, key, value);
- }
-}
+;
+var Bresenham = {
+ /**
+ * Scans a line of the given image from point p1 to p2 and returns a result object containing
+ * gray-scale values (0-255) of the underlying pixels in addition to the min and max values.
+ * @param imageWrapper
+ * @param p1 The start point {x,y}
+ * @param p2 The end point {x,y}
+ * @returns {line, min, max}
+ */
+ getBarcodeLine: function getBarcodeLine(imageWrapper, p1, p2) {
+ var x0 = p1.x | 0;
+ var y0 = p1.y | 0;
+ var x1 = p2.x | 0;
+ var y1 = p2.y | 0;
+ var steep = Math.abs(y1 - y0) > Math.abs(x1 - x0);
+ var tmp;
+ var line = [];
+ var imageData = imageWrapper.data;
+ var width = imageWrapper.size.x;
+ var val;
+ var min = 255;
+ var max = 0;
-module.exports = assignMergeValue;
+ function read(a, b) {
+ val = imageData[b * width + a];
+ min = val < min ? val : min;
+ max = val > max ? val : max;
+ line.push(val);
+ }
+ if (steep) {
+ tmp = x0;
+ x0 = y0;
+ y0 = tmp;
+ tmp = x1;
+ x1 = y1;
+ y1 = tmp;
+ }
-/***/ }),
-/* 36 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (x0 > x1) {
+ tmp = x0;
+ x0 = x1;
+ x1 = tmp;
+ tmp = y0;
+ y0 = y1;
+ y1 = tmp;
+ }
+
+ var deltax = x1 - x0;
+ var deltay = Math.abs(y1 - y0);
+ var error = deltax / 2 | 0;
+ var y = y0;
+ var ystep = y0 < y1 ? 1 : -1;
+
+ for (var x = x0; x < x1; x++) {
+ if (steep) {
+ read(y, x);
+ } else {
+ read(x, y);
+ }
-var baseAssignValue = __webpack_require__(21),
- eq = __webpack_require__(17);
+ error = error - deltay;
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
+ if (error < 0) {
+ y += ystep;
+ error = error + deltax;
+ }
+ }
+
+ return {
+ line: line,
+ min: min,
+ max: max
+ };
+ },
+
+ /**
+ * Converts the result from getBarcodeLine into a binary representation
+ * also considering the frequency and slope of the signal for more robust results
+ * @param result {line, min, max}
+ */
+ toBinaryLine: function toBinaryLine(result) {
+ var min = result.min;
+ var max = result.max;
+ var line = result.line;
+ var center = min + (max - min) / 2;
+ var extrema = new Array();
+ var threshold = (max - min) / 12;
+ var rThreshold = -threshold; // 1. find extrema
+
+ var currentDir = line[0] > center ? Slope.Up : Slope.Down;
+ extrema.push({
+ pos: 0,
+ val: line[0]
+ });
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+ for (var i = 0; i < line.length - 2; i++) {
+ var slope = line[i + 1] - line[i];
+ var slope2 = line[i + 2] - line[i + 1];
+ var dir = void 0;
-/**
- * Assigns `value` to `key` of `object` if the existing value is not equivalent
- * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
- * for equality comparisons.
- *
- * @private
- * @param {Object} object The object to modify.
- * @param {string} key The key of the property to assign.
- * @param {*} value The value to assign.
- */
-function assignValue(object, key, value) {
- var objValue = object[key];
- if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
- (value === undefined && !(key in object))) {
- baseAssignValue(object, key, value);
- }
-}
+ if (slope + slope2 < rThreshold && line[i + 1] < center * 1.5) {
+ dir = Slope.Down;
+ } else if (slope + slope2 > threshold && line[i + 1] > center * 0.5) {
+ dir = Slope.Up;
+ } else {
+ dir = currentDir;
+ }
-module.exports = assignValue;
+ if (currentDir !== dir) {
+ extrema.push({
+ pos: i,
+ val: line[i]
+ });
+ currentDir = dir;
+ }
+ }
+ extrema.push({
+ pos: line.length,
+ val: line[line.length - 1]
+ });
-/***/ }),
-/* 37 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (var j = extrema[0].pos; j < extrema[1].pos; j++) {
+ line[j] = line[j] > center ? 0 : 1;
+ } // iterate over extrema and convert to binary based on avg between minmax
-var getNative = __webpack_require__(22);
-var defineProperty = (function() {
- try {
- var func = getNative(Object, 'defineProperty');
- func({}, '', {});
- return func;
- } catch (e) {}
-}());
+ for (var _i = 1; _i < extrema.length - 1; _i++) {
+ if (extrema[_i + 1].val > extrema[_i].val) {
+ threshold = extrema[_i].val + (extrema[_i + 1].val - extrema[_i].val) / 3 * 2 | 0;
+ } else {
+ threshold = extrema[_i + 1].val + (extrema[_i].val - extrema[_i + 1].val) / 3 | 0;
+ }
-module.exports = defineProperty;
+ for (var _j = extrema[_i].pos; _j < extrema[_i + 1].pos; _j++) {
+ line[_j] = line[_j] > threshold ? 0 : 1;
+ }
+ }
+ return _objectSpread({}, result, {
+ threshold: threshold
+ });
+ }
+};
/***/ }),
-/* 38 */
-/***/ (function(module, exports, __webpack_require__) {
-/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */
-var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+/***/ "./src/input/camera-access.ts":
+/*!************************************!*\
+ !*** ./src/input/camera-access.ts ***!
+ \************************************/
+/*! exports provided: CameraAccess */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-module.exports = freeGlobal;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CameraAccess", function() { return CameraAccess; });
+/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/regenerator */ "../../node_modules/@babel/runtime/regenerator/index.js");
+/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/asyncToGenerator */ "../../node_modules/@babel/runtime/helpers/asyncToGenerator.js");
+/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _common_media_devices__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../common/media-devices */ "./src/common/media-devices.ts");
+
+
+
+
+var _stream;
+
+var CameraAccess = {
+ /**
+ * Attempts to attach the camera-stream to a given video element
+ * and calls the callback function when the content is ready
+ * @param video
+ * @param videoConstraints
+ */
+ request: function () {
+ var _request = _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1___default()(
+ /*#__PURE__*/
+ _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.mark(function _callee(video, videoConstraints) {
+ var normalizedConstraints;
+ return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.wrap(function _callee$(_context) {
+ while (1) {
+ switch (_context.prev = _context.next) {
+ case 0:
+ normalizedConstraints = CameraAccess.pickConstraints(videoConstraints);
+ _context.next = 3;
+ return Object(_common_media_devices__WEBPACK_IMPORTED_MODULE_2__["getUserMedia"])(normalizedConstraints);
+
+ case 3:
+ _stream = _context.sent;
+ video.srcObject = _stream;
+ video.setAttribute('autoplay', '');
+ video.setAttribute('muted', '');
+ video.setAttribute('playsinline', '');
+ return _context.abrupt("return", new Promise(function (resolve) {
+ return video.addEventListener('loadedmetadata', function () {
+ video.play();
+ resolve();
+ });
+ }).then(_waitForVideo.bind(null, video)));
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47)))
+ case 9:
+ case "end":
+ return _context.stop();
+ }
+ }
+ }, _callee);
+ }));
-/***/ }),
-/* 39 */
-/***/ (function(module, exports, __webpack_require__) {
+ function request(_x, _x2) {
+ return _request.apply(this, arguments);
+ }
-var overArg = __webpack_require__(147);
+ return request;
+ }(),
+ release: function release() {
+ var tracks = _stream && _stream.getVideoTracks();
-/** Built-in value references. */
-var getPrototype = overArg(Object.getPrototypeOf, Object);
+ if (tracks && tracks.length) {
+ tracks[0].stop();
+ }
-module.exports = getPrototype;
+ _stream = null;
+ },
+ enumerateVideoDevices: function () {
+ var _enumerateVideoDevices = _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1___default()(
+ /*#__PURE__*/
+ _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.mark(function _callee2() {
+ var devices;
+ return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.wrap(function _callee2$(_context2) {
+ while (1) {
+ switch (_context2.prev = _context2.next) {
+ case 0:
+ _context2.next = 2;
+ return Object(_common_media_devices__WEBPACK_IMPORTED_MODULE_2__["enumerateDevices"])();
+ case 2:
+ devices = _context2.sent;
+ return _context2.abrupt("return", devices.filter(function (_ref) {
+ var kind = _ref.kind;
+ return kind === 'videoinput';
+ }));
-/***/ }),
-/* 40 */
-/***/ (function(module, exports) {
+ case 4:
+ case "end":
+ return _context2.stop();
+ }
+ }
+ }, _callee2);
+ }));
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
+ function enumerateVideoDevices() {
+ return _enumerateVideoDevices.apply(this, arguments);
+ }
-/**
- * Checks if `value` is likely a prototype object.
- *
- * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
- */
-function isPrototype(value) {
- var Ctor = value && value.constructor,
- proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+ return enumerateVideoDevices;
+ }(),
+ getActiveStreamLabel: function getActiveStreamLabel() {
+ var track = CameraAccess.getActiveTrack();
+ return track ? track.label : '';
+ },
+ getActiveTrack: function getActiveTrack() {
+ var tracks = _stream && _stream.getVideoTracks();
- return value === proto;
-}
+ if (tracks && tracks.length) {
+ return tracks[0];
+ }
-module.exports = isPrototype;
+ return null;
+ },
+ pickConstraints: function pickConstraints(videoConstraints) {
+ var width = videoConstraints.width,
+ height = videoConstraints.height,
+ facingMode = videoConstraints.facingMode,
+ aspectRatio = videoConstraints.aspectRatio,
+ deviceId = videoConstraints.deviceId;
+ var _ref2 = videoConstraints,
+ minAspectRatio = _ref2.minAspectRatio,
+ facing = _ref2.facing;
+
+ if (typeof minAspectRatio !== 'undefined' && minAspectRatio > 0) {
+ aspectRatio = minAspectRatio;
+ console.log("WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead");
+ }
+
+ if (typeof facing !== 'undefined') {
+ facingMode = facing;
+ console.log("WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'");
+ }
+
+ var normalizedConstraints = deviceId && facingMode ? {
+ width: width,
+ height: height,
+ aspectRatio: aspectRatio,
+ deviceId: deviceId
+ } : {
+ width: width,
+ height: height,
+ facingMode: facingMode,
+ aspectRatio: aspectRatio,
+ deviceId: deviceId
+ };
+ return {
+ audio: false,
+ video: normalizedConstraints
+ };
+ }
+};
+function _waitForVideo(_ref3) {
+ var videoWidth = _ref3.videoWidth,
+ videoHeight = _ref3.videoHeight;
+ return new Promise(function (resolve, reject) {
+ var attempts = 10;
-/***/ }),
-/* 41 */
-/***/ (function(module, exports, __webpack_require__) {
+ function checkVideo() {
+ if (attempts > 0) {
+ if (videoWidth > 10 && videoHeight > 10) {
+ if (true) {
+ console.log("".concat(videoWidth, "px x ").concat(videoHeight, "px"));
+ }
-var apply = __webpack_require__(87);
+ resolve();
+ } else {
+ window.setTimeout(checkVideo, 500);
+ }
+ } else {
+ reject('Unable to play video stream. Is webcam working?');
+ }
-/* Built-in method references for those with the same name as other `lodash` methods. */
-var nativeMax = Math.max;
+ attempts--;
+ }
-/**
- * A specialized version of `baseRest` which transforms the rest array.
- *
- * @private
- * @param {Function} func The function to apply a rest parameter to.
- * @param {number} [start=func.length-1] The start position of the rest parameter.
- * @param {Function} transform The rest array transform.
- * @returns {Function} Returns the new function.
- */
-function overRest(func, start, transform) {
- start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
- return function() {
- var args = arguments,
- index = -1,
- length = nativeMax(args.length - start, 0),
- array = Array(length);
-
- while (++index < length) {
- array[index] = args[start + index];
- }
- index = -1;
- var otherArgs = Array(start + 1);
- while (++index < start) {
- otherArgs[index] = args[index];
- }
- otherArgs[start] = transform(array);
- return apply(func, this, otherArgs);
- };
+ checkVideo();
+ });
}
-module.exports = overRest;
+/***/ }),
+/***/ "./src/input/exif-helper.ts":
+/*!**********************************!*\
+ !*** ./src/input/exif-helper.ts ***!
+ \**********************************/
+/*! exports provided: AvailableTags, findTagsInObjectURL, findTagsInBuffer */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "AvailableTags", function() { return AvailableTags; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findTagsInObjectURL", function() { return findTagsInObjectURL; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findTagsInBuffer", function() { return findTagsInBuffer; });
+/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/regenerator */ "../../node_modules/@babel/runtime/regenerator/index.js");
+/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/asyncToGenerator */ "../../node_modules/@babel/runtime/helpers/asyncToGenerator.js");
+/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1__);
-/***/ }),
-/* 42 */
-/***/ (function(module, exports, __webpack_require__) {
-var baseSetToString = __webpack_require__(106),
- shortOut = __webpack_require__(148);
/**
- * Sets the `toString` method of `func` to return `string`.
- *
- * @private
- * @param {Function} func The function to modify.
- * @param {Function} string The `toString` result.
- * @returns {Function} Returns `func`.
+ * @borrows https://github.com/exif-js/exif-js
*/
-var setToString = shortOut(baseSetToString);
+var ExifTags = {
+ 0x0112: 'orientation'
+};
+var AvailableTags = Object.keys(ExifTags).map(function (key) {
+ return ExifTags[key];
+});
+function findTagsInObjectURL(_x) {
+ return _findTagsInObjectURL.apply(this, arguments);
+}
+
+function _findTagsInObjectURL() {
+ _findTagsInObjectURL = _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1___default()(
+ /*#__PURE__*/
+ _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.mark(function _callee(src) {
+ var tags,
+ buffer,
+ _args = arguments;
+ return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.wrap(function _callee$(_context) {
+ while (1) {
+ switch (_context.prev = _context.next) {
+ case 0:
+ tags = _args.length > 1 && _args[1] !== undefined ? _args[1] : AvailableTags;
+
+ if (!/^blob:/i.test(src)) {
+ _context.next = 6;
+ break;
+ }
-module.exports = setToString;
+ _context.next = 4;
+ return objectURLToBlob(src);
+ case 4:
+ buffer = _context.sent;
+ return _context.abrupt("return", findTagsInBuffer(buffer, tags));
-/***/ }),
-/* 43 */
-/***/ (function(module, exports) {
+ case 6:
+ return _context.abrupt("return", Promise.resolve(null));
-/**
- * This method returns the first argument it receives.
- *
- * @static
- * @since 0.1.0
- * @memberOf _
- * @category Util
- * @param {*} value Any value.
- * @returns {*} Returns `value`.
- * @example
- *
- * var object = { 'a': 1 };
- *
- * console.log(_.identity(object) === object);
- * // => true
- */
-function identity(value) {
- return value;
+ case 7:
+ case "end":
+ return _context.stop();
+ }
+ }
+ }, _callee);
+ }));
+ return _findTagsInObjectURL.apply(this, arguments);
}
-module.exports = identity;
+function findTagsInBuffer(file) {
+ var selectedTags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : AvailableTags;
+ var dataView = new DataView(file);
+ var length = file.byteLength;
+ var exifTags = selectedTags.reduce(function (result, selectedTag) {
+ var exifTag = Object.keys(ExifTags).find(function (tag) {
+ return ExifTags[tag] === selectedTag;
+ });
+
+ if (exifTag) {
+ result[exifTag] = selectedTag;
+ }
+ return result;
+ }, {});
+ var offset = 2;
-/***/ }),
-/* 44 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (dataView.getUint8(0) !== 0xFF || dataView.getUint8(1) !== 0xD8) {
+ return null;
+ }
-/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(5),
- stubFalse = __webpack_require__(163);
+ while (offset < length) {
+ if (dataView.getUint8(offset) !== 0xFF) {
+ return null;
+ }
-/** Detect free variable `exports`. */
-var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+ var marker = dataView.getUint8(offset + 1);
-/** Detect free variable `module`. */
-var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+ if (marker === 0xE1) {
+ return readEXIFData(dataView, offset + 4, exifTags);
+ } else {
+ offset += 2 + dataView.getUint16(offset + 2);
+ }
+ }
-/** Detect the popular CommonJS extension `module.exports`. */
-var moduleExports = freeModule && freeModule.exports === freeExports;
+ return null;
+}
-/** Built-in value references. */
-var Buffer = moduleExports ? root.Buffer : undefined;
+function objectURLToBlob(_x2) {
+ return _objectURLToBlob.apply(this, arguments);
+}
-/* Built-in method references for those with the same name as other `lodash` methods. */
-var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+function _objectURLToBlob() {
+ _objectURLToBlob = _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1___default()(
+ /*#__PURE__*/
+ _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.mark(function _callee2(url) {
+ var response;
+ return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.wrap(function _callee2$(_context2) {
+ while (1) {
+ switch (_context2.prev = _context2.next) {
+ case 0:
+ _context2.next = 2;
+ return fetch(url);
-/**
- * Checks if `value` is a buffer.
- *
- * @static
- * @memberOf _
- * @since 4.3.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
- * @example
- *
- * _.isBuffer(new Buffer(2));
- * // => true
- *
- * _.isBuffer(new Uint8Array(2));
- * // => false
- */
-var isBuffer = nativeIsBuffer || stubFalse;
+ case 2:
+ response = _context2.sent;
-module.exports = isBuffer;
+ if (!response.ok) {
+ _context2.next = 5;
+ break;
+ }
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)(module)))
+ return _context2.abrupt("return", response.arrayBuffer());
-/***/ }),
-/* 45 */
-/***/ (function(module, exports, __webpack_require__) {
+ case 5:
+ throw new Error('HTTP Error ' + response.status);
-var baseIsTypedArray = __webpack_require__(98),
- baseUnary = __webpack_require__(109),
- nodeUtil = __webpack_require__(145);
+ case 6:
+ case "end":
+ return _context2.stop();
+ }
+ }
+ }, _callee2);
+ }));
+ return _objectURLToBlob.apply(this, arguments);
+}
-/* Node.js helper references. */
-var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+function readEXIFData(dataView, start, exifTags) {
+ if ('Exif'.split('').some(function (_char, index) {
+ return dataView.getUint8(start + index) !== _char.charCodeAt(0);
+ })) {
+ return null;
+ }
-/**
- * Checks if `value` is classified as a typed array.
- *
- * @static
- * @memberOf _
- * @since 3.0.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
- * @example
- *
- * _.isTypedArray(new Uint8Array);
- * // => true
- *
- * _.isTypedArray([]);
- * // => false
- */
-var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+ var tiffOffset = start + 6;
+ var bigEnd;
-module.exports = isTypedArray;
+ if (dataView.getUint16(tiffOffset) === 0x4949) {
+ bigEnd = false;
+ } else if (dataView.getUint16(tiffOffset) === 0x4D4D) {
+ bigEnd = true;
+ } else {
+ return null;
+ }
+ if (dataView.getUint16(tiffOffset + 2, !bigEnd) !== 0x002A) {
+ return null;
+ }
-/***/ }),
-/* 46 */
-/***/ (function(module, exports, __webpack_require__) {
+ var firstIFDOffset = dataView.getUint32(tiffOffset + 4, !bigEnd);
-var arrayLikeKeys = __webpack_require__(88),
- baseKeysIn = __webpack_require__(99),
- isArrayLike = __webpack_require__(24);
+ if (firstIFDOffset < 0x00000008) {
+ return null;
+ }
-/**
- * Creates an array of the own and inherited enumerable property names of `object`.
- *
- * **Note:** Non-object values are coerced to objects.
- *
- * @static
- * @memberOf _
- * @since 3.0.0
- * @category Object
- * @param {Object} object The object to query.
- * @returns {Array} Returns the array of property names.
- * @example
- *
- * function Foo() {
- * this.a = 1;
- * this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * _.keysIn(new Foo);
- * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
- */
-function keysIn(object) {
- return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+ var tags = readTags(dataView, tiffOffset + firstIFDOffset, exifTags, bigEnd);
+ return tags;
}
-module.exports = keysIn;
+function readTags(dataView, dirStart, strings, bigEnd) {
+ var entries = dataView.getUint16(dirStart, !bigEnd);
+ var tags = {};
+ for (var i = 0; i < entries; i++) {
+ var entryOffset = dirStart + i * 12 + 2;
+ var tag = strings[dataView.getUint16(entryOffset, !bigEnd)];
-/***/ }),
-/* 47 */
-/***/ (function(module, exports) {
+ if (tag) {
+ tags[tag] = readTagValue(dataView, entryOffset, bigEnd);
+ }
+ }
-var g;
-
-// This works in non-strict mode
-g = (function() {
- return this;
-})();
-
-try {
- // This works if eval is allowed (see CSP)
- g = g || Function("return this")() || (1,eval)("this");
-} catch(e) {
- // This works if the window reference is available
- if(typeof window === "object")
- g = window;
-}
-
-// g can still be undefined, but nothing to do about it...
-// We return undefined, instead of nothing here, so it's
-// easier to handle this case. if(!global) { ...}
-
-module.exports = g;
+ return tags;
+}
+function readTagValue(dataView, entryOffset, bigEnd) {
+ var type = dataView.getUint16(entryOffset + 2, !bigEnd);
+ var numValues = dataView.getUint32(entryOffset + 4, !bigEnd);
+ return type === 3 && numValues === 1 ? dataView.getUint16(entryOffset + 8, !bigEnd) : undefined;
+}
/***/ }),
-/* 48 */
+
+/***/ "./src/input/frame-grabber.ts":
+/*!************************************!*\
+ !*** ./src/input/frame-grabber.ts ***!
+ \************************************/
+/*! exports provided: FrameGrabber */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge__ = __webpack_require__(28);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_merge__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_typedefs__ = __webpack_require__(54);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_typedefs___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__common_typedefs__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__common_image_wrapper__ = __webpack_require__(20);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__locator_barcode_locator__ = __webpack_require__(64);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__decoder_barcode_decoder__ = __webpack_require__(57);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__common_events__ = __webpack_require__(51);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__input_camera_access__ = __webpack_require__(59);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__common_image_debug__ = __webpack_require__(9);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__analytics_result_collector__ = __webpack_require__(49);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__config_config__ = __webpack_require__(56);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_input_stream__ = __webpack_require__(63);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11_frame_grabber__ = __webpack_require__(61);
-
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FrameGrabber", function() { return FrameGrabber; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
-var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
- // eslint-disable-line no-unused-vars
+var QUATER_CIRCLE = Math.PI / 2;
+var FrameGrabber =
+/*#__PURE__*/
+function () {
+ function FrameGrabber(inputStream, canvas) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, FrameGrabber);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_inputStream", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_streamConfig", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_canvas", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_context", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_data", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_canvasHeight", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_canvasWidth", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_height", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_width", void 0);
-var vec2 = {
- clone: __webpack_require__(7)
-};
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_topLeft", void 0);
-var _inputStream,
- _framegrabber,
- _stopped,
- _canvasContainer = {
- ctx: {
- image: null,
- overlay: null
- },
- dom: {
- image: null,
- overlay: null
- }
-},
- _inputImageWrapper,
- _boxSize,
- _decoder,
- _workerPool = [],
- _onUIThread = true,
- _resultCollector,
- _config = {};
-
-function initializeData(imageWrapper) {
- initBuffers(imageWrapper);
- _decoder = __WEBPACK_IMPORTED_MODULE_4__decoder_barcode_decoder__["a" /* default */].create(_config.decoder, _inputImageWrapper);
-}
+ this._inputStream = inputStream;
+ this._streamConfig = inputStream.config;
+ this._canvasWidth = inputStream.canvasWidth;
+ this._canvasHeight = inputStream.canvasHeight;
+ this._width = inputStream.width;
+ this._height = inputStream.height;
+ this._topLeft = inputStream.topLeft;
+ this._canvas = canvas || document.createElement('canvas');
+ this._canvas.width = this._canvasWidth;
+ this._canvas.height = this._canvasHeight;
+ this._context = this._canvas.getContext('2d');
+ this._data = new Uint8Array(this._width * this._height);
-function initInputStream(cb) {
- var video;
- if (_config.inputStream.type === "VideoStream") {
- video = document.createElement("video");
- _inputStream = __WEBPACK_IMPORTED_MODULE_10_input_stream__["a" /* default */].createVideoStream(video);
- } else if (_config.inputStream.type === "ImageStream") {
- _inputStream = __WEBPACK_IMPORTED_MODULE_10_input_stream__["a" /* default */].createImageStream();
- } else if (_config.inputStream.type === "LiveStream") {
- var $viewport = getViewPort();
- if ($viewport) {
- video = $viewport.querySelector("video");
- if (!video) {
- video = document.createElement("video");
- $viewport.appendChild(video);
- }
+ if (true) {
+ console.log('FrameGrabber', JSON.stringify({
+ size: {
+ x: this._width,
+ y: this._height
+ },
+ topLeft: this._topLeft,
+ videoSize: {
+ x: inputStream.realWidth,
+ y: inputStream.realHeight
+ },
+ canvasSize: {
+ x: this._canvasWidth,
+ y: this._canvasHeight
}
- _inputStream = __WEBPACK_IMPORTED_MODULE_10_input_stream__["a" /* default */].createLiveStream(video);
- __WEBPACK_IMPORTED_MODULE_6__input_camera_access__["a" /* default */].request(video, _config.inputStream.constraints).then(function () {
- _inputStream.trigger("canrecord");
- }).catch(function (err) {
- return cb(err);
- });
+ }));
}
+ }
+ /**
+ * Fetches a frame from the input stream and puts into the frame buffer.
+ * The image data is converted to gray scale and then half-sampled if configured.
+ */
- _inputStream.setAttribute("preload", "auto");
- _inputStream.setInputStream(_config.inputStream);
- _inputStream.addEventListener("canrecord", canRecord.bind(undefined, cb));
-}
-function getViewPort() {
- var target = _config.inputStream.target;
- // Check if target is already a DOM element
- if (target && target.nodeName && target.nodeType === 1) {
- return target;
- } else {
- // Use '#interactive.viewport' as a fallback selector (backwards compatibility)
- var selector = typeof target === 'string' ? target : '#interactive.viewport';
- return document.querySelector(selector);
- }
-}
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(FrameGrabber, [{
+ key: "grab",
+ value: function grab(data) {
+ this._data = data;
-function canRecord(cb) {
- __WEBPACK_IMPORTED_MODULE_3__locator_barcode_locator__["a" /* default */].checkImageConstraints(_inputStream, _config.locator);
- initCanvas(_config);
- _framegrabber = __WEBPACK_IMPORTED_MODULE_11_frame_grabber__["a" /* default */].create(_inputStream, _canvasContainer.dom.image);
+ var frame = this._inputStream.getFrame();
- adjustWorkerPool(_config.numOfWorkers, function () {
- if (_config.numOfWorkers === 0) {
- initializeData();
- }
- ready(cb);
- });
-}
+ if (frame) {
+ this._adjustCanvasSize();
-function ready(cb) {
- _inputStream.play();
- cb();
-}
+ var drawable;
+ var drawAngle = 0;
-function initCanvas() {
- if (typeof document !== "undefined") {
- var $viewport = getViewPort();
- _canvasContainer.dom.image = document.querySelector("canvas.imgBuffer");
- if (!_canvasContainer.dom.image) {
- _canvasContainer.dom.image = document.createElement("canvas");
- _canvasContainer.dom.image.className = "imgBuffer";
- if ($viewport && _config.inputStream.type === "ImageStream") {
- $viewport.appendChild(_canvasContainer.dom.image);
- }
- }
- _canvasContainer.ctx.image = _canvasContainer.dom.image.getContext("2d");
- _canvasContainer.dom.image.width = _inputStream.getCanvasSize().x;
- _canvasContainer.dom.image.height = _inputStream.getCanvasSize().y;
+ if (frame instanceof HTMLVideoElement) {
+ drawable = frame;
+ } else {
+ drawable = frame.image;
+
+ if (frame.tags) {
+ switch (frame.tags.orientation) {
+ case 6:
+ {
+ drawAngle = QUATER_CIRCLE;
+ break;
+ }
- _canvasContainer.dom.overlay = document.querySelector("canvas.drawingBuffer");
- if (!_canvasContainer.dom.overlay) {
- _canvasContainer.dom.overlay = document.createElement("canvas");
- _canvasContainer.dom.overlay.className = "drawingBuffer";
- if ($viewport) {
- $viewport.appendChild(_canvasContainer.dom.overlay);
- }
- var clearFix = document.createElement("br");
- clearFix.setAttribute("clear", "all");
- if ($viewport) {
- $viewport.appendChild(clearFix);
+ case 8:
+ {
+ drawAngle = -QUATER_CIRCLE;
+ break;
+ }
}
+ }
}
- _canvasContainer.ctx.overlay = _canvasContainer.dom.overlay.getContext("2d");
- _canvasContainer.dom.overlay.width = _inputStream.getCanvasSize().x;
- _canvasContainer.dom.overlay.height = _inputStream.getCanvasSize().y;
- }
-}
-function initBuffers(imageWrapper) {
- if (imageWrapper) {
- _inputImageWrapper = imageWrapper;
- } else {
- _inputImageWrapper = new __WEBPACK_IMPORTED_MODULE_2__common_image_wrapper__["a" /* default */]({
- x: _inputStream.getWidth(),
- y: _inputStream.getHeight()
- });
- }
+ if (drawAngle !== 0) {
+ var halfWidth = this._canvasWidth >> 1;
+ var halfHeight = this._canvasHeight >> 1;
- if (true) {
- console.log(_inputImageWrapper.size);
- }
- _boxSize = [vec2.clone([0, 0]), vec2.clone([0, _inputImageWrapper.size.y]), vec2.clone([_inputImageWrapper.size.x, _inputImageWrapper.size.y]), vec2.clone([_inputImageWrapper.size.x, 0])];
- __WEBPACK_IMPORTED_MODULE_3__locator_barcode_locator__["a" /* default */].init(_inputImageWrapper, _config.locator);
-}
+ this._context.translate(halfWidth, halfHeight);
-function getBoundingBoxes() {
- if (_config.locate) {
- return __WEBPACK_IMPORTED_MODULE_3__locator_barcode_locator__["a" /* default */].locate();
- } else {
- return [[vec2.clone(_boxSize[0]), vec2.clone(_boxSize[1]), vec2.clone(_boxSize[2]), vec2.clone(_boxSize[3])]];
- }
-}
+ this._context.rotate(drawAngle);
-function transformResult(result) {
- var topRight = _inputStream.getTopRight(),
- xOffset = topRight.x,
- yOffset = topRight.y,
- i;
+ this._context.drawImage(drawable, -halfHeight, -halfWidth, this._canvasHeight, this._canvasWidth);
- if (xOffset === 0 && yOffset === 0) {
- return;
- }
+ this._context.rotate(-drawAngle);
- if (result.barcodes) {
- for (i = 0; i < result.barcodes.length; i++) {
- transformResult(result.barcodes[i]);
+ this._context.translate(-halfWidth, -halfHeight);
+ } else {
+ this._context.drawImage(drawable, 0, 0, this._canvasWidth, this._canvasHeight);
+ }
+
+ var imageData = this._context.getImageData(this._topLeft.x, this._topLeft.y, this._width, this._height).data;
+
+ if (this._streamConfig.halfSample) {
+ this._grayAndHalfSampleFromCanvasData(imageData);
+ } else {
+ this._computeGray(imageData);
}
- }
- if (result.line && result.line.length === 2) {
- moveLine(result.line);
+ return true;
+ } else {
+ return false;
+ }
}
+ }, {
+ key: "_adjustCanvasSize",
+ value: function _adjustCanvasSize() {
+ if (this._canvas.height !== this._canvasHeight || this._canvas.width !== this._canvasWidth) {
+ if (true) {
+ console.warn('Canvas size needs to be adjusted');
+ }
- if (result.box) {
- moveBox(result.box);
+ this._canvas.height = this._canvasHeight;
+ this._canvas.width = this._canvasWidth;
+ }
}
+ }, {
+ key: "_grayAndHalfSampleFromCanvasData",
+ value: function _grayAndHalfSampleFromCanvasData(imageData) {
+ var endIndex = imageData.length >> 2;
+ var outWidth = this._width >> 1;
+ var topRowIndex = 0;
+ var bottomRowIndex = this._width;
+ var outImageIndex = 0;
- if (result.boxes && result.boxes.length > 0) {
- for (i = 0; i < result.boxes.length; i++) {
- moveBox(result.boxes[i]);
+ while (bottomRowIndex < endIndex) {
+ for (var i = 0; i < outWidth; i++) {
+ var top4 = topRowIndex << 2;
+ var bottom4 = bottomRowIndex << 2;
+ this._data[outImageIndex] = (0.299 * imageData[top4 + 0] + 0.587 * imageData[top4 + 1] + 0.114 * imageData[top4 + 2] + (0.299 * imageData[top4 + 4] + 0.587 * imageData[top4 + 5] + 0.114 * imageData[top4 + 6]) + (0.299 * imageData[bottom4 + 0] + 0.587 * imageData[bottom4 + 1] + 0.114 * imageData[bottom4 + 2]) + (0.299 * imageData[bottom4 + 4] + 0.587 * imageData[bottom4 + 5] + 0.114 * imageData[bottom4 + 6])) / 4 | 0;
+ outImageIndex++;
+ topRowIndex += 2;
+ bottomRowIndex += 2;
}
- }
- function moveBox(box) {
- var corner = box.length;
+ topRowIndex += this._width;
+ bottomRowIndex += this._width;
+ }
+ }
+ }, {
+ key: "_computeGray",
+ value: function _computeGray(imageData) {
+ var imageDataLength = imageData.length;
- while (corner--) {
- box[corner][0] += xOffset;
- box[corner][1] += yOffset;
+ if (this._streamConfig && this._streamConfig.singleChannel) {
+ for (var i = 0, j = 0; i < imageDataLength; i += 4, j++) {
+ this._data[j] = imageData[i];
+ }
+ } else {
+ for (var _i = 0, _j = 0; _i < imageDataLength; _i += 4, _j++) {
+ this._data[_j] = 0.299 * imageData[_i] + 0.587 * imageData[_i + 1] + 0.114 * imageData[_i + 2] | 0;
}
+ }
}
+ }]);
- function moveLine(line) {
- line[0].x += xOffset;
- line[0].y += yOffset;
- line[1].x += xOffset;
- line[1].y += yOffset;
- }
-}
+ return FrameGrabber;
+}();
-function addResult(result, imageData) {
- if (!imageData || !_resultCollector) {
- return;
- }
+/***/ }),
- if (result.barcodes) {
- result.barcodes.filter(function (barcode) {
- return barcode.codeResult;
- }).forEach(function (barcode) {
- return addResult(barcode, imageData);
- });
- } else if (result.codeResult) {
- _resultCollector.addResult(imageData, _inputStream.getCanvasSize(), result.codeResult);
- }
-}
+/***/ "./src/input/image-loader.ts":
+/*!***********************************!*\
+ !*** ./src/input/image-loader.ts ***!
+ \***********************************/
+/*! exports provided: ImageLoader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-function hasCodeResult(result) {
- return result && (result.barcodes ? result.barcodes.some(function (barcode) {
- return barcode.codeResult;
- }) : result.codeResult);
-}
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ImageLoader", function() { return ImageLoader; });
+/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/regenerator */ "../../node_modules/@babel/runtime/regenerator/index.js");
+/* harmony import */ var _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/asyncToGenerator */ "../../node_modules/@babel/runtime/helpers/asyncToGenerator.js");
+/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _exif_helper__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./exif-helper */ "./src/input/exif-helper.ts");
-function publishResult(result, imageData) {
- var resultToPublish = result;
- if (result && _onUIThread) {
- transformResult(result);
- addResult(result, imageData);
- resultToPublish = result.barcodes || result;
- }
- __WEBPACK_IMPORTED_MODULE_5__common_events__["a" /* default */].publish("processed", resultToPublish);
- if (hasCodeResult(result)) {
- __WEBPACK_IMPORTED_MODULE_5__common_events__["a" /* default */].publish("detected", resultToPublish);
- }
-}
-function locateAndDecode() {
- var result, boxes;
- boxes = getBoundingBoxes();
- if (boxes) {
- result = _decoder.decodeFromBoundingBoxes(boxes);
- result = result || {};
- result.boxes = boxes;
- publishResult(result, _inputImageWrapper.data);
- } else {
- publishResult();
- }
-}
+var ImageLoader =
+/*#__PURE__*/
+function () {
+ function ImageLoader() {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_2___default()(this, ImageLoader);
+ }
-function update() {
- var availableWorker;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3___default()(ImageLoader, null, [{
+ key: "load",
+ value: function () {
+ var _load = _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1___default()(
+ /*#__PURE__*/
+ _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.mark(function _callee2(baseUri, callback, offset, size, sequence) {
+ var imageSrcs, loadedImages, notLoadedImages, i, loaded, _loaded;
+
+ return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.wrap(function _callee2$(_context2) {
+ while (1) {
+ switch (_context2.prev = _context2.next) {
+ case 0:
+ _loaded = function _ref2() {
+ _loaded = _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_1___default()(
+ /*#__PURE__*/
+ _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.mark(function _callee(loadedImage) {
+ var x, y, imageName, firstImage;
+ return _babel_runtime_regenerator__WEBPACK_IMPORTED_MODULE_0___default.a.wrap(function _callee$(_context) {
+ while (1) {
+ switch (_context.prev = _context.next) {
+ case 0:
+ x = 0;
+
+ case 1:
+ if (!(x < notLoadedImages.length)) {
+ _context.next = 17;
+ break;
+ }
- if (_onUIThread) {
- if (_workerPool.length > 0) {
- availableWorker = _workerPool.filter(function (workerThread) {
- return !workerThread.busy;
- })[0];
- if (availableWorker) {
- _framegrabber.attachData(availableWorker.imageData);
- } else {
- return; // all workers are busy
- }
- } else {
- _framegrabber.attachData(_inputImageWrapper.data);
- }
- if (_framegrabber.grab()) {
- if (availableWorker) {
- availableWorker.busy = true;
- availableWorker.worker.postMessage({
- cmd: 'process',
- imageData: availableWorker.imageData
- }, [availableWorker.imageData.buffer]);
- } else {
- locateAndDecode();
- }
- }
- } else {
- locateAndDecode();
- }
-}
+ if (!(notLoadedImages[x] === loadedImage)) {
+ _context.next = 14;
+ break;
+ }
-function startContinuousUpdate() {
- var next = null,
- delay = 1000 / (_config.frequency || 60);
-
- _stopped = false;
- (function frame(timestamp) {
- next = next || timestamp;
- if (!_stopped) {
- if (timestamp >= next) {
- next += delay;
- update();
- }
- window.requestAnimFrame(frame);
- }
- })(performance.now());
-}
+ notLoadedImages.splice(x, 1); // TODO: assume the index is the same
-function _start() {
- if (_onUIThread && _config.inputStream.type === "LiveStream") {
- startContinuousUpdate();
- } else {
- update();
- }
-}
+ y = 0;
-function initWorker(cb) {
- var blobURL,
- workerThread = {
- worker: undefined,
- imageData: new Uint8Array(_inputStream.getWidth() * _inputStream.getHeight()),
- busy: true
- };
+ case 5:
+ if (!(y < imageSrcs.length)) {
+ _context.next = 13;
+ break;
+ }
- blobURL = generateWorkerBlob();
- workerThread.worker = new Worker(blobURL);
+ imageName = imageSrcs[y].substr(imageSrcs[y].lastIndexOf('/'));
- workerThread.worker.onmessage = function (e) {
- if (e.data.event === 'initialized') {
- URL.revokeObjectURL(blobURL);
- workerThread.busy = false;
- workerThread.imageData = new Uint8Array(e.data.imageData);
- if (true) {
- console.log("Worker initialized");
- }
- return cb(workerThread);
- } else if (e.data.event === 'processed') {
- workerThread.imageData = new Uint8Array(e.data.imageData);
- workerThread.busy = false;
- publishResult(e.data.result, workerThread.imageData);
- } else if (e.data.event === 'error') {
- if (true) {
- console.log("Worker error: " + e.data.message);
- }
- }
- };
+ if (!(loadedImage.src.lastIndexOf(imageName) !== -1)) {
+ _context.next = 10;
+ break;
+ }
- workerThread.worker.postMessage({
- cmd: 'init',
- size: { x: _inputStream.getWidth(), y: _inputStream.getHeight() },
- imageData: workerThread.imageData,
- config: configForWorker(_config)
- }, [workerThread.imageData.buffer]);
-}
+ loadedImages[y] = {
+ image: loadedImage
+ };
+ return _context.abrupt("break", 13);
-function configForWorker(config) {
- return _extends({}, config, {
- inputStream: _extends({}, config.inputStream, {
- target: null
- })
- });
-}
+ case 10:
+ y++;
+ _context.next = 5;
+ break;
-function workerInterface(factory) {
- /* eslint-disable no-undef*/
- if (factory) {
- var Quagga = factory().default;
- if (!Quagga) {
- self.postMessage({ 'event': 'error', message: 'Quagga could not be created' });
- return;
- }
- }
- var imageWrapper;
-
- self.onmessage = function (e) {
- if (e.data.cmd === 'init') {
- var config = e.data.config;
- config.numOfWorkers = 0;
- imageWrapper = new Quagga.ImageWrapper({
- x: e.data.size.x,
- y: e.data.size.y
- }, new Uint8Array(e.data.imageData));
- Quagga.init(config, ready, imageWrapper);
- Quagga.onProcessed(onProcessed);
- } else if (e.data.cmd === 'process') {
- imageWrapper.data = new Uint8Array(e.data.imageData);
- Quagga.start();
- } else if (e.data.cmd === 'setReaders') {
- Quagga.setReaders(e.data.readers);
- }
- };
+ case 13:
+ return _context.abrupt("break", 17);
- function onProcessed(result) {
- self.postMessage({
- 'event': 'processed',
- imageData: imageWrapper.data,
- result: result
- }, [imageWrapper.data.buffer]);
- }
+ case 14:
+ x++;
+ _context.next = 1;
+ break;
- function ready() {
- // eslint-disable-line
- self.postMessage({ 'event': 'initialized', imageData: imageWrapper.data }, [imageWrapper.data.buffer]);
- }
+ case 17:
+ if (!(notLoadedImages.length === 0)) {
+ _context.next = 33;
+ break;
+ }
- /* eslint-enable */
-}
+ if (true) {
+ console.log('Images loaded');
+ }
-function generateWorkerBlob() {
- var blob, factorySource;
+ _context.prev = 19;
- /* jshint ignore:start */
- if (typeof __factorySource__ !== 'undefined') {
- factorySource = __factorySource__; // eslint-disable-line no-undef
- }
- /* jshint ignore:end */
+ if (!(sequence === false)) {
+ _context.next = 25;
+ break;
+ }
- blob = new Blob(['(' + workerInterface.toString() + ')(' + factorySource + ');'], { type: 'text/javascript' });
+ firstImage = loadedImages[0];
+ _context.next = 24;
+ return Object(_exif_helper__WEBPACK_IMPORTED_MODULE_4__["findTagsInObjectURL"])(baseUri);
- return window.URL.createObjectURL(blob);
-}
+ case 24:
+ firstImage.tags = _context.sent;
-function _setReaders(readers) {
- if (_decoder) {
- _decoder.setReaders(readers);
- } else if (_onUIThread && _workerPool.length > 0) {
- _workerPool.forEach(function (workerThread) {
- workerThread.worker.postMessage({ cmd: 'setReaders', readers: readers });
- });
- }
-}
+ case 25:
+ _context.next = 30;
+ break;
-function adjustWorkerPool(capacity, cb) {
- var increaseBy = capacity - _workerPool.length;
- if (increaseBy === 0) {
- return cb && cb();
- }
- if (increaseBy < 0) {
- var workersToTerminate = _workerPool.slice(increaseBy);
- workersToTerminate.forEach(function (workerThread) {
- workerThread.worker.terminate();
- if (true) {
- console.log("Worker terminated!");
- }
- });
- _workerPool = _workerPool.slice(0, increaseBy);
- return cb && cb();
- } else {
- var workerInitialized = function workerInitialized(workerThread) {
- _workerPool.push(workerThread);
- if (_workerPool.length >= capacity) {
- cb && cb();
- }
- };
+ case 27:
+ _context.prev = 27;
+ _context.t0 = _context["catch"](19);
+ console.log(_context.t0);
- for (var i = 0; i < increaseBy; i++) {
- initWorker(workerInitialized);
- }
- }
-}
+ case 30:
+ _context.prev = 30;
+ callback(loadedImages);
+ return _context.finish(30);
-/* harmony default export */ __webpack_exports__["default"] = {
- init: function init(config, cb, imageWrapper) {
- _config = __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default()({}, __WEBPACK_IMPORTED_MODULE_9__config_config__["a" /* default */], config);
- if (imageWrapper) {
- _onUIThread = false;
- initializeData(imageWrapper);
- return cb();
- } else {
- initInputStream(cb);
- }
- },
- start: function start() {
- _start();
- },
- stop: function stop() {
- _stopped = true;
- adjustWorkerPool(0);
- if (_config.inputStream.type === "LiveStream") {
- __WEBPACK_IMPORTED_MODULE_6__input_camera_access__["a" /* default */].release();
- _inputStream.clearEventHandlers();
- }
- },
- pause: function pause() {
- _stopped = true;
- },
- onDetected: function onDetected(callback) {
- __WEBPACK_IMPORTED_MODULE_5__common_events__["a" /* default */].subscribe("detected", callback);
- },
- offDetected: function offDetected(callback) {
- __WEBPACK_IMPORTED_MODULE_5__common_events__["a" /* default */].unsubscribe("detected", callback);
- },
- onProcessed: function onProcessed(callback) {
- __WEBPACK_IMPORTED_MODULE_5__common_events__["a" /* default */].subscribe("processed", callback);
- },
- offProcessed: function offProcessed(callback) {
- __WEBPACK_IMPORTED_MODULE_5__common_events__["a" /* default */].unsubscribe("processed", callback);
- },
- setReaders: function setReaders(readers) {
- _setReaders(readers);
- },
- registerResultCollector: function registerResultCollector(resultCollector) {
- if (resultCollector && typeof resultCollector.addResult === 'function') {
- _resultCollector = resultCollector;
- }
- },
- canvas: _canvasContainer,
- decodeSingle: function decodeSingle(config, resultCallback) {
- var _this = this;
-
- config = __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default()({
- inputStream: {
- type: "ImageStream",
- sequence: false,
- size: 800,
- src: config.src
- },
- numOfWorkers: true && config.debug ? 0 : 1,
- locator: {
- halfSample: false
+ case 33:
+ case "end":
+ return _context.stop();
+ }
+ }
+ }, _callee, null, [[19, 27, 30, 33]]);
+ }));
+ return _loaded.apply(this, arguments);
+ };
+
+ loaded = function _ref(_x6) {
+ return _loaded.apply(this, arguments);
+ };
+
+ imageSrcs = new Array(size);
+ loadedImages = new Array(size);
+ notLoadedImages = new Array();
+
+ if (sequence === false) {
+ imageSrcs[0] = baseUri;
+ } else {
+ for (i = 0; i < size; i++) {
+ imageSrcs[i] = "".concat(baseUri, "image-").concat(('00' + (offset + i)).slice(-3), ".jpg");
+ }
+ }
+
+ imageSrcs.forEach(function (src) {
+ var image = new Image();
+ notLoadedImages.push(image);
+
+ image.onload = function () {
+ return loaded(image);
+ };
+
+ image.src = src;
+ });
+
+ case 7:
+ case "end":
+ return _context2.stop();
}
- }, config);
- this.init(config, function () {
- __WEBPACK_IMPORTED_MODULE_5__common_events__["a" /* default */].once("processed", function (result) {
- _this.stop();
- resultCallback.call(null, result);
- }, true);
- _start();
- });
- },
- ImageWrapper: __WEBPACK_IMPORTED_MODULE_2__common_image_wrapper__["a" /* default */],
- ImageDebug: __WEBPACK_IMPORTED_MODULE_7__common_image_debug__["a" /* default */],
- ResultCollector: __WEBPACK_IMPORTED_MODULE_8__analytics_result_collector__["a" /* default */],
- CameraAccess: __WEBPACK_IMPORTED_MODULE_6__input_camera_access__["a" /* default */]
-};
+ }
+ }, _callee2);
+ }));
+
+ function load(_x, _x2, _x3, _x4, _x5) {
+ return _load.apply(this, arguments);
+ }
+
+ return load;
+ }()
+ }]);
+
+ return ImageLoader;
+}();
/***/ }),
-/* 49 */
+
+/***/ "./src/input/image-stream.ts":
+/*!***********************************!*\
+ !*** ./src/input/image-stream.ts ***!
+ \***********************************/
+/*! exports provided: ImageStream */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__common_image_debug__ = __webpack_require__(9);
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ImageStream", function() { return ImageStream; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/assertThisInitialized */ "../../node_modules/@babel/runtime/helpers/assertThisInitialized.js");
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var _image_loader__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./image-loader */ "./src/input/image-loader.ts");
+/* harmony import */ var _input_stream__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./input-stream */ "./src/input/input-stream.ts");
-function contains(codeResult, list) {
- if (list) {
- return list.some(function (item) {
- return Object.keys(item).every(function (key) {
- return item[key] === codeResult[key];
- });
- });
- }
- return false;
-}
-function passesFilter(codeResult, filter) {
- if (typeof filter === 'function') {
- return filter(codeResult);
- }
- return true;
-}
-/* harmony default export */ __webpack_exports__["a"] = {
- create: function create(config) {
- var canvas = document.createElement("canvas"),
- ctx = canvas.getContext("2d"),
- results = [],
- capacity = config.capacity || 20,
- capture = config.capture === true;
- function matchesConstraints(codeResult) {
- return capacity && codeResult && !contains(codeResult, config.blacklist) && passesFilter(codeResult, config.filter);
- }
- return {
- addResult: function addResult(data, imageSize, codeResult) {
- var result = {};
-
- if (matchesConstraints(codeResult)) {
- capacity--;
- result.codeResult = codeResult;
- if (capture) {
- canvas.width = imageSize.x;
- canvas.height = imageSize.y;
- __WEBPACK_IMPORTED_MODULE_0__common_image_debug__["a" /* default */].drawImage(data, imageSize, ctx);
- result.frame = canvas.toDataURL();
- }
- results.push(result);
- }
- },
- getResults: function getResults() {
- return results;
- }
- };
- }
-};
-/***/ }),
-/* 50 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-var vec2 = {
- clone: __webpack_require__(7),
- dot: __webpack_require__(32)
-};
-/**
- * Creates a cluster for grouping similar orientations of datapoints
- */
-/* harmony default export */ __webpack_exports__["a"] = {
- create: function create(point, threshold) {
- var points = [],
- center = {
- rad: 0,
- vec: vec2.clone([0, 0])
- },
- pointMap = {};
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
- function init() {
- _add(point);
- updateCenter();
- }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
- function _add(pointToAdd) {
- pointMap[pointToAdd.id] = pointToAdd;
- points.push(pointToAdd);
- }
- function updateCenter() {
- var i,
- sum = 0;
- for (i = 0; i < points.length; i++) {
- sum += points[i].rad;
- }
- center.rad = sum / points.length;
- center.vec = vec2.clone([Math.cos(center.rad), Math.sin(center.rad)]);
- }
- init();
+var ImageStream =
+/*#__PURE__*/
+function (_InputStream) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default()(ImageStream, _InputStream);
- return {
- add: function add(pointToAdd) {
- if (!pointMap[pointToAdd.id]) {
- _add(pointToAdd);
- updateCenter();
- }
- },
- fits: function fits(otherPoint) {
- // check cosine similarity to center-angle
- var similarity = Math.abs(vec2.dot(otherPoint.point.vec, center.vec));
- if (similarity > threshold) {
- return true;
- }
- return false;
- },
- getPoints: function getPoints() {
- return points;
- },
- getCenter: function getCenter() {
- return center;
- }
- };
- },
- createPoint: function createPoint(newPoint, id, property) {
- return {
- rad: newPoint[property],
- point: newPoint,
- id: id
- };
- }
-};
+ function ImageStream() {
+ var _this;
-/***/ }),
-/* 51 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, ImageStream);
-"use strict";
-/* harmony default export */ __webpack_exports__["a"] = (function () {
- var events = {};
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(ImageStream).call(this));
- function getEvent(eventName) {
- if (!events[eventName]) {
- events[eventName] = {
- subscribers: []
- };
- }
- return events[eventName];
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_baseUrl", void 0);
- function clearEvents() {
- events = {};
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_ended", void 0);
- function publishSubscription(subscription, data) {
- if (subscription.async) {
- setTimeout(function () {
- subscription.callback(data);
- }, 4);
- } else {
- subscription.callback(data);
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_frameIndex", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_height", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_images", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_loaded", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_offset", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_paused", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_size", void 0);
+
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_width", void 0);
+
+ _this._canvasHeight = 0;
+ _this._canvasWidth = 0;
+ _this._baseUrl = null;
+ _this._ended = false;
+ _this._frameIndex = 0;
+ _this._height = 0;
+ _this._images = null;
+ _this._loaded = false;
+ _this._offset = 1;
+ _this._paused = true;
+ _this._size = 0;
+ _this._width = 0;
+ return _this;
+ }
+
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(ImageStream, [{
+ key: "setAttribute",
+ value: function setAttribute() {}
+ }, {
+ key: "pause",
+ value: function pause() {
+ this._paused = true;
+ }
+ }, {
+ key: "play",
+ value: function play() {
+ this._paused = false;
}
+ }, {
+ key: "getFrame",
+ value: function getFrame() {
+ var _this2 = this;
- function _subscribe(event, callback, async) {
- var subscription;
+ var frame = null;
- if (typeof callback === "function") {
- subscription = {
- callback: callback,
- async: async
- };
+ if (this._loaded && !this._paused) {
+ frame = this._images[this._frameIndex];
+
+ if (this._frameIndex < this._size - 1) {
+ this._frameIndex++;
} else {
- subscription = callback;
- if (!subscription.callback) {
- throw "Callback was not specified on options";
- }
+ setTimeout(function () {
+ _this2._ended = true;
+
+ _this2.trigger('ended', []);
+ }, 0);
}
+ }
- getEvent(event).subscribers.push(subscription);
+ return frame;
}
+ }, {
+ key: "_loadImages",
+ value: function _loadImages() {
+ var _this3 = this;
- return {
- subscribe: function subscribe(event, callback, async) {
- return _subscribe(event, callback, async);
- },
- publish: function publish(eventName, data) {
- var event = getEvent(eventName),
- subscribers = event.subscribers;
-
- // Publish one-time subscriptions
- subscribers.filter(function (subscriber) {
- return !!subscriber.once;
- }).forEach(function (subscriber) {
- publishSubscription(subscriber, data);
- });
+ this._loaded = false;
+ _image_loader__WEBPACK_IMPORTED_MODULE_7__["ImageLoader"].load(this._baseUrl, function (images) {
+ _this3._images = images;
- // remove them from the subscriber
- event.subscribers = subscribers.filter(function (subscriber) {
- return !subscriber.once;
- });
+ switch (images[0].tags && images[0].tags.orientation) {
+ case 6:
+ case 8:
+ {
+ _this3._width = images[0].image.height;
+ _this3._height = images[0].image.width;
+ break;
+ }
- // publish the rest
- event.subscribers.forEach(function (subscriber) {
- publishSubscription(subscriber, data);
- });
- },
- once: function once(event, callback, async) {
- _subscribe(event, {
- callback: callback,
- async: async,
- once: true
- });
- },
- unsubscribe: function unsubscribe(eventName, callback) {
- var event;
-
- if (eventName) {
- event = getEvent(eventName);
- if (event && callback) {
- event.subscribers = event.subscribers.filter(function (subscriber) {
- return subscriber.callback !== callback;
- });
- } else {
- event.subscribers = [];
- }
- } else {
- clearEvents();
+ default:
+ {
+ _this3._width = images[0].image.width;
+ _this3._height = images[0].image.height;
}
}
- };
-})();
-
-/***/ }),
-/* 52 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony export (immutable) */ __webpack_exports__["b"] = enumerateDevices;
-/* harmony export (immutable) */ __webpack_exports__["a"] = getUserMedia;
+ _this3._canvasWidth = _this3._calculatedWidth = _this3._config.size ? _this3._width > _this3._height ? _this3._config.size : _this3._width * _this3._config.size / _this3._height | 0 : _this3._width;
+ _this3._canvasHeight = _this3._calculatedHeight = _this3._config.size ? _this3._width > _this3._height ? _this3._height * _this3._config.size / _this3._width | 0 : _this3._config.size : _this3._height;
+ _this3._loaded = true;
+ _this3._frameIndex = 0;
+ setTimeout(function () {
+ return _this3.trigger('canrecord', []);
+ }, 0);
+ }, this._offset, this._size, this._config.sequence);
+ }
+ }, {
+ key: "realHeight",
+ get: function get() {
+ return this._height;
+ }
+ }, {
+ key: "realWidth",
+ get: function get() {
+ return this._width;
+ }
+ }, {
+ key: "config",
+ get: function get() {
+ return this._config;
+ },
+ set: function set(config) {
+ this._config = _objectSpread({}, config);
+ this._baseUrl = config.src;
+ this._size = config.sequence && config.length ? config.length : 1;
-function enumerateDevices() {
- if (navigator.mediaDevices && typeof navigator.mediaDevices.enumerateDevices === 'function') {
- return navigator.mediaDevices.enumerateDevices();
+ this._loadImages();
}
- return Promise.reject(new Error('enumerateDevices is not defined'));
-};
-
-function getUserMedia(constraints) {
- if (navigator.mediaDevices && typeof navigator.mediaDevices.getUserMedia === 'function') {
- return navigator.mediaDevices.getUserMedia(constraints);
+ }, {
+ key: "ended",
+ get: function get() {
+ return this._ended;
}
- return Promise.reject(new Error('getUserMedia is not defined'));
-}
+ }, {
+ key: "currentTime",
+ set: function set(time) {
+ this._frameIndex = time;
+ }
+ }]);
+
+ return ImageStream;
+}(_input_stream__WEBPACK_IMPORTED_MODULE_8__["InputStream"]);
/***/ }),
-/* 53 */
+
+/***/ "./src/input/input-stream-utils.ts":
+/*!*****************************************!*\
+ !*** ./src/input/input-stream-utils.ts ***!
+ \*****************************************/
+/*! exports provided: calculatePatchSize, checkImageConstraints, _parseCssDimensionValues, _dimensionsConverters, computeImageArea */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/**
- * Construct representing a part of another {ImageWrapper}. Shares data
- * between the parent and the child.
- * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner)
- * @param size {ImageRef} The size of the resulting image
- * @param I {ImageWrapper} The {ImageWrapper} to share from
- * @returns {SubImage} A shared part of the original image
- */
-function SubImage(from, size, I) {
- if (!I) {
- I = {
- data: null,
- size: size
- };
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "calculatePatchSize", function() { return calculatePatchSize; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "checkImageConstraints", function() { return checkImageConstraints; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_parseCssDimensionValues", function() { return _parseCssDimensionValues; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_dimensionsConverters", function() { return _dimensionsConverters; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "computeImageArea", function() { return computeImageArea; });
+function _computeDivisors(n) {
+ var divisors = new Array();
+ var largeDivisors = new Array();
+
+ for (var divisor = 1; divisor * divisor <= n; divisor++) {
+ if (n % divisor === 0) {
+ divisors.push(divisor);
+
+ if (divisor * divisor !== n) {
+ largeDivisors.unshift(n / divisor | 0);
+ }
}
- this.data = I.data;
- this.originalSize = I.size;
- this.I = I;
+ }
- this.from = from;
- this.size = size;
+ return divisors.concat(largeDivisors);
}
-/**
- * Displays the {SubImage} in a given canvas
- * @param canvas {Canvas} The canvas element to write to
- * @param scale {Number} Scale which is applied to each pixel-value
- */
-SubImage.prototype.show = function (canvas, scale) {
- var ctx, frame, data, current, y, x, pixel;
+function _computeCommonDivisors(m, n) {
+ if (m === n) {
+ return _computeDivisors(m);
+ }
- if (!scale) {
- scale = 1.0;
+ var max = m > n ? m : n;
+ var min = m > n ? n : m;
+ var divisors = new Array();
+ var largeDivisors = new Array();
+
+ for (var divisor = 1; divisor * divisor <= min; divisor++) {
+ if (max % divisor === 0 && min % divisor === 0) {
+ divisors.push(divisor);
+ var largeDivisor = min / divisor | 0;
+
+ if (divisor !== largeDivisor && max % largeDivisor === 0) {
+ largeDivisors.unshift();
+ }
}
- ctx = canvas.getContext('2d');
- canvas.width = this.size.x;
- canvas.height = this.size.y;
- frame = ctx.getImageData(0, 0, canvas.width, canvas.height);
- data = frame.data;
- current = 0;
- for (y = 0; y < this.size.y; y++) {
- for (x = 0; x < this.size.x; x++) {
- pixel = y * this.size.x + x;
- current = this.get(x, y) * scale;
- data[pixel * 4 + 0] = current;
- data[pixel * 4 + 1] = current;
- data[pixel * 4 + 2] = current;
- data[pixel * 4 + 3] = 255;
- }
- }
- frame.data = data;
- ctx.putImageData(frame, 0, 0);
-};
+ }
-/**
- * Retrieves a given pixel position from the {SubImage}
- * @param x {Number} The x-position
- * @param y {Number} The y-position
- * @returns {Number} The grayscale value at the pixel-position
- */
-SubImage.prototype.get = function (x, y) {
- return this.data[(this.from.y + y) * this.originalSize.x + this.from.x + x];
-};
+ return divisors.concat(largeDivisors);
+}
-/**
- * Updates the underlying data from a given {ImageWrapper}
- * @param image {ImageWrapper} The updated image
- */
-SubImage.prototype.updateData = function (image) {
- this.originalSize = image.size;
- this.data = image.data;
-};
+function calculatePatchSize(patchSize, _ref) {
+ var x = _ref.x,
+ y = _ref.y;
+ var wideSide = Math.max(x | 0, y | 0) | 0;
+ var nrOfPatchesList = [8, 10, 15, 20, 32, 60, 80];
+ var nrOfPatchesMap = {
+ 'x-small': 5,
+ small: 4,
+ medium: 3,
+ large: 2,
+ 'x-large': 1
+ };
+ var nrOfPatchesIndex = nrOfPatchesMap[patchSize] || nrOfPatchesMap.medium | 0;
+ var nrOfPatches = nrOfPatchesList[nrOfPatchesIndex] | 0;
+ var desiredPatchSize = wideSide / nrOfPatches | 0;
-/**
- * Updates the position of the shared area
- * @param from {x,y} The new location
- * @returns {SubImage} returns {this} for possible chaining
- */
-SubImage.prototype.updateFrom = function (from) {
- this.from = from;
- return this;
-};
+ function findPatchSizeForDivisors(divisors) {
+ var i = 0;
+ var found = divisors[divisors.length >> 1] | 0;
-/* harmony default export */ __webpack_exports__["a"] = SubImage;
+ while (i < divisors.length - 1 && divisors[i] < desiredPatchSize) {
+ i++;
+ }
-/***/ }),
-/* 54 */
-/***/ (function(module, exports) {
+ if (i > 0) {
+ if (Math.abs(divisors[i] - desiredPatchSize) > Math.abs(divisors[i - 1] - desiredPatchSize)) {
+ found = divisors[i - 1] | 0;
+ } else {
+ found = divisors[i] | 0;
+ }
+ }
-/*
- * typedefs.js
- * Normalizes browser-specific prefixes
- */
+ if (desiredPatchSize / found < nrOfPatchesList[nrOfPatchesIndex + 1] / nrOfPatchesList[nrOfPatchesIndex] && desiredPatchSize / found > nrOfPatchesList[nrOfPatchesIndex - 1] / nrOfPatchesList[nrOfPatchesIndex]) {
+ return {
+ x: found,
+ y: found
+ };
+ }
-if (typeof window !== 'undefined') {
- window.requestAnimFrame = function () {
- return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function ( /* function FrameRequestCallback */callback) {
- window.setTimeout(callback, 1000 / 60);
- };
- }();
-}
-Math.imul = Math.imul || function (a, b) {
- var ah = a >>> 16 & 0xffff,
- al = a & 0xffff,
- bh = b >>> 16 & 0xffff,
- bl = b & 0xffff;
- // the shift by 0 fixes the sign on the high part
- // the final |0 converts the unsigned value into a signed value
- return al * bl + (ah * bl + al * bh << 16 >>> 0) | 0;
-};
+ return null;
+ }
-if (typeof Object.assign !== 'function') {
- Object.assign = function (target) {
- // .length of function is 2
- 'use strict';
+ var optimalPatchSize = findPatchSizeForDivisors(_computeCommonDivisors(x, y)) || findPatchSizeForDivisors(_computeDivisors(wideSide)) || findPatchSizeForDivisors(_computeDivisors(desiredPatchSize * nrOfPatches));
+ return optimalPatchSize;
+}
+function checkImageConstraints(inputStream, config) {
+ var width = inputStream.width;
+ var height = inputStream.height;
+ var shift = config.halfSample ? 1 : 0 | 0;
+ var inputStreamConfig = inputStream.config; // calculate width and height based on area
+
+ if (inputStreamConfig && inputStreamConfig.area) {
+ var area = computeImageArea(width, height, inputStreamConfig.area);
+ inputStream.topLeft = area.topLeft;
+ inputStream.setCanvasSize(width, height);
+ width = area.width;
+ height = area.height;
+ }
- if (target === null) {
- // TypeError if undefined or null
- throw new TypeError('Cannot convert undefined or null to object');
- }
+ var size = {
+ x: width >> shift,
+ y: height >> shift
+ };
+ var patchSize = calculatePatchSize(config.patchSize, size);
- var to = Object(target);
+ if (true) {
+ console.log('Patch-Size:', JSON.stringify(patchSize));
+ }
- for (var index = 1; index < arguments.length; index++) {
- var nextSource = arguments[index];
+ inputStream.width = (size.x / patchSize.x << shift) * patchSize.x | 0;
+ inputStream.height = (size.y / patchSize.y << shift) * patchSize.y | 0;
- if (nextSource !== null) {
- // Skip over if undefined or null
- for (var nextKey in nextSource) {
- // Avoid bugs when hasOwnProperty is shadowed
- if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
- to[nextKey] = nextSource[nextKey];
- }
- }
- }
- }
- return to;
- };
-}
+ if (inputStream.width % patchSize.x === 0 && inputStream.height % patchSize.y === 0) {
+ return true;
+ } // eslint-disable-next-line max-len
-/***/ }),
-/* 55 */
-/***/ (function(module, exports) {
-module.exports = {
- inputStream: {
- name: "Live",
- type: "LiveStream",
- constraints: {
- width: 640,
- height: 480,
- // aspectRatio: 640/480, // optional
- facingMode: "environment" },
- area: {
- top: "0%",
- right: "0%",
- left: "0%",
- bottom: "0%"
- },
- singleChannel: false // true: only the red color-channel is read
- },
- locate: true,
- numOfWorkers: 0,
- decoder: {
- readers: ['code_128_reader'],
- debug: {
- drawBoundingBox: false,
- showFrequency: false,
- drawScanline: false,
- showPattern: false
- }
- },
- locator: {
- halfSample: true,
- patchSize: "medium", // x-small, small, medium, large, x-large
- debug: {
- showCanvas: false,
- showPatches: false,
- showFoundPatches: false,
- showSkeleton: false,
- showLabels: false,
- showPatchLabels: false,
- showRemainingPatchLabels: false,
- boxFromPatches: {
- showTransformed: false,
- showTransformedBox: false,
- showBB: false
- }
- }
- }
+ throw new Error("Image dimensions do not comply with the current settings: width (".concat(width, ") and height (").concat(height, ") must be a multiple of ").concat(patchSize.x));
+}
+function _parseCssDimensionValues(value) {
+ var dimension = {
+ value: parseFloat(value),
+ unit: value.indexOf('%') === value.length - 1 ? '%' : value.indexOf('px') === value.length - 2 ? 'px' : '%'
+ };
+ return dimension;
+}
+var _dimensionsConverters = {
+ bottom: function bottom(dimension, _ref2) {
+ var height = _ref2.height;
+ return dimension.unit === '%' ? height - height * dimension.value / 100 | 0 : dimension.unit === 'px' ? height - dimension.value : height;
+ },
+ left: function left(dimension, _ref3) {
+ var width = _ref3.width;
+ return dimension.unit === '%' ? width * dimension.value / 100 | 0 : dimension.unit === 'px' ? dimension.value : 0;
+ },
+ right: function right(dimension, _ref4) {
+ var width = _ref4.width;
+ return dimension.unit === '%' ? width - width * dimension.value / 100 | 0 : dimension.unit === 'px' ? width - dimension.value : width;
+ },
+ top: function top(dimension, _ref5) {
+ var height = _ref5.height;
+ return dimension.unit === '%' ? height * dimension.value / 100 | 0 : dimension.unit === 'px' ? dimension.value : 0;
+ }
};
+function computeImageArea(inputWidth, inputHeight, area) {
+ var context = {
+ width: inputWidth,
+ height: inputHeight
+ };
+ var parsedArea = Object.keys(area).reduce(function (result, key) {
+ var value = area[key];
-/***/ }),
-/* 56 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ var parsed = _parseCssDimensionValues(value);
-"use strict";
-var config = void 0;
+ var calculated = _dimensionsConverters[key](parsed, context);
-if (true) {
- config = __webpack_require__(55);
-} else if (ENV.node) {
- config = require('./config.node.js');
-} else {
- config = require('./config.prod.js');
+ result[key] = calculated;
+ return result;
+ }, {});
+ return {
+ topLeft: {
+ x: parsedArea.left,
+ y: parsedArea.top
+ },
+ width: parsedArea.right - parsedArea.left,
+ height: parsedArea.bottom - parsedArea.top
+ };
}
-/* harmony default export */ __webpack_exports__["a"] = config;
-
/***/ }),
-/* 57 */
+
+/***/ "./src/input/input-stream.ts":
+/*!***********************************!*\
+ !*** ./src/input/input-stream.ts ***!
+ \***********************************/
+/*! exports provided: InputStream */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__bresenham__ = __webpack_require__(58);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_image_debug__ = __webpack_require__(9);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__reader_code_128_reader__ = __webpack_require__(69);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__reader_ean_reader__ = __webpack_require__(4);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__reader_code_39_reader__ = __webpack_require__(31);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__reader_code_39_vin_reader__ = __webpack_require__(70);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__reader_codabar_reader__ = __webpack_require__(68);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__reader_upc_reader__ = __webpack_require__(77);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__reader_ean_8_reader__ = __webpack_require__(74);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__reader_ean_2_reader__ = __webpack_require__(72);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__reader_ean_5_reader__ = __webpack_require__(73);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__reader_upc_e_reader__ = __webpack_require__(76);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__reader_i2of5_reader__ = __webpack_require__(75);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__reader_2of5_reader__ = __webpack_require__(67);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__reader_code_93_reader__ = __webpack_require__(71);
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "InputStream", function() { return InputStream; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+var InputStream =
+/*#__PURE__*/
+function () {
+ function InputStream() {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, InputStream);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_calculatedHeight", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_calculatedWidth", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_canvasHeight", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_canvasWidth", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_config", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_eventNames", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_eventHandlers", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_topLeft", void 0);
+ this._canvasWidth = 0;
+ this._canvasHeight = 0;
+ this._config = null;
+ this._eventNames = ['canrecord', 'ended'];
+ this._eventHandlers = new Map();
+ this._topLeft = {
+ x: 0,
+ y: 0
+ };
+ }
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(InputStream, [{
+ key: "setCanvasSize",
+ value: function setCanvasSize(width, height) {
+ this._canvasWidth = width;
+ this._canvasHeight = height;
+ }
+ }, {
+ key: "addEventListener",
+ value: function addEventListener(event, listener, _options) {
+ if (this._eventNames.indexOf(event) !== -1) {
+ if (!this._eventHandlers.has(event)) {
+ this._eventHandlers.set(event, new Array());
+ }
-var READERS = {
- code_128_reader: __WEBPACK_IMPORTED_MODULE_2__reader_code_128_reader__["a" /* default */],
- ean_reader: __WEBPACK_IMPORTED_MODULE_3__reader_ean_reader__["a" /* default */],
- ean_5_reader: __WEBPACK_IMPORTED_MODULE_10__reader_ean_5_reader__["a" /* default */],
- ean_2_reader: __WEBPACK_IMPORTED_MODULE_9__reader_ean_2_reader__["a" /* default */],
- ean_8_reader: __WEBPACK_IMPORTED_MODULE_8__reader_ean_8_reader__["a" /* default */],
- code_39_reader: __WEBPACK_IMPORTED_MODULE_4__reader_code_39_reader__["a" /* default */],
- code_39_vin_reader: __WEBPACK_IMPORTED_MODULE_5__reader_code_39_vin_reader__["a" /* default */],
- codabar_reader: __WEBPACK_IMPORTED_MODULE_6__reader_codabar_reader__["a" /* default */],
- upc_reader: __WEBPACK_IMPORTED_MODULE_7__reader_upc_reader__["a" /* default */],
- upc_e_reader: __WEBPACK_IMPORTED_MODULE_11__reader_upc_e_reader__["a" /* default */],
- i2of5_reader: __WEBPACK_IMPORTED_MODULE_12__reader_i2of5_reader__["a" /* default */],
- '2of5_reader': __WEBPACK_IMPORTED_MODULE_13__reader_2of5_reader__["a" /* default */],
- code_93_reader: __WEBPACK_IMPORTED_MODULE_14__reader_code_93_reader__["a" /* default */]
-};
-/* harmony default export */ __webpack_exports__["a"] = {
- create: function create(config, inputImageWrapper) {
- var _canvas = {
- ctx: {
- frequency: null,
- pattern: null,
- overlay: null
- },
- dom: {
- frequency: null,
- pattern: null,
- overlay: null
- }
- },
- _barcodeReaders = [];
-
- initCanvas();
- initReaders();
- initConfig();
-
- function initCanvas() {
- if (true && typeof document !== 'undefined') {
- var $debug = document.querySelector("#debug.detection");
- _canvas.dom.frequency = document.querySelector("canvas.frequency");
- if (!_canvas.dom.frequency) {
- _canvas.dom.frequency = document.createElement("canvas");
- _canvas.dom.frequency.className = "frequency";
- if ($debug) {
- $debug.appendChild(_canvas.dom.frequency);
- }
- }
- _canvas.ctx.frequency = _canvas.dom.frequency.getContext("2d");
-
- _canvas.dom.pattern = document.querySelector("canvas.patternBuffer");
- if (!_canvas.dom.pattern) {
- _canvas.dom.pattern = document.createElement("canvas");
- _canvas.dom.pattern.className = "patternBuffer";
- if ($debug) {
- $debug.appendChild(_canvas.dom.pattern);
- }
- }
- _canvas.ctx.pattern = _canvas.dom.pattern.getContext("2d");
+ this._eventHandlers.get(event).push(listener);
+ }
+ }
+ }, {
+ key: "clearEventHandlers",
+ value: function clearEventHandlers() {
+ this._eventHandlers.clear();
+ }
+ }, {
+ key: "trigger",
+ value: function trigger(eventName, argArray) {
+ var _this = this;
- _canvas.dom.overlay = document.querySelector("canvas.drawingBuffer");
- if (_canvas.dom.overlay) {
- _canvas.ctx.overlay = _canvas.dom.overlay.getContext("2d");
- }
- }
- }
+ var handlers = this._eventHandlers.get(eventName);
- function initReaders() {
- config.readers.forEach(function (readerConfig) {
- var reader,
- configuration = {},
- supplements = [];
+ if (handlers) {
+ handlers.forEach(function (handler) {
+ return handler.apply(_this, argArray);
+ });
+ }
+ }
+ }, {
+ key: "height",
+ get: function get() {
+ return this._calculatedHeight;
+ },
+ set: function set(height) {
+ this._calculatedHeight = height;
+ }
+ }, {
+ key: "width",
+ get: function get() {
+ return this._calculatedWidth;
+ },
+ set: function set(width) {
+ this._calculatedWidth = width;
+ }
+ }, {
+ key: "topLeft",
+ get: function get() {
+ return _objectSpread({}, this._topLeft);
+ },
+ set: function set(topLeft) {
+ this._topLeft.x = topLeft.x;
+ this._topLeft.y = topLeft.y;
+ }
+ }, {
+ key: "canvasHeight",
+ get: function get() {
+ return this._canvasHeight;
+ }
+ }, {
+ key: "canvasWidth",
+ get: function get() {
+ return this._canvasWidth;
+ }
+ }]);
- if ((typeof readerConfig === 'undefined' ? 'undefined' : _typeof(readerConfig)) === 'object') {
- reader = readerConfig.format;
- configuration = readerConfig.config;
- } else if (typeof readerConfig === 'string') {
- reader = readerConfig;
- }
- if (true) {
- console.log("Before registering reader: ", reader);
- }
- if (configuration.supplements) {
- supplements = configuration.supplements.map(function (supplement) {
- return new READERS[supplement]();
- });
- }
- _barcodeReaders.push(new READERS[reader](configuration, supplements));
- });
- if (true) {
- console.log("Registered Readers: " + _barcodeReaders.map(function (reader) {
- return JSON.stringify({ format: reader.FORMAT, config: reader.config });
- }).join(', '));
- }
- }
+ return InputStream;
+}();
- function initConfig() {
- if (true && typeof document !== 'undefined') {
- var i,
- vis = [{
- node: _canvas.dom.frequency,
- prop: config.debug.showFrequency
- }, {
- node: _canvas.dom.pattern,
- prop: config.debug.showPattern
- }];
-
- for (i = 0; i < vis.length; i++) {
- if (vis[i].prop === true) {
- vis[i].node.style.display = "block";
- } else {
- vis[i].node.style.display = "none";
- }
- }
- }
- }
+/***/ }),
- /**
- * extend the line on both ends
- * @param {Array} line
- * @param {Number} angle
- */
- function getExtendedLine(line, angle, ext) {
- function extendLine(amount) {
- var extension = {
- y: amount * Math.sin(angle),
- x: amount * Math.cos(angle)
- };
+/***/ "./src/input/live-stream.ts":
+/*!**********************************!*\
+ !*** ./src/input/live-stream.ts ***!
+ \**********************************/
+/*! exports provided: LiveStream */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- line[0].y -= extension.y;
- line[0].x -= extension.x;
- line[1].y += extension.y;
- line[1].x += extension.x;
- }
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LiveStream", function() { return LiveStream; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _video_stream__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./video-stream */ "./src/input/video-stream.ts");
- // check if inside image
- extendLine(ext);
- while (ext > 1 && (!inputImageWrapper.inImageWithBorder(line[0], 0) || !inputImageWrapper.inImageWithBorder(line[1], 0))) {
- ext -= Math.ceil(ext / 2);
- extendLine(-ext);
- }
- return line;
- }
- function getLine(box) {
- return [{
- x: (box[1][0] - box[0][0]) / 2 + box[0][0],
- y: (box[1][1] - box[0][1]) / 2 + box[0][1]
- }, {
- x: (box[3][0] - box[2][0]) / 2 + box[2][0],
- y: (box[3][1] - box[2][1]) / 2 + box[2][1]
- }];
- }
- function tryDecode(line) {
- var result = null,
- i,
- barcodeLine = __WEBPACK_IMPORTED_MODULE_0__bresenham__["a" /* default */].getBarcodeLine(inputImageWrapper, line[0], line[1]);
- if (true && config.debug.showFrequency) {
- __WEBPACK_IMPORTED_MODULE_1__common_image_debug__["a" /* default */].drawPath(line, { x: 'x', y: 'y' }, _canvas.ctx.overlay, { color: 'red', lineWidth: 3 });
- __WEBPACK_IMPORTED_MODULE_0__bresenham__["a" /* default */].debug.printFrequency(barcodeLine.line, _canvas.dom.frequency);
- }
- __WEBPACK_IMPORTED_MODULE_0__bresenham__["a" /* default */].toBinaryLine(barcodeLine);
- if (true && config.debug.showPattern) {
- __WEBPACK_IMPORTED_MODULE_0__bresenham__["a" /* default */].debug.printPattern(barcodeLine.line, _canvas.dom.pattern);
- }
+var LiveStream =
+/*#__PURE__*/
+function (_VideoStream) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default()(LiveStream, _VideoStream);
- for (i = 0; i < _barcodeReaders.length && result === null; i++) {
- result = _barcodeReaders[i].decodePattern(barcodeLine.line);
- }
- if (result === null) {
- return null;
- }
- return {
- codeResult: result,
- barcodeLine: barcodeLine
- };
- }
+ function LiveStream(video) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, LiveStream);
- /**
- * This method slices the given area apart and tries to detect a barcode-pattern
- * for each slice. It returns the decoded barcode, or null if nothing was found
- * @param {Array} box
- * @param {Array} line
- * @param {Number} lineAngle
- */
- function tryDecodeBruteForce(box, line, lineAngle) {
- var sideLength = Math.sqrt(Math.pow(box[1][0] - box[0][0], 2) + Math.pow(box[1][1] - box[0][1], 2)),
- i,
- slices = 16,
- result = null,
- dir,
- extension,
- xdir = Math.sin(lineAngle),
- ydir = Math.cos(lineAngle);
-
- for (i = 1; i < slices && result === null; i++) {
- // move line perpendicular to angle
- dir = sideLength / slices * i * (i % 2 === 0 ? -1 : 1);
- extension = {
- y: dir * xdir,
- x: dir * ydir
- };
- line[0].y += extension.x;
- line[0].x -= extension.y;
- line[1].y += extension.x;
- line[1].x -= extension.y;
+ video.setAttribute('autoplay', '');
+ return _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(LiveStream).call(this, video));
+ }
- result = tryDecode(line);
- }
- return result;
- }
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(LiveStream, [{
+ key: "ended",
+ get: function get() {
+ return false;
+ }
+ }]);
- function getLineLength(line) {
- return Math.sqrt(Math.pow(Math.abs(line[1].y - line[0].y), 2) + Math.pow(Math.abs(line[1].x - line[0].x), 2));
- }
+ return LiveStream;
+}(_video_stream__WEBPACK_IMPORTED_MODULE_5__["VideoStream"]);
- /**
- * With the help of the configured readers (Code128 or EAN) this function tries to detect a
- * valid barcode pattern within the given area.
- * @param {Object} box The area to search in
- * @returns {Object} the result {codeResult, line, angle, pattern, threshold}
- */
- function _decodeFromBoundingBox(box) {
- var line,
- lineAngle,
- ctx = _canvas.ctx.overlay,
- result,
- lineLength;
+/***/ }),
- if (true) {
- if (config.debug.drawBoundingBox && ctx) {
- __WEBPACK_IMPORTED_MODULE_1__common_image_debug__["a" /* default */].drawPath(box, { x: 0, y: 1 }, ctx, { color: "blue", lineWidth: 2 });
- }
- }
+/***/ "./src/input/video-stream.ts":
+/*!***********************************!*\
+ !*** ./src/input/video-stream.ts ***!
+ \***********************************/
+/*! exports provided: VideoStream, LiveStream */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- line = getLine(box);
- lineLength = getLineLength(line);
- lineAngle = Math.atan2(line[1].y - line[0].y, line[1].x - line[0].x);
- line = getExtendedLine(line, lineAngle, Math.floor(lineLength * 0.1));
- if (line === null) {
- return null;
- }
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "VideoStream", function() { return VideoStream; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LiveStream", function() { return LiveStream; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/assertThisInitialized */ "../../node_modules/@babel/runtime/helpers/assertThisInitialized.js");
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/get */ "../../node_modules/@babel/runtime/helpers/get.js");
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7__);
+/* harmony import */ var _input_stream__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./input-stream */ "./src/input/input-stream.ts");
- result = tryDecode(line);
- if (result === null) {
- result = tryDecodeBruteForce(box, line, lineAngle);
- }
- if (result === null) {
- return null;
- }
- if (true && result && config.debug.drawScanline && ctx) {
- __WEBPACK_IMPORTED_MODULE_1__common_image_debug__["a" /* default */].drawPath(line, { x: 'x', y: 'y' }, ctx, { color: 'red', lineWidth: 3 });
- }
- return {
- codeResult: result.codeResult,
- line: line,
- angle: lineAngle,
- pattern: result.barcodeLine.line,
- threshold: result.barcodeLine.threshold
- };
- }
- return {
- decodeFromBoundingBox: function decodeFromBoundingBox(box) {
- return _decodeFromBoundingBox(box);
- },
- decodeFromBoundingBoxes: function decodeFromBoundingBoxes(boxes) {
- var i,
- result,
- barcodes = [],
- multiple = config.multiple;
-
- for (i = 0; i < boxes.length; i++) {
- var box = boxes[i];
- result = _decodeFromBoundingBox(box) || {};
- result.box = box;
-
- if (multiple) {
- barcodes.push(result);
- } else if (result.codeResult) {
- return result;
- }
- }
- if (multiple) {
- return {
- barcodes: barcodes
- };
- }
- },
- setReaders: function setReaders(readers) {
- config.readers = readers;
- _barcodeReaders.length = 0;
- initReaders();
- }
- };
- }
-};
-/***/ }),
-/* 58 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__ = __webpack_require__(20);
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-var Bresenham = {};
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7___default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-var Slope = {
- DIR: {
- UP: 1,
- DOWN: -1
- }
-};
-/**
- * Scans a line of the given image from point p1 to p2 and returns a result object containing
- * gray-scale values (0-255) of the underlying pixels in addition to the min
- * and max values.
- * @param {Object} imageWrapper
- * @param {Object} p1 The start point {x,y}
- * @param {Object} p2 The end point {x,y}
- * @returns {line, min, max}
- */
-Bresenham.getBarcodeLine = function (imageWrapper, p1, p2) {
- var x0 = p1.x | 0,
- y0 = p1.y | 0,
- x1 = p2.x | 0,
- y1 = p2.y | 0,
- steep = Math.abs(y1 - y0) > Math.abs(x1 - x0),
- deltax,
- deltay,
- error,
- ystep,
- y,
- tmp,
- x,
- line = [],
- imageData = imageWrapper.data,
- width = imageWrapper.size.x,
- sum = 0,
- val,
- min = 255,
- max = 0;
- function read(a, b) {
- val = imageData[b * width + a];
- sum += val;
- min = val < min ? val : min;
- max = val > max ? val : max;
- line.push(val);
- }
+var VideoStream =
+/*#__PURE__*/
+function (_InputStream) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6___default()(VideoStream, _InputStream);
- if (steep) {
- tmp = x0;
- x0 = y0;
- y0 = tmp;
+ function VideoStream(video) {
+ var _this;
- tmp = x1;
- x1 = y1;
- y1 = tmp;
- }
- if (x0 > x1) {
- tmp = x0;
- x0 = x1;
- x1 = tmp;
-
- tmp = y0;
- y0 = y1;
- y1 = tmp;
- }
- deltax = x1 - x0;
- deltay = Math.abs(y1 - y0);
- error = deltax / 2 | 0;
- y = y0;
- ystep = y0 < y1 ? 1 : -1;
- for (x = x0; x < x1; x++) {
- if (steep) {
- read(y, x);
- } else {
- read(x, y);
- }
- error = error - deltay;
- if (error < 0) {
- y = y + ystep;
- error = error + deltax;
- }
- }
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, VideoStream);
- return {
- line: line,
- min: min,
- max: max
- };
-};
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default()(VideoStream).call(this));
-/**
- * Converts the result from getBarcodeLine into a binary representation
- * also considering the frequency and slope of the signal for more robust results
- * @param {Object} result {line, min, max}
- */
-Bresenham.toBinaryLine = function (result) {
- var min = result.min,
- max = result.max,
- line = result.line,
- slope,
- slope2,
- center = min + (max - min) / 2,
- extrema = [],
- currentDir,
- dir,
- threshold = (max - min) / 12,
- rThreshold = -threshold,
- i,
- j;
-
- // 1. find extrema
- currentDir = line[0] > center ? Slope.DIR.UP : Slope.DIR.DOWN;
- extrema.push({
- pos: 0,
- val: line[0]
- });
- for (i = 0; i < line.length - 2; i++) {
- slope = line[i + 1] - line[i];
- slope2 = line[i + 2] - line[i + 1];
- if (slope + slope2 < rThreshold && line[i + 1] < center * 1.5) {
- dir = Slope.DIR.DOWN;
- } else if (slope + slope2 > threshold && line[i + 1] > center * 0.5) {
- dir = Slope.DIR.UP;
- } else {
- dir = currentDir;
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_3___default()(_this), "_video", void 0);
- if (currentDir !== dir) {
- extrema.push({
- pos: i,
- val: line[i]
- });
- currentDir = dir;
- }
- }
- extrema.push({
- pos: line.length,
- val: line[line.length - 1]
- });
+ _this._video = video;
+ return _this;
+ }
- for (j = extrema[0].pos; j < extrema[1].pos; j++) {
- line[j] = line[j] > center ? 0 : 1;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(VideoStream, [{
+ key: "setAttribute",
+ value: function setAttribute(name, value) {
+ this._video.setAttribute(name, value);
+ }
+ }, {
+ key: "pause",
+ value: function pause() {
+ this._video.pause();
}
+ }, {
+ key: "play",
+ value: function play() {
+ this._video.play();
+ }
+ }, {
+ key: "addEventListener",
+ value: function addEventListener(event, listener, options) {
+ _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5___default()(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default()(VideoStream.prototype), "addEventListener", this).call(this, event, listener, options);
- // iterate over extrema and convert to binary based on avg between minmax
- for (i = 1; i < extrema.length - 1; i++) {
- if (extrema[i + 1].val > extrema[i].val) {
- threshold = extrema[i].val + (extrema[i + 1].val - extrema[i].val) / 3 * 2 | 0;
- } else {
- threshold = extrema[i + 1].val + (extrema[i].val - extrema[i + 1].val) / 3 | 0;
- }
+ if (this._eventNames.indexOf(event) === -1) {
+ this._video.addEventListener(event, listener, options);
+ }
+ }
+ }, {
+ key: "clearEventHandlers",
+ value: function clearEventHandlers() {
+ // TODO: come up with a way to remove video event handlers
+ // this._eventNames.forEach(eventName => {
+ // const handlers = this._eventHandlers.get(eventName);
+ // if (handlers && handlers.length > 0) {
+ // handlers.forEach(handler => this._video.removeEventListener(eventName, handler));
+ // }
+ // });
+ _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5___default()(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default()(VideoStream.prototype), "clearEventHandlers", this).call(this);
+ }
+ }, {
+ key: "trigger",
+ value: function trigger(eventName, argArray) {
+ if (eventName === 'canrecord') {
+ this._initSize();
+ }
- for (j = extrema[i].pos; j < extrema[i + 1].pos; j++) {
- line[j] = line[j] > threshold ? 0 : 1;
- }
+ _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5___default()(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default()(VideoStream.prototype), "trigger", this).call(this, eventName, argArray);
+ }
+ }, {
+ key: "getFrame",
+ value: function getFrame() {
+ return this._video;
+ }
+ }, {
+ key: "_initSize",
+ value: function _initSize() {
+ var width = this._video.videoWidth;
+ var height = this._video.videoHeight;
+ this._canvasWidth = this._calculatedWidth = this._config.size ? width > height ? this._config.size : width * this._config.size / height | 0 : width;
+ this._canvasHeight = this._calculatedHeight = this._config.size ? width > height ? height * this._config.size / width | 0 : this._config.size : height;
+ }
+ }, {
+ key: "realHeight",
+ get: function get() {
+ return this._video.videoHeight;
+ }
+ }, {
+ key: "realWidth",
+ get: function get() {
+ return this._video.videoWidth;
+ }
+ }, {
+ key: "config",
+ get: function get() {
+ return this._config;
+ },
+ set: function set(config) {
+ this._config = _objectSpread({}, config);
+ this._video.src = config.src || '';
+ }
+ }, {
+ key: "ended",
+ get: function get() {
+ return this._video.ended;
+ }
+ }, {
+ key: "currentTime",
+ set: function set(time) {
+ if (this._config.type !== 'LiveStream') {
+ this._video.currentTime = time;
+ }
}
+ }]);
- return {
- line: line,
- threshold: threshold
- };
-};
+ return VideoStream;
+}(_input_stream__WEBPACK_IMPORTED_MODULE_8__["InputStream"]);
+var LiveStream =
+/*#__PURE__*/
+function (_VideoStream) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6___default()(LiveStream, _VideoStream);
-/**
- * Used for development only
- */
-Bresenham.debug = {
- printFrequency: function printFrequency(line, canvas) {
- var i,
- ctx = canvas.getContext("2d");
- canvas.width = line.length;
- canvas.height = 256;
-
- ctx.beginPath();
- ctx.strokeStyle = "blue";
- for (i = 0; i < line.length; i++) {
- ctx.moveTo(i, 255);
- ctx.lineTo(i, 255 - line[i]);
- }
- ctx.stroke();
- ctx.closePath();
- },
+ function LiveStream(video) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, LiveStream);
- printPattern: function printPattern(line, canvas) {
- var ctx = canvas.getContext("2d"),
- i;
+ video.setAttribute('autoplay', '');
+ return _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default()(LiveStream).call(this, video));
+ }
- canvas.width = line.length;
- ctx.fillColor = "black";
- for (i = 0; i < line.length; i++) {
- if (line[i] === 1) {
- ctx.fillRect(i, 0, 1, 100);
- }
- }
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(LiveStream, [{
+ key: "ended",
+ get: function get() {
+ return false;
}
-};
+ }]);
-/* harmony default export */ __webpack_exports__["a"] = Bresenham;
+ return LiveStream;
+}(VideoStream);
/***/ }),
-/* 59 */
+
+/***/ "./src/locator/barcode-locator-utils.ts":
+/*!**********************************************!*\
+ !*** ./src/locator/barcode-locator-utils.ts ***!
+ \**********************************************/
+/*! exports provided: invert, transformWithMatrix, otsuThreshold, halfSample */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_pick__ = __webpack_require__(162);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_pick___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_pick__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_mediaDevices__ = __webpack_require__(52);
-/* unused harmony export pickConstraints */
-
-
-
-
-var facingMatching = {
- "user": /front/i,
- "environment": /back/i
-};
-
-var streamRef;
-
-function waitForVideo(video) {
- return new Promise(function (resolve, reject) {
- var attempts = 10;
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "invert", function() { return invert; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformWithMatrix", function() { return transformWithMatrix; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "otsuThreshold", function() { return otsuThreshold; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "halfSample", function() { return halfSample; });
+/**
+ * Invert matrix
+ * @param matrix the matrix to invert
+ * @returns the inverted matrix
+ */
+function invert(matrix) {
+ var a0 = matrix[0];
+ var a1 = matrix[1];
+ var a2 = matrix[2];
+ var a3 = matrix[3];
+ var determinant = a0 * a3 - a2 * a1;
+
+ if (!determinant) {
+ return null;
+ }
- function checkVideo() {
- if (attempts > 0) {
- if (video.videoWidth > 10 && video.videoHeight > 10) {
- if (true) {
- console.log(video.videoWidth + "px x " + video.videoHeight + "px");
- }
- resolve();
- } else {
- window.setTimeout(checkVideo, 500);
- }
- } else {
- reject('Unable to play video stream. Is webcam working?');
- }
- attempts--;
- }
- checkVideo();
- });
+ return new Float32Array([a3 / determinant, -a1 / determinant, -a2 / determinant, a0 / determinant]);
}
-
/**
- * Tries to attach the camera-stream to a given video-element
- * and calls the callback function when the content is ready
- * @param {Object} constraints
- * @param {Object} video
+ * Transforms the vector with a matrix
+ * @param { x, y } vector to transform
+ * @param matrix matrix to transform with
+ * @returns the transformed vector
*/
-function initCamera(video, constraints) {
- return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1_mediaDevices__["a" /* getUserMedia */])(constraints).then(function (stream) {
- return new Promise(function (resolve) {
- streamRef = stream;
- video.setAttribute("autoplay", true);
- video.setAttribute('muted', true);
- video.setAttribute('playsinline', true);
- video.srcObject = stream;
- video.addEventListener('loadedmetadata', function () {
- video.play();
- resolve();
- });
- });
- }).then(waitForVideo.bind(null, video));
-}
-function deprecatedConstraints(videoConstraints) {
- var normalized = __WEBPACK_IMPORTED_MODULE_0_lodash_pick___default()(videoConstraints, ["width", "height", "facingMode", "aspectRatio", "deviceId"]);
-
- if (typeof videoConstraints.minAspectRatio !== 'undefined' && videoConstraints.minAspectRatio > 0) {
- normalized.aspectRatio = videoConstraints.minAspectRatio;
- console.log("WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead");
- }
- if (typeof videoConstraints.facing !== 'undefined') {
- normalized.facingMode = videoConstraints.facing;
- console.log("WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'");
- }
- return normalized;
+function transformWithMatrix(_ref, matrix) {
+ var x = _ref.x,
+ y = _ref.y;
+ return {
+ x: matrix[0] * x + matrix[2] * y,
+ y: matrix[1] * x + matrix[3] * y
+ };
}
-function pickConstraints(videoConstraints) {
- var normalizedConstraints = {
- audio: false,
- video: deprecatedConstraints(videoConstraints)
- };
+function _computeHistogram(imageWrapper, bitsPerPixel) {
+ if (!bitsPerPixel) {
+ bitsPerPixel = 8;
+ }
- if (normalizedConstraints.video.deviceId && normalizedConstraints.video.facingMode) {
- delete normalizedConstraints.video.facingMode;
- }
- return Promise.resolve(normalizedConstraints);
-}
+ var imageData = imageWrapper.data;
+ var bitShift = 8 - bitsPerPixel;
+ var bucketCount = 1 << bitsPerPixel;
+ var histogram = new Int32Array(bucketCount);
-function enumerateVideoDevices() {
- return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1_mediaDevices__["b" /* enumerateDevices */])().then(function (devices) {
- return devices.filter(function (device) {
- return device.kind === 'videoinput';
- });
- });
-}
+ for (var i = imageData.length; i--;) {
+ histogram[imageData[i] >> bitShift]++;
+ }
-function getActiveTrack() {
- if (streamRef) {
- var tracks = streamRef.getVideoTracks();
- if (tracks && tracks.length) {
- return tracks[0];
- }
- }
+ return histogram;
}
-/* harmony default export */ __webpack_exports__["a"] = {
- request: function request(video, videoConstraints) {
- return pickConstraints(videoConstraints).then(initCamera.bind(null, video));
- },
- release: function release() {
- var tracks = streamRef && streamRef.getVideoTracks();
- if (tracks && tracks.length) {
- tracks[0].stop();
- }
- streamRef = null;
- },
- enumerateVideoDevices: enumerateVideoDevices,
- getActiveStreamLabel: function getActiveStreamLabel() {
- var track = getActiveTrack();
- return track ? track.label : '';
- },
- getActiveTrack: getActiveTrack
-};
+function _determineOtsuThreshold(imageWrapper, bitsPerPixel) {
+ if (!bitsPerPixel) {
+ bitsPerPixel = 8;
+ }
-/***/ }),
-/* 60 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ var bitShift = 8 - bitsPerPixel;
-"use strict";
-/* unused harmony export AvailableTags */
-/* harmony export (immutable) */ __webpack_exports__["a"] = findTagsInObjectURL;
-/* unused harmony export base64ToArrayBuffer */
-/* unused harmony export findTagsInBuffer */
-// Scraped from https://github.com/exif-js/exif-js
+ var hist = _computeHistogram(imageWrapper, bitsPerPixel);
-var ExifTags = { 0x0112: "orientation" };
-var AvailableTags = Object.keys(ExifTags).map(function (key) {
- return ExifTags[key];
-});
+ var vet = [0];
+ var max = (1 << bitsPerPixel) - 1;
-function findTagsInObjectURL(src) {
- var tags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : AvailableTags;
+ function px(init, end) {
+ var sum = 0;
- if (/^blob\:/i.test(src)) {
- return objectURLToBlob(src).then(readToBuffer).then(function (buffer) {
- return findTagsInBuffer(buffer, tags);
- });
+ for (var i = init; i <= end; i++) {
+ sum += hist[i];
}
- return Promise.resolve(null);
-}
-function base64ToArrayBuffer(dataUrl) {
- var base64 = dataUrl.replace(/^data\:([^\;]+)\;base64,/gmi, ''),
- binary = atob(base64),
- len = binary.length,
- buffer = new ArrayBuffer(len),
- view = new Uint8Array(buffer);
+ return sum;
+ }
+
+ function mx(init, end) {
+ var sum = 0;
- for (var i = 0; i < len; i++) {
- view[i] = binary.charCodeAt(i);
+ for (var i = init; i <= end; i++) {
+ sum += i * hist[i];
}
- return buffer;
-}
-
-function readToBuffer(blob) {
- return new Promise(function (resolve) {
- var fileReader = new FileReader();
- fileReader.onload = function (e) {
- return resolve(e.target.result);
- };
- fileReader.readAsArrayBuffer(blob);
- });
-}
-function objectURLToBlob(url) {
- return new Promise(function (resolve, reject) {
- var http = new XMLHttpRequest();
- http.open("GET", url, true);
- http.responseType = "blob";
- http.onreadystatechange = function () {
- if (http.readyState === XMLHttpRequest.DONE && (http.status === 200 || http.status === 0)) {
- resolve(this.response);
- }
- };
- http.onerror = reject;
- http.send();
- });
-}
+ return sum;
+ }
-function findTagsInBuffer(file) {
- var selectedTags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : AvailableTags;
+ for (var k = 1; k < max; k++) {
+ var p1 = px(0, k);
+ var p2 = px(k + 1, max);
+ var p12 = p1 * p2 || 1;
+ var m1 = mx(0, k) * p2;
+ var m2 = mx(k + 1, max) * p1;
+ var m12 = m1 - m2;
+ vet[k] = m12 * m12 / p12;
+ } // index of max element
- var dataView = new DataView(file),
- length = file.byteLength,
- exifTags = selectedTags.reduce(function (result, selectedTag) {
- var exifTag = Object.keys(ExifTags).filter(function (tag) {
- return ExifTags[tag] === selectedTag;
- })[0];
- if (exifTag) {
- result[exifTag] = selectedTag;
- }
- return result;
- }, {});
- var offset = 2,
- marker = void 0;
- if (dataView.getUint8(0) !== 0xFF || dataView.getUint8(1) !== 0xD8) {
- return false;
- }
+ var threshold = vet.reduce(function (maxIndex, item, index, array) {
+ return item > array[maxIndex] ? index : maxIndex;
+ }, 0);
+ return threshold << bitShift;
+}
- while (offset < length) {
- if (dataView.getUint8(offset) !== 0xFF) {
- return false;
- }
+function otsuThreshold(imageWrapper, targetWrapper) {
+ var threshold = _determineOtsuThreshold(imageWrapper);
- marker = dataView.getUint8(offset + 1);
- if (marker === 0xE1) {
- return readEXIFData(dataView, offset + 4, exifTags);
- } else {
- offset += 2 + dataView.getUint16(offset + 2);
- }
- }
+ var targetData = targetWrapper.data;
+ imageWrapper.data.forEach(function (value, index) {
+ targetData[index] = value < threshold ? 1 : 0;
+ });
+ return threshold;
}
+/**
+ * @param imageWrapper input image to be sampled
+ * @param outImageWrapper {ImageWrapper} to be stored in
+ */
-function readEXIFData(file, start, exifTags) {
- if (getStringFromBuffer(file, start, 4) !== "Exif") {
- return false;
+function halfSample(imageWrapper, outImageWrapper) {
+ var image = imageWrapper.data;
+ var width = imageWrapper.size.x;
+ var outImage = outImageWrapper.data;
+ var endIndex = image.length;
+ var outWidth = width >> 1;
+ var topRowIndex = 0;
+ var bottomRowIndex = width;
+ var outImgIndex = 0;
+
+ while (bottomRowIndex < endIndex) {
+ for (var i = 0; i < outWidth; i++) {
+ outImage[outImgIndex] = image[topRowIndex] + image[topRowIndex + 1] + image[bottomRowIndex] + image[bottomRowIndex + 1] >> 2;
+ outImgIndex++;
+ topRowIndex += 2;
+ bottomRowIndex += 2;
}
- var tiffOffset = start + 6;
- var bigEnd = void 0,
- tags = void 0;
+ topRowIndex += width;
+ bottomRowIndex += width;
+ }
+}
- if (file.getUint16(tiffOffset) === 0x4949) {
- bigEnd = false;
- } else if (file.getUint16(tiffOffset) === 0x4D4D) {
- bigEnd = true;
- } else {
- return false;
- }
+/***/ }),
- if (file.getUint16(tiffOffset + 2, !bigEnd) !== 0x002A) {
- return false;
- }
+/***/ "./src/locator/barcode-locator.ts":
+/*!****************************************!*\
+ !*** ./src/locator/barcode-locator.ts ***!
+ \****************************************/
+/*! exports provided: BarcodeLocator */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- var firstIFDOffset = file.getUint32(tiffOffset + 4, !bigEnd);
- if (firstIFDOffset < 0x00000008) {
- return false;
- }
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BarcodeLocator", function() { return BarcodeLocator; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _common_cluster__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/cluster */ "./src/common/cluster.ts");
+/* harmony import */ var _common_hsv2rgb__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../common/hsv2rgb */ "./src/common/hsv2rgb.ts");
+/* harmony import */ var _common_image_debug__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../common/image-debug */ "./src/common/image-debug.ts");
+/* harmony import */ var _common_image_wrapper__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../common/image-wrapper */ "./src/common/image-wrapper.ts");
+/* harmony import */ var _input_input_stream_utils__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../input/input-stream-utils */ "./src/input/input-stream-utils.ts");
+/* harmony import */ var _barcode_locator_utils__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./barcode-locator-utils */ "./src/locator/barcode-locator-utils.ts");
+/* harmony import */ var _rasterizer__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./rasterizer */ "./src/locator/rasterizer.ts");
+/* harmony import */ var _skeletonizer__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./skeletonizer */ "./src/locator/skeletonizer.js");
+/* harmony import */ var _tracer__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./tracer */ "./src/locator/tracer.ts");
- tags = readTags(file, tiffOffset, tiffOffset + firstIFDOffset, exifTags, bigEnd);
- return tags;
-}
-function readTags(file, tiffStart, dirStart, strings, bigEnd) {
- var entries = file.getUint16(dirStart, !bigEnd),
- tags = {};
- for (var i = 0; i < entries; i++) {
- var entryOffset = dirStart + i * 12 + 2,
- tag = strings[file.getUint16(entryOffset, !bigEnd)];
- if (tag) {
- tags[tag] = readTagValue(file, entryOffset, tiffStart, dirStart, bigEnd);
- }
- }
- return tags;
-}
-function readTagValue(file, entryOffset, tiffStart, dirStart, bigEnd) {
- var type = file.getUint16(entryOffset + 2, !bigEnd),
- numValues = file.getUint32(entryOffset + 4, !bigEnd);
- switch (type) {
- case 3:
- if (numValues === 1) {
- return file.getUint16(entryOffset + 8, !bigEnd);
- }
- }
-}
-function getStringFromBuffer(buffer, start, length) {
- var outstr = "";
- for (var n = start; n < start + length; n++) {
- outstr += String.fromCharCode(buffer.getUint8(n));
- }
- return outstr;
-}
-/***/ }),
-/* 61 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__common_cv_utils__ = __webpack_require__(19);
-var TO_RADIANS = Math.PI / 180;
-function adjustCanvasSize(canvas, targetSize) {
- if (canvas.width !== targetSize.x) {
- if (true) {
- console.log("WARNING: canvas-size needs to be adjusted");
- }
- canvas.width = targetSize.x;
- }
- if (canvas.height !== targetSize.y) {
- if (true) {
- console.log("WARNING: canvas-size needs to be adjusted");
- }
- canvas.height = targetSize.y;
- }
-}
-var FrameGrabber = {};
-
-FrameGrabber.create = function (inputStream, canvas) {
- var _that = {},
- _streamConfig = inputStream.getConfig(),
- _video_size = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__common_cv_utils__["b" /* imageRef */])(inputStream.getRealWidth(), inputStream.getRealHeight()),
- _canvasSize = inputStream.getCanvasSize(),
- _size = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__common_cv_utils__["b" /* imageRef */])(inputStream.getWidth(), inputStream.getHeight()),
- topRight = inputStream.getTopRight(),
- _sx = topRight.x,
- _sy = topRight.y,
- _canvas,
- _ctx = null,
- _data = null;
-
- _canvas = canvas ? canvas : document.createElement("canvas");
- _canvas.width = _canvasSize.x;
- _canvas.height = _canvasSize.y;
- _ctx = _canvas.getContext("2d");
- _data = new Uint8Array(_size.x * _size.y);
- if (true) {
- console.log("FrameGrabber", JSON.stringify({
- size: _size,
- topRight: topRight,
- videoSize: _video_size,
- canvasSize: _canvasSize
- }));
- }
+var MomentSimilarityThreshold = 0.9;
+var BarcodeLocator =
+/*#__PURE__*/
+function () {
+ function BarcodeLocator(inputImageWrapper, config) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, BarcodeLocator);
- /**
- * Uses the given array as frame-buffer
- */
- _that.attachData = function (data) {
- _data = data;
- };
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_config", void 0);
- /**
- * Returns the used frame-buffer
- */
- _that.getData = function () {
- return _data;
- };
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_inputImageWrapper", void 0);
- /**
- * Fetches a frame from the input-stream and puts into the frame-buffer.
- * The image-data is converted to gray-scale and then half-sampled if configured.
- */
- _that.grab = function () {
- var doHalfSample = _streamConfig.halfSample,
- frame = inputStream.getFrame(),
- drawable = frame,
- drawAngle = 0,
- ctxData;
- if (drawable) {
- adjustCanvasSize(_canvas, _canvasSize);
- if (_streamConfig.type === 'ImageStream') {
- drawable = frame.img;
- if (frame.tags && frame.tags.orientation) {
- switch (frame.tags.orientation) {
- case 6:
- drawAngle = 90 * TO_RADIANS;
- break;
- case 8:
- drawAngle = -90 * TO_RADIANS;
- break;
- }
- }
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_currentImageWrapper", void 0);
- if (drawAngle !== 0) {
- _ctx.translate(_canvasSize.x / 2, _canvasSize.y / 2);
- _ctx.rotate(drawAngle);
- _ctx.drawImage(drawable, -_canvasSize.y / 2, -_canvasSize.x / 2, _canvasSize.y, _canvasSize.x);
- _ctx.rotate(-drawAngle);
- _ctx.translate(-_canvasSize.x / 2, -_canvasSize.y / 2);
- } else {
- _ctx.drawImage(drawable, 0, 0, _canvasSize.x, _canvasSize.y);
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_skelImageWrapper", void 0);
- ctxData = _ctx.getImageData(_sx, _sy, _size.x, _size.y).data;
- if (doHalfSample) {
- __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__common_cv_utils__["c" /* grayAndHalfSampleFromCanvasData */])(ctxData, _size, _data);
- } else {
- __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__common_cv_utils__["d" /* computeGray */])(ctxData, _data, _streamConfig);
- }
- return true;
- } else {
- return false;
- }
- };
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_subImageWrapper", void 0);
- _that.getSize = function () {
- return _size;
- };
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_labelImageWrapper", void 0);
- return _that;
-};
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_binaryImageWrapper", void 0);
-/* harmony default export */ __webpack_exports__["a"] = FrameGrabber;
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_patchGrid", void 0);
-/***/ }),
-/* 62 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_patchLabelGrid", void 0);
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__exif_helper__ = __webpack_require__(60);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_imageToPatchGrid", void 0);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_patchSize", void 0);
-var ImageLoader = {};
-ImageLoader.load = function (directory, callback, offset, size, sequence) {
- var htmlImagesSrcArray = new Array(size),
- htmlImagesArray = new Array(htmlImagesSrcArray.length),
- i,
- img,
- num;
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_binaryContext", void 0);
- if (sequence === false) {
- htmlImagesSrcArray[0] = directory;
- } else {
- for (i = 0; i < htmlImagesSrcArray.length; i++) {
- num = offset + i;
- htmlImagesSrcArray[i] = directory + "image-" + ("00" + num).slice(-3) + ".jpg";
- }
- }
- htmlImagesArray.notLoaded = [];
- htmlImagesArray.addImage = function (image) {
- htmlImagesArray.notLoaded.push(image);
- };
- htmlImagesArray.loaded = function (loadedImg) {
- var notloadedImgs = htmlImagesArray.notLoaded;
- for (var x = 0; x < notloadedImgs.length; x++) {
- if (notloadedImgs[x] === loadedImg) {
- notloadedImgs.splice(x, 1);
- for (var y = 0; y < htmlImagesSrcArray.length; y++) {
- var imgName = htmlImagesSrcArray[y].substr(htmlImagesSrcArray[y].lastIndexOf("/"));
- if (loadedImg.src.lastIndexOf(imgName) !== -1) {
- htmlImagesArray[y] = { img: loadedImg };
- break;
- }
- }
- break;
- }
- }
- if (notloadedImgs.length === 0) {
- if (true) {
- console.log("Images loaded");
- }
- if (sequence === false) {
- __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__exif_helper__["a" /* findTagsInObjectURL */])(directory, ['orientation']).then(function (tags) {
- htmlImagesArray[0].tags = tags;
- callback(htmlImagesArray);
- }).catch(function (e) {
- console.log(e);
- callback(htmlImagesArray);
- });
- } else {
- callback(htmlImagesArray);
- }
- }
- };
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_numPatches", void 0);
- for (i = 0; i < htmlImagesSrcArray.length; i++) {
- img = new Image();
- htmlImagesArray.addImage(img);
- addOnloadHandler(img, htmlImagesArray);
- img.src = htmlImagesSrcArray[i];
- }
-};
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_skeletonizer", void 0);
-function addOnloadHandler(img, htmlImagesArray) {
- img.onload = function () {
- htmlImagesArray.loaded(this);
+ this._config = config;
+ this._inputImageWrapper = inputImageWrapper;
+ this._numPatches = {
+ x: 0,
+ y: 0
};
-}
-/* harmony default export */ __webpack_exports__["a"] = ImageLoader;
+ this._initBuffers();
-/***/ }),
-/* 63 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ this._initCanvas();
+ }
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__image_loader__ = __webpack_require__(62);
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(BarcodeLocator, [{
+ key: "locate",
+ value: function locate() {
+ if (this._config.halfSample) {
+ Object(_barcode_locator_utils__WEBPACK_IMPORTED_MODULE_8__["halfSample"])(this._inputImageWrapper, this._currentImageWrapper);
+ }
+ this._binarizeImage();
-var InputStream = {};
-InputStream.createVideoStream = function (video) {
- var that = {},
- _config = null,
- _eventNames = ['canrecord', 'ended'],
- _eventHandlers = {},
- _calculatedWidth,
- _calculatedHeight,
- _topRight = { x: 0, y: 0 },
- _canvasSize = { x: 0, y: 0 };
+ var patchesFound = this._findPatches(); // return unless 5% or more patches are found
- function initSize() {
- var width = video.videoWidth,
- height = video.videoHeight;
- _calculatedWidth = _config.size ? width / height > 1 ? _config.size : Math.floor(width / height * _config.size) : width;
- _calculatedHeight = _config.size ? width / height > 1 ? Math.floor(height / width * _config.size) : _config.size : height;
+ if (patchesFound.length < this._numPatches.x * this._numPatches.y * 0.05) {
+ return null;
+ } // rasterize area by comparing angular similarity;
- _canvasSize.x = _calculatedWidth;
- _canvasSize.y = _calculatedHeight;
- }
- that.getRealWidth = function () {
- return video.videoWidth;
- };
+ var maxLabel = this._rasterizeAngularSimilarity(patchesFound);
- that.getRealHeight = function () {
- return video.videoHeight;
- };
+ if (maxLabel < 1) {
+ return null;
+ } // search for area with the most patches (biggest connected area)
- that.getWidth = function () {
- return _calculatedWidth;
- };
- that.getHeight = function () {
- return _calculatedHeight;
- };
+ var topLabels = this._findBiggestConnectedAreas(maxLabel);
- that.setWidth = function (width) {
- _calculatedWidth = width;
- };
+ if (topLabels.length === 0) {
+ return null;
+ }
- that.setHeight = function (height) {
- _calculatedHeight = height;
- };
+ var boxes = this._findBoxes(topLabels, maxLabel);
- that.setInputStream = function (config) {
- _config = config;
- video.src = typeof config.src !== 'undefined' ? config.src : '';
- };
+ return boxes;
+ }
+ }, {
+ key: "_initBuffers",
+ value: function _initBuffers() {
+ if (this._config.halfSample) {
+ this._currentImageWrapper = new _common_image_wrapper__WEBPACK_IMPORTED_MODULE_6__["ImageWrapper"]({
+ x: this._inputImageWrapper.size.x / 2 | 0,
+ y: this._inputImageWrapper.size.y / 2 | 0
+ });
+ } else {
+ this._currentImageWrapper = this._inputImageWrapper;
+ }
- that.ended = function () {
- return video.ended;
- };
+ this._patchSize = Object(_input_input_stream_utils__WEBPACK_IMPORTED_MODULE_7__["calculatePatchSize"])(this._config.patchSize, this._currentImageWrapper.size);
+ this._numPatches.x = this._currentImageWrapper.size.x / this._patchSize.x | 0;
+ this._numPatches.y = this._currentImageWrapper.size.y / this._patchSize.y | 0;
+ this._binaryImageWrapper = new _common_image_wrapper__WEBPACK_IMPORTED_MODULE_6__["ImageWrapper"](this._currentImageWrapper.size, undefined, Uint8Array, false);
+ this._labelImageWrapper = new _common_image_wrapper__WEBPACK_IMPORTED_MODULE_6__["ImageWrapper"](this._patchSize, undefined, Array, true);
+ var skeletonImageData = new ArrayBuffer(64 * 1024);
+ this._subImageWrapper = new _common_image_wrapper__WEBPACK_IMPORTED_MODULE_6__["ImageWrapper"](this._patchSize, new Uint8Array(skeletonImageData, 0, this._patchSize.x * this._patchSize.y));
+ this._skelImageWrapper = new _common_image_wrapper__WEBPACK_IMPORTED_MODULE_6__["ImageWrapper"](this._patchSize, new Uint8Array(skeletonImageData, this._patchSize.x * this._patchSize.y * 3, this._patchSize.x * this._patchSize.y), undefined, true);
+ this._skeletonizer = Object(_skeletonizer__WEBPACK_IMPORTED_MODULE_10__["default"])(typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : global, {
+ size: this._patchSize.x
+ }, skeletonImageData);
+ var size = {
+ x: this._currentImageWrapper.size.x / this._subImageWrapper.size.x | 0,
+ y: this._currentImageWrapper.size.y / this._subImageWrapper.size.y | 0
+ };
+ this._patchLabelGrid = new _common_image_wrapper__WEBPACK_IMPORTED_MODULE_6__["ImageWrapper"](size, undefined, Int32Array, true);
+ this._patchGrid = new _common_image_wrapper__WEBPACK_IMPORTED_MODULE_6__["ImageWrapper"](size, undefined, undefined, true);
+ this._imageToPatchGrid = new Array(this._patchLabelGrid.data.length);
+ }
+ }, {
+ key: "_initCanvas",
+ value: function _initCanvas() {
+ if (this._config.useWorker || typeof document === 'undefined') {
+ return;
+ }
- that.getConfig = function () {
- return _config;
- };
+ var canvas = document.createElement('canvas');
+ canvas.className = 'binaryBuffer';
+ canvas.width = this._binaryImageWrapper.size.x;
+ canvas.height = this._binaryImageWrapper.size.y;
- that.setAttribute = function (name, value) {
- video.setAttribute(name, value);
- };
+ if ( true && this._config.debug && this._config.debug.showCanvas) {
+ document.querySelector('#debug').appendChild(canvas);
+ }
- that.pause = function () {
- video.pause();
- };
+ this._binaryContext = canvas.getContext('2d');
+ }
+ /**
+ * Creates a bounding box which encloses all the given patches
+ * @returns The minimal bounding box
+ */
- that.play = function () {
- video.play();
- };
+ }, {
+ key: "_boxFromPatches",
+ value: function _boxFromPatches(patches) {
+ var _this = this;
- that.setCurrentTime = function (time) {
- if (_config.type !== "LiveStream") {
- video.currentTime = time;
- }
- };
+ var debug = true && this._config.debug;
+ var averageRad = patches.reduce(function (sum, _ref) {
+ var pos = _ref.pos,
+ rad = _ref.rad;
- that.addEventListener = function (event, f, bool) {
- if (_eventNames.indexOf(event) !== -1) {
- if (!_eventHandlers[event]) {
- _eventHandlers[event] = [];
- }
- _eventHandlers[event].push(f);
- } else {
- video.addEventListener(event, f, bool);
+ if (debug && debug.showPatches) {
+ // draw all patches which are to be taken into consideration
+ _this._drawRect(pos, _this._subImageWrapper.size, 'red', 1);
}
- };
- that.clearEventHandlers = function () {
- _eventNames.forEach(function (eventName) {
- var handlers = _eventHandlers[eventName];
- if (handlers && handlers.length > 0) {
- handlers.forEach(function (handler) {
- video.removeEventListener(eventName, handler);
- });
- }
- });
- };
+ return sum + rad;
+ }, 0) / patches.length;
+ averageRad = (averageRad * 180 / Math.PI + 90) % 180 - 90;
- that.trigger = function (eventName, args) {
- var j,
- handlers = _eventHandlers[eventName];
+ if (averageRad < 0) {
+ averageRad += 180;
+ }
+
+ averageRad = (180 - averageRad) * Math.PI / 180;
+ var cos = Math.cos(averageRad);
+ var sin = Math.sin(averageRad);
+ var matrix = new Float32Array([cos, sin, -sin, cos]);
+ var inverseMatrix = Object(_barcode_locator_utils__WEBPACK_IMPORTED_MODULE_8__["invert"])(matrix); // iterate over patches and rotate by angle
- if (eventName === 'canrecord') {
- initSize();
+ patches.forEach(function (_ref2) {
+ var box = _ref2.box;
+
+ for (var j = 0; j < 4; j++) {
+ box[j] = Object(_barcode_locator_utils__WEBPACK_IMPORTED_MODULE_8__["transformWithMatrix"])(box[j], matrix);
}
- if (handlers && handlers.length > 0) {
- for (j = 0; j < handlers.length; j++) {
- handlers[j].apply(that, args);
- }
+
+ if (debug && debug.boxFromPatches.showTransformed) {
+ _this._drawPath(box, '#99ff00', 2);
}
- };
+ });
+ var minX = this._binaryImageWrapper.size.x;
+ var minY = this._binaryImageWrapper.size.y;
+ var maxX = -minX;
+ var maxY = -minY; // find bounding box
- that.setTopRight = function (topRight) {
- _topRight.x = topRight.x;
- _topRight.y = topRight.y;
- };
+ patches.forEach(function (_ref3) {
+ var box = _ref3.box;
+ box.forEach(function (_ref4) {
+ var x = _ref4.x,
+ y = _ref4.y;
- that.getTopRight = function () {
- return _topRight;
- };
+ if (x < minX) {
+ minX = x;
+ }
- that.setCanvasSize = function (size) {
- _canvasSize.x = size.x;
- _canvasSize.y = size.y;
- };
+ if (x > maxX) {
+ maxX = x;
+ }
- that.getCanvasSize = function () {
- return _canvasSize;
- };
+ if (y < minY) {
+ minY = y;
+ }
- that.getFrame = function () {
- return video;
- };
+ if (y > maxY) {
+ maxY = y;
+ }
+ });
+ });
+ var box = [{
+ x: minX,
+ y: minY
+ }, {
+ x: maxX,
+ y: minY
+ }, {
+ x: maxX,
+ y: maxY
+ }, {
+ x: minX,
+ y: maxY
+ }];
+
+ if (debug && debug.boxFromPatches.showTransformedBox) {
+ this._drawPath(box, '#ff0000', 2);
+ } // reverse rotation
+
+
+ box = box.map(function (vertex) {
+ return Object(_barcode_locator_utils__WEBPACK_IMPORTED_MODULE_8__["transformWithMatrix"])(vertex, inverseMatrix);
+ });
+
+ if (debug && debug.boxFromPatches.showBB) {
+ this._drawPath(box, '#ff0000', 2);
+ }
- return that;
-};
+ if (this._config.halfSample) {
+ // scale
+ box = box.map(function (_ref5) {
+ var x = _ref5.x,
+ y = _ref5.y;
+ return {
+ x: x * 2,
+ y: y *= 2
+ };
+ });
+ }
-InputStream.createLiveStream = function (video) {
- video.setAttribute("autoplay", true);
- var that = InputStream.createVideoStream(video);
+ return box;
+ }
+ /**
+ * Creates a binary image of the current image
+ */
- that.ended = function () {
- return false;
- };
+ }, {
+ key: "_binarizeImage",
+ value: function _binarizeImage() {
+ Object(_barcode_locator_utils__WEBPACK_IMPORTED_MODULE_8__["otsuThreshold"])(this._currentImageWrapper, this._binaryImageWrapper);
- return that;
-};
+ this._binaryImageWrapper.zeroBorder();
-InputStream.createImageStream = function () {
- var that = {};
- var _config = null;
-
- var width = 0,
- height = 0,
- frameIdx = 0,
- paused = true,
- loaded = false,
- imgArray = null,
- size = 0,
- offset = 1,
- baseUrl = null,
- ended = false,
- calculatedWidth,
- calculatedHeight,
- _eventNames = ['canrecord', 'ended'],
- _eventHandlers = {},
- _topRight = { x: 0, y: 0 },
- _canvasSize = { x: 0, y: 0 };
-
- function loadImages() {
- loaded = false;
- __WEBPACK_IMPORTED_MODULE_0__image_loader__["a" /* default */].load(baseUrl, function (imgs) {
- imgArray = imgs;
- if (imgs[0].tags && imgs[0].tags.orientation) {
- switch (imgs[0].tags.orientation) {
- case 6:
- case 8:
- width = imgs[0].img.height;
- height = imgs[0].img.width;
- break;
- default:
- width = imgs[0].img.width;
- height = imgs[0].img.height;
- }
- } else {
- width = imgs[0].img.width;
- height = imgs[0].img.height;
- }
- calculatedWidth = _config.size ? width / height > 1 ? _config.size : Math.floor(width / height * _config.size) : width;
- calculatedHeight = _config.size ? width / height > 1 ? Math.floor(height / width * _config.size) : _config.size : height;
- _canvasSize.x = calculatedWidth;
- _canvasSize.y = calculatedHeight;
- loaded = true;
- frameIdx = 0;
- setTimeout(function () {
- publishEvent("canrecord", []);
- }, 0);
- }, offset, size, _config.sequence);
- }
-
- function publishEvent(eventName, args) {
- var j,
- handlers = _eventHandlers[eventName];
-
- if (handlers && handlers.length > 0) {
- for (j = 0; j < handlers.length; j++) {
- handlers[j].apply(that, args);
- }
- }
+ if ( true && this._config.debug && this._config.debug.showCanvas) {
+ this._binaryImageWrapper.show(this._binaryContext, 255);
+ }
}
+ /**
+ * Iterate over the entire image, extract patches
+ */
- that.trigger = publishEvent;
-
- that.getWidth = function () {
- return calculatedWidth;
- };
+ }, {
+ key: "_findPatches",
+ value: function _findPatches() {
+ var debug = true && this._config.debug;
+ var patchesFound = new Array();
- that.getHeight = function () {
- return calculatedHeight;
- };
+ for (var i = 0; i < this._numPatches.x; i++) {
+ for (var j = 0; j < this._numPatches.y; j++) {
+ var x = this._subImageWrapper.size.x * i;
+ var y = this._subImageWrapper.size.y * j; // seperate parts
- that.setWidth = function (newWidth) {
- calculatedWidth = newWidth;
- };
+ this._skeletonize(x, y); // Rasterize, find individual bars
- that.setHeight = function (newHeight) {
- calculatedHeight = newHeight;
- };
- that.getRealWidth = function () {
- return width;
- };
+ this._skelImageWrapper.zeroBorder();
- that.getRealHeight = function () {
- return height;
- };
+ this._labelImageWrapper.data.fill(0);
- that.setInputStream = function (stream) {
- _config = stream;
- if (stream.sequence === false) {
- baseUrl = stream.src;
- size = 1;
- } else {
- baseUrl = stream.src;
- size = stream.length;
- }
- loadImages();
- };
+ var rasterizer = new _rasterizer__WEBPACK_IMPORTED_MODULE_9__["Rasterizer"](this._skelImageWrapper, this._labelImageWrapper);
+ var rasterResult = rasterizer.rasterize(0);
- that.ended = function () {
- return ended;
- };
+ if (debug && debug.showLabels) {
+ this._labelImageWrapper.overlay(this._binaryContext, 360 / rasterResult.count | 0, x, y);
+ } // calculate moments from the skeletonized patch
- that.setAttribute = function () {};
- that.getConfig = function () {
- return _config;
- };
+ var moments = this._labelImageWrapper.moments(rasterResult.count); // extract eligible patches
- that.pause = function () {
- paused = true;
- };
- that.play = function () {
- paused = false;
- };
+ var patch = this._describePatch(moments, j * this._numPatches.x + i, x, y);
- that.setCurrentTime = function (time) {
- frameIdx = time;
- };
+ if (patch) {
+ patchesFound.push(patch);
- that.addEventListener = function (event, f) {
- if (_eventNames.indexOf(event) !== -1) {
- if (!_eventHandlers[event]) {
- _eventHandlers[event] = [];
+ if (debug && debug.showFoundPatches) {
+ this._drawRect(patch.pos, this._subImageWrapper.size, '#99ff00', 2);
}
- _eventHandlers[event].push(f);
+ }
}
- };
+ }
- that.setTopRight = function (topRight) {
- _topRight.x = topRight.x;
- _topRight.y = topRight.y;
- };
+ return patchesFound;
+ }
+ /**
+ * Finds those connected areas which contain at least 6 patches
+ * and returns them ordered DESC by the number of contained patches
+ * @param maxLabel
+ */
- that.getTopRight = function () {
- return _topRight;
- };
+ }, {
+ key: "_findBiggestConnectedAreas",
+ value: function _findBiggestConnectedAreas(maxLabel) {
+ var labelHist = new Array(maxLabel).fill(0);
- that.setCanvasSize = function (canvasSize) {
- _canvasSize.x = canvasSize.x;
- _canvasSize.y = canvasSize.y;
- };
+ this._patchLabelGrid.data.forEach(function (data) {
+ if (data > 0) {
+ labelHist[data - 1]++;
+ }
+ }); // extract top areas with at least 6 patches present
- that.getCanvasSize = function () {
- return _canvasSize;
- };
- that.getFrame = function () {
- var frame;
+ var topLabels = labelHist.map(function (value, index) {
+ return {
+ value: value,
+ index: index
+ };
+ }).filter(function (_ref6) {
+ var value = _ref6.value;
+ return value >= 5;
+ }).sort(function (a, b) {
+ return b.value - a.value;
+ }).map(function (_ref7) {
+ var index = _ref7.index;
+ return index + 1;
+ });
+ return topLabels;
+ }
+ /**
+ *
+ */
+
+ }, {
+ key: "_findBoxes",
+ value: function _findBoxes(topLabels, maxLabel) {
+ var _this2 = this;
- if (!loaded) {
- return null;
- }
- if (!paused) {
- frame = imgArray[frameIdx];
- if (frameIdx < size - 1) {
- frameIdx++;
- } else {
- setTimeout(function () {
- ended = true;
- publishEvent("ended", []);
- }, 0);
- }
- }
- return frame;
- };
+ var boxes = new Array();
+ var showRemainingPatchLabels = true && this._config.debug && this._config.debug.showRemainingPatchLabels;
+ topLabels.forEach(function (label) {
+ var patches = new Array();
- return that;
-};
+ _this2._patchLabelGrid.data.forEach(function (data, index) {
+ if (data === label) {
+ patches.push(_this2._imageToPatchGrid[index]);
+ }
+ });
-/* harmony default export */ __webpack_exports__["a"] = InputStream;
+ var box = _this2._boxFromPatches(patches);
-/***/ }),
-/* 64 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ if (box) {
+ boxes.push(box);
-"use strict";
-/* WEBPACK VAR INJECTION */(function(global) {/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__ = __webpack_require__(20);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_cv_utils__ = __webpack_require__(19);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__common_array_helper__ = __webpack_require__(3);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__common_image_debug__ = __webpack_require__(9);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__rasterizer__ = __webpack_require__(65);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__tracer__ = __webpack_require__(30);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__skeletonizer__ = __webpack_require__(66);
+ if (showRemainingPatchLabels) {
+ // draw patch-labels if requested
+ var hsv = [label / (maxLabel + 1) * 360, 1, 1];
+ var rgb = [0, 0, 0];
+ Object(_common_hsv2rgb__WEBPACK_IMPORTED_MODULE_4__["hsv2rgb"])(hsv, rgb);
+ var color = "rgb(".concat(rgb.join(','), ")");
+ patches.forEach(function (_ref8) {
+ var pos = _ref8.pos;
+ return _this2._drawRect(pos, _this2._subImageWrapper.size, color, 2);
+ });
+ }
+ }
+ });
+ return boxes;
+ }
+ /**
+ * Find similar moments (via cluster)
+ * @param moments
+ */
+ }, {
+ key: "_similarMoments",
+ value: function _similarMoments(moments) {
+ var clusters = _common_cluster__WEBPACK_IMPORTED_MODULE_3__["Cluster"].clusterize(moments, MomentSimilarityThreshold);
+ var topCluster = clusters.reduce(function (top, item) {
+ var count = item.moments.length;
+ return count > top.count ? {
+ item: item,
+ count: count
+ } : top;
+ }, {
+ item: {
+ moments: []
+ },
+ count: 0
+ });
+ var result = topCluster.item.moments;
+ return result;
+ }
+ }, {
+ key: "_skeletonize",
+ value: function _skeletonize(x, y) {
+ this._binaryImageWrapper.subImageAsCopy(this._subImageWrapper, x, y);
+ this._skeletonizer.skeletonize(); // Show skeleton if requested
+ if ( true && this._config.debug && this._config.debug.showSkeleton) {
+ this._skelImageWrapper.overlay(this._binaryContext, 360, x, y);
+ }
+ }
+ /**
+ * Extracts and describes those patches which seem to contain a barcode pattern
+ * @param moments
+ * @param index
+ * @param x
+ * @param y
+ * @returns list of patches
+ */
+ }, {
+ key: "_describePatch",
+ value: function _describePatch(moments, index, x, y) {
+ if (moments.length > 1) {
+ var minComponentWeight = Math.ceil(this._patchSize.x / 3); // only collect moments which area covers at least minComponentWeight pixels
+ var eligibleMoments = moments.filter(function (moment) {
+ return moment.m00 > minComponentWeight;
+ }); // if at least 2 moments are found which have at least minComponentWeights covered
-var vec2 = {
- clone: __webpack_require__(7),
- dot: __webpack_require__(32),
- scale: __webpack_require__(81),
- transformMat2: __webpack_require__(82)
-};
-var mat2 = {
- copy: __webpack_require__(78),
- create: __webpack_require__(79),
- invert: __webpack_require__(80)
-};
+ if (eligibleMoments.length > 1) {
+ var matchingMoments = this._similarMoments(eligibleMoments);
-var _config,
- _currentImageWrapper,
- _skelImageWrapper,
- _subImageWrapper,
- _labelImageWrapper,
- _patchGrid,
- _patchLabelGrid,
- _imageToPatchGrid,
- _binaryImageWrapper,
- _patchSize,
- _canvasContainer = {
- ctx: {
- binary: null
- },
- dom: {
- binary: null
- }
-},
- _numPatches = { x: 0, y: 0 },
- _inputImageWrapper,
- _skeletonizer;
+ var length = matchingMoments.length | 0; // Only two of the moments are allowed not to fit into the equation
-function initBuffers() {
- var skeletonImageData;
+ if (length > 1 && length << 2 >= eligibleMoments.length * 3 && length << 2 > moments.length) {
+ // determine the similarity of the moments
+ var rad = matchingMoments.reduce(function (sum, moment) {
+ return sum + moment.rad;
+ }, 0) / length;
+ return {
+ index: index,
+ pos: {
+ x: x,
+ y: y
+ },
+ box: [{
+ x: x,
+ y: y
+ }, {
+ x: x + this._subImageWrapper.size.x,
+ y: y
+ }, {
+ x: x + this._subImageWrapper.size.x,
+ y: y + this._subImageWrapper.size.y
+ }, {
+ x: x,
+ y: y + this._subImageWrapper.size.y
+ }],
+ moments: matchingMoments,
+ rad: rad,
+ x: Math.cos(rad),
+ y: Math.sin(rad)
+ };
+ }
+ }
+ }
- if (_config.halfSample) {
- _currentImageWrapper = new __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__["a" /* default */]({
- x: _inputImageWrapper.size.x / 2 | 0,
- y: _inputImageWrapper.size.y / 2 | 0
- });
- } else {
- _currentImageWrapper = _inputImageWrapper;
+ return null;
}
+ }, {
+ key: "_notYetProcessed",
+ value: function _notYetProcessed() {
+ for (var i = 0; i < this._patchLabelGrid.data.length; i++) {
+ if (this._patchLabelGrid.data[i] === 0 && this._patchGrid.data[i] === 1) {
+ return i;
+ }
+ }
- _patchSize = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["e" /* calculatePatchSize */])(_config.patchSize, _currentImageWrapper.size);
-
- _numPatches.x = _currentImageWrapper.size.x / _patchSize.x | 0;
- _numPatches.y = _currentImageWrapper.size.y / _patchSize.y | 0;
+ return this._patchLabelGrid.data.length;
+ }
+ }, {
+ key: "_trace",
+ value: function _trace(currentIndex, label) {
+ var _this3 = this;
- _binaryImageWrapper = new __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__["a" /* default */](_currentImageWrapper.size, undefined, Uint8Array, false);
+ var threshold = 0.95;
+ var current = {
+ x: currentIndex % this._patchLabelGrid.size.x,
+ y: currentIndex / this._patchLabelGrid.size.x | 0
+ };
- _labelImageWrapper = new __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__["a" /* default */](_patchSize, undefined, Array, true);
+ if (currentIndex < this._patchLabelGrid.data.length) {
+ var currentPatch = this._imageToPatchGrid[currentIndex]; // assign label
- skeletonImageData = new ArrayBuffer(64 * 1024);
- _subImageWrapper = new __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__["a" /* default */](_patchSize, new Uint8Array(skeletonImageData, 0, _patchSize.x * _patchSize.y));
- _skelImageWrapper = new __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__["a" /* default */](_patchSize, new Uint8Array(skeletonImageData, _patchSize.x * _patchSize.y * 3, _patchSize.x * _patchSize.y), undefined, true);
- _skeletonizer = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6__skeletonizer__["a" /* default */])(typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : global, {
- size: _patchSize.x
- }, skeletonImageData);
+ this._patchLabelGrid.data[currentIndex] = label;
+ _tracer__WEBPACK_IMPORTED_MODULE_11__["SearchDirections"].forEach(function (direction) {
+ var y = current.y + direction[0];
+ var x = current.x + direction[1];
+ var index = y * _this3._patchLabelGrid.size.x + x; // continue if patch empty
- _imageToPatchGrid = new __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__["a" /* default */]({
- x: _currentImageWrapper.size.x / _subImageWrapper.size.x | 0,
- y: _currentImageWrapper.size.y / _subImageWrapper.size.y | 0
- }, undefined, Array, true);
- _patchGrid = new __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__["a" /* default */](_imageToPatchGrid.size, undefined, undefined, true);
- _patchLabelGrid = new __WEBPACK_IMPORTED_MODULE_0__common_image_wrapper__["a" /* default */](_imageToPatchGrid.size, undefined, Int32Array, true);
-}
+ if (_this3._patchGrid.data[index] === 0) {
+ _this3._patchLabelGrid.data[index] = Number.MAX_VALUE;
+ } else if (_this3._patchLabelGrid.data[index] === 0) {
+ var patch = _this3._imageToPatchGrid[index];
+ var similarity = Math.abs(patch.x * currentPatch.x + patch.y * currentPatch.y);
-function initCanvas() {
- if (_config.useWorker || typeof document === 'undefined') {
- return;
+ if (similarity > threshold) {
+ _this3._trace(index, label);
+ }
+ }
+ });
+ }
}
- _canvasContainer.dom.binary = document.createElement("canvas");
- _canvasContainer.dom.binary.className = "binaryBuffer";
- if (true && _config.debug.showCanvas === true) {
- document.querySelector("#debug").appendChild(_canvasContainer.dom.binary);
- }
- _canvasContainer.ctx.binary = _canvasContainer.dom.binary.getContext("2d");
- _canvasContainer.dom.binary.width = _binaryImageWrapper.size.x;
- _canvasContainer.dom.binary.height = _binaryImageWrapper.size.y;
-}
+ /**
+ * Finds patches which are connected and share the same orientation
+ * @param patchesFound
+ */
-/**
- * Creates a bounding box which encloses all the given patches
- * @returns {Array} The minimal bounding box
- */
-function boxFromPatches(patches) {
- var overAvg,
- i,
- j,
- patch,
- transMat,
- minx = _binaryImageWrapper.size.x,
- miny = _binaryImageWrapper.size.y,
- maxx = -_binaryImageWrapper.size.x,
- maxy = -_binaryImageWrapper.size.y,
- box,
- scale;
+ }, {
+ key: "_rasterizeAngularSimilarity",
+ value: function _rasterizeAngularSimilarity(patchesFound) {
+ var _this4 = this;
- // draw all patches which are to be taken into consideration
- overAvg = 0;
- for (i = 0; i < patches.length; i++) {
- patch = patches[i];
- overAvg += patch.rad;
- if (true && _config.debug.showPatches) {
- __WEBPACK_IMPORTED_MODULE_3__common_image_debug__["a" /* default */].drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, { color: "red" });
- }
- }
+ var label = 0;
+ var hsv = [0, 1, 1];
+ var rgb = [0, 0, 0]; // prepare for finding the right patches
- overAvg /= patches.length;
- overAvg = (overAvg * 180 / Math.PI + 90) % 180 - 90;
- if (overAvg < 0) {
- overAvg += 180;
- }
+ this._patchGrid.data.fill(0);
- overAvg = (180 - overAvg) * Math.PI / 180;
- transMat = mat2.copy(mat2.create(), [Math.cos(overAvg), Math.sin(overAvg), -Math.sin(overAvg), Math.cos(overAvg)]);
+ this._patchLabelGrid.data.fill(0);
- // iterate over patches and rotate by angle
- for (i = 0; i < patches.length; i++) {
- patch = patches[i];
- for (j = 0; j < 4; j++) {
- vec2.transformMat2(patch.box[j], patch.box[j], transMat);
- }
+ this._imageToPatchGrid.fill(null);
+
+ patchesFound.forEach(function (patch) {
+ _this4._imageToPatchGrid[patch.index] = patch;
+ _this4._patchGrid.data[patch.index] = 1;
+ }); // rasterize the patches found to determine area
+
+ this._patchGrid.zeroBorder();
+
+ var currentIndex = 0;
+
+ while ((currentIndex = this._notYetProcessed()) < this._patchLabelGrid.data.length) {
+ label++;
+
+ this._trace(currentIndex, label);
+ } // draw patch-labels if requested
- if (true && _config.debug.boxFromPatches.showTransformed) {
- __WEBPACK_IMPORTED_MODULE_3__common_image_debug__["a" /* default */].drawPath(patch.box, { x: 0, y: 1 }, _canvasContainer.ctx.binary, { color: '#99ff00', lineWidth: 2 });
+
+ if ( true && this._config.debug && this._config.debug.showPatchLabels) {
+ for (var j = 0; j < this._patchLabelGrid.data.length; j++) {
+ if (this._patchLabelGrid.data[j] > 0 && this._patchLabelGrid.data[j] <= label) {
+ var patch = this._imageToPatchGrid[j];
+ hsv[0] = this._patchLabelGrid.data[j] / (label + 1) * 360;
+ Object(_common_hsv2rgb__WEBPACK_IMPORTED_MODULE_4__["hsv2rgb"])(hsv, rgb);
+
+ this._drawRect(patch.pos, this._subImageWrapper.size, "rgb(".concat(rgb.join(','), ")"), 2);
+ }
}
+ }
+
+ return label;
}
+ }, {
+ key: "_drawRect",
+ value: function _drawRect(_ref9, size, color, lineWidth) {
+ var x = _ref9.x,
+ y = _ref9.y;
+ this._binaryContext.strokeStyle = color;
+ this._binaryContext.fillStyle = color;
+ this._binaryContext.lineWidth = lineWidth || 1;
- // find bounding box
- for (i = 0; i < patches.length; i++) {
- patch = patches[i];
- for (j = 0; j < 4; j++) {
- if (patch.box[j][0] < minx) {
- minx = patch.box[j][0];
- }
- if (patch.box[j][0] > maxx) {
- maxx = patch.box[j][0];
- }
- if (patch.box[j][1] < miny) {
- miny = patch.box[j][1];
- }
- if (patch.box[j][1] > maxy) {
- maxy = patch.box[j][1];
- }
- }
+ this._binaryContext.strokeRect(x, y, size.x, size.y);
+ }
+ }, {
+ key: "_drawPath",
+ value: function _drawPath(path, color, lineWidth) {
+ _common_image_debug__WEBPACK_IMPORTED_MODULE_5__["ImageDebug"].drawPath(path, this._binaryContext, color, lineWidth);
}
+ }]);
- box = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]];
+ return BarcodeLocator;
+}();
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node_modules/webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))
- if (true && _config.debug.boxFromPatches.showTransformedBox) {
- __WEBPACK_IMPORTED_MODULE_3__common_image_debug__["a" /* default */].drawPath(box, { x: 0, y: 1 }, _canvasContainer.ctx.binary, { color: '#ff0000', lineWidth: 2 });
- }
+/***/ }),
- scale = _config.halfSample ? 2 : 1;
- // reverse rotation;
- transMat = mat2.invert(transMat, transMat);
- for (j = 0; j < 4; j++) {
- vec2.transformMat2(box[j], box[j], transMat);
- }
+/***/ "./src/locator/rasterizer.ts":
+/*!***********************************!*\
+ !*** ./src/locator/rasterizer.ts ***!
+ \***********************************/
+/*! exports provided: Rasterizer */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- if (true && _config.debug.boxFromPatches.showBB) {
- __WEBPACK_IMPORTED_MODULE_3__common_image_debug__["a" /* default */].drawPath(box, { x: 0, y: 1 }, _canvasContainer.ctx.binary, { color: '#ff0000', lineWidth: 2 });
- }
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Rasterizer", function() { return Rasterizer; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _tracer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./tracer */ "./src/locator/tracer.ts");
- for (j = 0; j < 4; j++) {
- vec2.scale(box[j], box[j], scale);
- }
- return box;
-}
-/**
- * Creates a binary image of the current image
- */
-function binarizeImage() {
- __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["f" /* otsuThreshold */])(_currentImageWrapper, _binaryImageWrapper);
- _binaryImageWrapper.zeroBorder();
- if (true && _config.debug.showCanvas) {
- _binaryImageWrapper.show(_canvasContainer.dom.binary, 255);
- }
-}
/**
- * Iterate over the entire image
- * extract patches
+ * @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
*/
-function findPatches() {
- var i,
- j,
- x,
- y,
- moments,
- patchesFound = [],
- rasterizer,
- rasterResult,
- patch;
- for (i = 0; i < _numPatches.x; i++) {
- for (j = 0; j < _numPatches.y; j++) {
- x = _subImageWrapper.size.x * i;
- y = _subImageWrapper.size.y * j;
-
- // seperate parts
- skeletonize(x, y);
-
- // Rasterize, find individual bars
- _skelImageWrapper.zeroBorder();
- __WEBPACK_IMPORTED_MODULE_2__common_array_helper__["a" /* default */].init(_labelImageWrapper.data, 0);
- rasterizer = __WEBPACK_IMPORTED_MODULE_4__rasterizer__["a" /* default */].create(_skelImageWrapper, _labelImageWrapper);
- rasterResult = rasterizer.rasterize(0);
-
- if (true && _config.debug.showLabels) {
- _labelImageWrapper.overlay(_canvasContainer.dom.binary, Math.floor(360 / rasterResult.count), { x: x, y: y });
- }
- // calculate moments from the skeletonized patch
- moments = _labelImageWrapper.moments(rasterResult.count);
+var EdgeLabel;
- // extract eligible patches
- patchesFound = patchesFound.concat(describePatch(moments, [i, j], x, y));
- }
- }
+(function (EdgeLabel) {
+ EdgeLabel[EdgeLabel["Outside"] = -32767] = "Outside";
+ EdgeLabel[EdgeLabel["Inside"] = -32766] = "Inside";
+})(EdgeLabel || (EdgeLabel = {}));
- if (true && _config.debug.showFoundPatches) {
- for (i = 0; i < patchesFound.length; i++) {
- patch = patchesFound[i];
- __WEBPACK_IMPORTED_MODULE_3__common_image_debug__["a" /* default */].drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, { color: "#99ff00", lineWidth: 2 });
- }
- }
+;
+var ContourDirection;
- return patchesFound;
-}
+(function (ContourDirection) {
+ ContourDirection[ContourDirection["CW"] = 0] = "CW";
+ ContourDirection[ContourDirection["CCW"] = 1] = "CCW";
+ ContourDirection[ContourDirection["Unknown"] = 2] = "Unknown";
+})(ContourDirection || (ContourDirection = {}));
-/**
- * Finds those connected areas which contain at least 6 patches
- * and returns them ordered DESC by the number of contained patches
- * @param {Number} maxLabel
- */
-function findBiggestConnectedAreas(maxLabel) {
- var i,
- sum,
- labelHist = [],
- topLabels = [];
+;
+var Rasterizer =
+/*#__PURE__*/
+function () {
+ function Rasterizer(imageWrapper, labelWrapper) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, Rasterizer);
- for (i = 0; i < maxLabel; i++) {
- labelHist.push(0);
- }
- sum = _patchLabelGrid.data.length;
- while (sum--) {
- if (_patchLabelGrid.data[sum] > 0) {
- labelHist[_patchLabelGrid.data[sum] - 1]++;
- }
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_width", void 0);
- labelHist = labelHist.map(function (val, idx) {
- return {
- val: val,
- label: idx + 1
- };
- });
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_height", void 0);
- labelHist.sort(function (a, b) {
- return b.val - a.val;
- });
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_tracer", void 0);
- // extract top areas with at least 6 patches present
- topLabels = labelHist.filter(function (el) {
- return el.val >= 5;
- });
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_imageData", void 0);
- return topLabels;
-}
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_labelData", void 0);
-/**
- *
- */
-function findBoxes(topLabels, maxLabel) {
- var i,
- j,
- sum,
- patches = [],
- patch,
- box,
- boxes = [],
- hsv = [0, 1, 1],
- rgb = [0, 0, 0];
-
- for (i = 0; i < topLabels.length; i++) {
- sum = _patchLabelGrid.data.length;
- patches.length = 0;
- while (sum--) {
- if (_patchLabelGrid.data[sum] === topLabels[i].label) {
- patch = _imageToPatchGrid.data[sum];
- patches.push(patch);
- }
- }
- box = boxFromPatches(patches);
- if (box) {
- boxes.push(box);
+ this._imageData = imageWrapper.data;
+ this._labelData = labelWrapper.data;
+ this._width = imageWrapper.size.x;
+ this._height = imageWrapper.size.y;
+ this._tracer = new _tracer__WEBPACK_IMPORTED_MODULE_3__["Tracer"](imageWrapper, labelWrapper);
+ }
- // draw patch-labels if requested
- if (true && _config.debug.showRemainingPatchLabels) {
- for (j = 0; j < patches.length; j++) {
- patch = patches[j];
- hsv[0] = topLabels[i].label / (maxLabel + 1) * 360;
- __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["a" /* hsv2rgb */])(hsv, rgb);
- __WEBPACK_IMPORTED_MODULE_3__common_image_debug__["a" /* default */].drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, { color: "rgb(" + rgb.join(",") + ")", lineWidth: 2 });
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(Rasterizer, [{
+ key: "rasterize",
+ value: function rasterize(depthLabel) {
+ var colorMap = new Array();
+
+ for (var i = 0; i < 400; i++) {
+ colorMap[i] = 0;
+ }
+
+ colorMap[0] = this._imageData[0];
+ var cc = null;
+ var sc;
+ var connectedCount = 0;
+
+ for (var cy = 1; cy < this._height - 1; cy++) {
+ var labelIndex = 0;
+ var bc = colorMap[0];
+
+ for (var cx = 1; cx < this._width - 1; cx++) {
+ var pos = cy * this._width + cx;
+
+ if (this._labelData[pos] === 0) {
+ var color = this._imageData[pos];
+
+ if (color !== bc) {
+ if (labelIndex === 0) {
+ var lc = connectedCount + 1;
+ colorMap[lc] = color;
+ bc = color;
+
+ var vertex = this._tracer.contourTracing(cy, cx, lc, color, EdgeLabel.Outside);
+
+ if (vertex !== null) {
+ connectedCount++;
+ labelIndex = lc;
+ var p = {
+ dir: ContourDirection.CW,
+ index: labelIndex,
+ firstVertex: vertex,
+ nextPeer: cc,
+ insideContours: null
+ };
+
+ if (cc !== null) {
+ cc.previousPeer = p;
+ }
+
+ cc = p;
}
- }
- }
- }
- return boxes;
-}
+ } else {
+ var _vertex = this._tracer.contourTracing(cy, cx, EdgeLabel.Inside, color, labelIndex);
+
+ if (_vertex !== null) {
+ var _p = {
+ dir: depthLabel === 0 ? ContourDirection.CCW : ContourDirection.CW,
+ firstVertex: _vertex,
+ index: depthLabel,
+ insideContours: null
+ };
+ sc = cc;
+
+ while (sc !== null && sc.index !== labelIndex) {
+ sc = sc.nextPeer;
+ }
+
+ if (sc !== null) {
+ _p.nextPeer = sc.insideContours;
+
+ if (sc.insideContours !== null) {
+ sc.insideContours.previousPeer = _p;
+ }
-/**
- * Find similar moments (via cluster)
- * @param {Object} moments
- */
-function similarMoments(moments) {
- var clusters = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["g" /* cluster */])(moments, 0.90);
- var topCluster = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["h" /* topGeneric */])(clusters, 1, function (e) {
- return e.getPoints().length;
- });
- var points = [],
- result = [];
- if (topCluster.length === 1) {
- points = topCluster[0].item.getPoints();
- for (var i = 0; i < points.length; i++) {
- result.push(points[i].point);
+ sc.insideContours = _p;
+ }
+ }
+ }
+ } else {
+ this._labelData[pos] = labelIndex;
+ }
+ } else if (this._labelData[pos] === EdgeLabel.Inside) {
+ labelIndex = 0;
+ bc = this._imageData[pos];
+ } else if (this._labelData[pos] === EdgeLabel.Outside) {
+ labelIndex = 0;
+ bc = colorMap[0];
+ } else {
+ labelIndex = this._labelData[pos];
+ bc = colorMap[labelIndex];
+ }
}
- }
- return result;
-}
+ }
-function skeletonize(x, y) {
- _binaryImageWrapper.subImageAsCopy(_subImageWrapper, __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["b" /* imageRef */])(x, y));
- _skeletonizer.skeletonize();
+ sc = cc;
- // Show skeleton if requested
- if (true && _config.debug.showSkeleton) {
- _skelImageWrapper.overlay(_canvasContainer.dom.binary, 360, __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["b" /* imageRef */])(x, y));
- }
-}
+ while (sc !== null) {
+ sc.index = depthLabel;
+ sc = sc.nextPeer;
+ }
-/**
- * Extracts and describes those patches which seem to contain a barcode pattern
- * @param {Array} moments
- * @param {Object} patchPos,
- * @param {Number} x
- * @param {Number} y
- * @returns {Array} list of patches
- */
-function describePatch(moments, patchPos, x, y) {
- var k,
- avg,
- eligibleMoments = [],
- matchingMoments,
- patch,
- patchesFound = [],
- minComponentWeight = Math.ceil(_patchSize.x / 3);
-
- if (moments.length >= 2) {
- // only collect moments which's area covers at least minComponentWeight pixels.
- for (k = 0; k < moments.length; k++) {
- if (moments[k].m00 > minComponentWeight) {
- eligibleMoments.push(moments[k]);
- }
+ return {
+ cc: cc,
+ count: connectedCount
+ };
+ }
+ }, {
+ key: "drawContour",
+ value: function drawContour(canvas, firstContour) {
+ var context = canvas.getContext('2d');
+ context.strokeStyle = 'red';
+ context.fillStyle = 'red';
+ context.lineWidth = 1;
+ var pq = firstContour;
+ var iq = pq && pq.insideContours;
+
+ while (pq !== null) {
+ var q = iq || pq;
+
+ if (iq !== null) {
+ iq = iq.nextPeer;
+ } else {
+ pq = pq.nextPeer;
+ iq = pq && pq.insideContours;
}
- // if at least 2 moments are found which have at least minComponentWeights covered
- if (eligibleMoments.length >= 2) {
- matchingMoments = similarMoments(eligibleMoments);
- avg = 0;
- // determine the similarity of the moments
- for (k = 0; k < matchingMoments.length; k++) {
- avg += matchingMoments[k].rad;
+ switch (q.dir) {
+ case ContourDirection.CW:
+ {
+ context.strokeStyle = 'red';
+ break;
}
- // Only two of the moments are allowed not to fit into the equation
- // add the patch to the set
- if (matchingMoments.length > 1 && matchingMoments.length >= eligibleMoments.length / 4 * 3 && matchingMoments.length > moments.length / 4) {
- avg /= matchingMoments.length;
- patch = {
- index: patchPos[1] * _numPatches.x + patchPos[0],
- pos: {
- x: x,
- y: y
- },
- box: [vec2.clone([x, y]), vec2.clone([x + _subImageWrapper.size.x, y]), vec2.clone([x + _subImageWrapper.size.x, y + _subImageWrapper.size.y]), vec2.clone([x, y + _subImageWrapper.size.y])],
- moments: matchingMoments,
- rad: avg,
- vec: vec2.clone([Math.cos(avg), Math.sin(avg)])
- };
- patchesFound.push(patch);
+ case ContourDirection.CCW:
+ {
+ context.strokeStyle = 'blue';
+ break;
}
- }
- }
- return patchesFound;
-}
-/**
- * finds patches which are connected and share the same orientation
- * @param {Object} patchesFound
- */
-function rasterizeAngularSimilarity(patchesFound) {
- var label = 0,
- threshold = 0.95,
- currIdx = 0,
- j,
- patch,
- hsv = [0, 1, 1],
- rgb = [0, 0, 0];
-
- function notYetProcessed() {
- var i;
- for (i = 0; i < _patchLabelGrid.data.length; i++) {
- if (_patchLabelGrid.data[i] === 0 && _patchGrid.data[i] === 1) {
- return i;
+ case ContourDirection.Unknown:
+ {
+ context.strokeStyle = 'green';
+ break;
}
}
- return _patchLabelGrid.length;
+
+ var p = q.firstVertex;
+ context.beginPath();
+ context.moveTo(p.x, p.y);
+
+ do {
+ p = p.next;
+ context.lineTo(p.x, p.y);
+ } while (p !== q.firstVertex);
+
+ context.stroke();
+ }
}
+ }]);
- function trace(currentIdx) {
- var x,
- y,
- currentPatch,
- idx,
- dir,
- current = {
- x: currentIdx % _patchLabelGrid.size.x,
- y: currentIdx / _patchLabelGrid.size.x | 0
- },
- similarity;
-
- if (currentIdx < _patchLabelGrid.data.length) {
- currentPatch = _imageToPatchGrid.data[currentIdx];
- // assign label
- _patchLabelGrid.data[currentIdx] = label;
- for (dir = 0; dir < __WEBPACK_IMPORTED_MODULE_5__tracer__["a" /* default */].searchDirections.length; dir++) {
- y = current.y + __WEBPACK_IMPORTED_MODULE_5__tracer__["a" /* default */].searchDirections[dir][0];
- x = current.x + __WEBPACK_IMPORTED_MODULE_5__tracer__["a" /* default */].searchDirections[dir][1];
- idx = y * _patchLabelGrid.size.x + x;
-
- // continue if patch empty
- if (_patchGrid.data[idx] === 0) {
- _patchLabelGrid.data[idx] = Number.MAX_VALUE;
- continue;
- }
+ return Rasterizer;
+}();
- if (_patchLabelGrid.data[idx] === 0) {
- similarity = Math.abs(vec2.dot(_imageToPatchGrid.data[idx].vec, currentPatch.vec));
- if (similarity > threshold) {
- trace(idx);
- }
- }
- }
+/***/ }),
+
+/***/ "./src/locator/skeletonizer.js":
+/*!*************************************!*\
+ !*** ./src/locator/skeletonizer.js ***!
+ \*************************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* eslint-disable eqeqeq */
+function Skeletonizer(stdlib, foreign, buffer) {
+ "use asm";
+
+ var images = new stdlib.Uint8Array(buffer),
+ size = foreign.size | 0,
+ imul = stdlib.Math.imul;
+
+ function erode(inImagePtr, outImagePtr) {
+ inImagePtr = inImagePtr | 0;
+ outImagePtr = outImagePtr | 0;
+ var v = 0,
+ u = 0,
+ sum = 0,
+ yStart1 = 0,
+ yStart2 = 0,
+ xStart1 = 0,
+ xStart2 = 0,
+ offset = 0;
+
+ for (v = 1; (v | 0) < (size - 1 | 0); v = v + 1 | 0) {
+ offset = offset + size | 0;
+
+ for (u = 1; (u | 0) < (size - 1 | 0); u = u + 1 | 0) {
+ yStart1 = offset - size | 0;
+ yStart2 = offset + size | 0;
+ xStart1 = u - 1 | 0;
+ xStart2 = u + 1 | 0;
+ sum = (images[inImagePtr + yStart1 + xStart1 | 0] | 0) + (images[inImagePtr + yStart1 + xStart2 | 0] | 0) + (images[inImagePtr + offset + u | 0] | 0) + (images[inImagePtr + yStart2 + xStart1 | 0] | 0) + (images[inImagePtr + yStart2 + xStart2 | 0] | 0) | 0;
+
+ if ((sum | 0) == (5 | 0)) {
+ images[outImagePtr + offset + u | 0] = 1;
+ } else {
+ images[outImagePtr + offset + u | 0] = 0;
}
+ }
}
- // prepare for finding the right patches
- __WEBPACK_IMPORTED_MODULE_2__common_array_helper__["a" /* default */].init(_patchGrid.data, 0);
- __WEBPACK_IMPORTED_MODULE_2__common_array_helper__["a" /* default */].init(_patchLabelGrid.data, 0);
- __WEBPACK_IMPORTED_MODULE_2__common_array_helper__["a" /* default */].init(_imageToPatchGrid.data, null);
+ return;
+ }
+
+ function subtract(aImagePtr, bImagePtr, outImagePtr) {
+ aImagePtr = aImagePtr | 0;
+ bImagePtr = bImagePtr | 0;
+ outImagePtr = outImagePtr | 0;
+ var length = 0;
+ length = imul(size, size) | 0;
- for (j = 0; j < patchesFound.length; j++) {
- patch = patchesFound[j];
- _imageToPatchGrid.data[patch.index] = patch;
- _patchGrid.data[patch.index] = 1;
+ while ((length | 0) > 0) {
+ length = length - 1 | 0;
+ images[outImagePtr + length | 0] = (images[aImagePtr + length | 0] | 0) - (images[bImagePtr + length | 0] | 0) | 0;
}
+ }
- // rasterize the patches found to determine area
- _patchGrid.zeroBorder();
+ function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) {
+ aImagePtr = aImagePtr | 0;
+ bImagePtr = bImagePtr | 0;
+ outImagePtr = outImagePtr | 0;
+ var length = 0;
+ length = imul(size, size) | 0;
- while ((currIdx = notYetProcessed()) < _patchLabelGrid.data.length) {
- label++;
- trace(currIdx);
+ while ((length | 0) > 0) {
+ length = length - 1 | 0;
+ images[outImagePtr + length | 0] = images[aImagePtr + length | 0] | 0 | (images[bImagePtr + length | 0] | 0) | 0;
}
+ }
- // draw patch-labels if requested
- if (true && _config.debug.showPatchLabels) {
- for (j = 0; j < _patchLabelGrid.data.length; j++) {
- if (_patchLabelGrid.data[j] > 0 && _patchLabelGrid.data[j] <= label) {
- patch = _imageToPatchGrid.data[j];
- hsv[0] = _patchLabelGrid.data[j] / (label + 1) * 360;
- __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["a" /* hsv2rgb */])(hsv, rgb);
- __WEBPACK_IMPORTED_MODULE_3__common_image_debug__["a" /* default */].drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, { color: "rgb(" + rgb.join(",") + ")", lineWidth: 2 });
- }
- }
- }
+ function countNonZero(imagePtr) {
+ imagePtr = imagePtr | 0;
+ var sum = 0,
+ length = 0;
+ length = imul(size, size) | 0;
- return label;
-}
+ while ((length | 0) > 0) {
+ length = length - 1 | 0;
+ sum = (sum | 0) + (images[imagePtr + length | 0] | 0) | 0;
+ }
-/* harmony default export */ __webpack_exports__["a"] = {
- init: function init(inputImageWrapper, config) {
- _config = config;
- _inputImageWrapper = inputImageWrapper;
+ return sum | 0;
+ }
- initBuffers();
- initCanvas();
- },
+ function init(imagePtr, value) {
+ imagePtr = imagePtr | 0;
+ value = value | 0;
+ var length = 0;
+ length = imul(size, size) | 0;
- locate: function locate() {
- var patchesFound, topLabels, boxes;
+ while ((length | 0) > 0) {
+ length = length - 1 | 0;
+ images[imagePtr + length | 0] = value;
+ }
+ }
- if (_config.halfSample) {
- __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["i" /* halfSample */])(_inputImageWrapper, _currentImageWrapper);
+ function dilate(inImagePtr, outImagePtr) {
+ inImagePtr = inImagePtr | 0;
+ outImagePtr = outImagePtr | 0;
+ var v = 0,
+ u = 0,
+ sum = 0,
+ yStart1 = 0,
+ yStart2 = 0,
+ xStart1 = 0,
+ xStart2 = 0,
+ offset = 0;
+
+ for (v = 1; (v | 0) < (size - 1 | 0); v = v + 1 | 0) {
+ offset = offset + size | 0;
+
+ for (u = 1; (u | 0) < (size - 1 | 0); u = u + 1 | 0) {
+ yStart1 = offset - size | 0;
+ yStart2 = offset + size | 0;
+ xStart1 = u - 1 | 0;
+ xStart2 = u + 1 | 0;
+ sum = (images[inImagePtr + yStart1 + xStart1 | 0] | 0) + (images[inImagePtr + yStart1 + xStart2 | 0] | 0) + (images[inImagePtr + offset + u | 0] | 0) + (images[inImagePtr + yStart2 + xStart1 | 0] | 0) + (images[inImagePtr + yStart2 + xStart2 | 0] | 0) | 0;
+
+ if ((sum | 0) > (0 | 0)) {
+ images[outImagePtr + offset + u | 0] = 1;
+ } else {
+ images[outImagePtr + offset + u | 0] = 0;
}
+ }
+ }
- binarizeImage();
- patchesFound = findPatches();
- // return unless 5% or more patches are found
- if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) {
- return null;
- }
+ return;
+ }
- // rasterrize area by comparing angular similarity;
- var maxLabel = rasterizeAngularSimilarity(patchesFound);
- if (maxLabel < 1) {
- return null;
- }
+ function memcpy(srcImagePtr, dstImagePtr) {
+ srcImagePtr = srcImagePtr | 0;
+ dstImagePtr = dstImagePtr | 0;
+ var length = 0;
+ length = imul(size, size) | 0;
- // search for area with the most patches (biggest connected area)
- topLabels = findBiggestConnectedAreas(maxLabel);
- if (topLabels.length === 0) {
- return null;
- }
+ while ((length | 0) > 0) {
+ length = length - 1 | 0;
+ images[dstImagePtr + length | 0] = images[srcImagePtr + length | 0] | 0;
+ }
+ }
- boxes = findBoxes(topLabels, maxLabel);
- return boxes;
- },
+ function zeroBorder(imagePtr) {
+ imagePtr = imagePtr | 0;
+ var x = 0,
+ y = 0;
- checkImageConstraints: function checkImageConstraints(inputStream, config) {
- var patchSize,
- width = inputStream.getWidth(),
- height = inputStream.getHeight(),
- halfSample = config.halfSample ? 0.5 : 1,
- size,
- area;
-
- // calculate width and height based on area
- if (inputStream.getConfig().area) {
- area = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["j" /* computeImageArea */])(width, height, inputStream.getConfig().area);
- inputStream.setTopRight({ x: area.sx, y: area.sy });
- inputStream.setCanvasSize({ x: width, y: height });
- width = area.sw;
- height = area.sh;
- }
-
- size = {
- x: Math.floor(width * halfSample),
- y: Math.floor(height * halfSample)
- };
+ for (x = 0; (x | 0) < (size - 1 | 0); x = x + 1 | 0) {
+ images[imagePtr + x | 0] = 0;
+ images[imagePtr + y | 0] = 0;
+ y = y + size - 1 | 0;
+ images[imagePtr + y | 0] = 0;
+ y = y + 1 | 0;
+ }
- patchSize = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["e" /* calculatePatchSize */])(config.patchSize, size);
- if (true) {
- console.log("Patch-Size: " + JSON.stringify(patchSize));
- }
+ for (x = 0; (x | 0) < (size | 0); x = x + 1 | 0) {
+ images[imagePtr + y | 0] = 0;
+ y = y + 1 | 0;
+ }
+ }
- inputStream.setWidth(Math.floor(Math.floor(size.x / patchSize.x) * (1 / halfSample) * patchSize.x));
- inputStream.setHeight(Math.floor(Math.floor(size.y / patchSize.y) * (1 / halfSample) * patchSize.y));
+ function skeletonize() {
+ var subImagePtr = 0,
+ erodedImagePtr = 0,
+ tempImagePtr = 0,
+ skelImagePtr = 0,
+ sum = 0,
+ done = 0;
+ erodedImagePtr = imul(size, size) | 0;
+ tempImagePtr = erodedImagePtr + erodedImagePtr | 0;
+ skelImagePtr = tempImagePtr + erodedImagePtr | 0; // init skel-image
- if (inputStream.getWidth() % patchSize.x === 0 && inputStream.getHeight() % patchSize.y === 0) {
- return true;
- }
+ init(skelImagePtr, 0);
+ zeroBorder(subImagePtr);
- throw new Error("Image dimensions do not comply with the current settings: Width (" + width + " )and height (" + height + ") must a multiple of " + patchSize.x);
- }
-};
-/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(47)))
+ do {
+ erode(subImagePtr, erodedImagePtr);
+ dilate(erodedImagePtr, tempImagePtr);
+ subtract(subImagePtr, tempImagePtr, tempImagePtr);
+ bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr);
+ memcpy(erodedImagePtr, subImagePtr);
+ sum = countNonZero(subImagePtr) | 0;
+ done = (sum | 0) == 0 | 0;
+ } while (!done);
+ }
+
+ return {
+ skeletonize: skeletonize
+ };
+}
+
+/* harmony default export */ __webpack_exports__["default"] = (Skeletonizer);
+/* eslint-enable eqeqeq */
/***/ }),
-/* 65 */
+
+/***/ "./src/locator/tracer.ts":
+/*!*******************************!*\
+ !*** ./src/locator/tracer.ts ***!
+ \*******************************/
+/*! exports provided: SearchDirections, Tracer */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__tracer__ = __webpack_require__(30);
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SearchDirections", function() { return SearchDirections; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Tracer", function() { return Tracer; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
+
+
/**
- * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
+ * @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization
*/
-var Rasterizer = {
- createContour2D: function createContour2D() {
- return {
- dir: null,
- index: null,
- firstVertex: null,
- insideContours: null,
- nextpeer: null,
- prevpeer: null
- };
- },
- CONTOUR_DIR: {
- CW_DIR: 0,
- CCW_DIR: 1,
- UNKNOWN_DIR: 2
- },
- DIR: {
- OUTSIDE_EDGE: -32767,
- INSIDE_EDGE: -32766
- },
- create: function create(imageWrapper, labelWrapper) {
- var imageData = imageWrapper.data,
- labelData = labelWrapper.data,
- width = imageWrapper.size.x,
- height = imageWrapper.size.y,
- tracer = __WEBPACK_IMPORTED_MODULE_0__tracer__["a" /* default */].create(imageWrapper, labelWrapper);
+var SearchDirections = [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]];
+var Tracer =
+/*#__PURE__*/
+function () {
+ function Tracer(imageWrapper, labelWrapper) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, Tracer);
- return {
- rasterize: function rasterize(depthlabel) {
- var color,
- bc,
- lc,
- labelindex,
- cx,
- cy,
- colorMap = [],
- vertex,
- p,
- cc,
- sc,
- pos,
- connectedCount = 0,
- i;
-
- for (i = 0; i < 400; i++) {
- colorMap[i] = 0;
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_imageData", void 0);
- colorMap[0] = imageData[0];
- cc = null;
- for (cy = 1; cy < height - 1; cy++) {
- labelindex = 0;
- bc = colorMap[0];
- for (cx = 1; cx < width - 1; cx++) {
- pos = cy * width + cx;
- if (labelData[pos] === 0) {
- color = imageData[pos];
- if (color !== bc) {
- if (labelindex === 0) {
- lc = connectedCount + 1;
- colorMap[lc] = color;
- bc = color;
- vertex = tracer.contourTracing(cy, cx, lc, color, Rasterizer.DIR.OUTSIDE_EDGE);
- if (vertex !== null) {
- connectedCount++;
- labelindex = lc;
- p = Rasterizer.createContour2D();
- p.dir = Rasterizer.CONTOUR_DIR.CW_DIR;
- p.index = labelindex;
- p.firstVertex = vertex;
- p.nextpeer = cc;
- p.insideContours = null;
- if (cc !== null) {
- cc.prevpeer = p;
- }
- cc = p;
- }
- } else {
- vertex = tracer.contourTracing(cy, cx, Rasterizer.DIR.INSIDE_EDGE, color, labelindex);
- if (vertex !== null) {
- p = Rasterizer.createContour2D();
- p.firstVertex = vertex;
- p.insideContours = null;
- if (depthlabel === 0) {
- p.dir = Rasterizer.CONTOUR_DIR.CCW_DIR;
- } else {
- p.dir = Rasterizer.CONTOUR_DIR.CW_DIR;
- }
- p.index = depthlabel;
- sc = cc;
- while (sc !== null && sc.index !== labelindex) {
- sc = sc.nextpeer;
- }
- if (sc !== null) {
- p.nextpeer = sc.insideContours;
- if (sc.insideContours !== null) {
- sc.insideContours.prevpeer = p;
- }
- sc.insideContours = p;
- }
- }
- }
- } else {
- labelData[pos] = labelindex;
- }
- } else if (labelData[pos] === Rasterizer.DIR.OUTSIDE_EDGE || labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) {
- labelindex = 0;
- if (labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) {
- bc = imageData[pos];
- } else {
- bc = colorMap[0];
- }
- } else {
- labelindex = labelData[pos];
- bc = colorMap[labelindex];
- }
- }
- }
- sc = cc;
- while (sc !== null) {
- sc.index = depthlabel;
- sc = sc.nextpeer;
- }
- return {
- cc: cc,
- count: connectedCount
- };
- },
- debug: {
- drawContour: function drawContour(canvas, firstContour) {
- var ctx = canvas.getContext("2d"),
- pq = firstContour,
- iq,
- q,
- p;
-
- ctx.strokeStyle = "red";
- ctx.fillStyle = "red";
- ctx.lineWidth = 1;
-
- if (pq !== null) {
- iq = pq.insideContours;
- } else {
- iq = null;
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_labelData", void 0);
- while (pq !== null) {
- if (iq !== null) {
- q = iq;
- iq = iq.nextpeer;
- } else {
- q = pq;
- pq = pq.nextpeer;
- if (pq !== null) {
- iq = pq.insideContours;
- } else {
- iq = null;
- }
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_width", void 0);
- switch (q.dir) {
- case Rasterizer.CONTOUR_DIR.CW_DIR:
- ctx.strokeStyle = "red";
- break;
- case Rasterizer.CONTOUR_DIR.CCW_DIR:
- ctx.strokeStyle = "blue";
- break;
- case Rasterizer.CONTOUR_DIR.UNKNOWN_DIR:
- ctx.strokeStyle = "green";
- break;
- }
+ this._imageData = imageWrapper.data;
+ this._labelData = labelWrapper.data;
+ this._width = imageWrapper.size.x;
+ }
- p = q.firstVertex;
- ctx.beginPath();
- ctx.moveTo(p.x, p.y);
- do {
- p = p.next;
- ctx.lineTo(p.x, p.y);
- } while (p !== q.firstVertex);
- ctx.stroke();
- }
- }
- }
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(Tracer, [{
+ key: "trace",
+ value: function trace(current, color, label, edgeLabel) {
+ for (var i = 0; i < 7; i++) {
+ var y = current.cy + SearchDirections[current.dir][0] | 0;
+ var x = current.cx + SearchDirections[current.dir][1] | 0;
+ var pos = y * this._width + x | 0;
+
+ if (this._imageData[pos] === color && (this._labelData[pos] === 0 || this._labelData[pos] === label)) {
+ this._labelData[pos] = label;
+ current.cx = x;
+ current.cy = y;
+ return true;
+ } else {
+ if (this._labelData[pos] === 0) {
+ this._labelData[pos] = edgeLabel;
+ }
+
+ current.dir = (current.dir + 1) % 8;
+ }
+ }
+
+ return false;
+ }
+ }, {
+ key: "contourTracing",
+ value: function contourTracing(sy, sx, label, color, edgeLabel) {
+ var Fv = null;
+ var current = {
+ cx: sx,
+ cy: sy,
+ dir: 0
+ };
+
+ if (this.trace(current, color, label, edgeLabel)) {
+ Fv = {
+ x: sx,
+ y: sy,
+ dir: current.dir,
+ next: null,
+ prev: null
+ };
+ var Cv = Fv;
+ var ldir = current.dir;
+ var P = {
+ x: current.cx,
+ y: current.cy,
+ dir: 0,
+ next: null,
+ prev: Cv
};
+ Cv.next = P;
+ Cv = P;
+
+ do {
+ current.dir = (current.dir + 6) % 8;
+ this.trace(current, color, label, edgeLabel);
+
+ if (ldir !== current.dir) {
+ Cv.dir = current.dir;
+ P = {
+ x: current.cx,
+ y: current.cy,
+ dir: 0,
+ next: null,
+ prev: Cv
+ };
+ Cv.next = P;
+ Cv = P;
+ } else {
+ Cv.dir = ldir;
+ Cv.x = current.cx;
+ Cv.y = current.cy;
+ }
+
+ ldir = current.dir;
+ } while (current.cx !== sx || current.cy !== sy);
+
+ Fv.prev = Cv.prev;
+ Cv.prev.next = Fv;
+ }
+
+ return Fv;
}
-};
+ }]);
-/* harmony default export */ __webpack_exports__["a"] = Rasterizer;
+ return Tracer;
+}();
/***/ }),
-/* 66 */
+
+/***/ "./src/quagga.ts":
+/*!***********************!*\
+ !*** ./src/quagga.ts ***!
+ \***********************/
+/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* @preserve ASM BEGIN */
-/* eslint-disable eqeqeq*/
-function Skeletonizer(stdlib, foreign, buffer) {
- "use asm";
-
- var images = new stdlib.Uint8Array(buffer),
- size = foreign.size | 0,
- imul = stdlib.Math.imul;
-
- function erode(inImagePtr, outImagePtr) {
- inImagePtr = inImagePtr | 0;
- outImagePtr = outImagePtr | 0;
-
- var v = 0,
- u = 0,
- sum = 0,
- yStart1 = 0,
- yStart2 = 0,
- xStart1 = 0,
- xStart2 = 0,
- offset = 0;
-
- for (v = 1; (v | 0) < (size - 1 | 0); v = v + 1 | 0) {
- offset = offset + size | 0;
- for (u = 1; (u | 0) < (size - 1 | 0); u = u + 1 | 0) {
- yStart1 = offset - size | 0;
- yStart2 = offset + size | 0;
- xStart1 = u - 1 | 0;
- xStart2 = u + 1 | 0;
- sum = (images[inImagePtr + yStart1 + xStart1 | 0] | 0) + (images[inImagePtr + yStart1 + xStart2 | 0] | 0) + (images[inImagePtr + offset + u | 0] | 0) + (images[inImagePtr + yStart2 + xStart1 | 0] | 0) + (images[inImagePtr + yStart2 + xStart2 | 0] | 0) | 0;
- if ((sum | 0) == (5 | 0)) {
- images[outImagePtr + offset + u | 0] = 1;
- } else {
- images[outImagePtr + offset + u | 0] = 0;
- }
- }
- }
- return;
- }
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _analytics_result_collector__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./analytics/result-collector */ "./src/analytics/result-collector.ts");
+/* harmony import */ var _common_events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./common/events */ "./src/common/events.ts");
+/* harmony import */ var _common_image_debug__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./common/image-debug */ "./src/common/image-debug.ts");
+/* harmony import */ var _common_image_wrapper__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./common/image-wrapper */ "./src/common/image-wrapper.ts");
+/* harmony import */ var _common_merge__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./common/merge */ "./src/common/merge.ts");
+/* harmony import */ var _config_config__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./config/config */ "./src/config/config.dev.ts");
+/* harmony import */ var _decoder_barcode_decoder__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./decoder/barcode-decoder */ "./src/decoder/barcode-decoder.ts");
+/* harmony import */ var _input_camera_access__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./input/camera-access */ "./src/input/camera-access.ts");
+/* harmony import */ var _input_frame_grabber__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./input/frame-grabber */ "./src/input/frame-grabber.ts");
+/* harmony import */ var _input_image_stream__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./input/image-stream */ "./src/input/image-stream.ts");
+/* harmony import */ var _input_live_stream__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./input/live-stream */ "./src/input/live-stream.ts");
+/* harmony import */ var _input_video_stream__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./input/video-stream */ "./src/input/video-stream.ts");
+/* harmony import */ var _input_input_stream_utils__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./input/input-stream-utils */ "./src/input/input-stream-utils.ts");
+/* harmony import */ var _locator_barcode_locator__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./locator/barcode-locator */ "./src/locator/barcode-locator.ts");
- function subtract(aImagePtr, bImagePtr, outImagePtr) {
- aImagePtr = aImagePtr | 0;
- bImagePtr = bImagePtr | 0;
- outImagePtr = outImagePtr | 0;
- var length = 0;
- length = imul(size, size) | 0;
- while ((length | 0) > 0) {
- length = length - 1 | 0;
- images[outImagePtr + length | 0] = (images[aImagePtr + length | 0] | 0) - (images[bImagePtr + length | 0] | 0) | 0;
- }
- }
- function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) {
- aImagePtr = aImagePtr | 0;
- bImagePtr = bImagePtr | 0;
- outImagePtr = outImagePtr | 0;
- var length = 0;
- length = imul(size, size) | 0;
-
- while ((length | 0) > 0) {
- length = length - 1 | 0;
- images[outImagePtr + length | 0] = images[aImagePtr + length | 0] | 0 | (images[bImagePtr + length | 0] | 0) | 0;
- }
- }
- function countNonZero(imagePtr) {
- imagePtr = imagePtr | 0;
- var sum = 0,
- length = 0;
- length = imul(size, size) | 0;
- while ((length | 0) > 0) {
- length = length - 1 | 0;
- sum = (sum | 0) + (images[imagePtr + length | 0] | 0) | 0;
- }
- return sum | 0;
- }
- function init(imagePtr, value) {
- imagePtr = imagePtr | 0;
- value = value | 0;
- var length = 0;
- length = imul(size, size) | 0;
+var _inputStream;
- while ((length | 0) > 0) {
- length = length - 1 | 0;
- images[imagePtr + length | 0] = value;
- }
- }
+var _frameGrabber;
- function dilate(inImagePtr, outImagePtr) {
- inImagePtr = inImagePtr | 0;
- outImagePtr = outImagePtr | 0;
+var _stopped;
- var v = 0,
- u = 0,
- sum = 0,
- yStart1 = 0,
- yStart2 = 0,
- xStart1 = 0,
- xStart2 = 0,
- offset = 0;
+var _canvasContainer = {
+ ctx: {
+ image: null,
+ overlay: null
+ },
+ dom: {
+ image: null,
+ overlay: null
+ }
+};
- for (v = 1; (v | 0) < (size - 1 | 0); v = v + 1 | 0) {
- offset = offset + size | 0;
- for (u = 1; (u | 0) < (size - 1 | 0); u = u + 1 | 0) {
- yStart1 = offset - size | 0;
- yStart2 = offset + size | 0;
- xStart1 = u - 1 | 0;
- xStart2 = u + 1 | 0;
- sum = (images[inImagePtr + yStart1 + xStart1 | 0] | 0) + (images[inImagePtr + yStart1 + xStart2 | 0] | 0) + (images[inImagePtr + offset + u | 0] | 0) + (images[inImagePtr + yStart2 + xStart1 | 0] | 0) + (images[inImagePtr + yStart2 + xStart2 | 0] | 0) | 0;
- if ((sum | 0) > (0 | 0)) {
- images[outImagePtr + offset + u | 0] = 1;
- } else {
- images[outImagePtr + offset + u | 0] = 0;
- }
- }
- }
- return;
- }
+var _inputImageWrapper;
- function memcpy(srcImagePtr, dstImagePtr) {
- srcImagePtr = srcImagePtr | 0;
- dstImagePtr = dstImagePtr | 0;
+var _locator;
- var length = 0;
+var _boxSize;
- length = imul(size, size) | 0;
+var _decoder;
- while ((length | 0) > 0) {
- length = length - 1 | 0;
- images[dstImagePtr + length | 0] = images[srcImagePtr + length | 0] | 0;
- }
- }
+var _workerPool = new Array();
- function zeroBorder(imagePtr) {
- imagePtr = imagePtr | 0;
+var _onUIThread;
- var x = 0,
- y = 0;
+var _resultCollector;
- for (x = 0; (x | 0) < (size - 1 | 0); x = x + 1 | 0) {
- images[imagePtr + x | 0] = 0;
- images[imagePtr + y | 0] = 0;
- y = y + size - 1 | 0;
- images[imagePtr + y | 0] = 0;
- y = y + 1 | 0;
- }
- for (x = 0; (x | 0) < (size | 0); x = x + 1 | 0) {
- images[imagePtr + y | 0] = 0;
- y = y + 1 | 0;
- }
- }
+var _config;
- function skeletonize() {
- var subImagePtr = 0,
- erodedImagePtr = 0,
- tempImagePtr = 0,
- skelImagePtr = 0,
- sum = 0,
- done = 0;
+/* harmony default export */ __webpack_exports__["default"] = ({
+ init: function init(config, cb, imageWrapper) {
+ _onUIThread = true;
+ _config = Object(_common_merge__WEBPACK_IMPORTED_MODULE_4__["merge"])(_config_config__WEBPACK_IMPORTED_MODULE_5__["config"], config);
- erodedImagePtr = imul(size, size) | 0;
- tempImagePtr = erodedImagePtr + erodedImagePtr | 0;
- skelImagePtr = tempImagePtr + erodedImagePtr | 0;
+ if (imageWrapper) {
+ _onUIThread = false;
- // init skel-image
- init(skelImagePtr, 0);
- zeroBorder(subImagePtr);
+ _initializeData(imageWrapper);
- do {
- erode(subImagePtr, erodedImagePtr);
- dilate(erodedImagePtr, tempImagePtr);
- subtract(subImagePtr, tempImagePtr, tempImagePtr);
- bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr);
- memcpy(erodedImagePtr, subImagePtr);
- sum = countNonZero(subImagePtr) | 0;
- done = (sum | 0) == 0 | 0;
- } while (!done);
+ cb();
+ } else {
+ _initInputStream(cb);
}
- return {
- skeletonize: skeletonize
- };
-}
-/* @preserve ASM END */
-/* harmony default export */ __webpack_exports__["a"] = Skeletonizer;
-/* eslint-enable eqeqeq*/
+ },
+ CameraAccess: _input_camera_access__WEBPACK_IMPORTED_MODULE_7__["CameraAccess"],
+ ImageDebug: _common_image_debug__WEBPACK_IMPORTED_MODULE_2__["ImageDebug"],
+ ImageWrapper: _common_image_wrapper__WEBPACK_IMPORTED_MODULE_3__["ImageWrapper"],
+ ResultCollector: _analytics_result_collector__WEBPACK_IMPORTED_MODULE_0__["ResultCollector"],
-/***/ }),
-/* 67 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ get canvas() {
+ return _canvasContainer;
+ },
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__barcode_reader__ = __webpack_require__(1);
+ start: function start() {
+ if (_onUIThread && _config.inputStream.type === 'LiveStream') {
+ _startContinuousUpdate();
+ } else {
+ _update();
+ }
+ },
+ stop: function stop() {
+ _stopped = true;
+ _adjustWorkerPool(0);
-function TwoOfFiveReader(opts) {
- __WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].call(this, opts);
- this.barSpaceRatio = [1, 1];
-}
+ if (_config.inputStream.type === 'LiveStream') {
+ _input_camera_access__WEBPACK_IMPORTED_MODULE_7__["CameraAccess"].release();
-var N = 1,
- W = 3,
- properties = {
- START_PATTERN: { value: [W, N, W, N, N, N] },
- STOP_PATTERN: { value: [W, N, N, N, W] },
- CODE_PATTERN: { value: [[N, N, W, W, N], [W, N, N, N, W], [N, W, N, N, W], [W, W, N, N, N], [N, N, W, N, W], [W, N, W, N, N], [N, W, W, N, N], [N, N, N, W, W], [W, N, N, W, N], [N, W, N, W, N]] },
- SINGLE_CODE_ERROR: { value: 0.78, writable: true },
- AVG_CODE_ERROR: { value: 0.30, writable: true },
- FORMAT: { value: "2of5" }
-};
+ _inputStream.clearEventHandlers();
+ }
+ },
+ decodeSingle: function decodeSingle(config, resultCallback) {
+ var _this = this;
-var startPatternLength = properties.START_PATTERN.value.reduce(function (sum, val) {
- return sum + val;
-}, 0);
+ config = Object(_common_merge__WEBPACK_IMPORTED_MODULE_4__["merge"])({
+ inputStream: {
+ type: 'ImageStream',
+ sequence: false,
+ size: 800,
+ src: config.src
+ },
+ numOfWorkers: true && config.debug ? 0 : 1,
+ locator: {
+ halfSample: false
+ }
+ }, config);
+ this.init(config, function () {
+ _common_events__WEBPACK_IMPORTED_MODULE_1__["Events"].once('processed', function (result) {
+ _this.stop();
-TwoOfFiveReader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].prototype, properties);
-TwoOfFiveReader.prototype.constructor = TwoOfFiveReader;
+ resultCallback.call(null, result);
+ }, true);
-TwoOfFiveReader.prototype._findPattern = function (pattern, offset, isWhite, tryHarder) {
- var counter = [],
- self = this,
- i,
- counterPos = 0,
- bestMatch = {
- error: Number.MAX_VALUE,
- code: -1,
- start: 0,
- end: 0
- },
- error,
- j,
- sum,
- epsilon = self.AVG_CODE_ERROR;
-
- isWhite = isWhite || false;
- tryHarder = tryHarder || false;
-
- if (!offset) {
- offset = self._nextSet(self._row);
+ _this.start();
+ });
+ },
+ pause: function pause() {
+ _stopped = true;
+ },
+ onDetected: function onDetected(callback) {
+ _common_events__WEBPACK_IMPORTED_MODULE_1__["Events"].subscribe('detected', callback);
+ },
+ offDetected: function offDetected(callback) {
+ _common_events__WEBPACK_IMPORTED_MODULE_1__["Events"].unsubscribe('detected', callback);
+ },
+ onProcessed: function onProcessed(callback) {
+ _common_events__WEBPACK_IMPORTED_MODULE_1__["Events"].subscribe('processed', callback);
+ },
+ offProcessed: function offProcessed(callback) {
+ _common_events__WEBPACK_IMPORTED_MODULE_1__["Events"].unsubscribe('processed', callback);
+ },
+ setReaders: function setReaders(readers) {
+ if (_decoder) {
+ _decoder.setReaders(readers);
+ } else if (_onUIThread && _workerPool.length > 0) {
+ _workerPool.forEach(function (_ref) {
+ var worker = _ref.worker;
+ return worker.postMessage({
+ cmd: 'setReaders',
+ readers: readers
+ });
+ });
}
-
- for (i = 0; i < pattern.length; i++) {
- counter[i] = 0;
+ },
+ registerResultCollector: function registerResultCollector(resultCollector) {
+ if (resultCollector && typeof resultCollector.addResult === 'function') {
+ _resultCollector = resultCollector;
}
+ }
+});
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- if (counterPos === counter.length - 1) {
- sum = 0;
- for (j = 0; j < counter.length; j++) {
- sum += counter[j];
- }
- error = self._matchPattern(counter, pattern);
- if (error < epsilon) {
- bestMatch.error = error;
- bestMatch.start = i - sum;
- bestMatch.end = i;
- return bestMatch;
- }
- if (tryHarder) {
- for (j = 0; j < counter.length - 2; j++) {
- counter[j] = counter[j + 2];
- }
- counter[counter.length - 2] = 0;
- counter[counter.length - 1] = 0;
- counterPos--;
- } else {
- return null;
- }
- } else {
- counterPos++;
- }
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- return null;
-};
-
-TwoOfFiveReader.prototype._findStart = function () {
- var self = this,
- leadingWhitespaceStart,
- offset = self._nextSet(self._row),
- startInfo,
- narrowBarWidth = 1;
-
- while (!startInfo) {
- startInfo = self._findPattern(self.START_PATTERN, offset, false, true);
- if (!startInfo) {
- return null;
- }
- narrowBarWidth = Math.floor((startInfo.end - startInfo.start) / startPatternLength);
- leadingWhitespaceStart = startInfo.start - narrowBarWidth * 5;
- if (leadingWhitespaceStart >= 0) {
- if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {
- return startInfo;
- }
- }
- offset = startInfo.end;
- startInfo = null;
- }
-};
+function _initializeData(imageWrapper) {
+ _initBuffers(imageWrapper);
-TwoOfFiveReader.prototype._verifyTrailingWhitespace = function (endInfo) {
- var self = this,
- trailingWhitespaceEnd;
+ _decoder = new _decoder_barcode_decoder__WEBPACK_IMPORTED_MODULE_6__["BarcodeDecoder"](_config.decoder, _inputImageWrapper);
+}
- trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
- if (trailingWhitespaceEnd < self._row.length) {
- if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
- return endInfo;
- }
- }
- return null;
-};
+function _initInputStream(callback) {
+ var video;
-TwoOfFiveReader.prototype._findEnd = function () {
- var self = this,
- endInfo,
- tmp,
- offset;
+ if (_config.inputStream.type === 'VideoStream') {
+ video = document.createElement('video');
+ _inputStream = new _input_video_stream__WEBPACK_IMPORTED_MODULE_11__["VideoStream"](video);
+ } else if (_config.inputStream.type === 'ImageStream') {
+ _inputStream = new _input_image_stream__WEBPACK_IMPORTED_MODULE_9__["ImageStream"]();
+ } else if (_config.inputStream.type === 'LiveStream') {
+ var viewport = _getViewPort();
- self._row.reverse();
- offset = self._nextSet(self._row);
- endInfo = self._findPattern(self.STOP_PATTERN, offset, false, true);
- self._row.reverse();
+ if (viewport) {
+ video = viewport.querySelector('video');
- if (endInfo === null) {
- return null;
+ if (!video) {
+ video = document.createElement('video');
+ viewport.appendChild(video);
+ }
}
- // reverse numbers
- tmp = endInfo.start;
- endInfo.start = self._row.length - endInfo.end;
- endInfo.end = self._row.length - tmp;
+ _inputStream = new _input_live_stream__WEBPACK_IMPORTED_MODULE_10__["LiveStream"](video);
+ _input_camera_access__WEBPACK_IMPORTED_MODULE_7__["CameraAccess"].request(video, _config.inputStream.constraints).then(function () {
+ return _inputStream.trigger('canrecord');
+ }, function (err) {
+ return callback(err);
+ });
+ }
- return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;
-};
+ _inputStream.setAttribute('preload', 'auto');
-TwoOfFiveReader.prototype._decodeCode = function (counter) {
- var j,
- self = this,
- sum = 0,
- normalized,
- error,
- epsilon = self.AVG_CODE_ERROR,
- code,
- bestMatch = {
- error: Number.MAX_VALUE,
- code: -1,
- start: 0,
- end: 0
- };
+ _inputStream.config = _config.inputStream;
- for (j = 0; j < counter.length; j++) {
- sum += counter[j];
- }
- for (code = 0; code < self.CODE_PATTERN.length; code++) {
- error = self._matchPattern(counter, self.CODE_PATTERN[code]);
- if (error < bestMatch.error) {
- bestMatch.code = code;
- bestMatch.error = error;
- }
- }
- if (bestMatch.error < epsilon) {
- return bestMatch;
- }
-};
+ _inputStream.addEventListener('canrecord', _canRecord.bind(this, callback));
+}
-TwoOfFiveReader.prototype._decodePayload = function (counters, result, decodedCodes) {
- var i,
- self = this,
- pos = 0,
- counterLength = counters.length,
- counter = [0, 0, 0, 0, 0],
- code;
+function _getViewPort() {
+ var target = _config.inputStream.target; // Check if target is already a DOM element
- while (pos < counterLength) {
- for (i = 0; i < 5; i++) {
- counter[i] = counters[pos] * this.barSpaceRatio[0];
- pos += 2;
- }
- code = self._decodeCode(counter);
- if (!code) {
- return null;
- }
- result.push(code.code + "");
- decodedCodes.push(code);
- }
- return code;
-};
+ if (target instanceof HTMLElement) {
+ return target;
+ } else {
+ // Use '#interactive.viewport' as a fallback selector (backwards compatibility)
+ var selector = typeof target === 'string' ? target : '#interactive.viewport';
+ return document.querySelector(selector);
+ }
+}
-TwoOfFiveReader.prototype._verifyCounterLength = function (counters) {
- return counters.length % 10 === 0;
-};
+function _canRecord(cb) {
+ Object(_input_input_stream_utils__WEBPACK_IMPORTED_MODULE_12__["checkImageConstraints"])(_inputStream, _config.locator);
-TwoOfFiveReader.prototype._decode = function () {
- var startInfo,
- endInfo,
- self = this,
- code,
- result = [],
- decodedCodes = [],
- counters;
-
- startInfo = self._findStart();
- if (!startInfo) {
- return null;
- }
- decodedCodes.push(startInfo);
+ _initCanvas();
- endInfo = self._findEnd();
- if (!endInfo) {
- return null;
- }
+ _frameGrabber = new _input_frame_grabber__WEBPACK_IMPORTED_MODULE_8__["FrameGrabber"](_inputStream, _canvasContainer.dom.image);
- counters = self._fillCounters(startInfo.end, endInfo.start, false);
- if (!self._verifyCounterLength(counters)) {
- return null;
+ _adjustWorkerPool(_config.numOfWorkers, function () {
+ if (_config.numOfWorkers === 0) {
+ _initializeData();
}
- code = self._decodePayload(counters, result, decodedCodes);
- if (!code) {
- return null;
- }
- if (result.length < 5) {
- return null;
- }
-
- decodedCodes.push(endInfo);
- return {
- code: result.join(""),
- start: startInfo.start,
- end: endInfo.end,
- startInfo: startInfo,
- decodedCodes: decodedCodes
- };
-};
-
-/* harmony default export */ __webpack_exports__["a"] = TwoOfFiveReader;
-
-/***/ }),
-/* 68 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__barcode_reader__ = __webpack_require__(1);
+ _inputStream.play();
-function CodabarReader() {
- __WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].call(this);
- this._counters = [];
+ cb();
+ });
}
-var properties = {
- ALPHABETH_STRING: { value: "0123456789-$:/.+ABCD" },
- ALPHABET: { value: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 36, 58, 47, 46, 43, 65, 66, 67, 68] },
- CHARACTER_ENCODINGS: { value: [0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, 0x00c, 0x018, 0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E] },
- START_END: { value: [0x01A, 0x029, 0x00B, 0x00E] },
- MIN_ENCODED_CHARS: { value: 4 },
- MAX_ACCEPTABLE: { value: 2.0 },
- PADDING: { value: 1.5 },
- FORMAT: { value: "codabar", writeable: false }
-};
-
-CodabarReader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].prototype, properties);
-CodabarReader.prototype.constructor = CodabarReader;
+function _initCanvas() {
+ if (typeof document !== 'undefined') {
+ var viewport = _getViewPort();
-CodabarReader.prototype._decode = function () {
- var self = this,
- result = [],
- start,
- decodedChar,
- pattern,
- nextStart,
- end;
-
- this._counters = self._fillCounters();
- start = self._findStart();
- if (!start) {
- return null;
- }
- nextStart = start.startCounter;
-
- do {
- pattern = self._toPattern(nextStart);
- if (pattern < 0) {
- return null;
- }
- decodedChar = self._patternToChar(pattern);
- if (decodedChar < 0) {
- return null;
- }
- result.push(decodedChar);
- nextStart += 8;
- if (result.length > 1 && self._isStartEnd(pattern)) {
- break;
- }
- } while (nextStart < self._counters.length);
-
- // verify end
- if (result.length - 2 < self.MIN_ENCODED_CHARS || !self._isStartEnd(pattern)) {
- return null;
- }
+ _canvasContainer.dom.image = document.querySelector('canvas.imgBuffer');
- // verify end white space
- if (!self._verifyWhitespace(start.startCounter, nextStart - 8)) {
- return null;
- }
+ if (!_canvasContainer.dom.image) {
+ _canvasContainer.dom.image = document.createElement('canvas');
+ _canvasContainer.dom.image.className = 'imgBuffer';
- if (!self._validateResult(result, start.startCounter)) {
- return null;
+ if (viewport && _config.inputStream.type === 'ImageStream') {
+ viewport.appendChild(_canvasContainer.dom.image);
+ }
}
- nextStart = nextStart > self._counters.length ? self._counters.length : nextStart;
- end = start.start + self._sumCounters(start.startCounter, nextStart - 8);
+ _canvasContainer.ctx.image = _canvasContainer.dom.image.getContext('2d');
+ _canvasContainer.dom.image.width = _inputStream.canvasWidth;
+ _canvasContainer.dom.image.height = _inputStream.canvasHeight;
+ _canvasContainer.dom.overlay = document.querySelector('canvas.drawingBuffer');
- return {
- code: result.join(""),
- start: start.start,
- end: end,
- startInfo: start,
- decodedCodes: result
- };
-};
+ if (!_canvasContainer.dom.overlay) {
+ _canvasContainer.dom.overlay = document.createElement('canvas');
+ _canvasContainer.dom.overlay.className = 'drawingBuffer';
-CodabarReader.prototype._verifyWhitespace = function (startCounter, endCounter) {
- if (startCounter - 1 <= 0 || this._counters[startCounter - 1] >= this._calculatePatternLength(startCounter) / 2.0) {
- if (endCounter + 8 >= this._counters.length || this._counters[endCounter + 7] >= this._calculatePatternLength(endCounter) / 2.0) {
- return true;
- }
- }
- return false;
-};
+ if (viewport) {
+ viewport.appendChild(_canvasContainer.dom.overlay);
+ }
-CodabarReader.prototype._calculatePatternLength = function (offset) {
- var i,
- sum = 0;
+ var clearFix = document.createElement('br');
+ clearFix.setAttribute('clear', 'all');
- for (i = offset; i < offset + 7; i++) {
- sum += this._counters[i];
+ if (viewport) {
+ viewport.appendChild(clearFix);
+ }
}
- return sum;
-};
-
-CodabarReader.prototype._thresholdResultPattern = function (result, startCounter) {
- var self = this,
- categorization = {
- space: {
- narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE },
- wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE }
- },
- bar: {
- narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE },
- wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE }
- }
- },
- kind,
- cat,
- i,
- j,
- pos = startCounter,
- pattern;
-
- for (i = 0; i < result.length; i++) {
- pattern = self._charToPattern(result[i]);
- for (j = 6; j >= 0; j--) {
- kind = (j & 1) === 2 ? categorization.bar : categorization.space;
- cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;
- cat.size += self._counters[pos + j];
- cat.counts++;
- pattern >>= 1;
- }
- pos += 8;
- }
+ _canvasContainer.ctx.overlay = _canvasContainer.dom.overlay.getContext('2d');
+ _canvasContainer.dom.overlay.width = _inputStream.canvasWidth;
+ _canvasContainer.dom.overlay.height = _inputStream.canvasHeight;
+ }
+}
- ["space", "bar"].forEach(function (key) {
- var newkind = categorization[key];
- newkind.wide.min = Math.floor((newkind.narrow.size / newkind.narrow.counts + newkind.wide.size / newkind.wide.counts) / 2);
- newkind.narrow.max = Math.ceil(newkind.wide.min);
- newkind.wide.max = Math.ceil((newkind.wide.size * self.MAX_ACCEPTABLE + self.PADDING) / newkind.wide.counts);
+function _initBuffers(imageWrapper) {
+ if (imageWrapper) {
+ _inputImageWrapper = imageWrapper;
+ } else {
+ _inputImageWrapper = new _common_image_wrapper__WEBPACK_IMPORTED_MODULE_3__["ImageWrapper"]({
+ x: _inputStream.width,
+ y: _inputStream.height
});
+ }
- return categorization;
-};
-
-CodabarReader.prototype._charToPattern = function (char) {
- var self = this,
- charCode = char.charCodeAt(0),
- i;
-
- for (i = 0; i < self.ALPHABET.length; i++) {
- if (self.ALPHABET[i] === charCode) {
- return self.CHARACTER_ENCODINGS[i];
- }
- }
- return 0x0;
-};
-
-CodabarReader.prototype._validateResult = function (result, startCounter) {
- var self = this,
- thresholds = self._thresholdResultPattern(result, startCounter),
- i,
- j,
- kind,
- cat,
- size,
- pos = startCounter,
- pattern;
-
- for (i = 0; i < result.length; i++) {
- pattern = self._charToPattern(result[i]);
- for (j = 6; j >= 0; j--) {
- kind = (j & 1) === 0 ? thresholds.bar : thresholds.space;
- cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;
- size = self._counters[pos + j];
- if (size < cat.min || size > cat.max) {
- return false;
- }
- pattern >>= 1;
- }
- pos += 8;
- }
- return true;
-};
-
-CodabarReader.prototype._patternToChar = function (pattern) {
- var i,
- self = this;
-
- for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {
- if (self.CHARACTER_ENCODINGS[i] === pattern) {
- return String.fromCharCode(self.ALPHABET[i]);
- }
- }
- return -1;
-};
-
-CodabarReader.prototype._computeAlternatingThreshold = function (offset, end) {
- var i,
- min = Number.MAX_VALUE,
- max = 0,
- counter;
-
- for (i = offset; i < end; i += 2) {
- counter = this._counters[i];
- if (counter > max) {
- max = counter;
- }
- if (counter < min) {
- min = counter;
- }
- }
-
- return (min + max) / 2.0 | 0;
-};
-
-CodabarReader.prototype._toPattern = function (offset) {
- var numCounters = 7,
- end = offset + numCounters,
- barThreshold,
- spaceThreshold,
- bitmask = 1 << numCounters - 1,
- pattern = 0,
- i,
- threshold;
-
- if (end > this._counters.length) {
- return -1;
- }
-
- barThreshold = this._computeAlternatingThreshold(offset, end);
- spaceThreshold = this._computeAlternatingThreshold(offset + 1, end);
-
- for (i = 0; i < numCounters; i++) {
- threshold = (i & 1) === 0 ? barThreshold : spaceThreshold;
- if (this._counters[offset + i] > threshold) {
- pattern |= bitmask;
- }
- bitmask >>= 1;
- }
-
- return pattern;
-};
-
-CodabarReader.prototype._isStartEnd = function (pattern) {
- var i;
-
- for (i = 0; i < this.START_END.length; i++) {
- if (this.START_END[i] === pattern) {
- return true;
- }
- }
- return false;
-};
-
-CodabarReader.prototype._sumCounters = function (start, end) {
- var i,
- sum = 0;
-
- for (i = start; i < end; i++) {
- sum += this._counters[i];
- }
- return sum;
-};
-
-CodabarReader.prototype._findStart = function () {
- var self = this,
- i,
- pattern,
- start = self._nextUnset(self._row),
- end;
-
- for (i = 1; i < this._counters.length; i++) {
- pattern = self._toPattern(i);
- if (pattern !== -1 && self._isStartEnd(pattern)) {
- // TODO: Look for whitespace ahead
- start += self._sumCounters(0, i);
- end = start + self._sumCounters(i, i + 8);
- return {
- start: start,
- end: end,
- startCounter: i,
- endCounter: i + 8
- };
- }
- }
-};
-
-/* harmony default export */ __webpack_exports__["a"] = CodabarReader;
-
-/***/ }),
-/* 69 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__barcode_reader__ = __webpack_require__(1);
-
+ if (true) {
+ console.log(_inputImageWrapper.size);
+ }
-function Code128Reader() {
- __WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].call(this);
+ _boxSize = [{
+ x: 0,
+ y: 0
+ }, {
+ x: 0,
+ y: _inputImageWrapper.size.y
+ }, {
+ x: _inputImageWrapper.size.x,
+ y: _inputImageWrapper.size.y
+ }, {
+ x: _inputImageWrapper.size.x,
+ y: 0
+ }];
+ _locator = new _locator_barcode_locator__WEBPACK_IMPORTED_MODULE_13__["BarcodeLocator"](_inputImageWrapper, _config.locator);
+}
+
+function _transform(polygon, offset) {
+ polygon.forEach(function (vertex) {
+ vertex.x += offset.x;
+ vertex.y += offset.y;
+ });
}
-var properties = {
- CODE_SHIFT: { value: 98 },
- CODE_C: { value: 99 },
- CODE_B: { value: 100 },
- CODE_A: { value: 101 },
- START_CODE_A: { value: 103 },
- START_CODE_B: { value: 104 },
- START_CODE_C: { value: 105 },
- STOP_CODE: { value: 106 },
- CODE_PATTERN: { value: [[2, 1, 2, 2, 2, 2], [2, 2, 2, 1, 2, 2], [2, 2, 2, 2, 2, 1], [1, 2, 1, 2, 2, 3], [1, 2, 1, 3, 2, 2], [1, 3, 1, 2, 2, 2], [1, 2, 2, 2, 1, 3], [1, 2, 2, 3, 1, 2], [1, 3, 2, 2, 1, 2], [2, 2, 1, 2, 1, 3], [2, 2, 1, 3, 1, 2], [2, 3, 1, 2, 1, 2], [1, 1, 2, 2, 3, 2], [1, 2, 2, 1, 3, 2], [1, 2, 2, 2, 3, 1], [1, 1, 3, 2, 2, 2], [1, 2, 3, 1, 2, 2], [1, 2, 3, 2, 2, 1], [2, 2, 3, 2, 1, 1], [2, 2, 1, 1, 3, 2], [2, 2, 1, 2, 3, 1], [2, 1, 3, 2, 1, 2], [2, 2, 3, 1, 1, 2], [3, 1, 2, 1, 3, 1], [3, 1, 1, 2, 2, 2], [3, 2, 1, 1, 2, 2], [3, 2, 1, 2, 2, 1], [3, 1, 2, 2, 1, 2], [3, 2, 2, 1, 1, 2], [3, 2, 2, 2, 1, 1], [2, 1, 2, 1, 2, 3], [2, 1, 2, 3, 2, 1], [2, 3, 2, 1, 2, 1], [1, 1, 1, 3, 2, 3], [1, 3, 1, 1, 2, 3], [1, 3, 1, 3, 2, 1], [1, 1, 2, 3, 1, 3], [1, 3, 2, 1, 1, 3], [1, 3, 2, 3, 1, 1], [2, 1, 1, 3, 1, 3], [2, 3, 1, 1, 1, 3], [2, 3, 1, 3, 1, 1], [1, 1, 2, 1, 3, 3], [1, 1, 2, 3, 3, 1], [1, 3, 2, 1, 3, 1], [1, 1, 3, 1, 2, 3], [1, 1, 3, 3, 2, 1], [1, 3, 3, 1, 2, 1], [3, 1, 3, 1, 2, 1], [2, 1, 1, 3, 3, 1], [2, 3, 1, 1, 3, 1], [2, 1, 3, 1, 1, 3], [2, 1, 3, 3, 1, 1], [2, 1, 3, 1, 3, 1], [3, 1, 1, 1, 2, 3], [3, 1, 1, 3, 2, 1], [3, 3, 1, 1, 2, 1], [3, 1, 2, 1, 1, 3], [3, 1, 2, 3, 1, 1], [3, 3, 2, 1, 1, 1], [3, 1, 4, 1, 1, 1], [2, 2, 1, 4, 1, 1], [4, 3, 1, 1, 1, 1], [1, 1, 1, 2, 2, 4], [1, 1, 1, 4, 2, 2], [1, 2, 1, 1, 2, 4], [1, 2, 1, 4, 2, 1], [1, 4, 1, 1, 2, 2], [1, 4, 1, 2, 2, 1], [1, 1, 2, 2, 1, 4], [1, 1, 2, 4, 1, 2], [1, 2, 2, 1, 1, 4], [1, 2, 2, 4, 1, 1], [1, 4, 2, 1, 1, 2], [1, 4, 2, 2, 1, 1], [2, 4, 1, 2, 1, 1], [2, 2, 1, 1, 1, 4], [4, 1, 3, 1, 1, 1], [2, 4, 1, 1, 1, 2], [1, 3, 4, 1, 1, 1], [1, 1, 1, 2, 4, 2], [1, 2, 1, 1, 4, 2], [1, 2, 1, 2, 4, 1], [1, 1, 4, 2, 1, 2], [1, 2, 4, 1, 1, 2], [1, 2, 4, 2, 1, 1], [4, 1, 1, 2, 1, 2], [4, 2, 1, 1, 1, 2], [4, 2, 1, 2, 1, 1], [2, 1, 2, 1, 4, 1], [2, 1, 4, 1, 2, 1], [4, 1, 2, 1, 2, 1], [1, 1, 1, 1, 4, 3], [1, 1, 1, 3, 4, 1], [1, 3, 1, 1, 4, 1], [1, 1, 4, 1, 1, 3], [1, 1, 4, 3, 1, 1], [4, 1, 1, 1, 1, 3], [4, 1, 1, 3, 1, 1], [1, 1, 3, 1, 4, 1], [1, 1, 4, 1, 3, 1], [3, 1, 1, 1, 4, 1], [4, 1, 1, 1, 3, 1], [2, 1, 1, 4, 1, 2], [2, 1, 1, 2, 1, 4], [2, 1, 1, 2, 3, 2], [2, 3, 3, 1, 1, 1, 2]] },
- SINGLE_CODE_ERROR: { value: 0.64 },
- AVG_CODE_ERROR: { value: 0.30 },
- FORMAT: { value: "code_128", writeable: false },
- MODULE_INDICES: { value: { bar: [0, 2, 4], space: [1, 3, 5] } }
-};
-
-Code128Reader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].prototype, properties);
-Code128Reader.prototype.constructor = Code128Reader;
-
-Code128Reader.prototype._decodeCode = function (start, correction) {
- var counter = [0, 0, 0, 0, 0, 0],
- i,
- self = this,
- offset = start,
- isWhite = !self._row[offset],
- counterPos = 0,
- bestMatch = {
- error: Number.MAX_VALUE,
- code: -1,
- start: start,
- end: start,
- correction: {
- bar: 1,
- space: 1
- }
- },
- code,
- error;
-
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- if (counterPos === counter.length - 1) {
- if (correction) {
- self._correct(counter, correction);
- }
- for (code = 0; code < self.CODE_PATTERN.length; code++) {
- error = self._matchPattern(counter, self.CODE_PATTERN[code]);
- if (error < bestMatch.error) {
- bestMatch.code = code;
- bestMatch.error = error;
- }
- }
- bestMatch.end = i;
- if (bestMatch.code === -1 || bestMatch.error > self.AVG_CODE_ERROR) {
- return null;
- }
- if (self.CODE_PATTERN[bestMatch.code]) {
- bestMatch.correction.bar = calculateCorrection(self.CODE_PATTERN[bestMatch.code], counter, this.MODULE_INDICES.bar);
- bestMatch.correction.space = calculateCorrection(self.CODE_PATTERN[bestMatch.code], counter, this.MODULE_INDICES.space);
- }
- return bestMatch;
- } else {
- counterPos++;
- }
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- return null;
-};
-
-Code128Reader.prototype._correct = function (counter, correction) {
- this._correctBars(counter, correction.bar, this.MODULE_INDICES.bar);
- this._correctBars(counter, correction.space, this.MODULE_INDICES.space);
-};
+function _transformResult(result, offset) {
+ if (result.barcodes) {
+ result.barcodes.forEach(function (barcode) {
+ return _transformResult(barcode, offset);
+ });
+ }
-Code128Reader.prototype._findStart = function () {
- var counter = [0, 0, 0, 0, 0, 0],
- i,
- self = this,
- offset = self._nextSet(self._row),
- isWhite = false,
- counterPos = 0,
- bestMatch = {
- error: Number.MAX_VALUE,
- code: -1,
- start: 0,
- end: 0,
- correction: {
- bar: 1,
- space: 1
- }
- },
- code,
- error,
- j,
- sum;
-
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- if (counterPos === counter.length - 1) {
- sum = 0;
- for (j = 0; j < counter.length; j++) {
- sum += counter[j];
- }
- for (code = self.START_CODE_A; code <= self.START_CODE_C; code++) {
- error = self._matchPattern(counter, self.CODE_PATTERN[code]);
- if (error < bestMatch.error) {
- bestMatch.code = code;
- bestMatch.error = error;
- }
- }
- if (bestMatch.error < self.AVG_CODE_ERROR) {
- bestMatch.start = i - sum;
- bestMatch.end = i;
- bestMatch.correction.bar = calculateCorrection(self.CODE_PATTERN[bestMatch.code], counter, this.MODULE_INDICES.bar);
- bestMatch.correction.space = calculateCorrection(self.CODE_PATTERN[bestMatch.code], counter, this.MODULE_INDICES.space);
- return bestMatch;
- }
+ if (result.line) {
+ _transform(result.line, offset);
+ }
- for (j = 0; j < 4; j++) {
- counter[j] = counter[j + 2];
- }
- counter[4] = 0;
- counter[5] = 0;
- counterPos--;
- } else {
- counterPos++;
- }
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- return null;
-};
+ if (result.box) {
+ _transform(result.box, offset);
+ }
-Code128Reader.prototype._decode = function () {
- var self = this,
- startInfo = self._findStart(),
- code = null,
- done = false,
- result = [],
- multiplier = 0,
- checksum = 0,
- codeset,
- rawResult = [],
- decodedCodes = [],
- shiftNext = false,
- unshift,
- removeLastCharacter = true;
-
- if (startInfo === null) {
- return null;
- }
- code = {
- code: startInfo.code,
- start: startInfo.start,
- end: startInfo.end,
- correction: {
- bar: startInfo.correction.bar,
- space: startInfo.correction.space
- }
- };
- decodedCodes.push(code);
- checksum = code.code;
- switch (code.code) {
- case self.START_CODE_A:
- codeset = self.CODE_A;
- break;
- case self.START_CODE_B:
- codeset = self.CODE_B;
- break;
- case self.START_CODE_C:
- codeset = self.CODE_C;
- break;
- default:
- return null;
- }
+ if (result.boxes) {
+ result.boxes.forEach(function (box) {
+ return _transform(box, offset);
+ });
+ }
+}
- while (!done) {
- unshift = shiftNext;
- shiftNext = false;
- code = self._decodeCode(code.end, code.correction);
- if (code !== null) {
- if (code.code !== self.STOP_CODE) {
- removeLastCharacter = true;
- }
+function _addResult(result, imageData, canvasWidth, canvasHeight) {
+ if (imageData && _resultCollector) {
+ if (result.barcodes) {
+ result.barcodes.forEach(function (_ref2) {
+ var codeResult = _ref2.codeResult;
- if (code.code !== self.STOP_CODE) {
- rawResult.push(code.code);
- multiplier++;
- checksum += multiplier * code.code;
- }
- decodedCodes.push(code);
-
- switch (codeset) {
- case self.CODE_A:
- if (code.code < 64) {
- result.push(String.fromCharCode(32 + code.code));
- } else if (code.code < 96) {
- result.push(String.fromCharCode(code.code - 64));
- } else {
- if (code.code !== self.STOP_CODE) {
- removeLastCharacter = false;
- }
- switch (code.code) {
- case self.CODE_SHIFT:
- shiftNext = true;
- codeset = self.CODE_B;
- break;
- case self.CODE_B:
- codeset = self.CODE_B;
- break;
- case self.CODE_C:
- codeset = self.CODE_C;
- break;
- case self.STOP_CODE:
- done = true;
- break;
- }
- }
- break;
- case self.CODE_B:
- if (code.code < 96) {
- result.push(String.fromCharCode(32 + code.code));
- } else {
- if (code.code !== self.STOP_CODE) {
- removeLastCharacter = false;
- }
- switch (code.code) {
- case self.CODE_SHIFT:
- shiftNext = true;
- codeset = self.CODE_A;
- break;
- case self.CODE_A:
- codeset = self.CODE_A;
- break;
- case self.CODE_C:
- codeset = self.CODE_C;
- break;
- case self.STOP_CODE:
- done = true;
- break;
- }
- }
- break;
- case self.CODE_C:
- if (code.code < 100) {
- result.push(code.code < 10 ? "0" + code.code : code.code);
- } else {
- if (code.code !== self.STOP_CODE) {
- removeLastCharacter = false;
- }
- switch (code.code) {
- case self.CODE_A:
- codeset = self.CODE_A;
- break;
- case self.CODE_B:
- codeset = self.CODE_B;
- break;
- case self.STOP_CODE:
- done = true;
- break;
- }
- }
- break;
- }
- } else {
- done = true;
- }
- if (unshift) {
- codeset = codeset === self.CODE_A ? self.CODE_B : self.CODE_A;
+ if (codeResult) {
+ _resultCollector.addResult(imageData, canvasWidth, canvasHeight, codeResult);
}
+ });
+ } else if (result.codeResult) {
+ _resultCollector.addResult(imageData, canvasWidth, canvasHeight, result.codeResult);
}
+ }
+}
- if (code === null) {
- return null;
- }
+function _hasCodeResult(result) {
+ return result && (!!result.codeResult || result.barcodes && result.barcodes.some(function (barcode) {
+ return !!barcode.codeResult;
+ }));
+}
- code.end = self._nextUnset(self._row, code.end);
- if (!self._verifyTrailingWhitespace(code)) {
- return null;
- }
+function _publishResult(result, imageData) {
+ var resultToPublish = result;
- checksum -= multiplier * rawResult[rawResult.length - 1];
- if (checksum % 103 !== rawResult[rawResult.length - 1]) {
- return null;
- }
-
- if (!result.length) {
- return null;
- }
+ if (result && _onUIThread) {
+ var offset = _inputStream.topLeft;
- // remove last code from result (checksum)
- if (removeLastCharacter) {
- result.splice(result.length - 1, 1);
+ if (offset.x !== 0 || offset.y !== 0) {
+ _transformResult(result, offset);
}
- return {
- code: result.join(""),
- start: startInfo.start,
- end: code.end,
- codeset: codeset,
- startInfo: startInfo,
- decodedCodes: decodedCodes,
- endInfo: code
- };
-};
-
-__WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].prototype._verifyTrailingWhitespace = function (endInfo) {
- var self = this,
- trailingWhitespaceEnd;
+ _addResult(result, imageData, _inputStream.canvasWidth, _inputStream.canvasHeight);
- trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
- if (trailingWhitespaceEnd < self._row.length) {
- if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
- return endInfo;
- }
- }
- return null;
-};
+ resultToPublish = result.barcodes || result;
+ }
-function calculateCorrection(expected, normalized, indices) {
- var length = indices.length,
- sumNormalized = 0,
- sumExpected = 0;
+ _common_events__WEBPACK_IMPORTED_MODULE_1__["Events"].publish('processed', resultToPublish);
- while (length--) {
- sumExpected += expected[indices[length]];
- sumNormalized += normalized[indices[length]];
- }
- return sumExpected / sumNormalized;
+ if (_hasCodeResult(result)) {
+ _common_events__WEBPACK_IMPORTED_MODULE_1__["Events"].publish('detected', resultToPublish);
+ }
}
-/* harmony default export */ __webpack_exports__["a"] = Code128Reader;
-
-/***/ }),
-/* 70 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+function _locateAndDecode() {
+ var boxes = _config.locate ? _locator.locate() : [_boxSize];
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__code_39_reader__ = __webpack_require__(31);
+ var result = _decoder.decodeFromBoundingBoxes(boxes);
-
-function Code39VINReader() {
- __WEBPACK_IMPORTED_MODULE_0__code_39_reader__["a" /* default */].call(this);
+ _publishResult(result, _inputImageWrapper.data);
}
-var patterns = {
- IOQ: /[IOQ]/g,
- AZ09: /[A-Z0-9]{17}/
-};
-
-Code39VINReader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__code_39_reader__["a" /* default */].prototype);
-Code39VINReader.prototype.constructor = Code39VINReader;
+function _update() {
+ if (_onUIThread) {
+ if (_workerPool.length > 0) {
+ var availableWorker = _workerPool.find(function (_ref3) {
+ var busy = _ref3.busy;
+ return !busy;
+ });
-// Cribbed from:
-// https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/client/result/VINResultParser.java
-Code39VINReader.prototype._decode = function () {
- var result = __WEBPACK_IMPORTED_MODULE_0__code_39_reader__["a" /* default */].prototype._decode.apply(this);
- if (!result) {
- return null;
- }
+ if (!availableWorker) {
+ return; // all workers are busy
+ }
- var code = result.code;
+ var imageData = availableWorker.imageData;
- if (!code) {
- return null;
+ if (_frameGrabber.grab(imageData)) {
+ availableWorker.busy = true;
+ availableWorker.worker.postMessage({
+ cmd: 'process',
+ imageData: imageData
+ }, [imageData.buffer]);
+ }
+ } else if (_frameGrabber.grab(_inputImageWrapper.data)) {
+ _locateAndDecode();
}
+ } else {
+ _locateAndDecode();
+ }
+}
- code = code.replace(patterns.IOQ, '');
+function _startContinuousUpdate() {
+ var delay = 1000 / (_config.frequency || 60);
+ var next = null;
+ _stopped = false;
- if (!code.match(patterns.AZ09)) {
- if (true) {
- console.log('Failed AZ09 pattern code:', code);
- }
- return null;
- }
+ (function frame(timestamp) {
+ next = next || timestamp;
- if (!this._checkChecksum(code)) {
- return null;
- }
+ if (!_stopped) {
+ if (timestamp >= next) {
+ next += delay;
- result.code = code;
- return result;
-};
-
-Code39VINReader.prototype._checkChecksum = function (code) {
- // TODO
- return !!code;
-};
+ _update();
+ }
-/* harmony default export */ __webpack_exports__["a"] = Code39VINReader;
+ window.requestAnimationFrame(frame);
+ }
+ })(performance.now());
+}
-/***/ }),
-/* 71 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+function _initWorker(cb) {
+ var blobURL = _generateWorkerBlob();
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__barcode_reader__ = __webpack_require__(1);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_array_helper__ = __webpack_require__(3);
+ var workerThread = {
+ worker: new Worker(blobURL),
+ imageData: new Uint8Array(_inputStream.width * _inputStream.height),
+ busy: true
+ };
+ workerThread.worker.onmessage = function (_ref4) {
+ var data = _ref4.data;
+ if (data.event === 'initialized') {
+ URL.revokeObjectURL(blobURL);
+ workerThread.busy = false;
+ workerThread.imageData = new Uint8Array(data.imageData);
-function Code93Reader() {
- __WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].call(this);
-}
+ if (true) {
+ console.log('Worker initialized');
+ }
-var ALPHABETH_STRING = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*";
+ cb(workerThread);
+ } else if (data.event === 'processed') {
+ workerThread.busy = false;
+ workerThread.imageData = new Uint8Array(data.imageData);
-var properties = {
- ALPHABETH_STRING: { value: ALPHABETH_STRING },
- ALPHABET: { value: ALPHABETH_STRING.split('').map(function (char) {
- return char.charCodeAt(0);
- }) },
- CHARACTER_ENCODINGS: { value: [0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, 0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A, 0x168, 0x164, 0x162, 0x134, 0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, 0x196, 0x19A, 0x16C, 0x166, 0x136, 0x13A, 0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, 0x126, 0x1DA, 0x1D6, 0x132, 0x15E] },
- ASTERISK: { value: 0x15E },
- FORMAT: { value: "code_93", writeable: false }
-};
+ _publishResult(data.result, workerThread.imageData);
+ } else if (data.event === 'error') {
+ if (true) {
+ console.log('Worker error:', data.message);
+ }
+ }
+ };
-Code93Reader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a" /* default */].prototype, properties);
-Code93Reader.prototype.constructor = Code93Reader;
+ workerThread.worker.postMessage({
+ cmd: 'init',
+ size: {
+ x: _inputStream.width,
+ y: _inputStream.height
+ },
+ imageData: workerThread.imageData,
+ config: Object(_common_merge__WEBPACK_IMPORTED_MODULE_4__["merge"])(_config, {
+ inputStream: {
+ target: null
+ }
+ })
+ }, [workerThread.imageData.buffer]);
+}
-Code93Reader.prototype._decode = function () {
- var self = this,
- counters = [0, 0, 0, 0, 0, 0],
- result = [],
- start = self._findStart(),
- decodedChar,
- lastStart,
- pattern,
- nextStart;
-
- if (!start) {
- return null;
- }
- nextStart = self._nextSet(self._row, start.end);
+function _workerInterface(factory) {
+ var Quagga;
+ var worker = self;
+ var imageWrapper;
- do {
- counters = self._toCounters(nextStart, counters);
- pattern = self._toPattern(counters);
- if (pattern < 0) {
- return null;
- }
- decodedChar = self._patternToChar(pattern);
- if (decodedChar < 0) {
- return null;
- }
- result.push(decodedChar);
- lastStart = nextStart;
- nextStart += __WEBPACK_IMPORTED_MODULE_1__common_array_helper__["a" /* default */].sum(counters);
- nextStart = self._nextSet(self._row, nextStart);
- } while (decodedChar !== '*');
- result.pop();
+ if (factory) {
+ Quagga = factory()["default"];
- if (!result.length) {
- return null;
+ if (!Quagga) {
+ worker.postMessage({
+ event: 'error',
+ message: 'Quagga could not be created'
+ });
+ return;
}
+ }
- if (!self._verifyEnd(lastStart, nextStart, counters)) {
- return null;
+ self.onmessage = function (_ref5) {
+ var data = _ref5.data;
+
+ if (data.cmd === 'init') {
+ var config = data.config;
+ config.numOfWorkers = 0;
+ imageWrapper = new Quagga.ImageWrapper({
+ x: data.size.x,
+ y: data.size.y
+ }, new Uint8Array(data.imageData));
+ Quagga.init(config, function () {
+ return worker.postMessage({
+ event: 'initialized',
+ imageData: imageWrapper.data
+ }, [imageWrapper.data.buffer]);
+ }, imageWrapper);
+ Quagga.onProcessed(function (result) {
+ return worker.postMessage({
+ event: 'processed',
+ imageData: imageWrapper.data,
+ result: result
+ }, [imageWrapper.data.buffer]);
+ });
+ } else if (data.cmd === 'process') {
+ imageWrapper.data = new Uint8Array(data.imageData);
+ Quagga.start();
+ } else if (data.cmd === 'setReaders') {
+ Quagga.setReaders(data.readers);
}
+ };
+}
- if (!self._verifyChecksums(result)) {
- return null;
- }
+function _generateWorkerBlob() {
+ // @ts-ignore
+ var factorySource = __factorySource__ || '';
+ var blob = new Blob(["(".concat(_workerInterface.toString(), ")(").concat(factorySource, ");")], {
+ type: 'text/javascript'
+ });
+ return window.URL.createObjectURL(blob);
+}
- result = result.slice(0, result.length - 2);
- if ((result = self._decodeExtended(result)) === null) {
- return null;
- };
+function _adjustWorkerPool(capacity, cb) {
+ var increaseBy = capacity - _workerPool.length;
- return {
- code: result.join(""),
- start: start.start,
- end: nextStart,
- startInfo: start,
- decodedCodes: result
- };
-};
+ if (increaseBy > 0) {
+ for (var i = 0; i < increaseBy; i++) {
+ _initWorker(function (workerThread) {
+ _workerPool.push(workerThread);
-Code93Reader.prototype._verifyEnd = function (lastStart, nextStart) {
- if (lastStart === nextStart || !this._row[nextStart]) {
- return false;
+ if (_workerPool.length >= capacity && cb) {
+ cb();
+ }
+ });
}
- return true;
-};
-
-Code93Reader.prototype._patternToChar = function (pattern) {
- var i,
- self = this;
+ } else {
+ if (increaseBy < 0) {
+ _workerPool.slice(increaseBy).forEach(function (_ref6) {
+ var worker = _ref6.worker;
+ worker.terminate();
- for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {
- if (self.CHARACTER_ENCODINGS[i] === pattern) {
- return String.fromCharCode(self.ALPHABET[i]);
+ if (true) {
+ console.log('Worker terminated!');
}
- }
- return -1;
-};
+ });
-Code93Reader.prototype._toPattern = function (counters) {
- var numCounters = counters.length;
- var pattern = 0;
- var sum = 0;
- for (var i = 0; i < numCounters; i++) {
- sum += counters[i];
+ _workerPool = _workerPool.slice(0, increaseBy);
}
- for (var _i = 0; _i < numCounters; _i++) {
- var normalized = Math.round(counters[_i] * 9 / sum);
- if (normalized < 1 || normalized > 4) {
- return -1;
- }
- if ((_i & 1) === 0) {
- for (var j = 0; j < normalized; j++) {
- pattern = pattern << 1 | 1;
- }
- } else {
- pattern <<= normalized;
- }
- }
+ return cb && cb();
+ }
+}
- return pattern;
-};
+/***/ }),
-Code93Reader.prototype._findStart = function () {
- var self = this,
- offset = self._nextSet(self._row),
- patternStart = offset,
- counter = [0, 0, 0, 0, 0, 0],
- counterPos = 0,
- isWhite = false,
- i,
- j,
- whiteSpaceMustStart;
-
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
- } else {
- if (counterPos === counter.length - 1) {
- // find start pattern
- if (self._toPattern(counter) === self.ASTERISK) {
- whiteSpaceMustStart = Math.floor(Math.max(0, patternStart - (i - patternStart) / 4));
- if (self._matchRange(whiteSpaceMustStart, patternStart, 0)) {
- return {
- start: patternStart,
- end: i
- };
- }
- }
+/***/ "./src/reader/2of5-reader.ts":
+/*!***********************************!*\
+ !*** ./src/reader/2of5-reader.ts ***!
+ \***********************************/
+/*! exports provided: TwoOfFiveReader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- patternStart += counter[0] + counter[1];
- for (j = 0; j < 4; j++) {
- counter[j] = counter[j + 2];
- }
- counter[4] = 0;
- counter[5] = 0;
- counterPos--;
- } else {
- counterPos++;
- }
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- return null;
-};
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TwoOfFiveReader", function() { return TwoOfFiveReader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/assertThisInitialized */ "../../node_modules/@babel/runtime/helpers/assertThisInitialized.js");
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var _barcode_reader__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./barcode-reader */ "./src/reader/barcode-reader.ts");
-Code93Reader.prototype._decodeExtended = function (charArray) {
- var length = charArray.length;
- var result = [];
- for (var i = 0; i < length; i++) {
- var char = charArray[i];
- if (char >= 'a' && char <= 'd') {
- if (i > length - 2) {
- return null;
- }
- var nextChar = charArray[++i];
- var nextCharCode = nextChar.charCodeAt(0);
- var decodedChar = void 0;
- switch (char) {
- case 'a':
- if (nextChar >= 'A' && nextChar <= 'Z') {
- decodedChar = String.fromCharCode(nextCharCode - 64);
- } else {
- return null;
- }
- break;
- case 'b':
- if (nextChar >= 'A' && nextChar <= 'E') {
- decodedChar = String.fromCharCode(nextCharCode - 38);
- } else if (nextChar >= 'F' && nextChar <= 'J') {
- decodedChar = String.fromCharCode(nextCharCode - 11);
- } else if (nextChar >= 'K' && nextChar <= 'O') {
- decodedChar = String.fromCharCode(nextCharCode + 16);
- } else if (nextChar >= 'P' && nextChar <= 'S') {
- decodedChar = String.fromCharCode(nextCharCode + 43);
- } else if (nextChar >= 'T' && nextChar <= 'Z') {
- decodedChar = String.fromCharCode(127);
- } else {
- return null;
- }
- break;
- case 'c':
- if (nextChar >= 'A' && nextChar <= 'O') {
- decodedChar = String.fromCharCode(nextCharCode - 32);
- } else if (nextChar === 'Z') {
- decodedChar = ':';
- } else {
- return null;
- }
- break;
- case 'd':
- if (nextChar >= 'A' && nextChar <= 'Z') {
- decodedChar = String.fromCharCode(nextCharCode + 32);
- } else {
- return null;
- }
- break;
- }
- result.push(decodedChar);
- } else {
- result.push(char);
- }
- }
- return result;
-};
-Code93Reader.prototype._verifyChecksums = function (charArray) {
- return this._matchCheckChar(charArray, charArray.length - 2, 20) && this._matchCheckChar(charArray, charArray.length - 1, 15);
-};
-Code93Reader.prototype._matchCheckChar = function (charArray, index, maxWeight) {
- var _this = this;
- var arrayToCheck = charArray.slice(0, index);
- var length = arrayToCheck.length;
- var weightedSums = arrayToCheck.reduce(function (sum, char, i) {
- var weight = (i * -1 + (length - 1)) % maxWeight + 1;
- var value = _this.ALPHABET.indexOf(char.charCodeAt(0));
- return sum + weight * value;
- }, 0);
- var checkChar = this.ALPHABET[weightedSums % 47];
- return checkChar === charArray[index].charCodeAt(0);
-};
-/* harmony default export */ __webpack_exports__["a"] = Code93Reader;
-/***/ }),
-/* 72 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ean_reader__ = __webpack_require__(4);
+var N = 1;
+var W = 3;
+var START_PATTERN = [W, N, W, N, N, N];
+var STOP_PATTERN = [W, N, N, N, W];
+var CODE_PATTERN = [[N, N, W, W, N], [W, N, N, N, W], [N, W, N, N, W], [W, W, N, N, N], [N, N, W, N, W], [W, N, W, N, N], [N, W, W, N, N], [N, N, N, W, W], [W, N, N, W, N], [N, W, N, W, N]];
+var startPatternLength = START_PATTERN.reduce(function (sum, val) {
+ return sum + val;
+}, 0);
+var TwoOfFiveReader =
+/*#__PURE__*/
+function (_BarcodeReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default()(TwoOfFiveReader, _BarcodeReader);
+ function TwoOfFiveReader(config) {
+ var _this;
-function EAN2Reader() {
- __WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].call(this);
-}
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, TwoOfFiveReader);
-var properties = {
- FORMAT: { value: "ean_2", writeable: false }
-};
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(TwoOfFiveReader).call(this, config));
-EAN2Reader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].prototype, properties);
-EAN2Reader.prototype.constructor = EAN2Reader;
-
-EAN2Reader.prototype.decode = function (row, start) {
- this._row = row;
- var counters = [0, 0, 0, 0],
- codeFrequency = 0,
- i = 0,
- offset = start,
- end = this._row.length,
- code,
- result = [],
- decodedCodes = [];
-
- for (i = 0; i < 2 && offset < end; i++) {
- code = this._decodeCode(offset);
- if (!code) {
- return null;
- }
- decodedCodes.push(code);
- result.push(code.code % 10);
- if (code.code >= this.CODE_G_START) {
- codeFrequency |= 1 << 1 - i;
- }
- if (i != 1) {
- offset = this._nextSet(this._row, code.end);
- offset = this._nextUnset(this._row, offset);
- }
- }
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_6___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_4___default()(_this), "_barSpaceRatio", void 0);
+
+ _this._barSpaceRatio = [1, 1];
+ _this._format = '2of5';
+ _this._singleCodeError = 0.78;
+ _this._averageCodeError = 0.30;
+ return _this;
+ }
+
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(TwoOfFiveReader, [{
+ key: "decode",
+ value: function decode() {
+ var startInfo = this._findStart();
- if (result.length != 2 || parseInt(result.join("")) % 4 !== codeFrequency) {
+ if (!startInfo) {
return null;
- }
- return {
- code: result.join(""),
- decodedCodes: decodedCodes,
- end: code.end
- };
-};
+ }
-/* harmony default export */ __webpack_exports__["a"] = EAN2Reader;
+ var endInfo = this._findEnd();
-/***/ }),
-/* 73 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ if (!endInfo) {
+ return null;
+ }
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ean_reader__ = __webpack_require__(4);
+ var counters = this._fillCounters(startInfo.end, endInfo.start, 0);
+ if (counters.length % 10 !== 0) {
+ return null;
+ }
-function EAN5Reader() {
- __WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].call(this);
-}
+ var result = new Array();
+ var decodedCodes = new Array();
+ decodedCodes.push(startInfo);
-var properties = {
- FORMAT: { value: "ean_5", writeable: false }
-};
+ var code = this._decodePayload(counters, result, decodedCodes);
-var CHECK_DIGIT_ENCODINGS = [24, 20, 18, 17, 12, 6, 3, 10, 9, 5];
+ if (!code || result.length < 5) {
+ return null;
+ }
-EAN5Reader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].prototype, properties);
-EAN5Reader.prototype.constructor = EAN5Reader;
+ decodedCodes.push(endInfo);
+ return {
+ code: result.join(''),
+ start: startInfo.start,
+ end: endInfo.end,
+ startInfo: startInfo,
+ decodedCodes: decodedCodes
+ };
+ }
+ }, {
+ key: "_findStart",
+ value: function _findStart() {
+ var offset = this._nextSet(this._row);
-EAN5Reader.prototype.decode = function (row, start) {
- this._row = row;
- var counters = [0, 0, 0, 0],
- codeFrequency = 0,
- i = 0,
- offset = start,
- end = this._row.length,
- code,
- result = [],
- decodedCodes = [];
+ var narrowBarWidth = 1;
+ var startInfo;
- for (i = 0; i < 5 && offset < end; i++) {
- code = this._decodeCode(offset);
- if (!code) {
- return null;
- }
- decodedCodes.push(code);
- result.push(code.code % 10);
- if (code.code >= this.CODE_G_START) {
- codeFrequency |= 1 << 4 - i;
+ while (!startInfo) {
+ startInfo = this._findPattern(START_PATTERN, offset, 0, true);
+
+ if (!startInfo) {
+ return null;
}
- if (i != 4) {
- offset = this._nextSet(this._row, code.end);
- offset = this._nextUnset(this._row, offset);
+
+ narrowBarWidth = (startInfo.end - startInfo.start) / startPatternLength | 0;
+ var leadingWhitespaceStart = startInfo.start - narrowBarWidth * 5;
+
+ if (leadingWhitespaceStart >= 0) {
+ if (this._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {
+ return startInfo;
+ }
}
- }
- if (result.length != 5) {
- return null;
- }
+ offset = startInfo.end;
+ startInfo = null;
+ }
- if (extensionChecksum(result) !== determineCheckDigit(codeFrequency)) {
- return null;
+ return null;
}
- return {
- code: result.join(""),
- decodedCodes: decodedCodes,
- end: code.end
- };
-};
+ }, {
+ key: "_verifyTrailingWhitespace",
+ value: function _verifyTrailingWhitespace(endInfo) {
+ var trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
-function determineCheckDigit(codeFrequency) {
- var i;
- for (i = 0; i < 10; i++) {
- if (codeFrequency === CHECK_DIGIT_ENCODINGS[i]) {
- return i;
+ if (trailingWhitespaceEnd < this._row.length) {
+ if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
+ return endInfo;
}
- }
- return null;
-}
-
-function extensionChecksum(result) {
- var length = result.length,
- sum = 0,
- i;
+ }
- for (i = length - 2; i >= 0; i -= 2) {
- sum += result[i];
- }
- sum *= 3;
- for (i = length - 1; i >= 0; i -= 2) {
- sum += result[i];
+ return null;
}
- sum *= 3;
- return sum % 10;
-}
-
-/* harmony default export */ __webpack_exports__["a"] = EAN5Reader;
+ }, {
+ key: "_findEnd",
+ value: function _findEnd() {
+ this._row.reverse();
-/***/ }),
-/* 74 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ var offset = this._nextSet(this._row);
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ean_reader__ = __webpack_require__(4);
+ var endInfo = this._findPattern(STOP_PATTERN, offset, 0, true);
+ this._row.reverse();
-function EAN8Reader(opts, supplements) {
- __WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].call(this, opts, supplements);
-}
+ if (endInfo === null) {
+ return null;
+ } // reverse numbers
-var properties = {
- FORMAT: { value: "ean_8", writeable: false }
-};
-EAN8Reader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].prototype, properties);
-EAN8Reader.prototype.constructor = EAN8Reader;
+ var start = endInfo.start;
+ endInfo.start = this._row.length - endInfo.end;
+ endInfo.end = this._row.length - start;
+ return endInfo !== null ? this._verifyTrailingWhitespace(endInfo) : null;
+ }
+ }, {
+ key: "_decodeCode",
+ value: function _decodeCode(counter) {
+ var bestMatch = {
+ error: Number.MAX_VALUE,
+ code: -1,
+ start: 0,
+ end: 0
+ };
-EAN8Reader.prototype._decodePayload = function (code, result, decodedCodes) {
- var i,
- self = this;
+ for (var code = 0; code < CODE_PATTERN.length; code++) {
+ var error = this._matchPattern(counter, CODE_PATTERN[code]);
- for (i = 0; i < 4; i++) {
- code = self._decodeCode(code.end, self.CODE_G_START);
- if (!code) {
- return null;
+ if (error < bestMatch.error) {
+ bestMatch.code = code;
+ bestMatch.error = error;
}
- result.push(code.code);
- decodedCodes.push(code);
- }
+ }
- code = self._findPattern(self.MIDDLE_PATTERN, code.end, true, false);
- if (code === null) {
- return null;
+ return bestMatch.error < this.AVERAGE_CODE_ERROR ? bestMatch : null;
}
- decodedCodes.push(code);
+ }, {
+ key: "_decodePayload",
+ value: function _decodePayload(counters, result, decodedCodes) {
+ var counterLength = counters.length;
+ var counter = [0, 0, 0, 0, 0];
+ var pos = 0;
+ var code;
+
+ while (pos < counterLength) {
+ for (var i = 0; i < 5; i++) {
+ counter[i] = counters[pos] * this._barSpaceRatio[0];
+ pos += 2;
+ }
+
+ code = this._decodeCode(counter);
- for (i = 0; i < 4; i++) {
- code = self._decodeCode(code.end, self.CODE_G_START);
if (!code) {
- return null;
+ return null;
}
- decodedCodes.push(code);
+
result.push(code.code);
- }
+ decodedCodes.push(code);
+ }
- return code;
-};
+ return code;
+ }
+ }]);
-/* harmony default export */ __webpack_exports__["a"] = EAN8Reader;
+ return TwoOfFiveReader;
+}(_barcode_reader__WEBPACK_IMPORTED_MODULE_7__["BarcodeReader"]);
/***/ }),
-/* 75 */
+
+/***/ "./src/reader/barcode-reader.ts":
+/*!**************************************!*\
+ !*** ./src/reader/barcode-reader.ts ***!
+ \**************************************/
+/*! exports provided: BarcodeDirection, BarcodeReader */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge__ = __webpack_require__(28);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_merge__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__barcode_reader__ = __webpack_require__(1);
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BarcodeDirection", function() { return BarcodeDirection; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BarcodeReader", function() { return BarcodeReader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2__);
+
+var BarcodeDirection;
+(function (BarcodeDirection) {
+ BarcodeDirection[BarcodeDirection["Forward"] = 1] = "Forward";
+ BarcodeDirection[BarcodeDirection["Reverse"] = -1] = "Reverse";
+})(BarcodeDirection || (BarcodeDirection = {}));
-function I2of5Reader(opts) {
- opts = __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default()(getDefaulConfig(), opts);
- __WEBPACK_IMPORTED_MODULE_1__barcode_reader__["a" /* default */].call(this, opts);
- this.barSpaceRatio = [1, 1];
- if (opts.normalizeBarSpaceWidth) {
- this.SINGLE_CODE_ERROR = 0.38;
- this.AVG_CODE_ERROR = 0.09;
+;
+var BarcodeReader =
+/*#__PURE__*/
+function () {
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(BarcodeReader, [{
+ key: "SINGLE_CODE_ERROR",
+ get: function get() {
+ return this._singleCodeError;
}
-}
+ }, {
+ key: "AVERAGE_CODE_ERROR",
+ get: function get() {
+ return this._averageCodeError;
+ }
+ }, {
+ key: "FORMAT",
+ get: function get() {
+ return this._format;
+ }
+ }], [{
+ key: "Exception",
+ get: function get() {
+ return {
+ StartNotFoundException: 'Start-Info was not found!',
+ CodeNotFoundException: 'Code could not be found!',
+ PatternNotFoundException: 'Pattern could not be found!'
+ };
+ }
+ }]);
-function getDefaulConfig() {
- var config = {};
+ function BarcodeReader(config, supplements) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, BarcodeReader);
- Object.keys(I2of5Reader.CONFIG_KEYS).forEach(function (key) {
- config[key] = I2of5Reader.CONFIG_KEYS[key].default;
- });
- return config;
-}
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_singleCodeError", void 0);
-var N = 1,
- W = 3,
- properties = {
- START_PATTERN: { value: [N, N, N, N] },
- STOP_PATTERN: { value: [N, N, W] },
- CODE_PATTERN: { value: [[N, N, W, W, N], [W, N, N, N, W], [N, W, N, N, W], [W, W, N, N, N], [N, N, W, N, W], [W, N, W, N, N], [N, W, W, N, N], [N, N, N, W, W], [W, N, N, W, N], [N, W, N, W, N]] },
- SINGLE_CODE_ERROR: { value: 0.78, writable: true },
- AVG_CODE_ERROR: { value: 0.38, writable: true },
- MAX_CORRECTION_FACTOR: { value: 5 },
- FORMAT: { value: "i2of5" }
-};
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_averageCodeError", void 0);
-I2of5Reader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_1__barcode_reader__["a" /* default */].prototype, properties);
-I2of5Reader.prototype.constructor = I2of5Reader;
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_format", void 0);
-I2of5Reader.prototype._matchPattern = function (counter, code) {
- if (this.config.normalizeBarSpaceWidth) {
- var i,
- counterSum = [0, 0],
- codeSum = [0, 0],
- correction = [0, 0],
- correctionRatio = this.MAX_CORRECTION_FACTOR,
- correctionRatioInverse = 1 / correctionRatio;
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "_row", void 0);
- for (i = 0; i < counter.length; i++) {
- counterSum[i % 2] += counter[i];
- codeSum[i % 2] += code[i];
- }
- correction[0] = codeSum[0] / counterSum[0];
- correction[1] = codeSum[1] / counterSum[1];
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "config", void 0);
- correction[0] = Math.max(Math.min(correction[0], correctionRatio), correctionRatioInverse);
- correction[1] = Math.max(Math.min(correction[1], correctionRatio), correctionRatioInverse);
- this.barSpaceRatio = correction;
- for (i = 0; i < counter.length; i++) {
- counter[i] *= this.barSpaceRatio[i % 2];
- }
- }
- return __WEBPACK_IMPORTED_MODULE_1__barcode_reader__["a" /* default */].prototype._matchPattern.call(this, counter, code);
-};
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_2___default()(this, "supplements", void 0);
+
+ this._format = 'unknown';
+ this._row = [];
+ this.config = config || {};
+ this.supplements = supplements;
+ }
-I2of5Reader.prototype._findPattern = function (pattern, offset, isWhite, tryHarder) {
- var counter = [],
- self = this,
- i,
- counterPos = 0,
- bestMatch = {
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(BarcodeReader, [{
+ key: "_findPattern",
+ value: function _findPattern(pattern, offset, isWhite, tryHarder) {
+ var counter = new Array(pattern.length);
+ var bestMatch = {
error: Number.MAX_VALUE,
code: -1,
start: 0,
end: 0
- },
- error,
- j,
- sum,
- normalized,
- epsilon = self.AVG_CODE_ERROR;
+ };
+ var epsilon = this.AVERAGE_CODE_ERROR;
+ var counterPos = 0;
- isWhite = isWhite || false;
- tryHarder = tryHarder || false;
-
- if (!offset) {
- offset = self._nextSet(self._row);
- }
+ if (!offset) {
+ offset = this._nextSet(this._row);
+ }
- for (i = 0; i < pattern.length; i++) {
- counter[i] = 0;
- }
+ counter.fill(0);
- for (i = offset; i < self._row.length; i++) {
- if (self._row[i] ^ isWhite) {
- counter[counterPos]++;
+ for (var i = offset; i < this._row.length; i++) {
+ if (this._row[i] ^ isWhite) {
+ counter[counterPos]++;
} else {
- if (counterPos === counter.length - 1) {
- sum = 0;
- for (j = 0; j < counter.length; j++) {
- sum += counter[j];
- }
- error = self._matchPattern(counter, pattern);
- if (error < epsilon) {
- bestMatch.error = error;
- bestMatch.start = i - sum;
- bestMatch.end = i;
- return bestMatch;
- }
- if (tryHarder) {
- for (j = 0; j < counter.length - 2; j++) {
- counter[j] = counter[j + 2];
- }
- counter[counter.length - 2] = 0;
- counter[counter.length - 1] = 0;
- counterPos--;
- } else {
- return null;
- }
- } else {
- counterPos++;
+ if (counterPos === counter.length - 1) {
+ var error = this._matchPattern(counter, pattern);
+
+ if (error < epsilon) {
+ bestMatch.error = error;
+ bestMatch.start = i - counter.reduce(function (sum, value) {
+ return sum + value;
+ }, 0);
+ bestMatch.end = i;
+ return bestMatch;
}
- counter[counterPos] = 1;
- isWhite = !isWhite;
- }
- }
- return null;
-};
-I2of5Reader.prototype._findStart = function () {
- var self = this,
- leadingWhitespaceStart,
- offset = self._nextSet(self._row),
- startInfo,
- narrowBarWidth = 1;
+ if (tryHarder) {
+ for (var j = 0; j < counter.length - 2; j++) {
+ counter[j] = counter[j + 2];
+ }
- while (!startInfo) {
- startInfo = self._findPattern(self.START_PATTERN, offset, false, true);
- if (!startInfo) {
- return null;
- }
- narrowBarWidth = Math.floor((startInfo.end - startInfo.start) / 4);
- leadingWhitespaceStart = startInfo.start - narrowBarWidth * 10;
- if (leadingWhitespaceStart >= 0) {
- if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {
- return startInfo;
+ counter[counter.length - 2] = 0;
+ counter[counter.length - 1] = 0;
+ counterPos--;
+ } else {
+ return null;
}
+ } else {
+ counterPos++;
+ }
+
+ counter[counterPos] = 1;
+ isWhite = isWhite ? 0 : 1;
}
- offset = startInfo.end;
- startInfo = null;
+ }
+
+ return null;
}
-};
+ }, {
+ key: "_nextUnset",
+ value: function _nextUnset(line, start) {
+ for (var i = start || 0; i < line.length; i++) {
+ if (!line[i]) {
+ return i;
+ }
+ }
-I2of5Reader.prototype._verifyTrailingWhitespace = function (endInfo) {
- var self = this,
- trailingWhitespaceEnd;
+ return line.length;
+ }
+ }, {
+ key: "_nextSet",
+ value: function _nextSet(line, start) {
+ for (var i = start || 0; i < line.length; i++) {
+ if (line[i]) {
+ return i;
+ }
+ }
- trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
- if (trailingWhitespaceEnd < self._row.length) {
- if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
- return endInfo;
+ return line.length;
+ }
+ }, {
+ key: "_matchRange",
+ value: function _matchRange(start, end, value) {
+ for (var i = start < 0 ? 0 : start; i < end; i++) {
+ if (this._row[i] !== value) {
+ return false;
}
+ }
+
+ return true;
}
- return null;
-};
+ }, {
+ key: "_matchPattern",
+ value: function _matchPattern(counter, code, maxSingleError) {
+ var error = 0;
+ var sum = 0;
+ var modulo = 0;
+ maxSingleError = maxSingleError || this.SINGLE_CODE_ERROR || 1;
-I2of5Reader.prototype._findEnd = function () {
- var self = this,
- endInfo,
- tmp;
+ for (var i = 0; i < counter.length; i++) {
+ sum += counter[i];
+ modulo += code[i];
+ }
- self._row.reverse();
- endInfo = self._findPattern(self.STOP_PATTERN);
- self._row.reverse();
+ if (sum < modulo) {
+ return Number.MAX_VALUE;
+ }
- if (endInfo === null) {
- return null;
- }
+ var barWidth = sum / modulo;
+ maxSingleError *= barWidth;
- // reverse numbers
- tmp = endInfo.start;
- endInfo.start = self._row.length - endInfo.end;
- endInfo.end = self._row.length - tmp;
+ for (var _i = 0; _i < counter.length; _i++) {
+ var count = counter[_i];
+ var scaled = code[_i] * barWidth;
+ var singleError = Math.abs(count - scaled) / scaled;
- return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;
-};
+ if (singleError > maxSingleError) {
+ return Number.MAX_VALUE;
+ }
-I2of5Reader.prototype._decodePair = function (counterPair) {
- var i,
- code,
- codes = [],
- self = this;
+ error += singleError;
+ }
- for (i = 0; i < counterPair.length; i++) {
- code = self._decodeCode(counterPair[i]);
- if (!code) {
- return null;
- }
- codes.push(code);
+ return error / modulo;
}
- return codes;
-};
+ }, {
+ key: "_correctBars",
+ value: function _correctBars(counter, correction, indices) {
+ var length = indices.length;
+ var tmp = 0;
-I2of5Reader.prototype._decodeCode = function (counter) {
- var j,
- self = this,
- sum = 0,
- normalized,
- error,
- epsilon = self.AVG_CODE_ERROR,
- code,
- bestMatch = {
- error: Number.MAX_VALUE,
- code: -1,
- start: 0,
- end: 0
- };
+ while (length--) {
+ tmp = counter[indices[length]] * (1 - (1 - correction) / 2);
- for (j = 0; j < counter.length; j++) {
- sum += counter[j];
- }
- for (code = 0; code < self.CODE_PATTERN.length; code++) {
- error = self._matchPattern(counter, self.CODE_PATTERN[code]);
- if (error < bestMatch.error) {
- bestMatch.code = code;
- bestMatch.error = error;
+ if (tmp > 1) {
+ counter[indices[length]] = tmp;
}
+ }
}
- if (bestMatch.error < epsilon) {
- return bestMatch;
- }
-};
+ }, {
+ key: "decodePattern",
+ value: function decodePattern(pattern) {
+ this._row = pattern;
+ var result = this.decode();
-I2of5Reader.prototype._decodePayload = function (counters, result, decodedCodes) {
- var i,
- self = this,
- pos = 0,
- counterLength = counters.length,
- counterPair = [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]],
- codes;
-
- while (pos < counterLength) {
- for (i = 0; i < 5; i++) {
- counterPair[0][i] = counters[pos] * this.barSpaceRatio[0];
- counterPair[1][i] = counters[pos + 1] * this.barSpaceRatio[1];
- pos += 2;
- }
- codes = self._decodePair(counterPair);
- if (!codes) {
- return null;
- }
- for (i = 0; i < codes.length; i++) {
- result.push(codes[i].code + "");
- decodedCodes.push(codes[i]);
+ if (result === null) {
+ this._row.reverse();
+
+ result = this.decode();
+
+ if (result) {
+ result.direction = BarcodeDirection.Reverse;
+ result.start = this._row.length - result.start;
+ result.end = this._row.length - result.end;
}
- }
- return codes;
-};
+ } else {
+ result.direction = BarcodeDirection.Forward;
+ }
-I2of5Reader.prototype._verifyCounterLength = function (counters) {
- return counters.length % 10 === 0;
-};
+ if (result) {
+ result.format = this.FORMAT;
+ }
-I2of5Reader.prototype._decode = function () {
- var startInfo,
- endInfo,
- self = this,
- code,
- result = [],
- decodedCodes = [],
- counters;
-
- startInfo = self._findStart();
- if (!startInfo) {
- return null;
+ return result;
}
- decodedCodes.push(startInfo);
+ }, {
+ key: "_fillCounters",
+ value: function _fillCounters(offset, end, isWhite) {
+ var counters = new Array();
+ var counterPos = 0;
+ counters[counterPos] = 0;
- endInfo = self._findEnd();
- if (!endInfo) {
- return null;
- }
+ for (var i = offset; i < end; i++) {
+ if (this._row[i] ^ isWhite) {
+ counters[counterPos]++;
+ } else {
+ counterPos++;
+ counters[counterPos] = 1;
+ isWhite = isWhite ? 0 : 1;
+ }
+ }
- counters = self._fillCounters(startInfo.end, endInfo.start, false);
- if (!self._verifyCounterLength(counters)) {
- return null;
- }
- code = self._decodePayload(counters, result, decodedCodes);
- if (!code) {
- return null;
- }
- if (result.length % 2 !== 0 || result.length < 6) {
- return null;
+ return counters;
}
+ }, {
+ key: "_toCounters",
+ value: function _toCounters(start, counters) {
+ var numCounters = counters.length;
+ var end = this._row.length;
+ var isWhite = this._row[start] ? 0 : 1;
+ var counterPos = 0;
+ counters.fill(0);
- decodedCodes.push(endInfo);
- return {
- code: result.join(""),
- start: startInfo.start,
- end: endInfo.end,
- startInfo: startInfo,
- decodedCodes: decodedCodes
- };
-};
+ for (var i = start; i < end; i++) {
+ if (this._row[i] ^ isWhite) {
+ counters[counterPos]++;
+ } else {
+ counterPos++;
+
+ if (counterPos === numCounters) {
+ break;
+ } else {
+ counters[counterPos] = 1;
+ isWhite = isWhite ? 0 : 1;
+ }
+ }
+ }
-I2of5Reader.CONFIG_KEYS = {
- normalizeBarSpaceWidth: {
- 'type': 'boolean',
- 'default': false,
- 'description': 'If true, the reader tries to normalize the' + 'width-difference between bars and spaces'
+ return counters;
}
-};
+ }]);
-/* harmony default export */ __webpack_exports__["a"] = I2of5Reader;
+ return BarcodeReader;
+}();
/***/ }),
-/* 76 */
+
+/***/ "./src/reader/codabar-reader.ts":
+/*!**************************************!*\
+ !*** ./src/reader/codabar-reader.ts ***!
+ \**************************************/
+/*! exports provided: CodabarReader */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ean_reader__ = __webpack_require__(4);
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CodabarReader", function() { return CodabarReader; });
+/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/typeof */ "../../node_modules/@babel/runtime/helpers/typeof.js");
+/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/assertThisInitialized */ "../../node_modules/@babel/runtime/helpers/assertThisInitialized.js");
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7__);
+/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @babel/runtime/helpers/toConsumableArray */ "../../node_modules/@babel/runtime/helpers/toConsumableArray.js");
+/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_8__);
+/* harmony import */ var _barcode_reader__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./barcode-reader */ "./src/reader/barcode-reader.ts");
-function UPCEReader(opts, supplements) {
- __WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].call(this, opts, supplements);
-}
-var properties = {
- CODE_FREQUENCY: { value: [[56, 52, 50, 49, 44, 38, 35, 42, 41, 37], [7, 11, 13, 14, 19, 25, 28, 21, 22, 26]] },
- STOP_PATTERN: { value: [1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7] },
- FORMAT: { value: "upc_e", writeable: false }
-};
-UPCEReader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].prototype, properties);
-UPCEReader.prototype.constructor = UPCEReader;
-UPCEReader.prototype._decodePayload = function (code, result, decodedCodes) {
- var i,
- self = this,
- codeFrequency = 0x0;
- for (i = 0; i < 6; i++) {
- code = self._decodeCode(code.end);
- if (!code) {
- return null;
- }
- if (code.code >= self.CODE_G_START) {
- code.code = code.code - self.CODE_G_START;
- codeFrequency |= 1 << 5 - i;
- }
- result.push(code.code);
- decodedCodes.push(code);
- }
- if (!self._determineParity(codeFrequency, result)) {
- return null;
- }
- return code;
-};
-UPCEReader.prototype._determineParity = function (codeFrequency, result) {
- var i, nrSystem;
- for (nrSystem = 0; nrSystem < this.CODE_FREQUENCY.length; nrSystem++) {
- for (i = 0; i < this.CODE_FREQUENCY[nrSystem].length; i++) {
- if (codeFrequency === this.CODE_FREQUENCY[nrSystem][i]) {
- result.unshift(nrSystem);
- result.push(i);
- return true;
- }
- }
- }
- return false;
-};
-UPCEReader.prototype._convertToUPCA = function (result) {
- var upca = [result[0]],
- lastDigit = result[result.length - 2];
+var ALPHABETH_STRING = '0123456789-$:/.+ABCD';
- if (lastDigit <= 2) {
- upca = upca.concat(result.slice(1, 3)).concat([lastDigit, 0, 0, 0, 0]).concat(result.slice(3, 6));
- } else if (lastDigit === 3) {
- upca = upca.concat(result.slice(1, 4)).concat([0, 0, 0, 0, 0]).concat(result.slice(4, 6));
- } else if (lastDigit === 4) {
- upca = upca.concat(result.slice(1, 5)).concat([0, 0, 0, 0, 0, result[5]]);
- } else {
- upca = upca.concat(result.slice(1, 6)).concat([0, 0, 0, 0, lastDigit]);
- }
+var ALPHABET = _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_8___default()(ALPHABETH_STRING).map(function (_char) {
+ return _char.charCodeAt(0);
+}); // const ALPHABET = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 36, 58, 47, 46, 43, 65, 66, 67, 68];
- upca.push(result[result.length - 1]);
- return upca;
-};
-UPCEReader.prototype._checksum = function (result) {
- return __WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].prototype._checksum.call(this, this._convertToUPCA(result));
-};
+var CHARACTER_ENCODINGS = [0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, 0x00c, 0x018, 0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E];
+var START_END = [0x01A, 0x029, 0x00B, 0x00E];
+var MIN_ENCODED_CHARS = 4;
+var MAX_ACCEPTABLE = 2.0;
+var PADDING = 1.5;
+var CodabarReader =
+/*#__PURE__*/
+function (_BarcodeReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6___default()(CodabarReader, _BarcodeReader);
-UPCEReader.prototype._findEnd = function (offset, isWhite) {
- isWhite = true;
- return __WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].prototype._findEnd.call(this, offset, isWhite);
-};
+ function CodabarReader() {
+ var _this;
-UPCEReader.prototype._verifyTrailingWhitespace = function (endInfo) {
- var self = this,
- trailingWhitespaceEnd;
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1___default()(this, CodabarReader);
- trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
- if (trailingWhitespaceEnd < self._row.length) {
- if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
- return endInfo;
- }
- }
-};
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_3___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default()(CodabarReader).call(this));
-/* harmony default export */ __webpack_exports__["a"] = UPCEReader;
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_5___default()(_this), "_counters", void 0);
-/***/ }),
-/* 77 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ _this._format = 'codabar';
+ _this._counters = [];
+ return _this;
+ }
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ean_reader__ = __webpack_require__(4);
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_2___default()(CodabarReader, [{
+ key: "decode",
+ value: function decode() {
+ this._counters = this._fillCounters(this._nextUnset(this._row), this._row.length, 1);
+ var start = this._findStart();
-function UPCReader(opts, supplements) {
- __WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].call(this, opts, supplements);
-}
+ if (!start) {
+ return null;
+ }
-var properties = {
- FORMAT: { value: "upc_a", writeable: false }
-};
+ var result = new Array();
+ var nextStart = start.startCounter;
+ var pattern;
-UPCReader.prototype = Object.create(__WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].prototype, properties);
-UPCReader.prototype.constructor = UPCReader;
+ do {
+ pattern = this._toPattern(nextStart);
-UPCReader.prototype._decode = function () {
- var result = __WEBPACK_IMPORTED_MODULE_0__ean_reader__["a" /* default */].prototype._decode.call(this);
+ if (pattern < 0) {
+ return null;
+ }
- if (result && result.code && result.code.length === 13 && result.code.charAt(0) === "0") {
- result.code = result.code.substring(1);
- return result;
- }
- return null;
-};
+ var decodedChar = this._patternToChar(pattern);
-/* harmony default export */ __webpack_exports__["a"] = UPCReader;
+ if (decodedChar === null) {
+ return null;
+ }
-/***/ }),
-/* 78 */
-/***/ (function(module, exports) {
+ result.push(decodedChar);
+ nextStart += 8;
-module.exports = copy
+ if (result.length > 1 && START_END.some(function (code) {
+ return code === pattern;
+ })) {
+ break;
+ }
+ } while (nextStart < this._counters.length); // verify end
-/**
- * Copy the values from one mat2 to another
- *
- * @alias mat2.copy
- * @param {mat2} out the receiving matrix
- * @param {mat2} a the source matrix
- * @returns {mat2} out
- */
-function copy(out, a) {
- out[0] = a[0]
- out[1] = a[1]
- out[2] = a[2]
- out[3] = a[3]
- return out
-}
+ if (result.length - 2 < MIN_ENCODED_CHARS || !START_END.some(function (code) {
+ return code === pattern;
+ })) {
+ return null;
+ } // verify end white space
-/***/ }),
-/* 79 */
-/***/ (function(module, exports) {
-module.exports = create
+ if (!this._verifyWhitespace(start.startCounter, nextStart - 8)) {
+ return null;
+ }
-/**
- * Creates a new identity mat2
- *
- * @alias mat2.create
- * @returns {mat2} a new 2x2 matrix
- */
-function create() {
- var out = new Float32Array(4)
- out[0] = 1
- out[1] = 0
- out[2] = 0
- out[3] = 1
- return out
-}
+ if (!this._validateResult(result, start.startCounter)) {
+ return null;
+ }
+ nextStart = nextStart > this._counters.length ? this._counters.length : nextStart;
-/***/ }),
-/* 80 */
-/***/ (function(module, exports) {
+ var end = start.start + this._sumCounters(start.startCounter, nextStart - 8);
-module.exports = invert
+ return {
+ code: result.join(''),
+ start: start.start,
+ end: end,
+ startInfo: start,
+ decodedCodes: result
+ };
+ }
+ }, {
+ key: "_verifyWhitespace",
+ value: function _verifyWhitespace(startCounter, endCounter) {
+ if (startCounter - 1 <= 0 || this._counters[startCounter - 1] >= this._calculatePatternLength(startCounter) / 2.0) {
+ if (endCounter + 8 >= this._counters.length || this._counters[endCounter + 7] >= this._calculatePatternLength(endCounter) / 2.0) {
+ return true;
+ }
+ }
-/**
- * Inverts a mat2
- *
- * @alias mat2.invert
- * @param {mat2} out the receiving matrix
- * @param {mat2} a the source matrix
- * @returns {mat2} out
- */
-function invert(out, a) {
- var a0 = a[0]
- var a1 = a[1]
- var a2 = a[2]
- var a3 = a[3]
- var det = a0 * a3 - a2 * a1
-
- if (!det) return null
- det = 1.0 / det
-
- out[0] = a3 * det
- out[1] = -a1 * det
- out[2] = -a2 * det
- out[3] = a0 * det
-
- return out
-}
+ return false;
+ }
+ }, {
+ key: "_calculatePatternLength",
+ value: function _calculatePatternLength(offset) {
+ var sum = 0;
+ for (var i = offset; i < offset + 7; i++) {
+ sum += this._counters[i];
+ }
-/***/ }),
-/* 81 */
-/***/ (function(module, exports) {
+ return sum;
+ }
+ }, {
+ key: "_thresholdResultPattern",
+ value: function _thresholdResultPattern(result, startCounter) {
+ var categorization = {
+ space: {
+ narrow: {
+ size: 0,
+ counts: 0,
+ min: 0,
+ max: Number.MAX_VALUE
+ },
+ wide: {
+ size: 0,
+ counts: 0,
+ min: 0,
+ max: Number.MAX_VALUE
+ }
+ },
+ bar: {
+ narrow: {
+ size: 0,
+ counts: 0,
+ min: 0,
+ max: Number.MAX_VALUE
+ },
+ wide: {
+ size: 0,
+ counts: 0,
+ min: 0,
+ max: Number.MAX_VALUE
+ }
+ }
+ };
+ var pos = startCounter;
+
+ for (var i = 0; i < result.length; i++) {
+ var pattern = this._charToPattern(result[i]);
+
+ for (var j = 6; j >= 0; j--) {
+ var kind = (j & 1) === 2 ? categorization.bar : categorization.space;
+ var cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;
+ cat.size += this._counters[pos + j];
+ cat.counts++;
+ pattern >>= 1;
+ }
-module.exports = scale
+ pos += 8;
+ }
-/**
- * Scales a vec2 by a scalar number
- *
- * @param {vec2} out the receiving vector
- * @param {vec2} a the vector to scale
- * @param {Number} b amount to scale the vector by
- * @returns {vec2} out
- */
-function scale(out, a, b) {
- out[0] = a[0] * b
- out[1] = a[1] * b
- return out
-}
+ ['space', 'bar'].forEach(function (key) {
+ var kind = categorization[key];
+ kind.wide.min = Math.floor((kind.narrow.size / kind.narrow.counts + kind.wide.size / kind.wide.counts) / 2);
+ kind.narrow.max = Math.ceil(kind.wide.min);
+ kind.wide.max = Math.ceil((kind.wide.size * MAX_ACCEPTABLE + PADDING) / kind.wide.counts);
+ });
+ return categorization;
+ }
+ }, {
+ key: "_charToPattern",
+ value: function _charToPattern(_char2) {
+ var charCode = _char2.charCodeAt(0);
-/***/ }),
-/* 82 */
-/***/ (function(module, exports) {
+ for (var i = 0; i < ALPHABET.length; i++) {
+ if (ALPHABET[i] === charCode) {
+ return CHARACTER_ENCODINGS[i];
+ }
+ }
-module.exports = transformMat2
+ return 0x0;
+ }
+ }, {
+ key: "_validateResult",
+ value: function _validateResult(result, startCounter) {
+ var threshold = this._thresholdResultPattern(result, startCounter);
-/**
- * Transforms the vec2 with a mat2
- *
- * @param {vec2} out the receiving vector
- * @param {vec2} a the vector to transform
- * @param {mat2} m matrix to transform with
- * @returns {vec2} out
- */
-function transformMat2(out, a, m) {
- var x = a[0],
- y = a[1]
- out[0] = m[0] * x + m[2] * y
- out[1] = m[1] * x + m[3] * y
- return out
-}
+ var pos = startCounter;
-/***/ }),
-/* 83 */
-/***/ (function(module, exports) {
+ for (var i = 0; i < result.length; i++) {
+ var pattern = this._charToPattern(result[i]);
-module.exports = clone;
+ for (var j = 6; j >= 0; j--) {
+ var kind = (j & 1) === 0 ? threshold.bar : threshold.space;
+ var cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;
+ var size = this._counters[pos + j];
-/**
- * Creates a new vec3 initialized with values from an existing vector
- *
- * @param {vec3} a vector to clone
- * @returns {vec3} a new 3D vector
- */
-function clone(a) {
- var out = new Float32Array(3)
- out[0] = a[0]
- out[1] = a[1]
- out[2] = a[2]
- return out
-}
+ if (size < cat.min || size > cat.max) {
+ return false;
+ }
-/***/ }),
-/* 84 */
-/***/ (function(module, exports, __webpack_require__) {
+ pattern >>= 1;
+ }
-var hashClear = __webpack_require__(122),
- hashDelete = __webpack_require__(123),
- hashGet = __webpack_require__(124),
- hashHas = __webpack_require__(125),
- hashSet = __webpack_require__(126);
+ pos += 8;
+ }
-/**
- * Creates a hash object.
- *
- * @private
- * @constructor
- * @param {Array} [entries] The key-value pairs to cache.
- */
-function Hash(entries) {
- var index = -1,
- length = entries == null ? 0 : entries.length;
-
- this.clear();
- while (++index < length) {
- var entry = entries[index];
- this.set(entry[0], entry[1]);
- }
-}
+ return true;
+ }
+ }, {
+ key: "_patternToChar",
+ value: function _patternToChar(pattern) {
+ for (var i = 0; i < CHARACTER_ENCODINGS.length; i++) {
+ if (CHARACTER_ENCODINGS[i] === pattern) {
+ return String.fromCharCode(ALPHABET[i]);
+ }
+ }
-// Add methods to `Hash`.
-Hash.prototype.clear = hashClear;
-Hash.prototype['delete'] = hashDelete;
-Hash.prototype.get = hashGet;
-Hash.prototype.has = hashHas;
-Hash.prototype.set = hashSet;
+ return null;
+ }
+ }, {
+ key: "_computeAlternatingThreshold",
+ value: function _computeAlternatingThreshold(offset, end) {
+ var min = Number.MAX_VALUE;
+ var max = 0;
-module.exports = Hash;
+ for (var i = offset; i < end; i += 2) {
+ var counter = this._counters[i];
+ if (counter > max) {
+ max = counter;
+ }
-/***/ }),
-/* 85 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (counter < min) {
+ min = counter;
+ }
+ }
-var ListCache = __webpack_require__(10),
- stackClear = __webpack_require__(149),
- stackDelete = __webpack_require__(150),
- stackGet = __webpack_require__(151),
- stackHas = __webpack_require__(152),
- stackSet = __webpack_require__(153);
+ return (min + max) / 2.0 | 0;
+ }
+ }, {
+ key: "_toPattern",
+ value: function _toPattern(offset) {
+ var numCounters = 7;
+ var end = offset + numCounters;
-/**
- * Creates a stack cache object to store key-value pairs.
- *
- * @private
- * @constructor
- * @param {Array} [entries] The key-value pairs to cache.
- */
-function Stack(entries) {
- var data = this.__data__ = new ListCache(entries);
- this.size = data.size;
-}
+ if (end > this._counters.length) {
+ return -1;
+ }
-// Add methods to `Stack`.
-Stack.prototype.clear = stackClear;
-Stack.prototype['delete'] = stackDelete;
-Stack.prototype.get = stackGet;
-Stack.prototype.has = stackHas;
-Stack.prototype.set = stackSet;
+ var barThreshold = this._computeAlternatingThreshold(offset, end);
-module.exports = Stack;
+ var spaceThreshold = this._computeAlternatingThreshold(offset + 1, end);
+ var bitmask = 1 << numCounters - 1;
+ var pattern = 0;
-/***/ }),
-/* 86 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (var i = 0; i < numCounters; i++) {
+ var threshold = (i & 1) === 0 ? barThreshold : spaceThreshold;
-var root = __webpack_require__(5);
+ if (this._counters[offset + i] > threshold) {
+ pattern |= bitmask;
+ }
-/** Built-in value references. */
-var Uint8Array = root.Uint8Array;
+ bitmask >>= 1;
+ }
-module.exports = Uint8Array;
+ return pattern;
+ }
+ }, {
+ key: "_sumCounters",
+ value: function _sumCounters(start, end) {
+ var sum = 0;
+ for (var i = start; i < end; i++) {
+ sum += this._counters[i];
+ }
-/***/ }),
-/* 87 */
-/***/ (function(module, exports) {
+ return sum;
+ }
+ }, {
+ key: "_findStart",
+ value: function _findStart() {
+ var _this2 = this;
-/**
- * A faster alternative to `Function#apply`, this function invokes `func`
- * with the `this` binding of `thisArg` and the arguments of `args`.
- *
- * @private
- * @param {Function} func The function to invoke.
- * @param {*} thisArg The `this` binding of `func`.
- * @param {Array} args The arguments to invoke `func` with.
- * @returns {*} Returns the result of `func`.
- */
-function apply(func, thisArg, args) {
- switch (args.length) {
- case 0: return func.call(thisArg);
- case 1: return func.call(thisArg, args[0]);
- case 2: return func.call(thisArg, args[0], args[1]);
- case 3: return func.call(thisArg, args[0], args[1], args[2]);
- }
- return func.apply(thisArg, args);
-}
+ var start = this._nextUnset(this._row);
-module.exports = apply;
+ var _loop = function _loop(i) {
+ var pattern = _this2._toPattern(i);
+ if (pattern !== -1 && START_END.some(function (code) {
+ return code === pattern;
+ })) {
+ // TODO: Look for whitespace ahead
+ start += _this2._sumCounters(0, i);
-/***/ }),
-/* 88 */
-/***/ (function(module, exports, __webpack_require__) {
+ var end = start + _this2._sumCounters(i, i + 8);
-var baseTimes = __webpack_require__(107),
- isArguments = __webpack_require__(18),
- isArray = __webpack_require__(2),
- isBuffer = __webpack_require__(44),
- isIndex = __webpack_require__(15),
- isTypedArray = __webpack_require__(45);
+ return {
+ v: {
+ start: start,
+ end: end,
+ startCounter: i,
+ endCounter: i + 8
+ }
+ };
+ }
+ };
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
+ for (var i = 1; i < this._counters.length; i++) {
+ var _ret = _loop(i);
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+ if (_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0___default()(_ret) === "object") return _ret.v;
+ }
-/**
- * Creates an array of the enumerable property names of the array-like `value`.
- *
- * @private
- * @param {*} value The value to query.
- * @param {boolean} inherited Specify returning inherited property names.
- * @returns {Array} Returns the array of property names.
- */
-function arrayLikeKeys(value, inherited) {
- var isArr = isArray(value),
- isArg = !isArr && isArguments(value),
- isBuff = !isArr && !isArg && isBuffer(value),
- isType = !isArr && !isArg && !isBuff && isTypedArray(value),
- skipIndexes = isArr || isArg || isBuff || isType,
- result = skipIndexes ? baseTimes(value.length, String) : [],
- length = result.length;
-
- for (var key in value) {
- if ((inherited || hasOwnProperty.call(value, key)) &&
- !(skipIndexes && (
- // Safari 9 has enumerable `arguments.length` in strict mode.
- key == 'length' ||
- // Node.js 0.10 has enumerable non-index properties on buffers.
- (isBuff && (key == 'offset' || key == 'parent')) ||
- // PhantomJS 2 has enumerable non-index properties on typed arrays.
- (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
- // Skip index properties.
- isIndex(key, length)
- ))) {
- result.push(key);
+ return null;
}
- }
- return result;
-}
-
-module.exports = arrayLikeKeys;
-
-
-/***/ }),
-/* 89 */
-/***/ (function(module, exports) {
-
-/**
- * A specialized version of `_.map` for arrays without support for iteratee
- * shorthands.
- *
- * @private
- * @param {Array} [array] The array to iterate over.
- * @param {Function} iteratee The function invoked per iteration.
- * @returns {Array} Returns the new mapped array.
- */
-function arrayMap(array, iteratee) {
- var index = -1,
- length = array == null ? 0 : array.length,
- result = Array(length);
-
- while (++index < length) {
- result[index] = iteratee(array[index], index, array);
- }
- return result;
-}
-
-module.exports = arrayMap;
+ }]);
+ return CodabarReader;
+}(_barcode_reader__WEBPACK_IMPORTED_MODULE_9__["BarcodeReader"]);
/***/ }),
-/* 90 */
-/***/ (function(module, exports) {
-/**
- * Appends the elements of `values` to `array`.
- *
- * @private
- * @param {Array} array The array to modify.
- * @param {Array} values The values to append.
- * @returns {Array} Returns `array`.
- */
-function arrayPush(array, values) {
- var index = -1,
- length = values.length,
- offset = array.length;
+/***/ "./src/reader/code-128-reader.ts":
+/*!***************************************!*\
+ !*** ./src/reader/code-128-reader.ts ***!
+ \***************************************/
+/*! exports provided: Code128Reader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- while (++index < length) {
- array[offset + index] = values[index];
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Code128Reader", function() { return Code128Reader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _barcode_reader__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./barcode-reader */ "./src/reader/barcode-reader.ts");
+
+
+
+
+
+
+var CODE_SHIFT = 98;
+var CODE_C = 99;
+var CODE_B = 100;
+var CODE_A = 101;
+var START_CODE_A = 103;
+var START_CODE_B = 104;
+var START_CODE_C = 105;
+var STOP_CODE = 106;
+var CODE_PATTERN = [[2, 1, 2, 2, 2, 2], [2, 2, 2, 1, 2, 2], [2, 2, 2, 2, 2, 1], [1, 2, 1, 2, 2, 3], [1, 2, 1, 3, 2, 2], [1, 3, 1, 2, 2, 2], [1, 2, 2, 2, 1, 3], [1, 2, 2, 3, 1, 2], [1, 3, 2, 2, 1, 2], [2, 2, 1, 2, 1, 3], [2, 2, 1, 3, 1, 2], [2, 3, 1, 2, 1, 2], [1, 1, 2, 2, 3, 2], [1, 2, 2, 1, 3, 2], [1, 2, 2, 2, 3, 1], [1, 1, 3, 2, 2, 2], [1, 2, 3, 1, 2, 2], [1, 2, 3, 2, 2, 1], [2, 2, 3, 2, 1, 1], [2, 2, 1, 1, 3, 2], [2, 2, 1, 2, 3, 1], [2, 1, 3, 2, 1, 2], [2, 2, 3, 1, 1, 2], [3, 1, 2, 1, 3, 1], [3, 1, 1, 2, 2, 2], [3, 2, 1, 1, 2, 2], [3, 2, 1, 2, 2, 1], [3, 1, 2, 2, 1, 2], [3, 2, 2, 1, 1, 2], [3, 2, 2, 2, 1, 1], [2, 1, 2, 1, 2, 3], [2, 1, 2, 3, 2, 1], [2, 3, 2, 1, 2, 1], [1, 1, 1, 3, 2, 3], [1, 3, 1, 1, 2, 3], [1, 3, 1, 3, 2, 1], [1, 1, 2, 3, 1, 3], [1, 3, 2, 1, 1, 3], [1, 3, 2, 3, 1, 1], [2, 1, 1, 3, 1, 3], [2, 3, 1, 1, 1, 3], [2, 3, 1, 3, 1, 1], [1, 1, 2, 1, 3, 3], [1, 1, 2, 3, 3, 1], [1, 3, 2, 1, 3, 1], [1, 1, 3, 1, 2, 3], [1, 1, 3, 3, 2, 1], [1, 3, 3, 1, 2, 1], [3, 1, 3, 1, 2, 1], [2, 1, 1, 3, 3, 1], [2, 3, 1, 1, 3, 1], [2, 1, 3, 1, 1, 3], [2, 1, 3, 3, 1, 1], [2, 1, 3, 1, 3, 1], [3, 1, 1, 1, 2, 3], [3, 1, 1, 3, 2, 1], [3, 3, 1, 1, 2, 1], [3, 1, 2, 1, 1, 3], [3, 1, 2, 3, 1, 1], [3, 3, 2, 1, 1, 1], [3, 1, 4, 1, 1, 1], [2, 2, 1, 4, 1, 1], [4, 3, 1, 1, 1, 1], [1, 1, 1, 2, 2, 4], [1, 1, 1, 4, 2, 2], [1, 2, 1, 1, 2, 4], [1, 2, 1, 4, 2, 1], [1, 4, 1, 1, 2, 2], [1, 4, 1, 2, 2, 1], [1, 1, 2, 2, 1, 4], [1, 1, 2, 4, 1, 2], [1, 2, 2, 1, 1, 4], [1, 2, 2, 4, 1, 1], [1, 4, 2, 1, 1, 2], [1, 4, 2, 2, 1, 1], [2, 4, 1, 2, 1, 1], [2, 2, 1, 1, 1, 4], [4, 1, 3, 1, 1, 1], [2, 4, 1, 1, 1, 2], [1, 3, 4, 1, 1, 1], [1, 1, 1, 2, 4, 2], [1, 2, 1, 1, 4, 2], [1, 2, 1, 2, 4, 1], [1, 1, 4, 2, 1, 2], [1, 2, 4, 1, 1, 2], [1, 2, 4, 2, 1, 1], [4, 1, 1, 2, 1, 2], [4, 2, 1, 1, 1, 2], [4, 2, 1, 2, 1, 1], [2, 1, 2, 1, 4, 1], [2, 1, 4, 1, 2, 1], [4, 1, 2, 1, 2, 1], [1, 1, 1, 1, 4, 3], [1, 1, 1, 3, 4, 1], [1, 3, 1, 1, 4, 1], [1, 1, 4, 1, 1, 3], [1, 1, 4, 3, 1, 1], [4, 1, 1, 1, 1, 3], [4, 1, 1, 3, 1, 1], [1, 1, 3, 1, 4, 1], [1, 1, 4, 1, 3, 1], [3, 1, 1, 1, 4, 1], [4, 1, 1, 1, 3, 1], [2, 1, 1, 4, 1, 2], [2, 1, 1, 2, 1, 4], [2, 1, 1, 2, 3, 2], [2, 3, 3, 1, 1, 1, 2]];
+var MODULE_INDICES = {
+ bar: [0, 2, 4],
+ space: [1, 3, 5]
+};
+var Code128Reader =
+/*#__PURE__*/
+function (_BarcodeReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default()(Code128Reader, _BarcodeReader);
+
+ function Code128Reader() {
+ var _this;
+
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, Code128Reader);
+
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(Code128Reader).call(this));
+ _this._format = 'code_128';
+ _this._singleCodeError = 0.64;
+ _this._averageCodeError = 0.30;
+ return _this;
}
- return array;
-}
-
-module.exports = arrayPush;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(Code128Reader, [{
+ key: "_decodeCode",
+ value: function _decodeCode(start, correction) {
+ var counter = [0, 0, 0, 0, 0, 0];
+ var offset = start;
+ var bestMatch = {
+ error: Number.MAX_VALUE,
+ code: -1,
+ start: start,
+ end: start,
+ correction: {
+ bar: 1,
+ space: 1
+ }
+ };
+ var epsilon = this.AVERAGE_CODE_ERROR;
+ var isWhite = this._row[offset] ? 0 : 1;
+ var counterPos = 0;
-/***/ }),
-/* 91 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (var i = offset; i < this._row.length; i++) {
+ if (this._row[i] ^ isWhite) {
+ counter[counterPos]++;
+ } else {
+ if (counterPos === counter.length - 1) {
+ if (correction) {
+ this._correct(counter, correction);
+ }
-var isObject = __webpack_require__(0);
+ for (var code = 0; code < CODE_PATTERN.length; code++) {
+ var error = this._matchPattern(counter, CODE_PATTERN[code]);
-/** Built-in value references. */
-var objectCreate = Object.create;
+ if (error < bestMatch.error) {
+ bestMatch.code = code;
+ bestMatch.error = error;
+ }
+ }
-/**
- * The base implementation of `_.create` without support for assigning
- * properties to the created object.
- *
- * @private
- * @param {Object} proto The object to inherit from.
- * @returns {Object} Returns the new object.
- */
-var baseCreate = (function() {
- function object() {}
- return function(proto) {
- if (!isObject(proto)) {
- return {};
- }
- if (objectCreate) {
- return objectCreate(proto);
- }
- object.prototype = proto;
- var result = new object;
- object.prototype = undefined;
- return result;
- };
-}());
+ bestMatch.end = i;
-module.exports = baseCreate;
+ if (bestMatch.code === -1 || bestMatch.error > epsilon) {
+ return null;
+ }
+ var expected = CODE_PATTERN[bestMatch.code];
-/***/ }),
-/* 92 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (expected) {
+ bestMatch.correction.bar = this._calculateCorrection(expected, counter, MODULE_INDICES.bar);
+ bestMatch.correction.space = this._calculateCorrection(expected, counter, MODULE_INDICES.space);
+ }
-var arrayPush = __webpack_require__(90),
- isFlattenable = __webpack_require__(128);
+ return bestMatch;
+ } else {
+ counterPos++;
+ }
-/**
- * The base implementation of `_.flatten` with support for restricting flattening.
- *
- * @private
- * @param {Array} array The array to flatten.
- * @param {number} depth The maximum recursion depth.
- * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
- * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
- * @param {Array} [result=[]] The initial result value.
- * @returns {Array} Returns the new flattened array.
- */
-function baseFlatten(array, depth, predicate, isStrict, result) {
- var index = -1,
- length = array.length;
-
- predicate || (predicate = isFlattenable);
- result || (result = []);
-
- while (++index < length) {
- var value = array[index];
- if (depth > 0 && predicate(value)) {
- if (depth > 1) {
- // Recursively flatten arrays (susceptible to call stack limits).
- baseFlatten(value, depth - 1, predicate, isStrict, result);
- } else {
- arrayPush(result, value);
+ counter[counterPos] = 1;
+ isWhite = isWhite ? 0 : 1;
+ }
}
- } else if (!isStrict) {
- result[result.length] = value;
+
+ return null;
}
- }
- return result;
-}
+ }, {
+ key: "_correct",
+ value: function _correct(counter, correction) {
+ this._correctBars(counter, correction.bar, MODULE_INDICES.bar);
-module.exports = baseFlatten;
+ this._correctBars(counter, correction.space, MODULE_INDICES.space);
+ }
+ }, {
+ key: "_findStart",
+ value: function _findStart() {
+ var counter = [0, 0, 0, 0, 0, 0];
+ var offset = this._nextSet(this._row);
-/***/ }),
-/* 93 */
-/***/ (function(module, exports, __webpack_require__) {
+ var bestMatch = {
+ error: Number.MAX_VALUE,
+ code: -1,
+ start: 0,
+ end: 0,
+ correction: {
+ bar: 1,
+ space: 1
+ }
+ };
+ var epsilon = this.AVERAGE_CODE_ERROR;
+ var isWhite = 0;
+ var counterPos = 0;
+ var sum;
+
+ for (var i = offset; i < this._row.length; i++) {
+ if (this._row[i] ^ isWhite) {
+ counter[counterPos]++;
+ } else {
+ if (counterPos === counter.length - 1) {
+ sum = 0;
-var createBaseFor = __webpack_require__(117);
+ for (var j = 0; j < counter.length; j++) {
+ sum += counter[j];
+ }
-/**
- * The base implementation of `baseForOwn` which iterates over `object`
- * properties returned by `keysFunc` and invokes `iteratee` for each property.
- * Iteratee functions may exit iteration early by explicitly returning `false`.
- *
- * @private
- * @param {Object} object The object to iterate over.
- * @param {Function} iteratee The function invoked per iteration.
- * @param {Function} keysFunc The function to get the keys of `object`.
- * @returns {Object} Returns `object`.
- */
-var baseFor = createBaseFor();
+ for (var code = START_CODE_A; code <= START_CODE_C; code++) {
+ var error = this._matchPattern(counter, CODE_PATTERN[code]);
-module.exports = baseFor;
+ if (error < bestMatch.error) {
+ bestMatch.code = code;
+ bestMatch.error = error;
+ }
+ }
+ if (bestMatch.error < epsilon) {
+ bestMatch.start = i - sum;
+ bestMatch.end = i;
+ bestMatch.correction.bar = this._calculateCorrection(CODE_PATTERN[bestMatch.code], counter, MODULE_INDICES.bar);
+ bestMatch.correction.space = this._calculateCorrection(CODE_PATTERN[bestMatch.code], counter, MODULE_INDICES.space);
+ return bestMatch;
+ }
-/***/ }),
-/* 94 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (var _j = 0; _j < 4; _j++) {
+ counter[_j] = counter[_j + 2];
+ }
-var castPath = __webpack_require__(13),
- toKey = __webpack_require__(23);
+ counter[4] = 0;
+ counter[5] = 0;
+ counterPos--;
+ } else {
+ counterPos++;
+ }
-/**
- * The base implementation of `_.get` without support for default values.
- *
- * @private
- * @param {Object} object The object to query.
- * @param {Array|string} path The path of the property to get.
- * @returns {*} Returns the resolved value.
- */
-function baseGet(object, path) {
- path = castPath(path, object);
+ counter[counterPos] = 1;
+ isWhite = isWhite ? 0 : 1;
+ }
+ }
- var index = 0,
- length = path.length;
+ return null;
+ }
+ }, {
+ key: "decode",
+ value: function decode() {
+ var result = new Array();
- while (object != null && index < length) {
- object = object[toKey(path[index++])];
- }
- return (index && index == length) ? object : undefined;
-}
+ var startInfo = this._findStart();
-module.exports = baseGet;
+ var code = null;
+ var done = false;
+ var multiplier = 0;
+ var checksum = 0;
+ var codeset;
+ var rawResult = new Array();
+ var decodedCodes = new Array();
+ var shiftNext = false;
+ var unshift;
+ var removeLastCharacter = true;
+ if (startInfo === null) {
+ return null;
+ }
-/***/ }),
-/* 95 */
-/***/ (function(module, exports) {
+ code = {
+ code: startInfo.code,
+ start: startInfo.start,
+ end: startInfo.end,
+ correction: {
+ bar: startInfo.correction.bar,
+ space: startInfo.correction.space
+ }
+ };
+ decodedCodes.push(code);
+ checksum = code.code;
-/**
- * The base implementation of `_.hasIn` without support for deep paths.
- *
- * @private
- * @param {Object} [object] The object to query.
- * @param {Array|string} key The key to check.
- * @returns {boolean} Returns `true` if `key` exists, else `false`.
- */
-function baseHasIn(object, key) {
- return object != null && key in Object(object);
-}
+ switch (code.code) {
+ case START_CODE_A:
+ codeset = CODE_A;
+ break;
-module.exports = baseHasIn;
+ case START_CODE_B:
+ codeset = CODE_B;
+ break;
+ case START_CODE_C:
+ codeset = CODE_C;
+ break;
-/***/ }),
-/* 96 */
-/***/ (function(module, exports, __webpack_require__) {
+ default:
+ return null;
+ }
-var baseGetTag = __webpack_require__(8),
- isObjectLike = __webpack_require__(6);
+ while (!done) {
+ unshift = shiftNext;
+ shiftNext = false;
+ code = this._decodeCode(code.end, code.correction);
-/** `Object#toString` result references. */
-var argsTag = '[object Arguments]';
+ if (code !== null) {
+ if (code.code !== STOP_CODE) {
+ removeLastCharacter = true;
+ }
+
+ if (code.code !== STOP_CODE) {
+ rawResult.push(code.code);
+ multiplier++;
+ checksum += multiplier * code.code;
+ }
+
+ decodedCodes.push(code);
+
+ switch (codeset) {
+ case CODE_A:
+ {
+ if (code.code < 64) {
+ result.push(String.fromCharCode(32 + code.code));
+ } else if (code.code < 96) {
+ result.push(String.fromCharCode(code.code - 64));
+ } else {
+ if (code.code !== STOP_CODE) {
+ removeLastCharacter = false;
+ }
+
+ switch (code.code) {
+ case CODE_SHIFT:
+ shiftNext = true;
+ codeset = CODE_B;
+ break;
+
+ case CODE_B:
+ codeset = CODE_B;
+ break;
+
+ case CODE_C:
+ codeset = CODE_C;
+ break;
+
+ case STOP_CODE:
+ done = true;
+ break;
+ }
+ }
-/**
- * The base implementation of `_.isArguments`.
- *
- * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an `arguments` object,
- */
-function baseIsArguments(value) {
- return isObjectLike(value) && baseGetTag(value) == argsTag;
-}
+ break;
+ }
-module.exports = baseIsArguments;
+ case CODE_B:
+ {
+ if (code.code < 96) {
+ result.push(String.fromCharCode(32 + code.code));
+ } else {
+ if (code.code !== STOP_CODE) {
+ removeLastCharacter = false;
+ }
+
+ switch (code.code) {
+ case CODE_SHIFT:
+ shiftNext = true;
+ codeset = CODE_A;
+ break;
+
+ case CODE_A:
+ codeset = CODE_A;
+ break;
+
+ case CODE_C:
+ codeset = CODE_C;
+ break;
+
+ case STOP_CODE:
+ done = true;
+ break;
+ }
+ }
+ break;
+ }
-/***/ }),
-/* 97 */
-/***/ (function(module, exports, __webpack_require__) {
+ case CODE_C:
+ {
+ if (code.code < 100) {
+ result.push(code.code < 10 ? '0' + code.code : code.code);
+ } else {
+ if (code.code !== STOP_CODE) {
+ removeLastCharacter = false;
+ }
+
+ switch (code.code) {
+ case CODE_A:
+ codeset = CODE_A;
+ break;
+
+ case CODE_B:
+ codeset = CODE_B;
+ break;
+
+ case STOP_CODE:
+ done = true;
+ break;
+ }
+ }
-var isFunction = __webpack_require__(25),
- isMasked = __webpack_require__(132),
- isObject = __webpack_require__(0),
- toSource = __webpack_require__(155);
+ break;
+ }
+ }
+ } else {
+ done = true;
+ }
-/**
- * Used to match `RegExp`
- * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
- */
-var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+ if (unshift) {
+ codeset = codeset === CODE_A ? CODE_B : CODE_A;
+ }
+ }
-/** Used to detect host constructors (Safari). */
-var reIsHostCtor = /^\[object .+?Constructor\]$/;
+ if (code === null) {
+ return null;
+ }
-/** Used for built-in method references. */
-var funcProto = Function.prototype,
- objectProto = Object.prototype;
+ code.end = this._nextUnset(this._row, code.end);
-/** Used to resolve the decompiled source of functions. */
-var funcToString = funcProto.toString;
+ if (!this._verifyTrailingWhitespace(code)) {
+ return null;
+ }
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+ checksum -= multiplier * rawResult[rawResult.length - 1];
-/** Used to detect if a method is native. */
-var reIsNative = RegExp('^' +
- funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
- .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
-);
+ if (checksum % 103 !== rawResult[rawResult.length - 1]) {
+ return null;
+ }
-/**
- * The base implementation of `_.isNative` without bad shim checks.
- *
- * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a native function,
- * else `false`.
- */
-function baseIsNative(value) {
- if (!isObject(value) || isMasked(value)) {
- return false;
- }
- var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
- return pattern.test(toSource(value));
-}
+ if (!result.length) {
+ return null;
+ } // remove last code from result (checksum)
-module.exports = baseIsNative;
+ if (removeLastCharacter) {
+ result.splice(result.length - 1, 1);
+ }
-/***/ }),
-/* 98 */
-/***/ (function(module, exports, __webpack_require__) {
+ return {
+ code: result.join(''),
+ start: startInfo.start,
+ end: code.end,
+ codeset: codeset,
+ startInfo: startInfo,
+ decodedCodes: decodedCodes,
+ endInfo: code
+ };
+ }
+ }, {
+ key: "_verifyTrailingWhitespace",
+ value: function _verifyTrailingWhitespace(endInfo) {
+ var trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
-var baseGetTag = __webpack_require__(8),
- isLength = __webpack_require__(26),
- isObjectLike = __webpack_require__(6);
-
-/** `Object#toString` result references. */
-var argsTag = '[object Arguments]',
- arrayTag = '[object Array]',
- boolTag = '[object Boolean]',
- dateTag = '[object Date]',
- errorTag = '[object Error]',
- funcTag = '[object Function]',
- mapTag = '[object Map]',
- numberTag = '[object Number]',
- objectTag = '[object Object]',
- regexpTag = '[object RegExp]',
- setTag = '[object Set]',
- stringTag = '[object String]',
- weakMapTag = '[object WeakMap]';
-
-var arrayBufferTag = '[object ArrayBuffer]',
- dataViewTag = '[object DataView]',
- float32Tag = '[object Float32Array]',
- float64Tag = '[object Float64Array]',
- int8Tag = '[object Int8Array]',
- int16Tag = '[object Int16Array]',
- int32Tag = '[object Int32Array]',
- uint8Tag = '[object Uint8Array]',
- uint8ClampedTag = '[object Uint8ClampedArray]',
- uint16Tag = '[object Uint16Array]',
- uint32Tag = '[object Uint32Array]';
-
-/** Used to identify `toStringTag` values of typed arrays. */
-var typedArrayTags = {};
-typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
-typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
-typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
-typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
-typedArrayTags[uint32Tag] = true;
-typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
-typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
-typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
-typedArrayTags[errorTag] = typedArrayTags[funcTag] =
-typedArrayTags[mapTag] = typedArrayTags[numberTag] =
-typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
-typedArrayTags[setTag] = typedArrayTags[stringTag] =
-typedArrayTags[weakMapTag] = false;
+ if (trailingWhitespaceEnd < this._row.length) {
+ if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
+ return endInfo;
+ }
+ }
-/**
- * The base implementation of `_.isTypedArray` without Node.js optimizations.
- *
- * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
- */
-function baseIsTypedArray(value) {
- return isObjectLike(value) &&
- isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
-}
+ return null;
+ }
+ }, {
+ key: "_calculateCorrection",
+ value: function _calculateCorrection(expected, normalized, indices) {
+ var sumNormalized = 0;
+ var sumExpected = 0;
+
+ for (var length = indices.length; length--;) {
+ sumExpected += expected[indices[length]];
+ sumNormalized += normalized[indices[length]];
+ }
-module.exports = baseIsTypedArray;
+ return sumExpected / sumNormalized;
+ }
+ }]);
+ return Code128Reader;
+}(_barcode_reader__WEBPACK_IMPORTED_MODULE_5__["BarcodeReader"]);
/***/ }),
-/* 99 */
-/***/ (function(module, exports, __webpack_require__) {
-var isObject = __webpack_require__(0),
- isPrototype = __webpack_require__(40),
- nativeKeysIn = __webpack_require__(144);
+/***/ "./src/reader/code-39-reader.ts":
+/*!**************************************!*\
+ !*** ./src/reader/code-39-reader.ts ***!
+ \**************************************/
+/*! exports provided: Code39Reader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Code39Reader", function() { return Code39Reader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/toConsumableArray */ "../../node_modules/@babel/runtime/helpers/toConsumableArray.js");
+/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _barcode_reader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./barcode-reader */ "./src/reader/barcode-reader.ts");
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
-/**
- * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
- *
- * @private
- * @param {Object} object The object to query.
- * @returns {Array} Returns the array of property names.
- */
-function baseKeysIn(object) {
- if (!isObject(object)) {
- return nativeKeysIn(object);
- }
- var isProto = isPrototype(object),
- result = [];
- for (var key in object) {
- if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
- result.push(key);
- }
- }
- return result;
-}
-module.exports = baseKeysIn;
-/***/ }),
-/* 100 */
-/***/ (function(module, exports, __webpack_require__) {
-var Stack = __webpack_require__(85),
- assignMergeValue = __webpack_require__(35),
- baseFor = __webpack_require__(93),
- baseMergeDeep = __webpack_require__(101),
- isObject = __webpack_require__(0),
- keysIn = __webpack_require__(46);
+var ASTERISK = 0x094;
+var ALPHABETH_STRING = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%';
+var ALPHABET = new Uint16Array(_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_5___default()(ALPHABETH_STRING).map(function (_char) {
+ return _char.charCodeAt(0);
+})); // const ALPHABET = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+// 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 45, 46, 32, 42, 36, 47, 43, 37];
-/**
- * The base implementation of `_.merge` without support for multiple sources.
- *
- * @private
- * @param {Object} object The destination object.
- * @param {Object} source The source object.
- * @param {number} srcIndex The index of `source`.
- * @param {Function} [customizer] The function to customize merged values.
- * @param {Object} [stack] Tracks traversed source values and their merged
- * counterparts.
- */
-function baseMerge(object, source, srcIndex, customizer, stack) {
- if (object === source) {
- return;
+var CHARACTER_ENCODINGS = new Uint16Array([0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, 0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, 0x0A8, 0x0A2, 0x08A, 0x02A]);
+var Code39Reader =
+/*#__PURE__*/
+function (_BarcodeReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default()(Code39Reader, _BarcodeReader);
+
+ function Code39Reader() {
+ var _this;
+
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, Code39Reader);
+
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(Code39Reader).call(this));
+ _this._format = 'code_39';
+ return _this;
}
- baseFor(source, function(srcValue, key) {
- if (isObject(srcValue)) {
- stack || (stack = new Stack);
- baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
- }
- else {
- var newValue = customizer
- ? customizer(object[key], srcValue, (key + ''), object, source, stack)
- : undefined;
- if (newValue === undefined) {
- newValue = srcValue;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(Code39Reader, [{
+ key: "decode",
+ value: function decode() {
+ var start = this._findStart();
+
+ if (!start) {
+ return null;
}
- assignMergeValue(object, key, newValue);
- }
- }, keysIn);
-}
-module.exports = baseMerge;
+ var result = new Array();
+ var counters = new Uint16Array(9);
+ var decodedChar;
+ var lastStart;
+ var nextStart = this._nextSet(this._row, start.end);
-/***/ }),
-/* 101 */
-/***/ (function(module, exports, __webpack_require__) {
+ do {
+ this._toCounters(nextStart, counters);
-var assignMergeValue = __webpack_require__(35),
- cloneBuffer = __webpack_require__(111),
- cloneTypedArray = __webpack_require__(112),
- copyArray = __webpack_require__(113),
- initCloneObject = __webpack_require__(127),
- isArguments = __webpack_require__(18),
- isArray = __webpack_require__(2),
- isArrayLikeObject = __webpack_require__(159),
- isBuffer = __webpack_require__(44),
- isFunction = __webpack_require__(25),
- isObject = __webpack_require__(0),
- isPlainObject = __webpack_require__(160),
- isTypedArray = __webpack_require__(45),
- toPlainObject = __webpack_require__(164);
+ var pattern = this._toPattern(counters);
-/**
- * A specialized version of `baseMerge` for arrays and objects which performs
- * deep merges and tracks traversed objects enabling objects with circular
- * references to be merged.
- *
- * @private
- * @param {Object} object The destination object.
- * @param {Object} source The source object.
- * @param {string} key The key of the value to merge.
- * @param {number} srcIndex The index of `source`.
- * @param {Function} mergeFunc The function to merge values.
- * @param {Function} [customizer] The function to customize assigned values.
- * @param {Object} [stack] Tracks traversed source values and their merged
- * counterparts.
- */
-function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
- var objValue = object[key],
- srcValue = source[key],
- stacked = stack.get(srcValue);
+ if (pattern < 0) {
+ return null;
+ }
- if (stacked) {
- assignMergeValue(object, key, stacked);
- return;
- }
- var newValue = customizer
- ? customizer(objValue, srcValue, (key + ''), object, source, stack)
- : undefined;
+ decodedChar = this._patternToChar(pattern);
- var isCommon = newValue === undefined;
+ if (decodedChar === null) {
+ return null;
+ }
- if (isCommon) {
- var isArr = isArray(srcValue),
- isBuff = !isArr && isBuffer(srcValue),
- isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+ result.push(decodedChar);
+ lastStart = nextStart;
+ nextStart += counters.reduce(function (sum, item) {
+ return sum + item;
+ }, 0);
+ nextStart = this._nextSet(this._row, nextStart);
+ } while (decodedChar !== '*');
- newValue = srcValue;
- if (isArr || isBuff || isTyped) {
- if (isArray(objValue)) {
- newValue = objValue;
- }
- else if (isArrayLikeObject(objValue)) {
- newValue = copyArray(objValue);
- }
- else if (isBuff) {
- isCommon = false;
- newValue = cloneBuffer(srcValue, true);
- }
- else if (isTyped) {
- isCommon = false;
- newValue = cloneTypedArray(srcValue, true);
+ result.pop();
+
+ if (!result.length) {
+ return null;
}
- else {
- newValue = [];
+
+ if (!this._verifyTrailingWhitespace(lastStart, nextStart, counters)) {
+ return null;
}
+
+ return {
+ code: result.join(''),
+ start: start.start,
+ end: nextStart,
+ startInfo: start,
+ decodedCodes: result
+ };
}
- else if (isPlainObject(srcValue) || isArguments(srcValue)) {
- newValue = objValue;
- if (isArguments(objValue)) {
- newValue = toPlainObject(objValue);
- }
- else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
- newValue = initCloneObject(srcValue);
+ }, {
+ key: "_patternToChar",
+ value: function _patternToChar(pattern) {
+ for (var i = 0; i < CHARACTER_ENCODINGS.length; i++) {
+ if (CHARACTER_ENCODINGS[i] === pattern) {
+ return String.fromCharCode(ALPHABET[i]);
+ }
}
+
+ return null;
}
- else {
- isCommon = false;
+ }, {
+ key: "_verifyTrailingWhitespace",
+ value: function _verifyTrailingWhitespace(lastStart, nextStart, counters) {
+ var patternSize = counters.reduce(function (sum, item) {
+ return sum + item;
+ }, 0);
+ var trailingWhitespaceEnd = nextStart - lastStart - patternSize;
+ return trailingWhitespaceEnd * 3 >= patternSize;
}
- }
- if (isCommon) {
- // Recursively merge objects and arrays (susceptible to call stack limits).
- stack.set(srcValue, newValue);
- mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
- stack['delete'](srcValue);
- }
- assignMergeValue(object, key, newValue);
-}
-
-module.exports = baseMergeDeep;
-
-
-/***/ }),
-/* 102 */
-/***/ (function(module, exports, __webpack_require__) {
+ }, {
+ key: "_findNextWidth",
+ value: function _findNextWidth(counters, current) {
+ var minWidth = Number.MAX_VALUE;
-var basePickBy = __webpack_require__(103),
- hasIn = __webpack_require__(158);
-
-/**
- * The base implementation of `_.pick` without support for individual
- * property identifiers.
- *
- * @private
- * @param {Object} object The source object.
- * @param {string[]} paths The property paths to pick.
- * @returns {Object} Returns the new object.
- */
-function basePick(object, paths) {
- return basePickBy(object, paths, function(value, path) {
- return hasIn(object, path);
- });
-}
+ for (var i = 0; i < counters.length; i++) {
+ if (counters[i] < minWidth && counters[i] > current) {
+ minWidth = counters[i];
+ }
+ }
-module.exports = basePick;
+ return minWidth;
+ }
+ }, {
+ key: "_toPattern",
+ value: function _toPattern(counters) {
+ var numCounters = counters.length;
+ var maxNarrowWidth = 0;
+ var numWideBars = numCounters;
+ var wideBarWidth = 0;
+ var pattern;
+ while (numWideBars > 3) {
+ maxNarrowWidth = this._findNextWidth(counters, maxNarrowWidth);
+ numWideBars = 0;
+ pattern = 0;
-/***/ }),
-/* 103 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (var i = 0; i < numCounters; i++) {
+ if (counters[i] > maxNarrowWidth) {
+ pattern |= 1 << numCounters - 1 - i;
+ numWideBars++;
+ wideBarWidth += counters[i];
+ }
+ }
-var baseGet = __webpack_require__(94),
- baseSet = __webpack_require__(105),
- castPath = __webpack_require__(13);
+ if (numWideBars === 3) {
+ for (var _i = 0; _i < numCounters && numWideBars > 0; _i++) {
+ if (counters[_i] > maxNarrowWidth) {
+ numWideBars--;
-/**
- * The base implementation of `_.pickBy` without support for iteratee shorthands.
- *
- * @private
- * @param {Object} object The source object.
- * @param {string[]} paths The property paths to pick.
- * @param {Function} predicate The function invoked per property.
- * @returns {Object} Returns the new object.
- */
-function basePickBy(object, paths, predicate) {
- var index = -1,
- length = paths.length,
- result = {};
+ if (counters[_i] * 2 >= wideBarWidth) {
+ return -1;
+ }
+ }
+ }
- while (++index < length) {
- var path = paths[index],
- value = baseGet(object, path);
+ return pattern;
+ }
+ }
- if (predicate(value, path)) {
- baseSet(result, castPath(path, object), value);
+ return -1;
}
- }
- return result;
-}
-
-module.exports = basePickBy;
-
+ }, {
+ key: "_findStart",
+ value: function _findStart() {
+ var offset = this._nextSet(this._row);
-/***/ }),
-/* 104 */
-/***/ (function(module, exports, __webpack_require__) {
+ var patternStart = offset;
+ var counter = new Uint16Array(9);
+ var counterPos = 0;
+ var isWhite = 0;
+ var whiteSpaceMustStart;
-var identity = __webpack_require__(43),
- overRest = __webpack_require__(41),
- setToString = __webpack_require__(42);
-
-/**
- * The base implementation of `_.rest` which doesn't validate or coerce arguments.
- *
- * @private
- * @param {Function} func The function to apply a rest parameter to.
- * @param {number} [start=func.length-1] The start position of the rest parameter.
- * @returns {Function} Returns the new function.
- */
-function baseRest(func, start) {
- return setToString(overRest(func, start, identity), func + '');
-}
+ for (var i = offset; i < this._row.length; i++) {
+ if (this._row[i] ^ isWhite) {
+ counter[counterPos]++;
+ } else {
+ if (counterPos === counter.length - 1) {
+ // find start pattern
+ if (this._toPattern(counter) === ASTERISK) {
+ whiteSpaceMustStart = Math.max(0, patternStart - (i - patternStart) / 4) | 0;
-module.exports = baseRest;
+ if (this._matchRange(whiteSpaceMustStart, patternStart, 0)) {
+ return {
+ start: patternStart,
+ end: i
+ };
+ }
+ }
+ patternStart += counter[0] + counter[1];
-/***/ }),
-/* 105 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (var j = 0; j < 7; j++) {
+ counter[j] = counter[j + 2];
+ }
-var assignValue = __webpack_require__(36),
- castPath = __webpack_require__(13),
- isIndex = __webpack_require__(15),
- isObject = __webpack_require__(0),
- toKey = __webpack_require__(23);
+ counter[7] = 0;
+ counter[8] = 0;
+ counterPos--;
+ } else {
+ counterPos++;
+ }
-/**
- * The base implementation of `_.set`.
- *
- * @private
- * @param {Object} object The object to modify.
- * @param {Array|string} path The path of the property to set.
- * @param {*} value The value to set.
- * @param {Function} [customizer] The function to customize path creation.
- * @returns {Object} Returns `object`.
- */
-function baseSet(object, path, value, customizer) {
- if (!isObject(object)) {
- return object;
- }
- path = castPath(path, object);
+ counter[counterPos] = 1;
+ isWhite = isWhite ? 0 : 1;
+ }
+ }
- var index = -1,
- length = path.length,
- lastIndex = length - 1,
- nested = object;
+ return null;
+ }
+ }]);
- while (nested != null && ++index < length) {
- var key = toKey(path[index]),
- newValue = value;
+ return Code39Reader;
+}(_barcode_reader__WEBPACK_IMPORTED_MODULE_6__["BarcodeReader"]);
- if (index != lastIndex) {
- var objValue = nested[key];
- newValue = customizer ? customizer(objValue, key, nested) : undefined;
- if (newValue === undefined) {
- newValue = isObject(objValue)
- ? objValue
- : (isIndex(path[index + 1]) ? [] : {});
- }
- }
- assignValue(nested, key, newValue);
- nested = nested[key];
- }
- return object;
-}
+/***/ }),
-module.exports = baseSet;
+/***/ "./src/reader/code-39-vin-reader.ts":
+/*!******************************************!*\
+ !*** ./src/reader/code-39-vin-reader.ts ***!
+ \******************************************/
+/*! exports provided: Code39VINReader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Code39VINReader", function() { return Code39VINReader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/get */ "../../node_modules/@babel/runtime/helpers/get.js");
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _code_39_reader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./code-39-reader */ "./src/reader/code-39-reader.ts");
-/***/ }),
-/* 106 */
-/***/ (function(module, exports, __webpack_require__) {
-var constant = __webpack_require__(156),
- defineProperty = __webpack_require__(37),
- identity = __webpack_require__(43);
-/**
- * The base implementation of `setToString` without support for hot loop shorting.
- *
- * @private
- * @param {Function} func The function to modify.
- * @param {Function} string The `toString` result.
- * @returns {Function} Returns `func`.
- */
-var baseSetToString = !defineProperty ? identity : function(func, string) {
- return defineProperty(func, 'toString', {
- 'configurable': true,
- 'enumerable': false,
- 'value': constant(string),
- 'writable': true
- });
-};
-module.exports = baseSetToString;
-/***/ }),
-/* 107 */
-/***/ (function(module, exports) {
-/**
- * The base implementation of `_.times` without support for iteratee shorthands
- * or max array length checks.
- *
- * @private
- * @param {number} n The number of times to invoke `iteratee`.
- * @param {Function} iteratee The function invoked per iteration.
- * @returns {Array} Returns the array of results.
- */
-function baseTimes(n, iteratee) {
- var index = -1,
- result = Array(n);
+var Code39VINReader =
+/*#__PURE__*/
+function (_Code39Reader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default()(Code39VINReader, _Code39Reader);
- while (++index < n) {
- result[index] = iteratee(index);
- }
- return result;
-}
+ function Code39VINReader() {
+ var _this;
-module.exports = baseTimes;
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, Code39VINReader);
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(Code39VINReader).call(this));
+ _this._format = 'code_39_vin';
+ return _this;
+ }
+ /**
+ * @borrows
+ * https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/client/result/VINResultParser.java
+ */
-/***/ }),
-/* 108 */
-/***/ (function(module, exports, __webpack_require__) {
-var Symbol = __webpack_require__(11),
- arrayMap = __webpack_require__(89),
- isArray = __webpack_require__(2),
- isSymbol = __webpack_require__(27);
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(Code39VINReader, [{
+ key: "decode",
+ value: function decode() {
+ var result = _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_4___default()(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(Code39VINReader.prototype), "decode", this).call(this);
-/** Used as references for various `Number` constants. */
-var INFINITY = 1 / 0;
+ if (!result) {
+ return null;
+ }
-/** Used to convert symbols to primitives and strings. */
-var symbolProto = Symbol ? Symbol.prototype : undefined,
- symbolToString = symbolProto ? symbolProto.toString : undefined;
+ var code = result.code;
-/**
- * The base implementation of `_.toString` which doesn't convert nullish
- * values to empty strings.
- *
- * @private
- * @param {*} value The value to process.
- * @returns {string} Returns the string.
- */
-function baseToString(value) {
- // Exit early for strings to avoid a performance hit in some environments.
- if (typeof value == 'string') {
- return value;
- }
- if (isArray(value)) {
- // Recursively convert values (susceptible to call stack limits).
- return arrayMap(value, baseToString) + '';
- }
- if (isSymbol(value)) {
- return symbolToString ? symbolToString.call(value) : '';
- }
- var result = (value + '');
- return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
-}
+ if (!code) {
+ return null;
+ }
-module.exports = baseToString;
+ code = code.replace(/[IOQ]/g, '');
+ if (!/[A-Z0-9]{17}/.test(code)) {
+ if (true) {
+ console.log('Failed AZ09 pattern code:', code);
+ }
-/***/ }),
-/* 109 */
-/***/ (function(module, exports) {
+ return null;
+ }
-/**
- * The base implementation of `_.unary` without support for storing metadata.
- *
- * @private
- * @param {Function} func The function to cap arguments for.
- * @returns {Function} Returns the new capped function.
- */
-function baseUnary(func) {
- return function(value) {
- return func(value);
- };
-}
+ if (!this._checkChecksum(code)) {
+ return null;
+ }
-module.exports = baseUnary;
+ result.code = code;
+ return result;
+ }
+ }, {
+ key: "_checkChecksum",
+ value: function _checkChecksum(code) {
+ // TODO
+ return !!code;
+ }
+ }]);
+ return Code39VINReader;
+}(_code_39_reader__WEBPACK_IMPORTED_MODULE_6__["Code39Reader"]);
/***/ }),
-/* 110 */
-/***/ (function(module, exports, __webpack_require__) {
-var Uint8Array = __webpack_require__(86);
-
-/**
- * Creates a clone of `arrayBuffer`.
- *
- * @private
- * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
- * @returns {ArrayBuffer} Returns the cloned array buffer.
- */
-function cloneArrayBuffer(arrayBuffer) {
- var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
- new Uint8Array(result).set(new Uint8Array(arrayBuffer));
- return result;
-}
+/***/ "./src/reader/code-93-reader.ts":
+/*!**************************************!*\
+ !*** ./src/reader/code-93-reader.ts ***!
+ \**************************************/
+/*! exports provided: Code93Reader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-module.exports = cloneArrayBuffer;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Code93Reader", function() { return Code93Reader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/toConsumableArray */ "../../node_modules/@babel/runtime/helpers/toConsumableArray.js");
+/* harmony import */ var _babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _barcode_reader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./barcode-reader */ "./src/reader/barcode-reader.ts");
-/***/ }),
-/* 111 */
-/***/ (function(module, exports, __webpack_require__) {
-/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(5);
-/** Detect free variable `exports`. */
-var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
-/** Detect free variable `module`. */
-var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
-/** Detect the popular CommonJS extension `module.exports`. */
-var moduleExports = freeModule && freeModule.exports === freeExports;
-/** Built-in value references. */
-var Buffer = moduleExports ? root.Buffer : undefined,
- allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
+var ALPHABETH_STRING = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*';
+var ALPHABET = new Uint16Array(_babel_runtime_helpers_toConsumableArray__WEBPACK_IMPORTED_MODULE_5___default()(ALPHABETH_STRING).map(function (_char) {
+ return _char.charCodeAt(0);
+}));
+var CHARACTER_ENCODINGS = new Uint16Array([0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, 0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A, 0x168, 0x164, 0x162, 0x134, 0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, 0x196, 0x19A, 0x16C, 0x166, 0x136, 0x13A, 0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, 0x126, 0x1DA, 0x1D6, 0x132, 0x15E]);
+var ASTERISK = 0x15E;
+var Code93Reader =
+/*#__PURE__*/
+function (_BarcodeReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default()(Code93Reader, _BarcodeReader);
-/**
- * Creates a clone of `buffer`.
- *
- * @private
- * @param {Buffer} buffer The buffer to clone.
- * @param {boolean} [isDeep] Specify a deep clone.
- * @returns {Buffer} Returns the cloned buffer.
- */
-function cloneBuffer(buffer, isDeep) {
- if (isDeep) {
- return buffer.slice();
- }
- var length = buffer.length,
- result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+ function Code93Reader() {
+ var _this;
- buffer.copy(result);
- return result;
-}
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, Code93Reader);
-module.exports = cloneBuffer;
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(Code93Reader).call(this));
+ _this._format = 'code_93';
+ return _this;
+ }
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)(module)))
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(Code93Reader, [{
+ key: "decode",
+ value: function decode() {
+ var start = this._findStart();
-/***/ }),
-/* 112 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (!start) {
+ return null;
+ }
-var cloneArrayBuffer = __webpack_require__(110);
+ var result = new Array();
+ var counters = new Uint16Array(6);
+ var decodedChar;
+ var lastStart;
-/**
- * Creates a clone of `typedArray`.
- *
- * @private
- * @param {Object} typedArray The typed array to clone.
- * @param {boolean} [isDeep] Specify a deep clone.
- * @returns {Object} Returns the cloned typed array.
- */
-function cloneTypedArray(typedArray, isDeep) {
- var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
- return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
-}
+ var nextStart = this._nextSet(this._row, start.end);
-module.exports = cloneTypedArray;
+ do {
+ this._toCounters(nextStart, counters);
+ var pattern = this._toPattern(counters);
-/***/ }),
-/* 113 */
-/***/ (function(module, exports) {
+ if (pattern < 0) {
+ return null;
+ }
-/**
- * Copies the values of `source` to `array`.
- *
- * @private
- * @param {Array} source The array to copy values from.
- * @param {Array} [array=[]] The array to copy values to.
- * @returns {Array} Returns `array`.
- */
-function copyArray(source, array) {
- var index = -1,
- length = source.length;
+ decodedChar = this._patternToChar(pattern);
- array || (array = Array(length));
- while (++index < length) {
- array[index] = source[index];
- }
- return array;
-}
+ if (decodedChar === null) {
+ return null;
+ }
-module.exports = copyArray;
+ result.push(decodedChar);
+ lastStart = nextStart;
+ nextStart += counters.reduce(function (sum, item) {
+ return sum + item;
+ }, 0);
+ nextStart = this._nextSet(this._row, nextStart);
+ } while (decodedChar !== '*');
+ result.pop();
-/***/ }),
-/* 114 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (!result.length) {
+ return null;
+ }
-var assignValue = __webpack_require__(36),
- baseAssignValue = __webpack_require__(21);
+ if (!this._verifyEnd(lastStart, nextStart)) {
+ return null;
+ }
-/**
- * Copies properties of `source` to `object`.
- *
- * @private
- * @param {Object} source The object to copy properties from.
- * @param {Array} props The property identifiers to copy.
- * @param {Object} [object={}] The object to copy properties to.
- * @param {Function} [customizer] The function to customize copied values.
- * @returns {Object} Returns `object`.
- */
-function copyObject(source, props, object, customizer) {
- var isNew = !object;
- object || (object = {});
+ if (!this._verifyChecksums(result)) {
+ return null;
+ }
- var index = -1,
- length = props.length;
+ result = result.slice(0, result.length - 2);
- while (++index < length) {
- var key = props[index];
+ if ((result = this._decodeExtended(result)) === null) {
+ return null;
+ }
- var newValue = customizer
- ? customizer(object[key], source[key], key, object, source)
- : undefined;
+ return {
+ code: result.join(''),
+ start: start.start,
+ end: nextStart,
+ startInfo: start,
+ decodedCodes: result
+ };
+ }
+ }, {
+ key: "_patternToChar",
+ value: function _patternToChar(pattern) {
+ for (var i = 0; i < CHARACTER_ENCODINGS.length; i++) {
+ if (CHARACTER_ENCODINGS[i] === pattern) {
+ return String.fromCharCode(ALPHABET[i]);
+ }
+ }
- if (newValue === undefined) {
- newValue = source[key];
+ return null;
}
- if (isNew) {
- baseAssignValue(object, key, newValue);
- } else {
- assignValue(object, key, newValue);
+ }, {
+ key: "_verifyEnd",
+ value: function _verifyEnd(lastStart, nextStart) {
+ if (lastStart === nextStart || !this._row[nextStart]) {
+ return false;
+ }
+
+ return true;
}
- }
- return object;
-}
+ }, {
+ key: "_toPattern",
+ value: function _toPattern(counters) {
+ var numCounters = counters.length;
+ var pattern = 0;
+ var sum = 0;
-module.exports = copyObject;
+ for (var i = 0; i < numCounters; i++) {
+ sum += counters[i];
+ }
+ for (var _i = 0; _i < numCounters; _i++) {
+ var normalized = Math.round(counters[_i] * 9 / sum);
-/***/ }),
-/* 115 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (normalized < 1 || normalized > 4) {
+ return -1;
+ }
-var root = __webpack_require__(5);
+ if ((_i & 1) === 0) {
+ for (var j = 0; j < normalized; j++) {
+ pattern = pattern << 1 | 1;
+ }
+ } else {
+ pattern <<= normalized;
+ }
+ }
-/** Used to detect overreaching core-js shims. */
-var coreJsData = root['__core-js_shared__'];
+ return pattern;
+ }
+ }, {
+ key: "_findStart",
+ value: function _findStart() {
+ var counter = new Uint16Array(6);
-module.exports = coreJsData;
+ var offset = this._nextSet(this._row);
+ var patternStart = offset;
+ var counterPos = 0;
+ var isWhite = 0;
+ var whiteSpaceMustStart;
-/***/ }),
-/* 116 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (var i = offset; i < this._row.length; i++) {
+ if (this._row[i] ^ isWhite) {
+ counter[counterPos]++;
+ } else {
+ if (counterPos === counter.length - 1) {
+ // find start pattern
+ if (this._toPattern(counter) === ASTERISK) {
+ whiteSpaceMustStart = Math.max(0, patternStart - (i - patternStart) / 4) | 0;
-var baseRest = __webpack_require__(104),
- isIterateeCall = __webpack_require__(129);
+ if (this._matchRange(whiteSpaceMustStart, patternStart, 0)) {
+ return {
+ start: patternStart,
+ end: i
+ };
+ }
+ }
-/**
- * Creates a function like `_.assign`.
- *
- * @private
- * @param {Function} assigner The function to assign values.
- * @returns {Function} Returns the new assigner function.
- */
-function createAssigner(assigner) {
- return baseRest(function(object, sources) {
- var index = -1,
- length = sources.length,
- customizer = length > 1 ? sources[length - 1] : undefined,
- guard = length > 2 ? sources[2] : undefined;
+ patternStart += counter[0] + counter[1];
- customizer = (assigner.length > 3 && typeof customizer == 'function')
- ? (length--, customizer)
- : undefined;
+ for (var j = 0; j < 4; j++) {
+ counter[j] = counter[j + 2];
+ }
- if (guard && isIterateeCall(sources[0], sources[1], guard)) {
- customizer = length < 3 ? undefined : customizer;
- length = 1;
- }
- object = Object(object);
- while (++index < length) {
- var source = sources[index];
- if (source) {
- assigner(object, source, index, customizer);
+ counter[4] = 0;
+ counter[5] = 0;
+ counterPos--;
+ } else {
+ counterPos++;
+ }
+
+ counter[counterPos] = 1;
+ isWhite = isWhite ? 0 : 1;
+ }
}
+
+ return null;
}
- return object;
- });
-}
+ }, {
+ key: "_decodeExtended",
+ value: function _decodeExtended(charArray) {
+ var length = charArray.length;
+ var result = new Array();
-module.exports = createAssigner;
+ for (var i = 0; i < length; i++) {
+ var _char2 = charArray[i];
+ if (_char2 >= 'a' && _char2 <= 'd') {
+ if (i > length - 2) {
+ return null;
+ }
-/***/ }),
-/* 117 */
-/***/ (function(module, exports) {
+ var nextChar = charArray[++i];
+ var nextCharCode = nextChar.charCodeAt(0);
+ var decodedChar = void 0;
-/**
- * Creates a base function for methods like `_.forIn` and `_.forOwn`.
- *
- * @private
- * @param {boolean} [fromRight] Specify iterating from right to left.
- * @returns {Function} Returns the new base function.
- */
-function createBaseFor(fromRight) {
- return function(object, iteratee, keysFunc) {
- var index = -1,
- iterable = Object(object),
- props = keysFunc(object),
- length = props.length;
+ switch (_char2) {
+ case 'a':
+ {
+ if (nextChar >= 'A' && nextChar <= 'Z') {
+ decodedChar = String.fromCharCode(nextCharCode - 64);
+ } else {
+ return null;
+ }
- while (length--) {
- var key = props[fromRight ? length : ++index];
- if (iteratee(iterable[key], key, iterable) === false) {
- break;
- }
- }
- return object;
- };
-}
+ break;
+ }
+
+ case 'b':
+ {
+ if (nextChar >= 'A' && nextChar <= 'E') {
+ decodedChar = String.fromCharCode(nextCharCode - 38);
+ } else if (nextChar >= 'F' && nextChar <= 'J') {
+ decodedChar = String.fromCharCode(nextCharCode - 11);
+ } else if (nextChar >= 'K' && nextChar <= 'O') {
+ decodedChar = String.fromCharCode(nextCharCode + 16);
+ } else if (nextChar >= 'P' && nextChar <= 'S') {
+ decodedChar = String.fromCharCode(nextCharCode + 43);
+ } else if (nextChar >= 'T' && nextChar <= 'Z') {
+ decodedChar = String.fromCharCode(127);
+ } else {
+ return null;
+ }
-module.exports = createBaseFor;
+ break;
+ }
+
+ case 'c':
+ {
+ if (nextChar >= 'A' && nextChar <= 'O') {
+ decodedChar = String.fromCharCode(nextCharCode - 32);
+ } else if (nextChar === 'Z') {
+ decodedChar = ':';
+ } else {
+ return null;
+ }
+ break;
+ }
-/***/ }),
-/* 118 */
-/***/ (function(module, exports, __webpack_require__) {
+ case 'd':
+ {
+ if (nextChar >= 'A' && nextChar <= 'Z') {
+ decodedChar = String.fromCharCode(nextCharCode + 32);
+ } else {
+ return null;
+ }
-var flatten = __webpack_require__(157),
- overRest = __webpack_require__(41),
- setToString = __webpack_require__(42);
+ break;
+ }
+ }
-/**
- * A specialized version of `baseRest` which flattens the rest array.
- *
- * @private
- * @param {Function} func The function to apply a rest parameter to.
- * @returns {Function} Returns the new function.
- */
-function flatRest(func) {
- return setToString(overRest(func, undefined, flatten), func + '');
-}
+ result.push(decodedChar);
+ } else {
+ result.push(_char2);
+ }
+ }
-module.exports = flatRest;
+ return result;
+ }
+ }, {
+ key: "_verifyChecksums",
+ value: function _verifyChecksums(charArray) {
+ return this._matchCheckChar(charArray, charArray.length - 2, 20) && this._matchCheckChar(charArray, charArray.length - 1, 15);
+ }
+ }, {
+ key: "_matchCheckChar",
+ value: function _matchCheckChar(charArray, index, maxWeight) {
+ var arrayToCheck = charArray.slice(0, index);
+ var length = arrayToCheck.length;
+ var weightedSums = arrayToCheck.reduce(function (sum, _char3, i) {
+ var weight = (i * -1 + (length - 1)) % maxWeight + 1;
+ var value = ALPHABET.indexOf(_char3.charCodeAt(0));
+ return sum + weight * value;
+ }, 0);
+ var checkChar = ALPHABET[weightedSums % 47];
+ return checkChar === charArray[index].charCodeAt(0);
+ }
+ }]);
+ return Code93Reader;
+}(_barcode_reader__WEBPACK_IMPORTED_MODULE_6__["BarcodeReader"]);
/***/ }),
-/* 119 */
-/***/ (function(module, exports, __webpack_require__) {
-var Symbol = __webpack_require__(11);
+/***/ "./src/reader/ean-2-reader.ts":
+/*!************************************!*\
+ !*** ./src/reader/ean-2-reader.ts ***!
+ \************************************/
+/*! exports provided: EAN2Reader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EAN2Reader", function() { return EAN2Reader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _ean_reader__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./ean-reader */ "./src/reader/ean-reader.ts");
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
-/**
- * Used to resolve the
- * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
- * of values.
- */
-var nativeObjectToString = objectProto.toString;
-/** Built-in value references. */
-var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
-/**
- * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
- *
- * @private
- * @param {*} value The value to query.
- * @returns {string} Returns the raw `toStringTag`.
- */
-function getRawTag(value) {
- var isOwn = hasOwnProperty.call(value, symToStringTag),
- tag = value[symToStringTag];
- try {
- value[symToStringTag] = undefined;
- var unmasked = true;
- } catch (e) {}
-
- var result = nativeObjectToString.call(value);
- if (unmasked) {
- if (isOwn) {
- value[symToStringTag] = tag;
- } else {
- delete value[symToStringTag];
- }
- }
- return result;
-}
-module.exports = getRawTag;
+var EAN2Reader =
+/*#__PURE__*/
+function (_EANReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default()(EAN2Reader, _EANReader);
+ function EAN2Reader(config, supplements) {
+ var _this;
-/***/ }),
-/* 120 */
-/***/ (function(module, exports) {
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, EAN2Reader);
-/**
- * Gets the value at `key` of `object`.
- *
- * @private
- * @param {Object} [object] The object to query.
- * @param {string} key The key of the property to get.
- * @returns {*} Returns the property value.
- */
-function getValue(object, key) {
- return object == null ? undefined : object[key];
-}
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(EAN2Reader).call(this, config, supplements));
+ _this._format = 'ean_2';
+ return _this;
+ }
-module.exports = getValue;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(EAN2Reader, [{
+ key: "decode",
+ value: function decode(row, start) {
+ var end = row.length;
+ var result = new Array();
+ var decodedCodes = new Array();
+ var offset = start;
+ var codeFrequency = 0;
+ var code;
+ this._row = row;
+
+ for (var i = 0; i < 2 && offset < end; i++) {
+ code = this._decodeCode(offset);
+ if (!code) {
+ return null;
+ }
-/***/ }),
-/* 121 */
-/***/ (function(module, exports, __webpack_require__) {
+ decodedCodes.push(code);
+ result.push(code.code % 10);
-var castPath = __webpack_require__(13),
- isArguments = __webpack_require__(18),
- isArray = __webpack_require__(2),
- isIndex = __webpack_require__(15),
- isLength = __webpack_require__(26),
- toKey = __webpack_require__(23);
+ if (code.code >= this.CODE_G_START) {
+ codeFrequency |= 1 << 1 - i;
+ }
-/**
- * Checks if `path` exists on `object`.
- *
- * @private
- * @param {Object} object The object to query.
- * @param {Array|string} path The path to check.
- * @param {Function} hasFunc The function to check properties.
- * @returns {boolean} Returns `true` if `path` exists, else `false`.
- */
-function hasPath(object, path, hasFunc) {
- path = castPath(path, object);
+ if (i !== 1) {
+ offset = this._nextSet(this._row, code.end);
+ offset = this._nextUnset(this._row, offset);
+ }
+ }
- var index = -1,
- length = path.length,
- result = false;
+ if (result.length !== 2 || parseInt(result.join('')) % 4 !== codeFrequency) {
+ return null;
+ }
- while (++index < length) {
- var key = toKey(path[index]);
- if (!(result = object != null && hasFunc(object, key))) {
- break;
+ return {
+ code: result.join(''),
+ decodedCodes: decodedCodes,
+ end: code.end
+ };
}
- object = object[key];
- }
- if (result || ++index != length) {
- return result;
- }
- length = object == null ? 0 : object.length;
- return !!length && isLength(length) && isIndex(key, length) &&
- (isArray(object) || isArguments(object));
-}
-
-module.exports = hasPath;
+ }]);
+ return EAN2Reader;
+}(_ean_reader__WEBPACK_IMPORTED_MODULE_5__["EANReader"]);
/***/ }),
-/* 122 */
-/***/ (function(module, exports, __webpack_require__) {
-
-var nativeCreate = __webpack_require__(16);
-
-/**
- * Removes all key-value entries from the hash.
- *
- * @private
- * @name clear
- * @memberOf Hash
- */
-function hashClear() {
- this.__data__ = nativeCreate ? nativeCreate(null) : {};
- this.size = 0;
-}
-module.exports = hashClear;
+/***/ "./src/reader/ean-5-reader.ts":
+/*!************************************!*\
+ !*** ./src/reader/ean-5-reader.ts ***!
+ \************************************/
+/*! exports provided: EAN5Reader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EAN5Reader", function() { return EAN5Reader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _ean_reader__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./ean-reader */ "./src/reader/ean-reader.ts");
-/***/ }),
-/* 123 */
-/***/ (function(module, exports) {
-/**
- * Removes `key` and its value from the hash.
- *
- * @private
- * @name delete
- * @memberOf Hash
- * @param {Object} hash The hash to modify.
- * @param {string} key The key of the value to remove.
- * @returns {boolean} Returns `true` if the entry was removed, else `false`.
- */
-function hashDelete(key) {
- var result = this.has(key) && delete this.__data__[key];
- this.size -= result ? 1 : 0;
- return result;
-}
-module.exports = hashDelete;
-/***/ }),
-/* 124 */
-/***/ (function(module, exports, __webpack_require__) {
-var nativeCreate = __webpack_require__(16);
+var EAN5Reader =
+/*#__PURE__*/
+function (_EANReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default()(EAN5Reader, _EANReader);
-/** Used to stand-in for `undefined` hash values. */
-var HASH_UNDEFINED = '__lodash_hash_undefined__';
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3___default()(EAN5Reader, [{
+ key: "CHECK_DIGIT_ENCODINGS",
+ get: function get() {
+ return [24, 20, 18, 17, 12, 6, 3, 10, 9, 5];
+ }
+ }]);
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
+ function EAN5Reader(config, supplements) {
+ var _this;
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, EAN5Reader);
-/**
- * Gets the hash value for `key`.
- *
- * @private
- * @name get
- * @memberOf Hash
- * @param {string} key The key of the value to get.
- * @returns {*} Returns the entry value.
- */
-function hashGet(key) {
- var data = this.__data__;
- if (nativeCreate) {
- var result = data[key];
- return result === HASH_UNDEFINED ? undefined : result;
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_1___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2___default()(EAN5Reader).call(this, config, supplements));
+ _this._format = 'ean_5';
+ return _this;
}
- return hasOwnProperty.call(data, key) ? data[key] : undefined;
-}
-
-module.exports = hashGet;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_3___default()(EAN5Reader, [{
+ key: "decode",
+ value: function decode(row, start) {
+ var end = row.length;
+ var result = new Array();
+ var decodedCodes = new Array();
+ var codeFrequency = 0;
+ var offset = start;
+ var code;
+ this._row = row;
+
+ for (var i = 0; i < 5 && offset < end; i++) {
+ code = this._decodeCode(offset);
-/***/ }),
-/* 125 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (!code) {
+ return null;
+ }
-var nativeCreate = __webpack_require__(16);
+ decodedCodes.push(code);
+ result.push(code.code % 10);
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
+ if (code.code >= this.CODE_G_START) {
+ codeFrequency |= 1 << 4 - i;
+ }
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+ if (i !== 4) {
+ offset = this._nextSet(this._row, code.end);
+ offset = this._nextUnset(this._row, offset);
+ }
+ }
-/**
- * Checks if a hash value for `key` exists.
- *
- * @private
- * @name has
- * @memberOf Hash
- * @param {string} key The key of the entry to check.
- * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
- */
-function hashHas(key) {
- var data = this.__data__;
- return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
-}
+ if (result.length !== 5) {
+ return null;
+ }
-module.exports = hashHas;
+ if (this._extensionChecksum(result) !== this._determineCheckDigit(codeFrequency)) {
+ return null;
+ }
+ return {
+ code: result.join(''),
+ decodedCodes: decodedCodes,
+ end: code.end
+ };
+ }
+ }, {
+ key: "_determineCheckDigit",
+ value: function _determineCheckDigit(codeFrequency) {
+ for (var i = 0; i < 10; i++) {
+ if (codeFrequency === this.CHECK_DIGIT_ENCODINGS[i]) {
+ return i;
+ }
+ }
-/***/ }),
-/* 126 */
-/***/ (function(module, exports, __webpack_require__) {
+ return null;
+ }
+ }, {
+ key: "_extensionChecksum",
+ value: function _extensionChecksum(result) {
+ var length = result.length;
+ var sum = 0;
-var nativeCreate = __webpack_require__(16);
+ for (var i = length - 2; i >= 0; i -= 2) {
+ sum += result[i];
+ }
-/** Used to stand-in for `undefined` hash values. */
-var HASH_UNDEFINED = '__lodash_hash_undefined__';
+ sum *= 3;
-/**
- * Sets the hash `key` to `value`.
- *
- * @private
- * @name set
- * @memberOf Hash
- * @param {string} key The key of the value to set.
- * @param {*} value The value to set.
- * @returns {Object} Returns the hash instance.
- */
-function hashSet(key, value) {
- var data = this.__data__;
- this.size += this.has(key) ? 0 : 1;
- data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
- return this;
-}
+ for (var _i = length - 1; _i >= 0; _i -= 2) {
+ sum += result[_i];
+ }
-module.exports = hashSet;
+ sum *= 3;
+ return sum % 10;
+ }
+ }]);
+ return EAN5Reader;
+}(_ean_reader__WEBPACK_IMPORTED_MODULE_5__["EANReader"]);
/***/ }),
-/* 127 */
-/***/ (function(module, exports, __webpack_require__) {
-
-var baseCreate = __webpack_require__(91),
- getPrototype = __webpack_require__(39),
- isPrototype = __webpack_require__(40);
-
-/**
- * Initializes an object clone.
- *
- * @private
- * @param {Object} object The object to clone.
- * @returns {Object} Returns the initialized clone.
- */
-function initCloneObject(object) {
- return (typeof object.constructor == 'function' && !isPrototype(object))
- ? baseCreate(getPrototype(object))
- : {};
-}
-module.exports = initCloneObject;
+/***/ "./src/reader/ean-8-reader.ts":
+/*!************************************!*\
+ !*** ./src/reader/ean-8-reader.ts ***!
+ \************************************/
+/*! exports provided: EAN8Reader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EAN8Reader", function() { return EAN8Reader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _ean_reader__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./ean-reader */ "./src/reader/ean-reader.ts");
-/***/ }),
-/* 128 */
-/***/ (function(module, exports, __webpack_require__) {
-var Symbol = __webpack_require__(11),
- isArguments = __webpack_require__(18),
- isArray = __webpack_require__(2);
-/** Built-in value references. */
-var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;
-/**
- * Checks if `value` is a flattenable `arguments` object or array.
- *
- * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
- */
-function isFlattenable(value) {
- return isArray(value) || isArguments(value) ||
- !!(spreadableSymbol && value && value[spreadableSymbol]);
-}
-module.exports = isFlattenable;
+var EAN8Reader =
+/*#__PURE__*/
+function (_EANReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_4___default()(EAN8Reader, _EANReader);
-/***/ }),
-/* 129 */
-/***/ (function(module, exports, __webpack_require__) {
+ function EAN8Reader(config, supplements) {
+ var _this;
-var eq = __webpack_require__(17),
- isArrayLike = __webpack_require__(24),
- isIndex = __webpack_require__(15),
- isObject = __webpack_require__(0);
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, EAN8Reader);
-/**
- * Checks if the given arguments are from an iteratee call.
- *
- * @private
- * @param {*} value The potential iteratee value argument.
- * @param {*} index The potential iteratee index or key argument.
- * @param {*} object The potential iteratee object argument.
- * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
- * else `false`.
- */
-function isIterateeCall(value, index, object) {
- if (!isObject(object)) {
- return false;
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(EAN8Reader).call(this, config, supplements));
+ _this._format = 'ean_8';
+ return _this;
}
- var type = typeof index;
- if (type == 'number'
- ? (isArrayLike(object) && isIndex(index, object.length))
- : (type == 'string' && index in object)
- ) {
- return eq(object[index], value);
- }
- return false;
-}
-module.exports = isIterateeCall;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(EAN8Reader, [{
+ key: "_decodePayload",
+ value: function _decodePayload(code, result, decodedCodes) {
+ for (var i = 0; i < 4; i++) {
+ code = this._decodeCode(code.end, this.CODE_G_START);
+ if (!code) {
+ return null;
+ }
-/***/ }),
-/* 130 */
-/***/ (function(module, exports, __webpack_require__) {
-
-var isArray = __webpack_require__(2),
- isSymbol = __webpack_require__(27);
+ result.push(code.code);
+ decodedCodes.push(code);
+ }
-/** Used to match property names within property paths. */
-var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
- reIsPlainProp = /^\w*$/;
+ code = this._findPattern(this.MIDDLE_PATTERN, code.end, 1, false);
-/**
- * Checks if `value` is a property name and not a property path.
- *
- * @private
- * @param {*} value The value to check.
- * @param {Object} [object] The object to query keys on.
- * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
- */
-function isKey(value, object) {
- if (isArray(value)) {
- return false;
- }
- var type = typeof value;
- if (type == 'number' || type == 'symbol' || type == 'boolean' ||
- value == null || isSymbol(value)) {
- return true;
- }
- return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
- (object != null && value in Object(object));
-}
+ if (code === null) {
+ return null;
+ }
-module.exports = isKey;
+ decodedCodes.push(code);
+ for (var _i = 0; _i < 4; _i++) {
+ code = this._decodeCode(code.end, this.CODE_G_START);
-/***/ }),
-/* 131 */
-/***/ (function(module, exports) {
+ if (!code) {
+ return null;
+ }
-/**
- * Checks if `value` is suitable for use as unique object key.
- *
- * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
- */
-function isKeyable(value) {
- var type = typeof value;
- return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
- ? (value !== '__proto__')
- : (value === null);
-}
+ decodedCodes.push(code);
+ result.push(code.code);
+ }
-module.exports = isKeyable;
+ return code;
+ }
+ }]);
+ return EAN8Reader;
+}(_ean_reader__WEBPACK_IMPORTED_MODULE_5__["EANReader"]);
/***/ }),
-/* 132 */
-/***/ (function(module, exports, __webpack_require__) {
-var coreJsData = __webpack_require__(115);
+/***/ "./src/reader/ean-reader.ts":
+/*!**********************************!*\
+ !*** ./src/reader/ean-reader.ts ***!
+ \**********************************/
+/*! exports provided: EANReader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-/** Used to detect methods masquerading as native. */
-var maskSrcKey = (function() {
- var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
- return uid ? ('Symbol(src)_1.' + uid) : '';
-}());
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EANReader", function() { return EANReader; });
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _common_merge__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../common/merge */ "./src/common/merge.ts");
+/* harmony import */ var _barcode_reader__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./barcode-reader */ "./src/reader/barcode-reader.ts");
-/**
- * Checks if `func` has its source masked.
- *
- * @private
- * @param {Function} func The function to check.
- * @returns {boolean} Returns `true` if `func` is masked, else `false`.
- */
-function isMasked(func) {
- return !!maskSrcKey && (maskSrcKey in func);
-}
-module.exports = isMasked;
-/***/ }),
-/* 133 */
-/***/ (function(module, exports) {
-/**
- * Removes all key-value entries from the list cache.
- *
- * @private
- * @name clear
- * @memberOf ListCache
- */
-function listCacheClear() {
- this.__data__ = [];
- this.size = 0;
-}
-module.exports = listCacheClear;
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-/***/ }),
-/* 134 */
-/***/ (function(module, exports, __webpack_require__) {
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-var assocIndexOf = __webpack_require__(12);
-/** Used for built-in method references. */
-var arrayProto = Array.prototype;
-/** Built-in value references. */
-var splice = arrayProto.splice;
+var EXTENSION_START_PATTERN = [1, 1, 2];
+var CODE_PATTERN = [[3, 2, 1, 1], [2, 2, 2, 1], [2, 1, 2, 2], [1, 4, 1, 1], [1, 1, 3, 2], [1, 2, 3, 1], [1, 1, 1, 4], [1, 3, 1, 2], [1, 2, 1, 3], [3, 1, 1, 2], [1, 1, 2, 3], [1, 2, 2, 2], [2, 2, 1, 2], [1, 1, 4, 1], [2, 3, 1, 1], [1, 3, 2, 1], [4, 1, 1, 1], [2, 1, 3, 1], [3, 1, 2, 1], [2, 1, 1, 3]];
+var CODE_FREQUENCY = [0, 11, 13, 14, 19, 25, 28, 21, 22, 26];
+var EANReader =
+/*#__PURE__*/
+function (_BarcodeReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default()(EANReader, _BarcodeReader);
-/**
- * Removes `key` and its value from the list cache.
- *
- * @private
- * @name delete
- * @memberOf ListCache
- * @param {string} key The key of the value to remove.
- * @returns {boolean} Returns `true` if the entry was removed, else `false`.
- */
-function listCacheDelete(key) {
- var data = this.__data__,
- index = assocIndexOf(data, key);
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4___default()(EANReader, [{
+ key: "CODE_L_START",
+ get: function get() {
+ return 0;
+ }
+ }, {
+ key: "CODE_G_START",
+ get: function get() {
+ return 10;
+ }
+ }, {
+ key: "START_PATTERN",
+ get: function get() {
+ return [1, 1, 1];
+ }
+ }, {
+ key: "STOP_PATTERN",
+ get: function get() {
+ return [1, 1, 1];
+ }
+ }, {
+ key: "MIDDLE_PATTERN",
+ get: function get() {
+ return [1, 1, 1, 1, 1];
+ }
+ }]);
- if (index < 0) {
- return false;
- }
- var lastIndex = data.length - 1;
- if (index == lastIndex) {
- data.pop();
- } else {
- splice.call(data, index, 1);
- }
- --this.size;
- return true;
-}
+ function EANReader(config, supplements) {
+ var _this;
-module.exports = listCacheDelete;
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1___default()(this, EANReader);
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(EANReader).call(this, Object(_common_merge__WEBPACK_IMPORTED_MODULE_6__["merge"])({
+ supplements: [] // Allowed extensions to be decoded (2 and/or 5)
-/***/ }),
-/* 135 */
-/***/ (function(module, exports, __webpack_require__) {
+ }, config), supplements));
+ _this._format = 'ean_13';
+ _this._singleCodeError = 0.70;
+ _this._averageCodeError = 0.48;
+ return _this;
+ }
-var assocIndexOf = __webpack_require__(12);
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4___default()(EANReader, [{
+ key: "_decodeCode",
+ value: function _decodeCode(start, coderange) {
+ var counter = [0, 0, 0, 0];
+ var offset = start;
+ var bestMatch = {
+ error: Number.MAX_VALUE,
+ code: -1,
+ start: start,
+ end: start
+ };
+ var epsilon = this.AVERAGE_CODE_ERROR;
+ var isWhite = this._row[offset] ? 0 : 1;
+ var counterPos = 0;
-/**
- * Gets the list cache value for `key`.
- *
- * @private
- * @name get
- * @memberOf ListCache
- * @param {string} key The key of the value to get.
- * @returns {*} Returns the entry value.
- */
-function listCacheGet(key) {
- var data = this.__data__,
- index = assocIndexOf(data, key);
+ if (!coderange) {
+ coderange = CODE_PATTERN.length;
+ }
- return index < 0 ? undefined : data[index][1];
-}
+ for (var i = offset; i < this._row.length; i++) {
+ if (this._row[i] ^ isWhite) {
+ counter[counterPos]++;
+ } else {
+ if (counterPos === counter.length - 1) {
+ for (var code = 0; code < coderange; code++) {
+ var error = this._matchPattern(counter, CODE_PATTERN[code]);
+
+ if (error < bestMatch.error) {
+ bestMatch.code = code;
+ bestMatch.error = error;
+ }
+ }
-module.exports = listCacheGet;
+ bestMatch.end = i;
+ if (bestMatch.error > epsilon) {
+ return null;
+ }
-/***/ }),
-/* 136 */
-/***/ (function(module, exports, __webpack_require__) {
+ return bestMatch;
+ } else {
+ counterPos++;
+ }
-var assocIndexOf = __webpack_require__(12);
+ counter[counterPos] = 1;
+ isWhite = isWhite ? 0 : 1;
+ }
+ }
-/**
- * Checks if a list cache value for `key` exists.
- *
- * @private
- * @name has
- * @memberOf ListCache
- * @param {string} key The key of the entry to check.
- * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
- */
-function listCacheHas(key) {
- return assocIndexOf(this.__data__, key) > -1;
-}
+ return null;
+ }
+ }, {
+ key: "_findStart",
+ value: function _findStart() {
+ var offset = this._nextSet(this._row);
-module.exports = listCacheHas;
+ var startInfo;
+ while (!startInfo) {
+ startInfo = this._findPattern(this.START_PATTERN, offset, 0, true);
-/***/ }),
-/* 137 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (!startInfo) {
+ return null;
+ }
-var assocIndexOf = __webpack_require__(12);
+ var leadingWhitespaceStart = startInfo.start - (startInfo.end - startInfo.start);
-/**
- * Sets the list cache `key` to `value`.
- *
- * @private
- * @name set
- * @memberOf ListCache
- * @param {string} key The key of the value to set.
- * @param {*} value The value to set.
- * @returns {Object} Returns the list cache instance.
- */
-function listCacheSet(key, value) {
- var data = this.__data__,
- index = assocIndexOf(data, key);
+ if (leadingWhitespaceStart >= 0) {
+ if (this._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {
+ return startInfo;
+ }
+ }
- if (index < 0) {
- ++this.size;
- data.push([key, value]);
- } else {
- data[index][1] = value;
- }
- return this;
-}
+ offset = startInfo.end;
+ startInfo = null;
+ }
-module.exports = listCacheSet;
+ return null;
+ }
+ }, {
+ key: "_verifyTrailingWhitespace",
+ value: function _verifyTrailingWhitespace(endInfo) {
+ var trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start);
+ if (trailingWhitespaceEnd < this._row.length) {
+ if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
+ return endInfo;
+ }
+ }
-/***/ }),
-/* 138 */
-/***/ (function(module, exports, __webpack_require__) {
+ return null;
+ }
+ }, {
+ key: "_findEnd",
+ value: function _findEnd(offset, isWhite) {
+ var endInfo = this._findPattern(this.STOP_PATTERN, offset, isWhite, false);
-var Hash = __webpack_require__(84),
- ListCache = __webpack_require__(10),
- Map = __webpack_require__(33);
+ return endInfo !== null ? this._verifyTrailingWhitespace(endInfo) : null;
+ }
+ }, {
+ key: "_calculateFirstDigit",
+ value: function _calculateFirstDigit(codeFrequency) {
+ for (var i = 0; i < CODE_FREQUENCY.length; i++) {
+ if (codeFrequency === CODE_FREQUENCY[i]) {
+ return i;
+ }
+ }
-/**
- * Removes all key-value entries from the map.
- *
- * @private
- * @name clear
- * @memberOf MapCache
- */
-function mapCacheClear() {
- this.size = 0;
- this.__data__ = {
- 'hash': new Hash,
- 'map': new (Map || ListCache),
- 'string': new Hash
- };
-}
+ return null;
+ }
+ }, {
+ key: "_decodePayload",
+ value: function _decodePayload(code, result, decodedCodes) {
+ var codeFrequency = 0x0;
-module.exports = mapCacheClear;
+ for (var i = 0; i < 6; i++) {
+ code = this._decodeCode(code.end);
+ if (!code) {
+ return null;
+ }
-/***/ }),
-/* 139 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (code.code >= this.CODE_G_START) {
+ code.code -= this.CODE_G_START;
+ codeFrequency |= 1 << 5 - i;
+ } else {
+ codeFrequency |= 0 << 5 - i;
+ }
-var getMapData = __webpack_require__(14);
+ result.push(code.code);
+ decodedCodes.push(code);
+ }
-/**
- * Removes `key` and its value from the map.
- *
- * @private
- * @name delete
- * @memberOf MapCache
- * @param {string} key The key of the value to remove.
- * @returns {boolean} Returns `true` if the entry was removed, else `false`.
- */
-function mapCacheDelete(key) {
- var result = getMapData(this, key)['delete'](key);
- this.size -= result ? 1 : 0;
- return result;
-}
+ var firstDigit = this._calculateFirstDigit(codeFrequency);
-module.exports = mapCacheDelete;
+ if (firstDigit === null) {
+ return null;
+ }
+ result.unshift(firstDigit);
+ code = this._findPattern(this.MIDDLE_PATTERN, code.end, 1, false);
-/***/ }),
-/* 140 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (code === null) {
+ return null;
+ }
-var getMapData = __webpack_require__(14);
+ decodedCodes.push(code);
-/**
- * Gets the map value for `key`.
- *
- * @private
- * @name get
- * @memberOf MapCache
- * @param {string} key The key of the value to get.
- * @returns {*} Returns the entry value.
- */
-function mapCacheGet(key) {
- return getMapData(this, key).get(key);
-}
+ for (var _i = 0; _i < 6; _i++) {
+ code = this._decodeCode(code.end, this.CODE_G_START);
-module.exports = mapCacheGet;
+ if (!code) {
+ return null;
+ }
+ decodedCodes.push(code);
+ result.push(code.code);
+ }
-/***/ }),
-/* 141 */
-/***/ (function(module, exports, __webpack_require__) {
+ return code;
+ }
+ }, {
+ key: "decode",
+ value: function decode() {
+ var result = new Array();
+ var decodedCodes = new Array();
+ var resultInfo = {};
-var getMapData = __webpack_require__(14);
+ var startInfo = this._findStart();
-/**
- * Checks if a map value for `key` exists.
- *
- * @private
- * @name has
- * @memberOf MapCache
- * @param {string} key The key of the entry to check.
- * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
- */
-function mapCacheHas(key) {
- return getMapData(this, key).has(key);
-}
+ if (!startInfo) {
+ return null;
+ }
-module.exports = mapCacheHas;
+ var code = {
+ code: startInfo.code,
+ start: startInfo.start,
+ end: startInfo.end
+ };
+ decodedCodes.push(code);
+ code = this._decodePayload(code, result, decodedCodes);
+ if (!code) {
+ return null;
+ }
-/***/ }),
-/* 142 */
-/***/ (function(module, exports, __webpack_require__) {
+ code = this._findEnd(code.end, 0);
-var getMapData = __webpack_require__(14);
+ if (!code) {
+ return null;
+ }
-/**
- * Sets the map `key` to `value`.
- *
- * @private
- * @name set
- * @memberOf MapCache
- * @param {string} key The key of the value to set.
- * @param {*} value The value to set.
- * @returns {Object} Returns the map cache instance.
- */
-function mapCacheSet(key, value) {
- var data = getMapData(this, key),
- size = data.size;
+ decodedCodes.push(code); // Checksum
- data.set(key, value);
- this.size += data.size == size ? 0 : 1;
- return this;
-}
+ if (!this._checksum(result)) {
+ return null;
+ }
-module.exports = mapCacheSet;
+ if (this.supplements.length > 0) {
+ var supplement = this._decodeExtensions(code.end);
+ if (!supplement) {
+ return null;
+ }
-/***/ }),
-/* 143 */
-/***/ (function(module, exports, __webpack_require__) {
+ var lastCode = supplement.decodedCodes[supplement.decodedCodes.length - 1];
+ var endInfo = {
+ start: lastCode.start + ((lastCode.end - lastCode.start) / 2 | 0),
+ end: lastCode.end
+ };
-var memoize = __webpack_require__(161);
+ if (!this._verifyTrailingWhitespace(endInfo)) {
+ return null;
+ }
-/** Used as the maximum memoize cache size. */
-var MAX_MEMOIZE_SIZE = 500;
+ resultInfo = {
+ supplement: supplement,
+ code: result.join('') + supplement.code
+ };
+ }
-/**
- * A specialized version of `_.memoize` which clears the memoized function's
- * cache when it exceeds `MAX_MEMOIZE_SIZE`.
- *
- * @private
- * @param {Function} func The function to have its output memoized.
- * @returns {Function} Returns the new memoized function.
- */
-function memoizeCapped(func) {
- var result = memoize(func, function(key) {
- if (cache.size === MAX_MEMOIZE_SIZE) {
- cache.clear();
+ return _objectSpread({
+ code: result.join(''),
+ start: startInfo.start,
+ end: code.end,
+ startInfo: startInfo,
+ decodedCodes: decodedCodes
+ }, resultInfo);
}
- return key;
- });
+ }, {
+ key: "_decodeExtensions",
+ value: function _decodeExtensions(offset) {
+ var start = this._nextSet(this._row, offset);
- var cache = result.cache;
- return result;
-}
+ var startInfo = this._findPattern(EXTENSION_START_PATTERN, start, 0, false);
-module.exports = memoizeCapped;
+ if (startInfo === null) {
+ return null;
+ }
+ for (var i = 0; i < this.supplements.length; i++) {
+ var result = this.supplements[i].decode(this._row, startInfo.end);
-/***/ }),
-/* 144 */
-/***/ (function(module, exports) {
+ if (result !== null) {
+ return {
+ code: result.code,
+ start: start,
+ startInfo: startInfo,
+ end: result.end,
+ decodedCodes: result.decodedCodes
+ };
+ }
+ }
-/**
- * This function is like
- * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
- * except that it includes inherited enumerable properties.
- *
- * @private
- * @param {Object} object The object to query.
- * @returns {Array} Returns the array of property names.
- */
-function nativeKeysIn(object) {
- var result = [];
- if (object != null) {
- for (var key in Object(object)) {
- result.push(key);
+ return null;
}
- }
- return result;
-}
-
-module.exports = nativeKeysIn;
-
-
-/***/ }),
-/* 145 */
-/***/ (function(module, exports, __webpack_require__) {
+ }, {
+ key: "_checksum",
+ value: function _checksum(result) {
+ var sum = 0;
-/* WEBPACK VAR INJECTION */(function(module) {var freeGlobal = __webpack_require__(38);
+ for (var i = result.length - 2; i >= 0; i -= 2) {
+ sum += result[i];
+ }
-/** Detect free variable `exports`. */
-var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+ sum *= 3;
-/** Detect free variable `module`. */
-var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+ for (var _i2 = result.length - 1; _i2 >= 0; _i2 -= 2) {
+ sum += result[_i2];
+ }
-/** Detect the popular CommonJS extension `module.exports`. */
-var moduleExports = freeModule && freeModule.exports === freeExports;
+ return sum % 10 === 0;
+ }
+ }]);
-/** Detect free variable `process` from Node.js. */
-var freeProcess = moduleExports && freeGlobal.process;
+ return EANReader;
+}(_barcode_reader__WEBPACK_IMPORTED_MODULE_7__["BarcodeReader"]);
-/** Used to access faster Node.js helpers. */
-var nodeUtil = (function() {
- try {
- return freeProcess && freeProcess.binding && freeProcess.binding('util');
- } catch (e) {}
-}());
+/***/ }),
-module.exports = nodeUtil;
+/***/ "./src/reader/i2of5-reader.ts":
+/*!************************************!*\
+ !*** ./src/reader/i2of5-reader.ts ***!
+ \************************************/
+/*! exports provided: I2of5Reader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)(module)))
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "I2of5Reader", function() { return I2of5Reader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/assertThisInitialized */ "../../node_modules/@babel/runtime/helpers/assertThisInitialized.js");
+/* harmony import */ var _babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/get */ "../../node_modules/@babel/runtime/helpers/get.js");
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../../node_modules/@babel/runtime/helpers/defineProperty.js");
+/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7__);
+/* harmony import */ var _common_merge__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../common/merge */ "./src/common/merge.ts");
+/* harmony import */ var _barcode_reader__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./barcode-reader */ "./src/reader/barcode-reader.ts");
-/***/ }),
-/* 146 */
-/***/ (function(module, exports) {
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
-/**
- * Used to resolve the
- * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
- * of values.
- */
-var nativeObjectToString = objectProto.toString;
-/**
- * Converts `value` to a string using `Object.prototype.toString`.
- *
- * @private
- * @param {*} value The value to convert.
- * @returns {string} Returns the converted string.
- */
-function objectToString(value) {
- return nativeObjectToString.call(value);
-}
-module.exports = objectToString;
-/***/ }),
-/* 147 */
-/***/ (function(module, exports) {
-/**
- * Creates a unary function that invokes `func` with its argument transformed.
- *
- * @private
- * @param {Function} func The function to wrap.
- * @param {Function} transform The argument transform.
- * @returns {Function} Returns the new function.
- */
-function overArg(func, transform) {
- return function(arg) {
- return func(transform(arg));
- };
-}
-module.exports = overArg;
+var N = 1;
+var W = 3;
+var START_PATTERN = [N, N, N, N];
+var STOP_PATTERN = [N, N, W];
+var CODE_PATTERN = [[N, N, W, W, N], [W, N, N, N, W], [N, W, N, N, W], [W, W, N, N, N], [N, N, W, N, W], [W, N, W, N, N], [N, W, W, N, N], [N, N, N, W, W], [W, N, N, W, N], [N, W, N, W, N]];
+var MAX_CORRECTION_FACTOR = 5;
+var I2of5Reader =
+/*#__PURE__*/
+function (_BarcodeReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_6___default()(I2of5Reader, _BarcodeReader);
-/***/ }),
-/* 148 */
-/***/ (function(module, exports) {
+ function I2of5Reader(config) {
+ var _this;
-/** Used to detect hot functions by number of calls within a span of milliseconds. */
-var HOT_COUNT = 800,
- HOT_SPAN = 16;
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, I2of5Reader);
-/* Built-in method references for those with the same name as other `lodash` methods. */
-var nativeNow = Date.now;
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default()(I2of5Reader).call(this, Object(_common_merge__WEBPACK_IMPORTED_MODULE_8__["merge"])({
+ normalizeBarSpaceWidth: false // Normalize the width difference between bars and spaces
-/**
- * Creates a function that'll short out and invoke `identity` instead
- * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
- * milliseconds.
- *
- * @private
- * @param {Function} func The function to restrict.
- * @returns {Function} Returns the new shortable function.
- */
-function shortOut(func) {
- var count = 0,
- lastCalled = 0;
+ }, config)));
- return function() {
- var stamp = nativeNow(),
- remaining = HOT_SPAN - (stamp - lastCalled);
+ _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_7___default()(_babel_runtime_helpers_assertThisInitialized__WEBPACK_IMPORTED_MODULE_3___default()(_this), "_barSpaceRatio", void 0);
- lastCalled = stamp;
- if (remaining > 0) {
- if (++count >= HOT_COUNT) {
- return arguments[0];
- }
+ _this._barSpaceRatio = [1, 1];
+ _this._format = 'i2of5';
+
+ if (_this.config.normalizeBarSpaceWidth) {
+ _this._singleCodeError = 0.38;
+ _this._averageCodeError = 0.09;
} else {
- count = 0;
+ _this._singleCodeError = 0.78;
+ _this._averageCodeError = 0.38;
}
- return func.apply(undefined, arguments);
- };
-}
-module.exports = shortOut;
+ return _this;
+ }
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(I2of5Reader, [{
+ key: "decode",
+ value: function decode() {
+ var startInfo = this._findStart();
-/***/ }),
-/* 149 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (!startInfo) {
+ return null;
+ }
-var ListCache = __webpack_require__(10);
+ var endInfo = this._findEnd();
-/**
- * Removes all key-value entries from the stack.
- *
- * @private
- * @name clear
- * @memberOf Stack
- */
-function stackClear() {
- this.__data__ = new ListCache;
- this.size = 0;
-}
+ if (!endInfo) {
+ return null;
+ }
-module.exports = stackClear;
+ var counters = this._fillCounters(startInfo.end, endInfo.start, 0);
+ if (counters.length % 10 !== 0) {
+ return null;
+ }
-/***/ }),
-/* 150 */
-/***/ (function(module, exports) {
+ var result = new Array();
+ var decodedCodes = new Array();
+ decodedCodes.push(startInfo);
-/**
- * Removes `key` and its value from the stack.
- *
- * @private
- * @name delete
- * @memberOf Stack
- * @param {string} key The key of the value to remove.
- * @returns {boolean} Returns `true` if the entry was removed, else `false`.
- */
-function stackDelete(key) {
- var data = this.__data__,
- result = data['delete'](key);
+ var code = this._decodePayload(counters, result, decodedCodes);
- this.size = data.size;
- return result;
-}
+ if (!code || result.length % 2 !== 0 || result.length < 6) {
+ return null;
+ }
-module.exports = stackDelete;
+ decodedCodes.push(endInfo);
+ return {
+ code: result.join(''),
+ start: startInfo.start,
+ end: endInfo.end,
+ startInfo: startInfo,
+ decodedCodes: decodedCodes
+ };
+ }
+ }, {
+ key: "_matchPattern",
+ value: function _matchPattern(counter, code) {
+ if (this.config.normalizeBarSpaceWidth) {
+ var counterSum = [0, 0];
+ var codeSum = [0, 0];
+ var correction = [0, 0];
+ var correctionRatio = MAX_CORRECTION_FACTOR;
+ var correctionRatioInverse = 1 / correctionRatio;
+ for (var i = 0; i < counter.length; i++) {
+ counterSum[i % 2] += counter[i];
+ codeSum[i % 2] += code[i];
+ }
-/***/ }),
-/* 151 */
-/***/ (function(module, exports) {
+ correction[0] = codeSum[0] / counterSum[0];
+ correction[1] = codeSum[1] / counterSum[1];
+ correction[0] = Math.max(Math.min(correction[0], correctionRatio), correctionRatioInverse);
+ correction[1] = Math.max(Math.min(correction[1], correctionRatio), correctionRatioInverse);
+ this._barSpaceRatio = correction;
-/**
- * Gets the stack value for `key`.
- *
- * @private
- * @name get
- * @memberOf Stack
- * @param {string} key The key of the value to get.
- * @returns {*} Returns the entry value.
- */
-function stackGet(key) {
- return this.__data__.get(key);
-}
+ for (var _i = 0; _i < counter.length; _i++) {
+ counter[_i] *= this._barSpaceRatio[_i % 2];
+ }
+ }
-module.exports = stackGet;
+ return _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_5___default()(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_4___default()(I2of5Reader.prototype), "_matchPattern", this).call(this, counter, code);
+ }
+ }, {
+ key: "_findStart",
+ value: function _findStart() {
+ var offset = this._nextSet(this._row);
+ var startInfo;
-/***/ }),
-/* 152 */
-/***/ (function(module, exports) {
+ while (!startInfo) {
+ startInfo = this._findPattern(START_PATTERN, offset, 0, true);
-/**
- * Checks if a stack value for `key` exists.
- *
- * @private
- * @name has
- * @memberOf Stack
- * @param {string} key The key of the entry to check.
- * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
- */
-function stackHas(key) {
- return this.__data__.has(key);
-}
+ if (!startInfo) {
+ return null;
+ }
-module.exports = stackHas;
+ var narrowBarWidth = startInfo.end - startInfo.start >> 2;
+ var leadingWhitespaceStart = startInfo.start - narrowBarWidth * 10;
+ if (leadingWhitespaceStart >= 0) {
+ if (this._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {
+ return startInfo;
+ }
+ }
-/***/ }),
-/* 153 */
-/***/ (function(module, exports, __webpack_require__) {
+ offset = startInfo.end;
+ startInfo = null;
+ }
-var ListCache = __webpack_require__(10),
- Map = __webpack_require__(33),
- MapCache = __webpack_require__(34);
+ return null;
+ }
+ }, {
+ key: "_verifyTrailingWhitespace",
+ value: function _verifyTrailingWhitespace(endInfo) {
+ var trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
-/** Used as the size to enable large array optimizations. */
-var LARGE_ARRAY_SIZE = 200;
+ if (trailingWhitespaceEnd < this._row.length) {
+ if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
+ return endInfo;
+ }
+ }
-/**
- * Sets the stack `key` to `value`.
- *
- * @private
- * @name set
- * @memberOf Stack
- * @param {string} key The key of the value to set.
- * @param {*} value The value to set.
- * @returns {Object} Returns the stack cache instance.
- */
-function stackSet(key, value) {
- var data = this.__data__;
- if (data instanceof ListCache) {
- var pairs = data.__data__;
- if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
- pairs.push([key, value]);
- this.size = ++data.size;
- return this;
+ return null;
}
- data = this.__data__ = new MapCache(pairs);
- }
- data.set(key, value);
- this.size = data.size;
- return this;
-}
+ }, {
+ key: "_findEnd",
+ value: function _findEnd() {
+ this._row.reverse();
-module.exports = stackSet;
+ var endInfo = this._findPattern(STOP_PATTERN, undefined, 0, false);
+ this._row.reverse();
-/***/ }),
-/* 154 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (endInfo === null) {
+ return null;
+ } // reverse numbers
-var memoizeCapped = __webpack_require__(143);
-/** Used to match property names within property paths. */
-var reLeadingDot = /^\./,
- rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+ var start = endInfo.start;
+ endInfo.start = this._row.length - endInfo.end;
+ endInfo.end = this._row.length - start;
+ return endInfo !== null ? this._verifyTrailingWhitespace(endInfo) : null;
+ }
+ }, {
+ key: "_decodeCode",
+ value: function _decodeCode(counter) {
+ var bestMatch = {
+ error: Number.MAX_VALUE,
+ code: -1,
+ start: 0,
+ end: 0
+ };
-/** Used to match backslashes in property paths. */
-var reEscapeChar = /\\(\\)?/g;
+ for (var code = 0; code < CODE_PATTERN.length; code++) {
+ var error = this._matchPattern(counter, CODE_PATTERN[code]);
-/**
- * Converts `string` to a property path array.
- *
- * @private
- * @param {string} string The string to convert.
- * @returns {Array} Returns the property path array.
- */
-var stringToPath = memoizeCapped(function(string) {
- var result = [];
- if (reLeadingDot.test(string)) {
- result.push('');
- }
- string.replace(rePropName, function(match, number, quote, string) {
- result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
- });
- return result;
-});
+ if (error < bestMatch.error) {
+ bestMatch.code = code;
+ bestMatch.error = error;
+ }
+ }
+
+ return bestMatch.error < this.AVERAGE_CODE_ERROR ? bestMatch : null;
+ }
+ }, {
+ key: "_decodePayload",
+ value: function _decodePayload(counters, result, decodedCodes) {
+ var counterLength = counters.length;
+ var counter0 = [0, 0, 0, 0, 0];
+ var counter1 = [0, 0, 0, 0, 0];
+ var code0;
+ var code1;
+ var pos = 0;
-module.exports = stringToPath;
+ while (pos < counterLength) {
+ for (var i = 0; i < 5; i++) {
+ counter0[i] = counters[pos] * this._barSpaceRatio[0];
+ counter1[i] = counters[pos + 1] * this._barSpaceRatio[1];
+ pos += 2;
+ }
+ code0 = this._decodeCode(counter0);
-/***/ }),
-/* 155 */
-/***/ (function(module, exports) {
+ if (!code0) {
+ return null;
+ }
-/** Used for built-in method references. */
-var funcProto = Function.prototype;
+ code1 = this._decodeCode(counter1);
-/** Used to resolve the decompiled source of functions. */
-var funcToString = funcProto.toString;
+ if (!code1) {
+ return null;
+ }
-/**
- * Converts `func` to its source code.
- *
- * @private
- * @param {Function} func The function to convert.
- * @returns {string} Returns the source code.
- */
-function toSource(func) {
- if (func != null) {
- try {
- return funcToString.call(func);
- } catch (e) {}
- try {
- return (func + '');
- } catch (e) {}
- }
- return '';
-}
+ result.push(code0.code, code1.code);
+ decodedCodes.push(code0, code1);
+ }
-module.exports = toSource;
+ return [code0, code1];
+ }
+ }]);
+ return I2of5Reader;
+}(_barcode_reader__WEBPACK_IMPORTED_MODULE_9__["BarcodeReader"]);
/***/ }),
-/* 156 */
-/***/ (function(module, exports) {
-/**
- * Creates a function that returns `value`.
- *
- * @static
- * @memberOf _
- * @since 2.4.0
- * @category Util
- * @param {*} value The value to return from the new function.
- * @returns {Function} Returns the new constant function.
- * @example
- *
- * var objects = _.times(2, _.constant({ 'a': 1 }));
- *
- * console.log(objects);
- * // => [{ 'a': 1 }, { 'a': 1 }]
- *
- * console.log(objects[0] === objects[1]);
- * // => true
- */
-function constant(value) {
- return function() {
- return value;
- };
-}
+/***/ "./src/reader/index.ts":
+/*!*****************************!*\
+ !*** ./src/reader/index.ts ***!
+ \*****************************/
+/*! exports provided: Readers */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-module.exports = constant;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Readers", function() { return Readers; });
+/* harmony import */ var _code_128_reader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./code-128-reader */ "./src/reader/code-128-reader.ts");
+/* harmony import */ var _code_39_reader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./code-39-reader */ "./src/reader/code-39-reader.ts");
+/* harmony import */ var _code_39_vin_reader__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./code-39-vin-reader */ "./src/reader/code-39-vin-reader.ts");
+/* harmony import */ var _codabar_reader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./codabar-reader */ "./src/reader/codabar-reader.ts");
+/* harmony import */ var _ean_reader__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./ean-reader */ "./src/reader/ean-reader.ts");
+/* harmony import */ var _ean_8_reader__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./ean-8-reader */ "./src/reader/ean-8-reader.ts");
+/* harmony import */ var _ean_2_reader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./ean-2-reader */ "./src/reader/ean-2-reader.ts");
+/* harmony import */ var _ean_5_reader__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./ean-5-reader */ "./src/reader/ean-5-reader.ts");
+/* harmony import */ var _upc_reader__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./upc-reader */ "./src/reader/upc-reader.ts");
+/* harmony import */ var _upc_e_reader__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./upc-e-reader */ "./src/reader/upc-e-reader.ts");
+/* harmony import */ var _i2of5_reader__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./i2of5-reader */ "./src/reader/i2of5-reader.ts");
+/* harmony import */ var _2of5_reader__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./2of5-reader */ "./src/reader/2of5-reader.ts");
+/* harmony import */ var _code_93_reader__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./code-93-reader */ "./src/reader/code-93-reader.ts");
-/***/ }),
-/* 157 */
-/***/ (function(module, exports, __webpack_require__) {
-var baseFlatten = __webpack_require__(92);
-/**
- * Flattens `array` a single level deep.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Array
- * @param {Array} array The array to flatten.
- * @returns {Array} Returns the new flattened array.
- * @example
- *
- * _.flatten([1, [2, [3, [4]], 5]]);
- * // => [1, 2, [3, [4]], 5]
- */
-function flatten(array) {
- var length = array == null ? 0 : array.length;
- return length ? baseFlatten(array, 1) : [];
-}
-module.exports = flatten;
-/***/ }),
-/* 158 */
-/***/ (function(module, exports, __webpack_require__) {
-var baseHasIn = __webpack_require__(95),
- hasPath = __webpack_require__(121);
-/**
- * Checks if `path` is a direct or inherited property of `object`.
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Object
- * @param {Object} object The object to query.
- * @param {Array|string} path The path to check.
- * @returns {boolean} Returns `true` if `path` exists, else `false`.
- * @example
- *
- * var object = _.create({ 'a': _.create({ 'b': 2 }) });
- *
- * _.hasIn(object, 'a');
- * // => true
- *
- * _.hasIn(object, 'a.b');
- * // => true
- *
- * _.hasIn(object, ['a', 'b']);
- * // => true
- *
- * _.hasIn(object, 'b');
- * // => false
- */
-function hasIn(object, path) {
- return object != null && hasPath(object, path, baseHasIn);
-}
-module.exports = hasIn;
+
+var Readers = {
+ code_128_reader: _code_128_reader__WEBPACK_IMPORTED_MODULE_0__["Code128Reader"],
+ ean_reader: _ean_reader__WEBPACK_IMPORTED_MODULE_4__["EANReader"],
+ ean_5_reader: _ean_5_reader__WEBPACK_IMPORTED_MODULE_7__["EAN5Reader"],
+ ean_2_reader: _ean_2_reader__WEBPACK_IMPORTED_MODULE_6__["EAN2Reader"],
+ ean_8_reader: _ean_8_reader__WEBPACK_IMPORTED_MODULE_5__["EAN8Reader"],
+ code_39_reader: _code_39_reader__WEBPACK_IMPORTED_MODULE_1__["Code39Reader"],
+ code_39_vin_reader: _code_39_vin_reader__WEBPACK_IMPORTED_MODULE_2__["Code39VINReader"],
+ codabar_reader: _codabar_reader__WEBPACK_IMPORTED_MODULE_3__["CodabarReader"],
+ upc_reader: _upc_reader__WEBPACK_IMPORTED_MODULE_8__["UPCReader"],
+ upc_e_reader: _upc_e_reader__WEBPACK_IMPORTED_MODULE_9__["UPCEReader"],
+ i2of5_reader: _i2of5_reader__WEBPACK_IMPORTED_MODULE_10__["I2of5Reader"],
+ '2of5_reader': _2of5_reader__WEBPACK_IMPORTED_MODULE_11__["TwoOfFiveReader"],
+ code_93_reader: _code_93_reader__WEBPACK_IMPORTED_MODULE_12__["Code93Reader"]
+};
+
/***/ }),
-/* 159 */
-/***/ (function(module, exports, __webpack_require__) {
-var isArrayLike = __webpack_require__(24),
- isObjectLike = __webpack_require__(6);
+/***/ "./src/reader/upc-e-reader.ts":
+/*!************************************!*\
+ !*** ./src/reader/upc-e-reader.ts ***!
+ \************************************/
+/*! exports provided: UPCEReader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-/**
- * This method is like `_.isArrayLike` except that it also checks if `value`
- * is an object.
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an array-like object,
- * else `false`.
- * @example
- *
- * _.isArrayLikeObject([1, 2, 3]);
- * // => true
- *
- * _.isArrayLikeObject(document.body.children);
- * // => true
- *
- * _.isArrayLikeObject('abc');
- * // => false
- *
- * _.isArrayLikeObject(_.noop);
- * // => false
- */
-function isArrayLikeObject(value) {
- return isObjectLike(value) && isArrayLike(value);
-}
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "UPCEReader", function() { return UPCEReader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/get */ "../../node_modules/@babel/runtime/helpers/get.js");
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _ean_reader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./ean-reader */ "./src/reader/ean-reader.ts");
-module.exports = isArrayLikeObject;
-/***/ }),
-/* 160 */
-/***/ (function(module, exports, __webpack_require__) {
-var baseGetTag = __webpack_require__(8),
- getPrototype = __webpack_require__(39),
- isObjectLike = __webpack_require__(6);
-/** `Object#toString` result references. */
-var objectTag = '[object Object]';
-/** Used for built-in method references. */
-var funcProto = Function.prototype,
- objectProto = Object.prototype;
-/** Used to resolve the decompiled source of functions. */
-var funcToString = funcProto.toString;
+var CODE_FREQUENCY = [[56, 52, 50, 49, 44, 38, 35, 42, 41, 37], [7, 11, 13, 14, 19, 25, 28, 21, 22, 26]];
+var UPCEReader =
+/*#__PURE__*/
+function (_EANReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default()(UPCEReader, _EANReader);
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4___default()(UPCEReader, [{
+ key: "STOP_PATTERN",
+ get: function get() {
+ return [1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7];
+ }
+ }]);
-/** Used to infer the `Object` constructor. */
-var objectCtorString = funcToString.call(Object);
+ function UPCEReader(config, supplements) {
+ var _this;
-/**
- * Checks if `value` is a plain object, that is, an object created by the
- * `Object` constructor or one with a `[[Prototype]]` of `null`.
- *
- * @static
- * @memberOf _
- * @since 0.8.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
- * @example
- *
- * function Foo() {
- * this.a = 1;
- * }
- *
- * _.isPlainObject(new Foo);
- * // => false
- *
- * _.isPlainObject([1, 2, 3]);
- * // => false
- *
- * _.isPlainObject({ 'x': 0, 'y': 0 });
- * // => true
- *
- * _.isPlainObject(Object.create(null));
- * // => true
- */
-function isPlainObject(value) {
- if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
- return false;
- }
- var proto = getPrototype(value);
- if (proto === null) {
- return true;
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, UPCEReader);
+
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_1___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2___default()(UPCEReader).call(this, config, supplements));
+ _this._format = 'upc_e';
+ return _this;
}
- var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
- return typeof Ctor == 'function' && Ctor instanceof Ctor &&
- funcToString.call(Ctor) == objectCtorString;
-}
-module.exports = isPlainObject;
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_4___default()(UPCEReader, [{
+ key: "_decodePayload",
+ value: function _decodePayload(code, result, decodedCodes) {
+ var codeFrequency = 0x0;
+ for (var i = 0; i < 6; i++) {
+ code = this._decodeCode(code.end);
-/***/ }),
-/* 161 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (!code) {
+ return null;
+ }
-var MapCache = __webpack_require__(34);
+ if (code.code >= this.CODE_G_START) {
+ code.code = code.code - this.CODE_G_START;
+ codeFrequency |= 1 << 5 - i;
+ }
-/** Error message constants. */
-var FUNC_ERROR_TEXT = 'Expected a function';
+ result.push(code.code);
+ decodedCodes.push(code);
+ }
-/**
- * Creates a function that memoizes the result of `func`. If `resolver` is
- * provided, it determines the cache key for storing the result based on the
- * arguments provided to the memoized function. By default, the first argument
- * provided to the memoized function is used as the map cache key. The `func`
- * is invoked with the `this` binding of the memoized function.
- *
- * **Note:** The cache is exposed as the `cache` property on the memoized
- * function. Its creation may be customized by replacing the `_.memoize.Cache`
- * constructor with one whose instances implement the
- * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
- * method interface of `clear`, `delete`, `get`, `has`, and `set`.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Function
- * @param {Function} func The function to have its output memoized.
- * @param {Function} [resolver] The function to resolve the cache key.
- * @returns {Function} Returns the new memoized function.
- * @example
- *
- * var object = { 'a': 1, 'b': 2 };
- * var other = { 'c': 3, 'd': 4 };
- *
- * var values = _.memoize(_.values);
- * values(object);
- * // => [1, 2]
- *
- * values(other);
- * // => [3, 4]
- *
- * object.a = 2;
- * values(object);
- * // => [1, 2]
- *
- * // Modify the result cache.
- * values.cache.set(object, ['a', 'b']);
- * values(object);
- * // => ['a', 'b']
- *
- * // Replace `_.memoize.Cache`.
- * _.memoize.Cache = WeakMap;
- */
-function memoize(func, resolver) {
- if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
- throw new TypeError(FUNC_ERROR_TEXT);
- }
- var memoized = function() {
- var args = arguments,
- key = resolver ? resolver.apply(this, args) : args[0],
- cache = memoized.cache;
+ if (!this._determineParity(codeFrequency, result)) {
+ return null;
+ }
- if (cache.has(key)) {
- return cache.get(key);
+ return code;
}
- var result = func.apply(this, args);
- memoized.cache = cache.set(key, result) || cache;
- return result;
- };
- memoized.cache = new (memoize.Cache || MapCache);
- return memoized;
-}
-
-// Expose `MapCache`.
-memoize.Cache = MapCache;
-
-module.exports = memoize;
+ }, {
+ key: "_determineParity",
+ value: function _determineParity(codeFrequency, result) {
+ for (var nrSystem = 0; nrSystem < CODE_FREQUENCY.length; nrSystem++) {
+ for (var i = 0; i < CODE_FREQUENCY[nrSystem].length; i++) {
+ if (codeFrequency === CODE_FREQUENCY[nrSystem][i]) {
+ result.unshift(nrSystem);
+ result.push(i);
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ }, {
+ key: "_convertToUPCA",
+ value: function _convertToUPCA(result) {
+ var lastDigit = result[result.length - 2];
+ var upca = [result[0]];
-/***/ }),
-/* 162 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (lastDigit <= 2) {
+ upca = upca.concat(result.slice(1, 3)).concat([lastDigit, 0, 0, 0, 0]).concat(result.slice(3, 6));
+ } else if (lastDigit === 3) {
+ upca = upca.concat(result.slice(1, 4)).concat([0, 0, 0, 0, 0]).concat(result.slice(4, 6));
+ } else if (lastDigit === 4) {
+ upca = upca.concat(result.slice(1, 5)).concat([0, 0, 0, 0, 0, result[5]]);
+ } else {
+ upca = upca.concat(result.slice(1, 6)).concat([0, 0, 0, 0, lastDigit]);
+ }
-var basePick = __webpack_require__(102),
- flatRest = __webpack_require__(118);
+ upca.push(result[result.length - 1]);
+ return upca;
+ }
+ }, {
+ key: "_checksum",
+ value: function _checksum(result) {
+ return _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_3___default()(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2___default()(UPCEReader.prototype), "_checksum", this).call(this, this._convertToUPCA(result));
+ }
+ }, {
+ key: "_findEnd",
+ value: function _findEnd(offset, isWhite) {
+ isWhite = 1;
+ return _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_3___default()(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_2___default()(UPCEReader.prototype), "_findEnd", this).call(this, offset, isWhite);
+ }
+ }, {
+ key: "_verifyTrailingWhitespace",
+ value: function _verifyTrailingWhitespace(endInfo) {
+ var trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;
-/**
- * Creates an object composed of the picked `object` properties.
- *
- * @static
- * @since 0.1.0
- * @memberOf _
- * @category Object
- * @param {Object} object The source object.
- * @param {...(string|string[])} [paths] The property paths to pick.
- * @returns {Object} Returns the new object.
- * @example
- *
- * var object = { 'a': 1, 'b': '2', 'c': 3 };
- *
- * _.pick(object, ['a', 'c']);
- * // => { 'a': 1, 'c': 3 }
- */
-var pick = flatRest(function(object, paths) {
- return object == null ? {} : basePick(object, paths);
-});
+ if (trailingWhitespaceEnd < this._row.length) {
+ if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {
+ return endInfo;
+ }
+ }
-module.exports = pick;
+ return null;
+ }
+ }]);
+ return UPCEReader;
+}(_ean_reader__WEBPACK_IMPORTED_MODULE_6__["EANReader"]);
/***/ }),
-/* 163 */
-/***/ (function(module, exports) {
-/**
- * This method returns `false`.
- *
- * @static
- * @memberOf _
- * @since 4.13.0
- * @category Util
- * @returns {boolean} Returns `false`.
- * @example
- *
- * _.times(2, _.stubFalse);
- * // => [false, false]
- */
-function stubFalse() {
- return false;
-}
+/***/ "./src/reader/upc-reader.ts":
+/*!**********************************!*\
+ !*** ./src/reader/upc-reader.ts ***!
+ \**********************************/
+/*! exports provided: UPCReader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-module.exports = stubFalse;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "UPCReader", function() { return UPCReader; });
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+/* harmony import */ var _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/createClass */ "../../node_modules/@babel/runtime/helpers/createClass.js");
+/* harmony import */ var _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+/* harmony import */ var _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+/* harmony import */ var _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/get */ "../../node_modules/@babel/runtime/helpers/get.js");
+/* harmony import */ var _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/inherits */ "../../node_modules/@babel/runtime/helpers/inherits.js");
+/* harmony import */ var _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _ean_reader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./ean-reader */ "./src/reader/ean-reader.ts");
-/***/ }),
-/* 164 */
-/***/ (function(module, exports, __webpack_require__) {
-var copyObject = __webpack_require__(114),
- keysIn = __webpack_require__(46);
-/**
- * Converts `value` to a plain object flattening inherited enumerable string
- * keyed properties of `value` to own properties of the plain object.
- *
- * @static
- * @memberOf _
- * @since 3.0.0
- * @category Lang
- * @param {*} value The value to convert.
- * @returns {Object} Returns the converted plain object.
- * @example
- *
- * function Foo() {
- * this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * _.assign({ 'a': 1 }, new Foo);
- * // => { 'a': 1, 'b': 2 }
- *
- * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
- * // => { 'a': 1, 'b': 2, 'c': 3 }
- */
-function toPlainObject(value) {
- return copyObject(value, keysIn(value));
-}
-module.exports = toPlainObject;
-/***/ }),
-/* 165 */
-/***/ (function(module, exports, __webpack_require__) {
+var UPCReader =
+/*#__PURE__*/
+function (_EANReader) {
+ _babel_runtime_helpers_inherits__WEBPACK_IMPORTED_MODULE_5___default()(UPCReader, _EANReader);
-var baseToString = __webpack_require__(108);
+ function UPCReader(config, supplements) {
+ var _this;
-/**
- * Converts `value` to a string. An empty string is returned for `null`
- * and `undefined` values. The sign of `-0` is preserved.
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to convert.
- * @returns {string} Returns the converted string.
- * @example
- *
- * _.toString(null);
- * // => ''
- *
- * _.toString(-0);
- * // => '-0'
- *
- * _.toString([1, 2, 3]);
- * // => '1,2,3'
- */
-function toString(value) {
- return value == null ? '' : baseToString(value);
-}
+ _babel_runtime_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_0___default()(this, UPCReader);
-module.exports = toString;
+ _this = _babel_runtime_helpers_possibleConstructorReturn__WEBPACK_IMPORTED_MODULE_2___default()(this, _babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(UPCReader).call(this, config, supplements));
+ _this._format = 'upc_a';
+ return _this;
+ }
+ _babel_runtime_helpers_createClass__WEBPACK_IMPORTED_MODULE_1___default()(UPCReader, [{
+ key: "decode",
+ value: function decode() {
+ var result = _babel_runtime_helpers_get__WEBPACK_IMPORTED_MODULE_4___default()(_babel_runtime_helpers_getPrototypeOf__WEBPACK_IMPORTED_MODULE_3___default()(UPCReader.prototype), "decode", this).call(this);
-/***/ }),
-/* 166 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (result && result.code && result.code.length === 13 && result.code.charAt(0) === '0') {
+ result.code = result.code.substring(1);
+ return result;
+ }
-module.exports = __webpack_require__(48);
+ return null;
+ }
+ }]);
+ return UPCReader;
+}(_ean_reader__WEBPACK_IMPORTED_MODULE_6__["EANReader"]);
/***/ })
-/******/ ])
+
+/******/ })
});
;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/myModuleDefinition","webpack:///webpack/bootstrap 7560cc4927231b2e3789","webpack:///./~/lodash/isObject.js","webpack:///./src/reader/barcode_reader.js","webpack:///./~/lodash/isArray.js","webpack:///./src/common/array_helper.js","webpack:///./src/reader/ean_reader.js","webpack:///./~/lodash/_root.js","webpack:///./~/lodash/isObjectLike.js","webpack:///./~/gl-vec2/clone.js","webpack:///./~/lodash/_baseGetTag.js","webpack:///./src/common/image_debug.js","webpack:///./~/lodash/_ListCache.js","webpack:///./~/lodash/_Symbol.js","webpack:///./~/lodash/_assocIndexOf.js","webpack:///./~/lodash/_castPath.js","webpack:///./~/lodash/_getMapData.js","webpack:///./~/lodash/_isIndex.js","webpack:///./~/lodash/_nativeCreate.js","webpack:///./~/lodash/eq.js","webpack:///./~/lodash/isArguments.js","webpack:///./src/common/cv_utils.js","webpack:///./src/common/image_wrapper.js","webpack:///./~/lodash/_baseAssignValue.js","webpack:///./~/lodash/_getNative.js","webpack:///./~/lodash/_toKey.js","webpack:///./~/lodash/isArrayLike.js","webpack:///./~/lodash/isFunction.js","webpack:///./~/lodash/isLength.js","webpack:///./~/lodash/isSymbol.js","webpack:///./~/lodash/merge.js","webpack:///(webpack)/buildin/module.js","webpack:///./src/locator/tracer.js","webpack:///./src/reader/code_39_reader.js","webpack:///./~/gl-vec2/dot.js","webpack:///./~/lodash/_Map.js","webpack:///./~/lodash/_MapCache.js","webpack:///./~/lodash/_assignMergeValue.js","webpack:///./~/lodash/_assignValue.js","webpack:///./~/lodash/_defineProperty.js","webpack:///./~/lodash/_freeGlobal.js","webpack:///./~/lodash/_getPrototype.js","webpack:///./~/lodash/_isPrototype.js","webpack:///./~/lodash/_overRest.js","webpack:///./~/lodash/_setToString.js","webpack:///./~/lodash/identity.js","webpack:///./~/lodash/isBuffer.js","webpack:///./~/lodash/isTypedArray.js","webpack:///./~/lodash/keysIn.js","webpack:///(webpack)/buildin/global.js","webpack:///./src/quagga.js","webpack:///./src/analytics/result_collector.js","webpack:///./src/common/cluster.js","webpack:///./src/common/events.js","webpack:///./src/common/mediaDevices.js","webpack:///./src/common/subImage.js","webpack:///./src/common/typedefs.js","webpack:///./src/config/config.dev.js","webpack:///./src/config/config.js","webpack:///./src/decoder/barcode_decoder.js","webpack:///./src/decoder/bresenham.js","webpack:///./src/input/camera_access.js","webpack:///./src/input/exif_helper.js","webpack:///./src/input/frame_grabber.js","webpack:///./src/input/image_loader.js","webpack:///./src/input/input_stream.js","webpack:///./src/locator/barcode_locator.js","webpack:///./src/locator/rasterizer.js","webpack:///./src/locator/skeletonizer.js","webpack:///./src/reader/2of5_reader.js","webpack:///./src/reader/codabar_reader.js","webpack:///./src/reader/code_128_reader.js","webpack:///./src/reader/code_39_vin_reader.js","webpack:///./src/reader/code_93_reader.js","webpack:///./src/reader/ean_2_reader.js","webpack:///./src/reader/ean_5_reader.js","webpack:///./src/reader/ean_8_reader.js","webpack:///./src/reader/i2of5_reader.js","webpack:///./src/reader/upc_e_reader.js","webpack:///./src/reader/upc_reader.js","webpack:///./~/gl-mat2/copy.js","webpack:///./~/gl-mat2/create.js","webpack:///./~/gl-mat2/invert.js","webpack:///./~/gl-vec2/scale.js","webpack:///./~/gl-vec2/transformMat2.js","webpack:///./~/gl-vec3/clone.js","webpack:///./~/lodash/_Hash.js","webpack:///./~/lodash/_Stack.js","webpack:///./~/lodash/_Uint8Array.js","webpack:///./~/lodash/_apply.js","webpack:///./~/lodash/_arrayLikeKeys.js","webpack:///./~/lodash/_arrayMap.js","webpack:///./~/lodash/_arrayPush.js","webpack:///./~/lodash/_baseCreate.js","webpack:///./~/lodash/_baseFlatten.js","webpack:///./~/lodash/_baseFor.js","webpack:///./~/lodash/_baseGet.js","webpack:///./~/lodash/_baseHasIn.js","webpack:///./~/lodash/_baseIsArguments.js","webpack:///./~/lodash/_baseIsNative.js","webpack:///./~/lodash/_baseIsTypedArray.js","webpack:///./~/lodash/_baseKeysIn.js","webpack:///./~/lodash/_baseMerge.js","webpack:///./~/lodash/_baseMergeDeep.js","webpack:///./~/lodash/_basePick.js","webpack:///./~/lodash/_basePickBy.js","webpack:///./~/lodash/_baseRest.js","webpack:///./~/lodash/_baseSet.js","webpack:///./~/lodash/_baseSetToString.js","webpack:///./~/lodash/_baseTimes.js","webpack:///./~/lodash/_baseToString.js","webpack:///./~/lodash/_baseUnary.js","webpack:///./~/lodash/_cloneArrayBuffer.js","webpack:///./~/lodash/_cloneBuffer.js","webpack:///./~/lodash/_cloneTypedArray.js","webpack:///./~/lodash/_copyArray.js","webpack:///./~/lodash/_copyObject.js","webpack:///./~/lodash/_coreJsData.js","webpack:///./~/lodash/_createAssigner.js","webpack:///./~/lodash/_createBaseFor.js","webpack:///./~/lodash/_flatRest.js","webpack:///./~/lodash/_getRawTag.js","webpack:///./~/lodash/_getValue.js","webpack:///./~/lodash/_hasPath.js","webpack:///./~/lodash/_hashClear.js","webpack:///./~/lodash/_hashDelete.js","webpack:///./~/lodash/_hashGet.js","webpack:///./~/lodash/_hashHas.js","webpack:///./~/lodash/_hashSet.js","webpack:///./~/lodash/_initCloneObject.js","webpack:///./~/lodash/_isFlattenable.js","webpack:///./~/lodash/_isIterateeCall.js","webpack:///./~/lodash/_isKey.js","webpack:///./~/lodash/_isKeyable.js","webpack:///./~/lodash/_isMasked.js","webpack:///./~/lodash/_listCacheClear.js","webpack:///./~/lodash/_listCacheDelete.js","webpack:///./~/lodash/_listCacheGet.js","webpack:///./~/lodash/_listCacheHas.js","webpack:///./~/lodash/_listCacheSet.js","webpack:///./~/lodash/_mapCacheClear.js","webpack:///./~/lodash/_mapCacheDelete.js","webpack:///./~/lodash/_mapCacheGet.js","webpack:///./~/lodash/_mapCacheHas.js","webpack:///./~/lodash/_mapCacheSet.js","webpack:///./~/lodash/_memoizeCapped.js","webpack:///./~/lodash/_nativeKeysIn.js","webpack:///./~/lodash/_nodeUtil.js","webpack:///./~/lodash/_objectToString.js","webpack:///./~/lodash/_overArg.js","webpack:///./~/lodash/_shortOut.js","webpack:///./~/lodash/_stackClear.js","webpack:///./~/lodash/_stackDelete.js","webpack:///./~/lodash/_stackGet.js","webpack:///./~/lodash/_stackHas.js","webpack:///./~/lodash/_stackSet.js","webpack:///./~/lodash/_stringToPath.js","webpack:///./~/lodash/_toSource.js","webpack:///./~/lodash/constant.js","webpack:///./~/lodash/flatten.js","webpack:///./~/lodash/hasIn.js","webpack:///./~/lodash/isArrayLikeObject.js","webpack:///./~/lodash/isPlainObject.js","webpack:///./~/lodash/memoize.js","webpack:///./~/lodash/pick.js","webpack:///./~/lodash/stubFalse.js","webpack:///./~/lodash/toPlainObject.js","webpack:///./~/lodash/toString.js"],"names":["BarcodeReader","config","supplements","_row","prototype","_nextUnset","line","start","i","undefined","length","_matchPattern","counter","code","maxSingleError","error","singleError","sum","modulo","barWidth","count","scaled","SINGLE_CODE_ERROR","Number","MAX_VALUE","Math","abs","_nextSet","offset","_correctBars","correction","indices","tmp","_matchTrace","cmpCounter","epsilon","self","isWhite","counterPos","bestMatch","push","end","decodePattern","pattern","result","_decode","reverse","direction","DIRECTION","REVERSE","FORWARD","format","FORMAT","_matchRange","value","_fillCounters","counters","_toCounters","numCounters","ArrayHelper","init","Object","defineProperty","writeable","Exception","StartNotFoundException","CodeNotFoundException","PatternNotFoundException","CONFIG_KEYS","arr","val","l","shuffle","j","x","floor","random","toPointList","row","rows","join","threshold","scoreFunc","queue","apply","maxIndex","max","EANReader","opts","getDefaulConfig","call","keys","forEach","key","default","properties","CODE_L_START","CODE_G_START","START_PATTERN","STOP_PATTERN","MIDDLE_PATTERN","EXTENSION_START_PATTERN","CODE_PATTERN","CODE_FREQUENCY","AVG_CODE_ERROR","create","constructor","_decodeCode","coderange","_findPattern","tryHarder","_findStart","leadingWhitespaceStart","startInfo","_verifyTrailingWhitespace","endInfo","trailingWhitespaceEnd","_findEnd","_calculateFirstDigit","codeFrequency","_decodePayload","decodedCodes","firstDigit","unshift","resultInfo","_checksum","ext","_decodeExtensions","lastCode","supplement","codeset","decode","drawRect","pos","size","ctx","style","strokeStyle","color","fillStyle","lineWidth","beginPath","strokeRect","y","drawPath","path","def","moveTo","lineTo","closePath","stroke","drawImage","imageData","canvasData","getImageData","data","imageDataPos","canvasDataPos","putImageData","vec2","clone","require","vec3","imageRef","that","toVec2","toVec3","round","computeIntegralImage2","imageWrapper","integralWrapper","width","height","integralImageData","posA","posB","posC","posD","computeIntegralImage","v","u","thresholdImage","targetWrapper","targetData","computeHistogram","bitsPerPixel","bitShift","bucketCnt","hist","Int32Array","sharpenLine","left","center","right","determineOtsuThreshold","px","mx","determineThreshold","vet","p1","p2","p12","k","m1","m2","m12","otsuThreshold","computeBinaryImage","kernel","A","B","C","D","avg","cluster","points","property","point","clusters","addToCluster","newPoint","found","fits","add","Cluster2","createPoint","Tracer","trace","vec","iteration","maxIterations","top","centerPos","currentPos","idx","forward","from","to","toIdx","predictedPos","thresholdX","thresholdY","match","predicted","DILATE","ERODE","dilate","inImageWrapper","outImageWrapper","inImageData","outImageData","yStart1","yStart2","xStart1","xStart2","erode","subtract","aImageWrapper","bImageWrapper","resultImageWrapper","aImageData","bImageData","cImageData","bitwiseOr","countNonZero","topGeneric","list","minIdx","min","score","hit","item","grayArrayFromImage","htmlImage","offsetX","array","ctxData","computeGray","grayArrayFromContext","grayAndHalfSampleFromCanvasData","outArray","topRowIdx","bottomRowIdx","endIdx","outWidth","outImgIdx","inWidth","singleChannel","loadImageArray","src","callback","canvas","document","createElement","img","Image","onload","getContext","Uint8Array","halfSample","inImgWrapper","outImgWrapper","inImg","outImg","hsv2rgb","hsv","rgb","h","s","c","m","r","g","b","_computeDivisors","n","largeDivisors","divisors","sqrt","concat","_computeIntersection","arr1","arr2","calculatePatchSize","patchSize","imgSize","divisorsX","divisorsY","wideSide","common","nrOfPatchesList","nrOfPatchesMap","nrOfPatchesIdx","medium","nrOfPatches","desiredPatchSize","optimalPatchSize","findPatchSizeForDivisors","_parseCSSDimensionValues","dimension","parseFloat","unit","indexOf","_dimensionsConverters","context","bottom","computeImageArea","inputWidth","inputHeight","area","parsedArea","reduce","parsed","calculated","sx","sy","sw","sh","ImageWrapper","ArrayType","initialize","Array","inImageWithBorder","imgRef","border","sample","lx","ly","w","base","a","d","e","clearArray","subImage","subImageAsCopy","sizeY","sizeX","copyTo","srcData","dstData","get","getSafe","indexMapping","set","zeroBorder","invert","convolve","kx","ky","kSize","accu","moments","labelcount","ysq","labelsum","label","mu11","mu02","mu20","x_","y_","PI","PI_4","m00","m01","m10","m11","m02","m20","theta","rad","isNaN","atan","cos","sin","show","scale","frame","current","pixel","overlay","whiteRgb","blackRgb","searchDirections","labelWrapper","labelData","edgelabel","cy","dir","cx","vertex2D","next","prev","contourTracing","Fv","Cv","P","ldir","Code39Reader","ALPHABETH_STRING","ALPHABET","CHARACTER_ENCODINGS","ASTERISK","decodedChar","lastStart","nextStart","_toPattern","_patternToChar","pop","patternSize","String","fromCharCode","_findNextWidth","minWidth","maxNarrowWidth","numWideBars","wideBarWidth","patternStart","whiteSpaceMustStart","_inputStream","_framegrabber","_stopped","_canvasContainer","image","dom","_inputImageWrapper","_boxSize","_decoder","_workerPool","_onUIThread","_resultCollector","_config","initializeData","initBuffers","BarcodeDecoder","decoder","initInputStream","cb","video","inputStream","type","InputStream","createVideoStream","createImageStream","$viewport","getViewPort","querySelector","appendChild","createLiveStream","CameraAccess","request","constraints","then","trigger","catch","err","setAttribute","setInputStream","addEventListener","canRecord","bind","target","nodeName","nodeType","selector","BarcodeLocator","checkImageConstraints","locator","initCanvas","FrameGrabber","adjustWorkerPool","numOfWorkers","ready","play","className","getCanvasSize","clearFix","getWidth","getHeight","console","log","getBoundingBoxes","locate","transformResult","topRight","getTopRight","xOffset","yOffset","barcodes","moveLine","box","moveBox","boxes","corner","addResult","filter","barcode","codeResult","hasCodeResult","some","publishResult","resultToPublish","Events","publish","locateAndDecode","decodeFromBoundingBoxes","update","availableWorker","workerThread","busy","attachData","grab","worker","postMessage","cmd","buffer","startContinuousUpdate","delay","frequency","timestamp","window","requestAnimFrame","performance","now","initWorker","blobURL","generateWorkerBlob","Worker","onmessage","event","URL","revokeObjectURL","message","configForWorker","workerInterface","factory","Quagga","onProcessed","setReaders","readers","blob","factorySource","__factorySource__","Blob","toString","createObjectURL","capacity","increaseBy","workersToTerminate","slice","terminate","workerInitialized","stop","release","clearEventHandlers","pause","onDetected","subscribe","offDetected","unsubscribe","offProcessed","registerResultCollector","resultCollector","decodeSingle","resultCallback","sequence","debug","once","ImageDebug","ResultCollector","contains","every","passesFilter","results","capture","matchesConstraints","blacklist","imageSize","toDataURL","getResults","dot","pointMap","updateCenter","pointToAdd","id","otherPoint","similarity","getPoints","getCenter","events","getEvent","eventName","subscribers","clearEvents","publishSubscription","subscription","async","setTimeout","subscriber","enumerateDevices","navigator","mediaDevices","Promise","reject","Error","getUserMedia","SubImage","I","originalSize","updateData","updateFrom","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","msRequestAnimationFrame","imul","ah","al","bh","bl","assign","TypeError","index","arguments","nextSource","nextKey","hasOwnProperty","module","exports","name","facingMode","drawBoundingBox","showFrequency","drawScanline","showPattern","showCanvas","showPatches","showFoundPatches","showSkeleton","showLabels","showPatchLabels","showRemainingPatchLabels","boxFromPatches","showTransformed","showTransformedBox","showBB","ENV","node","READERS","code_128_reader","ean_reader","ean_5_reader","ean_2_reader","ean_8_reader","code_39_reader","code_39_vin_reader","codabar_reader","upc_reader","upc_e_reader","i2of5_reader","code_93_reader","Code93Reader","inputImageWrapper","_canvas","_barcodeReaders","initReaders","initConfig","$debug","readerConfig","reader","configuration","map","JSON","stringify","vis","prop","display","getExtendedLine","angle","extendLine","amount","extension","ceil","getLine","tryDecode","barcodeLine","Bresenham","getBarcodeLine","printFrequency","toBinaryLine","printPattern","tryDecodeBruteForce","lineAngle","sideLength","pow","slices","xdir","ydir","getLineLength","decodeFromBoundingBox","lineLength","atan2","multiple","Slope","DIR","UP","DOWN","x0","y0","x1","y1","steep","deltax","deltay","ystep","read","slope","slope2","extrema","currentDir","rThreshold","fillColor","fillRect","facingMatching","streamRef","waitForVideo","resolve","attempts","checkVideo","videoWidth","videoHeight","initCamera","stream","srcObject","deprecatedConstraints","videoConstraints","normalized","minAspectRatio","aspectRatio","facing","pickConstraints","normalizedConstraints","audio","deviceId","enumerateVideoDevices","devices","device","kind","getActiveTrack","tracks","getVideoTracks","getActiveStreamLabel","track","ExifTags","AvailableTags","findTagsInObjectURL","tags","test","objectURLToBlob","readToBuffer","findTagsInBuffer","base64ToArrayBuffer","dataUrl","base64","replace","binary","atob","len","ArrayBuffer","view","charCodeAt","fileReader","FileReader","readAsArrayBuffer","url","http","XMLHttpRequest","open","responseType","onreadystatechange","readyState","DONE","status","response","onerror","send","file","selectedTags","dataView","DataView","byteLength","exifTags","selectedTag","exifTag","tag","marker","getUint8","readEXIFData","getUint16","getStringFromBuffer","tiffOffset","bigEnd","firstIFDOffset","getUint32","readTags","tiffStart","dirStart","strings","entries","entryOffset","readTagValue","numValues","outstr","TO_RADIANS","adjustCanvasSize","targetSize","_that","_streamConfig","getConfig","_video_size","getRealWidth","getRealHeight","_canvasSize","_size","_sx","_sy","_ctx","_data","videoSize","canvasSize","getData","doHalfSample","getFrame","drawable","drawAngle","orientation","translate","rotate","getSize","ImageLoader","load","directory","htmlImagesSrcArray","htmlImagesArray","num","notLoaded","addImage","loaded","loadedImg","notloadedImgs","splice","imgName","substr","lastIndexOf","addOnloadHandler","_eventNames","_eventHandlers","_calculatedWidth","_calculatedHeight","_topRight","initSize","setWidth","setHeight","ended","setCurrentTime","time","currentTime","f","bool","handlers","handler","removeEventListener","args","setTopRight","setCanvasSize","frameIdx","paused","imgArray","baseUrl","calculatedWidth","calculatedHeight","loadImages","imgs","publishEvent","newWidth","newHeight","transformMat2","mat2","copy","_currentImageWrapper","_skelImageWrapper","_subImageWrapper","_labelImageWrapper","_patchGrid","_patchLabelGrid","_imageToPatchGrid","_binaryImageWrapper","_patchSize","_numPatches","_skeletonizer","skeletonImageData","skeletonizer","global","useWorker","patches","overAvg","patch","transMat","minx","miny","maxx","maxy","binarizeImage","findPatches","patchesFound","rasterizer","rasterResult","skeletonize","Rasterizer","rasterize","describePatch","findBiggestConnectedAreas","maxLabel","labelHist","topLabels","sort","el","findBoxes","similarMoments","topCluster","patchPos","eligibleMoments","matchingMoments","minComponentWeight","rasterizeAngularSimilarity","currIdx","notYetProcessed","currentIdx","currentPatch","createContour2D","firstVertex","insideContours","nextpeer","prevpeer","CONTOUR_DIR","CW_DIR","CCW_DIR","UNKNOWN_DIR","OUTSIDE_EDGE","INSIDE_EDGE","tracer","depthlabel","bc","lc","labelindex","colorMap","vertex","p","cc","sc","connectedCount","drawContour","firstContour","pq","iq","q","Skeletonizer","stdlib","foreign","images","inImagePtr","outImagePtr","aImagePtr","bImagePtr","imagePtr","memcpy","srcImagePtr","dstImagePtr","subImagePtr","erodedImagePtr","tempImagePtr","skelImagePtr","done","TwoOfFiveReader","barSpaceRatio","N","W","writable","startPatternLength","narrowBarWidth","counterLength","_verifyCounterLength","CodabarReader","_counters","START_END","MIN_ENCODED_CHARS","MAX_ACCEPTABLE","PADDING","startCounter","_isStartEnd","_verifyWhitespace","_validateResult","_sumCounters","endCounter","_calculatePatternLength","_thresholdResultPattern","categorization","space","narrow","counts","wide","bar","cat","_charToPattern","newkind","char","charCode","thresholds","_computeAlternatingThreshold","barThreshold","spaceThreshold","bitmask","Code128Reader","CODE_SHIFT","CODE_C","CODE_B","CODE_A","START_CODE_A","START_CODE_B","START_CODE_C","STOP_CODE","MODULE_INDICES","_correct","calculateCorrection","multiplier","checksum","rawResult","shiftNext","removeLastCharacter","expected","sumNormalized","sumExpected","Code39VINReader","patterns","IOQ","AZ09","_checkChecksum","split","_verifyEnd","_verifyChecksums","_decodeExtended","charArray","nextChar","nextCharCode","_matchCheckChar","maxWeight","arrayToCheck","weightedSums","weight","checkChar","EAN2Reader","parseInt","EAN5Reader","CHECK_DIGIT_ENCODINGS","extensionChecksum","determineCheckDigit","EAN8Reader","I2of5Reader","normalizeBarSpaceWidth","MAX_CORRECTION_FACTOR","counterSum","codeSum","correctionRatio","correctionRatioInverse","_decodePair","counterPair","codes","UPCEReader","_determineParity","nrSystem","_convertToUPCA","upca","lastDigit","UPCReader","charAt","substring"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;ACRA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA,mDAA2C,cAAc;;AAEzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;AAEA;AACA;;;;;;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;AC9BA;;AAEA,SAASA,aAAT,CAAuBC,MAAvB,EAA+BC,WAA/B,EAA4C;AACxC,SAAKC,IAAL,GAAY,EAAZ;AACA,SAAKF,MAAL,GAAcA,UAAU,EAAxB;AACA,SAAKC,WAAL,GAAmBA,WAAnB;AACA,WAAO,IAAP;AACH;;AAEDF,cAAcI,SAAd,CAAwBC,UAAxB,GAAqC,UAASC,IAAT,EAAeC,KAAf,EAAsB;AACvD,QAAIC,CAAJ;;AAEA,QAAID,UAAUE,SAAd,EAAyB;AACrBF,gBAAQ,CAAR;AACH;AACD,SAAKC,IAAID,KAAT,EAAgBC,IAAIF,KAAKI,MAAzB,EAAiCF,GAAjC,EAAsC;AAClC,YAAI,CAACF,KAAKE,CAAL,CAAL,EAAc;AACV,mBAAOA,CAAP;AACH;AACJ;AACD,WAAOF,KAAKI,MAAZ;AACH,CAZD;;AAcAV,cAAcI,SAAd,CAAwBO,aAAxB,GAAwC,UAASC,OAAT,EAAkBC,IAAlB,EAAwBC,cAAxB,EAAwC;AAC5E,QAAIN,CAAJ;AAAA,QACIO,QAAQ,CADZ;AAAA,QAEIC,cAAc,CAFlB;AAAA,QAGIC,MAAM,CAHV;AAAA,QAIIC,SAAS,CAJb;AAAA,QAKIC,QALJ;AAAA,QAMIC,KANJ;AAAA,QAOIC,MAPJ;;AASAP,qBAAiBA,kBAAkB,KAAKQ,iBAAvB,IAA4C,CAA7D;;AAEA,SAAKd,IAAI,CAAT,EAAYA,IAAII,QAAQF,MAAxB,EAAgCF,GAAhC,EAAqC;AACjCS,eAAOL,QAAQJ,CAAR,CAAP;AACAU,kBAAUL,KAAKL,CAAL,CAAV;AACH;AACD,QAAIS,MAAMC,MAAV,EAAkB;AACd,eAAOK,OAAOC,SAAd;AACH;AACDL,eAAWF,MAAMC,MAAjB;AACAJ,sBAAkBK,QAAlB;;AAEA,SAAKX,IAAI,CAAT,EAAYA,IAAII,QAAQF,MAAxB,EAAgCF,GAAhC,EAAqC;AACjCY,gBAAQR,QAAQJ,CAAR,CAAR;AACAa,iBAASR,KAAKL,CAAL,IAAUW,QAAnB;AACAH,sBAAcS,KAAKC,GAAL,CAASN,QAAQC,MAAjB,IAA2BA,MAAzC;AACA,YAAIL,cAAcF,cAAlB,EAAkC;AAC9B,mBAAOS,OAAOC,SAAd;AACH;AACDT,iBAASC,WAAT;AACH;AACD,WAAOD,QAAQG,MAAf;AACH,CAhCD;;AAkCAlB,cAAcI,SAAd,CAAwBuB,QAAxB,GAAmC,UAASrB,IAAT,EAAesB,MAAf,EAAuB;AACtD,QAAIpB,CAAJ;;AAEAoB,aAASA,UAAU,CAAnB;AACA,SAAKpB,IAAIoB,MAAT,EAAiBpB,IAAIF,KAAKI,MAA1B,EAAkCF,GAAlC,EAAuC;AACnC,YAAIF,KAAKE,CAAL,CAAJ,EAAa;AACT,mBAAOA,CAAP;AACH;AACJ;AACD,WAAOF,KAAKI,MAAZ;AACH,CAVD;;AAYAV,cAAcI,SAAd,CAAwByB,YAAxB,GAAuC,UAASjB,OAAT,EAAkBkB,UAAlB,EAA8BC,OAA9B,EAAuC;AAC1E,QAAIrB,SAASqB,QAAQrB,MAArB;AAAA,QACIsB,MAAM,CADV;AAEA,WAAMtB,QAAN,EAAgB;AACZsB,cAAMpB,QAAQmB,QAAQrB,MAAR,CAAR,KAA4B,IAAK,CAAC,IAAIoB,UAAL,IAAmB,CAApD,CAAN;AACA,YAAIE,MAAM,CAAV,EAAa;AACTpB,oBAAQmB,QAAQrB,MAAR,CAAR,IAA2BsB,GAA3B;AACH;AACJ;AACJ,CATD;;AAWAhC,cAAcI,SAAd,CAAwB6B,WAAxB,GAAsC,UAASC,UAAT,EAAqBC,OAArB,EAA8B;AAChE,QAAIvB,UAAU,EAAd;AAAA,QACIJ,CADJ;AAAA,QAEI4B,OAAO,IAFX;AAAA,QAGIR,SAASQ,KAAKT,QAAL,CAAcS,KAAKjC,IAAnB,CAHb;AAAA,QAIIkC,UAAU,CAACD,KAAKjC,IAAL,CAAUyB,MAAV,CAJf;AAAA,QAKIU,aAAa,CALjB;AAAA,QAMIC,YAAY;AACRxB,eAAOQ,OAAOC,SADN;AAERX,cAAM,CAAC,CAFC;AAGRN,eAAO;AAHC,KANhB;AAAA,QAWIQ,KAXJ;;AAaA,QAAImB,UAAJ,EAAgB;AACZ,aAAM1B,IAAI,CAAV,EAAaA,IAAI0B,WAAWxB,MAA5B,EAAoCF,GAApC,EAAyC;AACrCI,oBAAQ4B,IAAR,CAAa,CAAb;AACH;AACD,aAAMhC,IAAIoB,MAAV,EAAkBpB,IAAI4B,KAAKjC,IAAL,CAAUO,MAAhC,EAAwCF,GAAxC,EAA6C;AACzC,gBAAI4B,KAAKjC,IAAL,CAAUK,CAAV,IAAe6B,OAAnB,EAA4B;AACxBzB,wBAAQ0B,UAAR;AACH,aAFD,MAEO;AACH,oBAAIA,eAAe1B,QAAQF,MAAR,GAAiB,CAApC,EAAuC;AACnCK,4BAAQqB,KAAKzB,aAAL,CAAmBC,OAAnB,EAA4BsB,UAA5B,CAAR;;AAEA,wBAAInB,QAAQoB,OAAZ,EAAqB;AACjBI,kCAAUhC,KAAV,GAAkBC,IAAIoB,MAAtB;AACAW,kCAAUE,GAAV,GAAgBjC,CAAhB;AACA+B,kCAAU3B,OAAV,GAAoBA,OAApB;AACA,+BAAO2B,SAAP;AACH,qBALD,MAKO;AACH,+BAAO,IAAP;AACH;AACJ,iBAXD,MAWO;AACHD;AACH;AACD1B,wBAAQ0B,UAAR,IAAsB,CAAtB;AACAD,0BAAU,CAACA,OAAX;AACH;AACJ;AACJ,KA1BD,MA0BO;AACHzB,gBAAQ4B,IAAR,CAAa,CAAb;AACA,aAAMhC,IAAIoB,MAAV,EAAkBpB,IAAI4B,KAAKjC,IAAL,CAAUO,MAAhC,EAAwCF,GAAxC,EAA6C;AACzC,gBAAI4B,KAAKjC,IAAL,CAAUK,CAAV,IAAe6B,OAAnB,EAA4B;AACxBzB,wBAAQ0B,UAAR;AACH,aAFD,MAEO;AACHA;AACA1B,wBAAQ4B,IAAR,CAAa,CAAb;AACA5B,wBAAQ0B,UAAR,IAAsB,CAAtB;AACAD,0BAAU,CAACA,OAAX;AACH;AACJ;AACJ;;AAED;AACAE,cAAUhC,KAAV,GAAkBqB,MAAlB;AACAW,cAAUE,GAAV,GAAgBL,KAAKjC,IAAL,CAAUO,MAAV,GAAmB,CAAnC;AACA6B,cAAU3B,OAAV,GAAoBA,OAApB;AACA,WAAO2B,SAAP;AACH,CA3DD;;AA6DAvC,cAAcI,SAAd,CAAwBsC,aAAxB,GAAwC,UAASC,OAAT,EAAkB;AACtD,QAAIP,OAAO,IAAX;AAAA,QACIQ,MADJ;;AAGAR,SAAKjC,IAAL,GAAYwC,OAAZ;AACAC,aAASR,KAAKS,OAAL,EAAT;AACA,QAAID,WAAW,IAAf,EAAqB;AACjBR,aAAKjC,IAAL,CAAU2C,OAAV;AACAF,iBAASR,KAAKS,OAAL,EAAT;AACA,YAAID,MAAJ,EAAY;AACRA,mBAAOG,SAAP,GAAmB/C,cAAcgD,SAAd,CAAwBC,OAA3C;AACAL,mBAAOrC,KAAP,GAAe6B,KAAKjC,IAAL,CAAUO,MAAV,GAAmBkC,OAAOrC,KAAzC;AACAqC,mBAAOH,GAAP,GAAaL,KAAKjC,IAAL,CAAUO,MAAV,GAAmBkC,OAAOH,GAAvC;AACH;AACJ,KARD,MAQO;AACHG,eAAOG,SAAP,GAAmB/C,cAAcgD,SAAd,CAAwBE,OAA3C;AACH;AACD,QAAIN,MAAJ,EAAY;AACRA,eAAOO,MAAP,GAAgBf,KAAKgB,MAArB;AACH;AACD,WAAOR,MAAP;AACH,CArBD;;AAuBA5C,cAAcI,SAAd,CAAwBiD,WAAxB,GAAsC,UAAS9C,KAAT,EAAgBkC,GAAhB,EAAqBa,KAArB,EAA4B;AAC9D,QAAI9C,CAAJ;;AAEAD,YAAQA,QAAQ,CAAR,GAAY,CAAZ,GAAgBA,KAAxB;AACA,SAAKC,IAAID,KAAT,EAAgBC,IAAIiC,GAApB,EAAyBjC,GAAzB,EAA8B;AAC1B,YAAI,KAAKL,IAAL,CAAUK,CAAV,MAAiB8C,KAArB,EAA4B;AACxB,mBAAO,KAAP;AACH;AACJ;AACD,WAAO,IAAP;AACH,CAVD;;AAYAtD,cAAcI,SAAd,CAAwBmD,aAAxB,GAAwC,UAAS3B,MAAT,EAAiBa,GAAjB,EAAsBJ,OAAtB,EAA+B;AACnE,QAAID,OAAO,IAAX;AAAA,QACIE,aAAa,CADjB;AAAA,QAEI9B,CAFJ;AAAA,QAGIgD,WAAW,EAHf;;AAKAnB,cAAW,OAAOA,OAAP,KAAmB,WAApB,GAAmCA,OAAnC,GAA6C,IAAvD;AACAT,aAAU,OAAOA,MAAP,KAAkB,WAAnB,GAAkCA,MAAlC,GAA2CQ,KAAK/B,UAAL,CAAgB+B,KAAKjC,IAArB,CAApD;AACAsC,UAAMA,OAAOL,KAAKjC,IAAL,CAAUO,MAAvB;;AAEA8C,aAASlB,UAAT,IAAuB,CAAvB;AACA,SAAK9B,IAAIoB,MAAT,EAAiBpB,IAAIiC,GAArB,EAA0BjC,GAA1B,EAA+B;AAC3B,YAAI4B,KAAKjC,IAAL,CAAUK,CAAV,IAAe6B,OAAnB,EAA4B;AACxBmB,qBAASlB,UAAT;AACH,SAFD,MAEO;AACHA;AACAkB,qBAASlB,UAAT,IAAuB,CAAvB;AACAD,sBAAU,CAACA,OAAX;AACH;AACJ;AACD,WAAOmB,QAAP;AACH,CArBD;;AAuBAxD,cAAcI,SAAd,CAAwBqD,WAAxB,GAAsC,UAASlD,KAAT,EAAgBK,OAAhB,EAAyB;AAC3D,QAAIwB,OAAO,IAAX;AAAA,QACIsB,cAAc9C,QAAQF,MAD1B;AAAA,QAEI+B,MAAML,KAAKjC,IAAL,CAAUO,MAFpB;AAAA,QAGI2B,UAAU,CAACD,KAAKjC,IAAL,CAAUI,KAAV,CAHf;AAAA,QAIIC,CAJJ;AAAA,QAKI8B,aAAa,CALjB;;AAOAqB,IAAA,qEAAAA,CAAYC,IAAZ,CAAiBhD,OAAjB,EAA0B,CAA1B;;AAEA,SAAMJ,IAAID,KAAV,EAAiBC,IAAIiC,GAArB,EAA0BjC,GAA1B,EAA+B;AAC3B,YAAI4B,KAAKjC,IAAL,CAAUK,CAAV,IAAe6B,OAAnB,EAA4B;AACxBzB,oBAAQ0B,UAAR;AACH,SAFD,MAEO;AACHA;AACA,gBAAIA,eAAeoB,WAAnB,EAAgC;AAC5B;AACH,aAFD,MAEO;AACH9C,wBAAQ0B,UAAR,IAAsB,CAAtB;AACAD,0BAAU,CAACA,OAAX;AACH;AACJ;AACJ;;AAED,WAAOzB,OAAP;AACH,CAzBD;;AA2BAiD,OAAOC,cAAP,CAAsB9D,cAAcI,SAApC,EAA+C,QAA/C,EAAyD;AACrDkD,WAAO,SAD8C;AAErDS,eAAW;AAF0C,CAAzD;;AAKA/D,cAAcgD,SAAd,GAA0B;AACtBE,aAAS,CADa;AAEtBD,aAAS,CAAC;AAFY,CAA1B;;AAKAjD,cAAcgE,SAAd,GAA0B;AACtBC,4BAAwB,2BADF;AAEtBC,2BAAuB,0BAFD;AAGtBC,8BAA0B;AAHJ,CAA1B;;AAMAnE,cAAcoE,WAAd,GAA4B,EAA5B;;AAEA,wDAAepE,aAAf,C;;;;;;ACpPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;ACzBA,wDAAe;AACX4D,UAAM,cAASS,GAAT,EAAcC,GAAd,EAAmB;AACrB,YAAIC,IAAIF,IAAI3D,MAAZ;AACA,eAAO6D,GAAP,EAAY;AACRF,gBAAIE,CAAJ,IAASD,GAAT;AACH;AACJ,KANU;;AAQX;;;;AAIAE,aAAS,iBAASH,GAAT,EAAc;AACnB,YAAI7D,IAAI6D,IAAI3D,MAAJ,GAAa,CAArB;AAAA,YAAwB+D,CAAxB;AAAA,YAA2BC,CAA3B;AACA,aAAKlE,CAAL,EAAQA,KAAK,CAAb,EAAgBA,GAAhB,EAAqB;AACjBiE,gBAAIhD,KAAKkD,KAAL,CAAWlD,KAAKmD,MAAL,KAAgBpE,CAA3B,CAAJ;AACAkE,gBAAIL,IAAI7D,CAAJ,CAAJ;AACA6D,gBAAI7D,CAAJ,IAAS6D,IAAII,CAAJ,CAAT;AACAJ,gBAAII,CAAJ,IAASC,CAAT;AACH;AACD,eAAOL,GAAP;AACH,KArBU;;AAuBXQ,iBAAa,qBAASR,GAAT,EAAc;AACvB,YAAI7D,CAAJ;AAAA,YAAOiE,CAAP;AAAA,YAAUK,MAAM,EAAhB;AAAA,YAAoBC,OAAO,EAA3B;AACA,aAAMvE,IAAI,CAAV,EAAaA,IAAI6D,IAAI3D,MAArB,EAA6BF,GAA7B,EAAkC;AAC9BsE,kBAAM,EAAN;AACA,iBAAML,IAAI,CAAV,EAAaA,IAAIJ,IAAI7D,CAAJ,EAAOE,MAAxB,EAAgC+D,GAAhC,EAAqC;AACjCK,oBAAIL,CAAJ,IAASJ,IAAI7D,CAAJ,EAAOiE,CAAP,CAAT;AACH;AACDM,iBAAKvE,CAAL,IAAU,MAAMsE,IAAIE,IAAJ,CAAS,GAAT,CAAN,GAAsB,GAAhC;AACH;AACD,eAAO,MAAMD,KAAKC,IAAL,CAAU,OAAV,CAAN,GAA2B,GAAlC;AACH,KAjCU;;AAmCX;;;;AAIAC,eAAW,mBAASZ,GAAT,EAAcY,UAAd,EAAyBC,SAAzB,EAAoC;AAC3C,YAAI1E,CAAJ;AAAA,YAAO2E,QAAQ,EAAf;AACA,aAAM3E,IAAI,CAAV,EAAaA,IAAI6D,IAAI3D,MAArB,EAA6BF,GAA7B,EAAkC;AAC9B,gBAAI0E,UAAUE,KAAV,CAAgBf,GAAhB,EAAqB,CAACA,IAAI7D,CAAJ,CAAD,CAArB,KAAkCyE,UAAtC,EAAiD;AAC7CE,sBAAM3C,IAAN,CAAW6B,IAAI7D,CAAJ,CAAX;AACH;AACJ;AACD,eAAO2E,KAAP;AACH,KA/CU;;AAiDXE,cAAU,kBAAShB,GAAT,EAAc;AACpB,YAAI7D,CAAJ;AAAA,YAAO8E,MAAM,CAAb;AACA,aAAM9E,IAAI,CAAV,EAAaA,IAAI6D,IAAI3D,MAArB,EAA6BF,GAA7B,EAAkC;AAC9B,gBAAI6D,IAAI7D,CAAJ,IAAS6D,IAAIiB,GAAJ,CAAb,EAAuB;AACnBA,sBAAM9E,CAAN;AACH;AACJ;AACD,eAAO8E,GAAP;AACH,KAzDU;;AA2DXA,SAAK,aAASjB,GAAT,EAAc;AACf,YAAI7D,CAAJ;AAAA,YAAO8E,MAAM,CAAb;AACA,aAAM9E,IAAI,CAAV,EAAaA,IAAI6D,IAAI3D,MAArB,EAA6BF,GAA7B,EAAkC;AAC9B,gBAAI6D,IAAI7D,CAAJ,IAAS8E,GAAb,EAAkB;AACdA,sBAAMjB,IAAI7D,CAAJ,CAAN;AACH;AACJ;AACD,eAAO8E,GAAP;AACH,KAnEU;;AAqEXrE,SAAK,aAASoD,GAAT,EAAc;AACf,YAAI3D,SAAS2D,IAAI3D,MAAjB;AAAA,YACIO,MAAM,CADV;;AAGA,eAAOP,QAAP,EAAiB;AACbO,mBAAOoD,IAAI3D,MAAJ,CAAP;AACH;AACD,eAAOO,GAAP;AACH;AA7EU,CAAf,C;;;;;;;;;;;;;;ACAA;;;AAGA,SAASsE,SAAT,CAAmBC,IAAnB,EAAyBtF,WAAzB,EAAsC;AAClCsF,WAAO,qDAAMC,iBAAN,EAAyBD,IAAzB,CAAP;AACAxF,IAAA,gEAAAA,CAAc0F,IAAd,CAAmB,IAAnB,EAAyBF,IAAzB,EAA+BtF,WAA/B;AACH;;AAED,SAASuF,eAAT,GAA2B;AACvB,QAAIxF,SAAS,EAAb;;AAEA4D,WAAO8B,IAAP,CAAYJ,UAAUnB,WAAtB,EAAmCwB,OAAnC,CAA2C,UAASC,GAAT,EAAc;AACrD5F,eAAO4F,GAAP,IAAcN,UAAUnB,WAAV,CAAsByB,GAAtB,EAA2BC,OAAzC;AACH,KAFD;AAGA,WAAO7F,MAAP;AACH;;AAED,IAAI8F,aAAa;AACbC,kBAAc,EAAC1C,OAAO,CAAR,EADD;AAEb2C,kBAAc,EAAC3C,OAAO,EAAR,EAFD;AAGb4C,mBAAe,EAAC5C,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAR,EAHF;AAIb6C,kBAAc,EAAC7C,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAR,EAJD;AAKb8C,oBAAgB,EAAC9C,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,CAAR,EALH;AAMb+C,6BAAyB,EAAC/C,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAR,EANZ;AAObgD,kBAAc,EAAChD,OAAO,CAClB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CADkB,EAElB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAFkB,EAGlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAHkB,EAIlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAJkB,EAKlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CALkB,EAMlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CANkB,EAOlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAPkB,EAQlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CARkB,EASlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CATkB,EAUlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAVkB,EAWlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAXkB,EAYlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAZkB,EAalB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAbkB,EAclB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAdkB,EAelB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAfkB,EAgBlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAhBkB,EAiBlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAjBkB,EAkBlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAlBkB,EAmBlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAnBkB,EAoBlB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CApBkB,CAAR,EAPD;AA6BbiD,oBAAgB,EAACjD,OAAO,CAAC,CAAD,EAAI,EAAJ,EAAQ,EAAR,EAAY,EAAZ,EAAgB,EAAhB,EAAoB,EAApB,EAAwB,EAAxB,EAA4B,EAA5B,EAAgC,EAAhC,EAAoC,EAApC,CAAR,EA7BH;AA8BbhC,uBAAmB,EAACgC,OAAO,IAAR,EA9BN;AA+BbkD,oBAAgB,EAAClD,OAAO,IAAR,EA/BH;AAgCbF,YAAQ,EAACE,OAAO,QAAR,EAAkBS,WAAW,KAA7B;AAhCK,CAAjB;;AAmCAwB,UAAUnF,SAAV,GAAsByD,OAAO4C,MAAP,CAAc,gEAAAzG,CAAcI,SAA5B,EAAuC2F,UAAvC,CAAtB;AACAR,UAAUnF,SAAV,CAAoBsG,WAApB,GAAkCnB,SAAlC;;AAEAA,UAAUnF,SAAV,CAAoBuG,WAApB,GAAkC,UAASpG,KAAT,EAAgBqG,SAAhB,EAA2B;AACzD,QAAIhG,UAAU,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAAd;AAAA,QACIJ,CADJ;AAAA,QAEI4B,OAAO,IAFX;AAAA,QAGIR,SAASrB,KAHb;AAAA,QAII8B,UAAU,CAACD,KAAKjC,IAAL,CAAUyB,MAAV,CAJf;AAAA,QAKIU,aAAa,CALjB;AAAA,QAMIC,YAAY;AACRxB,eAAOQ,OAAOC,SADN;AAERX,cAAM,CAAC,CAFC;AAGRN,eAAOA,KAHC;AAIRkC,aAAKlC;AAJG,KANhB;AAAA,QAYIM,IAZJ;AAAA,QAaIE,KAbJ;;AAeA,QAAI,CAAC6F,SAAL,EAAgB;AACZA,oBAAYxE,KAAKkE,YAAL,CAAkB5F,MAA9B;AACH;;AAED,SAAMF,IAAIoB,MAAV,EAAkBpB,IAAI4B,KAAKjC,IAAL,CAAUO,MAAhC,EAAwCF,GAAxC,EAA6C;AACzC,YAAI4B,KAAKjC,IAAL,CAAUK,CAAV,IAAe6B,OAAnB,EAA4B;AACxBzB,oBAAQ0B,UAAR;AACH,SAFD,MAEO;AACH,gBAAIA,eAAe1B,QAAQF,MAAR,GAAiB,CAApC,EAAuC;AACnC,qBAAKG,OAAO,CAAZ,EAAeA,OAAO+F,SAAtB,EAAiC/F,MAAjC,EAAyC;AACrCE,4BAAQqB,KAAKzB,aAAL,CAAmBC,OAAnB,EAA4BwB,KAAKkE,YAAL,CAAkBzF,IAAlB,CAA5B,CAAR;AACA,wBAAIE,QAAQwB,UAAUxB,KAAtB,EAA6B;AACzBwB,kCAAU1B,IAAV,GAAiBA,IAAjB;AACA0B,kCAAUxB,KAAV,GAAkBA,KAAlB;AACH;AACJ;AACDwB,0BAAUE,GAAV,GAAgBjC,CAAhB;AACA,oBAAI+B,UAAUxB,KAAV,GAAkBqB,KAAKoE,cAA3B,EAA2C;AACvC,2BAAO,IAAP;AACH;AACD,uBAAOjE,SAAP;AACH,aAbD,MAaO;AACHD;AACH;AACD1B,oBAAQ0B,UAAR,IAAsB,CAAtB;AACAD,sBAAU,CAACA,OAAX;AACH;AACJ;AACD,WAAO,IAAP;AACH,CA7CD;;AA+CAkD,UAAUnF,SAAV,CAAoByG,YAApB,GAAmC,UAASlE,OAAT,EAAkBf,MAAlB,EAA0BS,OAA1B,EAAmCyE,SAAnC,EAA8C3E,OAA9C,EAAuD;AACtF,QAAIvB,UAAU,EAAd;AAAA,QACIwB,OAAO,IADX;AAAA,QAEI5B,CAFJ;AAAA,QAGI8B,aAAa,CAHjB;AAAA,QAIIC,YAAY;AACRxB,eAAOQ,OAAOC,SADN;AAERX,cAAM,CAAC,CAFC;AAGRN,eAAO,CAHC;AAIRkC,aAAK;AAJG,KAJhB;AAAA,QAUI1B,KAVJ;AAAA,QAWI0D,CAXJ;AAAA,QAYIxD,GAZJ;;AAcA,QAAI,CAACW,MAAL,EAAa;AACTA,iBAASQ,KAAKT,QAAL,CAAcS,KAAKjC,IAAnB,CAAT;AACH;;AAED,QAAIkC,YAAY5B,SAAhB,EAA2B;AACvB4B,kBAAU,KAAV;AACH;;AAED,QAAIyE,cAAcrG,SAAlB,EAA6B;AACzBqG,oBAAY,IAAZ;AACH;;AAED,QAAK3E,YAAY1B,SAAjB,EAA4B;AACxB0B,kBAAUC,KAAKoE,cAAf;AACH;;AAED,SAAMhG,IAAI,CAAV,EAAaA,IAAImC,QAAQjC,MAAzB,EAAiCF,GAAjC,EAAsC;AAClCI,gBAAQJ,CAAR,IAAa,CAAb;AACH;;AAED,SAAMA,IAAIoB,MAAV,EAAkBpB,IAAI4B,KAAKjC,IAAL,CAAUO,MAAhC,EAAwCF,GAAxC,EAA6C;AACzC,YAAI4B,KAAKjC,IAAL,CAAUK,CAAV,IAAe6B,OAAnB,EAA4B;AACxBzB,oBAAQ0B,UAAR;AACH,SAFD,MAEO;AACH,gBAAIA,eAAe1B,QAAQF,MAAR,GAAiB,CAApC,EAAuC;AACnCO,sBAAM,CAAN;AACA,qBAAMwD,IAAI,CAAV,EAAaA,IAAI7D,QAAQF,MAAzB,EAAiC+D,GAAjC,EAAsC;AAClCxD,2BAAOL,QAAQ6D,CAAR,CAAP;AACH;AACD1D,wBAAQqB,KAAKzB,aAAL,CAAmBC,OAAnB,EAA4B+B,OAA5B,CAAR;;AAEA,oBAAI5B,QAAQoB,OAAZ,EAAqB;AACjBI,8BAAUxB,KAAV,GAAkBA,KAAlB;AACAwB,8BAAUhC,KAAV,GAAkBC,IAAIS,GAAtB;AACAsB,8BAAUE,GAAV,GAAgBjC,CAAhB;AACA,2BAAO+B,SAAP;AACH;AACD,oBAAIuE,SAAJ,EAAe;AACX,yBAAMrC,IAAI,CAAV,EAAaA,IAAI7D,QAAQF,MAAR,GAAiB,CAAlC,EAAqC+D,GAArC,EAA0C;AACtC7D,gCAAQ6D,CAAR,IAAa7D,QAAQ6D,IAAI,CAAZ,CAAb;AACH;AACD7D,4BAAQA,QAAQF,MAAR,GAAiB,CAAzB,IAA8B,CAA9B;AACAE,4BAAQA,QAAQF,MAAR,GAAiB,CAAzB,IAA8B,CAA9B;AACA4B;AACH,iBAPD,MAOO;AACH,2BAAO,IAAP;AACH;AACJ,aAvBD,MAuBO;AACHA;AACH;AACD1B,oBAAQ0B,UAAR,IAAsB,CAAtB;AACAD,sBAAU,CAACA,OAAX;AACH;AACJ;AACD,WAAO,IAAP;AACH,CAtED;;AAwEAkD,UAAUnF,SAAV,CAAoB2G,UAApB,GAAiC,YAAW;AACxC,QAAI3E,OAAO,IAAX;AAAA,QACI4E,sBADJ;AAAA,QAEIpF,SAASQ,KAAKT,QAAL,CAAcS,KAAKjC,IAAnB,CAFb;AAAA,QAGI8G,SAHJ;;AAKA,WAAO,CAACA,SAAR,EAAmB;AACfA,oBAAY7E,KAAKyE,YAAL,CAAkBzE,KAAK8D,aAAvB,EAAsCtE,MAAtC,CAAZ;AACA,YAAI,CAACqF,SAAL,EAAgB;AACZ,mBAAO,IAAP;AACH;AACDD,iCAAyBC,UAAU1G,KAAV,IAAmB0G,UAAUxE,GAAV,GAAgBwE,UAAU1G,KAA7C,CAAzB;AACA,YAAIyG,0BAA0B,CAA9B,EAAiC;AAC7B,gBAAI5E,KAAKiB,WAAL,CAAiB2D,sBAAjB,EAAyCC,UAAU1G,KAAnD,EAA0D,CAA1D,CAAJ,EAAkE;AAC9D,uBAAO0G,SAAP;AACH;AACJ;AACDrF,iBAASqF,UAAUxE,GAAnB;AACAwE,oBAAY,IAAZ;AACH;AACJ,CApBD;;AAsBA1B,UAAUnF,SAAV,CAAoB8G,yBAApB,GAAgD,UAASC,OAAT,EAAkB;AAC9D,QAAI/E,OAAO,IAAX;AAAA,QACIgF,qBADJ;;AAGAA,4BAAwBD,QAAQ1E,GAAR,IAAe0E,QAAQ1E,GAAR,GAAc0E,QAAQ5G,KAArC,CAAxB;AACA,QAAI6G,wBAAwBhF,KAAKjC,IAAL,CAAUO,MAAtC,EAA8C;AAC1C,YAAI0B,KAAKiB,WAAL,CAAiB8D,QAAQ1E,GAAzB,EAA8B2E,qBAA9B,EAAqD,CAArD,CAAJ,EAA6D;AACzD,mBAAOD,OAAP;AACH;AACJ;AACD,WAAO,IAAP;AACH,CAXD;;AAaA5B,UAAUnF,SAAV,CAAoBiH,QAApB,GAA+B,UAASzF,MAAT,EAAiBS,OAAjB,EAA0B;AACrD,QAAID,OAAO,IAAX;AAAA,QACI+E,UAAU/E,KAAKyE,YAAL,CAAkBzE,KAAK+D,YAAvB,EAAqCvE,MAArC,EAA6CS,OAA7C,EAAsD,KAAtD,CADd;;AAGA,WAAO8E,YAAY,IAAZ,GAAmB/E,KAAK8E,yBAAL,CAA+BC,OAA/B,CAAnB,GAA6D,IAApE;AACH,CALD;;AAOA5B,UAAUnF,SAAV,CAAoBkH,oBAApB,GAA2C,UAASC,aAAT,EAAwB;AAC/D,QAAI/G,CAAJ;AAAA,QACI4B,OAAO,IADX;;AAGA,SAAM5B,IAAI,CAAV,EAAaA,IAAI4B,KAAKmE,cAAL,CAAoB7F,MAArC,EAA6CF,GAA7C,EAAkD;AAC9C,YAAI+G,kBAAkBnF,KAAKmE,cAAL,CAAoB/F,CAApB,CAAtB,EAA8C;AAC1C,mBAAOA,CAAP;AACH;AACJ;AACD,WAAO,IAAP;AACH,CAVD;;AAYA+E,UAAUnF,SAAV,CAAoBoH,cAApB,GAAqC,UAAS3G,IAAT,EAAe+B,MAAf,EAAuB6E,YAAvB,EAAqC;AACtE,QAAIjH,CAAJ;AAAA,QACI4B,OAAO,IADX;AAAA,QAEImF,gBAAgB,GAFpB;AAAA,QAGIG,UAHJ;;AAKA,SAAMlH,IAAI,CAAV,EAAaA,IAAI,CAAjB,EAAoBA,GAApB,EAAyB;AACrBK,eAAOuB,KAAKuE,WAAL,CAAiB9F,KAAK4B,GAAtB,CAAP;AACA,YAAI,CAAC5B,IAAL,EAAW;AACP,mBAAO,IAAP;AACH;AACD,YAAIA,KAAKA,IAAL,IAAauB,KAAK6D,YAAtB,EAAoC;AAChCpF,iBAAKA,IAAL,GAAYA,KAAKA,IAAL,GAAYuB,KAAK6D,YAA7B;AACAsB,6BAAiB,KAAM,IAAI/G,CAA3B;AACH,SAHD,MAGO;AACH+G,6BAAiB,KAAM,IAAI/G,CAA3B;AACH;AACDoC,eAAOJ,IAAP,CAAY3B,KAAKA,IAAjB;AACA4G,qBAAajF,IAAb,CAAkB3B,IAAlB;AACH;;AAED6G,iBAAatF,KAAKkF,oBAAL,CAA0BC,aAA1B,CAAb;AACA,QAAIG,eAAe,IAAnB,EAAyB;AACrB,eAAO,IAAP;AACH;AACD9E,WAAO+E,OAAP,CAAeD,UAAf;;AAEA7G,WAAOuB,KAAKyE,YAAL,CAAkBzE,KAAKgE,cAAvB,EAAuCvF,KAAK4B,GAA5C,EAAiD,IAAjD,EAAuD,KAAvD,CAAP;AACA,QAAI5B,SAAS,IAAb,EAAmB;AACf,eAAO,IAAP;AACH;AACD4G,iBAAajF,IAAb,CAAkB3B,IAAlB;;AAEA,SAAML,IAAI,CAAV,EAAaA,IAAI,CAAjB,EAAoBA,GAApB,EAAyB;AACrBK,eAAOuB,KAAKuE,WAAL,CAAiB9F,KAAK4B,GAAtB,EAA2BL,KAAK6D,YAAhC,CAAP;AACA,YAAI,CAACpF,IAAL,EAAW;AACP,mBAAO,IAAP;AACH;AACD4G,qBAAajF,IAAb,CAAkB3B,IAAlB;AACA+B,eAAOJ,IAAP,CAAY3B,KAAKA,IAAjB;AACH;;AAED,WAAOA,IAAP;AACH,CA3CD;;AA6CA0E,UAAUnF,SAAV,CAAoByC,OAApB,GAA8B,YAAW;AACrC,QAAIoE,SAAJ;AAAA,QACI7E,OAAO,IADX;AAAA,QAEIvB,IAFJ;AAAA,QAGI+B,SAAS,EAHb;AAAA,QAII6E,eAAe,EAJnB;AAAA,QAKIG,aAAa,EALjB;;AAOAX,gBAAY7E,KAAK2E,UAAL,EAAZ;AACA,QAAI,CAACE,SAAL,EAAgB;AACZ,eAAO,IAAP;AACH;AACDpG,WAAO;AACHA,cAAMoG,UAAUpG,IADb;AAEHN,eAAO0G,UAAU1G,KAFd;AAGHkC,aAAKwE,UAAUxE;AAHZ,KAAP;AAKAgF,iBAAajF,IAAb,CAAkB3B,IAAlB;AACAA,WAAOuB,KAAKoF,cAAL,CAAoB3G,IAApB,EAA0B+B,MAA1B,EAAkC6E,YAAlC,CAAP;AACA,QAAI,CAAC5G,IAAL,EAAW;AACP,eAAO,IAAP;AACH;AACDA,WAAOuB,KAAKiF,QAAL,CAAcxG,KAAK4B,GAAnB,EAAwB,KAAxB,CAAP;AACA,QAAI,CAAC5B,IAAL,EAAU;AACN,eAAO,IAAP;AACH;;AAED4G,iBAAajF,IAAb,CAAkB3B,IAAlB;;AAEA;AACA,QAAI,CAACuB,KAAKyF,SAAL,CAAejF,MAAf,CAAL,EAA6B;AACzB,eAAO,IAAP;AACH;;AAED,QAAI,KAAK1C,WAAL,CAAiBQ,MAAjB,GAA0B,CAA9B,EAAiC;AAC7B,YAAIoH,MAAM,KAAKC,iBAAL,CAAuBlH,KAAK4B,GAA5B,CAAV;AACA,YAAI,CAACqF,GAAL,EAAU;AACN,mBAAO,IAAP;AACH;AACD,YAAIE,WAAWF,IAAIL,YAAJ,CAAiBK,IAAIL,YAAJ,CAAiB/G,MAAjB,GAAwB,CAAzC,CAAf;AAAA,YACIyG,UAAU;AACN5G,mBAAOyH,SAASzH,KAAT,IAAmB,CAACyH,SAASvF,GAAT,GAAeuF,SAASzH,KAAzB,IAAkC,CAAnC,GAAwC,CAA1D,CADD;AAENkC,iBAAKuF,SAASvF;AAFR,SADd;AAKA,YAAG,CAACL,KAAK8E,yBAAL,CAA+BC,OAA/B,CAAJ,EAA6C;AACzC,mBAAO,IAAP;AACH;AACDS,qBAAa;AACTK,wBAAYH,GADH;AAETjH,kBAAM+B,OAAOoC,IAAP,CAAY,EAAZ,IAAkB8C,IAAIjH;AAFnB,SAAb;AAIH;;AAED;AACIA,cAAM+B,OAAOoC,IAAP,CAAY,EAAZ,CADV;AAEIzE,eAAO0G,UAAU1G,KAFrB;AAGIkC,aAAK5B,KAAK4B,GAHd;AAIIyF,iBAAS,EAJb;AAKIjB,mBAAWA,SALf;AAMIQ,sBAAcA;AANlB,OAOOG,UAPP;AASH,CA9DD;;AAgEArC,UAAUnF,SAAV,CAAoB2H,iBAApB,GAAwC,UAASnG,MAAT,EAAiB;AACrD,QAAIpB,CAAJ;AAAA,QACID,QAAQ,KAAKoB,QAAL,CAAc,KAAKxB,IAAnB,EAAyByB,MAAzB,CADZ;AAAA,QAEIqF,YAAY,KAAKJ,YAAL,CAAkB,KAAKR,uBAAvB,EAAgD9F,KAAhD,EAAuD,KAAvD,EAA8D,KAA9D,CAFhB;AAAA,QAGIqC,MAHJ;;AAKA,QAAIqE,cAAc,IAAlB,EAAwB;AACpB,eAAO,IAAP;AACH;;AAED,SAAKzG,IAAI,CAAT,EAAYA,IAAI,KAAKN,WAAL,CAAiBQ,MAAjC,EAAyCF,GAAzC,EAA8C;AAC1CoC,iBAAS,KAAK1C,WAAL,CAAiBM,CAAjB,EAAoB2H,MAApB,CAA2B,KAAKhI,IAAhC,EAAsC8G,UAAUxE,GAAhD,CAAT;AACA,YAAIG,WAAW,IAAf,EAAqB;AACjB,mBAAO;AACH/B,sBAAM+B,OAAO/B,IADV;AAEHN,4BAFG;AAGH0G,oCAHG;AAIHxE,qBAAKG,OAAOH,GAJT;AAKHyF,yBAAS,EALN;AAMHT,8BAAc7E,OAAO6E;AANlB,aAAP;AAQH;AACJ;AACD,WAAO,IAAP;AACH,CAxBD;;AA0BAlC,UAAUnF,SAAV,CAAoByH,SAApB,GAAgC,UAASjF,MAAT,EAAiB;AAC7C,QAAI3B,MAAM,CAAV;AAAA,QAAaT,CAAb;;AAEA,SAAMA,IAAIoC,OAAOlC,MAAP,GAAgB,CAA1B,EAA6BF,KAAK,CAAlC,EAAqCA,KAAK,CAA1C,EAA6C;AACzCS,eAAO2B,OAAOpC,CAAP,CAAP;AACH;AACDS,WAAO,CAAP;AACA,SAAMT,IAAIoC,OAAOlC,MAAP,GAAgB,CAA1B,EAA6BF,KAAK,CAAlC,EAAqCA,KAAK,CAA1C,EAA6C;AACzCS,eAAO2B,OAAOpC,CAAP,CAAP;AACH;AACD,WAAOS,MAAM,EAAN,KAAa,CAApB;AACH,CAXD;;AAaAsE,UAAUnB,WAAV,GAAwB;AACpBlE,iBAAa;AACT,gBAAQ,iBADC;AAET,mBAAW,EAFF;AAGT,uBAAe;AAHN;AADO,CAAxB;;AAQA,wDAAgBqF,SAAhB,C;;;;;;AChYA;;AAEA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5BA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACA;AACA;AACA;AACA;AACA;AACA,C;;;;;;ACbA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;AC3BA,wDAAe;AACX6C,cAAU,kBAASC,GAAT,EAAcC,IAAd,EAAoBC,GAApB,EAAyBC,KAAzB,EAA+B;AACrCD,YAAIE,WAAJ,GAAkBD,MAAME,KAAxB;AACAH,YAAII,SAAJ,GAAgBH,MAAME,KAAtB;AACAH,YAAIK,SAAJ,GAAgB,CAAhB;AACAL,YAAIM,SAAJ;AACAN,YAAIO,UAAJ,CAAeT,IAAI3D,CAAnB,EAAsB2D,IAAIU,CAA1B,EAA6BT,KAAK5D,CAAlC,EAAqC4D,KAAKS,CAA1C;AACH,KAPU;AAQXC,cAAU,kBAASC,IAAT,EAAeC,GAAf,EAAoBX,GAApB,EAAyBC,KAAzB,EAAgC;AACtCD,YAAIE,WAAJ,GAAkBD,MAAME,KAAxB;AACAH,YAAII,SAAJ,GAAgBH,MAAME,KAAtB;AACAH,YAAIK,SAAJ,GAAgBJ,MAAMI,SAAtB;AACAL,YAAIM,SAAJ;AACAN,YAAIY,MAAJ,CAAWF,KAAK,CAAL,EAAQC,IAAIxE,CAAZ,CAAX,EAA2BuE,KAAK,CAAL,EAAQC,IAAIH,CAAZ,CAA3B;AACA,aAAK,IAAItE,IAAI,CAAb,EAAgBA,IAAIwE,KAAKvI,MAAzB,EAAiC+D,GAAjC,EAAsC;AAClC8D,gBAAIa,MAAJ,CAAWH,KAAKxE,CAAL,EAAQyE,IAAIxE,CAAZ,CAAX,EAA2BuE,KAAKxE,CAAL,EAAQyE,IAAIH,CAAZ,CAA3B;AACH;AACDR,YAAIc,SAAJ;AACAd,YAAIe,MAAJ;AACH,KAnBU;AAoBXC,eAAW,mBAASC,SAAT,EAAoBlB,IAApB,EAA0BC,GAA1B,EAA+B;AACtC,YAAIkB,aAAalB,IAAImB,YAAJ,CAAiB,CAAjB,EAAoB,CAApB,EAAuBpB,KAAK5D,CAA5B,EAA+B4D,KAAKS,CAApC,CAAjB;AAAA,YACIY,OAAOF,WAAWE,IADtB;AAAA,YAEIC,eAAeJ,UAAU9I,MAF7B;AAAA,YAGImJ,gBAAgBF,KAAKjJ,MAHzB;AAAA,YAII4C,KAJJ;;AAMA,YAAIuG,gBAAgBD,YAAhB,KAAiC,CAArC,EAAwC;AACpC,mBAAO,KAAP;AACH;AACD,eAAOA,cAAP,EAAsB;AAClBtG,oBAAQkG,UAAUI,YAAV,CAAR;AACAD,iBAAK,EAAEE,aAAP,IAAwB,GAAxB;AACAF,iBAAK,EAAEE,aAAP,IAAwBvG,KAAxB;AACAqG,iBAAK,EAAEE,aAAP,IAAwBvG,KAAxB;AACAqG,iBAAK,EAAEE,aAAP,IAAwBvG,KAAxB;AACH;AACDiF,YAAIuB,YAAJ,CAAiBL,UAAjB,EAA6B,CAA7B,EAAgC,CAAhC;AACA,eAAO,IAAP;AACH;AAvCU,CAAf,C;;;;;;ACAA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC/BA;;AAEA;AACA;;AAEA;;;;;;;ACLA;;AAEA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;;AAEA;AACA;;AAEA;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA,iBAAiB;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpCA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA,6BAA6B,kBAAkB,EAAE;AACjD;AACA;AACA;AACA;AACA;AACA,8CAA8C,kBAAkB,EAAE;AAClE;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnCA;AACA;AACA,IAAMM,OAAO;AACTC,WAAO,mBAAAC,CAAQ,CAAR;AADE,CAAb;AAGA,IAAMC,OAAO;AACTF,WAAO,mBAAAC,CAAQ,EAAR;AADE,CAAb;;AAIA;;;;;AAKO,SAASE,QAAT,CAAkBzF,CAAlB,EAAqBqE,CAArB,EAAwB;AAC3B,QAAIqB,OAAO;AACP1F,WAAGA,CADI;AAEPqE,WAAGA,CAFI;AAGPsB,gBAAQ,kBAAW;AACf,mBAAON,KAAKC,KAAL,CAAW,CAAC,KAAKtF,CAAN,EAAS,KAAKqE,CAAd,CAAX,CAAP;AACH,SALM;AAMPuB,gBAAQ,kBAAW;AACf,mBAAOJ,KAAKF,KAAL,CAAW,CAAC,KAAKtF,CAAN,EAAS,KAAKqE,CAAd,EAAiB,CAAjB,CAAX,CAAP;AACH,SARM;AASPwB,eAAO,iBAAW;AACd,iBAAK7F,CAAL,GAAS,KAAKA,CAAL,GAAS,GAAT,GAAejD,KAAKkD,KAAL,CAAW,KAAKD,CAAL,GAAS,GAApB,CAAf,GAA0CjD,KAAKkD,KAAL,CAAW,KAAKD,CAAL,GAAS,GAApB,CAAnD;AACA,iBAAKqE,CAAL,GAAS,KAAKA,CAAL,GAAS,GAAT,GAAetH,KAAKkD,KAAL,CAAW,KAAKoE,CAAL,GAAS,GAApB,CAAf,GAA0CtH,KAAKkD,KAAL,CAAW,KAAKoE,CAAL,GAAS,GAApB,CAAnD;AACA,mBAAO,IAAP;AACH;AAbM,KAAX;AAeA,WAAOqB,IAAP;AACH;;AAED;;;;AAIO,SAASI,qBAAT,CAA+BC,YAA/B,EAA6CC,eAA7C,EAA8D;AACjE,QAAIlB,YAAYiB,aAAad,IAA7B;AACA,QAAIgB,QAAQF,aAAanC,IAAb,CAAkB5D,CAA9B;AACA,QAAIkG,SAASH,aAAanC,IAAb,CAAkBS,CAA/B;AACA,QAAI8B,oBAAoBH,gBAAgBf,IAAxC;AACA,QAAI1I,MAAM,CAAV;AAAA,QAAa6J,OAAO,CAApB;AAAA,QAAuBC,OAAO,CAA9B;AAAA,QAAiCC,OAAO,CAAxC;AAAA,QAA2CC,OAAO,CAAlD;AAAA,QAAqDvG,CAArD;AAAA,QAAwDqE,CAAxD;;AAEA;AACAgC,WAAOJ,KAAP;AACA1J,UAAM,CAAN;AACA,SAAM8H,IAAI,CAAV,EAAaA,IAAI6B,MAAjB,EAAyB7B,GAAzB,EAA8B;AAC1B9H,eAAOuI,UAAUsB,IAAV,CAAP;AACAD,0BAAkBE,IAAlB,KAA2B9J,GAA3B;AACA6J,gBAAQH,KAAR;AACAI,gBAAQJ,KAAR;AACH;;AAEDG,WAAO,CAAP;AACAC,WAAO,CAAP;AACA9J,UAAM,CAAN;AACA,SAAMyD,IAAI,CAAV,EAAaA,IAAIiG,KAAjB,EAAwBjG,GAAxB,EAA6B;AACzBzD,eAAOuI,UAAUsB,IAAV,CAAP;AACAD,0BAAkBE,IAAlB,KAA2B9J,GAA3B;AACA6J;AACAC;AACH;;AAED,SAAMhC,IAAI,CAAV,EAAaA,IAAI6B,MAAjB,EAAyB7B,GAAzB,EAA8B;AAC1B+B,eAAO/B,IAAI4B,KAAJ,GAAY,CAAnB;AACAI,eAAO,CAAChC,IAAI,CAAL,IAAU4B,KAAV,GAAkB,CAAzB;AACAK,eAAOjC,IAAI4B,KAAX;AACAM,eAAO,CAAClC,IAAI,CAAL,IAAU4B,KAAjB;AACA,aAAMjG,IAAI,CAAV,EAAaA,IAAIiG,KAAjB,EAAwBjG,GAAxB,EAA6B;AACzBmG,8BAAkBC,IAAlB,KACItB,UAAUsB,IAAV,IAAkBD,kBAAkBE,IAAlB,CAAlB,GAA4CF,kBAAkBG,IAAlB,CAA5C,GAAsEH,kBAAkBI,IAAlB,CAD1E;AAEAH;AACAC;AACAC;AACAC;AACH;AACJ;AACJ;;AAEM,SAASC,oBAAT,CAA8BT,YAA9B,EAA4CC,eAA5C,EAA6D;AAChE,QAAIlB,YAAYiB,aAAad,IAA7B;AACA,QAAIgB,QAAQF,aAAanC,IAAb,CAAkB5D,CAA9B;AACA,QAAIkG,SAASH,aAAanC,IAAb,CAAkBS,CAA/B;AACA,QAAI8B,oBAAoBH,gBAAgBf,IAAxC;AACA,QAAI1I,MAAM,CAAV;;AAEA;AACA,SAAK,IAAIT,IAAI,CAAb,EAAgBA,IAAImK,KAApB,EAA2BnK,GAA3B,EAAgC;AAC5BS,eAAOuI,UAAUhJ,CAAV,CAAP;AACAqK,0BAAkBrK,CAAlB,IAAuBS,GAAvB;AACH;;AAED,SAAK,IAAIkK,IAAI,CAAb,EAAgBA,IAAIP,MAApB,EAA4BO,GAA5B,EAAiC;AAC7BlK,cAAM,CAAN;AACA,aAAK,IAAImK,IAAI,CAAb,EAAgBA,IAAIT,KAApB,EAA2BS,GAA3B,EAAgC;AAC5BnK,mBAAOuI,UAAU2B,IAAIR,KAAJ,GAAYS,CAAtB,CAAP;AACAP,8BAAoBM,CAAD,GAAMR,KAAP,GAAgBS,CAAlC,IAAuCnK,MAAM4J,kBAAkB,CAACM,IAAI,CAAL,IAAUR,KAAV,GAAkBS,CAApC,CAA7C;AACH;AACJ;AACJ;;AAEM,SAASC,cAAT,CAAwBZ,YAAxB,EAAsCxF,SAAtC,EAAiDqG,aAAjD,EAAgE;AACnE,QAAI,CAACA,aAAL,EAAoB;AAChBA,wBAAgBb,YAAhB;AACH;AACD,QAAIjB,YAAYiB,aAAad,IAA7B;AAAA,QAAmCjJ,SAAS8I,UAAU9I,MAAtD;AAAA,QAA8D6K,aAAaD,cAAc3B,IAAzF;;AAEA,WAAOjJ,QAAP,EAAiB;AACb6K,mBAAW7K,MAAX,IAAqB8I,UAAU9I,MAAV,IAAoBuE,SAApB,GAAgC,CAAhC,GAAoC,CAAzD;AACH;AACJ;;AAEM,SAASuG,gBAAT,CAA0Bf,YAA1B,EAAwCgB,YAAxC,EAAsD;AACzD,QAAI,CAACA,YAAL,EAAmB;AACfA,uBAAe,CAAf;AACH;AACD,QAAIjC,YAAYiB,aAAad,IAA7B;AAAA,QACIjJ,SAAS8I,UAAU9I,MADvB;AAAA,QAEIgL,WAAW,IAAID,YAFnB;AAAA,QAGIE,YAAY,KAAKF,YAHrB;AAAA,QAIIG,OAAO,IAAIC,UAAJ,CAAeF,SAAf,CAJX;;AAMA,WAAOjL,QAAP,EAAiB;AACbkL,aAAKpC,UAAU9I,MAAV,KAAqBgL,QAA1B;AACH;AACD,WAAOE,IAAP;AACH;;AAEM,SAASE,WAAT,CAAqBxL,IAArB,EAA2B;AAC9B,QAAIE,CAAJ;AAAA,QACIE,SAASJ,KAAKI,MADlB;AAAA,QAEIqL,OAAOzL,KAAK,CAAL,CAFX;AAAA,QAGI0L,SAAS1L,KAAK,CAAL,CAHb;AAAA,QAII2L,KAJJ;;AAMA,SAAKzL,IAAI,CAAT,EAAYA,IAAIE,SAAS,CAAzB,EAA4BF,GAA5B,EAAiC;AAC7ByL,gBAAQ3L,KAAKE,IAAI,CAAT,CAAR;AACA;AACAF,aAAKE,IAAI,CAAT,IAAiBwL,SAAS,CAAV,GAAeD,IAAf,GAAsBE,KAAxB,GAAkC,GAAhD;AACAF,eAAOC,MAAP;AACAA,iBAASC,KAAT;AACH;AACD,WAAO3L,IAAP;AACH;;AAEM,SAAS4L,sBAAT,CAAgCzB,YAAhC,EAA8CgB,YAA9C,EAA4D;AAC/D,QAAI,CAACA,YAAL,EAAmB;AACfA,uBAAe,CAAf;AACH;AACD,QAAIG,IAAJ;AAAA,QACI3G,SADJ;AAAA,QAEIyG,WAAW,IAAID,YAFnB;;AAIA,aAASU,EAAT,CAAYvI,IAAZ,EAAkBnB,GAAlB,EAAuB;AACnB,YAAIxB,MAAM,CAAV;AAAA,YAAaT,CAAb;AACA,aAAMA,IAAIoD,IAAV,EAAgBpD,KAAKiC,GAArB,EAA0BjC,GAA1B,EAA+B;AAC3BS,mBAAO2K,KAAKpL,CAAL,CAAP;AACH;AACD,eAAOS,GAAP;AACH;;AAED,aAASmL,EAAT,CAAYxI,IAAZ,EAAkBnB,GAAlB,EAAuB;AACnB,YAAIjC,CAAJ;AAAA,YAAOS,MAAM,CAAb;;AAEA,aAAMT,IAAIoD,IAAV,EAAgBpD,KAAKiC,GAArB,EAA0BjC,GAA1B,EAA+B;AAC3BS,mBAAOT,IAAIoL,KAAKpL,CAAL,CAAX;AACH;;AAED,eAAOS,GAAP;AACH;;AAED,aAASoL,kBAAT,GAA8B;AAC1B,YAAIC,MAAM,CAAC,CAAD,CAAV;AAAA,YAAeC,EAAf;AAAA,YAAmBC,EAAnB;AAAA,YAAuBC,GAAvB;AAAA,YAA4BC,CAA5B;AAAA,YAA+BC,EAA/B;AAAA,YAAmCC,EAAnC;AAAA,YAAuCC,GAAvC;AAAA,YACIvH,MAAM,CAAC,KAAKmG,YAAN,IAAsB,CADhC;;AAGAG,eAAOJ,iBAAiBf,YAAjB,EAA+BgB,YAA/B,CAAP;AACA,aAAMiB,IAAI,CAAV,EAAaA,IAAIpH,GAAjB,EAAsBoH,GAAtB,EAA2B;AACvBH,iBAAKJ,GAAG,CAAH,EAAMO,CAAN,CAAL;AACAF,iBAAKL,GAAGO,IAAI,CAAP,EAAUpH,GAAV,CAAL;AACAmH,kBAAMF,KAAKC,EAAX;AACA,gBAAIC,QAAQ,CAAZ,EAAe;AACXA,sBAAM,CAAN;AACH;AACDE,iBAAKP,GAAG,CAAH,EAAMM,CAAN,IAAWF,EAAhB;AACAI,iBAAKR,GAAGM,IAAI,CAAP,EAAUpH,GAAV,IAAiBiH,EAAtB;AACAM,kBAAMF,KAAKC,EAAX;AACAN,gBAAII,CAAJ,IAASG,MAAMA,GAAN,GAAYJ,GAArB;AACH;AACD,eAAO,8DAAA9I,CAAY0B,QAAZ,CAAqBiH,GAArB,CAAP;AACH;;AAEDrH,gBAAYoH,oBAAZ;AACA,WAAOpH,aAAayG,QAApB;AACH;;AAEM,SAASoB,aAAT,CAAuBrC,YAAvB,EAAqCa,aAArC,EAAoD;AACvD,QAAIrG,YAAYiH,uBAAuBzB,YAAvB,CAAhB;;AAEAY,mBAAeZ,YAAf,EAA6BxF,SAA7B,EAAwCqG,aAAxC;AACA,WAAOrG,SAAP;AACH;;AAED;AACO,SAAS8H,kBAAT,CAA4BtC,YAA5B,EAA0CC,eAA1C,EAA2DY,aAA3D,EAA0E;AAC7EJ,yBAAqBT,YAArB,EAAmCC,eAAnC;;AAEA,QAAI,CAACY,aAAL,EAAoB;AAChBA,wBAAgBb,YAAhB;AACH;AACD,QAAIjB,YAAYiB,aAAad,IAA7B;AACA,QAAI4B,aAAaD,cAAc3B,IAA/B;AACA,QAAIgB,QAAQF,aAAanC,IAAb,CAAkB5D,CAA9B;AACA,QAAIkG,SAASH,aAAanC,IAAb,CAAkBS,CAA/B;AACA,QAAI8B,oBAAoBH,gBAAgBf,IAAxC;AACA,QAAI1I,MAAM,CAAV;AAAA,QAAakK,CAAb;AAAA,QAAgBC,CAAhB;AAAA,QAAmB4B,SAAS,CAA5B;AAAA,QAA+BC,CAA/B;AAAA,QAAkCC,CAAlC;AAAA,QAAqCC,CAArC;AAAA,QAAwCC,CAAxC;AAAA,QAA2CC,GAA3C;AAAA,QAAgD/E,OAAO,CAAC0E,SAAS,CAAT,GAAa,CAAd,KAAoBA,SAAS,CAAT,GAAa,CAAjC,CAAvD;;AAEA;AACA,SAAM7B,IAAI,CAAV,EAAaA,KAAK6B,MAAlB,EAA0B7B,GAA1B,EAA+B;AAC3B,aAAMC,IAAI,CAAV,EAAaA,IAAIT,KAAjB,EAAwBS,GAAxB,EAA6B;AACzBG,uBAAaJ,CAAD,GAAMR,KAAP,GAAgBS,CAA3B,IAAgC,CAAhC;AACAG,uBAAY,CAAEX,SAAS,CAAV,GAAeO,CAAhB,IAAqBR,KAAtB,GAA+BS,CAA1C,IAA+C,CAA/C;AACH;AACJ;;AAED;AACA,SAAMD,IAAI6B,MAAV,EAAkB7B,IAAIP,SAASoC,MAA/B,EAAuC7B,GAAvC,EAA4C;AACxC,aAAMC,IAAI,CAAV,EAAaA,KAAK4B,MAAlB,EAA0B5B,GAA1B,EAA+B;AAC3BG,uBAAaJ,CAAD,GAAMR,KAAP,GAAgBS,CAA3B,IAAgC,CAAhC;AACAG,uBAAaJ,CAAD,GAAMR,KAAP,IAAiBA,QAAQ,CAAR,GAAYS,CAA7B,CAAX,IAA8C,CAA9C;AACH;AACJ;;AAED,SAAMD,IAAI6B,SAAS,CAAnB,EAAsB7B,IAAIP,SAASoC,MAAT,GAAkB,CAA5C,EAA+C7B,GAA/C,EAAoD;AAChD,aAAMC,IAAI4B,SAAS,CAAnB,EAAsB5B,IAAIT,QAAQqC,MAAlC,EAA0C5B,GAA1C,EAA+C;AAC3C6B,gBAAIpC,kBAAkB,CAACM,IAAI6B,MAAJ,GAAa,CAAd,IAAmBrC,KAAnB,IAA4BS,IAAI4B,MAAJ,GAAa,CAAzC,CAAlB,CAAJ;AACAE,gBAAIrC,kBAAkB,CAACM,IAAI6B,MAAJ,GAAa,CAAd,IAAmBrC,KAAnB,IAA4BS,IAAI4B,MAAhC,CAAlB,CAAJ;AACAG,gBAAItC,kBAAkB,CAACM,IAAI6B,MAAL,IAAerC,KAAf,IAAwBS,IAAI4B,MAAJ,GAAa,CAArC,CAAlB,CAAJ;AACAI,gBAAIvC,kBAAkB,CAACM,IAAI6B,MAAL,IAAerC,KAAf,IAAwBS,IAAI4B,MAA5B,CAAlB,CAAJ;AACA/L,kBAAMmM,IAAID,CAAJ,GAAQD,CAAR,GAAYD,CAAlB;AACAI,kBAAMpM,MAAOqH,IAAb;AACAiD,uBAAWJ,IAAIR,KAAJ,GAAYS,CAAvB,IAA4B5B,UAAU2B,IAAIR,KAAJ,GAAYS,CAAtB,IAA4BiC,MAAM,CAAlC,GAAuC,CAAvC,GAA2C,CAAvE;AACH;AACJ;AACJ;;AAEM,SAASC,OAAT,CAAiBC,MAAjB,EAAyBtI,SAAzB,EAAoCuI,QAApC,EAA8C;AACjD,QAAIhN,CAAJ;AAAA,QAAOkM,CAAP;AAAA,QAAUY,OAAV;AAAA,QAAmBG,KAAnB;AAAA,QAA0BC,WAAW,EAArC;;AAEA,QAAI,CAACF,QAAL,EAAe;AACXA,mBAAW,KAAX;AACH;;AAED,aAASG,YAAT,CAAsBC,QAAtB,EAAgC;AAC5B,YAAIC,QAAQ,KAAZ;AACA,aAAMnB,IAAI,CAAV,EAAaA,IAAIgB,SAAShN,MAA1B,EAAkCgM,GAAlC,EAAuC;AACnCY,sBAAUI,SAAShB,CAAT,CAAV;AACA,gBAAIY,QAAQQ,IAAR,CAAaF,QAAb,CAAJ,EAA4B;AACxBN,wBAAQS,GAAR,CAAYH,QAAZ;AACAC,wBAAQ,IAAR;AACH;AACJ;AACD,eAAOA,KAAP;AACH;;AAED;AACA,SAAMrN,IAAI,CAAV,EAAaA,IAAI+M,OAAO7M,MAAxB,EAAgCF,GAAhC,EAAqC;AACjCiN,gBAAQ,yDAAAO,CAASC,WAAT,CAAqBV,OAAO/M,CAAP,CAArB,EAAgCA,CAAhC,EAAmCgN,QAAnC,CAAR;AACA,YAAI,CAACG,aAAaF,KAAb,CAAL,EAA0B;AACtBC,qBAASlL,IAAT,CAAc,yDAAAwL,CAASvH,MAAT,CAAgBgH,KAAhB,EAAuBxI,SAAvB,CAAd;AACH;AACJ;AACD,WAAOyI,QAAP;AACH;;AAEM,IAAMQ,SAAS;AAClBC,WAAO,eAASZ,MAAT,EAAiBa,GAAjB,EAAsB;AACzB,YAAIC,SAAJ;AAAA,YAAeC,gBAAgB,EAA/B;AAAA,YAAmCC,MAAM,EAAzC;AAAA,YAA6C3L,SAAS,EAAtD;AAAA,YAA0D4L,YAAY,CAAtE;AAAA,YAAyEC,aAAa,CAAtF;;AAEA,iBAASN,KAAT,CAAeO,GAAf,EAAoBC,OAApB,EAA6B;AACzB,gBAAIC,IAAJ;AAAA,gBAAUC,EAAV;AAAA,gBAAcC,KAAd;AAAA,gBAAqBC,YAArB;AAAA,gBAAmCC,aAAa,CAAhD;AAAA,gBAAmDC,aAAaxN,KAAKC,GAAL,CAAS0M,IAAI,CAAJ,IAAS,EAAlB,CAAhE;AAAA,gBAAuFP,QAAQ,KAA/F;;AAEA,qBAASqB,KAAT,CAAe7G,GAAf,EAAoB8G,SAApB,EAA+B;AAC3B,oBAAI9G,IAAI3D,CAAJ,GAASyK,UAAUzK,CAAV,GAAcsK,UAAvB,IACO3G,IAAI3D,CAAJ,GAASyK,UAAUzK,CAAV,GAAcsK,UAD9B,IAEO3G,IAAIU,CAAJ,GAASoG,UAAUpG,CAAV,GAAckG,UAF9B,IAGO5G,IAAIU,CAAJ,GAASoG,UAAUpG,CAAV,GAAckG,UAHlC,EAG+C;AAC3C,2BAAO,IAAP;AACH,iBALD,MAKO;AACH,2BAAO,KAAP;AACH;AACJ;;AAED;AACA;;AAEAL,mBAAOrB,OAAOmB,GAAP,CAAP;AACA,gBAAIC,OAAJ,EAAa;AACTI,+BAAe;AACXrK,uBAAGkK,KAAKlK,CAAL,GAAS0J,IAAI,CAAJ,CADD;AAEXrF,uBAAG6F,KAAK7F,CAAL,GAASqF,IAAI,CAAJ;AAFD,iBAAf;AAIH,aALD,MAKO;AACHW,+BAAe;AACXrK,uBAAGkK,KAAKlK,CAAL,GAAS0J,IAAI,CAAJ,CADD;AAEXrF,uBAAG6F,KAAK7F,CAAL,GAASqF,IAAI,CAAJ;AAFD,iBAAf;AAIH;;AAEDU,oBAAQH,UAAUD,MAAM,CAAhB,GAAoBA,MAAM,CAAlC;AACAG,iBAAKtB,OAAOuB,KAAP,CAAL;AACA,mBAAOD,MAAM,CAAEhB,QAAQqB,MAAML,EAAN,EAAUE,YAAV,CAAV,MAAuC,IAA7C,IAAsDtN,KAAKC,GAAL,CAASmN,GAAG9F,CAAH,GAAO6F,KAAK7F,CAArB,IAA0BqF,IAAI,CAAJ,CAAvF,EAAgG;AAC5FU,wBAAQH,UAAUG,QAAQ,CAAlB,GAAsBA,QAAQ,CAAtC;AACAD,qBAAKtB,OAAOuB,KAAP,CAAL;AACH;;AAED,mBAAOjB,QAAQiB,KAAR,GAAgB,IAAvB;AACH;;AAED,aAAMT,YAAY,CAAlB,EAAqBA,YAAYC,aAAjC,EAAgDD,WAAhD,EAA6D;AACzD;AACAG,wBAAY/M,KAAKkD,KAAL,CAAWlD,KAAKmD,MAAL,KAAgB2I,OAAO7M,MAAlC,CAAZ;;AAEA;AACA6N,kBAAM,EAAN;AACAE,yBAAaD,SAAb;AACAD,gBAAI/L,IAAJ,CAAS+K,OAAOkB,UAAP,CAAT;AACA,mBAAO,CAAEA,aAAaN,MAAMM,UAAN,EAAkB,IAAlB,CAAf,MAA4C,IAAnD,EAAyD;AACrDF,oBAAI/L,IAAJ,CAAS+K,OAAOkB,UAAP,CAAT;AACH;AACD,gBAAID,YAAY,CAAhB,EAAmB;AACfC,6BAAaD,SAAb;AACA,uBAAO,CAAEC,aAAaN,MAAMM,UAAN,EAAkB,KAAlB,CAAf,MAA6C,IAApD,EAA0D;AACtDF,wBAAI/L,IAAJ,CAAS+K,OAAOkB,UAAP,CAAT;AACH;AACJ;;AAED,gBAAIF,IAAI7N,MAAJ,GAAakC,OAAOlC,MAAxB,EAAgC;AAC5BkC,yBAAS2L,GAAT;AACH;AACJ;AACD,eAAO3L,MAAP;AACH;AAnEiB,CAAf;;AAsEA,IAAMwM,SAAS,CAAf;AACA,IAAMC,QAAQ,CAAd;;AAEA,SAASC,MAAT,CAAgBC,cAAhB,EAAgCC,eAAhC,EAAiD;AACpD,QAAIrE,CAAJ;AAAA,QACIC,CADJ;AAAA,QAEIqE,cAAcF,eAAe5F,IAFjC;AAAA,QAGI+F,eAAeF,gBAAgB7F,IAHnC;AAAA,QAIIiB,SAAS2E,eAAejH,IAAf,CAAoBS,CAJjC;AAAA,QAKI4B,QAAQ4E,eAAejH,IAAf,CAAoB5D,CALhC;AAAA,QAMIzD,GANJ;AAAA,QAOI0O,OAPJ;AAAA,QAQIC,OARJ;AAAA,QASIC,OATJ;AAAA,QAUIC,OAVJ;;AAYA,SAAM3E,IAAI,CAAV,EAAaA,IAAIP,SAAS,CAA1B,EAA6BO,GAA7B,EAAkC;AAC9B,aAAMC,IAAI,CAAV,EAAaA,IAAIT,QAAQ,CAAzB,EAA4BS,GAA5B,EAAiC;AAC7BuE,sBAAUxE,IAAI,CAAd;AACAyE,sBAAUzE,IAAI,CAAd;AACA0E,sBAAUzE,IAAI,CAAd;AACA0E,sBAAU1E,IAAI,CAAd;AACAnK,kBAAMwO,YAAYE,UAAUhF,KAAV,GAAkBkF,OAA9B,IAAyCJ,YAAYE,UAAUhF,KAAV,GAAkBmF,OAA9B,CAAzC,GACNL,YAAYtE,IAAIR,KAAJ,GAAYS,CAAxB,CADM,GAENqE,YAAYG,UAAUjF,KAAV,GAAkBkF,OAA9B,CAFM,GAEmCJ,YAAYG,UAAUjF,KAAV,GAAkBmF,OAA9B,CAFzC;AAGAJ,yBAAavE,IAAIR,KAAJ,GAAYS,CAAzB,IAA8BnK,MAAM,CAAN,GAAU,CAAV,GAAc,CAA5C;AACH;AACJ;AACJ;;AAEM,SAAS8O,KAAT,CAAeR,cAAf,EAA+BC,eAA/B,EAAgD;AACnD,QAAIrE,CAAJ;AAAA,QACIC,CADJ;AAAA,QAEIqE,cAAcF,eAAe5F,IAFjC;AAAA,QAGI+F,eAAeF,gBAAgB7F,IAHnC;AAAA,QAIIiB,SAAS2E,eAAejH,IAAf,CAAoBS,CAJjC;AAAA,QAKI4B,QAAQ4E,eAAejH,IAAf,CAAoB5D,CALhC;AAAA,QAMIzD,GANJ;AAAA,QAOI0O,OAPJ;AAAA,QAQIC,OARJ;AAAA,QASIC,OATJ;AAAA,QAUIC,OAVJ;;AAYA,SAAM3E,IAAI,CAAV,EAAaA,IAAIP,SAAS,CAA1B,EAA6BO,GAA7B,EAAkC;AAC9B,aAAMC,IAAI,CAAV,EAAaA,IAAIT,QAAQ,CAAzB,EAA4BS,GAA5B,EAAiC;AAC7BuE,sBAAUxE,IAAI,CAAd;AACAyE,sBAAUzE,IAAI,CAAd;AACA0E,sBAAUzE,IAAI,CAAd;AACA0E,sBAAU1E,IAAI,CAAd;AACAnK,kBAAMwO,YAAYE,UAAUhF,KAAV,GAAkBkF,OAA9B,IAAyCJ,YAAYE,UAAUhF,KAAV,GAAkBmF,OAA9B,CAAzC,GACNL,YAAYtE,IAAIR,KAAJ,GAAYS,CAAxB,CADM,GAENqE,YAAYG,UAAUjF,KAAV,GAAkBkF,OAA9B,CAFM,GAEmCJ,YAAYG,UAAUjF,KAAV,GAAkBmF,OAA9B,CAFzC;AAGAJ,yBAAavE,IAAIR,KAAJ,GAAYS,CAAzB,IAA8BnK,QAAQ,CAAR,GAAY,CAAZ,GAAgB,CAA9C;AACH;AACJ;AACJ;;AAEM,SAAS+O,QAAT,CAAkBC,aAAlB,EAAiCC,aAAjC,EAAgDC,kBAAhD,EAAoE;AACvE,QAAI,CAACA,kBAAL,EAAyB;AACrBA,6BAAqBF,aAArB;AACH;AACD,QAAIvP,SAASuP,cAActG,IAAd,CAAmBjJ,MAAhC;AAAA,QACI0P,aAAaH,cAActG,IAD/B;AAAA,QAEI0G,aAAaH,cAAcvG,IAF/B;AAAA,QAGI2G,aAAaH,mBAAmBxG,IAHpC;;AAKA,WAAOjJ,QAAP,EAAiB;AACb4P,mBAAW5P,MAAX,IAAqB0P,WAAW1P,MAAX,IAAqB2P,WAAW3P,MAAX,CAA1C;AACH;AACJ;;AAEM,SAAS6P,SAAT,CAAmBN,aAAnB,EAAkCC,aAAlC,EAAiDC,kBAAjD,EAAqE;AACxE,QAAI,CAACA,kBAAL,EAAyB;AACrBA,6BAAqBF,aAArB;AACH;AACD,QAAIvP,SAASuP,cAActG,IAAd,CAAmBjJ,MAAhC;AAAA,QACI0P,aAAaH,cAActG,IAD/B;AAAA,QAEI0G,aAAaH,cAAcvG,IAF/B;AAAA,QAGI2G,aAAaH,mBAAmBxG,IAHpC;;AAKA,WAAOjJ,QAAP,EAAiB;AACb4P,mBAAW5P,MAAX,IAAqB0P,WAAW1P,MAAX,KAAsB2P,WAAW3P,MAAX,CAA3C;AACH;AACJ;;AAEM,SAAS8P,YAAT,CAAsB/F,YAAtB,EAAoC;AACvC,QAAI/J,SAAS+J,aAAad,IAAb,CAAkBjJ,MAA/B;AAAA,QAAuCiJ,OAAOc,aAAad,IAA3D;AAAA,QAAiE1I,MAAM,CAAvE;;AAEA,WAAOP,QAAP,EAAiB;AACbO,eAAO0I,KAAKjJ,MAAL,CAAP;AACH;AACD,WAAOO,GAAP;AACH;;AAEM,SAASwP,UAAT,CAAoBC,IAApB,EAA0BnC,GAA1B,EAA+BrJ,SAA/B,EAA0C;AAC7C,QAAI1E,CAAJ;AAAA,QAAOmQ,SAAS,CAAhB;AAAA,QAAmBC,MAAM,CAAzB;AAAA,QAA4BzL,QAAQ,EAApC;AAAA,QAAwC0L,KAAxC;AAAA,QAA+CC,GAA/C;AAAA,QAAoDzI,GAApD;;AAEA,SAAM7H,IAAI,CAAV,EAAaA,IAAI+N,GAAjB,EAAsB/N,GAAtB,EAA2B;AACvB2E,cAAM3E,CAAN,IAAW;AACPqQ,mBAAO,CADA;AAEPE,kBAAM;AAFC,SAAX;AAIH;;AAED,SAAMvQ,IAAI,CAAV,EAAaA,IAAIkQ,KAAKhQ,MAAtB,EAA8BF,GAA9B,EAAmC;AAC/BqQ,gBAAQ3L,UAAUE,KAAV,CAAgB,IAAhB,EAAsB,CAACsL,KAAKlQ,CAAL,CAAD,CAAtB,CAAR;AACA,YAAIqQ,QAAQD,GAAZ,EAAiB;AACbE,kBAAM3L,MAAMwL,MAAN,CAAN;AACAG,gBAAID,KAAJ,GAAYA,KAAZ;AACAC,gBAAIC,IAAJ,GAAWL,KAAKlQ,CAAL,CAAX;AACAoQ,kBAAMrP,OAAOC,SAAb;AACA,iBAAM6G,MAAM,CAAZ,EAAeA,MAAMkG,GAArB,EAA0BlG,KAA1B,EAAiC;AAC7B,oBAAIlD,MAAMkD,GAAN,EAAWwI,KAAX,GAAmBD,GAAvB,EAA4B;AACxBA,0BAAMzL,MAAMkD,GAAN,EAAWwI,KAAjB;AACAF,6BAAStI,GAAT;AACH;AACJ;AACJ;AACJ;;AAED,WAAOlD,KAAP;AACH;;AAEM,SAAS6L,kBAAT,CAA4BC,SAA5B,EAAuCC,OAAvC,EAAgD3I,GAAhD,EAAqD4I,KAArD,EAA4D;AAC/D5I,QAAIgB,SAAJ,CAAc0H,SAAd,EAAyBC,OAAzB,EAAkC,CAAlC,EAAqCD,UAAUtG,KAA/C,EAAsDsG,UAAUrG,MAAhE;AACA,QAAIwG,UAAU7I,IAAImB,YAAJ,CAAiBwH,OAAjB,EAA0B,CAA1B,EAA6BD,UAAUtG,KAAvC,EAA8CsG,UAAUrG,MAAxD,EAAgEjB,IAA9E;AACA0H,gBAAYD,OAAZ,EAAqBD,KAArB;AACH;;AAEM,SAASG,oBAAT,CAA8B/I,GAA9B,EAAmCD,IAAnC,EAAyC1G,MAAzC,EAAiDuP,KAAjD,EAAwD;AAC3D,QAAIC,UAAU7I,IAAImB,YAAJ,CAAiB9H,OAAO8C,CAAxB,EAA2B9C,OAAOmH,CAAlC,EAAqCT,KAAK5D,CAA1C,EAA6C4D,KAAKS,CAAlD,EAAqDY,IAAnE;AACA0H,gBAAYD,OAAZ,EAAqBD,KAArB;AACH;;AAEM,SAASI,+BAAT,CAAyC9H,UAAzC,EAAqDnB,IAArD,EAA2DkJ,QAA3D,EAAqE;AACxE,QAAIC,YAAY,CAAhB;AACA,QAAIC,eAAepJ,KAAK5D,CAAxB;AACA,QAAIiN,SAASlQ,KAAKkD,KAAL,CAAW8E,WAAW/I,MAAX,GAAoB,CAA/B,CAAb;AACA,QAAIkR,WAAWtJ,KAAK5D,CAAL,GAAS,CAAxB;AACA,QAAImN,YAAY,CAAhB;AACA,QAAIC,UAAUxJ,KAAK5D,CAAnB;AACA,QAAIlE,CAAJ;;AAEA,WAAOkR,eAAeC,MAAtB,EAA8B;AAC1B,aAAMnR,IAAI,CAAV,EAAaA,IAAIoR,QAAjB,EAA2BpR,GAA3B,EAAgC;AAC5BgR,qBAASK,SAAT,IAAsB,CACjB,QAAQpI,WAAWgI,YAAY,CAAZ,GAAgB,CAA3B,CAAR,GACA,QAAQhI,WAAWgI,YAAY,CAAZ,GAAgB,CAA3B,CADR,GAEA,QAAQhI,WAAWgI,YAAY,CAAZ,GAAgB,CAA3B,CAFT,IAGC,QAAQhI,WAAW,CAACgI,YAAY,CAAb,IAAkB,CAAlB,GAAsB,CAAjC,CAAR,GACA,QAAQhI,WAAW,CAACgI,YAAY,CAAb,IAAkB,CAAlB,GAAsB,CAAjC,CADR,GAEA,QAAQhI,WAAW,CAACgI,YAAY,CAAb,IAAkB,CAAlB,GAAsB,CAAjC,CALT,KAMC,QAAQhI,WAAYiI,YAAD,GAAiB,CAAjB,GAAqB,CAAhC,CAAR,GACA,QAAQjI,WAAYiI,YAAD,GAAiB,CAAjB,GAAqB,CAAhC,CADR,GAEA,QAAQjI,WAAYiI,YAAD,GAAiB,CAAjB,GAAqB,CAAhC,CART,KASC,QAAQjI,WAAW,CAACiI,eAAe,CAAhB,IAAqB,CAArB,GAAyB,CAApC,CAAR,GACA,QAAQjI,WAAW,CAACiI,eAAe,CAAhB,IAAqB,CAArB,GAAyB,CAApC,CADR,GAEA,QAAQjI,WAAW,CAACiI,eAAe,CAAhB,IAAqB,CAArB,GAAyB,CAApC,CAXT,CADkB,IAYkC,CAZxD;AAaAG;AACAJ,wBAAYA,YAAY,CAAxB;AACAC,2BAAeA,eAAe,CAA9B;AACH;AACDD,oBAAYA,YAAYK,OAAxB;AACAJ,uBAAeA,eAAeI,OAA9B;AACH;AACJ;;AAEM,SAAST,WAAT,CAAqB7H,SAArB,EAAgCgI,QAAhC,EAA0CvR,MAA1C,EAAkD;AACrD,QAAIsE,IAAKiF,UAAU9I,MAAV,GAAmB,CAApB,GAAyB,CAAjC;AAAA,QACIF,CADJ;AAAA,QAEIuR,gBAAgB9R,UAAUA,OAAO8R,aAAP,KAAyB,IAFvD;;AAIA,QAAIA,aAAJ,EAAmB;AACf,aAAKvR,IAAI,CAAT,EAAYA,IAAI+D,CAAhB,EAAmB/D,GAAnB,EAAwB;AACpBgR,qBAAShR,CAAT,IAAcgJ,UAAUhJ,IAAI,CAAJ,GAAQ,CAAlB,CAAd;AACH;AACJ,KAJD,MAIO;AACH,aAAKA,IAAI,CAAT,EAAYA,IAAI+D,CAAhB,EAAmB/D,GAAnB,EAAwB;AACpBgR,qBAAShR,CAAT,IACI,QAAQgJ,UAAUhJ,IAAI,CAAJ,GAAQ,CAAlB,CAAR,GAA+B,QAAQgJ,UAAUhJ,IAAI,CAAJ,GAAQ,CAAlB,CAAvC,GAA8D,QAAQgJ,UAAUhJ,IAAI,CAAJ,GAAQ,CAAlB,CAD1E;AAEH;AACJ;AACJ;;AAEM,SAASwR,cAAT,CAAwBC,GAAxB,EAA6BC,QAA7B,EAAuCC,MAAvC,EAA+C;AAClD,QAAI,CAACA,MAAL,EAAa;AACTA,iBAASC,SAASC,aAAT,CAAuB,QAAvB,CAAT;AACH;AACD,QAAIC,MAAM,IAAIC,KAAJ,EAAV;AACAD,QAAIJ,QAAJ,GAAeA,QAAf;AACAI,QAAIE,MAAJ,GAAa,YAAW;AACpBL,eAAOxH,KAAP,GAAe,KAAKA,KAApB;AACAwH,eAAOvH,MAAP,GAAgB,KAAKA,MAArB;AACA,YAAIrC,MAAM4J,OAAOM,UAAP,CAAkB,IAAlB,CAAV;AACAlK,YAAIgB,SAAJ,CAAc,IAAd,EAAoB,CAApB,EAAuB,CAAvB;AACA,YAAI4H,QAAQ,IAAIuB,UAAJ,CAAe,KAAK/H,KAAL,GAAa,KAAKC,MAAjC,CAAZ;AACArC,YAAIgB,SAAJ,CAAc,IAAd,EAAoB,CAApB,EAAuB,CAAvB;AACA,YAAII,OAAOpB,IAAImB,YAAJ,CAAiB,CAAjB,EAAoB,CAApB,EAAuB,KAAKiB,KAA5B,EAAmC,KAAKC,MAAxC,EAAgDjB,IAA3D;AACA0H,oBAAY1H,IAAZ,EAAkBwH,KAAlB;AACA,aAAKe,QAAL,CAAcf,KAAd,EAAqB;AACjBzM,eAAG,KAAKiG,KADS;AAEjB5B,eAAG,KAAK6B;AAFS,SAArB,EAGG,IAHH;AAIH,KAbD;AAcA0H,QAAIL,GAAJ,GAAUA,GAAV;AACH;;AAED;;;;AAIO,SAASU,UAAT,CAAoBC,YAApB,EAAkCC,aAAlC,EAAiD;AACpD,QAAIC,QAAQF,aAAajJ,IAAzB;AACA,QAAImI,UAAUc,aAAatK,IAAb,CAAkB5D,CAAhC;AACA,QAAIqO,SAASF,cAAclJ,IAA3B;AACA,QAAI8H,YAAY,CAAhB;AACA,QAAIC,eAAeI,OAAnB;AACA,QAAIH,SAASmB,MAAMpS,MAAnB;AACA,QAAIkR,WAAWE,UAAU,CAAzB;AACA,QAAID,YAAY,CAAhB;AACA,WAAOH,eAAeC,MAAtB,EAA8B;AAC1B,aAAK,IAAInR,IAAI,CAAb,EAAgBA,IAAIoR,QAApB,EAA8BpR,GAA9B,EAAmC;AAC/BuS,mBAAOlB,SAAP,IAAoBpQ,KAAKkD,KAAL,CAChB,CAACmO,MAAMrB,SAAN,IAAmBqB,MAAMrB,YAAY,CAAlB,CAAnB,GAA0CqB,MAAMpB,YAAN,CAA1C,GAAgEoB,MAAMpB,eAAe,CAArB,CAAjE,IAA4F,CAD5E,CAApB;AAEAG;AACAJ,wBAAYA,YAAY,CAAxB;AACAC,2BAAeA,eAAe,CAA9B;AACH;AACDD,oBAAYA,YAAYK,OAAxB;AACAJ,uBAAeA,eAAeI,OAA9B;AACH;AACJ;;AAEM,SAASkB,OAAT,CAAiBC,GAAjB,EAAsBC,GAAtB,EAA2B;AAC9B,QAAIC,IAAIF,IAAI,CAAJ,CAAR;AAAA,QACIG,IAAIH,IAAI,CAAJ,CADR;AAAA,QAEI9H,IAAI8H,IAAI,CAAJ,CAFR;AAAA,QAGII,IAAIlI,IAAIiI,CAHZ;AAAA,QAII1O,IAAI2O,KAAK,IAAI5R,KAAKC,GAAL,CAAUyR,IAAI,EAAL,GAAW,CAAX,GAAe,CAAxB,CAAT,CAJR;AAAA,QAKIG,IAAInI,IAAIkI,CALZ;AAAA,QAMIE,IAAI,CANR;AAAA,QAOIC,IAAI,CAPR;AAAA,QAQIC,IAAI,CARR;;AAUAP,UAAMA,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAb;;AAEA,QAAIC,IAAI,EAAR,EAAY;AACRI,YAAIF,CAAJ;AACAG,YAAI9O,CAAJ;AACH,KAHD,MAGO,IAAIyO,IAAI,GAAR,EAAa;AAChBI,YAAI7O,CAAJ;AACA8O,YAAIH,CAAJ;AACH,KAHM,MAGA,IAAIF,IAAI,GAAR,EAAa;AAChBK,YAAIH,CAAJ;AACAI,YAAI/O,CAAJ;AACH,KAHM,MAGA,IAAIyO,IAAI,GAAR,EAAa;AAChBK,YAAI9O,CAAJ;AACA+O,YAAIJ,CAAJ;AACH,KAHM,MAGA,IAAIF,IAAI,GAAR,EAAa;AAChBI,YAAI7O,CAAJ;AACA+O,YAAIJ,CAAJ;AACH,KAHM,MAGA,IAAIF,IAAI,GAAR,EAAa;AAChBI,YAAIF,CAAJ;AACAI,YAAI/O,CAAJ;AACH;AACDwO,QAAI,CAAJ,IAAU,CAACK,IAAID,CAAL,IAAU,GAAX,GAAkB,CAA3B;AACAJ,QAAI,CAAJ,IAAU,CAACM,IAAIF,CAAL,IAAU,GAAX,GAAkB,CAA3B;AACAJ,QAAI,CAAJ,IAAU,CAACO,IAAIH,CAAL,IAAU,GAAX,GAAkB,CAA3B;AACA,WAAOJ,GAAP;AACH;;AAEM,SAASQ,gBAAT,CAA0BC,CAA1B,EAA6B;AAChC,QAAIC,gBAAgB,EAApB;AAAA,QACIC,WAAW,EADf;AAAA,QAEIrT,CAFJ;;AAIA,SAAKA,IAAI,CAAT,EAAYA,IAAIiB,KAAKqS,IAAL,CAAUH,CAAV,IAAe,CAA/B,EAAkCnT,GAAlC,EAAuC;AACnC,YAAImT,IAAInT,CAAJ,KAAU,CAAd,EAAiB;AACbqT,qBAASrR,IAAT,CAAchC,CAAd;AACA,gBAAIA,MAAMmT,IAAInT,CAAd,EAAiB;AACboT,8BAAcjM,OAAd,CAAsBlG,KAAKkD,KAAL,CAAWgP,IAAInT,CAAf,CAAtB;AACH;AACJ;AACJ;AACD,WAAOqT,SAASE,MAAT,CAAgBH,aAAhB,CAAP;AACH;;AAED,SAASI,oBAAT,CAA8BC,IAA9B,EAAoCC,IAApC,EAA0C;AACtC,QAAI1T,IAAI,CAAR;AAAA,QACIiE,IAAI,CADR;AAAA,QAEI7B,SAAS,EAFb;;AAIA,WAAOpC,IAAIyT,KAAKvT,MAAT,IAAmB+D,IAAIyP,KAAKxT,MAAnC,EAA2C;AACvC,YAAIuT,KAAKzT,CAAL,MAAY0T,KAAKzP,CAAL,CAAhB,EAAyB;AACrB7B,mBAAOJ,IAAP,CAAYyR,KAAKzT,CAAL,CAAZ;AACAA;AACAiE;AACH,SAJD,MAIO,IAAIwP,KAAKzT,CAAL,IAAU0T,KAAKzP,CAAL,CAAd,EAAuB;AAC1BA;AACH,SAFM,MAEA;AACHjE;AACH;AACJ;AACD,WAAOoC,MAAP;AACH;;AAEM,SAASuR,kBAAT,CAA4BC,SAA5B,EAAuCC,OAAvC,EAAgD;AACnD,QAAIC,YAAYZ,iBAAiBW,QAAQ3P,CAAzB,CAAhB;AAAA,QACI6P,YAAYb,iBAAiBW,QAAQtL,CAAzB,CADhB;AAAA,QAEIyL,WAAW/S,KAAK6D,GAAL,CAAS+O,QAAQ3P,CAAjB,EAAoB2P,QAAQtL,CAA5B,CAFf;AAAA,QAGI0L,SAAST,qBAAqBM,SAArB,EAAgCC,SAAhC,CAHb;AAAA,QAIIG,kBAAkB,CAAC,CAAD,EAAI,EAAJ,EAAQ,EAAR,EAAY,EAAZ,EAAgB,EAAhB,EAAoB,EAApB,EAAwB,EAAxB,CAJtB;AAAA,QAKIC,iBAAiB;AACb,mBAAW,CADE;AAEb,iBAAS,CAFI;AAGb,kBAAU,CAHG;AAIb,iBAAS,CAJI;AAKb,mBAAW;AALE,KALrB;AAAA,QAYIC,iBAAiBD,eAAeP,SAAf,KAA6BO,eAAeE,MAZjE;AAAA,QAaIC,cAAcJ,gBAAgBE,cAAhB,CAblB;AAAA,QAcIG,mBAAmBtT,KAAKkD,KAAL,CAAW6P,WAAWM,WAAtB,CAdvB;AAAA,QAeIE,gBAfJ;;AAiBA,aAASC,wBAAT,CAAkCpB,QAAlC,EAA4C;AACxC,YAAIrT,IAAI,CAAR;AAAA,YACIqN,QAAQgG,SAASpS,KAAKkD,KAAL,CAAWkP,SAASnT,MAAT,GAAkB,CAA7B,CAAT,CADZ;;AAGA,eAAOF,IAAKqT,SAASnT,MAAT,GAAkB,CAAvB,IAA6BmT,SAASrT,CAAT,IAAcuU,gBAAlD,EAAoE;AAChEvU;AACH;AACD,YAAIA,IAAI,CAAR,EAAW;AACP,gBAAIiB,KAAKC,GAAL,CAASmS,SAASrT,CAAT,IAAcuU,gBAAvB,IAA2CtT,KAAKC,GAAL,CAASmS,SAASrT,IAAI,CAAb,IAAkBuU,gBAA3B,CAA/C,EAA6F;AACzFlH,wBAAQgG,SAASrT,IAAI,CAAb,CAAR;AACH,aAFD,MAEO;AACHqN,wBAAQgG,SAASrT,CAAT,CAAR;AACH;AACJ;AACD,YAAIuU,mBAAmBlH,KAAnB,GAA2B6G,gBAAgBE,iBAAiB,CAAjC,IAAsCF,gBAAgBE,cAAhB,CAAjE,IACAG,mBAAmBlH,KAAnB,GAA2B6G,gBAAgBE,iBAAiB,CAAjC,IAAsCF,gBAAgBE,cAAhB,CADrE,EACuG;AACnG,mBAAO,EAAClQ,GAAGmJ,KAAJ,EAAW9E,GAAG8E,KAAd,EAAP;AACH;AACD,eAAO,IAAP;AACH;;AAEDmH,uBAAmBC,yBAAyBR,MAAzB,CAAnB;AACA,QAAI,CAACO,gBAAL,EAAuB;AACnBA,2BAAmBC,yBAAyBvB,iBAAiBc,QAAjB,CAAzB,CAAnB;AACA,YAAI,CAACQ,gBAAL,EAAuB;AACnBA,+BAAmBC,yBAA0BvB,iBAAiBqB,mBAAmBD,WAApC,CAA1B,CAAnB;AACH;AACJ;AACD,WAAOE,gBAAP;AACH;;AAEM,SAASE,wBAAT,CAAkC5R,KAAlC,EAAyC;AAC5C,QAAI6R,YAAY;AACZ7R,eAAO8R,WAAW9R,KAAX,CADK;AAEZ+R,cAAM/R,MAAMgS,OAAN,CAAc,GAAd,MAAuBhS,MAAM5C,MAAN,GAAe,CAAtC,GAA0C,GAA1C,GAAgD;AAF1C,KAAhB;;AAKA,WAAOyU,SAAP;AACH;;AAEM,IAAMI,wBAAwB;AACjChH,SAAK,aAAS4G,SAAT,EAAoBK,OAApB,EAA6B;AAC9B,YAAIL,UAAUE,IAAV,KAAmB,GAAvB,EAA4B;AACxB,mBAAO5T,KAAKkD,KAAL,CAAW6Q,QAAQ5K,MAAR,IAAkBuK,UAAU7R,KAAV,GAAkB,GAApC,CAAX,CAAP;AACH;AACJ,KALgC;AAMjC2I,WAAO,eAASkJ,SAAT,EAAoBK,OAApB,EAA6B;AAChC,YAAIL,UAAUE,IAAV,KAAmB,GAAvB,EAA4B;AACxB,mBAAO5T,KAAKkD,KAAL,CAAW6Q,QAAQ7K,KAAR,GAAiB6K,QAAQ7K,KAAR,IAAiBwK,UAAU7R,KAAV,GAAkB,GAAnC,CAA5B,CAAP;AACH;AACJ,KAVgC;AAWjCmS,YAAQ,gBAASN,SAAT,EAAoBK,OAApB,EAA6B;AACjC,YAAIL,UAAUE,IAAV,KAAmB,GAAvB,EAA4B;AACxB,mBAAO5T,KAAKkD,KAAL,CAAW6Q,QAAQ5K,MAAR,GAAkB4K,QAAQ5K,MAAR,IAAkBuK,UAAU7R,KAAV,GAAkB,GAApC,CAA7B,CAAP;AACH;AACJ,KAfgC;AAgBjCyI,UAAM,cAASoJ,SAAT,EAAoBK,OAApB,EAA6B;AAC/B,YAAIL,UAAUE,IAAV,KAAmB,GAAvB,EAA4B;AACxB,mBAAO5T,KAAKkD,KAAL,CAAW6Q,QAAQ7K,KAAR,IAAiBwK,UAAU7R,KAAV,GAAkB,GAAnC,CAAX,CAAP;AACH;AACJ;AApBgC,CAA9B;;AAuBA,SAASoS,gBAAT,CAA0BC,UAA1B,EAAsCC,WAAtC,EAAmDC,IAAnD,EAAyD;AAC5D,QAAIL,UAAU,EAAC7K,OAAOgL,UAAR,EAAoB/K,QAAQgL,WAA5B,EAAd;;AAEA,QAAIE,aAAajS,OAAO8B,IAAP,CAAYkQ,IAAZ,EAAkBE,MAAlB,CAAyB,UAASnT,MAAT,EAAiBiD,GAAjB,EAAsB;AAC5D,YAAIvC,QAAQuS,KAAKhQ,GAAL,CAAZ;AAAA,YACImQ,SAASd,yBAAyB5R,KAAzB,CADb;AAAA,YAEI2S,aAAaV,sBAAsB1P,GAAtB,EAA2BmQ,MAA3B,EAAmCR,OAAnC,CAFjB;;AAIA5S,eAAOiD,GAAP,IAAcoQ,UAAd;AACA,eAAOrT,MAAP;AACH,KAPgB,EAOd,EAPc,CAAjB;;AASA,WAAO;AACHsT,YAAIJ,WAAW/J,IADZ;AAEHoK,YAAIL,WAAWvH,GAFZ;AAGH6H,YAAIN,WAAW7J,KAAX,GAAmB6J,WAAW/J,IAH/B;AAIHsK,YAAIP,WAAWL,MAAX,GAAoBK,WAAWvH;AAJhC,KAAP;AAMH,E;;;;;;;;;;AC9uBD;AACA;AACA;AACA,IAAMxE,OAAO;AACTC,WAAO,mBAAAC,CAAQ,CAAR;AADE,CAAb;;AAIA;;;;;;;;;AASA,SAASqM,YAAT,CAAsBhO,IAAtB,EAA4BqB,IAA5B,EAAkC4M,SAAlC,EAA6CC,UAA7C,EAAyD;AACrD,QAAI,CAAC7M,IAAL,EAAW;AACP,YAAI4M,SAAJ,EAAe;AACX,iBAAK5M,IAAL,GAAY,IAAI4M,SAAJ,CAAcjO,KAAK5D,CAAL,GAAS4D,KAAKS,CAA5B,CAAZ;AACA,gBAAIwN,cAAcE,KAAd,IAAuBD,UAA3B,EAAuC;AACnC7S,gBAAA,qEAAAA,CAAYC,IAAZ,CAAiB,KAAK+F,IAAtB,EAA4B,CAA5B;AACH;AACJ,SALD,MAKO;AACH,iBAAKA,IAAL,GAAY,IAAI+I,UAAJ,CAAepK,KAAK5D,CAAL,GAAS4D,KAAKS,CAA7B,CAAZ;AACA,gBAAI2J,eAAe+D,KAAf,IAAwBD,UAA5B,EAAwC;AACpC7S,gBAAA,qEAAAA,CAAYC,IAAZ,CAAiB,KAAK+F,IAAtB,EAA4B,CAA5B;AACH;AACJ;AACJ,KAZD,MAYO;AACH,aAAKA,IAAL,GAAYA,IAAZ;AACH;AACD,SAAKrB,IAAL,GAAYA,IAAZ;AACH;;AAED;;;;;;;AAOAgO,aAAalW,SAAb,CAAuBsW,iBAAvB,GAA2C,UAASC,MAAT,EAAiBC,MAAjB,EAAyB;AAChE,WAAQD,OAAOjS,CAAP,IAAYkS,MAAb,IACCD,OAAO5N,CAAP,IAAY6N,MADb,IAECD,OAAOjS,CAAP,GAAY,KAAK4D,IAAL,CAAU5D,CAAV,GAAckS,MAF3B,IAGCD,OAAO5N,CAAP,GAAY,KAAKT,IAAL,CAAUS,CAAV,GAAc6N,MAHlC;AAIH,CALD;;AAOA;;;;;;;;AAQAN,aAAaO,MAAb,GAAsB,UAAS/D,KAAT,EAAgBpO,CAAhB,EAAmBqE,CAAnB,EAAsB;AACxC,QAAI+N,KAAKrV,KAAKkD,KAAL,CAAWD,CAAX,CAAT;AACA,QAAIqS,KAAKtV,KAAKkD,KAAL,CAAWoE,CAAX,CAAT;AACA,QAAIiO,IAAIlE,MAAMxK,IAAN,CAAW5D,CAAnB;AACA,QAAIuS,OAAOF,KAAKjE,MAAMxK,IAAN,CAAW5D,CAAhB,GAAoBoS,EAA/B;AACA,QAAII,IAAIpE,MAAMnJ,IAAN,CAAWsN,OAAO,CAAlB,CAAR;AACA,QAAIxD,IAAIX,MAAMnJ,IAAN,CAAWsN,OAAO,CAAlB,CAAR;AACA,QAAI5D,IAAIP,MAAMnJ,IAAN,CAAWsN,OAAOD,CAAlB,CAAR;AACA,QAAIG,IAAIrE,MAAMnJ,IAAN,CAAWsN,OAAOD,CAAP,GAAW,CAAtB,CAAR;AACA,QAAII,IAAIF,IAAIzD,CAAZ;AACA/O,SAAKoS,EAAL;AACA/N,SAAKgO,EAAL;;AAEA,QAAInU,SAASnB,KAAKkD,KAAL,CAAWD,KAAKqE,KAAKqO,IAAI/D,CAAJ,GAAQ8D,CAAb,IAAkBC,CAAvB,IAA4BrO,KAAKsK,IAAI6D,CAAT,CAA5B,GAA0CA,CAArD,CAAb;AACA,WAAOtU,MAAP;AACH,CAfD;;AAiBA;;;;AAIA0T,aAAae,UAAb,GAA0B,UAASlG,KAAT,EAAgB;AACtC,QAAI5M,IAAI4M,MAAMzQ,MAAd;AACA,WAAO6D,GAAP,EAAY;AACR4M,cAAM5M,CAAN,IAAW,CAAX;AACH;AACJ,CALD;;AAOA;;;;;;AAMA+R,aAAalW,SAAb,CAAuBkX,QAAvB,GAAkC,UAAS1I,IAAT,EAAetG,IAAf,EAAqB;AACnD,WAAO,IAAI,0DAAJ,CAAasG,IAAb,EAAmBtG,IAAnB,EAAyB,IAAzB,CAAP;AACH,CAFD;;AAIA;;;;;AAKAgO,aAAalW,SAAb,CAAuBmX,cAAvB,GAAwC,UAAS9M,YAAT,EAAuBmE,IAAvB,EAA6B;AACjE,QAAI4I,QAAQ/M,aAAanC,IAAb,CAAkBS,CAA9B;AAAA,QAAiC0O,QAAQhN,aAAanC,IAAb,CAAkB5D,CAA3D;AACA,QAAIA,CAAJ,EAAOqE,CAAP;AACA,SAAMrE,IAAI,CAAV,EAAaA,IAAI+S,KAAjB,EAAwB/S,GAAxB,EAA6B;AACzB,aAAMqE,IAAI,CAAV,EAAaA,IAAIyO,KAAjB,EAAwBzO,GAAxB,EAA6B;AACzB0B,yBAAad,IAAb,CAAkBZ,IAAI0O,KAAJ,GAAY/S,CAA9B,IAAmC,KAAKiF,IAAL,CAAU,CAACiF,KAAK7F,CAAL,GAASA,CAAV,IAAe,KAAKT,IAAL,CAAU5D,CAAzB,GAA6BkK,KAAKlK,CAAlC,GAAsCA,CAAhD,CAAnC;AACH;AACJ;AACJ,CARD;;AAUA4R,aAAalW,SAAb,CAAuBsX,MAAvB,GAAgC,UAASjN,YAAT,EAAuB;AACnD,QAAI/J,SAAS,KAAKiJ,IAAL,CAAUjJ,MAAvB;AAAA,QAA+BiX,UAAU,KAAKhO,IAA9C;AAAA,QAAoDiO,UAAUnN,aAAad,IAA3E;;AAEA,WAAOjJ,QAAP,EAAiB;AACbkX,gBAAQlX,MAAR,IAAkBiX,QAAQjX,MAAR,CAAlB;AACH;AACJ,CAND;;AAQA;;;;;;AAMA4V,aAAalW,SAAb,CAAuByX,GAAvB,GAA6B,UAASnT,CAAT,EAAYqE,CAAZ,EAAe;AACxC,WAAO,KAAKY,IAAL,CAAUZ,IAAI,KAAKT,IAAL,CAAU5D,CAAd,GAAkBA,CAA5B,CAAP;AACH,CAFD;;AAIA;;;;;;AAMA4R,aAAalW,SAAb,CAAuB0X,OAAvB,GAAiC,UAASpT,CAAT,EAAYqE,CAAZ,EAAe;AAC5C,QAAIvI,CAAJ;;AAEA,QAAI,CAAC,KAAKuX,YAAV,EAAwB;AACpB,aAAKA,YAAL,GAAoB;AAChBrT,eAAG,EADa;AAEhBqE,eAAG;AAFa,SAApB;AAIA,aAAKvI,IAAI,CAAT,EAAYA,IAAI,KAAK8H,IAAL,CAAU5D,CAA1B,EAA6BlE,GAA7B,EAAkC;AAC9B,iBAAKuX,YAAL,CAAkBrT,CAAlB,CAAoBlE,CAApB,IAAyBA,CAAzB;AACA,iBAAKuX,YAAL,CAAkBrT,CAAlB,CAAoBlE,IAAI,KAAK8H,IAAL,CAAU5D,CAAlC,IAAuClE,CAAvC;AACH;AACD,aAAKA,IAAI,CAAT,EAAYA,IAAI,KAAK8H,IAAL,CAAUS,CAA1B,EAA6BvI,GAA7B,EAAkC;AAC9B,iBAAKuX,YAAL,CAAkBhP,CAAlB,CAAoBvI,CAApB,IAAyBA,CAAzB;AACA,iBAAKuX,YAAL,CAAkBhP,CAAlB,CAAoBvI,IAAI,KAAK8H,IAAL,CAAUS,CAAlC,IAAuCvI,CAAvC;AACH;AACJ;AACD,WAAO,KAAKmJ,IAAL,CAAW,KAAKoO,YAAL,CAAkBhP,CAAlB,CAAoBA,IAAI,KAAKT,IAAL,CAAUS,CAAlC,CAAD,GAAyC,KAAKT,IAAL,CAAU5D,CAAnD,GAAuD,KAAKqT,YAAL,CAAkBrT,CAAlB,CAAoBA,IAAI,KAAK4D,IAAL,CAAU5D,CAAlC,CAAjE,CAAP;AACH,CAlBD;;AAoBA;;;;;;;AAOA4R,aAAalW,SAAb,CAAuB4X,GAAvB,GAA6B,UAAStT,CAAT,EAAYqE,CAAZ,EAAezF,KAAf,EAAsB;AAC/C,SAAKqG,IAAL,CAAUZ,IAAI,KAAKT,IAAL,CAAU5D,CAAd,GAAkBA,CAA5B,IAAiCpB,KAAjC;AACA,WAAO,IAAP;AACH,CAHD;;AAKA;;;AAGAgT,aAAalW,SAAb,CAAuB6X,UAAvB,GAAoC,YAAW;AAC3C,QAAIzX,CAAJ;AAAA,QAAOmK,QAAQ,KAAKrC,IAAL,CAAU5D,CAAzB;AAAA,QAA4BkG,SAAS,KAAKtC,IAAL,CAAUS,CAA/C;AAAA,QAAkDY,OAAO,KAAKA,IAA9D;AACA,SAAMnJ,IAAI,CAAV,EAAaA,IAAImK,KAAjB,EAAwBnK,GAAxB,EAA6B;AACzBmJ,aAAKnJ,CAAL,IAAUmJ,KAAK,CAACiB,SAAS,CAAV,IAAeD,KAAf,GAAuBnK,CAA5B,IAAiC,CAA3C;AACH;AACD,SAAMA,IAAI,CAAV,EAAaA,IAAIoK,SAAS,CAA1B,EAA6BpK,GAA7B,EAAkC;AAC9BmJ,aAAKnJ,IAAImK,KAAT,IAAkBhB,KAAKnJ,IAAImK,KAAJ,IAAaA,QAAQ,CAArB,CAAL,IAAgC,CAAlD;AACH;AACJ,CARD;;AAUA;;;AAGA2L,aAAalW,SAAb,CAAuB8X,MAAvB,GAAgC,YAAW;AACvC,QAAIvO,OAAO,KAAKA,IAAhB;AAAA,QAAsBjJ,SAASiJ,KAAKjJ,MAApC;;AAEA,WAAOA,QAAP,EAAiB;AACbiJ,aAAKjJ,MAAL,IAAeiJ,KAAKjJ,MAAL,IAAe,CAAf,GAAmB,CAAlC;AACH;AACJ,CAND;;AAQA4V,aAAalW,SAAb,CAAuB+X,QAAvB,GAAkC,UAASnL,MAAT,EAAiB;AAC/C,QAAItI,CAAJ;AAAA,QAAOqE,CAAP;AAAA,QAAUqP,EAAV;AAAA,QAAcC,EAAd;AAAA,QAAkBC,QAAStL,OAAOtM,MAAP,GAAgB,CAAjB,GAAsB,CAAhD;AAAA,QAAmD6X,OAAO,CAA1D;AACA,SAAMxP,IAAI,CAAV,EAAaA,IAAI,KAAKT,IAAL,CAAUS,CAA3B,EAA8BA,GAA9B,EAAmC;AAC/B,aAAMrE,IAAI,CAAV,EAAaA,IAAI,KAAK4D,IAAL,CAAU5D,CAA3B,EAA8BA,GAA9B,EAAmC;AAC/B6T,mBAAO,CAAP;AACA,iBAAMF,KAAK,CAACC,KAAZ,EAAmBD,MAAMC,KAAzB,EAAgCD,IAAhC,EAAsC;AAClC,qBAAMD,KAAK,CAACE,KAAZ,EAAmBF,MAAME,KAAzB,EAAgCF,IAAhC,EAAsC;AAClCG,4BAAQvL,OAAOqL,KAAKC,KAAZ,EAAmBF,KAAKE,KAAxB,IAAiC,KAAKR,OAAL,CAAapT,IAAI0T,EAAjB,EAAqBrP,IAAIsP,EAAzB,CAAzC;AACH;AACJ;AACD,iBAAK1O,IAAL,CAAUZ,IAAI,KAAKT,IAAL,CAAU5D,CAAd,GAAkBA,CAA5B,IAAiC6T,IAAjC;AACH;AACJ;AACJ,CAbD;;AAeAjC,aAAalW,SAAb,CAAuBoY,OAAvB,GAAiC,UAASC,UAAT,EAAqB;AAClD,QAAI9O,OAAO,KAAKA,IAAhB;AAAA,QACIjF,CADJ;AAAA,QAEIqE,CAFJ;AAAA,QAGI6B,SAAS,KAAKtC,IAAL,CAAUS,CAHvB;AAAA,QAII4B,QAAQ,KAAKrC,IAAL,CAAU5D,CAJtB;AAAA,QAKIJ,GALJ;AAAA,QAMIoU,GANJ;AAAA,QAOIC,WAAW,EAPf;AAAA,QAQInY,CARJ;AAAA,QASIoY,KATJ;AAAA,QAUIC,IAVJ;AAAA,QAWIC,IAXJ;AAAA,QAYIC,IAZJ;AAAA,QAaIC,EAbJ;AAAA,QAcIC,EAdJ;AAAA,QAeIjX,GAfJ;AAAA,QAgBIY,SAAS,EAhBb;AAAA,QAiBIsW,KAAKzX,KAAKyX,EAjBd;AAAA,QAkBIC,OAAOD,KAAK,CAlBhB;;AAoBA,QAAIT,cAAc,CAAlB,EAAqB;AACjB,eAAO7V,MAAP;AACH;;AAED,SAAMpC,IAAI,CAAV,EAAaA,IAAIiY,UAAjB,EAA6BjY,GAA7B,EAAkC;AAC9BmY,iBAASnY,CAAT,IAAc;AACV4Y,iBAAK,CADK;AAEVC,iBAAK,CAFK;AAGVC,iBAAK,CAHK;AAIVC,iBAAK,CAJK;AAKVC,iBAAK,CALK;AAMVC,iBAAK,CANK;AAOVC,mBAAO,CAPG;AAQVC,iBAAK;AARK,SAAd;AAUH;;AAED,SAAM5Q,IAAI,CAAV,EAAaA,IAAI6B,MAAjB,EAAyB7B,GAAzB,EAA8B;AAC1B2P,cAAM3P,IAAIA,CAAV;AACA,aAAMrE,IAAI,CAAV,EAAaA,IAAIiG,KAAjB,EAAwBjG,GAAxB,EAA6B;AACzBJ,kBAAMqF,KAAKZ,IAAI4B,KAAJ,GAAYjG,CAAjB,CAAN;AACA,gBAAIJ,MAAM,CAAV,EAAa;AACTsU,wBAAQD,SAASrU,MAAM,CAAf,CAAR;AACAsU,sBAAMQ,GAAN,IAAa,CAAb;AACAR,sBAAMS,GAAN,IAAatQ,CAAb;AACA6P,sBAAMU,GAAN,IAAa5U,CAAb;AACAkU,sBAAMW,GAAN,IAAa7U,IAAIqE,CAAjB;AACA6P,sBAAMY,GAAN,IAAad,GAAb;AACAE,sBAAMa,GAAN,IAAa/U,IAAIA,CAAjB;AACH;AACJ;AACJ;;AAED,SAAMlE,IAAI,CAAV,EAAaA,IAAIiY,UAAjB,EAA6BjY,GAA7B,EAAkC;AAC9BoY,gBAAQD,SAASnY,CAAT,CAAR;AACA,YAAI,CAACoZ,MAAMhB,MAAMQ,GAAZ,CAAD,IAAqBR,MAAMQ,GAAN,KAAc,CAAvC,EAA0C;AACtCJ,iBAAKJ,MAAMU,GAAN,GAAYV,MAAMQ,GAAvB;AACAH,iBAAKL,MAAMS,GAAN,GAAYT,MAAMQ,GAAvB;AACAP,mBAAOD,MAAMW,GAAN,GAAYX,MAAMQ,GAAlB,GAAwBJ,KAAKC,EAApC;AACAH,mBAAOF,MAAMY,GAAN,GAAYZ,MAAMQ,GAAlB,GAAwBH,KAAKA,EAApC;AACAF,mBAAOH,MAAMa,GAAN,GAAYb,MAAMQ,GAAlB,GAAwBJ,KAAKA,EAApC;AACAhX,kBAAM,CAAC8W,OAAOC,IAAR,KAAiB,IAAIF,IAArB,CAAN;AACA7W,kBAAM,MAAMP,KAAKoY,IAAL,CAAU7X,GAAV,CAAN,IAAwB6W,QAAQ,CAAR,GAAYM,IAAZ,GAAmB,CAACA,IAA5C,IAAqDD,EAA3D;AACAN,kBAAMc,KAAN,GAAc,CAAC1X,MAAM,GAAN,GAAYkX,EAAZ,GAAiB,EAAlB,IAAwB,GAAxB,GAA8B,EAA5C;AACA,gBAAIN,MAAMc,KAAN,GAAc,CAAlB,EAAqB;AACjBd,sBAAMc,KAAN,IAAe,GAAf;AACH;AACDd,kBAAMe,GAAN,GAAY3X,MAAMkX,EAAN,GAAWlX,MAAMkX,EAAjB,GAAsBlX,GAAlC;AACA4W,kBAAMxK,GAAN,GAAYrE,KAAKC,KAAL,CAAW,CAACvI,KAAKqY,GAAL,CAAS9X,GAAT,CAAD,EAAgBP,KAAKsY,GAAL,CAAS/X,GAAT,CAAhB,CAAX,CAAZ;AACAY,mBAAOJ,IAAP,CAAYoW,KAAZ;AACH;AACJ;;AAED,WAAOhW,MAAP;AACH,CA3ED;;AA6EA;;;;;AAKA0T,aAAalW,SAAb,CAAuB4Z,IAAvB,GAA8B,UAAS7H,MAAT,EAAiB8H,KAAjB,EAAwB;AAClD,QAAI1R,GAAJ,EACI2R,KADJ,EAEIvQ,IAFJ,EAGIwQ,OAHJ,EAIIC,KAJJ,EAKI1V,CALJ,EAMIqE,CANJ;;AAQA,QAAI,CAACkR,KAAL,EAAY;AACRA,gBAAQ,GAAR;AACH;AACD1R,UAAM4J,OAAOM,UAAP,CAAkB,IAAlB,CAAN;AACAN,WAAOxH,KAAP,GAAe,KAAKrC,IAAL,CAAU5D,CAAzB;AACAyN,WAAOvH,MAAP,GAAgB,KAAKtC,IAAL,CAAUS,CAA1B;AACAmR,YAAQ3R,IAAImB,YAAJ,CAAiB,CAAjB,EAAoB,CAApB,EAAuByI,OAAOxH,KAA9B,EAAqCwH,OAAOvH,MAA5C,CAAR;AACAjB,WAAOuQ,MAAMvQ,IAAb;AACAwQ,cAAU,CAAV;AACA,SAAKpR,IAAI,CAAT,EAAYA,IAAI,KAAKT,IAAL,CAAUS,CAA1B,EAA6BA,GAA7B,EAAkC;AAC9B,aAAKrE,IAAI,CAAT,EAAYA,IAAI,KAAK4D,IAAL,CAAU5D,CAA1B,EAA6BA,GAA7B,EAAkC;AAC9B0V,oBAAQrR,IAAI,KAAKT,IAAL,CAAU5D,CAAd,GAAkBA,CAA1B;AACAyV,sBAAU,KAAKtC,GAAL,CAASnT,CAAT,EAAYqE,CAAZ,IAAiBkR,KAA3B;AACAtQ,iBAAKyQ,QAAQ,CAAR,GAAY,CAAjB,IAAsBD,OAAtB;AACAxQ,iBAAKyQ,QAAQ,CAAR,GAAY,CAAjB,IAAsBD,OAAtB;AACAxQ,iBAAKyQ,QAAQ,CAAR,GAAY,CAAjB,IAAsBD,OAAtB;AACAxQ,iBAAKyQ,QAAQ,CAAR,GAAY,CAAjB,IAAsB,GAAtB;AACH;AACJ;AACD;AACA7R,QAAIuB,YAAJ,CAAiBoQ,KAAjB,EAAwB,CAAxB,EAA2B,CAA3B;AACH,CA9BD;;AAgCA;;;;;AAKA5D,aAAalW,SAAb,CAAuBia,OAAvB,GAAiC,UAASlI,MAAT,EAAiB8H,KAAjB,EAAwBrL,IAAxB,EAA8B;AAC3D,QAAI,CAACqL,KAAD,IAAUA,QAAQ,CAAlB,IAAuBA,QAAQ,GAAnC,EAAwC;AACpCA,gBAAQ,GAAR;AACH;AACD,QAAIhH,MAAM,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAV;AACA,QAAIC,MAAM,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAV;AACA,QAAIoH,WAAW,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAAf;AACA,QAAIC,WAAW,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAf;AACA,QAAI3X,SAAS,EAAb;AACA,QAAI2F,MAAM4J,OAAOM,UAAP,CAAkB,IAAlB,CAAV;AACA,QAAIyH,QAAQ3R,IAAImB,YAAJ,CAAiBkF,KAAKlK,CAAtB,EAAyBkK,KAAK7F,CAA9B,EAAiC,KAAKT,IAAL,CAAU5D,CAA3C,EAA8C,KAAK4D,IAAL,CAAUS,CAAxD,CAAZ;AACA,QAAIY,OAAOuQ,MAAMvQ,IAAjB;AACA,QAAIjJ,SAAS,KAAKiJ,IAAL,CAAUjJ,MAAvB;AACA,WAAOA,QAAP,EAAiB;AACbuS,YAAI,CAAJ,IAAS,KAAKtJ,IAAL,CAAUjJ,MAAV,IAAoBuZ,KAA7B;AACArX,iBAASqQ,IAAI,CAAJ,KAAU,CAAV,GAAcqH,QAAd,GAAyBrH,IAAI,CAAJ,KAAU,GAAV,GAAgBsH,QAAhB,GAA2B,wFAAAvH,CAAQC,GAAR,EAAaC,GAAb,CAA7D;AACAvJ,aAAKjJ,SAAS,CAAT,GAAa,CAAlB,IAAuBkC,OAAO,CAAP,CAAvB;AACA+G,aAAKjJ,SAAS,CAAT,GAAa,CAAlB,IAAuBkC,OAAO,CAAP,CAAvB;AACA+G,aAAKjJ,SAAS,CAAT,GAAa,CAAlB,IAAuBkC,OAAO,CAAP,CAAvB;AACA+G,aAAKjJ,SAAS,CAAT,GAAa,CAAlB,IAAuB,GAAvB;AACH;AACD6H,QAAIuB,YAAJ,CAAiBoQ,KAAjB,EAAwBtL,KAAKlK,CAA7B,EAAgCkK,KAAK7F,CAArC;AACH,CAtBD;;AAwBA,wDAAeuN,YAAf,C;;;;;;AC5VA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,EAAE;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;;AAEA;;;;;;;ACxBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChBA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,cAAc;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChCA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AClCA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5BA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA,YAAY,SAAS,GAAG,SAAS;AACjC;AACA;AACA;AACA,YAAY,SAAS,GAAG,SAAS;AACjC;AACA;AACA;AACA,UAAU,QAAQ,i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CA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,EAAE;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC3BA;;AAEA;AACA;AACA;AACA,WAAW,QAAQ;AACnB;AACA,GAAG;AACH,CAAC;;AAED;;;;;;;ACVA;AACA;;AAEA;;;;;;;;ACHA;;AAEA;AACA;;AAEA;;;;;;;ACLA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACjBA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnCA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;;AAEA;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,EAAE;AACf;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;ACrCA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC1BA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;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hBA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,C;;;;;;ACdA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC1BA;;AAEA;AACA;;AAEA;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,EAAE;AACb,WAAW,MAAM;AACjB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,QAAQ;AACnB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChDA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,SAAS;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;;;;;;AC7BA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACrCA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;;AAEA;;;;;;;ACfA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,aAAa,EAAE;AACf;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACvBA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACZA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,oCAAoC;;AAEpC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC9CA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC3DA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChCA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5FA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;AClBA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7BA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;AChBA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,WAAW,EAAE;AACb,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC9CA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpCA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACbA;;AAEA;AACA;AACA;AACA;AACA,WAAW,YAAY;AACvB,aAAa,YAAY;AACzB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;AClCA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,MAAM;AACjB,WAAW,OAAO,WAAW;AAC7B,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA,wBAAwB;;AAExB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACvCA;;AAEA;AACA;;AAEA;;;;;;;ACLA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;ACpCA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACxBA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7CA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACtCA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChBA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7BA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACtBA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACtBA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,EAAE;AACb,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7BA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5BA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;;AAEA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACZA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AClCA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;AClBA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpBA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACfA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACnBA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH,CAAC;;AAED;;;;;;;;ACrBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACpCA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;ACbA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjCA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA,CAAC;;AAED;;;;;;;AC3BA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;;;;;;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACzBA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACrBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,aAAa;AACxB,aAAa,QAAQ;AACrB;AACA;AACA,0BAA0B,gBAAgB,SAAS,GAAG;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AChCA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC7DA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA,iBAAiB;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;ACxEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,qBAAqB;AAChC,aAAa,OAAO;AACpB;AACA;AACA,iBAAiB;AACjB;AACA;AACA,UAAU;AACV;AACA;AACA,4BAA4B;AAC5B,CAAC;;AAED;;;;;;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;ACjBA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB,UAAU;AACV;AACA,aAAa,SAAS;AACtB,UAAU;AACV;AACA;AACA;AACA;;AAEA;;;;;;;AC/BA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA","file":"quagga.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(factory.toString()).default;\n\telse if(typeof exports === 'object')\n\t\texports[\"Quagga\"] = factory(factory.toString()).default;\n\telse\n\t\troot[\"Quagga\"] = factory(factory.toString()).default;\n})(this, function(__factorySource__) {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/myModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 166);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 7560cc4927231b2e3789","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isObject.js\n// module id = 0\n// module chunks = 0","import ArrayHelper from '../common/array_helper';\n\nfunction BarcodeReader(config, supplements) {\n    this._row = [];\n    this.config = config || {};\n    this.supplements = supplements;\n    return this;\n}\n\nBarcodeReader.prototype._nextUnset = function(line, start) {\n    var i;\n\n    if (start === undefined) {\n        start = 0;\n    }\n    for (i = start; i < line.length; i++) {\n        if (!line[i]) {\n            return i;\n        }\n    }\n    return line.length;\n};\n\nBarcodeReader.prototype._matchPattern = function(counter, code, maxSingleError) {\n    var i,\n        error = 0,\n        singleError = 0,\n        sum = 0,\n        modulo = 0,\n        barWidth,\n        count,\n        scaled;\n\n    maxSingleError = maxSingleError || this.SINGLE_CODE_ERROR || 1;\n\n    for (i = 0; i < counter.length; i++) {\n        sum += counter[i];\n        modulo += code[i];\n    }\n    if (sum < modulo) {\n        return Number.MAX_VALUE;\n    }\n    barWidth = sum / modulo;\n    maxSingleError *= barWidth;\n\n    for (i = 0; i < counter.length; i++) {\n        count = counter[i];\n        scaled = code[i] * barWidth;\n        singleError = Math.abs(count - scaled) / scaled;\n        if (singleError > maxSingleError) {\n            return Number.MAX_VALUE;\n        }\n        error += singleError;\n    }\n    return error / modulo;\n};\n\nBarcodeReader.prototype._nextSet = function(line, offset) {\n    var i;\n\n    offset = offset || 0;\n    for (i = offset; i < line.length; i++) {\n        if (line[i]) {\n            return i;\n        }\n    }\n    return line.length;\n};\n\nBarcodeReader.prototype._correctBars = function(counter, correction, indices) {\n    var length = indices.length,\n        tmp = 0;\n    while(length--) {\n        tmp = counter[indices[length]] * (1 - ((1 - correction) / 2));\n        if (tmp > 1) {\n            counter[indices[length]] = tmp;\n        }\n    }\n}\n\nBarcodeReader.prototype._matchTrace = function(cmpCounter, epsilon) {\n    var counter = [],\n        i,\n        self = this,\n        offset = self._nextSet(self._row),\n        isWhite = !self._row[offset],\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0\n        },\n        error;\n\n    if (cmpCounter) {\n        for ( i = 0; i < cmpCounter.length; i++) {\n            counter.push(0);\n        }\n        for ( i = offset; i < self._row.length; i++) {\n            if (self._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    error = self._matchPattern(counter, cmpCounter);\n\n                    if (error < epsilon) {\n                        bestMatch.start = i - offset;\n                        bestMatch.end = i;\n                        bestMatch.counter = counter;\n                        return bestMatch;\n                    } else {\n                        return null;\n                    }\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = !isWhite;\n            }\n        }\n    } else {\n        counter.push(0);\n        for ( i = offset; i < self._row.length; i++) {\n            if (self._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                counterPos++;\n                counter.push(0);\n                counter[counterPos] = 1;\n                isWhite = !isWhite;\n            }\n        }\n    }\n\n    // if cmpCounter was not given\n    bestMatch.start = offset;\n    bestMatch.end = self._row.length - 1;\n    bestMatch.counter = counter;\n    return bestMatch;\n};\n\nBarcodeReader.prototype.decodePattern = function(pattern) {\n    var self = this,\n        result;\n\n    self._row = pattern;\n    result = self._decode();\n    if (result === null) {\n        self._row.reverse();\n        result = self._decode();\n        if (result) {\n            result.direction = BarcodeReader.DIRECTION.REVERSE;\n            result.start = self._row.length - result.start;\n            result.end = self._row.length - result.end;\n        }\n    } else {\n        result.direction = BarcodeReader.DIRECTION.FORWARD;\n    }\n    if (result) {\n        result.format = self.FORMAT;\n    }\n    return result;\n};\n\nBarcodeReader.prototype._matchRange = function(start, end, value) {\n    var i;\n\n    start = start < 0 ? 0 : start;\n    for (i = start; i < end; i++) {\n        if (this._row[i] !== value) {\n            return false;\n        }\n    }\n    return true;\n};\n\nBarcodeReader.prototype._fillCounters = function(offset, end, isWhite) {\n    var self = this,\n        counterPos = 0,\n        i,\n        counters = [];\n\n    isWhite = (typeof isWhite !== 'undefined') ? isWhite : true;\n    offset = (typeof offset !== 'undefined') ? offset : self._nextUnset(self._row);\n    end = end || self._row.length;\n\n    counters[counterPos] = 0;\n    for (i = offset; i < end; i++) {\n        if (self._row[i] ^ isWhite) {\n            counters[counterPos]++;\n        } else {\n            counterPos++;\n            counters[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return counters;\n};\n\nBarcodeReader.prototype._toCounters = function(start, counter) {\n    var self = this,\n        numCounters = counter.length,\n        end = self._row.length,\n        isWhite = !self._row[start],\n        i,\n        counterPos = 0;\n\n    ArrayHelper.init(counter, 0);\n\n    for ( i = start; i < end; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            counterPos++;\n            if (counterPos === numCounters) {\n                break;\n            } else {\n                counter[counterPos] = 1;\n                isWhite = !isWhite;\n            }\n        }\n    }\n\n    return counter;\n};\n\nObject.defineProperty(BarcodeReader.prototype, \"FORMAT\", {\n    value: 'unknown',\n    writeable: false\n});\n\nBarcodeReader.DIRECTION = {\n    FORWARD: 1,\n    REVERSE: -1\n};\n\nBarcodeReader.Exception = {\n    StartNotFoundException: \"Start-Info was not found!\",\n    CodeNotFoundException: \"Code could not be found!\",\n    PatternNotFoundException: \"Pattern could not be found!\"\n};\n\nBarcodeReader.CONFIG_KEYS = {};\n\nexport default BarcodeReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/barcode_reader.js","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isArray.js\n// module id = 2\n// module chunks = 0","export default {\n    init: function(arr, val) {\n        var l = arr.length;\n        while (l--) {\n            arr[l] = val;\n        }\n    },\n\n    /**\n     * Shuffles the content of an array\n     * @return {Array} the array itself shuffled\n     */\n    shuffle: function(arr) {\n        var i = arr.length - 1, j, x;\n        for (i; i >= 0; i--) {\n            j = Math.floor(Math.random() * i);\n            x = arr[i];\n            arr[i] = arr[j];\n            arr[j] = x;\n        }\n        return arr;\n    },\n\n    toPointList: function(arr) {\n        var i, j, row = [], rows = [];\n        for ( i = 0; i < arr.length; i++) {\n            row = [];\n            for ( j = 0; j < arr[i].length; j++) {\n                row[j] = arr[i][j];\n            }\n            rows[i] = \"[\" + row.join(\",\") + \"]\";\n        }\n        return \"[\" + rows.join(\",\\r\\n\") + \"]\";\n    },\n\n    /**\n     * returns the elements which's score is bigger than the threshold\n     * @return {Array} the reduced array\n     */\n    threshold: function(arr, threshold, scoreFunc) {\n        var i, queue = [];\n        for ( i = 0; i < arr.length; i++) {\n            if (scoreFunc.apply(arr, [arr[i]]) >= threshold) {\n                queue.push(arr[i]);\n            }\n        }\n        return queue;\n    },\n\n    maxIndex: function(arr) {\n        var i, max = 0;\n        for ( i = 0; i < arr.length; i++) {\n            if (arr[i] > arr[max]) {\n                max = i;\n            }\n        }\n        return max;\n    },\n\n    max: function(arr) {\n        var i, max = 0;\n        for ( i = 0; i < arr.length; i++) {\n            if (arr[i] > max) {\n                max = arr[i];\n            }\n        }\n        return max;\n    },\n\n    sum: function(arr) {\n        var length = arr.length,\n            sum = 0;\n\n        while (length--) {\n            sum += arr[length];\n        }\n        return sum;\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/array_helper.js","import BarcodeReader from './barcode_reader';\nimport {merge} from 'lodash';\n\nfunction EANReader(opts, supplements) {\n    opts = merge(getDefaulConfig(), opts);\n    BarcodeReader.call(this, opts, supplements);\n}\n\nfunction getDefaulConfig() {\n    var config = {};\n\n    Object.keys(EANReader.CONFIG_KEYS).forEach(function(key) {\n        config[key] = EANReader.CONFIG_KEYS[key].default;\n    });\n    return config;\n}\n\nvar properties = {\n    CODE_L_START: {value: 0},\n    CODE_G_START: {value: 10},\n    START_PATTERN: {value: [1, 1, 1]},\n    STOP_PATTERN: {value: [1, 1, 1]},\n    MIDDLE_PATTERN: {value: [1, 1, 1, 1, 1]},\n    EXTENSION_START_PATTERN: {value: [1, 1, 2]},\n    CODE_PATTERN: {value: [\n        [3, 2, 1, 1],\n        [2, 2, 2, 1],\n        [2, 1, 2, 2],\n        [1, 4, 1, 1],\n        [1, 1, 3, 2],\n        [1, 2, 3, 1],\n        [1, 1, 1, 4],\n        [1, 3, 1, 2],\n        [1, 2, 1, 3],\n        [3, 1, 1, 2],\n        [1, 1, 2, 3],\n        [1, 2, 2, 2],\n        [2, 2, 1, 2],\n        [1, 1, 4, 1],\n        [2, 3, 1, 1],\n        [1, 3, 2, 1],\n        [4, 1, 1, 1],\n        [2, 1, 3, 1],\n        [3, 1, 2, 1],\n        [2, 1, 1, 3]\n    ]},\n    CODE_FREQUENCY: {value: [0, 11, 13, 14, 19, 25, 28, 21, 22, 26]},\n    SINGLE_CODE_ERROR: {value: 0.70},\n    AVG_CODE_ERROR: {value: 0.48},\n    FORMAT: {value: \"ean_13\", writeable: false}\n};\n\nEANReader.prototype = Object.create(BarcodeReader.prototype, properties);\nEANReader.prototype.constructor = EANReader;\n\nEANReader.prototype._decodeCode = function(start, coderange) {\n    var counter = [0, 0, 0, 0],\n        i,\n        self = this,\n        offset = start,\n        isWhite = !self._row[offset],\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: start,\n            end: start\n        },\n        code,\n        error;\n\n    if (!coderange) {\n        coderange = self.CODE_PATTERN.length;\n    }\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                for (code = 0; code < coderange; code++) {\n                    error = self._matchPattern(counter, self.CODE_PATTERN[code]);\n                    if (error < bestMatch.error) {\n                        bestMatch.code = code;\n                        bestMatch.error = error;\n                    }\n                }\n                bestMatch.end = i;\n                if (bestMatch.error > self.AVG_CODE_ERROR) {\n                    return null;\n                }\n                return bestMatch;\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._findPattern = function(pattern, offset, isWhite, tryHarder, epsilon) {\n    var counter = [],\n        self = this,\n        i,\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        },\n        error,\n        j,\n        sum;\n\n    if (!offset) {\n        offset = self._nextSet(self._row);\n    }\n\n    if (isWhite === undefined) {\n        isWhite = false;\n    }\n\n    if (tryHarder === undefined) {\n        tryHarder = true;\n    }\n\n    if ( epsilon === undefined) {\n        epsilon = self.AVG_CODE_ERROR;\n    }\n\n    for ( i = 0; i < pattern.length; i++) {\n        counter[i] = 0;\n    }\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                sum = 0;\n                for ( j = 0; j < counter.length; j++) {\n                    sum += counter[j];\n                }\n                error = self._matchPattern(counter, pattern);\n\n                if (error < epsilon) {\n                    bestMatch.error = error;\n                    bestMatch.start = i - sum;\n                    bestMatch.end = i;\n                    return bestMatch;\n                }\n                if (tryHarder) {\n                    for ( j = 0; j < counter.length - 2; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[counter.length - 2] = 0;\n                    counter[counter.length - 1] = 0;\n                    counterPos--;\n                } else {\n                    return null;\n                }\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._findStart = function() {\n    var self = this,\n        leadingWhitespaceStart,\n        offset = self._nextSet(self._row),\n        startInfo;\n\n    while (!startInfo) {\n        startInfo = self._findPattern(self.START_PATTERN, offset);\n        if (!startInfo) {\n            return null;\n        }\n        leadingWhitespaceStart = startInfo.start - (startInfo.end - startInfo.start);\n        if (leadingWhitespaceStart >= 0) {\n            if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                return startInfo;\n            }\n        }\n        offset = startInfo.end;\n        startInfo = null;\n    }\n};\n\nEANReader.prototype._verifyTrailingWhitespace = function(endInfo) {\n    var self = this,\n        trailingWhitespaceEnd;\n\n    trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start);\n    if (trailingWhitespaceEnd < self._row.length) {\n        if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n            return endInfo;\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._findEnd = function(offset, isWhite) {\n    var self = this,\n        endInfo = self._findPattern(self.STOP_PATTERN, offset, isWhite, false);\n\n    return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;\n};\n\nEANReader.prototype._calculateFirstDigit = function(codeFrequency) {\n    var i,\n        self = this;\n\n    for ( i = 0; i < self.CODE_FREQUENCY.length; i++) {\n        if (codeFrequency === self.CODE_FREQUENCY[i]) {\n            return i;\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._decodePayload = function(code, result, decodedCodes) {\n    var i,\n        self = this,\n        codeFrequency = 0x0,\n        firstDigit;\n\n    for ( i = 0; i < 6; i++) {\n        code = self._decodeCode(code.end);\n        if (!code) {\n            return null;\n        }\n        if (code.code >= self.CODE_G_START) {\n            code.code = code.code - self.CODE_G_START;\n            codeFrequency |= 1 << (5 - i);\n        } else {\n            codeFrequency |= 0 << (5 - i);\n        }\n        result.push(code.code);\n        decodedCodes.push(code);\n    }\n\n    firstDigit = self._calculateFirstDigit(codeFrequency);\n    if (firstDigit === null) {\n        return null;\n    }\n    result.unshift(firstDigit);\n\n    code = self._findPattern(self.MIDDLE_PATTERN, code.end, true, false);\n    if (code === null) {\n        return null;\n    }\n    decodedCodes.push(code);\n\n    for ( i = 0; i < 6; i++) {\n        code = self._decodeCode(code.end, self.CODE_G_START);\n        if (!code) {\n            return null;\n        }\n        decodedCodes.push(code);\n        result.push(code.code);\n    }\n\n    return code;\n};\n\nEANReader.prototype._decode = function() {\n    var startInfo,\n        self = this,\n        code,\n        result = [],\n        decodedCodes = [],\n        resultInfo = {};\n\n    startInfo = self._findStart();\n    if (!startInfo) {\n        return null;\n    }\n    code = {\n        code: startInfo.code,\n        start: startInfo.start,\n        end: startInfo.end\n    };\n    decodedCodes.push(code);\n    code = self._decodePayload(code, result, decodedCodes);\n    if (!code) {\n        return null;\n    }\n    code = self._findEnd(code.end, false);\n    if (!code){\n        return null;\n    }\n\n    decodedCodes.push(code);\n\n    // Checksum\n    if (!self._checksum(result)) {\n        return null;\n    }\n\n    if (this.supplements.length > 0) {\n        let ext = this._decodeExtensions(code.end);\n        if (!ext) {\n            return null;\n        }\n        let lastCode = ext.decodedCodes[ext.decodedCodes.length-1],\n            endInfo = {\n                start: lastCode.start + (((lastCode.end - lastCode.start) / 2) | 0),\n                end: lastCode.end\n            };\n        if(!self._verifyTrailingWhitespace(endInfo)) {\n            return null;\n        }\n        resultInfo = {\n            supplement: ext,\n            code: result.join(\"\") + ext.code\n        }\n    }\n\n    return {\n        code: result.join(\"\"),\n        start: startInfo.start,\n        end: code.end,\n        codeset: \"\",\n        startInfo: startInfo,\n        decodedCodes: decodedCodes,\n        ...resultInfo\n    };\n};\n\nEANReader.prototype._decodeExtensions = function(offset) {\n    var i,\n        start = this._nextSet(this._row, offset),\n        startInfo = this._findPattern(this.EXTENSION_START_PATTERN, start, false, false),\n        result;\n\n    if (startInfo === null) {\n        return null;\n    }\n\n    for (i = 0; i < this.supplements.length; i++) {\n        result = this.supplements[i].decode(this._row, startInfo.end);\n        if (result !== null) {\n            return {\n                code: result.code,\n                start,\n                startInfo,\n                end: result.end,\n                codeset: \"\",\n                decodedCodes: result.decodedCodes\n            }\n        }\n    }\n    return null;\n};\n\nEANReader.prototype._checksum = function(result) {\n    var sum = 0, i;\n\n    for ( i = result.length - 2; i >= 0; i -= 2) {\n        sum += result[i];\n    }\n    sum *= 3;\n    for ( i = result.length - 1; i >= 0; i -= 2) {\n        sum += result[i];\n    }\n    return sum % 10 === 0;\n};\n\nEANReader.CONFIG_KEYS = {\n    supplements: {\n        'type': 'arrayOf(string)',\n        'default': [],\n        'description': 'Allowed extensions to be decoded (2 and/or 5)'\n    }\n};\n\nexport default (EANReader);\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/ean_reader.js","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_root.js\n// module id = 5\n// module chunks = 0","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isObjectLike.js\n// module id = 6\n// module chunks = 0","module.exports = clone\n\n/**\n * Creates a new vec2 initialized with values from an existing vector\n *\n * @param {vec2} a vector to clone\n * @returns {vec2} a new 2D vector\n */\nfunction clone(a) {\n    var out = new Float32Array(2)\n    out[0] = a[0]\n    out[1] = a[1]\n    return out\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec2/clone.js\n// module id = 7\n// module chunks = 0","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseGetTag.js\n// module id = 8\n// module chunks = 0","export default {\n    drawRect: function(pos, size, ctx, style){\n        ctx.strokeStyle = style.color;\n        ctx.fillStyle = style.color;\n        ctx.lineWidth = 1;\n        ctx.beginPath();\n        ctx.strokeRect(pos.x, pos.y, size.x, size.y);\n    },\n    drawPath: function(path, def, ctx, style) {\n        ctx.strokeStyle = style.color;\n        ctx.fillStyle = style.color;\n        ctx.lineWidth = style.lineWidth;\n        ctx.beginPath();\n        ctx.moveTo(path[0][def.x], path[0][def.y]);\n        for (var j = 1; j < path.length; j++) {\n            ctx.lineTo(path[j][def.x], path[j][def.y]);\n        }\n        ctx.closePath();\n        ctx.stroke();\n    },\n    drawImage: function(imageData, size, ctx) {\n        var canvasData = ctx.getImageData(0, 0, size.x, size.y),\n            data = canvasData.data,\n            imageDataPos = imageData.length,\n            canvasDataPos = data.length,\n            value;\n\n        if (canvasDataPos / imageDataPos !== 4) {\n            return false;\n        }\n        while (imageDataPos--){\n            value = imageData[imageDataPos];\n            data[--canvasDataPos] = 255;\n            data[--canvasDataPos] = value;\n            data[--canvasDataPos] = value;\n            data[--canvasDataPos] = value;\n        }\n        ctx.putImageData(canvasData, 0, 0);\n        return true;\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/image_debug.js","var listCacheClear = require('./_listCacheClear'),\n    listCacheDelete = require('./_listCacheDelete'),\n    listCacheGet = require('./_listCacheGet'),\n    listCacheHas = require('./_listCacheHas'),\n    listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_ListCache.js\n// module id = 10\n// module chunks = 0","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Symbol.js\n// module id = 11\n// module chunks = 0","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = assocIndexOf;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_assocIndexOf.js\n// module id = 12\n// module chunks = 0","var isArray = require('./isArray'),\n    isKey = require('./_isKey'),\n    stringToPath = require('./_stringToPath'),\n    toString = require('./toString');\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n  if (isArray(value)) {\n    return value;\n  }\n  return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nmodule.exports = castPath;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_castPath.js\n// module id = 13\n// module chunks = 0","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nmodule.exports = getMapData;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getMapData.js\n// module id = 14\n// module chunks = 0","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isIndex.js\n// module id = 15\n// module chunks = 0","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_nativeCreate.js\n// module id = 16\n// module chunks = 0","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/eq.js\n// module id = 17\n// module chunks = 0","var baseIsArguments = require('./_baseIsArguments'),\n    isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isArguments.js\n// module id = 18\n// module chunks = 0","import Cluster2 from './cluster';\nimport ArrayHelper from './array_helper';\nconst vec2 = {\n    clone: require('gl-vec2/clone'),\n};\nconst vec3 = {\n    clone: require('gl-vec3/clone'),\n};\n\n/**\n * @param x x-coordinate\n * @param y y-coordinate\n * @return ImageReference {x,y} Coordinate\n */\nexport function imageRef(x, y) {\n    var that = {\n        x: x,\n        y: y,\n        toVec2: function() {\n            return vec2.clone([this.x, this.y]);\n        },\n        toVec3: function() {\n            return vec3.clone([this.x, this.y, 1]);\n        },\n        round: function() {\n            this.x = this.x > 0.0 ? Math.floor(this.x + 0.5) : Math.floor(this.x - 0.5);\n            this.y = this.y > 0.0 ? Math.floor(this.y + 0.5) : Math.floor(this.y - 0.5);\n            return this;\n        }\n    };\n    return that;\n};\n\n/**\n * Computes an integral image of a given grayscale image.\n * @param imageDataContainer {ImageDataContainer} the image to be integrated\n */\nexport function computeIntegralImage2(imageWrapper, integralWrapper) {\n    var imageData = imageWrapper.data;\n    var width = imageWrapper.size.x;\n    var height = imageWrapper.size.y;\n    var integralImageData = integralWrapper.data;\n    var sum = 0, posA = 0, posB = 0, posC = 0, posD = 0, x, y;\n\n    // sum up first column\n    posB = width;\n    sum = 0;\n    for ( y = 1; y < height; y++) {\n        sum += imageData[posA];\n        integralImageData[posB] += sum;\n        posA += width;\n        posB += width;\n    }\n\n    posA = 0;\n    posB = 1;\n    sum = 0;\n    for ( x = 1; x < width; x++) {\n        sum += imageData[posA];\n        integralImageData[posB] += sum;\n        posA++;\n        posB++;\n    }\n\n    for ( y = 1; y < height; y++) {\n        posA = y * width + 1;\n        posB = (y - 1) * width + 1;\n        posC = y * width;\n        posD = (y - 1) * width;\n        for ( x = 1; x < width; x++) {\n            integralImageData[posA] +=\n                imageData[posA] + integralImageData[posB] + integralImageData[posC] - integralImageData[posD];\n            posA++;\n            posB++;\n            posC++;\n            posD++;\n        }\n    }\n};\n\nexport function computeIntegralImage(imageWrapper, integralWrapper) {\n    var imageData = imageWrapper.data;\n    var width = imageWrapper.size.x;\n    var height = imageWrapper.size.y;\n    var integralImageData = integralWrapper.data;\n    var sum = 0;\n\n    // sum up first row\n    for (var i = 0; i < width; i++) {\n        sum += imageData[i];\n        integralImageData[i] = sum;\n    }\n\n    for (var v = 1; v < height; v++) {\n        sum = 0;\n        for (var u = 0; u < width; u++) {\n            sum += imageData[v * width + u];\n            integralImageData[((v) * width) + u] = sum + integralImageData[(v - 1) * width + u];\n        }\n    }\n};\n\nexport function thresholdImage(imageWrapper, threshold, targetWrapper) {\n    if (!targetWrapper) {\n        targetWrapper = imageWrapper;\n    }\n    var imageData = imageWrapper.data, length = imageData.length, targetData = targetWrapper.data;\n\n    while (length--) {\n        targetData[length] = imageData[length] < threshold ? 1 : 0;\n    }\n};\n\nexport function computeHistogram(imageWrapper, bitsPerPixel) {\n    if (!bitsPerPixel) {\n        bitsPerPixel = 8;\n    }\n    var imageData = imageWrapper.data,\n        length = imageData.length,\n        bitShift = 8 - bitsPerPixel,\n        bucketCnt = 1 << bitsPerPixel,\n        hist = new Int32Array(bucketCnt);\n\n    while (length--) {\n        hist[imageData[length] >> bitShift]++;\n    }\n    return hist;\n};\n\nexport function sharpenLine(line) {\n    var i,\n        length = line.length,\n        left = line[0],\n        center = line[1],\n        right;\n\n    for (i = 1; i < length - 1; i++) {\n        right = line[i + 1];\n        //  -1 4 -1 kernel\n        line[i - 1] = (((center * 2) - left - right)) & 255;\n        left = center;\n        center = right;\n    }\n    return line;\n};\n\nexport function determineOtsuThreshold(imageWrapper, bitsPerPixel) {\n    if (!bitsPerPixel) {\n        bitsPerPixel = 8;\n    }\n    var hist,\n        threshold,\n        bitShift = 8 - bitsPerPixel;\n\n    function px(init, end) {\n        var sum = 0, i;\n        for ( i = init; i <= end; i++) {\n            sum += hist[i];\n        }\n        return sum;\n    }\n\n    function mx(init, end) {\n        var i, sum = 0;\n\n        for ( i = init; i <= end; i++) {\n            sum += i * hist[i];\n        }\n\n        return sum;\n    }\n\n    function determineThreshold() {\n        var vet = [0], p1, p2, p12, k, m1, m2, m12,\n            max = (1 << bitsPerPixel) - 1;\n\n        hist = computeHistogram(imageWrapper, bitsPerPixel);\n        for ( k = 1; k < max; k++) {\n            p1 = px(0, k);\n            p2 = px(k + 1, max);\n            p12 = p1 * p2;\n            if (p12 === 0) {\n                p12 = 1;\n            }\n            m1 = mx(0, k) * p2;\n            m2 = mx(k + 1, max) * p1;\n            m12 = m1 - m2;\n            vet[k] = m12 * m12 / p12;\n        }\n        return ArrayHelper.maxIndex(vet);\n    }\n\n    threshold = determineThreshold();\n    return threshold << bitShift;\n};\n\nexport function otsuThreshold(imageWrapper, targetWrapper) {\n    var threshold = determineOtsuThreshold(imageWrapper);\n\n    thresholdImage(imageWrapper, threshold, targetWrapper);\n    return threshold;\n};\n\n// local thresholding\nexport function computeBinaryImage(imageWrapper, integralWrapper, targetWrapper) {\n    computeIntegralImage(imageWrapper, integralWrapper);\n\n    if (!targetWrapper) {\n        targetWrapper = imageWrapper;\n    }\n    var imageData = imageWrapper.data;\n    var targetData = targetWrapper.data;\n    var width = imageWrapper.size.x;\n    var height = imageWrapper.size.y;\n    var integralImageData = integralWrapper.data;\n    var sum = 0, v, u, kernel = 3, A, B, C, D, avg, size = (kernel * 2 + 1) * (kernel * 2 + 1);\n\n    // clear out top & bottom-border\n    for ( v = 0; v <= kernel; v++) {\n        for ( u = 0; u < width; u++) {\n            targetData[((v) * width) + u] = 0;\n            targetData[(((height - 1) - v) * width) + u] = 0;\n        }\n    }\n\n    // clear out left & right border\n    for ( v = kernel; v < height - kernel; v++) {\n        for ( u = 0; u <= kernel; u++) {\n            targetData[((v) * width) + u] = 0;\n            targetData[((v) * width) + (width - 1 - u)] = 0;\n        }\n    }\n\n    for ( v = kernel + 1; v < height - kernel - 1; v++) {\n        for ( u = kernel + 1; u < width - kernel; u++) {\n            A = integralImageData[(v - kernel - 1) * width + (u - kernel - 1)];\n            B = integralImageData[(v - kernel - 1) * width + (u + kernel)];\n            C = integralImageData[(v + kernel) * width + (u - kernel - 1)];\n            D = integralImageData[(v + kernel) * width + (u + kernel)];\n            sum = D - C - B + A;\n            avg = sum / (size);\n            targetData[v * width + u] = imageData[v * width + u] > (avg + 5) ? 0 : 1;\n        }\n    }\n};\n\nexport function cluster(points, threshold, property) {\n    var i, k, cluster, point, clusters = [];\n\n    if (!property) {\n        property = \"rad\";\n    }\n\n    function addToCluster(newPoint) {\n        var found = false;\n        for ( k = 0; k < clusters.length; k++) {\n            cluster = clusters[k];\n            if (cluster.fits(newPoint)) {\n                cluster.add(newPoint);\n                found = true;\n            }\n        }\n        return found;\n    }\n\n    // iterate over each cloud\n    for ( i = 0; i < points.length; i++) {\n        point = Cluster2.createPoint(points[i], i, property);\n        if (!addToCluster(point)) {\n            clusters.push(Cluster2.create(point, threshold));\n        }\n    }\n    return clusters;\n};\n\nexport const Tracer = {\n    trace: function(points, vec) {\n        var iteration, maxIterations = 10, top = [], result = [], centerPos = 0, currentPos = 0;\n\n        function trace(idx, forward) {\n            var from, to, toIdx, predictedPos, thresholdX = 1, thresholdY = Math.abs(vec[1] / 10), found = false;\n\n            function match(pos, predicted) {\n                if (pos.x > (predicted.x - thresholdX)\n                        && pos.x < (predicted.x + thresholdX)\n                        && pos.y > (predicted.y - thresholdY)\n                        && pos.y < (predicted.y + thresholdY)) {\n                    return true;\n                } else {\n                    return false;\n                }\n            }\n\n            // check if the next index is within the vec specifications\n            // if not, check as long as the threshold is met\n\n            from = points[idx];\n            if (forward) {\n                predictedPos = {\n                    x: from.x + vec[0],\n                    y: from.y + vec[1]\n                };\n            } else {\n                predictedPos = {\n                    x: from.x - vec[0],\n                    y: from.y - vec[1]\n                };\n            }\n\n            toIdx = forward ? idx + 1 : idx - 1;\n            to = points[toIdx];\n            while (to && ( found = match(to, predictedPos)) !== true && (Math.abs(to.y - from.y) < vec[1])) {\n                toIdx = forward ? toIdx + 1 : toIdx - 1;\n                to = points[toIdx];\n            }\n\n            return found ? toIdx : null;\n        }\n\n        for ( iteration = 0; iteration < maxIterations; iteration++) {\n            // randomly select point to start with\n            centerPos = Math.floor(Math.random() * points.length);\n\n            // trace forward\n            top = [];\n            currentPos = centerPos;\n            top.push(points[currentPos]);\n            while (( currentPos = trace(currentPos, true)) !== null) {\n                top.push(points[currentPos]);\n            }\n            if (centerPos > 0) {\n                currentPos = centerPos;\n                while (( currentPos = trace(currentPos, false)) !== null) {\n                    top.push(points[currentPos]);\n                }\n            }\n\n            if (top.length > result.length) {\n                result = top;\n            }\n        }\n        return result;\n    }\n};\n\nexport const DILATE = 1;\nexport const ERODE = 2;\n\nexport function dilate(inImageWrapper, outImageWrapper) {\n    var v,\n        u,\n        inImageData = inImageWrapper.data,\n        outImageData = outImageWrapper.data,\n        height = inImageWrapper.size.y,\n        width = inImageWrapper.size.x,\n        sum,\n        yStart1,\n        yStart2,\n        xStart1,\n        xStart2;\n\n    for ( v = 1; v < height - 1; v++) {\n        for ( u = 1; u < width - 1; u++) {\n            yStart1 = v - 1;\n            yStart2 = v + 1;\n            xStart1 = u - 1;\n            xStart2 = u + 1;\n            sum = inImageData[yStart1 * width + xStart1] + inImageData[yStart1 * width + xStart2] +\n            inImageData[v * width + u] +\n            inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2];\n            outImageData[v * width + u] = sum > 0 ? 1 : 0;\n        }\n    }\n};\n\nexport function erode(inImageWrapper, outImageWrapper) {\n    var v,\n        u,\n        inImageData = inImageWrapper.data,\n        outImageData = outImageWrapper.data,\n        height = inImageWrapper.size.y,\n        width = inImageWrapper.size.x,\n        sum,\n        yStart1,\n        yStart2,\n        xStart1,\n        xStart2;\n\n    for ( v = 1; v < height - 1; v++) {\n        for ( u = 1; u < width - 1; u++) {\n            yStart1 = v - 1;\n            yStart2 = v + 1;\n            xStart1 = u - 1;\n            xStart2 = u + 1;\n            sum = inImageData[yStart1 * width + xStart1] + inImageData[yStart1 * width + xStart2] +\n            inImageData[v * width + u] +\n            inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2];\n            outImageData[v * width + u] = sum === 5 ? 1 : 0;\n        }\n    }\n};\n\nexport function subtract(aImageWrapper, bImageWrapper, resultImageWrapper) {\n    if (!resultImageWrapper) {\n        resultImageWrapper = aImageWrapper;\n    }\n    var length = aImageWrapper.data.length,\n        aImageData = aImageWrapper.data,\n        bImageData = bImageWrapper.data,\n        cImageData = resultImageWrapper.data;\n\n    while (length--) {\n        cImageData[length] = aImageData[length] - bImageData[length];\n    }\n};\n\nexport function bitwiseOr(aImageWrapper, bImageWrapper, resultImageWrapper) {\n    if (!resultImageWrapper) {\n        resultImageWrapper = aImageWrapper;\n    }\n    var length = aImageWrapper.data.length,\n        aImageData = aImageWrapper.data,\n        bImageData = bImageWrapper.data,\n        cImageData = resultImageWrapper.data;\n\n    while (length--) {\n        cImageData[length] = aImageData[length] || bImageData[length];\n    }\n};\n\nexport function countNonZero(imageWrapper) {\n    var length = imageWrapper.data.length, data = imageWrapper.data, sum = 0;\n\n    while (length--) {\n        sum += data[length];\n    }\n    return sum;\n};\n\nexport function topGeneric(list, top, scoreFunc) {\n    var i, minIdx = 0, min = 0, queue = [], score, hit, pos;\n\n    for ( i = 0; i < top; i++) {\n        queue[i] = {\n            score: 0,\n            item: null\n        };\n    }\n\n    for ( i = 0; i < list.length; i++) {\n        score = scoreFunc.apply(this, [list[i]]);\n        if (score > min) {\n            hit = queue[minIdx];\n            hit.score = score;\n            hit.item = list[i];\n            min = Number.MAX_VALUE;\n            for ( pos = 0; pos < top; pos++) {\n                if (queue[pos].score < min) {\n                    min = queue[pos].score;\n                    minIdx = pos;\n                }\n            }\n        }\n    }\n\n    return queue;\n};\n\nexport function grayArrayFromImage(htmlImage, offsetX, ctx, array) {\n    ctx.drawImage(htmlImage, offsetX, 0, htmlImage.width, htmlImage.height);\n    var ctxData = ctx.getImageData(offsetX, 0, htmlImage.width, htmlImage.height).data;\n    computeGray(ctxData, array);\n};\n\nexport function grayArrayFromContext(ctx, size, offset, array) {\n    var ctxData = ctx.getImageData(offset.x, offset.y, size.x, size.y).data;\n    computeGray(ctxData, array);\n};\n\nexport function grayAndHalfSampleFromCanvasData(canvasData, size, outArray) {\n    var topRowIdx = 0;\n    var bottomRowIdx = size.x;\n    var endIdx = Math.floor(canvasData.length / 4);\n    var outWidth = size.x / 2;\n    var outImgIdx = 0;\n    var inWidth = size.x;\n    var i;\n\n    while (bottomRowIdx < endIdx) {\n        for ( i = 0; i < outWidth; i++) {\n            outArray[outImgIdx] = (\n                (0.299 * canvasData[topRowIdx * 4 + 0] +\n                 0.587 * canvasData[topRowIdx * 4 + 1] +\n                 0.114 * canvasData[topRowIdx * 4 + 2]) +\n                (0.299 * canvasData[(topRowIdx + 1) * 4 + 0] +\n                 0.587 * canvasData[(topRowIdx + 1) * 4 + 1] +\n                 0.114 * canvasData[(topRowIdx + 1) * 4 + 2]) +\n                (0.299 * canvasData[(bottomRowIdx) * 4 + 0] +\n                 0.587 * canvasData[(bottomRowIdx) * 4 + 1] +\n                 0.114 * canvasData[(bottomRowIdx) * 4 + 2]) +\n                (0.299 * canvasData[(bottomRowIdx + 1) * 4 + 0] +\n                 0.587 * canvasData[(bottomRowIdx + 1) * 4 + 1] +\n                 0.114 * canvasData[(bottomRowIdx + 1) * 4 + 2])) / 4;\n            outImgIdx++;\n            topRowIdx = topRowIdx + 2;\n            bottomRowIdx = bottomRowIdx + 2;\n        }\n        topRowIdx = topRowIdx + inWidth;\n        bottomRowIdx = bottomRowIdx + inWidth;\n    }\n};\n\nexport function computeGray(imageData, outArray, config) {\n    var l = (imageData.length / 4) | 0,\n        i,\n        singleChannel = config && config.singleChannel === true;\n\n    if (singleChannel) {\n        for (i = 0; i < l; i++) {\n            outArray[i] = imageData[i * 4 + 0];\n        }\n    } else {\n        for (i = 0; i < l; i++) {\n            outArray[i] =\n                0.299 * imageData[i * 4 + 0] + 0.587 * imageData[i * 4 + 1] + 0.114 * imageData[i * 4 + 2];\n        }\n    }\n};\n\nexport function loadImageArray(src, callback, canvas) {\n    if (!canvas) {\n        canvas = document.createElement('canvas');\n    }\n    var img = new Image();\n    img.callback = callback;\n    img.onload = function() {\n        canvas.width = this.width;\n        canvas.height = this.height;\n        var ctx = canvas.getContext('2d');\n        ctx.drawImage(this, 0, 0);\n        var array = new Uint8Array(this.width * this.height);\n        ctx.drawImage(this, 0, 0);\n        var data = ctx.getImageData(0, 0, this.width, this.height).data;\n        computeGray(data, array);\n        this.callback(array, {\n            x: this.width,\n            y: this.height\n        }, this);\n    };\n    img.src = src;\n};\n\n/**\n * @param inImg {ImageWrapper} input image to be sampled\n * @param outImg {ImageWrapper} to be stored in\n */\nexport function halfSample(inImgWrapper, outImgWrapper) {\n    var inImg = inImgWrapper.data;\n    var inWidth = inImgWrapper.size.x;\n    var outImg = outImgWrapper.data;\n    var topRowIdx = 0;\n    var bottomRowIdx = inWidth;\n    var endIdx = inImg.length;\n    var outWidth = inWidth / 2;\n    var outImgIdx = 0;\n    while (bottomRowIdx < endIdx) {\n        for (var i = 0; i < outWidth; i++) {\n            outImg[outImgIdx] = Math.floor(\n                (inImg[topRowIdx] + inImg[topRowIdx + 1] + inImg[bottomRowIdx] + inImg[bottomRowIdx + 1]) / 4);\n            outImgIdx++;\n            topRowIdx = topRowIdx + 2;\n            bottomRowIdx = bottomRowIdx + 2;\n        }\n        topRowIdx = topRowIdx + inWidth;\n        bottomRowIdx = bottomRowIdx + inWidth;\n    }\n};\n\nexport function hsv2rgb(hsv, rgb) {\n    var h = hsv[0],\n        s = hsv[1],\n        v = hsv[2],\n        c = v * s,\n        x = c * (1 - Math.abs((h / 60) % 2 - 1)),\n        m = v - c,\n        r = 0,\n        g = 0,\n        b = 0;\n\n    rgb = rgb || [0, 0, 0];\n\n    if (h < 60) {\n        r = c;\n        g = x;\n    } else if (h < 120) {\n        r = x;\n        g = c;\n    } else if (h < 180) {\n        g = c;\n        b = x;\n    } else if (h < 240) {\n        g = x;\n        b = c;\n    } else if (h < 300) {\n        r = x;\n        b = c;\n    } else if (h < 360) {\n        r = c;\n        b = x;\n    }\n    rgb[0] = ((r + m) * 255) | 0;\n    rgb[1] = ((g + m) * 255) | 0;\n    rgb[2] = ((b + m) * 255) | 0;\n    return rgb;\n};\n\nexport function _computeDivisors(n) {\n    var largeDivisors = [],\n        divisors = [],\n        i;\n\n    for (i = 1; i < Math.sqrt(n) + 1; i++) {\n        if (n % i === 0) {\n            divisors.push(i);\n            if (i !== n / i) {\n                largeDivisors.unshift(Math.floor(n / i));\n            }\n        }\n    }\n    return divisors.concat(largeDivisors);\n};\n\nfunction _computeIntersection(arr1, arr2) {\n    var i = 0,\n        j = 0,\n        result = [];\n\n    while (i < arr1.length && j < arr2.length) {\n        if (arr1[i] === arr2[j]) {\n            result.push(arr1[i]);\n            i++;\n            j++;\n        } else if (arr1[i] > arr2[j]) {\n            j++;\n        } else {\n            i++;\n        }\n    }\n    return result;\n};\n\nexport function calculatePatchSize(patchSize, imgSize) {\n    var divisorsX = _computeDivisors(imgSize.x),\n        divisorsY = _computeDivisors(imgSize.y),\n        wideSide = Math.max(imgSize.x, imgSize.y),\n        common = _computeIntersection(divisorsX, divisorsY),\n        nrOfPatchesList = [8, 10, 15, 20, 32, 60, 80],\n        nrOfPatchesMap = {\n            \"x-small\": 5,\n            \"small\": 4,\n            \"medium\": 3,\n            \"large\": 2,\n            \"x-large\": 1\n        },\n        nrOfPatchesIdx = nrOfPatchesMap[patchSize] || nrOfPatchesMap.medium,\n        nrOfPatches = nrOfPatchesList[nrOfPatchesIdx],\n        desiredPatchSize = Math.floor(wideSide / nrOfPatches),\n        optimalPatchSize;\n\n    function findPatchSizeForDivisors(divisors) {\n        var i = 0,\n            found = divisors[Math.floor(divisors.length / 2)];\n\n        while (i < (divisors.length - 1) && divisors[i] < desiredPatchSize) {\n            i++;\n        }\n        if (i > 0) {\n            if (Math.abs(divisors[i] - desiredPatchSize) > Math.abs(divisors[i - 1] - desiredPatchSize)) {\n                found = divisors[i - 1];\n            } else {\n                found = divisors[i];\n            }\n        }\n        if (desiredPatchSize / found < nrOfPatchesList[nrOfPatchesIdx + 1] / nrOfPatchesList[nrOfPatchesIdx] &&\n            desiredPatchSize / found > nrOfPatchesList[nrOfPatchesIdx - 1] / nrOfPatchesList[nrOfPatchesIdx] ) {\n            return {x: found, y: found};\n        }\n        return null;\n    }\n\n    optimalPatchSize = findPatchSizeForDivisors(common);\n    if (!optimalPatchSize) {\n        optimalPatchSize = findPatchSizeForDivisors(_computeDivisors(wideSide));\n        if (!optimalPatchSize) {\n            optimalPatchSize = findPatchSizeForDivisors((_computeDivisors(desiredPatchSize * nrOfPatches)));\n        }\n    }\n    return optimalPatchSize;\n};\n\nexport function _parseCSSDimensionValues(value) {\n    var dimension = {\n        value: parseFloat(value),\n        unit: value.indexOf(\"%\") === value.length - 1 ? \"%\" : \"%\"\n    };\n\n    return dimension;\n};\n\nexport const _dimensionsConverters = {\n    top: function(dimension, context) {\n        if (dimension.unit === \"%\") {\n            return Math.floor(context.height * (dimension.value / 100));\n        }\n    },\n    right: function(dimension, context) {\n        if (dimension.unit === \"%\") {\n            return Math.floor(context.width - (context.width * (dimension.value / 100)));\n        }\n    },\n    bottom: function(dimension, context) {\n        if (dimension.unit === \"%\") {\n            return Math.floor(context.height - (context.height * (dimension.value / 100)));\n        }\n    },\n    left: function(dimension, context) {\n        if (dimension.unit === \"%\") {\n            return Math.floor(context.width * (dimension.value / 100));\n        }\n    }\n};\n\nexport function computeImageArea(inputWidth, inputHeight, area) {\n    var context = {width: inputWidth, height: inputHeight};\n\n    var parsedArea = Object.keys(area).reduce(function(result, key) {\n        var value = area[key],\n            parsed = _parseCSSDimensionValues(value),\n            calculated = _dimensionsConverters[key](parsed, context);\n\n        result[key] = calculated;\n        return result;\n    }, {});\n\n    return {\n        sx: parsedArea.left,\n        sy: parsedArea.top,\n        sw: parsedArea.right - parsedArea.left,\n        sh: parsedArea.bottom - parsedArea.top\n    };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/cv_utils.js","import SubImage from './subImage';\nimport {hsv2rgb} from '../common/cv_utils';\nimport ArrayHelper from '../common/array_helper';\nconst vec2 = {\n    clone: require('gl-vec2/clone'),\n};\n\n/**\n * Represents a basic image combining the data and size.\n * In addition, some methods for manipulation are contained.\n * @param size {x,y} The size of the image in pixel\n * @param data {Array} If given, a flat array containing the pixel data\n * @param ArrayType {Type} If given, the desired DataType of the Array (may be typed/non-typed)\n * @param initialize {Boolean} Indicating if the array should be initialized on creation.\n * @returns {ImageWrapper}\n */\nfunction ImageWrapper(size, data, ArrayType, initialize) {\n    if (!data) {\n        if (ArrayType) {\n            this.data = new ArrayType(size.x * size.y);\n            if (ArrayType === Array && initialize) {\n                ArrayHelper.init(this.data, 0);\n            }\n        } else {\n            this.data = new Uint8Array(size.x * size.y);\n            if (Uint8Array === Array && initialize) {\n                ArrayHelper.init(this.data, 0);\n            }\n        }\n    } else {\n        this.data = data;\n    }\n    this.size = size;\n}\n\n/**\n * tests if a position is within the image with a given offset\n * @param imgRef {x, y} The location to test\n * @param border Number the padding value in pixel\n * @returns {Boolean} true if location inside the image's border, false otherwise\n * @see cvd/image.h\n */\nImageWrapper.prototype.inImageWithBorder = function(imgRef, border) {\n    return (imgRef.x >= border)\n        && (imgRef.y >= border)\n        && (imgRef.x < (this.size.x - border))\n        && (imgRef.y < (this.size.y - border));\n};\n\n/**\n * Performs bilinear sampling\n * @param inImg Image to extract sample from\n * @param x the x-coordinate\n * @param y the y-coordinate\n * @returns the sampled value\n * @see cvd/vision.h\n */\nImageWrapper.sample = function(inImg, x, y) {\n    var lx = Math.floor(x);\n    var ly = Math.floor(y);\n    var w = inImg.size.x;\n    var base = ly * inImg.size.x + lx;\n    var a = inImg.data[base + 0];\n    var b = inImg.data[base + 1];\n    var c = inImg.data[base + w];\n    var d = inImg.data[base + w + 1];\n    var e = a - b;\n    x -= lx;\n    y -= ly;\n\n    var result = Math.floor(x * (y * (e - c + d) - e) + y * (c - a) + a);\n    return result;\n};\n\n/**\n * Initializes a given array. Sets each element to zero.\n * @param array {Array} The array to initialize\n */\nImageWrapper.clearArray = function(array) {\n    var l = array.length;\n    while (l--) {\n        array[l] = 0;\n    }\n};\n\n/**\n * Creates a {SubImage} from the current image ({this}).\n * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner)\n * @param size {ImageRef} The size of the resulting image\n * @returns {SubImage} A shared part of the original image\n */\nImageWrapper.prototype.subImage = function(from, size) {\n    return new SubImage(from, size, this);\n};\n\n/**\n * Creates an {ImageWrapper) and copies the needed underlying image-data area\n * @param imageWrapper {ImageWrapper} The target {ImageWrapper} where the data should be copied\n * @param from {ImageRef} The location where to copy from (top-left location)\n */\nImageWrapper.prototype.subImageAsCopy = function(imageWrapper, from) {\n    var sizeY = imageWrapper.size.y, sizeX = imageWrapper.size.x;\n    var x, y;\n    for ( x = 0; x < sizeX; x++) {\n        for ( y = 0; y < sizeY; y++) {\n            imageWrapper.data[y * sizeX + x] = this.data[(from.y + y) * this.size.x + from.x + x];\n        }\n    }\n};\n\nImageWrapper.prototype.copyTo = function(imageWrapper) {\n    var length = this.data.length, srcData = this.data, dstData = imageWrapper.data;\n\n    while (length--) {\n        dstData[length] = srcData[length];\n    }\n};\n\n/**\n * Retrieves a given pixel position from the image\n * @param x {Number} The x-position\n * @param y {Number} The y-position\n * @returns {Number} The grayscale value at the pixel-position\n */\nImageWrapper.prototype.get = function(x, y) {\n    return this.data[y * this.size.x + x];\n};\n\n/**\n * Retrieves a given pixel position from the image\n * @param x {Number} The x-position\n * @param y {Number} The y-position\n * @returns {Number} The grayscale value at the pixel-position\n */\nImageWrapper.prototype.getSafe = function(x, y) {\n    var i;\n\n    if (!this.indexMapping) {\n        this.indexMapping = {\n            x: [],\n            y: []\n        };\n        for (i = 0; i < this.size.x; i++) {\n            this.indexMapping.x[i] = i;\n            this.indexMapping.x[i + this.size.x] = i;\n        }\n        for (i = 0; i < this.size.y; i++) {\n            this.indexMapping.y[i] = i;\n            this.indexMapping.y[i + this.size.y] = i;\n        }\n    }\n    return this.data[(this.indexMapping.y[y + this.size.y]) * this.size.x + this.indexMapping.x[x + this.size.x]];\n};\n\n/**\n * Sets a given pixel position in the image\n * @param x {Number} The x-position\n * @param y {Number} The y-position\n * @param value {Number} The grayscale value to set\n * @returns {ImageWrapper} The Image itself (for possible chaining)\n */\nImageWrapper.prototype.set = function(x, y, value) {\n    this.data[y * this.size.x + x] = value;\n    return this;\n};\n\n/**\n * Sets the border of the image (1 pixel) to zero\n */\nImageWrapper.prototype.zeroBorder = function() {\n    var i, width = this.size.x, height = this.size.y, data = this.data;\n    for ( i = 0; i < width; i++) {\n        data[i] = data[(height - 1) * width + i] = 0;\n    }\n    for ( i = 1; i < height - 1; i++) {\n        data[i * width] = data[i * width + (width - 1)] = 0;\n    }\n};\n\n/**\n * Inverts a binary image in place\n */\nImageWrapper.prototype.invert = function() {\n    var data = this.data, length = data.length;\n\n    while (length--) {\n        data[length] = data[length] ? 0 : 1;\n    }\n};\n\nImageWrapper.prototype.convolve = function(kernel) {\n    var x, y, kx, ky, kSize = (kernel.length / 2) | 0, accu = 0;\n    for ( y = 0; y < this.size.y; y++) {\n        for ( x = 0; x < this.size.x; x++) {\n            accu = 0;\n            for ( ky = -kSize; ky <= kSize; ky++) {\n                for ( kx = -kSize; kx <= kSize; kx++) {\n                    accu += kernel[ky + kSize][kx + kSize] * this.getSafe(x + kx, y + ky);\n                }\n            }\n            this.data[y * this.size.x + x] = accu;\n        }\n    }\n};\n\nImageWrapper.prototype.moments = function(labelcount) {\n    var data = this.data,\n        x,\n        y,\n        height = this.size.y,\n        width = this.size.x,\n        val,\n        ysq,\n        labelsum = [],\n        i,\n        label,\n        mu11,\n        mu02,\n        mu20,\n        x_,\n        y_,\n        tmp,\n        result = [],\n        PI = Math.PI,\n        PI_4 = PI / 4;\n\n    if (labelcount <= 0) {\n        return result;\n    }\n\n    for ( i = 0; i < labelcount; i++) {\n        labelsum[i] = {\n            m00: 0,\n            m01: 0,\n            m10: 0,\n            m11: 0,\n            m02: 0,\n            m20: 0,\n            theta: 0,\n            rad: 0\n        };\n    }\n\n    for ( y = 0; y < height; y++) {\n        ysq = y * y;\n        for ( x = 0; x < width; x++) {\n            val = data[y * width + x];\n            if (val > 0) {\n                label = labelsum[val - 1];\n                label.m00 += 1;\n                label.m01 += y;\n                label.m10 += x;\n                label.m11 += x * y;\n                label.m02 += ysq;\n                label.m20 += x * x;\n            }\n        }\n    }\n\n    for ( i = 0; i < labelcount; i++) {\n        label = labelsum[i];\n        if (!isNaN(label.m00) && label.m00 !== 0) {\n            x_ = label.m10 / label.m00;\n            y_ = label.m01 / label.m00;\n            mu11 = label.m11 / label.m00 - x_ * y_;\n            mu02 = label.m02 / label.m00 - y_ * y_;\n            mu20 = label.m20 / label.m00 - x_ * x_;\n            tmp = (mu02 - mu20) / (2 * mu11);\n            tmp = 0.5 * Math.atan(tmp) + (mu11 >= 0 ? PI_4 : -PI_4 ) + PI;\n            label.theta = (tmp * 180 / PI + 90) % 180 - 90;\n            if (label.theta < 0) {\n                label.theta += 180;\n            }\n            label.rad = tmp > PI ? tmp - PI : tmp;\n            label.vec = vec2.clone([Math.cos(tmp), Math.sin(tmp)]);\n            result.push(label);\n        }\n    }\n\n    return result;\n};\n\n/**\n * Displays the {ImageWrapper} in a given canvas\n * @param canvas {Canvas} The canvas element to write to\n * @param scale {Number} Scale which is applied to each pixel-value\n */\nImageWrapper.prototype.show = function(canvas, scale) {\n    var ctx,\n        frame,\n        data,\n        current,\n        pixel,\n        x,\n        y;\n\n    if (!scale) {\n        scale = 1.0;\n    }\n    ctx = canvas.getContext('2d');\n    canvas.width = this.size.x;\n    canvas.height = this.size.y;\n    frame = ctx.getImageData(0, 0, canvas.width, canvas.height);\n    data = frame.data;\n    current = 0;\n    for (y = 0; y < this.size.y; y++) {\n        for (x = 0; x < this.size.x; x++) {\n            pixel = y * this.size.x + x;\n            current = this.get(x, y) * scale;\n            data[pixel * 4 + 0] = current;\n            data[pixel * 4 + 1] = current;\n            data[pixel * 4 + 2] = current;\n            data[pixel * 4 + 3] = 255;\n        }\n    }\n    //frame.data = data;\n    ctx.putImageData(frame, 0, 0);\n};\n\n/**\n * Displays the {SubImage} in a given canvas\n * @param canvas {Canvas} The canvas element to write to\n * @param scale {Number} Scale which is applied to each pixel-value\n */\nImageWrapper.prototype.overlay = function(canvas, scale, from) {\n    if (!scale || scale < 0 || scale > 360) {\n        scale = 360;\n    }\n    var hsv = [0, 1, 1];\n    var rgb = [0, 0, 0];\n    var whiteRgb = [255, 255, 255];\n    var blackRgb = [0, 0, 0];\n    var result = [];\n    var ctx = canvas.getContext('2d');\n    var frame = ctx.getImageData(from.x, from.y, this.size.x, this.size.y);\n    var data = frame.data;\n    var length = this.data.length;\n    while (length--) {\n        hsv[0] = this.data[length] * scale;\n        result = hsv[0] <= 0 ? whiteRgb : hsv[0] >= 360 ? blackRgb : hsv2rgb(hsv, rgb);\n        data[length * 4 + 0] = result[0];\n        data[length * 4 + 1] = result[1];\n        data[length * 4 + 2] = result[2];\n        data[length * 4 + 3] = 255;\n    }\n    ctx.putImageData(frame, from.x, from.y);\n};\n\nexport default ImageWrapper;\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/image_wrapper.js","var defineProperty = require('./_defineProperty');\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\nmodule.exports = baseAssignValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseAssignValue.js\n// module id = 21\n// module chunks = 0","var baseIsNative = require('./_baseIsNative'),\n    getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getNative.js\n// module id = 22\n// module chunks = 0","var isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = toKey;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_toKey.js\n// module id = 23\n// module chunks = 0","var isFunction = require('./isFunction'),\n    isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isArrayLike.js\n// module id = 24\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isFunction.js\n// module id = 25\n// module chunks = 0","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isLength.js\n// module id = 26\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isSymbol.js\n// module id = 27\n// module chunks = 0","var baseMerge = require('./_baseMerge'),\n    createAssigner = require('./_createAssigner');\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n *   'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n *   'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = createAssigner(function(object, source, srcIndex) {\n  baseMerge(object, source, srcIndex);\n});\n\nmodule.exports = merge;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/merge.js\n// module id = 28\n// module chunks = 0","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/module.js\n// module id = 29\n// module chunks = 0","/**\n * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization\n */\nvar Tracer = {\n    searchDirections: [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]],\n    create: function(imageWrapper, labelWrapper) {\n        var imageData = imageWrapper.data,\n            labelData = labelWrapper.data,\n            searchDirections = this.searchDirections,\n            width = imageWrapper.size.x,\n            pos;\n\n        function trace(current, color, label, edgelabel) {\n            var i,\n                y,\n                x;\n\n            for ( i = 0; i < 7; i++) {\n                y = current.cy + searchDirections[current.dir][0];\n                x = current.cx + searchDirections[current.dir][1];\n                pos = y * width + x;\n                if ((imageData[pos] === color) && ((labelData[pos] === 0) || (labelData[pos] === label))) {\n                    labelData[pos] = label;\n                    current.cy = y;\n                    current.cx = x;\n                    return true;\n                } else {\n                    if (labelData[pos] === 0) {\n                        labelData[pos] = edgelabel;\n                    }\n                    current.dir = (current.dir + 1) % 8;\n                }\n            }\n            return false;\n        }\n\n        function vertex2D(x, y, dir) {\n            return {\n                dir: dir,\n                x: x,\n                y: y,\n                next: null,\n                prev: null\n            };\n        }\n\n        function contourTracing(sy, sx, label, color, edgelabel) {\n            var Fv = null,\n                Cv,\n                P,\n                ldir,\n                current = {\n                    cx: sx,\n                    cy: sy,\n                    dir: 0\n                };\n\n            if (trace(current, color, label, edgelabel)) {\n                Fv = vertex2D(sx, sy, current.dir);\n                Cv = Fv;\n                ldir = current.dir;\n                P = vertex2D(current.cx, current.cy, 0);\n                P.prev = Cv;\n                Cv.next = P;\n                P.next = null;\n                Cv = P;\n                do {\n                    current.dir = (current.dir + 6) % 8;\n                    trace(current, color, label, edgelabel);\n                    if (ldir !== current.dir) {\n                        Cv.dir = current.dir;\n                        P = vertex2D(current.cx, current.cy, 0);\n                        P.prev = Cv;\n                        Cv.next = P;\n                        P.next = null;\n                        Cv = P;\n                    } else {\n                        Cv.dir = ldir;\n                        Cv.x = current.cx;\n                        Cv.y = current.cy;\n                    }\n                    ldir = current.dir;\n                } while (current.cx !== sx || current.cy !== sy);\n                Fv.prev = Cv.prev;\n                Cv.prev.next = Fv;\n            }\n            return Fv;\n        }\n\n        return {\n            trace: function(current, color, label, edgelabel) {\n                return trace(current, color, label, edgelabel);\n            },\n            contourTracing: function(sy, sx, label, color, edgelabel) {\n                return contourTracing(sy, sx, label, color, edgelabel);\n            }\n        };\n    }\n};\n\nexport default (Tracer);\n\n\n\n// WEBPACK FOOTER //\n// ./src/locator/tracer.js","import BarcodeReader from './barcode_reader';\nimport ArrayHelper from '../common/array_helper';\n\nfunction Code39Reader() {\n    BarcodeReader.call(this);\n}\n\nvar properties = {\n    ALPHABETH_STRING: {value: \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%\"},\n    ALPHABET: {value: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,\n        79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 45, 46, 32, 42, 36, 47, 43, 37]},\n    CHARACTER_ENCODINGS: {value: [0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, 0x109, 0x049,\n        0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106,\n        0x046, 0x016, 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, 0x0A8, 0x0A2, 0x08A, 0x02A\n    ]},\n    ASTERISK: {value: 0x094},\n    FORMAT: {value: \"code_39\", writeable: false}\n};\n\nCode39Reader.prototype = Object.create(BarcodeReader.prototype, properties);\nCode39Reader.prototype.constructor = Code39Reader;\n\nCode39Reader.prototype._decode = function() {\n    var self = this,\n        counters = [0, 0, 0, 0, 0, 0, 0, 0, 0],\n        result = [],\n        start = self._findStart(),\n        decodedChar,\n        lastStart,\n        pattern,\n        nextStart;\n\n    if (!start) {\n        return null;\n    }\n    nextStart = self._nextSet(self._row, start.end);\n\n    do {\n        counters = self._toCounters(nextStart, counters);\n        pattern = self._toPattern(counters);\n        if (pattern < 0) {\n            return null;\n        }\n        decodedChar = self._patternToChar(pattern);\n        if (decodedChar < 0){\n            return null;\n        }\n        result.push(decodedChar);\n        lastStart = nextStart;\n        nextStart += ArrayHelper.sum(counters);\n        nextStart = self._nextSet(self._row, nextStart);\n    } while (decodedChar !== '*');\n    result.pop();\n\n    if (!result.length) {\n        return null;\n    }\n\n    if (!self._verifyTrailingWhitespace(lastStart, nextStart, counters)) {\n        return null;\n    }\n\n    return {\n        code: result.join(\"\"),\n        start: start.start,\n        end: nextStart,\n        startInfo: start,\n        decodedCodes: result\n    };\n};\n\nCode39Reader.prototype._verifyTrailingWhitespace = function(lastStart, nextStart, counters) {\n    var trailingWhitespaceEnd,\n        patternSize = ArrayHelper.sum(counters);\n\n    trailingWhitespaceEnd = nextStart - lastStart - patternSize;\n    if ((trailingWhitespaceEnd * 3) >= patternSize) {\n        return true;\n    }\n    return false;\n};\n\nCode39Reader.prototype._patternToChar = function(pattern) {\n    var i,\n        self = this;\n\n    for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {\n        if (self.CHARACTER_ENCODINGS[i] === pattern) {\n            return String.fromCharCode(self.ALPHABET[i]);\n        }\n    }\n    return -1;\n};\n\nCode39Reader.prototype._findNextWidth = function(counters, current) {\n    var i,\n        minWidth = Number.MAX_VALUE;\n\n    for (i = 0; i < counters.length; i++) {\n        if (counters[i] < minWidth && counters[i] > current) {\n            minWidth = counters[i];\n        }\n    }\n\n    return minWidth;\n};\n\nCode39Reader.prototype._toPattern = function(counters) {\n    var numCounters = counters.length,\n        maxNarrowWidth = 0,\n        numWideBars = numCounters,\n        wideBarWidth = 0,\n        self = this,\n        pattern,\n        i;\n\n    while (numWideBars > 3) {\n        maxNarrowWidth = self._findNextWidth(counters, maxNarrowWidth);\n        numWideBars = 0;\n        pattern = 0;\n        for (i = 0; i < numCounters; i++) {\n            if (counters[i] > maxNarrowWidth) {\n                pattern |= 1 << (numCounters - 1 - i);\n                numWideBars++;\n                wideBarWidth += counters[i];\n            }\n        }\n\n        if (numWideBars === 3) {\n            for (i = 0; i < numCounters && numWideBars > 0; i++) {\n                if (counters[i] > maxNarrowWidth) {\n                    numWideBars--;\n                    if ((counters[i] * 2) >= wideBarWidth) {\n                        return -1;\n                    }\n                }\n            }\n            return pattern;\n        }\n    }\n    return -1;\n};\n\nCode39Reader.prototype._findStart = function() {\n    var self = this,\n        offset = self._nextSet(self._row),\n        patternStart = offset,\n        counter = [0, 0, 0, 0, 0, 0, 0, 0, 0],\n        counterPos = 0,\n        isWhite = false,\n        i,\n        j,\n        whiteSpaceMustStart;\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                // find start pattern\n                if (self._toPattern(counter) === self.ASTERISK) {\n                    whiteSpaceMustStart = Math.floor(Math.max(0, patternStart - ((i - patternStart) / 4)));\n                    if (self._matchRange(whiteSpaceMustStart, patternStart, 0)) {\n                        return {\n                            start: patternStart,\n                            end: i\n                        };\n                    }\n                }\n\n                patternStart += counter[0] + counter[1];\n                for ( j = 0; j < 7; j++) {\n                    counter[j] = counter[j + 2];\n                }\n                counter[7] = 0;\n                counter[8] = 0;\n                counterPos--;\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nexport default Code39Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/code_39_reader.js","module.exports = dot\n\n/**\n * Calculates the dot product of two vec2's\n *\n * @param {vec2} a the first operand\n * @param {vec2} b the second operand\n * @returns {Number} dot product of a and b\n */\nfunction dot(a, b) {\n    return a[0] * b[0] + a[1] * b[1]\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec2/dot.js\n// module id = 32\n// module chunks = 0","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Map.js\n// module id = 33\n// module chunks = 0","var mapCacheClear = require('./_mapCacheClear'),\n    mapCacheDelete = require('./_mapCacheDelete'),\n    mapCacheGet = require('./_mapCacheGet'),\n    mapCacheHas = require('./_mapCacheHas'),\n    mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_MapCache.js\n// module id = 34\n// module chunks = 0","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignMergeValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_assignMergeValue.js\n// module id = 35\n// module chunks = 0","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_assignValue.js\n// module id = 36\n// module chunks = 0","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_defineProperty.js\n// module id = 37\n// module chunks = 0","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_freeGlobal.js\n// module id = 38\n// module chunks = 0","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getPrototype.js\n// module id = 39\n// module chunks = 0","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\nmodule.exports = isPrototype;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isPrototype.js\n// module id = 40\n// module chunks = 0","var apply = require('./_apply');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\nmodule.exports = overRest;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_overRest.js\n// module id = 41\n// module chunks = 0","var baseSetToString = require('./_baseSetToString'),\n    shortOut = require('./_shortOut');\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nmodule.exports = setToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_setToString.js\n// module id = 42\n// module chunks = 0","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nmodule.exports = identity;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/identity.js\n// module id = 43\n// module chunks = 0","var root = require('./_root'),\n    stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isBuffer.js\n// module id = 44\n// module chunks = 0","var baseIsTypedArray = require('./_baseIsTypedArray'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isTypedArray.js\n// module id = 45\n// module chunks = 0","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeysIn = require('./_baseKeysIn'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/keysIn.js\n// module id = 46\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 47\n// module chunks = 0","import TypeDefs from './common/typedefs'; // eslint-disable-line no-unused-vars\nimport ImageWrapper from './common/image_wrapper';\nimport BarcodeLocator from './locator/barcode_locator';\nimport BarcodeDecoder from './decoder/barcode_decoder';\nimport Events from './common/events';\nimport CameraAccess from './input/camera_access';\nimport ImageDebug from './common/image_debug';\nimport ResultCollector from './analytics/result_collector';\nimport Config from './config/config';\nimport InputStream from 'input_stream';\nimport FrameGrabber from 'frame_grabber';\nimport {merge} from 'lodash';\nconst vec2 = {\n    clone: require('gl-vec2/clone')\n};\n\nvar _inputStream,\n    _framegrabber,\n    _stopped,\n    _canvasContainer = {\n        ctx: {\n            image: null,\n            overlay: null\n        },\n        dom: {\n            image: null,\n            overlay: null\n        }\n    },\n    _inputImageWrapper,\n    _boxSize,\n    _decoder,\n    _workerPool = [],\n    _onUIThread = true,\n    _resultCollector,\n    _config = {};\n\nfunction initializeData(imageWrapper) {\n    initBuffers(imageWrapper);\n    _decoder = BarcodeDecoder.create(_config.decoder, _inputImageWrapper);\n}\n\nfunction initInputStream(cb) {\n    var video;\n    if (_config.inputStream.type === \"VideoStream\") {\n        video = document.createElement(\"video\");\n        _inputStream = InputStream.createVideoStream(video);\n    } else if (_config.inputStream.type === \"ImageStream\") {\n        _inputStream = InputStream.createImageStream();\n    } else if (_config.inputStream.type === \"LiveStream\") {\n        var $viewport = getViewPort();\n        if ($viewport) {\n            video = $viewport.querySelector(\"video\");\n            if (!video) {\n                video = document.createElement(\"video\");\n                $viewport.appendChild(video);\n            }\n        }\n        _inputStream = InputStream.createLiveStream(video);\n        CameraAccess.request(video, _config.inputStream.constraints)\n        .then(() => {\n            _inputStream.trigger(\"canrecord\");\n        }).catch((err) => {\n            return cb(err);\n        });\n    }\n\n    _inputStream.setAttribute(\"preload\", \"auto\");\n    _inputStream.setInputStream(_config.inputStream);\n    _inputStream.addEventListener(\"canrecord\", canRecord.bind(undefined, cb));\n}\n\nfunction getViewPort() {\n    var target = _config.inputStream.target;\n    // Check if target is already a DOM element\n    if (target && target.nodeName && target.nodeType === 1) {\n        return target;\n    } else {\n        // Use '#interactive.viewport' as a fallback selector (backwards compatibility)\n        var selector = typeof target === 'string' ? target : '#interactive.viewport';\n        return document.querySelector(selector);\n    }\n}\n\nfunction canRecord(cb) {\n    BarcodeLocator.checkImageConstraints(_inputStream, _config.locator);\n    initCanvas(_config);\n    _framegrabber = FrameGrabber.create(_inputStream, _canvasContainer.dom.image);\n\n    adjustWorkerPool(_config.numOfWorkers, function() {\n        if (_config.numOfWorkers === 0) {\n            initializeData();\n        }\n        ready(cb);\n    });\n}\n\nfunction ready(cb){\n    _inputStream.play();\n    cb();\n}\n\nfunction initCanvas() {\n    if (typeof document !== \"undefined\") {\n        var $viewport = getViewPort();\n        _canvasContainer.dom.image = document.querySelector(\"canvas.imgBuffer\");\n        if (!_canvasContainer.dom.image) {\n            _canvasContainer.dom.image = document.createElement(\"canvas\");\n            _canvasContainer.dom.image.className = \"imgBuffer\";\n            if ($viewport && _config.inputStream.type === \"ImageStream\") {\n                $viewport.appendChild(_canvasContainer.dom.image);\n            }\n        }\n        _canvasContainer.ctx.image = _canvasContainer.dom.image.getContext(\"2d\");\n        _canvasContainer.dom.image.width = _inputStream.getCanvasSize().x;\n        _canvasContainer.dom.image.height = _inputStream.getCanvasSize().y;\n\n        _canvasContainer.dom.overlay = document.querySelector(\"canvas.drawingBuffer\");\n        if (!_canvasContainer.dom.overlay) {\n            _canvasContainer.dom.overlay = document.createElement(\"canvas\");\n            _canvasContainer.dom.overlay.className = \"drawingBuffer\";\n            if ($viewport) {\n                $viewport.appendChild(_canvasContainer.dom.overlay);\n            }\n            var clearFix = document.createElement(\"br\");\n            clearFix.setAttribute(\"clear\", \"all\");\n            if ($viewport) {\n                $viewport.appendChild(clearFix);\n            }\n        }\n        _canvasContainer.ctx.overlay = _canvasContainer.dom.overlay.getContext(\"2d\");\n        _canvasContainer.dom.overlay.width = _inputStream.getCanvasSize().x;\n        _canvasContainer.dom.overlay.height = _inputStream.getCanvasSize().y;\n    }\n}\n\nfunction initBuffers(imageWrapper) {\n    if (imageWrapper) {\n        _inputImageWrapper = imageWrapper;\n    } else {\n        _inputImageWrapper = new ImageWrapper({\n            x: _inputStream.getWidth(),\n            y: _inputStream.getHeight()\n        });\n    }\n\n    if (ENV.development) {\n        console.log(_inputImageWrapper.size);\n    }\n    _boxSize = [\n        vec2.clone([0, 0]),\n        vec2.clone([0, _inputImageWrapper.size.y]),\n        vec2.clone([_inputImageWrapper.size.x, _inputImageWrapper.size.y]),\n        vec2.clone([_inputImageWrapper.size.x, 0])\n    ];\n    BarcodeLocator.init(_inputImageWrapper, _config.locator);\n}\n\nfunction getBoundingBoxes() {\n    if (_config.locate) {\n        return BarcodeLocator.locate();\n    } else {\n        return [[\n            vec2.clone(_boxSize[0]),\n            vec2.clone(_boxSize[1]),\n            vec2.clone(_boxSize[2]),\n            vec2.clone(_boxSize[3])]];\n    }\n}\n\nfunction transformResult(result) {\n    var topRight = _inputStream.getTopRight(),\n        xOffset = topRight.x,\n        yOffset = topRight.y,\n        i;\n\n    if (xOffset === 0 && yOffset === 0) {\n        return;\n    }\n\n    if (result.barcodes) {\n        for (i = 0; i < result.barcodes.length; i++) {\n            transformResult(result.barcodes[i]);\n        }\n    }\n\n    if (result.line && result.line.length === 2) {\n        moveLine(result.line);\n    }\n\n    if (result.box) {\n        moveBox(result.box);\n    }\n\n    if (result.boxes && result.boxes.length > 0) {\n        for (i = 0; i < result.boxes.length; i++) {\n            moveBox(result.boxes[i]);\n        }\n    }\n\n    function moveBox(box) {\n        var corner = box.length;\n\n        while (corner--) {\n            box[corner][0] += xOffset;\n            box[corner][1] += yOffset;\n        }\n    }\n\n    function moveLine(line) {\n        line[0].x += xOffset;\n        line[0].y += yOffset;\n        line[1].x += xOffset;\n        line[1].y += yOffset;\n    }\n}\n\nfunction addResult (result, imageData) {\n    if (!imageData || !_resultCollector) {\n        return;\n    }\n\n    if (result.barcodes) {\n        result.barcodes.filter(barcode => barcode.codeResult)\n            .forEach(barcode => addResult(barcode, imageData));\n    } else if (result.codeResult) {\n        _resultCollector.addResult(imageData, _inputStream.getCanvasSize(), result.codeResult);\n    }\n}\n\nfunction hasCodeResult (result) {\n    return result && (result.barcodes ?\n      result.barcodes.some(barcode => barcode.codeResult) :\n      result.codeResult);\n}\n\nfunction publishResult(result, imageData) {\n    let resultToPublish = result;\n\n    if (result && _onUIThread) {\n        transformResult(result);\n        addResult(result, imageData);\n        resultToPublish = result.barcodes || result;\n    }\n\n    Events.publish(\"processed\", resultToPublish);\n    if (hasCodeResult(result)) {\n        Events.publish(\"detected\", resultToPublish);\n    }\n}\n\nfunction locateAndDecode() {\n    var result,\n        boxes;\n\n    boxes = getBoundingBoxes();\n    if (boxes) {\n        result = _decoder.decodeFromBoundingBoxes(boxes);\n        result = result || {};\n        result.boxes = boxes;\n        publishResult(result, _inputImageWrapper.data);\n    } else {\n        publishResult();\n    }\n}\n\nfunction update() {\n    var availableWorker;\n\n    if (_onUIThread) {\n        if (_workerPool.length > 0) {\n            availableWorker = _workerPool.filter(function(workerThread) {\n                return !workerThread.busy;\n            })[0];\n            if (availableWorker) {\n                _framegrabber.attachData(availableWorker.imageData);\n            } else {\n                return; // all workers are busy\n            }\n        } else {\n            _framegrabber.attachData(_inputImageWrapper.data);\n        }\n        if (_framegrabber.grab()) {\n            if (availableWorker) {\n                availableWorker.busy = true;\n                availableWorker.worker.postMessage({\n                    cmd: 'process',\n                    imageData: availableWorker.imageData\n                }, [availableWorker.imageData.buffer]);\n            } else {\n                locateAndDecode();\n            }\n        }\n    } else {\n        locateAndDecode();\n    }\n}\n\nfunction startContinuousUpdate() {\n    var next = null,\n        delay = 1000 / (_config.frequency || 60);\n\n    _stopped = false;\n    (function frame(timestamp) {\n        next = next || timestamp;\n        if (!_stopped) {\n            if (timestamp >= next) {\n                next += delay;\n                update();\n            }\n            window.requestAnimFrame(frame);\n        }\n    }(performance.now()));\n}\n\nfunction start() {\n    if (_onUIThread && _config.inputStream.type === \"LiveStream\") {\n        startContinuousUpdate();\n    } else {\n        update();\n    }\n}\n\nfunction initWorker(cb) {\n    var blobURL,\n        workerThread = {\n            worker: undefined,\n            imageData: new Uint8Array(_inputStream.getWidth() * _inputStream.getHeight()),\n            busy: true\n        };\n\n    blobURL = generateWorkerBlob();\n    workerThread.worker = new Worker(blobURL);\n\n    workerThread.worker.onmessage = function(e) {\n        if (e.data.event === 'initialized') {\n            URL.revokeObjectURL(blobURL);\n            workerThread.busy = false;\n            workerThread.imageData = new Uint8Array(e.data.imageData);\n            if (ENV.development) {\n                console.log(\"Worker initialized\");\n            }\n            return cb(workerThread);\n        } else if (e.data.event === 'processed') {\n            workerThread.imageData = new Uint8Array(e.data.imageData);\n            workerThread.busy = false;\n            publishResult(e.data.result, workerThread.imageData);\n        } else if (e.data.event === 'error') {\n            if (ENV.development) {\n                console.log(\"Worker error: \" + e.data.message);\n            }\n        }\n    };\n\n    workerThread.worker.postMessage({\n        cmd: 'init',\n        size: {x: _inputStream.getWidth(), y: _inputStream.getHeight()},\n        imageData: workerThread.imageData,\n        config: configForWorker(_config)\n    }, [workerThread.imageData.buffer]);\n}\n\nfunction configForWorker(config) {\n    return {\n        ...config,\n        inputStream: {\n            ...config.inputStream,\n            target: null\n        }\n    };\n}\n\nfunction workerInterface(factory) {\n    /* eslint-disable no-undef*/\n    if (factory) {\n        var Quagga = factory().default;\n        if (!Quagga) {\n            self.postMessage({'event': 'error', message: 'Quagga could not be created'});\n            return;\n        }\n    }\n    var imageWrapper;\n\n    self.onmessage = function(e) {\n        if (e.data.cmd === 'init') {\n            var config = e.data.config;\n            config.numOfWorkers = 0;\n            imageWrapper = new Quagga.ImageWrapper({\n                x: e.data.size.x,\n                y: e.data.size.y\n            }, new Uint8Array(e.data.imageData));\n            Quagga.init(config, ready, imageWrapper);\n            Quagga.onProcessed(onProcessed);\n        } else if (e.data.cmd === 'process') {\n            imageWrapper.data = new Uint8Array(e.data.imageData);\n            Quagga.start();\n        } else if (e.data.cmd === 'setReaders') {\n            Quagga.setReaders(e.data.readers);\n        }\n    };\n\n    function onProcessed(result) {\n        self.postMessage({\n            'event': 'processed',\n            imageData: imageWrapper.data,\n            result: result\n        }, [imageWrapper.data.buffer]);\n    }\n\n    function ready() { // eslint-disable-line\n        self.postMessage({'event': 'initialized', imageData: imageWrapper.data}, [imageWrapper.data.buffer]);\n    }\n\n    /* eslint-enable */\n}\n\nfunction generateWorkerBlob() {\n    var blob,\n        factorySource;\n\n    /* jshint ignore:start */\n    if (typeof __factorySource__ !== 'undefined') {\n        factorySource = __factorySource__; // eslint-disable-line no-undef\n    }\n    /* jshint ignore:end */\n\n    blob = new Blob(['(' + workerInterface.toString() + ')(' + factorySource + ');'],\n        {type: 'text/javascript'});\n\n    return window.URL.createObjectURL(blob);\n}\n\nfunction setReaders(readers) {\n    if (_decoder) {\n        _decoder.setReaders(readers);\n    } else if (_onUIThread && _workerPool.length > 0) {\n        _workerPool.forEach(function(workerThread) {\n            workerThread.worker.postMessage({cmd: 'setReaders', readers: readers});\n        });\n    }\n}\n\nfunction adjustWorkerPool(capacity, cb) {\n    const increaseBy = capacity - _workerPool.length;\n    if (increaseBy === 0) {\n        return cb && cb();\n    }\n    if (increaseBy < 0) {\n        const workersToTerminate = _workerPool.slice(increaseBy);\n        workersToTerminate.forEach(function(workerThread) {\n            workerThread.worker.terminate();\n            if (ENV.development) {\n                console.log(\"Worker terminated!\");\n            }\n        });\n        _workerPool = _workerPool.slice(0, increaseBy);\n        return cb && cb();\n    } else {\n        for (var i = 0; i < increaseBy; i++) {\n            initWorker(workerInitialized);\n        }\n\n        function workerInitialized(workerThread) {\n            _workerPool.push(workerThread);\n            if (_workerPool.length >= capacity){\n                cb && cb();\n            }\n        }\n    }\n}\n\nexport default {\n    init: function(config, cb, imageWrapper) {\n        _config = merge({}, Config, config);\n        if (imageWrapper) {\n            _onUIThread = false;\n            initializeData(imageWrapper);\n            return cb();\n        } else {\n            initInputStream(cb);\n        }\n    },\n    start: function() {\n        start();\n    },\n    stop: function() {\n        _stopped = true;\n        adjustWorkerPool(0);\n        if (_config.inputStream.type === \"LiveStream\") {\n            CameraAccess.release();\n            _inputStream.clearEventHandlers();\n        }\n    },\n    pause: function() {\n        _stopped = true;\n    },\n    onDetected: function(callback) {\n        Events.subscribe(\"detected\", callback);\n    },\n    offDetected: function(callback) {\n        Events.unsubscribe(\"detected\", callback);\n    },\n    onProcessed: function(callback) {\n        Events.subscribe(\"processed\", callback);\n    },\n    offProcessed: function(callback) {\n        Events.unsubscribe(\"processed\", callback);\n    },\n    setReaders: function(readers) {\n        setReaders(readers);\n    },\n    registerResultCollector: function(resultCollector) {\n        if (resultCollector && typeof resultCollector.addResult === 'function') {\n            _resultCollector = resultCollector;\n        }\n    },\n    canvas: _canvasContainer,\n    decodeSingle: function(config, resultCallback) {\n        config = merge({\n            inputStream: {\n                type: \"ImageStream\",\n                sequence: false,\n                size: 800,\n                src: config.src\n            },\n            numOfWorkers: (ENV.development && config.debug) ? 0 : 1,\n            locator: {\n                halfSample: false\n            }\n        }, config);\n        this.init(config, () => {\n            Events.once(\"processed\", (result) => {\n                this.stop();\n                resultCallback.call(null, result);\n            }, true);\n            start();\n        });\n    },\n    ImageWrapper: ImageWrapper,\n    ImageDebug: ImageDebug,\n    ResultCollector: ResultCollector,\n    CameraAccess: CameraAccess,\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/quagga.js","import ImageDebug from '../common/image_debug';\n\nfunction contains(codeResult, list) {\n    if (list) {\n        return list.some(function (item) {\n            return Object.keys(item).every(function (key) {\n                return item[key] === codeResult[key];\n            });\n        });\n    }\n    return false;\n}\n\nfunction passesFilter(codeResult, filter) {\n    if (typeof filter === 'function') {\n        return filter(codeResult);\n    }\n    return true;\n}\n\nexport default {\n    create: function(config) {\n        var canvas = document.createElement(\"canvas\"),\n            ctx = canvas.getContext(\"2d\"),\n            results = [],\n            capacity = config.capacity || 20,\n            capture = config.capture === true;\n\n        function matchesConstraints(codeResult) {\n            return capacity\n                && codeResult\n                && !contains(codeResult, config.blacklist)\n                && passesFilter(codeResult, config.filter);\n        }\n\n        return {\n            addResult: function(data, imageSize, codeResult) {\n                var result = {};\n\n                if (matchesConstraints(codeResult)) {\n                    capacity--;\n                    result.codeResult = codeResult;\n                    if (capture) {\n                        canvas.width = imageSize.x;\n                        canvas.height = imageSize.y;\n                        ImageDebug.drawImage(data, imageSize, ctx);\n                        result.frame = canvas.toDataURL();\n                    }\n                    results.push(result);\n                }\n            },\n            getResults: function() {\n                return results;\n            }\n        };\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/analytics/result_collector.js","const vec2 = {\n    clone: require('gl-vec2/clone'),\n    dot: require('gl-vec2/dot')\n}\n    /**\n     * Creates a cluster for grouping similar orientations of datapoints\n     */\nexport default {\n    create: function(point, threshold) {\n        var points = [],\n            center = {\n                rad: 0,\n                vec: vec2.clone([0, 0])\n            },\n            pointMap = {};\n\n        function init() {\n            add(point);\n            updateCenter();\n        }\n\n        function add(pointToAdd) {\n            pointMap[pointToAdd.id] = pointToAdd;\n            points.push(pointToAdd);\n        }\n\n        function updateCenter() {\n            var i, sum = 0;\n            for ( i = 0; i < points.length; i++) {\n                sum += points[i].rad;\n            }\n            center.rad = sum / points.length;\n            center.vec = vec2.clone([Math.cos(center.rad), Math.sin(center.rad)]);\n        }\n\n        init();\n\n        return {\n            add: function(pointToAdd) {\n                if (!pointMap[pointToAdd.id]) {\n                    add(pointToAdd);\n                    updateCenter();\n                }\n            },\n            fits: function(otherPoint) {\n                // check cosine similarity to center-angle\n                var similarity = Math.abs(vec2.dot(otherPoint.point.vec, center.vec));\n                if (similarity > threshold) {\n                    return true;\n                }\n                return false;\n            },\n            getPoints: function() {\n                return points;\n            },\n            getCenter: function() {\n                return center;\n            }\n        };\n    },\n    createPoint: function(newPoint, id, property) {\n        return {\n            rad: newPoint[property],\n            point: newPoint,\n            id: id\n        };\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/cluster.js","export default (function() {\n    var events = {};\n\n    function getEvent(eventName) {\n        if (!events[eventName]) {\n            events[eventName] = {\n                subscribers: []\n            };\n        }\n        return events[eventName];\n    }\n\n    function clearEvents(){\n        events = {};\n    }\n\n    function publishSubscription(subscription, data) {\n        if (subscription.async) {\n            setTimeout(function() {\n                subscription.callback(data);\n            }, 4);\n        } else {\n            subscription.callback(data);\n        }\n    }\n\n    function subscribe(event, callback, async) {\n        var subscription;\n\n        if ( typeof callback === \"function\") {\n            subscription = {\n                callback: callback,\n                async: async\n            };\n        } else {\n            subscription = callback;\n            if (!subscription.callback) {\n                throw \"Callback was not specified on options\";\n            }\n        }\n\n        getEvent(event).subscribers.push(subscription);\n    }\n\n    return {\n        subscribe: function(event, callback, async) {\n            return subscribe(event, callback, async);\n        },\n        publish: function(eventName, data) {\n            var event = getEvent(eventName),\n                subscribers = event.subscribers;\n\n            // Publish one-time subscriptions\n            subscribers.filter(function(subscriber) {\n                return !!subscriber.once;\n            }).forEach((subscriber) => {\n                publishSubscription(subscriber, data);\n            });\n\n            // remove them from the subscriber\n            event.subscribers = subscribers.filter(function(subscriber) {\n                return !subscriber.once;\n            });\n\n            // publish the rest\n            event.subscribers.forEach((subscriber) => {\n                publishSubscription(subscriber, data);\n            });\n        },\n        once: function(event, callback, async) {\n            subscribe(event, {\n                callback: callback,\n                async: async,\n                once: true\n            });\n        },\n        unsubscribe: function(eventName, callback) {\n            var event;\n\n            if (eventName) {\n                event = getEvent(eventName);\n                if (event && callback) {\n                    event.subscribers = event.subscribers.filter(function(subscriber){\n                        return subscriber.callback !== callback;\n                    });\n                } else {\n                    event.subscribers = [];\n                }\n            } else {\n                clearEvents();\n            }\n        }\n    };\n})();\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/events.js","\nexport function enumerateDevices() {\n    if (navigator.mediaDevices\n            && typeof navigator.mediaDevices.enumerateDevices === 'function') {\n        return navigator.mediaDevices.enumerateDevices();\n    }\n    return Promise.reject(new Error('enumerateDevices is not defined'));\n};\n\nexport function getUserMedia(constraints) {\n    if (navigator.mediaDevices\n            && typeof navigator.mediaDevices.getUserMedia === 'function') {\n        return navigator.mediaDevices\n            .getUserMedia(constraints);\n    }\n    return Promise.reject(new Error('getUserMedia is not defined'));\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/mediaDevices.js","/**\n * Construct representing a part of another {ImageWrapper}. Shares data\n * between the parent and the child.\n * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner)\n * @param size {ImageRef} The size of the resulting image\n * @param I {ImageWrapper} The {ImageWrapper} to share from\n * @returns {SubImage} A shared part of the original image\n */\nfunction SubImage(from, size, I) {\n    if (!I) {\n        I = {\n            data: null,\n            size: size\n        };\n    }\n    this.data = I.data;\n    this.originalSize = I.size;\n    this.I = I;\n\n    this.from = from;\n    this.size = size;\n}\n\n/**\n * Displays the {SubImage} in a given canvas\n * @param canvas {Canvas} The canvas element to write to\n * @param scale {Number} Scale which is applied to each pixel-value\n */\nSubImage.prototype.show = function(canvas, scale) {\n    var ctx,\n        frame,\n        data,\n        current,\n        y,\n        x,\n        pixel;\n\n    if (!scale) {\n        scale = 1.0;\n    }\n    ctx = canvas.getContext('2d');\n    canvas.width = this.size.x;\n    canvas.height = this.size.y;\n    frame = ctx.getImageData(0, 0, canvas.width, canvas.height);\n    data = frame.data;\n    current = 0;\n    for (y = 0; y < this.size.y; y++) {\n        for (x = 0; x < this.size.x; x++) {\n            pixel = y * this.size.x + x;\n            current = this.get(x, y) * scale;\n            data[pixel * 4 + 0] = current;\n            data[pixel * 4 + 1] = current;\n            data[pixel * 4 + 2] = current;\n            data[pixel * 4 + 3] = 255;\n        }\n    }\n    frame.data = data;\n    ctx.putImageData(frame, 0, 0);\n};\n\n/**\n * Retrieves a given pixel position from the {SubImage}\n * @param x {Number} The x-position\n * @param y {Number} The y-position\n * @returns {Number} The grayscale value at the pixel-position\n */\nSubImage.prototype.get = function(x, y) {\n    return this.data[(this.from.y + y) * this.originalSize.x + this.from.x + x];\n};\n\n/**\n * Updates the underlying data from a given {ImageWrapper}\n * @param image {ImageWrapper} The updated image\n */\nSubImage.prototype.updateData = function(image) {\n    this.originalSize = image.size;\n    this.data = image.data;\n};\n\n/**\n * Updates the position of the shared area\n * @param from {x,y} The new location\n * @returns {SubImage} returns {this} for possible chaining\n */\nSubImage.prototype.updateFrom = function(from) {\n    this.from = from;\n    return this;\n};\n\nexport default (SubImage);\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/subImage.js","/*\n * typedefs.js\n * Normalizes browser-specific prefixes\n */\n\nif (typeof window !== 'undefined') {\n    window.requestAnimFrame = (function () {\n        return window.requestAnimationFrame ||\n            window.webkitRequestAnimationFrame ||\n            window.mozRequestAnimationFrame ||\n            window.oRequestAnimationFrame ||\n            window.msRequestAnimationFrame ||\n            function (/* function FrameRequestCallback */ callback) {\n                window.setTimeout(callback, 1000 / 60);\n            };\n    })();\n}\nMath.imul = Math.imul || function(a, b) {\n    var ah = (a >>> 16) & 0xffff,\n        al = a & 0xffff,\n        bh = (b >>> 16) & 0xffff,\n        bl = b & 0xffff;\n    // the shift by 0 fixes the sign on the high part\n    // the final |0 converts the unsigned value into a signed value\n    return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) | 0);\n};\n\nif (typeof Object.assign !== 'function') {\n    Object.assign = function(target) { // .length of function is 2\n        'use strict';\n        if (target === null) { // TypeError if undefined or null\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var to = Object(target);\n\n        for (var index = 1; index < arguments.length; index++) {\n            var nextSource = arguments[index];\n\n            if (nextSource !== null) { // Skip over if undefined or null\n                for (var nextKey in nextSource) {\n                    // Avoid bugs when hasOwnProperty is shadowed\n                    if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {\n                        to[nextKey] = nextSource[nextKey];\n                    }\n                }\n            }\n        }\n        return to;\n    };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/common/typedefs.js","module.exports = {\n    inputStream: {\n        name: \"Live\",\n        type: \"LiveStream\",\n        constraints: {\n            width: 640,\n            height: 480,\n            // aspectRatio: 640/480, // optional\n            facingMode: \"environment\", // or user\n            // deviceId: \"38745983457387598375983759834\"\n        },\n        area: {\n            top: \"0%\",\n            right: \"0%\",\n            left: \"0%\",\n            bottom: \"0%\"\n        },\n        singleChannel: false // true: only the red color-channel is read\n    },\n    locate: true,\n    numOfWorkers: 0,\n    decoder: {\n        readers: [\n            'code_128_reader'\n        ],\n        debug: {\n            drawBoundingBox: false,\n            showFrequency: false,\n            drawScanline: false,\n            showPattern: false\n        }\n    },\n    locator: {\n        halfSample: true,\n        patchSize: \"medium\", // x-small, small, medium, large, x-large\n        debug: {\n            showCanvas: false,\n            showPatches: false,\n            showFoundPatches: false,\n            showSkeleton: false,\n            showLabels: false,\n            showPatchLabels: false,\n            showRemainingPatchLabels: false,\n            boxFromPatches: {\n                showTransformed: false,\n                showTransformedBox: false,\n                showBB: false\n            }\n        }\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/config/config.dev.js","let config;\n\nif (ENV.development){\n    config = require('./config.dev.js');\n} else if (ENV.node) {\n    config = require('./config.node.js');\n} else {\n    config = require('./config.prod.js');\n}\n\nexport default config;\n\n\n\n// WEBPACK FOOTER //\n// ./src/config/config.js","import Bresenham from './bresenham';\nimport ImageDebug from '../common/image_debug';\nimport Code128Reader from '../reader/code_128_reader';\nimport EANReader from '../reader/ean_reader';\nimport Code39Reader from '../reader/code_39_reader';\nimport Code39VINReader from '../reader/code_39_vin_reader';\nimport CodabarReader from '../reader/codabar_reader';\nimport UPCReader from '../reader/upc_reader';\nimport EAN8Reader from '../reader/ean_8_reader';\nimport EAN2Reader from '../reader/ean_2_reader';\nimport EAN5Reader from '../reader/ean_5_reader';\nimport UPCEReader from '../reader/upc_e_reader';\nimport I2of5Reader from '../reader/i2of5_reader';\nimport TwoOfFiveReader from '../reader/2of5_reader';\nimport Code93Reader from '../reader/code_93_reader';\n\nconst READERS = {\n    code_128_reader: Code128Reader,\n    ean_reader: EANReader,\n    ean_5_reader: EAN5Reader,\n    ean_2_reader: EAN2Reader,\n    ean_8_reader: EAN8Reader,\n    code_39_reader: Code39Reader,\n    code_39_vin_reader: Code39VINReader,\n    codabar_reader: CodabarReader,\n    upc_reader: UPCReader,\n    upc_e_reader: UPCEReader,\n    i2of5_reader: I2of5Reader,\n    '2of5_reader': TwoOfFiveReader,\n    code_93_reader: Code93Reader\n};\nexport default {\n    create: function(config, inputImageWrapper) {\n        var _canvas = {\n                ctx: {\n                    frequency: null,\n                    pattern: null,\n                    overlay: null\n                },\n                dom: {\n                    frequency: null,\n                    pattern: null,\n                    overlay: null\n                }\n            },\n            _barcodeReaders = [];\n\n        initCanvas();\n        initReaders();\n        initConfig();\n\n        function initCanvas() {\n            if (ENV.development && typeof document !== 'undefined') {\n                var $debug = document.querySelector(\"#debug.detection\");\n                _canvas.dom.frequency = document.querySelector(\"canvas.frequency\");\n                if (!_canvas.dom.frequency) {\n                    _canvas.dom.frequency = document.createElement(\"canvas\");\n                    _canvas.dom.frequency.className = \"frequency\";\n                    if ($debug) {\n                        $debug.appendChild(_canvas.dom.frequency);\n                    }\n                }\n                _canvas.ctx.frequency = _canvas.dom.frequency.getContext(\"2d\");\n\n                _canvas.dom.pattern = document.querySelector(\"canvas.patternBuffer\");\n                if (!_canvas.dom.pattern) {\n                    _canvas.dom.pattern = document.createElement(\"canvas\");\n                    _canvas.dom.pattern.className = \"patternBuffer\";\n                    if ($debug) {\n                        $debug.appendChild(_canvas.dom.pattern);\n                    }\n                }\n                _canvas.ctx.pattern = _canvas.dom.pattern.getContext(\"2d\");\n\n                _canvas.dom.overlay = document.querySelector(\"canvas.drawingBuffer\");\n                if (_canvas.dom.overlay) {\n                    _canvas.ctx.overlay = _canvas.dom.overlay.getContext(\"2d\");\n                }\n            }\n        }\n\n        function initReaders() {\n            config.readers.forEach(function(readerConfig) {\n                var reader,\n                    configuration = {},\n                    supplements = [];\n\n                if (typeof readerConfig === 'object') {\n                    reader = readerConfig.format;\n                    configuration = readerConfig.config;\n                } else if (typeof readerConfig === 'string') {\n                    reader = readerConfig;\n                }\n                if (ENV.development) {\n                    console.log(\"Before registering reader: \", reader);\n                }\n                if (configuration.supplements) {\n                    supplements = configuration\n                        .supplements.map((supplement) => {\n                            return new READERS[supplement]();\n                        });\n                }\n                _barcodeReaders.push(new READERS[reader](configuration, supplements));\n            });\n            if (ENV.development) {\n                console.log(\"Registered Readers: \" + _barcodeReaders\n                    .map((reader) => JSON.stringify({format: reader.FORMAT, config: reader.config}))\n                    .join(', '));\n            }\n        }\n\n        function initConfig() {\n            if (ENV.development && typeof document !== 'undefined') {\n                var i,\n                    vis = [{\n                        node: _canvas.dom.frequency,\n                        prop: config.debug.showFrequency\n                    }, {\n                        node: _canvas.dom.pattern,\n                        prop: config.debug.showPattern\n                    }];\n\n                for (i = 0; i < vis.length; i++) {\n                    if (vis[i].prop === true) {\n                        vis[i].node.style.display = \"block\";\n                    } else {\n                        vis[i].node.style.display = \"none\";\n                    }\n                }\n            }\n        }\n\n        /**\n         * extend the line on both ends\n         * @param {Array} line\n         * @param {Number} angle\n         */\n        function getExtendedLine(line, angle, ext) {\n            function extendLine(amount) {\n                var extension = {\n                    y: amount * Math.sin(angle),\n                    x: amount * Math.cos(angle)\n                };\n\n                line[0].y -= extension.y;\n                line[0].x -= extension.x;\n                line[1].y += extension.y;\n                line[1].x += extension.x;\n            }\n\n            // check if inside image\n            extendLine(ext);\n            while (ext > 1 && (!inputImageWrapper.inImageWithBorder(line[0], 0)\n                    || !inputImageWrapper.inImageWithBorder(line[1], 0))) {\n                ext -= Math.ceil(ext / 2);\n                extendLine(-ext);\n            }\n            return line;\n        }\n\n        function getLine(box) {\n            return [{\n                x: (box[1][0] - box[0][0]) / 2 + box[0][0],\n                y: (box[1][1] - box[0][1]) / 2 + box[0][1]\n            }, {\n                x: (box[3][0] - box[2][0]) / 2 + box[2][0],\n                y: (box[3][1] - box[2][1]) / 2 + box[2][1]\n            }];\n        }\n\n        function tryDecode(line) {\n            var result = null,\n                i,\n                barcodeLine = Bresenham.getBarcodeLine(inputImageWrapper, line[0], line[1]);\n\n            if (ENV.development && config.debug.showFrequency) {\n                ImageDebug.drawPath(line, {x: 'x', y: 'y'}, _canvas.ctx.overlay, {color: 'red', lineWidth: 3});\n                Bresenham.debug.printFrequency(barcodeLine.line, _canvas.dom.frequency);\n            }\n\n            Bresenham.toBinaryLine(barcodeLine);\n\n            if (ENV.development && config.debug.showPattern) {\n                Bresenham.debug.printPattern(barcodeLine.line, _canvas.dom.pattern);\n            }\n\n            for ( i = 0; i < _barcodeReaders.length && result === null; i++) {\n                result = _barcodeReaders[i].decodePattern(barcodeLine.line);\n            }\n            if (result === null){\n                return null;\n            }\n            return {\n                codeResult: result,\n                barcodeLine: barcodeLine\n            };\n        }\n\n        /**\n         * This method slices the given area apart and tries to detect a barcode-pattern\n         * for each slice. It returns the decoded barcode, or null if nothing was found\n         * @param {Array} box\n         * @param {Array} line\n         * @param {Number} lineAngle\n         */\n        function tryDecodeBruteForce(box, line, lineAngle) {\n            var sideLength = Math.sqrt(Math.pow(box[1][0] - box[0][0], 2) + Math.pow((box[1][1] - box[0][1]), 2)),\n                i,\n                slices = 16,\n                result = null,\n                dir,\n                extension,\n                xdir = Math.sin(lineAngle),\n                ydir = Math.cos(lineAngle);\n\n            for ( i = 1; i < slices && result === null; i++) {\n                // move line perpendicular to angle\n                dir = sideLength / slices * i * (i % 2 === 0 ? -1 : 1);\n                extension = {\n                    y: dir * xdir,\n                    x: dir * ydir\n                };\n                line[0].y += extension.x;\n                line[0].x -= extension.y;\n                line[1].y += extension.x;\n                line[1].x -= extension.y;\n\n                result = tryDecode(line);\n            }\n            return result;\n        }\n\n        function getLineLength(line) {\n            return Math.sqrt(\n                Math.pow(Math.abs(line[1].y - line[0].y), 2) +\n                Math.pow(Math.abs(line[1].x - line[0].x), 2));\n        }\n\n        /**\n         * With the help of the configured readers (Code128 or EAN) this function tries to detect a\n         * valid barcode pattern within the given area.\n         * @param {Object} box The area to search in\n         * @returns {Object} the result {codeResult, line, angle, pattern, threshold}\n         */\n        function decodeFromBoundingBox(box) {\n            var line,\n                lineAngle,\n                ctx = _canvas.ctx.overlay,\n                result,\n                lineLength;\n\n            if (ENV.development) {\n                if (config.debug.drawBoundingBox && ctx) {\n                    ImageDebug.drawPath(box, {x: 0, y: 1}, ctx, {color: \"blue\", lineWidth: 2});\n                }\n            }\n\n            line = getLine(box);\n            lineLength = getLineLength(line);\n            lineAngle = Math.atan2(line[1].y - line[0].y, line[1].x - line[0].x);\n            line = getExtendedLine(line, lineAngle, Math.floor(lineLength * 0.1));\n            if (line === null){\n                return null;\n            }\n\n            result = tryDecode(line);\n            if (result === null) {\n                result = tryDecodeBruteForce(box, line, lineAngle);\n            }\n\n            if (result === null) {\n                return null;\n            }\n\n            if (ENV.development && result && config.debug.drawScanline && ctx) {\n                ImageDebug.drawPath(line, {x: 'x', y: 'y'}, ctx, {color: 'red', lineWidth: 3});\n            }\n\n            return {\n                codeResult: result.codeResult,\n                line: line,\n                angle: lineAngle,\n                pattern: result.barcodeLine.line,\n                threshold: result.barcodeLine.threshold\n            };\n        }\n\n        return {\n            decodeFromBoundingBox: function(box) {\n                return decodeFromBoundingBox(box);\n            },\n            decodeFromBoundingBoxes: function(boxes) {\n                var i, result,\n                    barcodes = [],\n                    multiple = config.multiple;\n\n                for ( i = 0; i < boxes.length; i++) {\n                    const box = boxes[i];\n                    result = decodeFromBoundingBox(box) || {};\n                    result.box = box;\n\n                    if (multiple) {\n                        barcodes.push(result);\n                    } else if (result.codeResult) {\n                        return result;\n                    }\n                }\n\n                if (multiple) {\n                    return {\n                        barcodes\n                    };\n                }\n            },\n            setReaders: function(readers) {\n                config.readers = readers;\n                _barcodeReaders.length = 0;\n                initReaders();\n            }\n        };\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/decoder/barcode_decoder.js","import ImageWrapper from '../common/image_wrapper';\n\nvar Bresenham = {};\n\nvar Slope = {\n    DIR: {\n        UP: 1,\n        DOWN: -1\n    }\n};\n/**\n * Scans a line of the given image from point p1 to p2 and returns a result object containing\n * gray-scale values (0-255) of the underlying pixels in addition to the min\n * and max values.\n * @param {Object} imageWrapper\n * @param {Object} p1 The start point {x,y}\n * @param {Object} p2 The end point {x,y}\n * @returns {line, min, max}\n */\nBresenham.getBarcodeLine = function(imageWrapper, p1, p2) {\n    var x0 = p1.x | 0,\n        y0 = p1.y | 0,\n        x1 = p2.x | 0,\n        y1 = p2.y | 0,\n        steep = Math.abs(y1 - y0) > Math.abs(x1 - x0),\n        deltax,\n        deltay,\n        error,\n        ystep,\n        y,\n        tmp,\n        x,\n        line = [],\n        imageData = imageWrapper.data,\n        width = imageWrapper.size.x,\n        sum = 0,\n        val,\n        min = 255,\n        max = 0;\n\n    function read(a, b) {\n        val = imageData[b * width + a];\n        sum += val;\n        min = val < min ? val : min;\n        max = val > max ? val : max;\n        line.push(val);\n    }\n\n    if (steep) {\n        tmp = x0;\n        x0 = y0;\n        y0 = tmp;\n\n        tmp = x1;\n        x1 = y1;\n        y1 = tmp;\n    }\n    if (x0 > x1) {\n        tmp = x0;\n        x0 = x1;\n        x1 = tmp;\n\n        tmp = y0;\n        y0 = y1;\n        y1 = tmp;\n    }\n    deltax = x1 - x0;\n    deltay = Math.abs(y1 - y0);\n    error = (deltax / 2) | 0;\n    y = y0;\n    ystep = y0 < y1 ? 1 : -1;\n    for ( x = x0; x < x1; x++) {\n        if (steep){\n            read(y, x);\n        } else {\n            read(x, y);\n        }\n        error = error - deltay;\n        if (error < 0) {\n            y = y + ystep;\n            error = error + deltax;\n        }\n    }\n\n    return {\n        line: line,\n        min: min,\n        max: max\n    };\n};\n\n/**\n * Converts the result from getBarcodeLine into a binary representation\n * also considering the frequency and slope of the signal for more robust results\n * @param {Object} result {line, min, max}\n */\nBresenham.toBinaryLine = function(result) {\n    var min = result.min,\n        max = result.max,\n        line = result.line,\n        slope,\n        slope2,\n        center = min + (max - min) / 2,\n        extrema = [],\n        currentDir,\n        dir,\n        threshold = (max - min) / 12,\n        rThreshold = -threshold,\n        i,\n        j;\n\n    // 1. find extrema\n    currentDir = line[0] > center ? Slope.DIR.UP : Slope.DIR.DOWN;\n    extrema.push({\n        pos: 0,\n        val: line[0]\n    });\n    for ( i = 0; i < line.length - 2; i++) {\n        slope = (line[i + 1] - line[i]);\n        slope2 = (line[i + 2] - line[i + 1]);\n        if ((slope + slope2) < rThreshold && line[i + 1] < (center * 1.5)) {\n            dir = Slope.DIR.DOWN;\n        } else if ((slope + slope2) > threshold && line[i + 1] > (center * 0.5)) {\n            dir = Slope.DIR.UP;\n        } else {\n            dir = currentDir;\n        }\n\n        if (currentDir !== dir) {\n            extrema.push({\n                pos: i,\n                val: line[i]\n            });\n            currentDir = dir;\n        }\n    }\n    extrema.push({\n        pos: line.length,\n        val: line[line.length - 1]\n    });\n\n    for ( j = extrema[0].pos; j < extrema[1].pos; j++) {\n        line[j] = line[j] > center ? 0 : 1;\n    }\n\n    // iterate over extrema and convert to binary based on avg between minmax\n    for ( i = 1; i < extrema.length - 1; i++) {\n        if (extrema[i + 1].val > extrema[i].val) {\n            threshold = (extrema[i].val + ((extrema[i + 1].val - extrema[i].val) / 3) * 2) | 0;\n        } else {\n            threshold = (extrema[i + 1].val + ((extrema[i].val - extrema[i + 1].val) / 3)) | 0;\n        }\n\n        for ( j = extrema[i].pos; j < extrema[i + 1].pos; j++) {\n            line[j] = line[j] > threshold ? 0 : 1;\n        }\n    }\n\n    return {\n        line: line,\n        threshold: threshold\n    };\n};\n\n/**\n * Used for development only\n */\nBresenham.debug = {\n    printFrequency: function(line, canvas) {\n        var i,\n            ctx = canvas.getContext(\"2d\");\n        canvas.width = line.length;\n        canvas.height = 256;\n\n        ctx.beginPath();\n        ctx.strokeStyle = \"blue\";\n        for ( i = 0; i < line.length; i++) {\n            ctx.moveTo(i, 255);\n            ctx.lineTo(i, 255 - line[i]);\n        }\n        ctx.stroke();\n        ctx.closePath();\n    },\n\n    printPattern: function(line, canvas) {\n        var ctx = canvas.getContext(\"2d\"), i;\n\n        canvas.width = line.length;\n        ctx.fillColor = \"black\";\n        for ( i = 0; i < line.length; i++) {\n            if (line[i] === 1) {\n                ctx.fillRect(i, 0, 1, 100);\n            }\n        }\n    }\n};\n\nexport default Bresenham;\n\n\n\n// WEBPACK FOOTER //\n// ./src/decoder/bresenham.js","import {omit, pick} from 'lodash';\nimport {getUserMedia, enumerateDevices} from 'mediaDevices';\n\nconst facingMatching = {\n    \"user\": /front/i,\n    \"environment\": /back/i\n};\n\nvar streamRef;\n\nfunction waitForVideo(video) {\n    return new Promise((resolve, reject) => {\n        let attempts = 10;\n\n        function checkVideo() {\n            if (attempts > 0) {\n                if (video.videoWidth > 10 && video.videoHeight > 10) {\n                    if (ENV.development) {\n                        console.log(video.videoWidth + \"px x \" + video.videoHeight + \"px\");\n                    }\n                    resolve();\n                } else {\n                    window.setTimeout(checkVideo, 500);\n                }\n            } else {\n                reject('Unable to play video stream. Is webcam working?');\n            }\n            attempts--;\n        }\n        checkVideo();\n    });\n}\n\n/**\n * Tries to attach the camera-stream to a given video-element\n * and calls the callback function when the content is ready\n * @param {Object} constraints\n * @param {Object} video\n */\nfunction initCamera(video, constraints) {\n    return getUserMedia(constraints)\n    .then((stream) => {\n        return new Promise((resolve) => {\n            streamRef = stream;\n            video.setAttribute(\"autoplay\", true);\n            video.setAttribute('muted', true);\n            video.setAttribute('playsinline', true);\n            video.srcObject = stream;\n            video.addEventListener('loadedmetadata', () => {\n                video.play();\n                resolve();\n            });\n        });\n    })\n    .then(waitForVideo.bind(null, video));\n}\n\nfunction deprecatedConstraints(videoConstraints) {\n    const normalized = pick(videoConstraints, [\"width\", \"height\", \"facingMode\",\n            \"aspectRatio\", \"deviceId\"]);\n\n    if (typeof videoConstraints.minAspectRatio !== 'undefined' &&\n            videoConstraints.minAspectRatio > 0) {\n        normalized.aspectRatio = videoConstraints.minAspectRatio;\n        console.log(\"WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead\");\n    }\n    if (typeof videoConstraints.facing !== 'undefined') {\n        normalized.facingMode = videoConstraints.facing;\n        console.log(\"WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'\");\n    }\n    return normalized;\n}\n\nexport function pickConstraints(videoConstraints) {\n    const normalizedConstraints = {\n        audio: false,\n        video: deprecatedConstraints(videoConstraints)\n    };\n\n    if (normalizedConstraints.video.deviceId\n            && normalizedConstraints.video.facingMode) {\n        delete normalizedConstraints.video.facingMode;\n    }\n    return Promise.resolve(normalizedConstraints);\n}\n\nfunction enumerateVideoDevices() {\n    return enumerateDevices()\n    .then(devices => devices.filter(device => device.kind === 'videoinput'));\n}\n\nfunction getActiveTrack() {\n    if (streamRef) {\n        const tracks = streamRef.getVideoTracks();\n        if (tracks && tracks.length) {\n            return tracks[0];\n        }\n    }\n}\n\nexport default {\n    request: function(video, videoConstraints) {\n        return pickConstraints(videoConstraints)\n            .then(initCamera.bind(null, video));\n    },\n    release: function() {\n        var tracks = streamRef && streamRef.getVideoTracks();\n        if (tracks && tracks.length) {\n            tracks[0].stop();\n        }\n        streamRef = null;\n    },\n    enumerateVideoDevices,\n    getActiveStreamLabel: function() {\n        const track = getActiveTrack();\n        return track ? track.label : '';\n    },\n    getActiveTrack\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/input/camera_access.js","// Scraped from https://github.com/exif-js/exif-js\n\nconst ExifTags = {0x0112: \"orientation\"};\nexport const AvailableTags = Object.keys(ExifTags).map(key => ExifTags[key]);\n\nexport function findTagsInObjectURL(src, tags = AvailableTags) {\n    if (/^blob\\:/i.test(src)) {\n        return objectURLToBlob(src)\n            .then(readToBuffer)\n            .then(buffer => findTagsInBuffer(buffer, tags));\n    }\n    return Promise.resolve(null);\n}\n\nexport function base64ToArrayBuffer(dataUrl) {\n    const base64 = dataUrl.replace(/^data\\:([^\\;]+)\\;base64,/gmi, ''),\n        binary = atob(base64),\n        len = binary.length,\n        buffer = new ArrayBuffer(len),\n        view = new Uint8Array(buffer);\n\n    for (let i = 0; i < len; i++) {\n        view[i] = binary.charCodeAt(i);\n    }\n    return buffer;\n}\n\nfunction readToBuffer(blob) {\n    return new Promise(resolve => {\n        const fileReader = new FileReader();\n        fileReader.onload = function(e) {\n            return resolve(e.target.result);\n        };\n        fileReader.readAsArrayBuffer(blob);\n    });\n}\n\nfunction objectURLToBlob(url) {\n    return new Promise((resolve, reject) => {\n        const http = new XMLHttpRequest();\n        http.open(\"GET\", url, true);\n        http.responseType = \"blob\";\n        http.onreadystatechange = function () {\n            if (http.readyState === XMLHttpRequest.DONE && (http.status === 200 || http.status === 0)) {\n                resolve(this.response);\n            }\n        };\n        http.onerror = reject;\n        http.send();\n    });\n}\n\nexport function findTagsInBuffer(file, selectedTags = AvailableTags) {\n    const dataView = new DataView(file),\n        length = file.byteLength,\n        exifTags = selectedTags.reduce((result, selectedTag) => {\n            const exifTag = Object.keys(ExifTags).filter(tag => ExifTags[tag] === selectedTag)[0];\n            if (exifTag) {\n                result[exifTag] = selectedTag;\n            }\n            return result;\n        }, {});\n    let offset = 2,\n        marker;\n\n    if ((dataView.getUint8(0) !== 0xFF) || (dataView.getUint8(1) !== 0xD8)) {\n        return false;\n    }\n\n    while (offset < length) {\n        if (dataView.getUint8(offset) !== 0xFF) {\n            return false;\n        }\n\n        marker = dataView.getUint8(offset + 1);\n        if (marker === 0xE1) {\n            return readEXIFData(dataView, offset + 4, exifTags);\n        } else {\n            offset += 2 + dataView.getUint16(offset + 2);\n        }\n    }\n}\n\nfunction readEXIFData(file, start, exifTags) {\n    if (getStringFromBuffer(file, start, 4) !== \"Exif\") {\n        return false;\n    }\n\n    const tiffOffset = start + 6;\n    let bigEnd,\n        tags;\n\n    if (file.getUint16(tiffOffset) === 0x4949) {\n        bigEnd = false;\n    } else if (file.getUint16(tiffOffset) === 0x4D4D) {\n        bigEnd = true;\n    } else {\n        return false;\n    }\n\n    if (file.getUint16(tiffOffset + 2, !bigEnd) !== 0x002A) {\n        return false;\n    }\n\n    const firstIFDOffset = file.getUint32(tiffOffset + 4, !bigEnd);\n    if (firstIFDOffset < 0x00000008) {\n        return false;\n    }\n\n    tags = readTags(file, tiffOffset, tiffOffset + firstIFDOffset, exifTags, bigEnd);\n    return tags;\n}\n\nfunction readTags(file, tiffStart, dirStart, strings, bigEnd) {\n    const entries = file.getUint16(dirStart, !bigEnd),\n        tags = {};\n\n    for (let i = 0; i < entries; i++) {\n        const entryOffset = dirStart + i * 12 + 2,\n            tag = strings[file.getUint16(entryOffset, !bigEnd)];\n        if (tag) {\n            tags[tag] = readTagValue(file, entryOffset, tiffStart, dirStart, bigEnd);\n        }\n    }\n    return tags;\n}\n\nfunction readTagValue(file, entryOffset, tiffStart, dirStart, bigEnd) {\n    const type = file.getUint16(entryOffset + 2, !bigEnd),\n        numValues = file.getUint32(entryOffset + 4, !bigEnd);\n\n    switch (type) {\n    case 3:\n        if (numValues === 1) {\n            return file.getUint16(entryOffset + 8, !bigEnd);\n        }\n    }\n}\n\nfunction getStringFromBuffer(buffer, start, length) {\n    let outstr = \"\";\n    for (let n = start; n < start + length; n++) {\n        outstr += String.fromCharCode(buffer.getUint8(n));\n    }\n    return outstr;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/input/exif_helper.js","import {\n    imageRef,\n    grayAndHalfSampleFromCanvasData,\n    computeGray\n} from '../common/cv_utils';\n\nconst TO_RADIANS = Math.PI / 180;\n\nfunction adjustCanvasSize(canvas, targetSize) {\n    if (canvas.width !== targetSize.x) {\n        if (ENV.development) {\n            console.log(\"WARNING: canvas-size needs to be adjusted\");\n        }\n        canvas.width = targetSize.x;\n    }\n    if (canvas.height !== targetSize.y) {\n        if (ENV.development) {\n            console.log(\"WARNING: canvas-size needs to be adjusted\");\n        }\n        canvas.height = targetSize.y;\n    }\n}\n\nvar FrameGrabber = {};\n\nFrameGrabber.create = function(inputStream, canvas) {\n    var _that = {},\n        _streamConfig = inputStream.getConfig(),\n        _video_size = imageRef(inputStream.getRealWidth(), inputStream.getRealHeight()),\n        _canvasSize = inputStream.getCanvasSize(),\n        _size = imageRef(inputStream.getWidth(), inputStream.getHeight()),\n        topRight = inputStream.getTopRight(),\n        _sx = topRight.x,\n        _sy = topRight.y,\n        _canvas,\n        _ctx = null,\n        _data = null;\n\n    _canvas = canvas ? canvas : document.createElement(\"canvas\");\n    _canvas.width = _canvasSize.x;\n    _canvas.height = _canvasSize.y;\n    _ctx = _canvas.getContext(\"2d\");\n    _data = new Uint8Array(_size.x * _size.y);\n    if (ENV.development) {\n        console.log(\"FrameGrabber\", JSON.stringify({\n            size: _size,\n            topRight: topRight,\n            videoSize: _video_size,\n            canvasSize: _canvasSize\n        }));\n    }\n\n    /**\n     * Uses the given array as frame-buffer\n     */\n    _that.attachData = function(data) {\n        _data = data;\n    };\n\n    /**\n     * Returns the used frame-buffer\n     */\n    _that.getData = function() {\n        return _data;\n    };\n\n    /**\n     * Fetches a frame from the input-stream and puts into the frame-buffer.\n     * The image-data is converted to gray-scale and then half-sampled if configured.\n     */\n    _that.grab = function() {\n        var doHalfSample = _streamConfig.halfSample,\n            frame = inputStream.getFrame(),\n            drawable = frame,\n            drawAngle = 0,\n            ctxData;\n        if (drawable) {\n            adjustCanvasSize(_canvas, _canvasSize);\n            if (_streamConfig.type === 'ImageStream') {\n                drawable = frame.img;\n                if (frame.tags && frame.tags.orientation) {\n                    switch (frame.tags.orientation) {\n                    case 6:\n                        drawAngle = 90 * TO_RADIANS;\n                        break;\n                    case 8:\n                        drawAngle = -90 * TO_RADIANS;\n                        break;\n                    }\n                }\n            }\n\n            if (drawAngle !== 0) {\n                _ctx.translate(_canvasSize.x / 2, _canvasSize.y / 2);\n                _ctx.rotate(drawAngle);\n                _ctx.drawImage(drawable, -_canvasSize.y / 2, -_canvasSize.x / 2, _canvasSize.y, _canvasSize.x);\n                _ctx.rotate(-drawAngle);\n                _ctx.translate(-_canvasSize.x / 2, -_canvasSize.y / 2);\n            } else {\n                _ctx.drawImage(drawable, 0, 0, _canvasSize.x, _canvasSize.y);\n            }\n\n            ctxData = _ctx.getImageData(_sx, _sy, _size.x, _size.y).data;\n            if (doHalfSample){\n                grayAndHalfSampleFromCanvasData(ctxData, _size, _data);\n            } else {\n                computeGray(ctxData, _data, _streamConfig);\n            }\n            return true;\n        } else {\n            return false;\n        }\n    };\n\n    _that.getSize = function() {\n        return _size;\n    };\n\n    return _that;\n};\n\nexport default FrameGrabber;\n\n\n\n// WEBPACK FOOTER //\n// ./src/input/frame_grabber.js","import {findTagsInObjectURL} from './exif_helper';\n\nvar ImageLoader = {};\nImageLoader.load = function(directory, callback, offset, size, sequence) {\n    var htmlImagesSrcArray = new Array(size),\n        htmlImagesArray = new Array(htmlImagesSrcArray.length),\n        i,\n        img,\n        num;\n\n    if (sequence === false) {\n        htmlImagesSrcArray[0] = directory;\n    } else {\n        for ( i = 0; i < htmlImagesSrcArray.length; i++) {\n            num = (offset + i);\n            htmlImagesSrcArray[i] = directory + \"image-\" + (\"00\" + num).slice(-3) + \".jpg\";\n        }\n    }\n    htmlImagesArray.notLoaded = [];\n    htmlImagesArray.addImage = function(image) {\n        htmlImagesArray.notLoaded.push(image);\n    };\n    htmlImagesArray.loaded = function(loadedImg) {\n        var notloadedImgs = htmlImagesArray.notLoaded;\n        for (var x = 0; x < notloadedImgs.length; x++) {\n            if (notloadedImgs[x] === loadedImg) {\n                notloadedImgs.splice(x, 1);\n                for (var y = 0; y < htmlImagesSrcArray.length; y++) {\n                    var imgName = htmlImagesSrcArray[y].substr(htmlImagesSrcArray[y].lastIndexOf(\"/\"));\n                    if (loadedImg.src.lastIndexOf(imgName) !== -1) {\n                        htmlImagesArray[y] = {img: loadedImg};\n                        break;\n                    }\n                }\n                break;\n            }\n        }\n        if (notloadedImgs.length === 0) {\n            if (ENV.development) {\n                console.log(\"Images loaded\");\n            }\n            if (sequence === false) {\n                findTagsInObjectURL(directory, ['orientation'])\n                    .then(tags => {\n                        htmlImagesArray[0].tags = tags;\n                        callback(htmlImagesArray);\n                    }).catch(e => {\n                        console.log(e);\n                        callback(htmlImagesArray);\n                    });\n            } else {\n                callback(htmlImagesArray);\n            }\n        }\n    };\n\n    for ( i = 0; i < htmlImagesSrcArray.length; i++) {\n        img = new Image();\n        htmlImagesArray.addImage(img);\n        addOnloadHandler(img, htmlImagesArray);\n        img.src = htmlImagesSrcArray[i];\n    }\n};\n\nfunction addOnloadHandler(img, htmlImagesArray) {\n    img.onload = function() {\n        htmlImagesArray.loaded(this);\n    };\n}\n\nexport default (ImageLoader);\n\n\n\n// WEBPACK FOOTER //\n// ./src/input/image_loader.js","import ImageLoader from './image_loader';\n\nvar InputStream = {};\nInputStream.createVideoStream = function(video) {\n    var that = {},\n        _config = null,\n        _eventNames = ['canrecord', 'ended'],\n        _eventHandlers = {},\n        _calculatedWidth,\n        _calculatedHeight,\n        _topRight = {x: 0, y: 0},\n        _canvasSize = {x: 0, y: 0};\n\n    function initSize() {\n        var width = video.videoWidth,\n            height = video.videoHeight;\n\n        _calculatedWidth =\n            _config.size ? width / height > 1 ? _config.size : Math.floor((width / height) * _config.size) : width;\n        _calculatedHeight =\n            _config.size ? width / height > 1 ? Math.floor((height / width) * _config.size) : _config.size : height;\n\n        _canvasSize.x = _calculatedWidth;\n        _canvasSize.y = _calculatedHeight;\n    }\n\n    that.getRealWidth = function() {\n        return video.videoWidth;\n    };\n\n    that.getRealHeight = function() {\n        return video.videoHeight;\n    };\n\n    that.getWidth = function() {\n        return _calculatedWidth;\n    };\n\n    that.getHeight = function() {\n        return _calculatedHeight;\n    };\n\n    that.setWidth = function(width) {\n        _calculatedWidth = width;\n    };\n\n    that.setHeight = function(height) {\n        _calculatedHeight = height;\n    };\n\n    that.setInputStream = function(config) {\n        _config = config;\n        video.src = (typeof config.src !== 'undefined') ? config.src : '';\n    };\n\n    that.ended = function() {\n        return video.ended;\n    };\n\n    that.getConfig = function() {\n        return _config;\n    };\n\n    that.setAttribute = function(name, value) {\n        video.setAttribute(name, value);\n    };\n\n    that.pause = function() {\n        video.pause();\n    };\n\n    that.play = function() {\n        video.play();\n    };\n\n    that.setCurrentTime = function(time) {\n        if (_config.type !== \"LiveStream\") {\n            video.currentTime = time;\n        }\n    };\n\n    that.addEventListener = function(event, f, bool) {\n        if (_eventNames.indexOf(event) !== -1) {\n            if (!_eventHandlers[event]) {\n                _eventHandlers[event] = [];\n            }\n            _eventHandlers[event].push(f);\n        } else {\n            video.addEventListener(event, f, bool);\n        }\n    };\n\n    that.clearEventHandlers = function() {\n        _eventNames.forEach(function(eventName) {\n            var handlers = _eventHandlers[eventName];\n            if (handlers && handlers.length > 0) {\n                handlers.forEach(function(handler) {\n                    video.removeEventListener(eventName, handler);\n                });\n            }\n        });\n    };\n\n    that.trigger = function(eventName, args) {\n        var j,\n            handlers = _eventHandlers[eventName];\n\n        if (eventName === 'canrecord') {\n            initSize();\n        }\n        if (handlers && handlers.length > 0) {\n            for ( j = 0; j < handlers.length; j++) {\n                handlers[j].apply(that, args);\n            }\n        }\n    };\n\n    that.setTopRight = function(topRight) {\n        _topRight.x = topRight.x;\n        _topRight.y = topRight.y;\n    };\n\n    that.getTopRight = function() {\n        return _topRight;\n    };\n\n    that.setCanvasSize = function(size) {\n        _canvasSize.x = size.x;\n        _canvasSize.y = size.y;\n    };\n\n    that.getCanvasSize = function() {\n        return _canvasSize;\n    };\n\n    that.getFrame = function() {\n        return video;\n    };\n\n    return that;\n};\n\nInputStream.createLiveStream = function(video) {\n    video.setAttribute(\"autoplay\", true);\n    var that = InputStream.createVideoStream(video);\n\n    that.ended = function() {\n        return false;\n    };\n\n    return that;\n};\n\nInputStream.createImageStream = function() {\n    var that = {};\n    var _config = null;\n\n    var width = 0,\n        height = 0,\n        frameIdx = 0,\n        paused = true,\n        loaded = false,\n        imgArray = null,\n        size = 0,\n        offset = 1,\n        baseUrl = null,\n        ended = false,\n        calculatedWidth,\n        calculatedHeight,\n        _eventNames = ['canrecord', 'ended'],\n        _eventHandlers = {},\n        _topRight = {x: 0, y: 0},\n        _canvasSize = {x: 0, y: 0};\n\n    function loadImages() {\n        loaded = false;\n        ImageLoader.load(baseUrl, function(imgs) {\n            imgArray = imgs;\n            if (imgs[0].tags && imgs[0].tags.orientation) {\n                switch (imgs[0].tags.orientation) {\n                case 6:\n                case 8:\n                    width = imgs[0].img.height;\n                    height = imgs[0].img.width;\n                    break;\n                default:\n                    width = imgs[0].img.width;\n                    height = imgs[0].img.height;\n                }\n            } else {\n                width = imgs[0].img.width;\n                height = imgs[0].img.height;\n            }\n            calculatedWidth =\n                _config.size ? width / height > 1 ? _config.size : Math.floor((width / height) * _config.size) : width;\n            calculatedHeight =\n                _config.size ? width / height > 1 ? Math.floor((height / width) * _config.size) : _config.size : height;\n            _canvasSize.x = calculatedWidth;\n            _canvasSize.y = calculatedHeight;\n            loaded = true;\n            frameIdx = 0;\n            setTimeout(function() {\n                publishEvent(\"canrecord\", []);\n            }, 0);\n        }, offset, size, _config.sequence);\n    }\n\n    function publishEvent(eventName, args) {\n        var j,\n            handlers = _eventHandlers[eventName];\n\n        if (handlers && handlers.length > 0) {\n            for ( j = 0; j < handlers.length; j++) {\n                handlers[j].apply(that, args);\n            }\n        }\n    }\n\n\n    that.trigger = publishEvent;\n\n    that.getWidth = function() {\n        return calculatedWidth;\n    };\n\n    that.getHeight = function() {\n        return calculatedHeight;\n    };\n\n    that.setWidth = function(newWidth) {\n        calculatedWidth = newWidth;\n    };\n\n    that.setHeight = function(newHeight) {\n        calculatedHeight = newHeight;\n    };\n\n    that.getRealWidth = function() {\n        return width;\n    };\n\n    that.getRealHeight = function() {\n        return height;\n    };\n\n    that.setInputStream = function(stream) {\n        _config = stream;\n        if (stream.sequence === false) {\n            baseUrl = stream.src;\n            size = 1;\n        } else {\n            baseUrl = stream.src;\n            size = stream.length;\n        }\n        loadImages();\n    };\n\n    that.ended = function() {\n        return ended;\n    };\n\n    that.setAttribute = function() {};\n\n    that.getConfig = function() {\n        return _config;\n    };\n\n    that.pause = function() {\n        paused = true;\n    };\n\n    that.play = function() {\n        paused = false;\n    };\n\n    that.setCurrentTime = function(time) {\n        frameIdx = time;\n    };\n\n    that.addEventListener = function(event, f) {\n        if (_eventNames.indexOf(event) !== -1) {\n            if (!_eventHandlers[event]) {\n                _eventHandlers[event] = [];\n            }\n            _eventHandlers[event].push(f);\n        }\n    };\n\n    that.setTopRight = function(topRight) {\n        _topRight.x = topRight.x;\n        _topRight.y = topRight.y;\n    };\n\n    that.getTopRight = function() {\n        return _topRight;\n    };\n\n    that.setCanvasSize = function(canvasSize) {\n        _canvasSize.x = canvasSize.x;\n        _canvasSize.y = canvasSize.y;\n    };\n\n    that.getCanvasSize = function() {\n        return _canvasSize;\n    };\n\n    that.getFrame = function() {\n        var frame;\n\n        if (!loaded){\n            return null;\n        }\n        if (!paused) {\n            frame = imgArray[frameIdx];\n            if (frameIdx < (size - 1)) {\n                frameIdx++;\n            } else {\n                setTimeout(function() {\n                    ended = true;\n                    publishEvent(\"ended\", []);\n                }, 0);\n            }\n        }\n        return frame;\n    };\n\n    return that;\n};\n\nexport default InputStream;\n\n\n\n// WEBPACK FOOTER //\n// ./src/input/input_stream.js","import ImageWrapper from '../common/image_wrapper';\nimport {\n    calculatePatchSize,\n    otsuThreshold,\n    hsv2rgb,\n    cluster,\n    topGeneric,\n    imageRef,\n    halfSample,\n    computeImageArea\n} from '../common/cv_utils';\nimport ArrayHelper from '../common/array_helper';\nimport ImageDebug from '../common/image_debug';\nimport Rasterizer from './rasterizer';\nimport Tracer from './tracer';\nimport skeletonizer from './skeletonizer';\nconst vec2 = {\n    clone: require('gl-vec2/clone'),\n    dot:  require('gl-vec2/dot'),\n    scale: require('gl-vec2/scale'),\n    transformMat2: require('gl-vec2/transformMat2')\n};\nconst mat2 = {\n    copy: require('gl-mat2/copy'),\n    create: require('gl-mat2/create'),\n    invert: require('gl-mat2/invert')\n}\n\nvar _config,\n    _currentImageWrapper,\n    _skelImageWrapper,\n    _subImageWrapper,\n    _labelImageWrapper,\n    _patchGrid,\n    _patchLabelGrid,\n    _imageToPatchGrid,\n    _binaryImageWrapper,\n    _patchSize,\n    _canvasContainer = {\n        ctx: {\n            binary: null\n        },\n        dom: {\n            binary: null\n        }\n    },\n    _numPatches = {x: 0, y: 0},\n    _inputImageWrapper,\n    _skeletonizer;\n\nfunction initBuffers() {\n    var skeletonImageData;\n\n    if (_config.halfSample) {\n        _currentImageWrapper = new ImageWrapper({\n            x: _inputImageWrapper.size.x / 2 | 0,\n            y: _inputImageWrapper.size.y / 2 | 0\n        });\n    } else {\n        _currentImageWrapper = _inputImageWrapper;\n    }\n\n    _patchSize = calculatePatchSize(_config.patchSize, _currentImageWrapper.size);\n\n    _numPatches.x = _currentImageWrapper.size.x / _patchSize.x | 0;\n    _numPatches.y = _currentImageWrapper.size.y / _patchSize.y | 0;\n\n    _binaryImageWrapper = new ImageWrapper(_currentImageWrapper.size, undefined, Uint8Array, false);\n\n    _labelImageWrapper = new ImageWrapper(_patchSize, undefined, Array, true);\n\n    skeletonImageData = new ArrayBuffer(64 * 1024);\n    _subImageWrapper = new ImageWrapper(_patchSize,\n        new Uint8Array(skeletonImageData, 0, _patchSize.x * _patchSize.y));\n    _skelImageWrapper = new ImageWrapper(_patchSize,\n        new Uint8Array(skeletonImageData, _patchSize.x * _patchSize.y * 3, _patchSize.x * _patchSize.y),\n        undefined, true);\n    _skeletonizer = skeletonizer((typeof window !== 'undefined') ? window : (typeof self !== 'undefined') ? self : global, {\n        size: _patchSize.x\n    }, skeletonImageData);\n\n    _imageToPatchGrid = new ImageWrapper({\n        x: (_currentImageWrapper.size.x / _subImageWrapper.size.x) | 0,\n        y: (_currentImageWrapper.size.y / _subImageWrapper.size.y) | 0\n    }, undefined, Array, true);\n    _patchGrid = new ImageWrapper(_imageToPatchGrid.size, undefined, undefined, true);\n    _patchLabelGrid = new ImageWrapper(_imageToPatchGrid.size, undefined, Int32Array, true);\n}\n\nfunction initCanvas() {\n    if (_config.useWorker || typeof document === 'undefined') {\n        return;\n    }\n    _canvasContainer.dom.binary = document.createElement(\"canvas\");\n    _canvasContainer.dom.binary.className = \"binaryBuffer\";\n    if (ENV.development && _config.debug.showCanvas === true) {\n        document.querySelector(\"#debug\").appendChild(_canvasContainer.dom.binary);\n    }\n    _canvasContainer.ctx.binary = _canvasContainer.dom.binary.getContext(\"2d\");\n    _canvasContainer.dom.binary.width = _binaryImageWrapper.size.x;\n    _canvasContainer.dom.binary.height = _binaryImageWrapper.size.y;\n}\n\n/**\n * Creates a bounding box which encloses all the given patches\n * @returns {Array} The minimal bounding box\n */\nfunction boxFromPatches(patches) {\n    var overAvg,\n        i,\n        j,\n        patch,\n        transMat,\n        minx =\n        _binaryImageWrapper.size.x,\n        miny = _binaryImageWrapper.size.y,\n        maxx = -_binaryImageWrapper.size.x,\n        maxy = -_binaryImageWrapper.size.y,\n        box,\n        scale;\n\n    // draw all patches which are to be taken into consideration\n    overAvg = 0;\n    for ( i = 0; i < patches.length; i++) {\n        patch = patches[i];\n        overAvg += patch.rad;\n        if (ENV.development && _config.debug.showPatches) {\n            ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: \"red\"});\n        }\n    }\n\n    overAvg /= patches.length;\n    overAvg = (overAvg * 180 / Math.PI + 90) % 180 - 90;\n    if (overAvg < 0) {\n        overAvg += 180;\n    }\n\n    overAvg = (180 - overAvg) * Math.PI / 180;\n    transMat = mat2.copy(mat2.create(), [Math.cos(overAvg), Math.sin(overAvg), -Math.sin(overAvg), Math.cos(overAvg)]);\n\n    // iterate over patches and rotate by angle\n    for ( i = 0; i < patches.length; i++) {\n        patch = patches[i];\n        for ( j = 0; j < 4; j++) {\n            vec2.transformMat2(patch.box[j], patch.box[j], transMat);\n        }\n\n        if (ENV.development && _config.debug.boxFromPatches.showTransformed) {\n            ImageDebug.drawPath(patch.box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#99ff00', lineWidth: 2});\n        }\n    }\n\n    // find bounding box\n    for ( i = 0; i < patches.length; i++) {\n        patch = patches[i];\n        for ( j = 0; j < 4; j++) {\n            if (patch.box[j][0] < minx) {\n                minx = patch.box[j][0];\n            }\n            if (patch.box[j][0] > maxx) {\n                maxx = patch.box[j][0];\n            }\n            if (patch.box[j][1] < miny) {\n                miny = patch.box[j][1];\n            }\n            if (patch.box[j][1] > maxy) {\n                maxy = patch.box[j][1];\n            }\n        }\n    }\n\n    box = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]];\n\n    if (ENV.development && _config.debug.boxFromPatches.showTransformedBox) {\n        ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2});\n    }\n\n    scale = _config.halfSample ? 2 : 1;\n    // reverse rotation;\n    transMat = mat2.invert(transMat, transMat);\n    for ( j = 0; j < 4; j++) {\n        vec2.transformMat2(box[j], box[j], transMat);\n    }\n\n    if (ENV.development && _config.debug.boxFromPatches.showBB) {\n        ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2});\n    }\n\n    for ( j = 0; j < 4; j++) {\n        vec2.scale(box[j], box[j], scale);\n    }\n\n    return box;\n}\n\n/**\n * Creates a binary image of the current image\n */\nfunction binarizeImage() {\n    otsuThreshold(_currentImageWrapper, _binaryImageWrapper);\n    _binaryImageWrapper.zeroBorder();\n    if (ENV.development && _config.debug.showCanvas) {\n        _binaryImageWrapper.show(_canvasContainer.dom.binary, 255);\n    }\n}\n\n/**\n * Iterate over the entire image\n * extract patches\n */\nfunction findPatches() {\n    var i,\n        j,\n        x,\n        y,\n        moments,\n        patchesFound = [],\n        rasterizer,\n        rasterResult,\n        patch;\n    for (i = 0; i < _numPatches.x; i++) {\n        for (j = 0; j < _numPatches.y; j++) {\n            x = _subImageWrapper.size.x * i;\n            y = _subImageWrapper.size.y * j;\n\n            // seperate parts\n            skeletonize(x, y);\n\n            // Rasterize, find individual bars\n            _skelImageWrapper.zeroBorder();\n            ArrayHelper.init(_labelImageWrapper.data, 0);\n            rasterizer = Rasterizer.create(_skelImageWrapper, _labelImageWrapper);\n            rasterResult = rasterizer.rasterize(0);\n\n            if (ENV.development && _config.debug.showLabels) {\n                _labelImageWrapper.overlay(_canvasContainer.dom.binary, Math.floor(360 / rasterResult.count),\n                    {x: x, y: y});\n            }\n\n            // calculate moments from the skeletonized patch\n            moments = _labelImageWrapper.moments(rasterResult.count);\n\n            // extract eligible patches\n            patchesFound = patchesFound.concat(describePatch(moments, [i, j], x, y));\n        }\n    }\n\n    if (ENV.development && _config.debug.showFoundPatches) {\n        for ( i = 0; i < patchesFound.length; i++) {\n            patch = patchesFound[i];\n            ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary,\n                {color: \"#99ff00\", lineWidth: 2});\n        }\n    }\n\n    return patchesFound;\n}\n\n/**\n * Finds those connected areas which contain at least 6 patches\n * and returns them ordered DESC by the number of contained patches\n * @param {Number} maxLabel\n */\nfunction findBiggestConnectedAreas(maxLabel){\n    var i,\n        sum,\n        labelHist = [],\n        topLabels = [];\n\n    for ( i = 0; i < maxLabel; i++) {\n        labelHist.push(0);\n    }\n    sum = _patchLabelGrid.data.length;\n    while (sum--) {\n        if (_patchLabelGrid.data[sum] > 0) {\n            labelHist[_patchLabelGrid.data[sum] - 1]++;\n        }\n    }\n\n    labelHist = labelHist.map(function(val, idx) {\n        return {\n            val: val,\n            label: idx + 1\n        };\n    });\n\n    labelHist.sort(function(a, b) {\n        return b.val - a.val;\n    });\n\n    // extract top areas with at least 6 patches present\n    topLabels = labelHist.filter(function(el) {\n        return el.val >= 5;\n    });\n\n    return topLabels;\n}\n\n/**\n *\n */\nfunction findBoxes(topLabels, maxLabel) {\n    var i,\n        j,\n        sum,\n        patches = [],\n        patch,\n        box,\n        boxes = [],\n        hsv = [0, 1, 1],\n        rgb = [0, 0, 0];\n\n    for ( i = 0; i < topLabels.length; i++) {\n        sum = _patchLabelGrid.data.length;\n        patches.length = 0;\n        while (sum--) {\n            if (_patchLabelGrid.data[sum] === topLabels[i].label) {\n                patch = _imageToPatchGrid.data[sum];\n                patches.push(patch);\n            }\n        }\n        box = boxFromPatches(patches);\n        if (box) {\n            boxes.push(box);\n\n            // draw patch-labels if requested\n            if (ENV.development && _config.debug.showRemainingPatchLabels) {\n                for ( j = 0; j < patches.length; j++) {\n                    patch = patches[j];\n                    hsv[0] = (topLabels[i].label / (maxLabel + 1)) * 360;\n                    hsv2rgb(hsv, rgb);\n                    ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary,\n                        {color: \"rgb(\" + rgb.join(\",\") + \")\", lineWidth: 2});\n                }\n            }\n        }\n    }\n    return boxes;\n}\n\n/**\n * Find similar moments (via cluster)\n * @param {Object} moments\n */\nfunction similarMoments(moments) {\n    var clusters = cluster(moments, 0.90);\n    var topCluster = topGeneric(clusters, 1, function(e) {\n        return e.getPoints().length;\n    });\n    var points = [], result = [];\n    if (topCluster.length === 1) {\n        points = topCluster[0].item.getPoints();\n        for (var i = 0; i < points.length; i++) {\n            result.push(points[i].point);\n        }\n    }\n    return result;\n}\n\nfunction skeletonize(x, y) {\n    _binaryImageWrapper.subImageAsCopy(_subImageWrapper, imageRef(x, y));\n    _skeletonizer.skeletonize();\n\n    // Show skeleton if requested\n    if (ENV.development && _config.debug.showSkeleton) {\n        _skelImageWrapper.overlay(_canvasContainer.dom.binary, 360, imageRef(x, y));\n    }\n}\n\n/**\n * Extracts and describes those patches which seem to contain a barcode pattern\n * @param {Array} moments\n * @param {Object} patchPos,\n * @param {Number} x\n * @param {Number} y\n * @returns {Array} list of patches\n */\nfunction describePatch(moments, patchPos, x, y) {\n    var k,\n        avg,\n        eligibleMoments = [],\n        matchingMoments,\n        patch,\n        patchesFound = [],\n        minComponentWeight = Math.ceil(_patchSize.x / 3);\n\n    if (moments.length >= 2) {\n        // only collect moments which's area covers at least minComponentWeight pixels.\n        for ( k = 0; k < moments.length; k++) {\n            if (moments[k].m00 > minComponentWeight) {\n                eligibleMoments.push(moments[k]);\n            }\n        }\n\n        // if at least 2 moments are found which have at least minComponentWeights covered\n        if (eligibleMoments.length >= 2) {\n            matchingMoments = similarMoments(eligibleMoments);\n            avg = 0;\n            // determine the similarity of the moments\n            for ( k = 0; k < matchingMoments.length; k++) {\n                avg += matchingMoments[k].rad;\n            }\n\n            // Only two of the moments are allowed not to fit into the equation\n            // add the patch to the set\n            if (matchingMoments.length > 1\n                    && matchingMoments.length >= (eligibleMoments.length / 4) * 3\n                    && matchingMoments.length > moments.length / 4) {\n                avg /= matchingMoments.length;\n                patch = {\n                    index: patchPos[1] * _numPatches.x + patchPos[0],\n                    pos: {\n                        x: x,\n                        y: y\n                    },\n                    box: [\n                        vec2.clone([x, y]),\n                        vec2.clone([x + _subImageWrapper.size.x, y]),\n                        vec2.clone([x + _subImageWrapper.size.x, y + _subImageWrapper.size.y]),\n                        vec2.clone([x, y + _subImageWrapper.size.y])\n                    ],\n                    moments: matchingMoments,\n                    rad: avg,\n                    vec: vec2.clone([Math.cos(avg), Math.sin(avg)])\n                };\n                patchesFound.push(patch);\n            }\n        }\n    }\n    return patchesFound;\n}\n\n/**\n * finds patches which are connected and share the same orientation\n * @param {Object} patchesFound\n */\nfunction rasterizeAngularSimilarity(patchesFound) {\n    var label = 0,\n        threshold = 0.95,\n        currIdx = 0,\n        j,\n        patch,\n        hsv = [0, 1, 1],\n        rgb = [0, 0, 0];\n\n    function notYetProcessed() {\n        var i;\n        for ( i = 0; i < _patchLabelGrid.data.length; i++) {\n            if (_patchLabelGrid.data[i] === 0 && _patchGrid.data[i] === 1) {\n                return i;\n            }\n        }\n        return _patchLabelGrid.length;\n    }\n\n    function trace(currentIdx) {\n        var x,\n            y,\n            currentPatch,\n            idx,\n            dir,\n            current = {\n                x: currentIdx % _patchLabelGrid.size.x,\n                y: (currentIdx / _patchLabelGrid.size.x) | 0\n            },\n            similarity;\n\n        if (currentIdx < _patchLabelGrid.data.length) {\n            currentPatch = _imageToPatchGrid.data[currentIdx];\n            // assign label\n            _patchLabelGrid.data[currentIdx] = label;\n            for ( dir = 0; dir < Tracer.searchDirections.length; dir++) {\n                y = current.y + Tracer.searchDirections[dir][0];\n                x = current.x + Tracer.searchDirections[dir][1];\n                idx = y * _patchLabelGrid.size.x + x;\n\n                // continue if patch empty\n                if (_patchGrid.data[idx] === 0) {\n                    _patchLabelGrid.data[idx] = Number.MAX_VALUE;\n                    continue;\n                }\n\n                if (_patchLabelGrid.data[idx] === 0) {\n                    similarity = Math.abs(vec2.dot(_imageToPatchGrid.data[idx].vec, currentPatch.vec));\n                    if (similarity > threshold) {\n                        trace(idx);\n                    }\n                }\n            }\n        }\n    }\n\n    // prepare for finding the right patches\n    ArrayHelper.init(_patchGrid.data, 0);\n    ArrayHelper.init(_patchLabelGrid.data, 0);\n    ArrayHelper.init(_imageToPatchGrid.data, null);\n\n    for ( j = 0; j < patchesFound.length; j++) {\n        patch = patchesFound[j];\n        _imageToPatchGrid.data[patch.index] = patch;\n        _patchGrid.data[patch.index] = 1;\n    }\n\n    // rasterize the patches found to determine area\n    _patchGrid.zeroBorder();\n\n    while (( currIdx = notYetProcessed()) < _patchLabelGrid.data.length) {\n        label++;\n        trace(currIdx);\n    }\n\n    // draw patch-labels if requested\n    if (ENV.development && _config.debug.showPatchLabels) {\n        for ( j = 0; j < _patchLabelGrid.data.length; j++) {\n            if (_patchLabelGrid.data[j] > 0 && _patchLabelGrid.data[j] <= label) {\n                patch = _imageToPatchGrid.data[j];\n                hsv[0] = (_patchLabelGrid.data[j] / (label + 1)) * 360;\n                hsv2rgb(hsv, rgb);\n                ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary,\n                    {color: \"rgb(\" + rgb.join(\",\") + \")\", lineWidth: 2});\n            }\n        }\n    }\n\n    return label;\n}\n\nexport default {\n    init: function(inputImageWrapper, config) {\n        _config = config;\n        _inputImageWrapper = inputImageWrapper;\n\n        initBuffers();\n        initCanvas();\n    },\n\n    locate: function() {\n        var patchesFound,\n            topLabels,\n            boxes;\n\n        if (_config.halfSample) {\n            halfSample(_inputImageWrapper, _currentImageWrapper);\n        }\n\n        binarizeImage();\n        patchesFound = findPatches();\n        // return unless 5% or more patches are found\n        if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) {\n            return null;\n        }\n\n        // rasterrize area by comparing angular similarity;\n        var maxLabel = rasterizeAngularSimilarity(patchesFound);\n        if (maxLabel < 1) {\n            return null;\n        }\n\n        // search for area with the most patches (biggest connected area)\n        topLabels = findBiggestConnectedAreas(maxLabel);\n        if (topLabels.length === 0) {\n            return null;\n        }\n\n        boxes = findBoxes(topLabels, maxLabel);\n        return boxes;\n    },\n\n    checkImageConstraints: function(inputStream, config) {\n        var patchSize,\n            width = inputStream.getWidth(),\n            height = inputStream.getHeight(),\n            halfSample = config.halfSample ? 0.5 : 1,\n            size,\n            area;\n\n        // calculate width and height based on area\n        if (inputStream.getConfig().area) {\n            area = computeImageArea(width, height, inputStream.getConfig().area);\n            inputStream.setTopRight({x: area.sx, y: area.sy});\n            inputStream.setCanvasSize({x: width, y: height});\n            width = area.sw;\n            height = area.sh;\n        }\n\n        size = {\n            x: Math.floor(width * halfSample),\n            y: Math.floor(height * halfSample)\n        };\n\n        patchSize = calculatePatchSize(config.patchSize, size);\n        if (ENV.development) {\n            console.log(\"Patch-Size: \" + JSON.stringify(patchSize));\n        }\n\n        inputStream.setWidth(Math.floor(Math.floor(size.x / patchSize.x) * (1 / halfSample) * patchSize.x));\n        inputStream.setHeight(Math.floor(Math.floor(size.y / patchSize.y) * (1 / halfSample) * patchSize.y));\n\n        if ((inputStream.getWidth() % patchSize.x) === 0 && (inputStream.getHeight() % patchSize.y) === 0) {\n            return true;\n        }\n\n        throw new Error(\"Image dimensions do not comply with the current settings: Width (\" +\n            width + \" )and height (\" + height +\n            \") must a multiple of \" + patchSize.x);\n    }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/locator/barcode_locator.js","import Tracer from './tracer';\n\n/**\n * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization\n */\nvar Rasterizer = {\n    createContour2D: function() {\n        return {\n            dir: null,\n            index: null,\n            firstVertex: null,\n            insideContours: null,\n            nextpeer: null,\n            prevpeer: null\n        };\n    },\n    CONTOUR_DIR: {\n        CW_DIR: 0,\n        CCW_DIR: 1,\n        UNKNOWN_DIR: 2\n    },\n    DIR: {\n        OUTSIDE_EDGE: -32767,\n        INSIDE_EDGE: -32766\n    },\n    create: function(imageWrapper, labelWrapper) {\n        var imageData = imageWrapper.data,\n            labelData = labelWrapper.data,\n            width = imageWrapper.size.x,\n            height = imageWrapper.size.y,\n            tracer = Tracer.create(imageWrapper, labelWrapper);\n\n        return {\n            rasterize: function(depthlabel) {\n                var color,\n                    bc,\n                    lc,\n                    labelindex,\n                    cx,\n                    cy,\n                    colorMap = [],\n                    vertex,\n                    p,\n                    cc,\n                    sc,\n                    pos,\n                    connectedCount = 0,\n                    i;\n\n                for ( i = 0; i < 400; i++) {\n                    colorMap[i] = 0;\n                }\n\n                colorMap[0] = imageData[0];\n                cc = null;\n                for ( cy = 1; cy < height - 1; cy++) {\n                    labelindex = 0;\n                    bc = colorMap[0];\n                    for ( cx = 1; cx < width - 1; cx++) {\n                        pos = cy * width + cx;\n                        if (labelData[pos] === 0) {\n                            color = imageData[pos];\n                            if (color !== bc) {\n                                if (labelindex === 0) {\n                                    lc = connectedCount + 1;\n                                    colorMap[lc] = color;\n                                    bc = color;\n                                    vertex = tracer.contourTracing(cy, cx, lc, color, Rasterizer.DIR.OUTSIDE_EDGE);\n                                    if (vertex !== null) {\n                                        connectedCount++;\n                                        labelindex = lc;\n                                        p = Rasterizer.createContour2D();\n                                        p.dir = Rasterizer.CONTOUR_DIR.CW_DIR;\n                                        p.index = labelindex;\n                                        p.firstVertex = vertex;\n                                        p.nextpeer = cc;\n                                        p.insideContours = null;\n                                        if (cc !== null) {\n                                            cc.prevpeer = p;\n                                        }\n                                        cc = p;\n                                    }\n                                } else {\n                                    vertex = tracer\n                                        .contourTracing(cy, cx, Rasterizer.DIR.INSIDE_EDGE, color, labelindex);\n                                    if (vertex !== null) {\n                                        p = Rasterizer.createContour2D();\n                                        p.firstVertex = vertex;\n                                        p.insideContours = null;\n                                        if (depthlabel === 0) {\n                                            p.dir = Rasterizer.CONTOUR_DIR.CCW_DIR;\n                                        } else {\n                                            p.dir = Rasterizer.CONTOUR_DIR.CW_DIR;\n                                        }\n                                        p.index = depthlabel;\n                                        sc = cc;\n                                        while ((sc !== null) && sc.index !== labelindex) {\n                                            sc = sc.nextpeer;\n                                        }\n                                        if (sc !== null) {\n                                            p.nextpeer = sc.insideContours;\n                                            if (sc.insideContours !== null) {\n                                                sc.insideContours.prevpeer = p;\n                                            }\n                                            sc.insideContours = p;\n                                        }\n                                    }\n                                }\n                            } else {\n                                labelData[pos] = labelindex;\n                            }\n                        } else if (labelData[pos] === Rasterizer.DIR.OUTSIDE_EDGE\n                                || labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) {\n                            labelindex = 0;\n                            if (labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) {\n                                bc = imageData[pos];\n                            } else {\n                                bc = colorMap[0];\n                            }\n                        } else {\n                            labelindex = labelData[pos];\n                            bc = colorMap[labelindex];\n                        }\n                    }\n                }\n                sc = cc;\n                while (sc !== null) {\n                    sc.index = depthlabel;\n                    sc = sc.nextpeer;\n                }\n                return {\n                    cc: cc,\n                    count: connectedCount\n                };\n            },\n            debug: {\n                drawContour: function(canvas, firstContour) {\n                    var ctx = canvas.getContext(\"2d\"),\n                        pq = firstContour,\n                        iq,\n                        q,\n                        p;\n\n                    ctx.strokeStyle = \"red\";\n                    ctx.fillStyle = \"red\";\n                    ctx.lineWidth = 1;\n\n                    if (pq !== null) {\n                        iq = pq.insideContours;\n                    } else {\n                        iq = null;\n                    }\n\n                    while (pq !== null) {\n                        if (iq !== null) {\n                            q = iq;\n                            iq = iq.nextpeer;\n                        } else {\n                            q = pq;\n                            pq = pq.nextpeer;\n                            if (pq !== null) {\n                                iq = pq.insideContours;\n                            } else {\n                                iq = null;\n                            }\n                        }\n\n                        switch (q.dir) {\n                        case Rasterizer.CONTOUR_DIR.CW_DIR:\n                            ctx.strokeStyle = \"red\";\n                            break;\n                        case Rasterizer.CONTOUR_DIR.CCW_DIR:\n                            ctx.strokeStyle = \"blue\";\n                            break;\n                        case Rasterizer.CONTOUR_DIR.UNKNOWN_DIR:\n                            ctx.strokeStyle = \"green\";\n                            break;\n                        }\n\n                        p = q.firstVertex;\n                        ctx.beginPath();\n                        ctx.moveTo(p.x, p.y);\n                        do {\n                            p = p.next;\n                            ctx.lineTo(p.x, p.y);\n                        } while (p !== q.firstVertex);\n                        ctx.stroke();\n                    }\n                }\n            }\n        };\n    }\n};\n\nexport default Rasterizer;\n\n\n\n// WEBPACK FOOTER //\n// ./src/locator/rasterizer.js","/* @preserve ASM BEGIN */\n/* eslint-disable eqeqeq*/\nfunction Skeletonizer(stdlib, foreign, buffer) {\n    \"use asm\";\n\n    var images = new stdlib.Uint8Array(buffer),\n        size = foreign.size | 0,\n        imul = stdlib.Math.imul;\n\n    function erode(inImagePtr, outImagePtr) {\n        inImagePtr = inImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var v = 0,\n            u = 0,\n            sum = 0,\n            yStart1 = 0,\n            yStart2 = 0,\n            xStart1 = 0,\n            xStart2 = 0,\n            offset = 0;\n\n        for ( v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) {\n            offset = (offset + size) | 0;\n            for ( u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) {\n                yStart1 = (offset - size) | 0;\n                yStart2 = (offset + size) | 0;\n                xStart1 = (u - 1) | 0;\n                xStart2 = (u + 1) | 0;\n                sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0)\n                    + (images[(inImagePtr + offset + u) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0;\n                if ((sum | 0) == (5 | 0)) {\n                    images[(outImagePtr + offset + u) | 0] = 1;\n                } else {\n                    images[(outImagePtr + offset + u) | 0] = 0;\n                }\n            }\n        }\n        return;\n    }\n\n    function subtract(aImagePtr, bImagePtr, outImagePtr) {\n        aImagePtr = aImagePtr | 0;\n        bImagePtr = bImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(outImagePtr + length) | 0] =\n                ((images[(aImagePtr + length) | 0] | 0) - (images[(bImagePtr + length) | 0] | 0)) | 0;\n        }\n    }\n\n    function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) {\n        aImagePtr = aImagePtr | 0;\n        bImagePtr = bImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(outImagePtr + length) | 0] =\n                ((images[(aImagePtr + length) | 0] | 0) | (images[(bImagePtr + length) | 0] | 0)) | 0;\n        }\n    }\n\n    function countNonZero(imagePtr) {\n        imagePtr = imagePtr | 0;\n\n        var sum = 0,\n            length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            sum = ((sum | 0) + (images[(imagePtr + length) | 0] | 0)) | 0;\n        }\n\n        return (sum | 0);\n    }\n\n    function init(imagePtr, value) {\n        imagePtr = imagePtr | 0;\n        value = value | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(imagePtr + length) | 0] = value;\n        }\n    }\n\n    function dilate(inImagePtr, outImagePtr) {\n        inImagePtr = inImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var v = 0,\n            u = 0,\n            sum = 0,\n            yStart1 = 0,\n            yStart2 = 0,\n            xStart1 = 0,\n            xStart2 = 0,\n            offset = 0;\n\n        for ( v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) {\n            offset = (offset + size) | 0;\n            for ( u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) {\n                yStart1 = (offset - size) | 0;\n                yStart2 = (offset + size) | 0;\n                xStart1 = (u - 1) | 0;\n                xStart2 = (u + 1) | 0;\n                sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0)\n                    + (images[(inImagePtr + offset + u) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0;\n                if ((sum | 0) > (0 | 0)) {\n                    images[(outImagePtr + offset + u) | 0] = 1;\n                } else {\n                    images[(outImagePtr + offset + u) | 0] = 0;\n                }\n            }\n        }\n        return;\n    }\n\n    function memcpy(srcImagePtr, dstImagePtr) {\n        srcImagePtr = srcImagePtr | 0;\n        dstImagePtr = dstImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(dstImagePtr + length) | 0] = (images[(srcImagePtr + length) | 0] | 0);\n        }\n    }\n\n    function zeroBorder(imagePtr) {\n        imagePtr = imagePtr | 0;\n\n        var x = 0,\n            y = 0;\n\n        for ( x = 0; (x | 0) < ((size - 1) | 0); x = (x + 1) | 0) {\n            images[(imagePtr + x) | 0] = 0;\n            images[(imagePtr + y) | 0] = 0;\n            y = ((y + size) - 1) | 0;\n            images[(imagePtr + y) | 0] = 0;\n            y = (y + 1) | 0;\n        }\n        for ( x = 0; (x | 0) < (size | 0); x = (x + 1) | 0) {\n            images[(imagePtr + y) | 0] = 0;\n            y = (y + 1) | 0;\n        }\n    }\n\n    function skeletonize() {\n        var subImagePtr = 0,\n            erodedImagePtr = 0,\n            tempImagePtr = 0,\n            skelImagePtr = 0,\n            sum = 0,\n            done = 0;\n\n        erodedImagePtr = imul(size, size) | 0;\n        tempImagePtr = (erodedImagePtr + erodedImagePtr) | 0;\n        skelImagePtr = (tempImagePtr + erodedImagePtr) | 0;\n\n        // init skel-image\n        init(skelImagePtr, 0);\n        zeroBorder(subImagePtr);\n\n        do {\n            erode(subImagePtr, erodedImagePtr);\n            dilate(erodedImagePtr, tempImagePtr);\n            subtract(subImagePtr, tempImagePtr, tempImagePtr);\n            bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr);\n            memcpy(erodedImagePtr, subImagePtr);\n            sum = countNonZero(subImagePtr) | 0;\n            done = ((sum | 0) == 0 | 0);\n        } while (!done);\n    }\n    return {\n        skeletonize: skeletonize\n    };\n}\n/* @preserve ASM END */\nexport default Skeletonizer;\n/* eslint-enable eqeqeq*/\n\n\n\n// WEBPACK FOOTER //\n// ./src/locator/skeletonizer.js","import BarcodeReader from './barcode_reader';\n\nfunction TwoOfFiveReader(opts) {\n    BarcodeReader.call(this, opts);\n    this.barSpaceRatio = [1, 1];\n}\n\nvar N = 1,\n    W = 3,\n    properties = {\n        START_PATTERN: {value: [W, N, W, N, N, N]},\n        STOP_PATTERN: {value: [W, N, N, N, W]},\n        CODE_PATTERN: {value: [\n            [N, N, W, W, N],\n            [W, N, N, N, W],\n            [N, W, N, N, W],\n            [W, W, N, N, N],\n            [N, N, W, N, W],\n            [W, N, W, N, N],\n            [N, W, W, N, N],\n            [N, N, N, W, W],\n            [W, N, N, W, N],\n            [N, W, N, W, N]\n        ]},\n        SINGLE_CODE_ERROR: {value: 0.78, writable: true},\n        AVG_CODE_ERROR: {value: 0.30, writable: true},\n        FORMAT: {value: \"2of5\"}\n    };\n\nconst startPatternLength = properties.START_PATTERN.value.reduce((sum, val) => sum + val, 0);\n\nTwoOfFiveReader.prototype = Object.create(BarcodeReader.prototype, properties);\nTwoOfFiveReader.prototype.constructor = TwoOfFiveReader;\n\nTwoOfFiveReader.prototype._findPattern = function(pattern, offset, isWhite, tryHarder) {\n    var counter = [],\n        self = this,\n        i,\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        },\n        error,\n        j,\n        sum,\n        epsilon = self.AVG_CODE_ERROR;\n\n    isWhite = isWhite || false;\n    tryHarder = tryHarder || false;\n\n    if (!offset) {\n        offset = self._nextSet(self._row);\n    }\n\n    for ( i = 0; i < pattern.length; i++) {\n        counter[i] = 0;\n    }\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                sum = 0;\n                for ( j = 0; j < counter.length; j++) {\n                    sum += counter[j];\n                }\n                error = self._matchPattern(counter, pattern);\n                if (error < epsilon) {\n                    bestMatch.error = error;\n                    bestMatch.start = i - sum;\n                    bestMatch.end = i;\n                    return bestMatch;\n                }\n                if (tryHarder) {\n                    for (j = 0; j < counter.length - 2; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[counter.length - 2] = 0;\n                    counter[counter.length - 1] = 0;\n                    counterPos--;\n                } else {\n                    return null;\n                }\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nTwoOfFiveReader.prototype._findStart = function() {\n    var self = this,\n        leadingWhitespaceStart,\n        offset = self._nextSet(self._row),\n        startInfo,\n        narrowBarWidth = 1;\n\n    while (!startInfo) {\n        startInfo = self._findPattern(self.START_PATTERN, offset, false, true);\n        if (!startInfo) {\n            return null;\n        }\n        narrowBarWidth = Math.floor((startInfo.end - startInfo.start) / startPatternLength);\n        leadingWhitespaceStart = startInfo.start - narrowBarWidth * 5;\n        if (leadingWhitespaceStart >= 0) {\n            if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                return startInfo;\n            }\n        }\n        offset = startInfo.end;\n        startInfo = null;\n    }\n};\n\nTwoOfFiveReader.prototype._verifyTrailingWhitespace = function(endInfo) {\n    var self = this,\n        trailingWhitespaceEnd;\n\n    trailingWhitespaceEnd = endInfo.end + ((endInfo.end - endInfo.start) / 2);\n    if (trailingWhitespaceEnd < self._row.length) {\n        if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n            return endInfo;\n        }\n    }\n    return null;\n};\n\nTwoOfFiveReader.prototype._findEnd = function() {\n    var self = this,\n        endInfo,\n        tmp,\n        offset;\n\n    self._row.reverse();\n    offset = self._nextSet(self._row);\n    endInfo = self._findPattern(self.STOP_PATTERN, offset, false, true);\n    self._row.reverse();\n\n    if (endInfo === null) {\n        return null;\n    }\n\n    // reverse numbers\n    tmp = endInfo.start;\n    endInfo.start = self._row.length - endInfo.end;\n    endInfo.end = self._row.length - tmp;\n\n    return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;\n};\n\nTwoOfFiveReader.prototype._decodeCode = function(counter) {\n    var j,\n        self = this,\n        sum = 0,\n        normalized,\n        error,\n        epsilon = self.AVG_CODE_ERROR,\n        code,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        };\n\n    for ( j = 0; j < counter.length; j++) {\n        sum += counter[j];\n    }\n    for (code = 0; code < self.CODE_PATTERN.length; code++) {\n        error = self._matchPattern(counter, self.CODE_PATTERN[code]);\n        if (error < bestMatch.error) {\n            bestMatch.code = code;\n            bestMatch.error = error;\n        }\n    }\n    if (bestMatch.error < epsilon) {\n        return bestMatch;\n    }\n};\n\nTwoOfFiveReader.prototype._decodePayload = function(counters, result, decodedCodes) {\n    var i,\n        self = this,\n        pos = 0,\n        counterLength = counters.length,\n        counter = [0, 0, 0, 0, 0],\n        code;\n\n    while (pos < counterLength) {\n        for (i = 0; i < 5; i++) {\n            counter[i] = counters[pos] * this.barSpaceRatio[0];\n            pos += 2;\n        }\n        code = self._decodeCode(counter);\n        if (!code) {\n            return null;\n        }\n        result.push(code.code + \"\");\n        decodedCodes.push(code);\n    }\n    return code;\n};\n\nTwoOfFiveReader.prototype._verifyCounterLength = function(counters) {\n    return (counters.length % 10 === 0);\n};\n\nTwoOfFiveReader.prototype._decode = function() {\n    var startInfo,\n        endInfo,\n        self = this,\n        code,\n        result = [],\n        decodedCodes = [],\n        counters;\n\n    startInfo = self._findStart();\n    if (!startInfo) {\n        return null;\n    }\n    decodedCodes.push(startInfo);\n\n    endInfo = self._findEnd();\n    if (!endInfo) {\n        return null;\n    }\n\n    counters = self._fillCounters(startInfo.end, endInfo.start, false);\n    if (!self._verifyCounterLength(counters)) {\n        return null;\n    }\n    code = self._decodePayload(counters, result, decodedCodes);\n    if (!code) {\n        return null;\n    }\n    if (result.length < 5) {\n        return null;\n    }\n\n    decodedCodes.push(endInfo);\n    return {\n        code: result.join(\"\"),\n        start: startInfo.start,\n        end: endInfo.end,\n        startInfo: startInfo,\n        decodedCodes: decodedCodes\n    };\n};\n\nexport default TwoOfFiveReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/2of5_reader.js","import BarcodeReader from './barcode_reader';\n\nfunction CodabarReader() {\n    BarcodeReader.call(this);\n    this._counters = [];\n}\n\nvar properties = {\n    ALPHABETH_STRING: {value: \"0123456789-$:/.+ABCD\"},\n    ALPHABET: {value: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 36, 58, 47, 46, 43, 65, 66, 67, 68]},\n    CHARACTER_ENCODINGS: {value: [0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, 0x00c, 0x018,\n        0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E]},\n    START_END: {value: [0x01A, 0x029, 0x00B, 0x00E]},\n    MIN_ENCODED_CHARS: {value: 4},\n    MAX_ACCEPTABLE: {value: 2.0},\n    PADDING: {value: 1.5},\n    FORMAT: {value: \"codabar\", writeable: false}\n};\n\nCodabarReader.prototype = Object.create(BarcodeReader.prototype, properties);\nCodabarReader.prototype.constructor = CodabarReader;\n\nCodabarReader.prototype._decode = function() {\n    var self = this,\n        result = [],\n        start,\n        decodedChar,\n        pattern,\n        nextStart,\n        end;\n\n    this._counters = self._fillCounters();\n    start = self._findStart();\n    if (!start) {\n        return null;\n    }\n    nextStart = start.startCounter;\n\n    do {\n        pattern = self._toPattern(nextStart);\n        if (pattern < 0) {\n            return null;\n        }\n        decodedChar = self._patternToChar(pattern);\n        if (decodedChar < 0){\n            return null;\n        }\n        result.push(decodedChar);\n        nextStart += 8;\n        if (result.length > 1 && self._isStartEnd(pattern)) {\n            break;\n        }\n    } while (nextStart < self._counters.length);\n\n    // verify end\n    if ((result.length - 2) < self.MIN_ENCODED_CHARS || !self._isStartEnd(pattern)) {\n        return null;\n    }\n\n    // verify end white space\n    if (!self._verifyWhitespace(start.startCounter, nextStart - 8)){\n        return null;\n    }\n\n    if (!self._validateResult(result, start.startCounter)){\n        return null;\n    }\n\n    nextStart = nextStart > self._counters.length ? self._counters.length : nextStart;\n    end = start.start + self._sumCounters(start.startCounter, nextStart - 8);\n\n    return {\n        code: result.join(\"\"),\n        start: start.start,\n        end: end,\n        startInfo: start,\n        decodedCodes: result\n    };\n};\n\nCodabarReader.prototype._verifyWhitespace = function(startCounter, endCounter) {\n    if ((startCounter - 1 <= 0)\n            || this._counters[startCounter - 1] >= (this._calculatePatternLength(startCounter) / 2.0)) {\n        if ((endCounter + 8 >= this._counters.length)\n                || this._counters[endCounter + 7] >= (this._calculatePatternLength(endCounter) / 2.0)) {\n            return true;\n        }\n    }\n    return false;\n};\n\nCodabarReader.prototype._calculatePatternLength = function(offset) {\n    var i,\n        sum = 0;\n\n    for (i = offset; i < offset + 7; i++) {\n        sum += this._counters[i];\n    }\n\n    return sum;\n};\n\nCodabarReader.prototype._thresholdResultPattern = function(result, startCounter){\n    var self = this,\n        categorization = {\n            space: {\n                narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE},\n                wide: {size: 0, counts: 0, min: 0, max: Number.MAX_VALUE}\n            },\n            bar: {\n                narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE},\n                wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE}\n            }\n        },\n        kind,\n        cat,\n        i,\n        j,\n        pos = startCounter,\n        pattern;\n\n    for (i = 0; i < result.length; i++){\n        pattern = self._charToPattern(result[i]);\n        for (j = 6; j >= 0; j--) {\n            kind = (j & 1) === 2 ? categorization.bar : categorization.space;\n            cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;\n            cat.size += self._counters[pos + j];\n            cat.counts++;\n            pattern >>= 1;\n        }\n        pos += 8;\n    }\n\n    [\"space\", \"bar\"].forEach(function(key) {\n        var newkind = categorization[key];\n        newkind.wide.min =\n            Math.floor((newkind.narrow.size / newkind.narrow.counts + newkind.wide.size / newkind.wide.counts) / 2);\n        newkind.narrow.max = Math.ceil(newkind.wide.min);\n        newkind.wide.max = Math.ceil((newkind.wide.size * self.MAX_ACCEPTABLE + self.PADDING) / newkind.wide.counts);\n    });\n\n    return categorization;\n};\n\nCodabarReader.prototype._charToPattern = function(char) {\n    var self = this,\n        charCode = char.charCodeAt(0),\n        i;\n\n    for (i = 0; i < self.ALPHABET.length; i++) {\n        if (self.ALPHABET[i] === charCode){\n            return self.CHARACTER_ENCODINGS[i];\n        }\n    }\n    return 0x0;\n};\n\nCodabarReader.prototype._validateResult = function(result, startCounter) {\n    var self = this,\n        thresholds = self._thresholdResultPattern(result, startCounter),\n        i,\n        j,\n        kind,\n        cat,\n        size,\n        pos = startCounter,\n        pattern;\n\n    for (i = 0; i < result.length; i++) {\n        pattern = self._charToPattern(result[i]);\n        for (j = 6; j >= 0; j--) {\n            kind = (j & 1) === 0 ? thresholds.bar : thresholds.space;\n            cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;\n            size = self._counters[pos + j];\n            if (size < cat.min || size > cat.max) {\n                return false;\n            }\n            pattern >>= 1;\n        }\n        pos += 8;\n    }\n    return true;\n};\n\nCodabarReader.prototype._patternToChar = function(pattern) {\n    var i,\n        self = this;\n\n    for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {\n        if (self.CHARACTER_ENCODINGS[i] === pattern) {\n            return String.fromCharCode(self.ALPHABET[i]);\n        }\n    }\n    return -1;\n};\n\nCodabarReader.prototype._computeAlternatingThreshold = function(offset, end) {\n    var i,\n        min = Number.MAX_VALUE,\n        max = 0,\n        counter;\n\n    for (i = offset; i < end; i += 2){\n        counter = this._counters[i];\n        if (counter > max) {\n            max = counter;\n        }\n        if (counter < min) {\n            min = counter;\n        }\n    }\n\n    return ((min + max) / 2.0) | 0;\n};\n\nCodabarReader.prototype._toPattern = function(offset) {\n    var numCounters = 7,\n        end = offset + numCounters,\n        barThreshold,\n        spaceThreshold,\n        bitmask = 1 << (numCounters - 1),\n        pattern = 0,\n        i,\n        threshold;\n\n    if (end > this._counters.length) {\n        return -1;\n    }\n\n    barThreshold = this._computeAlternatingThreshold(offset, end);\n    spaceThreshold = this._computeAlternatingThreshold(offset + 1, end);\n\n    for (i = 0; i < numCounters; i++){\n        threshold = (i & 1) === 0 ? barThreshold : spaceThreshold;\n        if (this._counters[offset + i] > threshold) {\n            pattern |= bitmask;\n        }\n        bitmask >>= 1;\n    }\n\n    return pattern;\n};\n\nCodabarReader.prototype._isStartEnd = function(pattern) {\n    var i;\n\n    for (i = 0; i < this.START_END.length; i++) {\n        if (this.START_END[i] === pattern) {\n            return true;\n        }\n    }\n    return false;\n};\n\nCodabarReader.prototype._sumCounters = function(start, end) {\n    var i,\n        sum = 0;\n\n    for (i = start; i < end; i++) {\n        sum += this._counters[i];\n    }\n    return sum;\n};\n\nCodabarReader.prototype._findStart = function() {\n    var self = this,\n        i,\n        pattern,\n        start = self._nextUnset(self._row),\n        end;\n\n    for (i = 1; i < this._counters.length; i++) {\n        pattern = self._toPattern(i);\n        if (pattern !== -1 && self._isStartEnd(pattern)) {\n            // TODO: Look for whitespace ahead\n            start += self._sumCounters(0, i);\n            end = start + self._sumCounters(i, i + 8);\n            return {\n                start: start,\n                end: end,\n                startCounter: i,\n                endCounter: i + 8\n            };\n        }\n    }\n};\n\nexport default CodabarReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/codabar_reader.js","import BarcodeReader from './barcode_reader';\n\nfunction Code128Reader() {\n    BarcodeReader.call(this);\n}\n\nvar properties = {\n    CODE_SHIFT: {value: 98},\n    CODE_C: {value: 99},\n    CODE_B: {value: 100},\n    CODE_A: {value: 101},\n    START_CODE_A: {value: 103},\n    START_CODE_B: {value: 104},\n    START_CODE_C: {value: 105},\n    STOP_CODE: {value: 106},\n    CODE_PATTERN: {value: [\n        [2, 1, 2, 2, 2, 2],\n        [2, 2, 2, 1, 2, 2],\n        [2, 2, 2, 2, 2, 1],\n        [1, 2, 1, 2, 2, 3],\n        [1, 2, 1, 3, 2, 2],\n        [1, 3, 1, 2, 2, 2],\n        [1, 2, 2, 2, 1, 3],\n        [1, 2, 2, 3, 1, 2],\n        [1, 3, 2, 2, 1, 2],\n        [2, 2, 1, 2, 1, 3],\n        [2, 2, 1, 3, 1, 2],\n        [2, 3, 1, 2, 1, 2],\n        [1, 1, 2, 2, 3, 2],\n        [1, 2, 2, 1, 3, 2],\n        [1, 2, 2, 2, 3, 1],\n        [1, 1, 3, 2, 2, 2],\n        [1, 2, 3, 1, 2, 2],\n        [1, 2, 3, 2, 2, 1],\n        [2, 2, 3, 2, 1, 1],\n        [2, 2, 1, 1, 3, 2],\n        [2, 2, 1, 2, 3, 1],\n        [2, 1, 3, 2, 1, 2],\n        [2, 2, 3, 1, 1, 2],\n        [3, 1, 2, 1, 3, 1],\n        [3, 1, 1, 2, 2, 2],\n        [3, 2, 1, 1, 2, 2],\n        [3, 2, 1, 2, 2, 1],\n        [3, 1, 2, 2, 1, 2],\n        [3, 2, 2, 1, 1, 2],\n        [3, 2, 2, 2, 1, 1],\n        [2, 1, 2, 1, 2, 3],\n        [2, 1, 2, 3, 2, 1],\n        [2, 3, 2, 1, 2, 1],\n        [1, 1, 1, 3, 2, 3],\n        [1, 3, 1, 1, 2, 3],\n        [1, 3, 1, 3, 2, 1],\n        [1, 1, 2, 3, 1, 3],\n        [1, 3, 2, 1, 1, 3],\n        [1, 3, 2, 3, 1, 1],\n        [2, 1, 1, 3, 1, 3],\n        [2, 3, 1, 1, 1, 3],\n        [2, 3, 1, 3, 1, 1],\n        [1, 1, 2, 1, 3, 3],\n        [1, 1, 2, 3, 3, 1],\n        [1, 3, 2, 1, 3, 1],\n        [1, 1, 3, 1, 2, 3],\n        [1, 1, 3, 3, 2, 1],\n        [1, 3, 3, 1, 2, 1],\n        [3, 1, 3, 1, 2, 1],\n        [2, 1, 1, 3, 3, 1],\n        [2, 3, 1, 1, 3, 1],\n        [2, 1, 3, 1, 1, 3],\n        [2, 1, 3, 3, 1, 1],\n        [2, 1, 3, 1, 3, 1],\n        [3, 1, 1, 1, 2, 3],\n        [3, 1, 1, 3, 2, 1],\n        [3, 3, 1, 1, 2, 1],\n        [3, 1, 2, 1, 1, 3],\n        [3, 1, 2, 3, 1, 1],\n        [3, 3, 2, 1, 1, 1],\n        [3, 1, 4, 1, 1, 1],\n        [2, 2, 1, 4, 1, 1],\n        [4, 3, 1, 1, 1, 1],\n        [1, 1, 1, 2, 2, 4],\n        [1, 1, 1, 4, 2, 2],\n        [1, 2, 1, 1, 2, 4],\n        [1, 2, 1, 4, 2, 1],\n        [1, 4, 1, 1, 2, 2],\n        [1, 4, 1, 2, 2, 1],\n        [1, 1, 2, 2, 1, 4],\n        [1, 1, 2, 4, 1, 2],\n        [1, 2, 2, 1, 1, 4],\n        [1, 2, 2, 4, 1, 1],\n        [1, 4, 2, 1, 1, 2],\n        [1, 4, 2, 2, 1, 1],\n        [2, 4, 1, 2, 1, 1],\n        [2, 2, 1, 1, 1, 4],\n        [4, 1, 3, 1, 1, 1],\n        [2, 4, 1, 1, 1, 2],\n        [1, 3, 4, 1, 1, 1],\n        [1, 1, 1, 2, 4, 2],\n        [1, 2, 1, 1, 4, 2],\n        [1, 2, 1, 2, 4, 1],\n        [1, 1, 4, 2, 1, 2],\n        [1, 2, 4, 1, 1, 2],\n        [1, 2, 4, 2, 1, 1],\n        [4, 1, 1, 2, 1, 2],\n        [4, 2, 1, 1, 1, 2],\n        [4, 2, 1, 2, 1, 1],\n        [2, 1, 2, 1, 4, 1],\n        [2, 1, 4, 1, 2, 1],\n        [4, 1, 2, 1, 2, 1],\n        [1, 1, 1, 1, 4, 3],\n        [1, 1, 1, 3, 4, 1],\n        [1, 3, 1, 1, 4, 1],\n        [1, 1, 4, 1, 1, 3],\n        [1, 1, 4, 3, 1, 1],\n        [4, 1, 1, 1, 1, 3],\n        [4, 1, 1, 3, 1, 1],\n        [1, 1, 3, 1, 4, 1],\n        [1, 1, 4, 1, 3, 1],\n        [3, 1, 1, 1, 4, 1],\n        [4, 1, 1, 1, 3, 1],\n        [2, 1, 1, 4, 1, 2],\n        [2, 1, 1, 2, 1, 4],\n        [2, 1, 1, 2, 3, 2],\n        [2, 3, 3, 1, 1, 1, 2]\n    ]},\n    SINGLE_CODE_ERROR: {value: 0.64},\n    AVG_CODE_ERROR: {value: 0.30},\n    FORMAT: {value: \"code_128\", writeable: false},\n    MODULE_INDICES: {value: {bar: [0, 2, 4], space: [1, 3, 5]}}\n};\n\nCode128Reader.prototype = Object.create(BarcodeReader.prototype, properties);\nCode128Reader.prototype.constructor = Code128Reader;\n\nCode128Reader.prototype._decodeCode = function(start, correction) {\n    var counter = [0, 0, 0, 0, 0, 0],\n        i,\n        self = this,\n        offset = start,\n        isWhite = !self._row[offset],\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: start,\n            end: start,\n            correction: {\n                bar: 1,\n                space: 1\n            }\n        },\n        code,\n        error;\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                if (correction) {\n                    self._correct(counter, correction);\n                }\n                for (code = 0; code < self.CODE_PATTERN.length; code++) {\n                    error = self._matchPattern(counter, self.CODE_PATTERN[code]);\n                    if (error < bestMatch.error) {\n                        bestMatch.code = code;\n                        bestMatch.error = error;\n                    }\n                }\n                bestMatch.end = i;\n                if (bestMatch.code === -1 || bestMatch.error > self.AVG_CODE_ERROR) {\n                    return null;\n                }\n                if (self.CODE_PATTERN[bestMatch.code]) {\n                    bestMatch.correction.bar = calculateCorrection(\n                        self.CODE_PATTERN[bestMatch.code], counter,\n                        this.MODULE_INDICES.bar);\n                    bestMatch.correction.space = calculateCorrection(\n                        self.CODE_PATTERN[bestMatch.code], counter,\n                        this.MODULE_INDICES.space);\n                }\n                return bestMatch;\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nCode128Reader.prototype._correct = function(counter, correction) {\n    this._correctBars(counter, correction.bar, this.MODULE_INDICES.bar);\n    this._correctBars(counter, correction.space, this.MODULE_INDICES.space);\n};\n\nCode128Reader.prototype._findStart = function() {\n    var counter = [0, 0, 0, 0, 0, 0],\n        i,\n        self = this,\n        offset = self._nextSet(self._row),\n        isWhite = false,\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0,\n            correction: {\n                bar: 1,\n                space: 1\n            }\n        },\n        code,\n        error,\n        j,\n        sum;\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                sum = 0;\n                for ( j = 0; j < counter.length; j++) {\n                    sum += counter[j];\n                }\n                for (code = self.START_CODE_A; code <= self.START_CODE_C; code++) {\n                    error = self._matchPattern(counter, self.CODE_PATTERN[code]);\n                    if (error < bestMatch.error) {\n                        bestMatch.code = code;\n                        bestMatch.error = error;\n                    }\n                }\n                if (bestMatch.error < self.AVG_CODE_ERROR) {\n                    bestMatch.start = i - sum;\n                    bestMatch.end = i;\n                    bestMatch.correction.bar = calculateCorrection(\n                        self.CODE_PATTERN[bestMatch.code], counter,\n                        this.MODULE_INDICES.bar);\n                    bestMatch.correction.space = calculateCorrection(\n                        self.CODE_PATTERN[bestMatch.code], counter,\n                        this.MODULE_INDICES.space);\n                    return bestMatch;\n                }\n\n                for ( j = 0; j < 4; j++) {\n                    counter[j] = counter[j + 2];\n                }\n                counter[4] = 0;\n                counter[5] = 0;\n                counterPos--;\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nCode128Reader.prototype._decode = function() {\n    var self = this,\n        startInfo = self._findStart(),\n        code = null,\n        done = false,\n        result = [],\n        multiplier = 0,\n        checksum = 0,\n        codeset,\n        rawResult = [],\n        decodedCodes = [],\n        shiftNext = false,\n        unshift,\n        removeLastCharacter = true;\n\n    if (startInfo === null) {\n        return null;\n    }\n    code = {\n        code: startInfo.code,\n        start: startInfo.start,\n        end: startInfo.end,\n        correction: {\n            bar: startInfo.correction.bar,\n            space: startInfo.correction.space\n        }\n    };\n    decodedCodes.push(code);\n    checksum = code.code;\n    switch (code.code) {\n    case self.START_CODE_A:\n        codeset = self.CODE_A;\n        break;\n    case self.START_CODE_B:\n        codeset = self.CODE_B;\n        break;\n    case self.START_CODE_C:\n        codeset = self.CODE_C;\n        break;\n    default:\n        return null;\n    }\n\n    while (!done) {\n        unshift = shiftNext;\n        shiftNext = false;\n        code = self._decodeCode(code.end, code.correction);\n        if (code !== null) {\n            if (code.code !== self.STOP_CODE) {\n                removeLastCharacter = true;\n            }\n\n            if (code.code !== self.STOP_CODE) {\n                rawResult.push(code.code);\n                multiplier++;\n                checksum += multiplier * code.code;\n            }\n            decodedCodes.push(code);\n\n            switch (codeset) {\n            case self.CODE_A:\n                if (code.code < 64) {\n                    result.push(String.fromCharCode(32 + code.code));\n                } else if (code.code < 96) {\n                    result.push(String.fromCharCode(code.code - 64));\n                } else {\n                    if (code.code !== self.STOP_CODE) {\n                        removeLastCharacter = false;\n                    }\n                    switch (code.code) {\n                    case self.CODE_SHIFT:\n                        shiftNext = true;\n                        codeset = self.CODE_B;\n                        break;\n                    case self.CODE_B:\n                        codeset = self.CODE_B;\n                        break;\n                    case self.CODE_C:\n                        codeset = self.CODE_C;\n                        break;\n                    case self.STOP_CODE:\n                        done = true;\n                        break;\n                    }\n                }\n                break;\n            case self.CODE_B:\n                if (code.code < 96) {\n                    result.push(String.fromCharCode(32 + code.code));\n                } else {\n                    if (code.code !== self.STOP_CODE) {\n                        removeLastCharacter = false;\n                    }\n                    switch (code.code) {\n                    case self.CODE_SHIFT:\n                        shiftNext = true;\n                        codeset = self.CODE_A;\n                        break;\n                    case self.CODE_A:\n                        codeset = self.CODE_A;\n                        break;\n                    case self.CODE_C:\n                        codeset = self.CODE_C;\n                        break;\n                    case self.STOP_CODE:\n                        done = true;\n                        break;\n                    }\n                }\n                break;\n            case self.CODE_C:\n                if (code.code < 100) {\n                    result.push(code.code < 10 ? \"0\" + code.code : code.code);\n                } else {\n                    if (code.code !== self.STOP_CODE) {\n                        removeLastCharacter = false;\n                    }\n                    switch (code.code) {\n                    case self.CODE_A:\n                        codeset = self.CODE_A;\n                        break;\n                    case self.CODE_B:\n                        codeset = self.CODE_B;\n                        break;\n                    case self.STOP_CODE:\n                        done = true;\n                        break;\n                    }\n                }\n                break;\n            }\n        } else {\n            done = true;\n        }\n        if (unshift) {\n            codeset = codeset === self.CODE_A ? self.CODE_B : self.CODE_A;\n        }\n    }\n\n    if (code === null) {\n        return null;\n    }\n\n    code.end = self._nextUnset(self._row, code.end);\n    if (!self._verifyTrailingWhitespace(code)){\n        return null;\n    }\n\n    checksum -= multiplier * rawResult[rawResult.length - 1];\n    if (checksum % 103 !== rawResult[rawResult.length - 1]) {\n        return null;\n    }\n\n    if (!result.length) {\n        return null;\n    }\n\n    // remove last code from result (checksum)\n    if (removeLastCharacter) {\n        result.splice(result.length - 1, 1);\n    }\n\n\n    return {\n        code: result.join(\"\"),\n        start: startInfo.start,\n        end: code.end,\n        codeset: codeset,\n        startInfo: startInfo,\n        decodedCodes: decodedCodes,\n        endInfo: code\n    };\n};\n\n\nBarcodeReader.prototype._verifyTrailingWhitespace = function(endInfo) {\n    var self = this,\n        trailingWhitespaceEnd;\n\n    trailingWhitespaceEnd = endInfo.end + ((endInfo.end - endInfo.start) / 2);\n    if (trailingWhitespaceEnd < self._row.length) {\n        if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n            return endInfo;\n        }\n    }\n    return null;\n};\n\nfunction calculateCorrection(expected, normalized, indices) {\n    var length = indices.length,\n        sumNormalized = 0,\n        sumExpected = 0;\n\n    while(length--) {\n        sumExpected += expected[indices[length]];\n        sumNormalized += normalized[indices[length]];\n    }\n    return sumExpected/sumNormalized;\n}\n\nexport default Code128Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/code_128_reader.js","import Code39Reader from './code_39_reader';\n\nfunction Code39VINReader() {\n    Code39Reader.call(this);\n}\n\nvar patterns = {\n    IOQ: /[IOQ]/g,\n    AZ09: /[A-Z0-9]{17}/\n};\n\nCode39VINReader.prototype = Object.create(Code39Reader.prototype);\nCode39VINReader.prototype.constructor = Code39VINReader;\n\n// Cribbed from:\n// https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/client/result/VINResultParser.java\nCode39VINReader.prototype._decode = function() {\n    var result = Code39Reader.prototype._decode.apply(this);\n    if (!result) {\n        return null;\n    }\n\n    var code = result.code;\n\n    if (!code) {\n        return null;\n    }\n\n    code = code.replace(patterns.IOQ, '');\n\n    if (!code.match(patterns.AZ09)) {\n        if (ENV.development) {\n            console.log('Failed AZ09 pattern code:', code);\n        }\n        return null;\n    }\n\n    if (!this._checkChecksum(code)) {\n        return null;\n    }\n\n    result.code = code;\n    return result;\n};\n\nCode39VINReader.prototype._checkChecksum = function(code) {\n    // TODO\n    return !!code;\n};\n\nexport default Code39VINReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/code_39_vin_reader.js","import BarcodeReader from './barcode_reader';\nimport ArrayHelper from '../common/array_helper';\n\nfunction Code93Reader() {\n    BarcodeReader.call(this);\n}\n\nconst ALPHABETH_STRING = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*\";\n\nvar properties = {\n    ALPHABETH_STRING: {value: ALPHABETH_STRING},\n    ALPHABET: {value: ALPHABETH_STRING.split('').map(char => char.charCodeAt(0))},\n    CHARACTER_ENCODINGS: {value: [\n        0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A,\n        0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A, 0x168, 0x164, 0x162, 0x134,\n        0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6,\n        0x196, 0x19A, 0x16C, 0x166, 0x136, 0x13A, 0x12E, 0x1D4, 0x1D2, 0x1CA,\n        0x16E, 0x176, 0x1AE, 0x126, 0x1DA, 0x1D6, 0x132, 0x15E\n    ]},\n    ASTERISK: {value: 0x15E},\n    FORMAT: {value: \"code_93\", writeable: false}\n};\n\nCode93Reader.prototype = Object.create(BarcodeReader.prototype, properties);\nCode93Reader.prototype.constructor = Code93Reader;\n\nCode93Reader.prototype._decode = function() {\n    var self = this,\n        counters = [0, 0, 0, 0, 0, 0],\n        result = [],\n        start = self._findStart(),\n        decodedChar,\n        lastStart,\n        pattern,\n        nextStart;\n\n    if (!start) {\n        return null;\n    }\n    nextStart = self._nextSet(self._row, start.end);\n\n    do {\n        counters = self._toCounters(nextStart, counters);\n        pattern = self._toPattern(counters);\n        if (pattern < 0) {\n            return null;\n        }\n        decodedChar = self._patternToChar(pattern);\n        if (decodedChar < 0){\n            return null;\n        }\n        result.push(decodedChar);\n        lastStart = nextStart;\n        nextStart += ArrayHelper.sum(counters);\n        nextStart = self._nextSet(self._row, nextStart);\n    } while (decodedChar !== '*');\n    result.pop();\n\n    if (!result.length) {\n        return null;\n    }\n\n    if (!self._verifyEnd(lastStart, nextStart, counters)) {\n        return null;\n    }\n\n    if (!self._verifyChecksums(result)) {\n        return null;\n    }\n\n    result = result.slice(0, result.length - 2);\n    if ((result = self._decodeExtended(result)) === null) {\n        return null;\n    };\n\n    return {\n        code: result.join(\"\"),\n        start: start.start,\n        end: nextStart,\n        startInfo: start,\n        decodedCodes: result\n    };\n};\n\nCode93Reader.prototype._verifyEnd = function(lastStart, nextStart) {\n    if (lastStart === nextStart || !this._row[nextStart]) {\n        return false;\n    }\n    return true;\n};\n\nCode93Reader.prototype._patternToChar = function(pattern) {\n    var i,\n        self = this;\n\n    for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) {\n        if (self.CHARACTER_ENCODINGS[i] === pattern) {\n            return String.fromCharCode(self.ALPHABET[i]);\n        }\n    }\n    return -1;\n};\n\nCode93Reader.prototype._toPattern = function(counters) {\n    const numCounters = counters.length;\n    let pattern = 0;\n    let sum = 0;\n    for (let i = 0; i < numCounters; i++) {\n        sum += counters[i];\n    }\n\n    for (let i = 0; i < numCounters; i++) {\n        let normalized = Math.round(counters[i] * 9 / sum);\n        if (normalized < 1 || normalized > 4) {\n            return -1;\n        }\n        if ((i & 1) === 0) {\n            for (let j = 0; j < normalized; j++) {\n                pattern = (pattern << 1) | 1;\n            }\n        } else {\n            pattern <<= normalized;\n        }\n    }\n\n    return pattern;\n};\n\nCode93Reader.prototype._findStart = function() {\n    var self = this,\n        offset = self._nextSet(self._row),\n        patternStart = offset,\n        counter = [0, 0, 0, 0, 0, 0],\n        counterPos = 0,\n        isWhite = false,\n        i,\n        j,\n        whiteSpaceMustStart;\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                // find start pattern\n                if (self._toPattern(counter) === self.ASTERISK) {\n                    whiteSpaceMustStart = Math.floor(Math.max(0, patternStart - ((i - patternStart) / 4)));\n                    if (self._matchRange(whiteSpaceMustStart, patternStart, 0)) {\n                        return {\n                            start: patternStart,\n                            end: i\n                        };\n                    }\n                }\n\n                patternStart += counter[0] + counter[1];\n                for ( j = 0; j < 4; j++) {\n                    counter[j] = counter[j + 2];\n                }\n                counter[4] = 0;\n                counter[5] = 0;\n                counterPos--;\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nCode93Reader.prototype._decodeExtended = function(charArray) {\n    const length = charArray.length;\n    const result = [];\n    for (let i = 0; i < length; i++) {\n        const char = charArray[i];\n        if (char >= 'a' && char <= 'd') {\n            if (i > (length - 2)) {\n                return null;\n            }\n            const nextChar = charArray[++i];\n            const nextCharCode = nextChar.charCodeAt(0);\n            let decodedChar;\n            switch (char) {\n            case 'a':\n                if (nextChar >= 'A' && nextChar <= 'Z') {\n                    decodedChar = String.fromCharCode(nextCharCode - 64);\n                } else {\n                    return null;\n                }\n                break;\n            case 'b':\n                if (nextChar >= 'A' && nextChar <= 'E') {\n                    decodedChar = String.fromCharCode(nextCharCode - 38);\n                } else if (nextChar >= 'F' && nextChar <= 'J') {\n                    decodedChar = String.fromCharCode(nextCharCode - 11);\n                } else if (nextChar >= 'K' && nextChar <= 'O') {\n                    decodedChar = String.fromCharCode(nextCharCode + 16);\n                } else if (nextChar >= 'P' && nextChar <= 'S') {\n                    decodedChar = String.fromCharCode(nextCharCode + 43);\n                } else if (nextChar >= 'T' && nextChar <= 'Z') {\n                    decodedChar = String.fromCharCode(127);\n                } else {\n                    return null;\n                }\n                break;\n            case 'c':\n                if (nextChar >= 'A' && nextChar <= 'O') {\n                    decodedChar = String.fromCharCode(nextCharCode - 32);\n                } else if (nextChar === 'Z') {\n                    decodedChar = ':';\n                } else {\n                    return null;\n                }\n                break;\n            case 'd':\n                if (nextChar >= 'A' && nextChar <= 'Z') {\n                    decodedChar = String.fromCharCode(nextCharCode + 32);\n                } else {\n                    return null;\n                }\n                break;\n            }\n            result.push(decodedChar);\n        } else {\n            result.push(char);\n        }\n    }\n    return result;\n};\n\nCode93Reader.prototype._verifyChecksums = function(charArray) {\n    return this._matchCheckChar(charArray, charArray.length - 2, 20)\n        && this._matchCheckChar(charArray, charArray.length - 1, 15);\n};\n\nCode93Reader.prototype._matchCheckChar = function(charArray, index, maxWeight) {\n    const arrayToCheck = charArray.slice(0, index);\n    const length = arrayToCheck.length;\n    const weightedSums = arrayToCheck.reduce((sum, char, i) => {\n        const weight = (((i * -1) + (length - 1)) % maxWeight) + 1;\n        const value = this.ALPHABET.indexOf(char.charCodeAt(0));\n        return sum + (weight * value);\n    }, 0);\n\n    const checkChar = this.ALPHABET[(weightedSums % 47)];\n    return checkChar === charArray[index].charCodeAt(0);\n};\n\nexport default Code93Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/code_93_reader.js","import EANReader from './ean_reader';\n\nfunction EAN2Reader() {\n    EANReader.call(this);\n}\n\nvar properties = {\n    FORMAT: {value: \"ean_2\", writeable: false}\n};\n\nEAN2Reader.prototype = Object.create(EANReader.prototype, properties);\nEAN2Reader.prototype.constructor = EAN2Reader;\n\nEAN2Reader.prototype.decode = function(row, start) {\n    this._row = row;\n    var counters = [0, 0, 0, 0],\n        codeFrequency = 0,\n        i = 0,\n        offset = start,\n        end = this._row.length,\n        code,\n        result = [],\n        decodedCodes = [];\n\n    for (i = 0; i < 2 && offset < end; i++) {\n        code = this._decodeCode(offset);\n        if (!code) {\n            return null;\n        }\n        decodedCodes.push(code);\n        result.push(code.code % 10);\n        if (code.code >= this.CODE_G_START) {\n            codeFrequency |= 1 << (1 - i);\n        }\n        if (i != 1) {\n            offset = this._nextSet(this._row, code.end);\n            offset = this._nextUnset(this._row, offset);\n        }\n    }\n\n    if (result.length != 2 || (parseInt(result.join(\"\")) % 4)  !== codeFrequency) {\n        return null;\n    }\n    return {\n        code: result.join(\"\"),\n        decodedCodes,\n        end: code.end\n    };\n};\n\nexport default EAN2Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/ean_2_reader.js","import EANReader from './ean_reader';\n\nfunction EAN5Reader() {\n    EANReader.call(this);\n}\n\nvar properties = {\n    FORMAT: {value: \"ean_5\", writeable: false}\n};\n\nconst CHECK_DIGIT_ENCODINGS = [24, 20, 18, 17, 12, 6, 3, 10, 9, 5];\n\nEAN5Reader.prototype = Object.create(EANReader.prototype, properties);\nEAN5Reader.prototype.constructor = EAN5Reader;\n\nEAN5Reader.prototype.decode = function(row, start) {\n    this._row = row;\n    var counters = [0, 0, 0, 0],\n        codeFrequency = 0,\n        i = 0,\n        offset = start,\n        end = this._row.length,\n        code,\n        result = [],\n        decodedCodes = [];\n\n    for (i = 0; i < 5 && offset < end; i++) {\n        code = this._decodeCode(offset);\n        if (!code) {\n            return null;\n        }\n        decodedCodes.push(code);\n        result.push(code.code % 10);\n        if (code.code >= this.CODE_G_START) {\n            codeFrequency |= 1 << (4 - i);\n        }\n        if (i != 4) {\n            offset = this._nextSet(this._row, code.end);\n            offset = this._nextUnset(this._row, offset);\n        }\n    }\n\n    if (result.length != 5) {\n        return null;\n    }\n\n    if (extensionChecksum(result) !== determineCheckDigit(codeFrequency)) {\n        return null;\n    }\n    return {\n        code: result.join(\"\"),\n        decodedCodes,\n        end: code.end\n    };\n};\n\nfunction determineCheckDigit(codeFrequency) {\n    var i;\n    for (i = 0; i < 10; i++) {\n        if (codeFrequency === CHECK_DIGIT_ENCODINGS[i]) {\n            return i;\n        }\n    }\n    return null;\n}\n\n\nfunction extensionChecksum(result) {\n    var length = result.length,\n        sum = 0,\n        i;\n\n    for (i = length - 2; i >= 0; i -= 2) {\n        sum += result[i];\n    }\n    sum *= 3;\n    for (i = length - 1; i >= 0; i -= 2) {\n        sum += result[i];\n    }\n    sum *= 3;\n    return sum % 10;\n}\n\nexport default EAN5Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/ean_5_reader.js","import EANReader from './ean_reader';\n\nfunction EAN8Reader(opts, supplements) {\n    EANReader.call(this, opts, supplements);\n}\n\nvar properties = {\n    FORMAT: {value: \"ean_8\", writeable: false}\n};\n\nEAN8Reader.prototype = Object.create(EANReader.prototype, properties);\nEAN8Reader.prototype.constructor = EAN8Reader;\n\nEAN8Reader.prototype._decodePayload = function(code, result, decodedCodes) {\n    var i,\n        self = this;\n\n    for ( i = 0; i < 4; i++) {\n        code = self._decodeCode(code.end, self.CODE_G_START);\n        if (!code) {\n            return null;\n        }\n        result.push(code.code);\n        decodedCodes.push(code);\n    }\n\n    code = self._findPattern(self.MIDDLE_PATTERN, code.end, true, false);\n    if (code === null) {\n        return null;\n    }\n    decodedCodes.push(code);\n\n    for ( i = 0; i < 4; i++) {\n        code = self._decodeCode(code.end, self.CODE_G_START);\n        if (!code) {\n            return null;\n        }\n        decodedCodes.push(code);\n        result.push(code.code);\n    }\n\n    return code;\n};\n\nexport default EAN8Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/ean_8_reader.js","import BarcodeReader from './barcode_reader';\nimport {merge} from 'lodash';\n\nfunction I2of5Reader(opts) {\n    opts = merge(getDefaulConfig(), opts);\n    BarcodeReader.call(this, opts);\n    this.barSpaceRatio = [1, 1];\n    if (opts.normalizeBarSpaceWidth) {\n        this.SINGLE_CODE_ERROR = 0.38;\n        this.AVG_CODE_ERROR = 0.09;\n    }\n}\n\nfunction getDefaulConfig() {\n    var config = {};\n\n    Object.keys(I2of5Reader.CONFIG_KEYS).forEach(function(key) {\n        config[key] = I2of5Reader.CONFIG_KEYS[key].default;\n    });\n    return config;\n}\n\nvar N = 1,\n    W = 3,\n    properties = {\n        START_PATTERN: {value: [N, N, N, N]},\n        STOP_PATTERN: {value: [N, N, W]},\n        CODE_PATTERN: {value: [\n            [N, N, W, W, N],\n            [W, N, N, N, W],\n            [N, W, N, N, W],\n            [W, W, N, N, N],\n            [N, N, W, N, W],\n            [W, N, W, N, N],\n            [N, W, W, N, N],\n            [N, N, N, W, W],\n            [W, N, N, W, N],\n            [N, W, N, W, N]\n        ]},\n        SINGLE_CODE_ERROR: {value: 0.78, writable: true},\n        AVG_CODE_ERROR: {value: 0.38, writable: true},\n        MAX_CORRECTION_FACTOR: {value: 5},\n        FORMAT: {value: \"i2of5\"}\n    };\n\nI2of5Reader.prototype = Object.create(BarcodeReader.prototype, properties);\nI2of5Reader.prototype.constructor = I2of5Reader;\n\nI2of5Reader.prototype._matchPattern = function(counter, code) {\n    if (this.config.normalizeBarSpaceWidth) {\n        var i,\n            counterSum = [0, 0],\n            codeSum = [0, 0],\n            correction = [0, 0],\n            correctionRatio = this.MAX_CORRECTION_FACTOR,\n            correctionRatioInverse = 1 / correctionRatio;\n\n        for (i = 0; i < counter.length; i++) {\n            counterSum[i % 2] += counter[i];\n            codeSum[i % 2] += code[i];\n        }\n        correction[0] = codeSum[0] / counterSum[0];\n        correction[1] = codeSum[1] / counterSum[1];\n\n        correction[0] = Math.max(Math.min(correction[0], correctionRatio), correctionRatioInverse);\n        correction[1] = Math.max(Math.min(correction[1], correctionRatio), correctionRatioInverse);\n        this.barSpaceRatio = correction;\n        for (i = 0; i < counter.length; i++) {\n            counter[i] *= this.barSpaceRatio[i % 2];\n        }\n    }\n    return BarcodeReader.prototype._matchPattern.call(this, counter, code);\n};\n\nI2of5Reader.prototype._findPattern = function(pattern, offset, isWhite, tryHarder) {\n    var counter = [],\n        self = this,\n        i,\n        counterPos = 0,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        },\n        error,\n        j,\n        sum,\n        normalized,\n        epsilon = self.AVG_CODE_ERROR;\n\n    isWhite = isWhite || false;\n    tryHarder = tryHarder || false;\n\n    if (!offset) {\n        offset = self._nextSet(self._row);\n    }\n\n    for ( i = 0; i < pattern.length; i++) {\n        counter[i] = 0;\n    }\n\n    for ( i = offset; i < self._row.length; i++) {\n        if (self._row[i] ^ isWhite) {\n            counter[counterPos]++;\n        } else {\n            if (counterPos === counter.length - 1) {\n                sum = 0;\n                for ( j = 0; j < counter.length; j++) {\n                    sum += counter[j];\n                }\n                error = self._matchPattern(counter, pattern);\n                if (error < epsilon) {\n                    bestMatch.error = error;\n                    bestMatch.start = i - sum;\n                    bestMatch.end = i;\n                    return bestMatch;\n                }\n                if (tryHarder) {\n                    for (j = 0; j < counter.length - 2; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[counter.length - 2] = 0;\n                    counter[counter.length - 1] = 0;\n                    counterPos--;\n                } else {\n                    return null;\n                }\n            } else {\n                counterPos++;\n            }\n            counter[counterPos] = 1;\n            isWhite = !isWhite;\n        }\n    }\n    return null;\n};\n\nI2of5Reader.prototype._findStart = function() {\n    var self = this,\n        leadingWhitespaceStart,\n        offset = self._nextSet(self._row),\n        startInfo,\n        narrowBarWidth = 1;\n\n    while (!startInfo) {\n        startInfo = self._findPattern(self.START_PATTERN, offset, false, true);\n        if (!startInfo) {\n            return null;\n        }\n        narrowBarWidth = Math.floor((startInfo.end - startInfo.start) / 4);\n        leadingWhitespaceStart = startInfo.start - narrowBarWidth * 10;\n        if (leadingWhitespaceStart >= 0) {\n            if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                return startInfo;\n            }\n        }\n        offset = startInfo.end;\n        startInfo = null;\n    }\n};\n\nI2of5Reader.prototype._verifyTrailingWhitespace = function(endInfo) {\n    var self = this,\n        trailingWhitespaceEnd;\n\n    trailingWhitespaceEnd = endInfo.end + ((endInfo.end - endInfo.start) / 2);\n    if (trailingWhitespaceEnd < self._row.length) {\n        if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n            return endInfo;\n        }\n    }\n    return null;\n};\n\nI2of5Reader.prototype._findEnd = function() {\n    var self = this,\n        endInfo,\n        tmp;\n\n    self._row.reverse();\n    endInfo = self._findPattern(self.STOP_PATTERN);\n    self._row.reverse();\n\n    if (endInfo === null) {\n        return null;\n    }\n\n    // reverse numbers\n    tmp = endInfo.start;\n    endInfo.start = self._row.length - endInfo.end;\n    endInfo.end = self._row.length - tmp;\n\n    return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null;\n};\n\nI2of5Reader.prototype._decodePair = function(counterPair) {\n    var i,\n        code,\n        codes = [],\n        self = this;\n\n    for (i = 0; i < counterPair.length; i++) {\n        code = self._decodeCode(counterPair[i]);\n        if (!code) {\n            return null;\n        }\n        codes.push(code);\n    }\n    return codes;\n};\n\nI2of5Reader.prototype._decodeCode = function(counter) {\n    var j,\n        self = this,\n        sum = 0,\n        normalized,\n        error,\n        epsilon = self.AVG_CODE_ERROR,\n        code,\n        bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        };\n\n    for ( j = 0; j < counter.length; j++) {\n        sum += counter[j];\n    }\n    for (code = 0; code < self.CODE_PATTERN.length; code++) {\n        error = self._matchPattern(counter, self.CODE_PATTERN[code]);\n        if (error < bestMatch.error) {\n            bestMatch.code = code;\n            bestMatch.error = error;\n        }\n    }\n    if (bestMatch.error < epsilon) {\n        return bestMatch;\n    }\n};\n\nI2of5Reader.prototype._decodePayload = function(counters, result, decodedCodes) {\n    var i,\n        self = this,\n        pos = 0,\n        counterLength = counters.length,\n        counterPair = [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]],\n        codes;\n\n    while (pos < counterLength) {\n        for (i = 0; i < 5; i++) {\n            counterPair[0][i] = counters[pos] * this.barSpaceRatio[0];\n            counterPair[1][i] = counters[pos + 1] * this.barSpaceRatio[1];\n            pos += 2;\n        }\n        codes = self._decodePair(counterPair);\n        if (!codes) {\n            return null;\n        }\n        for (i = 0; i < codes.length; i++) {\n            result.push(codes[i].code + \"\");\n            decodedCodes.push(codes[i]);\n        }\n    }\n    return codes;\n};\n\nI2of5Reader.prototype._verifyCounterLength = function(counters) {\n    return (counters.length % 10 === 0);\n};\n\nI2of5Reader.prototype._decode = function() {\n    var startInfo,\n        endInfo,\n        self = this,\n        code,\n        result = [],\n        decodedCodes = [],\n        counters;\n\n    startInfo = self._findStart();\n    if (!startInfo) {\n        return null;\n    }\n    decodedCodes.push(startInfo);\n\n    endInfo = self._findEnd();\n    if (!endInfo) {\n        return null;\n    }\n\n    counters = self._fillCounters(startInfo.end, endInfo.start, false);\n    if (!self._verifyCounterLength(counters)) {\n        return null;\n    }\n    code = self._decodePayload(counters, result, decodedCodes);\n    if (!code) {\n        return null;\n    }\n    if (result.length % 2 !== 0 ||\n            result.length < 6) {\n        return null;\n    }\n\n    decodedCodes.push(endInfo);\n    return {\n        code: result.join(\"\"),\n        start: startInfo.start,\n        end: endInfo.end,\n        startInfo: startInfo,\n        decodedCodes: decodedCodes\n    };\n};\n\nI2of5Reader.CONFIG_KEYS = {\n    normalizeBarSpaceWidth: {\n        'type': 'boolean',\n        'default': false,\n        'description': 'If true, the reader tries to normalize the' +\n        'width-difference between bars and spaces'\n    }\n};\n\nexport default I2of5Reader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/i2of5_reader.js","import EANReader from './ean_reader';\n\nfunction UPCEReader(opts, supplements) {\n    EANReader.call(this, opts, supplements);\n}\n\nvar properties = {\n    CODE_FREQUENCY: {value: [\n        [ 56, 52, 50, 49, 44, 38, 35, 42, 41, 37 ],\n        [7, 11, 13, 14, 19, 25, 28, 21, 22, 26]]},\n    STOP_PATTERN: { value: [1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7]},\n    FORMAT: {value: \"upc_e\", writeable: false}\n};\n\nUPCEReader.prototype = Object.create(EANReader.prototype, properties);\nUPCEReader.prototype.constructor = UPCEReader;\n\nUPCEReader.prototype._decodePayload = function(code, result, decodedCodes) {\n    var i,\n        self = this,\n        codeFrequency = 0x0;\n\n    for ( i = 0; i < 6; i++) {\n        code = self._decodeCode(code.end);\n        if (!code) {\n            return null;\n        }\n        if (code.code >= self.CODE_G_START) {\n            code.code = code.code - self.CODE_G_START;\n            codeFrequency |= 1 << (5 - i);\n        }\n        result.push(code.code);\n        decodedCodes.push(code);\n    }\n    if (!self._determineParity(codeFrequency, result)) {\n        return null;\n    }\n\n    return code;\n};\n\nUPCEReader.prototype._determineParity = function(codeFrequency, result) {\n    var i,\n        nrSystem;\n\n    for (nrSystem = 0; nrSystem < this.CODE_FREQUENCY.length; nrSystem++){\n        for ( i = 0; i < this.CODE_FREQUENCY[nrSystem].length; i++) {\n            if (codeFrequency === this.CODE_FREQUENCY[nrSystem][i]) {\n                result.unshift(nrSystem);\n                result.push(i);\n                return true;\n            }\n        }\n    }\n    return false;\n};\n\nUPCEReader.prototype._convertToUPCA = function(result) {\n    var upca = [result[0]],\n        lastDigit = result[result.length - 2];\n\n    if (lastDigit <= 2) {\n        upca = upca.concat(result.slice(1, 3))\n            .concat([lastDigit, 0, 0, 0, 0])\n            .concat(result.slice(3, 6));\n    } else if (lastDigit === 3) {\n        upca = upca.concat(result.slice(1, 4))\n            .concat([0, 0, 0, 0, 0])\n            .concat(result.slice(4, 6));\n    } else if (lastDigit === 4) {\n        upca = upca.concat(result.slice(1, 5))\n            .concat([0, 0, 0, 0, 0, result[5]]);\n    } else {\n        upca = upca.concat(result.slice(1, 6))\n            .concat([0, 0, 0, 0, lastDigit]);\n    }\n\n    upca.push(result[result.length - 1]);\n    return upca;\n};\n\nUPCEReader.prototype._checksum = function(result) {\n    return EANReader.prototype._checksum.call(this, this._convertToUPCA(result));\n};\n\nUPCEReader.prototype._findEnd = function(offset, isWhite) {\n    isWhite = true;\n    return EANReader.prototype._findEnd.call(this, offset, isWhite);\n};\n\nUPCEReader.prototype._verifyTrailingWhitespace = function(endInfo) {\n    var self = this,\n        trailingWhitespaceEnd;\n\n    trailingWhitespaceEnd = endInfo.end + ((endInfo.end - endInfo.start) / 2);\n    if (trailingWhitespaceEnd < self._row.length) {\n        if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n            return endInfo;\n        }\n    }\n};\n\nexport default UPCEReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/upc_e_reader.js","import EANReader from './ean_reader';\n\nfunction UPCReader(opts, supplements) {\n    EANReader.call(this, opts, supplements);\n}\n\nvar properties = {\n    FORMAT: {value: \"upc_a\", writeable: false}\n};\n\nUPCReader.prototype = Object.create(EANReader.prototype, properties);\nUPCReader.prototype.constructor = UPCReader;\n\nUPCReader.prototype._decode = function() {\n    var result = EANReader.prototype._decode.call(this);\n\n    if (result && result.code && result.code.length === 13 && result.code.charAt(0) === \"0\") {\n        result.code = result.code.substring(1);\n        return result;\n    }\n    return null;\n};\n\nexport default UPCReader;\n\n\n\n// WEBPACK FOOTER //\n// ./src/reader/upc_reader.js","module.exports = copy\n\n/**\n * Copy the values from one mat2 to another\n *\n * @alias mat2.copy\n * @param {mat2} out the receiving matrix\n * @param {mat2} a the source matrix\n * @returns {mat2} out\n */\nfunction copy(out, a) {\n  out[0] = a[0]\n  out[1] = a[1]\n  out[2] = a[2]\n  out[3] = a[3]\n  return out\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-mat2/copy.js\n// module id = 78\n// module chunks = 0","module.exports = create\n\n/**\n * Creates a new identity mat2\n *\n * @alias mat2.create\n * @returns {mat2} a new 2x2 matrix\n */\nfunction create() {\n  var out = new Float32Array(4)\n  out[0] = 1\n  out[1] = 0\n  out[2] = 0\n  out[3] = 1\n  return out\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-mat2/create.js\n// module id = 79\n// module chunks = 0","module.exports = invert\n\n/**\n * Inverts a mat2\n *\n * @alias mat2.invert\n * @param {mat2} out the receiving matrix\n * @param {mat2} a the source matrix\n * @returns {mat2} out\n */\nfunction invert(out, a) {\n  var a0 = a[0]\n  var a1 = a[1]\n  var a2 = a[2]\n  var a3 = a[3]\n  var det = a0 * a3 - a2 * a1\n\n  if (!det) return null\n  det = 1.0 / det\n\n  out[0] =  a3 * det\n  out[1] = -a1 * det\n  out[2] = -a2 * det\n  out[3] =  a0 * det\n\n  return out\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-mat2/invert.js\n// module id = 80\n// module chunks = 0","module.exports = scale\n\n/**\n * Scales a vec2 by a scalar number\n *\n * @param {vec2} out the receiving vector\n * @param {vec2} a the vector to scale\n * @param {Number} b amount to scale the vector by\n * @returns {vec2} out\n */\nfunction scale(out, a, b) {\n    out[0] = a[0] * b\n    out[1] = a[1] * b\n    return out\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec2/scale.js\n// module id = 81\n// module chunks = 0","module.exports = transformMat2\n\n/**\n * Transforms the vec2 with a mat2\n *\n * @param {vec2} out the receiving vector\n * @param {vec2} a the vector to transform\n * @param {mat2} m matrix to transform with\n * @returns {vec2} out\n */\nfunction transformMat2(out, a, m) {\n    var x = a[0],\n        y = a[1]\n    out[0] = m[0] * x + m[2] * y\n    out[1] = m[1] * x + m[3] * y\n    return out\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec2/transformMat2.js\n// module id = 82\n// module chunks = 0","module.exports = clone;\n\n/**\n * Creates a new vec3 initialized with values from an existing vector\n *\n * @param {vec3} a vector to clone\n * @returns {vec3} a new 3D vector\n */\nfunction clone(a) {\n    var out = new Float32Array(3)\n    out[0] = a[0]\n    out[1] = a[1]\n    out[2] = a[2]\n    return out\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/gl-vec3/clone.js\n// module id = 83\n// module chunks = 0","var hashClear = require('./_hashClear'),\n    hashDelete = require('./_hashDelete'),\n    hashGet = require('./_hashGet'),\n    hashHas = require('./_hashHas'),\n    hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Hash.js\n// module id = 84\n// module chunks = 0","var ListCache = require('./_ListCache'),\n    stackClear = require('./_stackClear'),\n    stackDelete = require('./_stackDelete'),\n    stackGet = require('./_stackGet'),\n    stackHas = require('./_stackHas'),\n    stackSet = require('./_stackSet');\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nmodule.exports = Stack;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Stack.js\n// module id = 85\n// module chunks = 0","var root = require('./_root');\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nmodule.exports = Uint8Array;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Uint8Array.js\n// module id = 86\n// module chunks = 0","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\nmodule.exports = apply;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_apply.js\n// module id = 87\n// module chunks = 0","var baseTimes = require('./_baseTimes'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isIndex = require('./_isIndex'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayLikeKeys;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_arrayLikeKeys.js\n// module id = 88\n// module chunks = 0","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n  return result;\n}\n\nmodule.exports = arrayMap;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_arrayMap.js\n// module id = 89\n// module chunks = 0","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\nmodule.exports = arrayPush;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_arrayPush.js\n// module id = 90\n// module chunks = 0","var isObject = require('./isObject');\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nmodule.exports = baseCreate;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseCreate.js\n// module id = 91\n// module chunks = 0","var arrayPush = require('./_arrayPush'),\n    isFlattenable = require('./_isFlattenable');\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n  var index = -1,\n      length = array.length;\n\n  predicate || (predicate = isFlattenable);\n  result || (result = []);\n\n  while (++index < length) {\n    var value = array[index];\n    if (depth > 0 && predicate(value)) {\n      if (depth > 1) {\n        // Recursively flatten arrays (susceptible to call stack limits).\n        baseFlatten(value, depth - 1, predicate, isStrict, result);\n      } else {\n        arrayPush(result, value);\n      }\n    } else if (!isStrict) {\n      result[result.length] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseFlatten;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseFlatten.js\n// module id = 92\n// module chunks = 0","var createBaseFor = require('./_createBaseFor');\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nmodule.exports = baseFor;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseFor.js\n// module id = 93\n// module chunks = 0","var castPath = require('./_castPath'),\n    toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n  path = castPath(path, object);\n\n  var index = 0,\n      length = path.length;\n\n  while (object != null && index < length) {\n    object = object[toKey(path[index++])];\n  }\n  return (index && index == length) ? object : undefined;\n}\n\nmodule.exports = baseGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseGet.js\n// module id = 94\n// module chunks = 0","/**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHasIn(object, key) {\n  return object != null && key in Object(object);\n}\n\nmodule.exports = baseHasIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseHasIn.js\n// module id = 95\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseIsArguments.js\n// module id = 96\n// module chunks = 0","var isFunction = require('./isFunction'),\n    isMasked = require('./_isMasked'),\n    isObject = require('./isObject'),\n    toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseIsNative.js\n// module id = 97\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    isLength = require('./isLength'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseIsTypedArray.js\n// module id = 98\n// module chunks = 0","var isObject = require('./isObject'),\n    isPrototype = require('./_isPrototype'),\n    nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeysIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseKeysIn.js\n// module id = 99\n// module chunks = 0","var Stack = require('./_Stack'),\n    assignMergeValue = require('./_assignMergeValue'),\n    baseFor = require('./_baseFor'),\n    baseMergeDeep = require('./_baseMergeDeep'),\n    isObject = require('./isObject'),\n    keysIn = require('./keysIn');\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function(srcValue, key) {\n    if (isObject(srcValue)) {\n      stack || (stack = new Stack);\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(object[key], srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\nmodule.exports = baseMerge;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseMerge.js\n// module id = 100\n// module chunks = 0","var assignMergeValue = require('./_assignMergeValue'),\n    cloneBuffer = require('./_cloneBuffer'),\n    cloneTypedArray = require('./_cloneTypedArray'),\n    copyArray = require('./_copyArray'),\n    initCloneObject = require('./_initCloneObject'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isArrayLikeObject = require('./isArrayLikeObject'),\n    isBuffer = require('./isBuffer'),\n    isFunction = require('./isFunction'),\n    isObject = require('./isObject'),\n    isPlainObject = require('./isPlainObject'),\n    isTypedArray = require('./isTypedArray'),\n    toPlainObject = require('./toPlainObject');\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = object[key],\n      srcValue = source[key],\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      }\n      else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {\n        newValue = initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\nmodule.exports = baseMergeDeep;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseMergeDeep.js\n// module id = 101\n// module chunks = 0","var basePickBy = require('./_basePickBy'),\n    hasIn = require('./hasIn');\n\n/**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @returns {Object} Returns the new object.\n */\nfunction basePick(object, paths) {\n  return basePickBy(object, paths, function(value, path) {\n    return hasIn(object, path);\n  });\n}\n\nmodule.exports = basePick;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_basePick.js\n// module id = 102\n// module chunks = 0","var baseGet = require('./_baseGet'),\n    baseSet = require('./_baseSet'),\n    castPath = require('./_castPath');\n\n/**\n * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, paths, predicate) {\n  var index = -1,\n      length = paths.length,\n      result = {};\n\n  while (++index < length) {\n    var path = paths[index],\n        value = baseGet(object, path);\n\n    if (predicate(value, path)) {\n      baseSet(result, castPath(path, object), value);\n    }\n  }\n  return result;\n}\n\nmodule.exports = basePickBy;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_basePickBy.js\n// module id = 103\n// module chunks = 0","var identity = require('./identity'),\n    overRest = require('./_overRest'),\n    setToString = require('./_setToString');\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\nmodule.exports = baseRest;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseRest.js\n// module id = 104\n// module chunks = 0","var assignValue = require('./_assignValue'),\n    castPath = require('./_castPath'),\n    isIndex = require('./_isIndex'),\n    isObject = require('./isObject'),\n    toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\nfunction baseSet(object, path, value, customizer) {\n  if (!isObject(object)) {\n    return object;\n  }\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      lastIndex = length - 1,\n      nested = object;\n\n  while (nested != null && ++index < length) {\n    var key = toKey(path[index]),\n        newValue = value;\n\n    if (index != lastIndex) {\n      var objValue = nested[key];\n      newValue = customizer ? customizer(objValue, key, nested) : undefined;\n      if (newValue === undefined) {\n        newValue = isObject(objValue)\n          ? objValue\n          : (isIndex(path[index + 1]) ? [] : {});\n      }\n    }\n    assignValue(nested, key, newValue);\n    nested = nested[key];\n  }\n  return object;\n}\n\nmodule.exports = baseSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseSet.js\n// module id = 105\n// module chunks = 0","var constant = require('./constant'),\n    defineProperty = require('./_defineProperty'),\n    identity = require('./identity');\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\nmodule.exports = baseSetToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseSetToString.js\n// module id = 106\n// module chunks = 0","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nmodule.exports = baseTimes;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseTimes.js\n// module id = 107\n// module chunks = 0","var Symbol = require('./_Symbol'),\n    arrayMap = require('./_arrayMap'),\n    isArray = require('./isArray'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n  if (isArray(value)) {\n    // Recursively convert values (susceptible to call stack limits).\n    return arrayMap(value, baseToString) + '';\n  }\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = baseToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseToString.js\n// module id = 108\n// module chunks = 0","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nmodule.exports = baseUnary;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseUnary.js\n// module id = 109\n// module chunks = 0","var Uint8Array = require('./_Uint8Array');\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\nmodule.exports = cloneArrayBuffer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneArrayBuffer.js\n// module id = 110\n// module chunks = 0","var root = require('./_root');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneBuffer.js\n// module id = 111\n// module chunks = 0","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nmodule.exports = cloneTypedArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_cloneTypedArray.js\n// module id = 112\n// module chunks = 0","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nmodule.exports = copyArray;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_copyArray.js\n// module id = 113\n// module chunks = 0","var assignValue = require('./_assignValue'),\n    baseAssignValue = require('./_baseAssignValue');\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nmodule.exports = copyObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_copyObject.js\n// module id = 114\n// module chunks = 0","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_coreJsData.js\n// module id = 115\n// module chunks = 0","var baseRest = require('./_baseRest'),\n    isIterateeCall = require('./_isIterateeCall');\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\nmodule.exports = createAssigner;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_createAssigner.js\n// module id = 116\n// module chunks = 0","/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\nmodule.exports = createBaseFor;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_createBaseFor.js\n// module id = 117\n// module chunks = 0","var flatten = require('./flatten'),\n    overRest = require('./_overRest'),\n    setToString = require('./_setToString');\n\n/**\n * A specialized version of `baseRest` which flattens the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @returns {Function} Returns the new function.\n */\nfunction flatRest(func) {\n  return setToString(overRest(func, undefined, flatten), func + '');\n}\n\nmodule.exports = flatRest;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_flatRest.js\n// module id = 118\n// module chunks = 0","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getRawTag.js\n// module id = 119\n// module chunks = 0","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getValue.js\n// module id = 120\n// module chunks = 0","var castPath = require('./_castPath'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isIndex = require('./_isIndex'),\n    isLength = require('./isLength'),\n    toKey = require('./_toKey');\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      result = false;\n\n  while (++index < length) {\n    var key = toKey(path[index]);\n    if (!(result = object != null && hasFunc(object, key))) {\n      break;\n    }\n    object = object[key];\n  }\n  if (result || ++index != length) {\n    return result;\n  }\n  length = object == null ? 0 : object.length;\n  return !!length && isLength(length) && isIndex(key, length) &&\n    (isArray(object) || isArguments(object));\n}\n\nmodule.exports = hasPath;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hasPath.js\n// module id = 121\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nmodule.exports = hashClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashClear.js\n// module id = 122\n// module chunks = 0","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = hashDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashDelete.js\n// module id = 123\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashGet.js\n// module id = 124\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashHas.js\n// module id = 125\n// module chunks = 0","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nmodule.exports = hashSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_hashSet.js\n// module id = 126\n// module chunks = 0","var baseCreate = require('./_baseCreate'),\n    getPrototype = require('./_getPrototype'),\n    isPrototype = require('./_isPrototype');\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\nmodule.exports = initCloneObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_initCloneObject.js\n// module id = 127\n// module chunks = 0","var Symbol = require('./_Symbol'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray');\n\n/** Built-in value references. */\nvar spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n  return isArray(value) || isArguments(value) ||\n    !!(spreadableSymbol && value && value[spreadableSymbol]);\n}\n\nmodule.exports = isFlattenable;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isFlattenable.js\n// module id = 128\n// module chunks = 0","var eq = require('./eq'),\n    isArrayLike = require('./isArrayLike'),\n    isIndex = require('./_isIndex'),\n    isObject = require('./isObject');\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\nmodule.exports = isIterateeCall;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isIterateeCall.js\n// module id = 129\n// module chunks = 0","var isArray = require('./isArray'),\n    isSymbol = require('./isSymbol');\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n    reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n  if (isArray(value)) {\n    return false;\n  }\n  var type = typeof value;\n  if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n      value == null || isSymbol(value)) {\n    return true;\n  }\n  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n    (object != null && value in Object(object));\n}\n\nmodule.exports = isKey;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isKey.js\n// module id = 130\n// module chunks = 0","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nmodule.exports = isKeyable;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isKeyable.js\n// module id = 131\n// module chunks = 0","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_isMasked.js\n// module id = 132\n// module chunks = 0","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheClear.js\n// module id = 133\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nmodule.exports = listCacheDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheDelete.js\n// module id = 134\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheGet.js\n// module id = 135\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheHas.js\n// module id = 136\n// module chunks = 0","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nmodule.exports = listCacheSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_listCacheSet.js\n// module id = 137\n// module chunks = 0","var Hash = require('./_Hash'),\n    ListCache = require('./_ListCache'),\n    Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nmodule.exports = mapCacheClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheClear.js\n// module id = 138\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = mapCacheDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheDelete.js\n// module id = 139\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheGet.js\n// module id = 140\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheHas.js\n// module id = 141\n// module chunks = 0","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nmodule.exports = mapCacheSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_mapCacheSet.js\n// module id = 142\n// module chunks = 0","var memoize = require('./memoize');\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n  var result = memoize(func, function(key) {\n    if (cache.size === MAX_MEMOIZE_SIZE) {\n      cache.clear();\n    }\n    return key;\n  });\n\n  var cache = result.cache;\n  return result;\n}\n\nmodule.exports = memoizeCapped;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_memoizeCapped.js\n// module id = 143\n// module chunks = 0","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = nativeKeysIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_nativeKeysIn.js\n// module id = 144\n// module chunks = 0","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_nodeUtil.js\n// module id = 145\n// module chunks = 0","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_objectToString.js\n// module id = 146\n// module chunks = 0","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nmodule.exports = overArg;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_overArg.js\n// module id = 147\n// module chunks = 0","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\nmodule.exports = shortOut;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_shortOut.js\n// module id = 148\n// module chunks = 0","var ListCache = require('./_ListCache');\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\nmodule.exports = stackClear;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackClear.js\n// module id = 149\n// module chunks = 0","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nmodule.exports = stackDelete;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackDelete.js\n// module id = 150\n// module chunks = 0","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nmodule.exports = stackGet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackGet.js\n// module id = 151\n// module chunks = 0","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nmodule.exports = stackHas;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackHas.js\n// module id = 152\n// module chunks = 0","var ListCache = require('./_ListCache'),\n    Map = require('./_Map'),\n    MapCache = require('./_MapCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nmodule.exports = stackSet;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stackSet.js\n// module id = 153\n// module chunks = 0","var memoizeCapped = require('./_memoizeCapped');\n\n/** Used to match property names within property paths. */\nvar reLeadingDot = /^\\./,\n    rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n  var result = [];\n  if (reLeadingDot.test(string)) {\n    result.push('');\n  }\n  string.replace(rePropName, function(match, number, quote, string) {\n    result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));\n  });\n  return result;\n});\n\nmodule.exports = stringToPath;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_stringToPath.js\n// module id = 154\n// module chunks = 0","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_toSource.js\n// module id = 155\n// module chunks = 0","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\nmodule.exports = constant;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/constant.js\n// module id = 156\n// module chunks = 0","var baseFlatten = require('./_baseFlatten');\n\n/**\n * Flattens `array` a single level deep.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flatten([1, [2, [3, [4]], 5]]);\n * // => [1, 2, [3, [4]], 5]\n */\nfunction flatten(array) {\n  var length = array == null ? 0 : array.length;\n  return length ? baseFlatten(array, 1) : [];\n}\n\nmodule.exports = flatten;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/flatten.js\n// module id = 157\n// module chunks = 0","var baseHasIn = require('./_baseHasIn'),\n    hasPath = require('./_hasPath');\n\n/**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\nfunction hasIn(object, path) {\n  return object != null && hasPath(object, path, baseHasIn);\n}\n\nmodule.exports = hasIn;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/hasIn.js\n// module id = 158\n// module chunks = 0","var isArrayLike = require('./isArrayLike'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\nmodule.exports = isArrayLikeObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isArrayLikeObject.js\n// module id = 159\n// module chunks = 0","var baseGetTag = require('./_baseGetTag'),\n    getPrototype = require('./_getPrototype'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\nmodule.exports = isPlainObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isPlainObject.js\n// module id = 160\n// module chunks = 0","var MapCache = require('./_MapCache');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  var memoized = function() {\n    var args = arguments,\n        key = resolver ? resolver.apply(this, args) : args[0],\n        cache = memoized.cache;\n\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n    var result = func.apply(this, args);\n    memoized.cache = cache.set(key, result) || cache;\n    return result;\n  };\n  memoized.cache = new (memoize.Cache || MapCache);\n  return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nmodule.exports = memoize;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/memoize.js\n// module id = 161\n// module chunks = 0","var basePick = require('./_basePick'),\n    flatRest = require('./_flatRest');\n\n/**\n * Creates an object composed of the picked `object` properties.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pick(object, ['a', 'c']);\n * // => { 'a': 1, 'c': 3 }\n */\nvar pick = flatRest(function(object, paths) {\n  return object == null ? {} : basePick(object, paths);\n});\n\nmodule.exports = pick;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/pick.js\n// module id = 162\n// module chunks = 0","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = stubFalse;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/stubFalse.js\n// module id = 163\n// module chunks = 0","var copyObject = require('./_copyObject'),\n    keysIn = require('./keysIn');\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\nmodule.exports = toPlainObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/toPlainObject.js\n// module id = 164\n// module chunks = 0","var baseToString = require('./_baseToString');\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n\nmodule.exports = toString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/toString.js\n// module id = 165\n// module chunks = 0"],"sourceRoot":""}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://Quagga/webpack/myModuleDefinition","webpack://Quagga/webpack/bootstrap","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/classCallCheck.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/createClass.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/defineProperty.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/get.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/inherits.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/iterableToArray.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/superPropBase.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/typeof.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/regenerator/index.js","webpack://Quagga//Users/adomratchev/node_modules/regenerator-runtime/runtime-module.js","webpack://Quagga//Users/adomratchev/node_modules/regenerator-runtime/runtime.js","webpack://Quagga/(webpack)/buildin/global.js","webpack://Quagga/./src/analytics/result-collector.ts","webpack://Quagga/./src/common/cluster.ts","webpack://Quagga/./src/common/events.ts","webpack://Quagga/./src/common/hsv2rgb.ts","webpack://Quagga/./src/common/image-debug.ts","webpack://Quagga/./src/common/image-wrapper.ts","webpack://Quagga/./src/common/media-devices.ts","webpack://Quagga/./src/common/merge.ts","webpack://Quagga/./src/config/config.dev.ts","webpack://Quagga/./src/decoder/barcode-decoder.ts","webpack://Quagga/./src/decoder/bresenham.ts","webpack://Quagga/./src/input/camera-access.ts","webpack://Quagga/./src/input/exif-helper.ts","webpack://Quagga/./src/input/frame-grabber.ts","webpack://Quagga/./src/input/image-loader.ts","webpack://Quagga/./src/input/image-stream.ts","webpack://Quagga/./src/input/input-stream-utils.ts","webpack://Quagga/./src/input/input-stream.ts","webpack://Quagga/./src/input/live-stream.ts","webpack://Quagga/./src/input/video-stream.ts","webpack://Quagga/./src/locator/barcode-locator-utils.ts","webpack://Quagga/./src/locator/barcode-locator.ts","webpack://Quagga/./src/locator/rasterizer.ts","webpack://Quagga/./src/locator/skeletonizer.js","webpack://Quagga/./src/locator/tracer.ts","webpack://Quagga/./src/quagga.ts","webpack://Quagga/./src/reader/2of5-reader.ts","webpack://Quagga/./src/reader/barcode-reader.ts","webpack://Quagga/./src/reader/codabar-reader.ts","webpack://Quagga/./src/reader/code-128-reader.ts","webpack://Quagga/./src/reader/code-39-reader.ts","webpack://Quagga/./src/reader/code-39-vin-reader.ts","webpack://Quagga/./src/reader/code-93-reader.ts","webpack://Quagga/./src/reader/ean-2-reader.ts","webpack://Quagga/./src/reader/ean-5-reader.ts","webpack://Quagga/./src/reader/ean-8-reader.ts","webpack://Quagga/./src/reader/ean-reader.ts","webpack://Quagga/./src/reader/i2of5-reader.ts","webpack://Quagga/./src/reader/index.ts","webpack://Quagga/./src/reader/upc-e-reader.ts","webpack://Quagga/./src/reader/upc-reader.ts"],"names":["ResultCollector","config","_results","Array","_config","_capacity","capacity","_capture","capture","_canvas","document","createElement","_context","getContext","data","imageWidth","imageHeight","codeResult","_contains","_passesFilter","result","width","height","ImageDebug","drawImage","frame","toDataURL","push","blacklist","some","item","Object","keys","every","key","filter","Cluster","moments","threshold","clusters","forEach","moment","matchingCluster","find","cluster","fits","add","_threshold","_moments","_center","rad","x","y","point","reduce","sum","p","length","Math","cos","sin","similarity","abs","events","Events","event","callback","async","subscription","getEvent","subscriptions","type","eventItem","once","publishSubscription","subscribe","eventName","setTimeout","hsv2rgb","hsv","rgb","h","s","v","c","m","r","g","b","drawPath","path","context","color","lineWidth","strokeStyle","fillStyle","beginPath","moveTo","slice","lineTo","closePath","stroke","imageData","canvasData","getImageData","imageIndex","canvasIndex","value","putImageData","ImageWrapper","size","arrayType","initialize","Uint8Array","fill","border","imageWrapper","fromX","fromY","sizeY","sizeX","i","labelCount","labelSum","m00","m01","m10","m11","m02","m20","theta","ysq","val","label","PI","PI_4","isNaN","x_","y_","mu11","mu02","mu20","tmp","atan","scale","current","pixel","get","whiteRgb","blackRgb","enumerateDevices","navigator","mediaDevices","Promise","reject","Error","getUserMedia","constraints","merge","isObject","obj","objects","prev","pVal","oVal","isArray","inputStream","name","facingMode","area","top","right","left","bottom","singleChannel","locate","numOfWorkers","decoder","readers","debug","drawBoundingBox","showFrequency","drawScanline","showPattern","locator","halfSample","patchSize","showCanvas","showPatches","showFoundPatches","showSkeleton","showLabels","showPatchLabels","showRemainingPatchLabels","boxFromPatches","showTransformed","showTransformedBox","showBB","BarcodeDecoder","inputImageWrapper","_inputImageWrapper","_barcodeReaders","process","debugDiv","querySelector","_frequencyCanvas","className","appendChild","style","display","_patternCanvas","overlayCanvas","_overlayContext","_initReaders","boxes","barcode","multiple","barcodes","map","box","decodeFromBoundingBox","_drawPath","line","_getLine","angle","atan2","_getExtendedLine","_tryDecode","_tryDecodeBruteForce","pattern","barcodeLine","readerConfig","reader","configuration","supplements","format","console","log","supplement","Readers","FORMAT","JSON","stringify","extendLine","amount","extension","lineLength","sqrt","extensionLength","inImageWithBorder","Bresenham","getBarcodeLine","_printFrequency","toBinaryLine","_printPattern","decodePattern","lineAngle","sideLength","slices","xdir","ydir","dir","fillRect","Slope","p1","p2","x0","y0","x1","y1","steep","min","max","read","a","deltax","deltay","error","ystep","center","extrema","rThreshold","currentDir","Up","Down","pos","slope","slope2","j","_stream","CameraAccess","request","video","videoConstraints","normalizedConstraints","pickConstraints","srcObject","setAttribute","resolve","addEventListener","play","then","_waitForVideo","bind","release","tracks","getVideoTracks","stop","enumerateVideoDevices","devices","kind","getActiveStreamLabel","track","getActiveTrack","aspectRatio","deviceId","minAspectRatio","facing","audio","videoWidth","videoHeight","attempts","checkVideo","window","ExifTags","AvailableTags","findTagsInObjectURL","src","tags","test","objectURLToBlob","buffer","findTagsInBuffer","file","selectedTags","dataView","DataView","byteLength","exifTags","selectedTag","exifTag","tag","offset","getUint8","marker","readEXIFData","getUint16","url","fetch","response","ok","arrayBuffer","status","start","split","char","index","charCodeAt","tiffOffset","bigEnd","firstIFDOffset","getUint32","readTags","dirStart","strings","entries","entryOffset","readTagValue","numValues","undefined","QUATER_CIRCLE","FrameGrabber","canvas","_inputStream","_streamConfig","_canvasWidth","canvasWidth","_canvasHeight","canvasHeight","_width","_height","_topLeft","topLeft","_data","videoSize","realWidth","realHeight","canvasSize","getFrame","_adjustCanvasSize","drawable","drawAngle","HTMLVideoElement","image","orientation","halfWidth","halfHeight","translate","rotate","_grayAndHalfSampleFromCanvasData","_computeGray","warn","endIndex","outWidth","topRowIndex","bottomRowIndex","outImageIndex","top4","bottom4","imageDataLength","ImageLoader","baseUri","sequence","loaded","loadedImage","notLoadedImages","splice","imageSrcs","imageName","substr","lastIndexOf","loadedImages","firstImage","Image","onload","ImageStream","_baseUrl","_ended","_frameIndex","_images","_loaded","_offset","_paused","_size","trigger","load","images","_calculatedWidth","_calculatedHeight","_loadImages","time","InputStream","_computeDivisors","n","divisors","largeDivisors","divisor","unshift","concat","_computeCommonDivisors","largeDivisor","calculatePatchSize","wideSide","nrOfPatchesList","nrOfPatchesMap","small","medium","large","nrOfPatchesIndex","nrOfPatches","desiredPatchSize","findPatchSizeForDivisors","found","optimalPatchSize","checkImageConstraints","shift","inputStreamConfig","computeImageArea","setCanvasSize","_parseCssDimensionValues","dimension","parseFloat","unit","indexOf","_dimensionsConverters","inputWidth","inputHeight","parsedArea","parsed","calculated","_eventNames","_eventHandlers","Map","listener","_options","has","set","clear","argArray","handlers","handler","apply","LiveStream","VideoStream","_video","pause","options","_initSize","ended","currentTime","invert","matrix","a0","a1","a2","a3","determinant","Float32Array","transformWithMatrix","_computeHistogram","bitsPerPixel","bitShift","bucketCount","histogram","Int32Array","_determineOtsuThreshold","hist","vet","px","init","end","mx","k","p12","m1","m2","m12","maxIndex","array","otsuThreshold","targetWrapper","targetData","outImageWrapper","outImage","outImgIndex","MomentSimilarityThreshold","BarcodeLocator","_numPatches","_initBuffers","_initCanvas","_currentImageWrapper","_binarizeImage","patchesFound","_findPatches","maxLabel","_rasterizeAngularSimilarity","topLabels","_findBiggestConnectedAreas","_findBoxes","_patchSize","_binaryImageWrapper","_labelImageWrapper","skeletonImageData","ArrayBuffer","_subImageWrapper","_skelImageWrapper","_skeletonizer","skeletonizer","self","global","_patchLabelGrid","_patchGrid","_imageToPatchGrid","useWorker","_binaryContext","patches","averageRad","_drawRect","inverseMatrix","minX","minY","maxX","maxY","vertex","zeroBorder","show","_skeletonize","rasterizer","Rasterizer","rasterResult","rasterize","overlay","count","patch","_describePatch","labelHist","sort","_boxFromPatches","join","clusterize","topCluster","subImageAsCopy","skeletonize","minComponentWeight","ceil","eligibleMoments","matchingMoments","_similarMoments","currentIndex","currentPatch","SearchDirections","direction","Number","MAX_VALUE","_trace","_notYetProcessed","strokeRect","EdgeLabel","ContourDirection","labelWrapper","_imageData","_labelData","_tracer","Tracer","depthLabel","colorMap","cc","sc","connectedCount","cy","labelIndex","bc","cx","lc","contourTracing","Outside","CW","firstVertex","nextPeer","insideContours","previousPeer","Inside","CCW","firstContour","pq","iq","q","Unknown","next","Skeletonizer","stdlib","foreign","imul","erode","inImagePtr","outImagePtr","u","yStart1","yStart2","xStart1","xStart2","subtract","aImagePtr","bImagePtr","bitwiseOr","countNonZero","imagePtr","dilate","memcpy","srcImagePtr","dstImagePtr","subImagePtr","erodedImagePtr","tempImagePtr","skelImagePtr","done","edgeLabel","sy","sx","Fv","trace","Cv","ldir","P","_frameGrabber","_stopped","_canvasContainer","ctx","dom","_locator","_boxSize","_decoder","_workerPool","_onUIThread","_resultCollector","cb","defaultConfig","_initializeData","_initInputStream","_startContinuousUpdate","_update","_adjustWorkerPool","clearEventHandlers","decodeSingle","resultCallback","call","onDetected","offDetected","unsubscribe","onProcessed","offProcessed","setReaders","worker","postMessage","cmd","registerResultCollector","resultCollector","addResult","viewport","_getViewPort","err","_canRecord","target","HTMLElement","selector","clearFix","_transform","polygon","_transformResult","_addResult","_hasCodeResult","_publishResult","resultToPublish","publish","_locateAndDecode","decodeFromBoundingBoxes","availableWorker","busy","grab","delay","frequency","timestamp","requestAnimationFrame","performance","now","_initWorker","blobURL","_generateWorkerBlob","workerThread","Worker","onmessage","URL","revokeObjectURL","message","_workerInterface","factory","Quagga","factorySource","__factorySource__","blob","Blob","toString","createObjectURL","increaseBy","terminate","N","W","START_PATTERN","STOP_PATTERN","CODE_PATTERN","startPatternLength","TwoOfFiveReader","_barSpaceRatio","_format","_singleCodeError","_averageCodeError","startInfo","_findStart","endInfo","_findEnd","counters","_fillCounters","decodedCodes","code","_decodePayload","_nextSet","_row","narrowBarWidth","_findPattern","leadingWhitespaceStart","_matchRange","trailingWhitespaceEnd","reverse","_verifyTrailingWhitespace","counter","bestMatch","_matchPattern","AVERAGE_CODE_ERROR","counterLength","_decodeCode","BarcodeReader","BarcodeDirection","StartNotFoundException","CodeNotFoundException","PatternNotFoundException","isWhite","tryHarder","epsilon","counterPos","maxSingleError","modulo","SINGLE_CODE_ERROR","barWidth","scaled","singleError","correction","indices","decode","Reverse","Forward","numCounters","ALPHABETH_STRING","ALPHABET","CHARACTER_ENCODINGS","START_END","MIN_ENCODED_CHARS","MAX_ACCEPTABLE","PADDING","CodabarReader","_counters","_nextUnset","nextStart","startCounter","_toPattern","decodedChar","_patternToChar","_verifyWhitespace","_validateResult","_sumCounters","endCounter","_calculatePatternLength","categorization","space","narrow","counts","wide","bar","_charToPattern","cat","floor","charCode","_thresholdResultPattern","String","fromCharCode","barThreshold","_computeAlternatingThreshold","spaceThreshold","bitmask","CODE_SHIFT","CODE_C","CODE_B","CODE_A","START_CODE_A","START_CODE_B","START_CODE_C","STOP_CODE","MODULE_INDICES","Code128Reader","_correct","expected","_calculateCorrection","_correctBars","multiplier","checksum","codeset","rawResult","shiftNext","removeLastCharacter","normalized","sumNormalized","sumExpected","ASTERISK","Uint16Array","Code39Reader","lastStart","_toCounters","pop","patternSize","minWidth","maxNarrowWidth","numWideBars","wideBarWidth","_findNextWidth","patternStart","whiteSpaceMustStart","Code39VINReader","replace","_checkChecksum","Code93Reader","_verifyEnd","_verifyChecksums","_decodeExtended","round","charArray","nextChar","nextCharCode","_matchCheckChar","maxWeight","arrayToCheck","weightedSums","weight","checkChar","EAN2Reader","row","codeFrequency","CODE_G_START","parseInt","EANReader","EAN5Reader","_extensionChecksum","_determineCheckDigit","CHECK_DIGIT_ENCODINGS","EAN8Reader","MIDDLE_PATTERN","EXTENSION_START_PATTERN","CODE_FREQUENCY","coderange","firstDigit","_calculateFirstDigit","resultInfo","_checksum","_decodeExtensions","lastCode","MAX_CORRECTION_FACTOR","I2of5Reader","normalizeBarSpaceWidth","counterSum","codeSum","correctionRatio","correctionRatioInverse","counter0","counter1","code0","code1","code_128_reader","ean_reader","ean_5_reader","ean_2_reader","ean_8_reader","code_39_reader","code_39_vin_reader","codabar_reader","upc_reader","UPCReader","upc_e_reader","UPCEReader","i2of5_reader","code_93_reader","_determineParity","nrSystem","lastDigit","upca","_convertToUPCA","charAt","substring"],"mappings":";;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;AACA,CAAC;AACD,W;ACVA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kDAA0C,gCAAgC;AAC1E;AACA;;AAEA;AACA;AACA;AACA,gEAAwD,kBAAkB;AAC1E;AACA,yDAAiD,cAAc;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAyC,iCAAiC;AAC1E,wHAAgH,mBAAmB,EAAE;AACrI;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;;AAGA;AACA;;;;;;;;;;;;AClFA;AACA;AACA,iDAAiD,gBAAgB;AACjE;AACA;;AAEA;AACA;AACA;;AAEA,oC;;;;;;;;;;;ACVA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,wC;;;;;;;;;;;ACRA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,KAAK;AACL;AACA;;AAEA,mC;;;;;;;;;;;ACpCA;AACA;AACA;AACA;AACA;;AAEA,iC;;;;;;;;;;;ACNA;AACA,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,8B;;;;;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;;;;;ACfA,qBAAqB,mBAAO,CAAC,qFAAkB;;AAE/C,oBAAoB,mBAAO,CAAC,mFAAiB;;AAE7C;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA,sB;;;;;;;;;;;ACxBA;AACA;AACA;AACA;AACA;AACA;;AAEA,iC;;;;;;;;;;;ACPA,qBAAqB,mBAAO,CAAC,qFAAkB;;AAE/C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA,2B;;;;;;;;;;;ACjBA;AACA;AACA;;AAEA,kC;;;;;;;;;;;ACJA;AACA;AACA;;AAEA,oC;;;;;;;;;;;ACJA,cAAc,mBAAO,CAAC,8EAAmB;;AAEzC,4BAA4B,mBAAO,CAAC,mGAAyB;;AAE7D;AACA;AACA;AACA;;AAEA;AACA;;AAEA,4C;;;;;;;;;;;ACZA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,iC;;;;;;;;;;;ACTA,qBAAqB,mBAAO,CAAC,qFAAkB;;AAE/C;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,gC;;;;;;;;;;;ACXA,wBAAwB,mBAAO,CAAC,2FAAqB;;AAErD,sBAAsB,mBAAO,CAAC,uFAAmB;;AAEjD,wBAAwB,mBAAO,CAAC,2FAAqB;;AAErD;AACA;AACA;;AAEA,oC;;;;;;;;;;;ACVA,wBAAwB,2EAA2E,oCAAoC,mBAAmB,GAAG,EAAE,OAAO,oCAAoC,8HAA8H,GAAG,EAAE,sBAAsB;;AAEnW;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA,yB;;;;;;;;;;;AChBA,iBAAiB,mBAAO,CAAC,qFAAqB;;;;;;;;;;;;ACA9C;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,iBAAiB,mBAAO,CAAC,oEAAW;;AAEpC;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;;;;;;;;;;;ACpCA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,KAAK;AACL,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA,WAAW;AACX;;AAEA;AACA;AACA,wCAAwC,WAAW;AACnD;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA,SAAS;AACT;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oCAAoC,cAAc;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,iCAAiC,kBAAkB;AACnD;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,iBAAiB;;AAEjB;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,wBAAwB,iBAAiB;AACzC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,YAAY;AACZ;AACA;;AAEA;AACA,YAAY;AACZ;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,8CAA8C,QAAQ;AACtD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA;;AAEA,WAAW;AACX;AACA;AACA;;AAEA,WAAW;AACX;AACA;AACA;;AAEA,WAAW;AACX;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA,KAAK;;AAEL;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;;;;;;;;;;;AChtBA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;ACnBA;AAWO,IAAMA,eAAb;AAAA;AAAA;AAQI,2BAAYC,MAAZ,EAA2C;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AACvC,SAAKC,QAAL,GAAgB,IAAIC,KAAJ,EAAhB;AACA,SAAKC,OAAL,GAAeH,MAAf;AACA,SAAKI,SAAL,GAAiBJ,MAAM,CAACK,QAAP,IAAmB,EAApC;AACA,SAAKC,QAAL,GAAgBN,MAAM,CAACO,OAAP,KAAmB,IAAnC;;AAEA,QAAI,KAAKD,QAAT,EAAmB;AACf,WAAKE,OAAL,GAAeC,QAAQ,CAACC,aAAT,CAAuB,QAAvB,CAAf;AACA,WAAKC,QAAL,GAAgB,KAAKH,OAAL,CAAaI,UAAb,CAAwB,IAAxB,CAAhB;AACH;AACJ;;AAlBL;AAAA;AAAA,8BAoBcC,IApBd,EAoBgCC,UApBhC,EAoBoDC,WApBpD,EAoByEC,UApBzE,EAoBoG;AAC5F,UAAIA,UAAU,IAAI,KAAKZ,SAAnB,IAAgC,CAAC,KAAKa,SAAL,CAAeD,UAAf,CAAjC,IAA+D,KAAKE,aAAL,CAAmBF,UAAnB,CAAnE,EAAmG;AAC/F,YAAMG,MAAqB,GAAG;AAAEH,oBAAU,EAAVA;AAAF,SAA9B;AAEA,aAAKZ,SAAL;;AAEA,YAAI,KAAKE,QAAT,EAAmB;AACf,eAAKE,OAAL,CAAaY,KAAb,GAAqBN,UAArB;AACA,eAAKN,OAAL,CAAaa,MAAb,GAAsBN,WAAtB;AAEAO,wEAAU,CAACC,SAAX,CAAqBV,IAArB,EAA2BC,UAA3B,EAAuCC,WAAvC,EAAoD,KAAKJ,QAAzD;AAEAQ,gBAAM,CAACK,KAAP,GAAe,KAAKhB,OAAL,CAAaiB,SAAb,EAAf;AACH;;AAED,aAAKxB,QAAL,CAAcyB,IAAd,CAAmBP,MAAnB;AACH;AACJ;AArCL;AAAA;AAAA,iCAuCuC;AAC/B,aAAO,KAAKlB,QAAZ;AACH;AAzCL;AAAA;AAAA,8BA2CsBe,UA3CtB,EA2CoD;AAC5C,aAAO,KAAKb,OAAL,CAAawB,SAAb,IACH,KAAKxB,OAAL,CAAawB,SAAb,CAAuBC,IAAvB,CAA4B,UAAAC,IAAI;AAAA,eAAIC,MAAM,CAACC,IAAP,CAAYF,IAAZ,EAAkBG,KAAlB,CAAwB,UAAAC,GAAG;AAAA,iBAAIJ,IAAI,CAACI,GAAD,CAAJ,KAAcjB,UAAU,CAACiB,GAAD,CAA5B;AAAA,SAA3B,CAAJ;AAAA,OAAhC,CADJ;AAEH;AA9CL;AAAA;AAAA,kCAgD0BjB,UAhD1B,EAgDwD;AAChD,aAAO,OAAO,KAAKb,OAAL,CAAa+B,MAApB,KAA+B,UAA/B,IAA6C,KAAK/B,OAAL,CAAa+B,MAAb,CAAoBlB,UAApB,CAApD;AACH;AAlDL;;AAAA;AAAA,I;;;;;;;;;;;;;;;;;;;;;;;;ACRA;;;AAGO,IAAMmB,OAAb;AAAA;AAAA;AAAA;AAAA;AAAA,+BAKsBC,OALtB,EAK8CC,SAL9C,EAKiF;AACzE,UAAMC,QAAQ,GAAG,IAAIpC,KAAJ,EAAjB;AAEAkC,aAAO,CAACG,OAAR,CAAgB,UAAAC,MAAM,EAAI;AACtB,YAAMC,eAAe,GAAGH,QAAQ,CAACI,IAAT,CAAc,UAAAC,OAAO;AAAA,iBAAIA,OAAO,CAACC,IAAR,CAAaJ,MAAb,CAAJ;AAAA,SAArB,CAAxB;;AAEA,YAAIC,eAAJ,EAAqB;AACjBA,yBAAe,CAACI,GAAhB,CAAoBL,MAApB;AACH,SAFD,MAEO;AACHF,kBAAQ,CAACZ,IAAT,CAAc,IAAIS,OAAJ,CAAYE,SAAZ,EAAuBG,MAAvB,CAAd;AACH;AACJ,OARD;AAUA,aAAOF,QAAP;AACH;AAnBL;;AAqBI,mBAAYD,SAAZ,EAA+BG,MAA/B,EAA+C;AAAA;;AAAA;;AAAA;;AAAA;;AAC3C,SAAKM,UAAL,GAAkBT,SAAlB;AACA,SAAKU,QAAL,GAAgB,IAAI7C,KAAJ,EAAhB;AACA,SAAK8C,OAAL,GAAe;AACXC,SAAG,EAAE,CADM;AAEXC,OAAC,EAAE,CAFQ;AAGXC,OAAC,EAAE;AAHQ,KAAf;;AAMA,QAAIX,MAAJ,EAAY;AACR,WAAKK,GAAL,CAASL,MAAT;AACH;AACJ;;AAjCL;AAAA;AAAA,wBAmCQY,KAnCR,EAmCuB;AACf,WAAKL,QAAL,CAAcrB,IAAd,CAAmB0B,KAAnB,EADe,CAGf;;;AACA,WAAKJ,OAAL,CAAaC,GAAb,GAAmB,KAAKF,QAAL,CAAcM,MAAd,CAAqB,UAACC,GAAD,EAAMC,CAAN;AAAA,eAAYD,GAAG,GAAGC,CAAC,CAACN,GAApB;AAAA,OAArB,EAA8C,CAA9C,IAAmD,KAAKF,QAAL,CAAcS,MAApF;AACA,WAAKR,OAAL,CAAaE,CAAb,GAAiBO,IAAI,CAACC,GAAL,CAAS,KAAKV,OAAL,CAAaC,GAAtB,CAAjB;AACA,WAAKD,OAAL,CAAaG,CAAb,GAAiBM,IAAI,CAACE,GAAL,CAAS,KAAKX,OAAL,CAAaC,GAAtB,CAAjB;AACH;AA1CL;AAAA;AAAA,yBA4CST,MA5CT,EA4CkC;AAC1B;AACA,UAAMoB,UAAU,GAAGH,IAAI,CAACI,GAAL,CAASrB,MAAM,CAACU,CAAP,GAAW,KAAKF,OAAL,CAAaE,CAAxB,GAA4BV,MAAM,CAACW,CAAP,GAAW,KAAKH,OAAL,CAAaG,CAA7D,CAAnB;AACA,aAAOS,UAAU,GAAG,KAAKd,UAAzB;AACH;AAhDL;AAAA;AAAA,wBAkDkB;AACV,aAAO,KAAKC,QAAZ;AACH;AApDL;;AAAA;AAAA,I;;;;;;;;;;;;;;;;;;;;ACQA,IAAIe,MAAqC,GAAG,EAA5C;AAEO,IAAMC,MAAb;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,8BACqBC,KADrB,EACoCC,QADpC,EACiFC,KADjF,EACkG;AAC1F,UAAIC,YAAJ;;AAEA,UAAI,OAAOF,QAAP,KAAoB,UAAxB,EAAoC;AAChCE,oBAAY,GAAG;AACXF,kBAAQ,EAARA,QADW;AAEXC,eAAK,EAALA;AAFW,SAAf;AAIH,OALD,MAKO;AACHC,oBAAY,GAAGF,QAAf;;AACA,YAAI,CAACE,YAAY,CAACF,QAAlB,EAA4B;AACxB,gBAAM,uCAAN;AACH;AACJ;;AAEDG,cAAQ,CAACJ,KAAD,CAAR,CAAgBK,aAAhB,CAA8B3C,IAA9B,CAAmCyC,YAAnC;AACH;AAjBL;AAAA;AAAA,4BAmBmBG,IAnBnB,EAmBiCzD,IAnBjC,EAmB6C;AACrC,UAAM0D,SAAS,GAAGH,QAAQ,CAACE,IAAD,CAA1B;AACA,UAAMD,aAAa,GAAGE,SAAS,CAACF,aAAhC,CAFqC,CAIrC;;AACAA,mBAAa,CAACnC,MAAd,CAAqB;AAAA,YAAGsC,IAAH,QAAGA,IAAH;AAAA,eAAc,CAAC,CAACA,IAAhB;AAAA,OAArB,EAA2CjC,OAA3C,CAAmD,UAAA4B,YAAY;AAAA,eAAIM,mBAAmB,CAACN,YAAD,EAAetD,IAAf,CAAvB;AAAA,OAA/D,EALqC,CAOrC;;AACA0D,eAAS,CAACF,aAAV,GAA0BA,aAAa,CAACnC,MAAd,CAAqB;AAAA,YAAGsC,IAAH,SAAGA,IAAH;AAAA,eAAc,CAACA,IAAf;AAAA,OAArB,CAA1B,CARqC,CAUrC;;AACAD,eAAS,CAACF,aAAV,CAAwB9B,OAAxB,CAAgC,UAAA4B,YAAY;AAAA,eAAIM,mBAAmB,CAACN,YAAD,EAAetD,IAAf,CAAvB;AAAA,OAA5C;AACH;AA/BL;AAAA;AAAA,yBAiCgBmD,KAjChB,EAiC+BC,QAjC/B,EAiCwDC,KAjCxD,EAiC+E;AACvEH,YAAM,CAACW,SAAP,CAAiBV,KAAjB,EAAwB;AAAEC,gBAAQ,EAARA,QAAF;AAAYC,aAAK,EAALA,KAAZ;AAAmBM,YAAI,EAAE;AAAzB,OAAxB;AACH;AAnCL;AAAA;AAAA,gCAqCuBG,SArCvB,EAqC2CV,QArC3C,EAqCqE;AAC7D,UAAIU,SAAJ,EAAe;AACX,YAAMX,KAAK,GAAGI,QAAQ,CAACO,SAAD,CAAtB;;AACA,YAAIX,KAAK,IAAIC,QAAb,EAAuB;AACnBD,eAAK,CAACK,aAAN,GAAsBL,KAAK,CAACK,aAAN,CAAoBnC,MAApB,CAA2B,UAAAiC,YAAY;AAAA,mBAAIA,YAAY,CAACF,QAAb,KAA0BA,QAA9B;AAAA,WAAvC,CAAtB;AACH,SAFD,MAEO;AACHD,eAAK,CAACK,aAAN,GAAsB,EAAtB;AACH;AACJ,OAPD,MAOO;AACHP,cAAM,GAAG,EAAT;AACH;AACJ;AAhDL;;AAAA;AAAA;;AAmDA,SAASM,QAAT,CAAkBO,SAAlB,EAAgD;AAC5C,MAAI,CAACb,MAAM,CAACa,SAAD,CAAX,EAAwB;AACpBb,UAAM,CAACa,SAAD,CAAN,GAAoB;AAChBN,mBAAa,EAAE;AADC,KAApB;AAGH;;AACD,SAAOP,MAAM,CAACa,SAAD,CAAb;AACH;;AAED,SAASF,mBAAT,CAA6BN,YAA7B,EAA8DtD,IAA9D,EAA+E;AAC3E,MAAIsD,YAAY,CAACD,KAAjB,EAAwB;AACpBU,cAAU,CAAC,YAAY;AACnBT,kBAAY,CAACF,QAAb,CAAsBpD,IAAtB;AACH,KAFS,EAEP,CAFO,CAAV;AAGH,GAJD,MAIO;AACHsD,gBAAY,CAACF,QAAb,CAAsBpD,IAAtB;AACH;AACJ,C;;;;;;;;;;;;AChFD;AAAA;AAAO,SAASgE,OAAT,CAAiBC,GAAjB,EAA2BC,GAA3B,EAA2C;AAC9C,MAAMC,CAAC,GAAGF,GAAG,CAAC,CAAD,CAAb;AACA,MAAMG,CAAC,GAAGH,GAAG,CAAC,CAAD,CAAb;AACA,MAAMI,CAAC,GAAGJ,GAAG,CAAC,CAAD,CAAb;AACA,MAAMK,CAAC,GAAGD,CAAC,GAAGD,CAAd;AACA,MAAM/B,CAAC,GAAGiC,CAAC,IAAI,IAAI1B,IAAI,CAACI,GAAL,CAAUmB,CAAC,GAAG,EAAL,GAAW,CAAX,GAAe,CAAxB,CAAR,CAAX;AACA,MAAMI,CAAC,GAAGF,CAAC,GAAGC,CAAd;AACA,MAAIE,CAAC,GAAG,CAAR;AACA,MAAIC,CAAC,GAAG,CAAR;AACA,MAAIC,CAAC,GAAG,CAAR;;AAEA,MAAIP,CAAC,GAAG,EAAR,EAAY;AACRK,KAAC,GAAGF,CAAJ;AACAG,KAAC,GAAGpC,CAAJ;AACH,GAHD,MAGO,IAAI8B,CAAC,GAAG,GAAR,EAAa;AAChBK,KAAC,GAAGnC,CAAJ;AACAoC,KAAC,GAAGH,CAAJ;AACH,GAHM,MAGA,IAAIH,CAAC,GAAG,GAAR,EAAa;AAChBM,KAAC,GAAGH,CAAJ;AACAI,KAAC,GAAGrC,CAAJ;AACH,GAHM,MAGA,IAAI8B,CAAC,GAAG,GAAR,EAAa;AAChBM,KAAC,GAAGpC,CAAJ;AACAqC,KAAC,GAAGJ,CAAJ;AACH,GAHM,MAGA,IAAIH,CAAC,GAAG,GAAR,EAAa;AAChBK,KAAC,GAAGnC,CAAJ;AACAqC,KAAC,GAAGJ,CAAJ;AACH,GAHM,MAGA,IAAIH,CAAC,GAAG,GAAR,EAAa;AAChBK,KAAC,GAAGF,CAAJ;AACAI,KAAC,GAAGrC,CAAJ;AACH;;AAED6B,KAAG,GAAGA,GAAG,IAAI,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAb;AAEAA,KAAG,CAAC,CAAD,CAAH,GAAS,CAACM,CAAC,GAAGD,CAAL,IAAU,GAAV,GAAgB,CAAzB;AACAL,KAAG,CAAC,CAAD,CAAH,GAAS,CAACO,CAAC,GAAGF,CAAL,IAAU,GAAV,GAAgB,CAAzB;AACAL,KAAG,CAAC,CAAD,CAAH,GAAS,CAACQ,CAAC,GAAGH,CAAL,IAAU,GAAV,GAAgB,CAAzB;AAEA,SAAOL,GAAP;AACH,C;;;;;;;;;;;;ACxCD;AAAA;AAAO,IAAMzD,UAAU,GAAG;AACtBkE,UADsB,oBACbC,IADa,EACOC,OADP,EAC0CC,KAD1C,EACyDC,SADzD,EACkF;AACpG,QAAIH,IAAI,IAAIA,IAAI,CAACjC,MAAL,GAAc,CAA1B,EAA6B;AACzBkC,aAAO,CAACG,WAAR,GAAsBF,KAAtB;AACAD,aAAO,CAACI,SAAR,GAAoBH,KAApB;AACAD,aAAO,CAACE,SAAR,GAAoBA,SAApB;AACAF,aAAO,CAACK,SAAR;AACAL,aAAO,CAACM,MAAR,CAAeP,IAAI,CAAC,CAAD,CAAJ,CAAQvC,CAAvB,EAA0BuC,IAAI,CAAC,CAAD,CAAJ,CAAQtC,CAAlC;AACAsC,UAAI,CAACQ,KAAL,CAAW,CAAX,EAAc1D,OAAd,CAAsB;AAAA,YAAGW,CAAH,QAAGA,CAAH;AAAA,YAAMC,CAAN,QAAMA,CAAN;AAAA,eAAcuC,OAAO,CAACQ,MAAR,CAAehD,CAAf,EAAkBC,CAAlB,CAAd;AAAA,OAAtB;AACAuC,aAAO,CAACS,SAAR;AACAT,aAAO,CAACU,MAAR;AACH;AACJ,GAZqB;AActB7E,WAdsB,qBAcZ8E,SAdY,EAcWjF,KAdX,EAc0BC,MAd1B,EAc0CqE,OAd1C,EAcsF;AACxG,QAAMY,UAAU,GAAGZ,OAAO,CAACa,YAAR,CAAqB,CAArB,EAAwB,CAAxB,EAA2BnF,KAA3B,EAAkCC,MAAlC,CAAnB;AACA,QAAMR,IAAI,GAAGyF,UAAU,CAACzF,IAAxB;AACA,QAAI2F,UAAU,GAAGH,SAAS,CAAC7C,MAAV,GAAmB,CAApC;AACA,QAAIiD,WAAW,GAAG5F,IAAI,CAAC2C,MAAL,GAAc,CAAhC;;AAEA,QAAIiD,WAAW,GAAGD,UAAd,KAA6B,CAAjC,EAAoC;AAChC,aAAO,KAAP;AACH;;AAED,WAAOA,UAAU,EAAjB,EAAqB;AACjB,UAAME,KAAK,GAAGL,SAAS,CAACG,UAAD,CAAvB;AACA3F,UAAI,CAAC,EAAE4F,WAAH,CAAJ,GAAsB,GAAtB;AACA5F,UAAI,CAAC,EAAE4F,WAAH,CAAJ,GAAsBC,KAAtB;AACA7F,UAAI,CAAC,EAAE4F,WAAH,CAAJ,GAAsBC,KAAtB;AACA7F,UAAI,CAAC,EAAE4F,WAAH,CAAJ,GAAsBC,KAAtB;AACH;;AAEDhB,WAAO,CAACiB,YAAR,CAAqBL,UAArB,EAAiC,CAAjC,EAAoC,CAApC;AAEA,WAAO,IAAP;AACH;AAnCqB,CAAnB,C;;;;;;;;;;;;;;;;;;;;;;;;ACAP;;AAIA;;;;AAIO,IAAMM,YAAb;AAAA;AAAA;AAII;;;;;;AAMA,wBAAYC,IAAZ,EAAyBhG,IAAzB,EAAmCiG,SAAnC,EAAmFC,UAAnF,EAAyG;AAAA;;AAAA;;AAAA;;AACrG,QAAI,CAAClG,IAAL,EAAW;AACP,WAAKA,IAAL,GAAY,KAAKiG,SAAS,IAAIE,UAAlB,EAA8BH,IAAI,CAAC3D,CAAL,GAAS2D,IAAI,CAAC1D,CAA5C,CAAZ;;AAEA,UAAI4D,UAAJ,EAAgB;AACZ,aAAKlG,IAAL,CAAUoG,IAAV,CAAe,CAAf;AACH;AACJ,KAND,MAMO;AACH,WAAKpG,IAAL,GAAYA,IAAZ;AACH;;AAED,SAAKgG,IAAL,GAAYA,IAAZ;AACH;AAED;;;;;;;;;AAxBJ;AAAA;AAAA,sCA+BsBzD,KA/BtB,EA+BoC8D,MA/BpC,EA+B6D;AACrD,aAAQ9D,KAAK,CAACF,CAAN,IAAWgE,MAAZ,IACC9D,KAAK,CAACD,CAAN,IAAW+D,MADZ,IAEC9D,KAAK,CAACF,CAAN,GAAW,KAAK2D,IAAL,CAAU3D,CAAV,GAAcgE,MAF1B,IAGC9D,KAAK,CAACD,CAAN,GAAW,KAAK0D,IAAL,CAAU1D,CAAV,GAAc+D,MAHjC;AAIH;AAED;;;;;;;AAtCJ;AAAA;AAAA,mCA4CmBC,YA5CnB,EA4C+CC,KA5C/C,EA4C8DC,KA5C9D,EA4CmF;AAC3E,UAAMC,KAAK,GAAGH,YAAY,CAACN,IAAb,CAAkB1D,CAAhC;AACA,UAAMoE,KAAK,GAAGJ,YAAY,CAACN,IAAb,CAAkB3D,CAAhC;;AAEA,WAAK,IAAIA,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGqE,KAApB,EAA2BrE,CAAC,EAA5B,EAAgC;AAC5B,aAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGmE,KAApB,EAA2BnE,CAAC,EAA5B,EAAgC;AAC5BgE,sBAAY,CAACtG,IAAb,CAAkBsC,CAAC,GAAGoE,KAAJ,GAAYrE,CAA9B,IAAmC,KAAKrC,IAAL,CAAU,CAACwG,KAAK,GAAGlE,CAAT,IAAc,KAAK0D,IAAL,CAAU3D,CAAxB,GAA4BkE,KAA5B,GAAoClE,CAA9C,CAAnC;AACH;AACJ;AACJ;AAED;;;;;;;AAvDJ;AAAA;AAAA,wBA6DQA,CA7DR,EA6DmBC,CA7DnB,EA6DsC;AAC9B,aAAO,KAAKtC,IAAL,CAAUsC,CAAC,GAAG,KAAK0D,IAAL,CAAU3D,CAAd,GAAkBA,CAA5B,CAAP;AACH;AAED;;;;;;;;AAjEJ;AAAA;AAAA,wBAwEQA,CAxER,EAwEmBC,CAxEnB,EAwE8BuD,KAxE9B,EAwE8D;AACtD,WAAK7F,IAAL,CAAUsC,CAAC,GAAG,KAAK0D,IAAL,CAAU3D,CAAd,GAAkBA,CAA5B,IAAiCwD,KAAjC;AACA,aAAO,IAAP;AACH;AAED;;;;AA7EJ;AAAA;AAAA,iCAgFuB;AACf,UAAMtF,KAAK,GAAG,KAAKyF,IAAL,CAAU3D,CAAxB;AACA,UAAM7B,MAAM,GAAG,KAAKwF,IAAL,CAAU1D,CAAzB;AACA,UAAMtC,IAAI,GAAG,KAAKA,IAAlB;;AAEA,WAAK,IAAI2G,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGpG,KAApB,EAA2BoG,CAAC,EAA5B,EAAgC;AAC5B3G,YAAI,CAAC2G,CAAD,CAAJ,GAAU3G,IAAI,CAAC,CAACQ,MAAM,GAAG,CAAV,IAAeD,KAAf,GAAuBoG,CAAxB,CAAJ,GAAiC,CAA3C;AACH;;AAED,WAAK,IAAIA,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAGnG,MAAM,GAAG,CAA7B,EAAgCmG,EAAC,EAAjC,EAAqC;AACjC3G,YAAI,CAAC2G,EAAC,GAAGpG,KAAL,CAAJ,GAAkBP,IAAI,CAAC2G,EAAC,GAAGpG,KAAJ,IAAaA,KAAK,GAAG,CAArB,CAAD,CAAJ,GAAgC,CAAlD;AACH;AACJ;AAED;;;;AA9FJ;AAAA;AAAA,6BAiGmB;AACX,UAAMP,IAAI,GAAG,KAAKA,IAAlB;;AAEA,WAAK,IAAI2G,CAAC,GAAG3G,IAAI,CAAC2C,MAAlB,EAA0BgE,CAAC,EAA3B,GAAgC;AAC5B3G,YAAI,CAAC2G,CAAD,CAAJ,GAAU3G,IAAI,CAAC2G,CAAD,CAAJ,GAAU,CAAV,GAAc,CAAxB;AACH;AACJ;AAvGL;AAAA;AAAA,4BAyGYC,UAzGZ,EAyG+C;AACvC,UAAMpG,MAAM,GAAG,KAAKwF,IAAL,CAAU1D,CAAzB;AACA,UAAM/B,KAAK,GAAG,KAAKyF,IAAL,CAAU3D,CAAxB;AACA,UAAMwE,QAAQ,GAAG,IAAIxH,KAAJ,EAAjB;AACA,UAAMiB,MAAM,GAAG,IAAIjB,KAAJ,EAAf;;AAEA,UAAIuH,UAAU,IAAI,CAAlB,EAAqB;AACjB,eAAOtG,MAAP;AACH;;AAED,WAAK,IAAIqG,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGC,UAApB,EAAgCD,CAAC,EAAjC,EAAqC;AACjCE,gBAAQ,CAACF,CAAD,CAAR,GAAc;AACVG,aAAG,EAAE,CADK;AAEVC,aAAG,EAAE,CAFK;AAGVC,aAAG,EAAE,CAHK;AAIVC,aAAG,EAAE,CAJK;AAKVC,aAAG,EAAE,CALK;AAMVC,aAAG,EAAE,CANK;AAOVC,eAAK,EAAE,CAPG;AAQVhF,aAAG,EAAE;AARK,SAAd;AAUH;;AAED,WAAK,IAAIE,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG9B,MAApB,EAA4B8B,CAAC,EAA7B,EAAiC;AAC7B,YAAM+E,GAAG,GAAG/E,CAAC,GAAGA,CAAhB;;AACA,aAAK,IAAID,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG9B,KAApB,EAA2B8B,CAAC,EAA5B,EAAgC;AAC5B,cAAMiF,GAAG,GAAG,KAAKtH,IAAL,CAAUsC,CAAC,GAAG/B,KAAJ,GAAY8B,CAAtB,CAAZ;;AACA,cAAIiF,GAAG,GAAG,CAAV,EAAa;AACT,gBAAMC,KAAK,GAAGV,QAAQ,CAACS,GAAG,GAAG,CAAP,CAAtB;AACAC,iBAAK,CAACT,GAAN,IAAa,CAAb;AACAS,iBAAK,CAACR,GAAN,IAAazE,CAAb;AACAiF,iBAAK,CAACP,GAAN,IAAa3E,CAAb;AACAkF,iBAAK,CAACN,GAAN,IAAa5E,CAAC,GAAGC,CAAjB;AACAiF,iBAAK,CAACL,GAAN,IAAaG,GAAb;AACAE,iBAAK,CAACJ,GAAN,IAAa9E,CAAC,GAAGA,CAAjB;AACH;AACJ;AACJ;;AAED,UAAMmF,EAAE,GAAG5E,IAAI,CAAC4E,EAAhB;AACA,UAAMC,IAAI,GAAGD,EAAE,GAAG,CAAlB;;AAEA,WAAK,IAAIb,GAAC,GAAG,CAAb,EAAgBA,GAAC,GAAGC,UAApB,EAAgCD,GAAC,EAAjC,EAAqC;AACjC,YAAMY,MAAK,GAAGV,QAAQ,CAACF,GAAD,CAAtB;;AACA,YAAI,CAACe,KAAK,CAACH,MAAK,CAACT,GAAP,CAAN,IAAqBS,MAAK,CAACT,GAAN,KAAc,CAAvC,EAA0C;AACtC,cAAMa,EAAE,GAAGJ,MAAK,CAACP,GAAN,GAAYO,MAAK,CAACT,GAA7B;AACA,cAAMc,EAAE,GAAGL,MAAK,CAACR,GAAN,GAAYQ,MAAK,CAACT,GAA7B;AACA,cAAMe,IAAI,GAAGN,MAAK,CAACN,GAAN,GAAYM,MAAK,CAACT,GAAlB,GAAwBa,EAAE,GAAGC,EAA1C;AACA,cAAME,IAAI,GAAGP,MAAK,CAACL,GAAN,GAAYK,MAAK,CAACT,GAAlB,GAAwBc,EAAE,GAAGA,EAA1C;AACA,cAAMG,IAAI,GAAGR,MAAK,CAACJ,GAAN,GAAYI,MAAK,CAACT,GAAlB,GAAwBa,EAAE,GAAGA,EAA1C;AACA,cAAMK,GAAG,GAAG,MAAMpF,IAAI,CAACqF,IAAL,CAAU,CAACH,IAAI,GAAGC,IAAR,KAAiB,IAAIF,IAArB,CAAV,CAAN,IAA+CA,IAAI,IAAI,CAAR,GAAYJ,IAAZ,GAAmB,CAACA,IAAnE,IAA2ED,EAAvF;AACAD,gBAAK,CAACH,KAAN,GAAc,CAACY,GAAG,GAAG,GAAN,GAAYR,EAAZ,GAAiB,EAAlB,IAAwB,GAAxB,GAA8B,EAA5C;;AACA,cAAID,MAAK,CAACH,KAAN,GAAc,CAAlB,EAAqB;AACjBG,kBAAK,CAACH,KAAN,IAAe,GAAf;AACH;;AACDG,gBAAK,CAACnF,GAAN,GAAY4F,GAAG,GAAGR,EAAN,GAAWQ,GAAG,GAAGR,EAAjB,GAAsBQ,GAAlC;AACAT,gBAAK,CAAClF,CAAN,GAAUO,IAAI,CAACC,GAAL,CAASmF,GAAT,CAAV;AACAT,gBAAK,CAACjF,CAAN,GAAUM,IAAI,CAACE,GAAL,CAASkF,GAAT,CAAV;AACA1H,gBAAM,CAACO,IAAP,CAAY0G,MAAZ;AACH;AACJ;;AAED,aAAOjH,MAAP;AACH;AAED;;;;;;AA1KJ;AAAA;AAAA,yBA+KSuE,OA/KT,EA+K4CqD,KA/K5C,EA+KiE;AACzD,UAAM1H,MAAM,GAAG,KAAKwF,IAAL,CAAU1D,CAAzB;AACA,UAAM/B,KAAK,GAAG,KAAKyF,IAAL,CAAU3D,CAAxB,CAFyD,CAGzD;AACA;AACA;;AACA,UAAM1B,KAAK,GAAGkE,OAAO,CAACa,YAAR,CAAqB,CAArB,EAAwB,CAAxB,EAA2BnF,KAA3B,EAAkCC,MAAlC,CAAd;AACA,UAAMR,IAAI,GAAGW,KAAK,CAACX,IAAnB;AACA,UAAImI,OAAO,GAAG,CAAd;;AAEA,UAAI,CAACD,KAAL,EAAY;AACRA,aAAK,GAAG,GAAR;AACH;;AAED,WAAK,IAAI5F,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG9B,MAApB,EAA4B8B,CAAC,EAA7B,EAAiC;AAC7B,aAAK,IAAID,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG9B,KAApB,EAA2B8B,CAAC,EAA5B,EAAgC;AAC5B,cAAM+F,KAAK,GAAG9F,CAAC,GAAG/B,KAAJ,GAAY8B,CAA1B;AACA8F,iBAAO,GAAG,KAAKE,GAAL,CAAShG,CAAT,EAAYC,CAAZ,IAAiB4F,KAA3B;AACAlI,cAAI,CAACoI,KAAK,GAAG,CAAR,GAAY,CAAb,CAAJ,GAAsBD,OAAtB;AACAnI,cAAI,CAACoI,KAAK,GAAG,CAAR,GAAY,CAAb,CAAJ,GAAsBD,OAAtB;AACAnI,cAAI,CAACoI,KAAK,GAAG,CAAR,GAAY,CAAb,CAAJ,GAAsBD,OAAtB;AACAnI,cAAI,CAACoI,KAAK,GAAG,CAAR,GAAY,CAAb,CAAJ,GAAsB,GAAtB;AACH;AACJ,OAvBwD,CAyBzD;;;AACAvD,aAAO,CAACiB,YAAR,CAAqBnF,KAArB,EAA4B,CAA5B,EAA+B,CAA/B;AACH;AAED;;;;;;;;AA5MJ;AAAA;AAAA,4BAmNYkE,OAnNZ,EAmN+CqD,KAnN/C,EAmN8D3B,KAnN9D,EAmN6EC,KAnN7E,EAmNkG;AAC1F,UAAMvC,GAAQ,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAjB;AACA,UAAMqE,QAAa,GAAG,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAAtB;AACA,UAAMC,QAAa,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAtB;AACA,UAAM5H,KAAK,GAAGkE,OAAO,CAACa,YAAR,CAAqBa,KAArB,EAA4BC,KAA5B,EAAmC,KAAKR,IAAL,CAAU3D,CAA7C,EAAgD,KAAK2D,IAAL,CAAU1D,CAA1D,CAAd;AACA,UAAMtC,IAAI,GAAGW,KAAK,CAACX,IAAnB;;AAEA,UAAI,CAACkI,KAAD,IAAUA,KAAK,GAAG,CAAlB,IAAuBA,KAAK,GAAG,GAAnC,EAAwC;AACpCA,aAAK,GAAG,GAAR;AACH;;AAED,WAAK,IAAIvF,MAAM,GAAG,KAAK3C,IAAL,CAAU2C,MAA5B,EAAoCA,MAAM,EAA1C,GAA+C;AAC3CsB,WAAG,CAAC,CAAD,CAAH,GAAS,KAAKjE,IAAL,CAAU2C,MAAV,IAAoBuF,KAA7B;AACA,YAAMhE,GAAQ,GAAGD,GAAG,CAAC,CAAD,CAAH,IAAU,CAAV,GAAcqE,QAAd,GAAyBrE,GAAG,CAAC,CAAD,CAAH,IAAU,GAAV,GAAgBsE,QAAhB,GAA2BvE,wDAAO,CAACC,GAAD,CAA5E;AACAjE,YAAI,CAAC2C,MAAM,GAAG,CAAT,GAAa,CAAd,CAAJ,GAAuBuB,GAAG,CAAC,CAAD,CAA1B;AACAlE,YAAI,CAAC2C,MAAM,GAAG,CAAT,GAAa,CAAd,CAAJ,GAAuBuB,GAAG,CAAC,CAAD,CAA1B;AACAlE,YAAI,CAAC2C,MAAM,GAAG,CAAT,GAAa,CAAd,CAAJ,GAAuBuB,GAAG,CAAC,CAAD,CAA1B;AACAlE,YAAI,CAAC2C,MAAM,GAAG,CAAT,GAAa,CAAd,CAAJ,GAAuB,GAAvB;AACH;;AAEDkC,aAAO,CAACiB,YAAR,CAAqBnF,KAArB,EAA4B4F,KAA5B,EAAmCC,KAAnC;AACH;AAxOL;;AAAA;AAAA,I;;;;;;;;;;;;ACTA;AAAA;AAAA;AAAO,SAASgC,gBAAT,GAA6D;AAChE,MAAIC,SAAS,CAACC,YAAV,IAA0B,OAAOD,SAAS,CAACC,YAAV,CAAuBF,gBAA9B,KAAmD,UAAjF,EAA6F;AACzF,WAAOC,SAAS,CAACC,YAAV,CAAuBF,gBAAvB,EAAP;AACH;;AACD,SAAOG,OAAO,CAACC,MAAR,CAAe,IAAIC,KAAJ,CAAU,iCAAV,CAAf,CAAP;AACH;AAEM,SAASC,YAAT,CAAsBC,WAAtB,EAAiF;AACpF,MAAIN,SAAS,CAACC,YAAV,IAA0B,OAAOD,SAAS,CAACC,YAAV,CAAuBI,YAA9B,KAA+C,UAA7E,EAAyF;AACrF,WAAOL,SAAS,CAACC,YAAV,CAAuBI,YAAvB,CAAoCC,WAApC,CAAP;AACH;;AACD,SAAOJ,OAAO,CAACC,MAAR,CAAe,IAAIC,KAAJ,CAAU,6BAAV,CAAf,CAAP;AACH,C;;;;;;;;;;;;;;;;;;ACbD;;;;;;;;AAQO,SAASG,KAAT,GAAuD;AAC1D,MAAMC,QAAQ,GAAG,SAAXA,QAAW,CAACC,GAAD;AAAA,WAAkBA,GAAG,IAAI,qEAAOA,GAAP,MAAe,QAAxC;AAAA,GAAjB;;AAD0D,oCAArCC,OAAqC;AAArCA,WAAqC;AAAA;;AAG1D,SAAOA,OAAO,CAAC3G,MAAR,CAAe,UAAC4G,IAAD,EAAOF,GAAP,EAAe;AACjC,QAAIA,GAAJ,EAAS;AACLjI,YAAM,CAACC,IAAP,CAAYgI,GAAZ,EAAiBxH,OAAjB,CAAyB,UAAAN,GAAG,EAAI;AAC5B,YAAMiI,IAAI,GAAGD,IAAI,CAAChI,GAAD,CAAjB;AACA,YAAMkI,IAAI,GAAGJ,GAAG,CAAC9H,GAAD,CAAhB;;AAEA,YAAI/B,KAAK,CAACkK,OAAN,CAAcF,IAAd,KAAuBhK,KAAK,CAACkK,OAAN,CAAcD,IAAd,CAA3B,EAAgD;AAC5C;AACAF,cAAI,CAAChI,GAAD,CAAJ,GAAYkI,IAAZ;AACH,SAHD,MAGO,IAAIL,QAAQ,CAACI,IAAD,CAAR,IAAkBJ,QAAQ,CAACK,IAAD,CAA9B,EAAsC;AACzCF,cAAI,CAAChI,GAAD,CAAJ,GAAY4H,KAAK,CAACK,IAAD,EAAOC,IAAP,CAAjB;AACH,SAFM,MAEA;AACHF,cAAI,CAAChI,GAAD,CAAJ,GAAYkI,IAAZ;AACH;AACJ,OAZD;AAaH;;AAED,WAAOF,IAAP;AACH,GAlBM,EAkBJ,EAlBI,CAAP;AAmBH,C;;;;;;;;;;;;AC5BD;AAAA;AAAO,IAAMjK,MAAoB,GAAG;AAChCqK,aAAW,EAAE;AACTC,QAAI,EAAE,MADG;AAEThG,QAAI,EAAE,YAFG;AAGTsF,eAAW,EAAE;AACTxI,WAAK,EAAE,GADE;AAETC,YAAM,EAAE,GAFC;AAGT;AACAkJ,gBAAU,EAAE,aAJH,CAIiB;AAC1B;;AALS,KAHJ;AAUTC,QAAI,EAAE;AACFC,SAAG,EAAE,IADH;AAEFC,WAAK,EAAE,IAFL;AAGFC,UAAI,EAAE,IAHJ;AAIFC,YAAM,EAAE;AAJN,KAVG;AAgBTC,iBAAa,EAAE,KAhBN,CAgBY;;AAhBZ,GADmB;AAmBhCC,QAAM,EAAE,IAnBwB;AAoBhCC,cAAY,EAAE,CApBkB;AAqBhCC,SAAO,EAAE;AACLC,WAAO,EAAE,CACL,iBADK,CADJ;AAILC,SAAK,EAAE;AACHC,qBAAe,EAAE,KADd;AAEHC,mBAAa,EAAE,KAFZ;AAGHC,kBAAY,EAAE,KAHX;AAIHC,iBAAW,EAAE;AAJV;AAJF,GArBuB;AAgChCC,SAAO,EAAE;AACLC,cAAU,EAAE,IADP;AAELC,aAAS,EAAE,QAFN;AAEgB;AACrBP,SAAK,EAAE;AACHQ,gBAAU,EAAE,KADT;AAEHC,iBAAW,EAAE,KAFV;AAGHC,sBAAgB,EAAE,KAHf;AAIHC,kBAAY,EAAE,KAJX;AAKHC,gBAAU,EAAE,KALT;AAMHC,qBAAe,EAAE,KANd;AAOHC,8BAAwB,EAAE,KAPvB;AAQHC,oBAAc,EAAE;AACZC,uBAAe,EAAE,KADL;AAEZC,0BAAkB,EAAE,KAFR;AAGZC,cAAM,EAAE;AAHI;AARb;AAHF;AAhCuB,CAA7B,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACCP;AAEA;AACA;AAyBC;AAOM,IAAMC,cAAb;AAAA;AAAA;AAQI,0BAAYrM,MAAZ,EAA0CsM,iBAA1C,EAAuF;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AACnF,SAAKnM,OAAL,GAAeH,MAAf;AACA,SAAKuM,kBAAL,GAA0BD,iBAA1B;AACA,SAAKE,eAAL,GAAuB,EAAvB;;AAEA,QAAIC,KAAA,IAAyC,KAAKtM,OAAL,CAAa+K,KAAtD,IAA+D,OAAOzK,QAAP,KAAoB,WAAvF,EAAoG;AAChG,UAAMiM,QAAQ,GAAGjM,QAAQ,CAACkM,aAAT,CAAuB,kBAAvB,CAAjB;AAEA,WAAKC,gBAAL,GAAwBnM,QAAQ,CAACkM,aAAT,CAAuB,kBAAvB,CAAxB;;AACA,UAAI,CAAC,KAAKC,gBAAV,EAA4B;AACxB,aAAKA,gBAAL,GAAwBnM,QAAQ,CAACC,aAAT,CAAuB,QAAvB,CAAxB;AACA,aAAKkM,gBAAL,CAAsBC,SAAtB,GAAkC,WAAlC;;AACA,YAAIH,QAAJ,EAAc;AACVA,kBAAQ,CAACI,WAAT,CAAqB,KAAKF,gBAA1B;AACH;AACJ;;AACD,WAAKA,gBAAL,CAAsBG,KAAtB,CAA4BC,OAA5B,GAAsC,KAAK7M,OAAL,CAAa+K,KAAb,CAAmBE,aAAnB,GAAmC,OAAnC,GAA6C,MAAnF;AAEA,WAAK6B,cAAL,GAAsBxM,QAAQ,CAACkM,aAAT,CAAuB,sBAAvB,CAAtB;;AACA,UAAI,CAAC,KAAKM,cAAV,EAA0B;AACtB,aAAKA,cAAL,GAAsBxM,QAAQ,CAACC,aAAT,CAAuB,QAAvB,CAAtB;AACA,aAAKuM,cAAL,CAAoBJ,SAApB,GAAgC,eAAhC;;AACA,YAAIH,QAAJ,EAAc;AACVA,kBAAQ,CAACI,WAAT,CAAqB,KAAKG,cAA1B;AACH;AACJ;;AACD,WAAKA,cAAL,CAAoBF,KAApB,CAA0BC,OAA1B,GAAoC,KAAK7M,OAAL,CAAa+K,KAAb,CAAmBI,WAAnB,GAAiC,OAAjC,GAA2C,MAA/E;AAEA,UAAM4B,aAAa,GAAGzM,QAAQ,CAACkM,aAAT,CAA0C,sBAA1C,CAAtB;AACA,WAAKQ,eAAL,GAAuBD,aAAa,GAAGA,aAAa,CAACtM,UAAd,CAAyB,IAAzB,CAAH,GAAoC,IAAxE;AACH;;AAED,SAAKwM,YAAL;AACH;;AAzCL;AAAA;AAAA,4CA2C4BC,KA3C5B,EA2C8D;AAAA;;AACtD,UAAIC,OAAsB,GAAG,IAA7B;;AAEA,UAAID,KAAJ,EAAW;AACP,YAAI,KAAKlN,OAAL,CAAaoN,QAAjB,EAA2B;AACvB,cAAMC,QAAQ,GAAGH,KAAK,CAACI,GAAN,CAAU,UAAAC,GAAG;AAAA,mBAAI,KAAI,CAACC,qBAAL,CAA2BD,GAA3B,CAAJ;AAAA,WAAb,CAAjB;AACA,iBAAO;AAAEF,oBAAQ,EAARA,QAAF;AAAYH,iBAAK,EAALA;AAAZ,WAAP;AACH;;AACD,YAAIA,KAAK,CAACzL,IAAN,CAAW,UAAA8L,GAAG;AAAA,iBAAI,CAAC,EAAEJ,OAAO,GAAG,KAAI,CAACK,qBAAL,CAA2BD,GAA3B,CAAZ,CAAL;AAAA,SAAd,CAAJ,EAAsE;AAClEJ,iBAAO,CAACD,KAAR,GAAgBA,KAAhB;AACH;AACJ;;AAED,aAAOC,OAAP;AACH;AAED;;;;;;;AA3DJ;AAAA;AAAA,0CAiE0BI,GAjE1B,EAiEmD;AAC3C,UAAMxC,KAAK,GAAGuB,KAAA,IAAyC,KAAKU,eAA9C,IAAiE,KAAKhN,OAAL,CAAa+K,KAA5F;;AAEA,UAAIA,KAAK,IAAIA,KAAK,CAACC,eAAnB,EAAoC;AAChC,aAAKyC,SAAL,CAAeF,GAAf,EAAoB,MAApB,EAA4B,CAA5B;AACH;;AAED,UAAIG,IAAI,GAAG,KAAKC,QAAL,CAAcJ,GAAd,CAAX;;AAEA,UAAIG,IAAI,KAAK,IAAb,EAAmB;AACf,eAAO,IAAP;AACH;;AAED,UAAME,KAAK,GAAGtK,IAAI,CAACuK,KAAL,CAAWH,IAAI,CAAC,CAAD,CAAJ,CAAQ1K,CAAR,GAAY0K,IAAI,CAAC,CAAD,CAAJ,CAAQ1K,CAA/B,EAAkC0K,IAAI,CAAC,CAAD,CAAJ,CAAQ3K,CAAR,GAAY2K,IAAI,CAAC,CAAD,CAAJ,CAAQ3K,CAAtD,CAAd;AACA2K,UAAI,GAAG,KAAKI,gBAAL,CAAsBJ,IAAtB,EAA4BE,KAA5B,CAAP;;AAEA,UAAI5M,MAAM,GAAG,KAAK+M,UAAL,CAAgBL,IAAhB,CAAb;;AACA,UAAI1M,MAAM,KAAK,IAAf,EAAqB;AACjBA,cAAM,GAAG,KAAKgN,oBAAL,CAA0BT,GAA1B,EAA+BG,IAA/B,EAAqCE,KAArC,CAAT;AACH;;AAED,UAAI5M,MAAM,KAAK,IAAf,EAAqB;AACjB,eAAO,IAAP;AACH;;AAED,UAAI+J,KAAK,IAAIA,KAAK,CAACG,YAAnB,EAAiC;AAC7B,aAAKuC,SAAL,CAAeC,IAAf,EAAqB,KAArB,EAA4B,CAA5B;AACH;;AAED,aAAO;AACHE,aAAK,EAALA,KADG;AAEHL,WAAG,EAAHA,GAFG;AAGH1M,kBAAU,EAAEG,MAAM,CAACH,UAHhB;AAIH6M,YAAI,EAAJA,IAJG;AAKHO,eAAO,EAAEjN,MAAM,CAACkN,WAAP,CAAmBR,IALzB;AAMHxL,iBAAS,EAAElB,MAAM,CAACkN,WAAP,CAAmBhM;AAN3B,OAAP;AAQH;AAtGL;AAAA;AAAA,+BAwGe4I,OAxGf,EAwG+D;AACvD,WAAK9K,OAAL,CAAa8K,OAAb,GAAuBA,OAAvB;AACA,WAAKuB,eAAL,CAAqBhJ,MAArB,GAA8B,CAA9B;;AACA,WAAK4J,YAAL;AACH;AA5GL;AAAA;AAAA,mCA8GiC;AAAA;;AACzB,WAAKjN,OAAL,CAAa8K,OAAb,CAAqB1I,OAArB,CAA6B,UAAA+L,YAAY,EAAI;AACzC,YAAIC,MAAJ;AACA,YAAIC,aAAkC,GAAG,EAAzC;AACA,YAAIC,WAAW,GAAG,EAAlB;;AAEA,YAAI,qEAAOH,YAAP,MAAwB,QAA5B,EAAsC;AAClCC,gBAAM,GAAGD,YAAY,CAACI,MAAtB;AACAF,uBAAa,GAAGF,YAAY,CAACtO,MAAb,IAAuB,EAAvC;AACH,SAHD,MAGO,IAAI,OAAOsO,YAAP,KAAwB,QAA5B,EAAsC;AACzCC,gBAAM,GAAGD,YAAT;AACH;;AAED,YAAI7B,IAAJ,EAA2C;AACvCkC,iBAAO,CAACC,GAAR,CAAY,4BAAZ,EAA0CL,MAA1C;AACH;;AAED,YAAIC,aAAa,CAACC,WAAlB,EAA+B;AAC3BA,qBAAW,GAAGD,aAAa,CAACC,WAAd,CAA0BhB,GAA1B,CAA8B,UAAAoB,UAAU;AAAA,mBAAI,IAAIC,qDAAO,CAACD,UAAD,CAAX,EAAJ;AAAA,WAAxC,CAAd;AACH;;AAED,cAAI,CAACrC,eAAL,CAAqB9K,IAArB,CAA0B,IAAIoN,qDAAO,CAACP,MAAD,CAAX,CAAoBC,aAApB,EAAmCC,WAAnC,CAA1B;AACH,OArBD;;AAuBA,UAAIhC,IAAJ,EAA2C;AAAA;;AACvC,oBAAAkC,OAAO,EAACC,GAAR,kBAAY,qBAAZ,yFACO,KAAKpC,eAAL,CAAqBiB,GAArB,CAAyB;AAAA,cAAGzN,MAAH,QAAGA,MAAH;AAAA,cAAW+O,MAAX,QAAWA,MAAX;AAAA,iBAAwBC,IAAI,CAACC,SAAL,CAAe;AAAEjP,kBAAM,EAANA,MAAF;AAAU+O,kBAAM,EAANA;AAAV,WAAf,CAAxB;AAAA,SAAzB,CADP;AAEH;AACJ;AAED;;;;;;AA5IJ;AAAA;AAAA,qCAiJ6BlB,IAjJ7B,EAiJyCE,KAjJzC,EAiJ8D;AACtD,eAASmB,UAAT,CAAoBC,MAApB,EAAoC;AAChC,YAAMC,SAAS,GAAG;AACdjM,WAAC,EAAEgM,MAAM,GAAG1L,IAAI,CAACE,GAAL,CAASoK,KAAT,CADE;AAEd7K,WAAC,EAAEiM,MAAM,GAAG1L,IAAI,CAACC,GAAL,CAASqK,KAAT;AAFE,SAAlB;AAKAF,YAAI,CAAC,CAAD,CAAJ,CAAQ1K,CAAR,IAAaiM,SAAS,CAACjM,CAAvB;AACA0K,YAAI,CAAC,CAAD,CAAJ,CAAQ3K,CAAR,IAAakM,SAAS,CAAClM,CAAvB;AACA2K,YAAI,CAAC,CAAD,CAAJ,CAAQ1K,CAAR,IAAaiM,SAAS,CAACjM,CAAvB;AACA0K,YAAI,CAAC,CAAD,CAAJ,CAAQ3K,CAAR,IAAakM,SAAS,CAAClM,CAAvB;AACH;;AAED,UAAMmM,UAAU,GAAG5L,IAAI,CAAC6L,IAAL,CAAU,SAACzB,IAAI,CAAC,CAAD,CAAJ,CAAQ1K,CAAR,GAAY0K,IAAI,CAAC,CAAD,CAAJ,CAAQ1K,CAArB,EAA2B,CAA3B,aAAgC0K,IAAI,CAAC,CAAD,CAAJ,CAAQ3K,CAAR,GAAY2K,IAAI,CAAC,CAAD,CAAJ,CAAQ3K,CAApD,EAA0D,CAA1D,CAAV,CAAnB;AACA,UAAIqM,eAAe,GAAGF,UAAU,GAAG,GAAb,GAAmB,CAAzC;AAEAH,gBAAU,CAACK,eAAD,CAAV,CAhBsD,CAkBtD;;AACA,aAAOA,eAAe,GAAG,CAAlB,KAAwB,CAAC,KAAKhD,kBAAL,CAAwBiD,iBAAxB,CAA0C3B,IAAI,CAAC,CAAD,CAA9C,EAAmD,CAAnD,CAAD,IACxB,CAAC,KAAKtB,kBAAL,CAAwBiD,iBAAxB,CAA0C3B,IAAI,CAAC,CAAD,CAA9C,EAAmD,CAAnD,CADD,CAAP,EACgE;AAC5D0B,uBAAe,KAAK,CAApB;AACAL,kBAAU,CAAC,CAACK,eAAF,CAAV;AACH;;AAED,aAAO1B,IAAP;AACH;AA3KL;AAAA;AAAA,6BA6KqBH,GA7KrB,EA6KqC;AAC7B,aAAO,CAAC;AACJxK,SAAC,EAAE,CAACwK,GAAG,CAAC,CAAD,CAAH,CAAOxK,CAAP,GAAWwK,GAAG,CAAC,CAAD,CAAH,CAAOxK,CAAnB,IAAwB,CADvB;AAEJC,SAAC,EAAE,CAACuK,GAAG,CAAC,CAAD,CAAH,CAAOvK,CAAP,GAAWuK,GAAG,CAAC,CAAD,CAAH,CAAOvK,CAAnB,IAAwB;AAFvB,OAAD,EAGJ;AACCD,SAAC,EAAE,CAACwK,GAAG,CAAC,CAAD,CAAH,CAAOxK,CAAP,GAAWwK,GAAG,CAAC,CAAD,CAAH,CAAOxK,CAAnB,IAAwB,CAD5B;AAECC,SAAC,EAAE,CAACuK,GAAG,CAAC,CAAD,CAAH,CAAOvK,CAAP,GAAWuK,GAAG,CAAC,CAAD,CAAH,CAAOvK,CAAnB,IAAwB;AAF5B,OAHI,CAAP;AAOH;AArLL;AAAA;AAAA,+BAuLuB0K,IAvLvB,EAuL0D;AAClD,UAAM3C,KAAK,GAAGuB,KAAA,IAAyC,KAAKtM,OAAL,CAAa+K,KAApE;;AAEA,UAAIA,KAAK,IAAI,KAAKiC,eAAlB,EAAmC;AAC/B,aAAKS,SAAL,CAAeC,IAAf,EAAqB,KAArB,EAA4B,CAA5B;AACH;;AAED,UAAIQ,WAAW,GAAGoB,oDAAS,CAACC,cAAV,CAAyB,KAAKnD,kBAA9B,EAAkDsB,IAAI,CAAC,CAAD,CAAtD,EAA2DA,IAAI,CAAC,CAAD,CAA/D,CAAlB;;AAEA,UAAI3C,KAAK,IAAIA,KAAK,CAACE,aAAnB,EAAkC;AAC9B,aAAKuE,eAAL,CAAqBtB,WAAW,CAACR,IAAjC;AACH;;AAEDQ,iBAAW,GAAGoB,oDAAS,CAACG,YAAV,CAAuBvB,WAAvB,CAAd;;AAEA,UAAInD,KAAK,IAAIA,KAAK,CAACI,WAAnB,EAAgC;AAC5B,aAAKuE,aAAL,CAAmBxB,WAAW,CAACR,IAA/B;AACH;;AAED,UAAI7M,UAAmB,GAAG,IAA1B;;AAEA,WAAKwL,eAAL,CAAqB5K,IAArB,CAA0B,UAAA2M,MAAM;AAAA,eAAI,CAAC,EAAEvN,UAAU,GAAGuN,MAAM,CAACuB,aAAP,CAAqBzB,WAAW,CAACR,IAAjC,CAAf,CAAL;AAAA,OAAhC;;AAEA,aAAO7M,UAAU,GAAG;AAAEA,kBAAU,EAAVA,UAAF;AAAcqN,mBAAW,EAAXA;AAAd,OAAH,GAAiC,IAAlD;AACH;AAED;;;;;;;;AAjNJ;AAAA;AAAA,yCAwNiCX,GAxNjC,EAwN2CG,IAxN3C,EAwNuDkC,SAxNvD,EAwNiG;AACzF,UAAMC,UAAU,GAAGvM,IAAI,CAAC6L,IAAL,CAAU,SAAC5B,GAAG,CAAC,CAAD,CAAH,CAAOxK,CAAP,GAAWwK,GAAG,CAAC,CAAD,CAAH,CAAOxK,CAAnB,EAAyB,CAAzB,aAA8BwK,GAAG,CAAC,CAAD,CAAH,CAAOvK,CAAP,GAAWuK,GAAG,CAAC,CAAD,CAAH,CAAOvK,CAAhD,EAAsD,CAAtD,CAAV,CAAnB;AACA,UAAM8M,MAAM,GAAG,EAAf;AACA,UAAMC,IAAI,GAAGzM,IAAI,CAACE,GAAL,CAASoM,SAAT,CAAb;AACA,UAAMI,IAAI,GAAG1M,IAAI,CAACC,GAAL,CAASqM,SAAT,CAAb;;AAEA,WAAK,IAAIvI,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGyI,MAApB,EAA4BzI,CAAC,EAA7B,EAAiC;AAC7B;AACA,YAAM4I,GAAG,GAAGJ,UAAU,GAAGC,MAAb,GAAsBzI,CAAtB,IAA2BA,CAAC,GAAG,CAAJ,KAAU,CAAV,GAAc,CAAC,CAAf,GAAmB,CAA9C,CAAZ;AACAqG,YAAI,CAAC,CAAD,CAAJ,CAAQ1K,CAAR,IAAaiN,GAAG,GAAGF,IAAnB;AACArC,YAAI,CAAC,CAAD,CAAJ,CAAQ3K,CAAR,IAAakN,GAAG,GAAGD,IAAnB;AACAtC,YAAI,CAAC,CAAD,CAAJ,CAAQ1K,CAAR,IAAaiN,GAAG,GAAGF,IAAnB;AACArC,YAAI,CAAC,CAAD,CAAJ,CAAQ3K,CAAR,IAAakN,GAAG,GAAGD,IAAnB;;AAEA,YAAMhP,MAAM,GAAG,KAAK+M,UAAL,CAAgBL,IAAhB,CAAf;;AACA,YAAI1M,MAAJ,EAAY;AACR,iBAAOA,MAAP;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AAED;;;;AA/OJ;AAAA;AAAA,oCAkP4B0M,IAlP5B,EAkPuD;AAC/C,UAAMnI,OAAO,GAAG,KAAKkH,gBAAL,CAAsBhM,UAAtB,CAAiC,IAAjC,CAAhB;;AACA,WAAKgM,gBAAL,CAAsBxL,KAAtB,GAA8ByM,IAAI,CAACrK,MAAnC;AACA,WAAKoJ,gBAAL,CAAsBvL,MAAtB,GAA+B,GAA/B;AAEAqE,aAAO,CAACK,SAAR;AACAL,aAAO,CAACG,WAAR,GAAsB,MAAtB;;AAEA,WAAK,IAAI2B,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGqG,IAAI,CAACrK,MAAzB,EAAiCgE,CAAC,EAAlC,EAAsC;AAClC9B,eAAO,CAACM,MAAR,CAAewB,CAAf,EAAkB,GAAlB;AACA9B,eAAO,CAACQ,MAAR,CAAesB,CAAf,EAAkB,MAAMqG,IAAI,CAACrG,CAAD,CAA5B;AACH;;AAED9B,aAAO,CAACS,SAAR;AACAT,aAAO,CAACU,MAAR;AACH;AAED;;;;AAnQJ;AAAA;AAAA,kCAsQ0ByH,IAtQ1B,EAsQqD;AAC7C,UAAMnI,OAAO,GAAG,KAAKuH,cAAL,CAAoBrM,UAApB,CAA+B,IAA/B,CAAhB;;AAEA,WAAKqM,cAAL,CAAoB7L,KAApB,GAA4ByM,IAAI,CAACrK,MAAjC;AACAkC,aAAO,CAACI,SAAR,GAAoB,OAApB;;AAEA,WAAK,IAAI0B,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGqG,IAAI,CAACrK,MAAzB,EAAiCgE,CAAC,EAAlC,EAAsC;AAClC,YAAIqG,IAAI,CAACrG,CAAD,CAAJ,KAAY,CAAhB,EAAmB;AACf9B,iBAAO,CAAC2K,QAAR,CAAiB7I,CAAjB,EAAoB,CAApB,EAAuB,CAAvB,EAA0B,GAA1B;AACH;AACJ;AACJ;AAjRL;AAAA;AAAA,8BAmRsB/B,IAnRtB,EAmR0CE,KAnR1C,EAmRyDC,SAnRzD,EAmRkF;AAC1EtE,oEAAU,CAACkE,QAAX,CAAoBC,IAApB,EAA0B,KAAK0H,eAA/B,EAAgDxH,KAAhD,EAAuDC,SAAvD;AACH;AArRL;;AAAA;AAAA,I;;;;;;;;;;;;;;;;;;;;;;ICnCK0K,K;;WAAAA,K;AAAAA,O,CAAAA,K;AAAAA,O,CAAAA,K;GAAAA,K,KAAAA,K;;AAGJ;AASM,IAAMb,SAAS,GAAG;AACrB;;;;;;;;AAQAC,gBATqB,0BASNvI,YATM,EASsBoJ,EATtB,EASiCC,EATjC,EASyD;AAC1E,QAAIC,EAAE,GAAGF,EAAE,CAACrN,CAAH,GAAO,CAAhB;AACA,QAAIwN,EAAE,GAAGH,EAAE,CAACpN,CAAH,GAAO,CAAhB;AACA,QAAIwN,EAAE,GAAGH,EAAE,CAACtN,CAAH,GAAO,CAAhB;AACA,QAAI0N,EAAE,GAAGJ,EAAE,CAACrN,CAAH,GAAO,CAAhB;AACA,QAAM0N,KAAK,GAAGpN,IAAI,CAACI,GAAL,CAAS+M,EAAE,GAAGF,EAAd,IAAoBjN,IAAI,CAACI,GAAL,CAAS8M,EAAE,GAAGF,EAAd,CAAlC;AACA,QAAI5H,GAAJ;AACA,QAAMgF,IAAI,GAAG,EAAb;AACA,QAAMxH,SAAS,GAAGc,YAAY,CAACtG,IAA/B;AACA,QAAMO,KAAK,GAAG+F,YAAY,CAACN,IAAb,CAAkB3D,CAAhC;AACA,QAAIiF,GAAJ;AACA,QAAI2I,GAAG,GAAG,GAAV;AACA,QAAIC,GAAG,GAAG,CAAV;;AAEA,aAASC,IAAT,CAAcC,CAAd,EAAyB1L,CAAzB,EAAoC;AAChC4C,SAAG,GAAG9B,SAAS,CAACd,CAAC,GAAGnE,KAAJ,GAAY6P,CAAb,CAAf;AACAH,SAAG,GAAG3I,GAAG,GAAG2I,GAAN,GAAY3I,GAAZ,GAAkB2I,GAAxB;AACAC,SAAG,GAAG5I,GAAG,GAAG4I,GAAN,GAAY5I,GAAZ,GAAkB4I,GAAxB;AACAlD,UAAI,CAACnM,IAAL,CAAUyG,GAAV;AACH;;AAED,QAAI0I,KAAJ,EAAW;AACPhI,SAAG,GAAG4H,EAAN;AACAA,QAAE,GAAGC,EAAL;AACAA,QAAE,GAAG7H,GAAL;AAEAA,SAAG,GAAG8H,EAAN;AACAA,QAAE,GAAGC,EAAL;AACAA,QAAE,GAAG/H,GAAL;AACH;;AACD,QAAI4H,EAAE,GAAGE,EAAT,EAAa;AACT9H,SAAG,GAAG4H,EAAN;AACAA,QAAE,GAAGE,EAAL;AACAA,QAAE,GAAG9H,GAAL;AAEAA,SAAG,GAAG6H,EAAN;AACAA,QAAE,GAAGE,EAAL;AACAA,QAAE,GAAG/H,GAAL;AACH;;AAED,QAAIqI,MAAM,GAAGP,EAAE,GAAGF,EAAlB;AACA,QAAIU,MAAM,GAAG1N,IAAI,CAACI,GAAL,CAAS+M,EAAE,GAAGF,EAAd,CAAb;AACA,QAAIU,KAAK,GAAIF,MAAM,GAAG,CAAV,GAAe,CAA3B;AACA,QAAI/N,CAAC,GAAGuN,EAAR;AACA,QAAIW,KAAK,GAAGX,EAAE,GAAGE,EAAL,GAAU,CAAV,GAAc,CAAC,CAA3B;;AAEA,SAAK,IAAI1N,CAAC,GAAGuN,EAAb,EAAiBvN,CAAC,GAAGyN,EAArB,EAAyBzN,CAAC,EAA1B,EAA8B;AAC1B,UAAI2N,KAAJ,EAAW;AACPG,YAAI,CAAC7N,CAAD,EAAID,CAAJ,CAAJ;AACH,OAFD,MAEO;AACH8N,YAAI,CAAC9N,CAAD,EAAIC,CAAJ,CAAJ;AACH;;AACDiO,WAAK,GAAGA,KAAK,GAAGD,MAAhB;;AACA,UAAIC,KAAK,GAAG,CAAZ,EAAe;AACXjO,SAAC,IAAIkO,KAAL;AACAD,aAAK,GAAGA,KAAK,GAAGF,MAAhB;AACH;AACJ;;AAED,WAAO;AACHrD,UAAI,EAAJA,IADG;AAEHiD,SAAG,EAAHA,GAFG;AAGHC,SAAG,EAAHA;AAHG,KAAP;AAKH,GAzEoB;;AA2ErB;;;;;AAKAnB,cAhFqB,wBAgFRzO,MAhFQ,EAgF0B;AAC3C,QAAM2P,GAAG,GAAG3P,MAAM,CAAC2P,GAAnB;AACA,QAAMC,GAAG,GAAG5P,MAAM,CAAC4P,GAAnB;AACA,QAAMlD,IAAI,GAAG1M,MAAM,CAAC0M,IAApB;AACA,QAAMyD,MAAM,GAAGR,GAAG,GAAG,CAACC,GAAG,GAAGD,GAAP,IAAc,CAAnC;AACA,QAAMS,OAAO,GAAG,IAAIrR,KAAJ,EAAhB;AACA,QAAImC,SAAS,GAAG,CAAC0O,GAAG,GAAGD,GAAP,IAAc,EAA9B;AACA,QAAMU,UAAU,GAAG,CAACnP,SAApB,CAP2C,CAS3C;;AACA,QAAIoP,UAAU,GAAG5D,IAAI,CAAC,CAAD,CAAJ,GAAUyD,MAAV,GAAmBhB,KAAK,CAACoB,EAAzB,GAA8BpB,KAAK,CAACqB,IAArD;AACAJ,WAAO,CAAC7P,IAAR,CAAa;AACTkQ,SAAG,EAAE,CADI;AAETzJ,SAAG,EAAE0F,IAAI,CAAC,CAAD;AAFA,KAAb;;AAIA,SAAK,IAAIrG,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGqG,IAAI,CAACrK,MAAL,GAAc,CAAlC,EAAqCgE,CAAC,EAAtC,EAA0C;AACtC,UAAMqK,KAAK,GAAIhE,IAAI,CAACrG,CAAC,GAAG,CAAL,CAAJ,GAAcqG,IAAI,CAACrG,CAAD,CAAjC;AACA,UAAMsK,MAAM,GAAIjE,IAAI,CAACrG,CAAC,GAAG,CAAL,CAAJ,GAAcqG,IAAI,CAACrG,CAAC,GAAG,CAAL,CAAlC;AACA,UAAI4I,GAAU,SAAd;;AACA,UAAKyB,KAAK,GAAGC,MAAT,GAAmBN,UAAnB,IAAiC3D,IAAI,CAACrG,CAAC,GAAG,CAAL,CAAJ,GAAe8J,MAAM,GAAG,GAA7D,EAAmE;AAC/DlB,WAAG,GAAGE,KAAK,CAACqB,IAAZ;AACH,OAFD,MAEO,IAAKE,KAAK,GAAGC,MAAT,GAAmBzP,SAAnB,IAAgCwL,IAAI,CAACrG,CAAC,GAAG,CAAL,CAAJ,GAAe8J,MAAM,GAAG,GAA5D,EAAkE;AACrElB,WAAG,GAAGE,KAAK,CAACoB,EAAZ;AACH,OAFM,MAEA;AACHtB,WAAG,GAAGqB,UAAN;AACH;;AAED,UAAIA,UAAU,KAAKrB,GAAnB,EAAwB;AACpBmB,eAAO,CAAC7P,IAAR,CAAa;AACTkQ,aAAG,EAAEpK,CADI;AAETW,aAAG,EAAE0F,IAAI,CAACrG,CAAD;AAFA,SAAb;AAIAiK,kBAAU,GAAGrB,GAAb;AACH;AACJ;;AACDmB,WAAO,CAAC7P,IAAR,CAAa;AACTkQ,SAAG,EAAE/D,IAAI,CAACrK,MADD;AAET2E,SAAG,EAAE0F,IAAI,CAACA,IAAI,CAACrK,MAAL,GAAc,CAAf;AAFA,KAAb;;AAKA,SAAK,IAAIuO,CAAC,GAAGR,OAAO,CAAC,CAAD,CAAP,CAAWK,GAAxB,EAA6BG,CAAC,GAAGR,OAAO,CAAC,CAAD,CAAP,CAAWK,GAA5C,EAAiDG,CAAC,EAAlD,EAAsD;AAClDlE,UAAI,CAACkE,CAAD,CAAJ,GAAUlE,IAAI,CAACkE,CAAD,CAAJ,GAAUT,MAAV,GAAmB,CAAnB,GAAuB,CAAjC;AACH,KA1C0C,CA4C3C;;;AACA,SAAK,IAAI9J,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAG+J,OAAO,CAAC/N,MAAR,GAAiB,CAArC,EAAwCgE,EAAC,EAAzC,EAA6C;AACzC,UAAI+J,OAAO,CAAC/J,EAAC,GAAG,CAAL,CAAP,CAAeW,GAAf,GAAqBoJ,OAAO,CAAC/J,EAAD,CAAP,CAAWW,GAApC,EAAyC;AACrC9F,iBAAS,GAAIkP,OAAO,CAAC/J,EAAD,CAAP,CAAWW,GAAX,GAAkB,CAACoJ,OAAO,CAAC/J,EAAC,GAAG,CAAL,CAAP,CAAeW,GAAf,GAAqBoJ,OAAO,CAAC/J,EAAD,CAAP,CAAWW,GAAjC,IAAwC,CAAzC,GAA8C,CAAhE,GAAqE,CAAjF;AACH,OAFD,MAEO;AACH9F,iBAAS,GAAIkP,OAAO,CAAC/J,EAAC,GAAG,CAAL,CAAP,CAAeW,GAAf,GAAsB,CAACoJ,OAAO,CAAC/J,EAAD,CAAP,CAAWW,GAAX,GAAiBoJ,OAAO,CAAC/J,EAAC,GAAG,CAAL,CAAP,CAAeW,GAAjC,IAAwC,CAA/D,GAAqE,CAAjF;AACH;;AAED,WAAK,IAAI4J,EAAC,GAAGR,OAAO,CAAC/J,EAAD,CAAP,CAAWoK,GAAxB,EAA6BG,EAAC,GAAGR,OAAO,CAAC/J,EAAC,GAAG,CAAL,CAAP,CAAeoK,GAAhD,EAAqDG,EAAC,EAAtD,EAA0D;AACtDlE,YAAI,CAACkE,EAAD,CAAJ,GAAUlE,IAAI,CAACkE,EAAD,CAAJ,GAAU1P,SAAV,GAAsB,CAAtB,GAA0B,CAApC;AACH;AACJ;;AAED,6BACOlB,MADP;AAEIkB,eAAS,EAATA;AAFJ;AAIH;AA7IoB,CAAlB,C;;;;;;;;;;;;;;;;;;;;;ACfP;;AAEA,IAAI2P,OAAJ;;AAEO,IAAMC,YAAY,GAAG;AACxB;;;;;;AAMMC,SAPkB;AAAA;AAAA;AAAA,4FAOVC,KAPU,EAOeC,gBAPf;AAAA;AAAA;AAAA;AAAA;AAAA;AAQdC,mCARc,GAQUJ,YAAY,CAACK,eAAb,CAA6BF,gBAA7B,CARV;AAAA;AAAA,qBASJzI,0EAAY,CAAC0I,qBAAD,CATR;;AAAA;AASpBL,qBAToB;AAUpBG,mBAAK,CAACI,SAAN,GAAkBP,OAAlB;AACAG,mBAAK,CAACK,YAAN,CAAmB,UAAnB,EAA+B,EAA/B;AACAL,mBAAK,CAACK,YAAN,CAAmB,OAAnB,EAA4B,EAA5B;AACAL,mBAAK,CAACK,YAAN,CAAmB,aAAnB,EAAkC,EAAlC;AAboB,+CAeb,IAAIhJ,OAAJ,CAAY,UAAAiJ,OAAO;AAAA,uBAAIN,KAAK,CAACO,gBAAN,CAAuB,gBAAvB,EAAyC,YAAM;AACzEP,uBAAK,CAACQ,IAAN;AACAF,yBAAO;AACV,iBAH6B,CAAJ;AAAA,eAAnB,EAGHG,IAHG,CAGEC,aAAa,CAACC,IAAd,CAAmB,IAAnB,EAAyBX,KAAzB,CAHF,CAfa;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAqBxBY,SArBwB,qBAqBR;AACZ,QAAMC,MAAM,GAAGhB,OAAO,IAAIA,OAAO,CAACiB,cAAR,EAA1B;;AACA,QAAID,MAAM,IAAIA,MAAM,CAACxP,MAArB,EAA6B;AACzBwP,YAAM,CAAC,CAAD,CAAN,CAAUE,IAAV;AACH;;AACDlB,WAAO,GAAG,IAAV;AACH,GA3BuB;AA6BlBmB,uBA7BkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBA8BE9J,8EAAgB,EA9BlB;;AAAA;AA8Bd+J,qBA9Bc;AAAA,gDA+BbA,OAAO,CAAClR,MAAR,CAAe;AAAA,oBAAGmR,IAAH,QAAGA,IAAH;AAAA,uBAAcA,IAAI,KAAK,YAAvB;AAAA,eAAf,CA/Ba;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAkCxBC,sBAlCwB,kCAkCO;AAC3B,QAAMC,KAAK,GAAGtB,YAAY,CAACuB,cAAb,EAAd;AACA,WAAOD,KAAK,GAAGA,KAAK,CAACnL,KAAT,GAAiB,EAA7B;AACH,GArCuB;AAuCxBoL,gBAvCwB,4BAuCP;AACb,QAAMR,MAAM,GAAGhB,OAAO,IAAIA,OAAO,CAACiB,cAAR,EAA1B;;AACA,QAAID,MAAM,IAAIA,MAAM,CAACxP,MAArB,EAA6B;AACzB,aAAOwP,MAAM,CAAC,CAAD,CAAb;AACH;;AAED,WAAO,IAAP;AACH,GA9CuB;AAgDxBV,iBAhDwB,2BAgDRF,gBAhDQ,EAgDyD;AAAA,QACvEhR,KADuE,GAClBgR,gBADkB,CACvEhR,KADuE;AAAA,QAChEC,MADgE,GAClB+Q,gBADkB,CAChE/Q,MADgE;AAAA,QACxDkJ,UADwD,GAClB6H,gBADkB,CACxD7H,UADwD;AAAA,QAC5CkJ,WAD4C,GAClBrB,gBADkB,CAC5CqB,WAD4C;AAAA,QAC/BC,QAD+B,GAClBtB,gBADkB,CAC/BsB,QAD+B;AAAA,gBAE1CtB,gBAF0C;AAAA,QAErEuB,cAFqE,SAErEA,cAFqE;AAAA,QAErDC,MAFqD,SAErDA,MAFqD;;AAI7E,QAAI,OAAOD,cAAP,KAA0B,WAA1B,IAAyCA,cAAc,GAAG,CAA9D,EAAiE;AAC7DF,iBAAW,GAAGE,cAAd;AACAhF,aAAO,CAACC,GAAR;AACH;;AAED,QAAI,OAAOgF,MAAP,KAAkB,WAAtB,EAAmC;AAC/BrJ,gBAAU,GAAGqJ,MAAb;AACAjF,aAAO,CAACC,GAAR;AACH;;AAED,QAAMyD,qBAAqB,GAAGqB,QAAQ,IAAInJ,UAAZ,GAC1B;AAAEnJ,WAAK,EAALA,KAAF;AAASC,YAAM,EAANA,MAAT;AAAiBoS,iBAAW,EAAXA,WAAjB;AAA8BC,cAAQ,EAARA;AAA9B,KAD0B,GACiB;AAAEtS,WAAK,EAALA,KAAF;AAASC,YAAM,EAANA,MAAT;AAAiBkJ,gBAAU,EAAVA,UAAjB;AAA6BkJ,iBAAW,EAAXA,WAA7B;AAA0CC,cAAQ,EAARA;AAA1C,KAD/C;AAGA,WAAO;AACHG,WAAK,EAAE,KADJ;AAEH1B,WAAK,EAAEE;AAFJ,KAAP;AAIH;AArEuB,CAArB;;AAwEP,SAASQ,aAAT,QAAmE;AAAA,MAA1CiB,UAA0C,SAA1CA,UAA0C;AAAA,MAA9BC,WAA8B,SAA9BA,WAA8B;AAC/D,SAAO,IAAIvK,OAAJ,CAAY,UAACiJ,OAAD,EAAUhJ,MAAV,EAAqB;AACpC,QAAIuK,QAAQ,GAAG,EAAf;;AAEA,aAASC,UAAT,GAAsB;AAClB,UAAID,QAAQ,GAAG,CAAf,EAAkB;AACd,YAAIF,UAAU,GAAG,EAAb,IAAmBC,WAAW,GAAG,EAArC,EAAyC;AACrC,cAAItH,IAAJ,EAA2C;AACvCkC,mBAAO,CAACC,GAAR,WAAekF,UAAf,kBAAiCC,WAAjC;AACH;;AACDtB,iBAAO;AACV,SALD,MAKO;AACHyB,gBAAM,CAACtP,UAAP,CAAkBqP,UAAlB,EAA8B,GAA9B;AACH;AACJ,OATD,MASO;AACHxK,cAAM,CAAC,iDAAD,CAAN;AACH;;AACDuK,cAAQ;AACX;;AACDC,cAAU;AACb,GAnBM,CAAP;AAoBH,C;;;;;;;;;;;;;;;;;;;;;;;ACjGD;;;AAIA,IAAME,QAAQ,GAAG;AAAE,UAAQ;AAAV,CAAjB;AACO,IAAMC,aAA4B,GAAGtS,MAAM,CAACC,IAAP,CAAYoS,QAAZ,EAAsB1G,GAAtB,CAA0B,UAAAxL,GAAG;AAAA,SAAIkS,QAAQ,CAAClS,GAAD,CAAZ;AAAA,CAA7B,CAArC;AAMA,SAAeoS,mBAAtB;AAAA;AAAA;;;;;yEAAO,iBAAmCC,GAAnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAgDC,gBAAhD,2DAAuDH,aAAvD;;AAAA,iBACC,UAAUI,IAAV,CAAeF,GAAf,CADD;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAEsBG,eAAe,CAACH,GAAD,CAFrC;;AAAA;AAEOI,kBAFP;AAAA,6CAGQC,gBAAgB,CAACD,MAAD,EAASH,IAAT,CAHxB;;AAAA;AAAA,6CAKI/K,OAAO,CAACiJ,OAAR,CAAgB,IAAhB,CALJ;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AAQA,SAASkC,gBAAT,CAA0BC,IAA1B,EAAgG;AAAA,MAAnDC,YAAmD,uEAArBT,aAAqB;AACnG,MAAMU,QAAQ,GAAG,IAAIC,QAAJ,CAAaH,IAAb,CAAjB;AACA,MAAMpR,MAAM,GAAGoR,IAAI,CAACI,UAApB;AACA,MAAMC,QAAQ,GAAGJ,YAAY,CAACxR,MAAb,CAAoB,UAAClC,MAAD,EAAS+T,WAAT,EAAyB;AAC1D,QAAMC,OAAO,GAAGrT,MAAM,CAACC,IAAP,CAAYoS,QAAZ,EAAsBzR,IAAtB,CAA2B,UAAA0S,GAAG;AAAA,aAAIjB,QAAQ,CAACiB,GAAD,CAAR,KAAkBF,WAAtB;AAAA,KAA9B,CAAhB;;AACA,QAAIC,OAAJ,EAAa;AACThU,YAAM,CAACgU,OAAD,CAAN,GAAkBD,WAAlB;AACH;;AACD,WAAO/T,MAAP;AACH,GANgB,EAMd,EANc,CAAjB;AAOA,MAAIkU,MAAM,GAAG,CAAb;;AAEA,MAAKP,QAAQ,CAACQ,QAAT,CAAkB,CAAlB,MAAyB,IAA1B,IAAoCR,QAAQ,CAACQ,QAAT,CAAkB,CAAlB,MAAyB,IAAjE,EAAwE;AACpE,WAAO,IAAP;AACH;;AAED,SAAOD,MAAM,GAAG7R,MAAhB,EAAwB;AACpB,QAAIsR,QAAQ,CAACQ,QAAT,CAAkBD,MAAlB,MAA8B,IAAlC,EAAwC;AACpC,aAAO,IAAP;AACH;;AAED,QAAME,MAAM,GAAGT,QAAQ,CAACQ,QAAT,CAAkBD,MAAM,GAAG,CAA3B,CAAf;;AACA,QAAIE,MAAM,KAAK,IAAf,EAAqB;AACjB,aAAOC,YAAY,CAACV,QAAD,EAAWO,MAAM,GAAG,CAApB,EAAuBJ,QAAvB,CAAnB;AACH,KAFD,MAEO;AACHI,YAAM,IAAI,IAAIP,QAAQ,CAACW,SAAT,CAAmBJ,MAAM,GAAG,CAA5B,CAAd;AACH;AACJ;;AAED,SAAO,IAAP;AACH;;SAEcZ,e;;;;;;;yEAAf,kBAA+BiB,GAA/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAC2BC,KAAK,CAACD,GAAD,CADhC;;AAAA;AACUE,oBADV;;AAAA,iBAEQA,QAAQ,CAACC,EAFjB;AAAA;AAAA;AAAA;;AAAA,8CAGeD,QAAQ,CAACE,WAAT,EAHf;;AAAA;AAAA,kBAMU,IAAIpM,KAAJ,CAAU,gBAAgBkM,QAAQ,CAACG,MAAnC,CANV;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AASA,SAASP,YAAT,CAAsBV,QAAtB,EAA0CkB,KAA1C,EAAyDf,QAAzD,EAAoG;AAChG,MAAI,OAAOgB,KAAP,CAAa,EAAb,EAAiBrU,IAAjB,CAAsB,UAACsU,KAAD,EAAOC,KAAP;AAAA,WAAiBrB,QAAQ,CAACQ,QAAT,CAAkBU,KAAK,GAAGG,KAA1B,MAAqCD,KAAI,CAACE,UAAL,CAAgB,CAAhB,CAAtD;AAAA,GAAtB,CAAJ,EAAqG;AACjG,WAAO,IAAP;AACH;;AAED,MAAMC,UAAU,GAAGL,KAAK,GAAG,CAA3B;AACA,MAAIM,MAAJ;;AAEA,MAAIxB,QAAQ,CAACW,SAAT,CAAmBY,UAAnB,MAAmC,MAAvC,EAA+C;AAC3CC,UAAM,GAAG,KAAT;AACH,GAFD,MAEO,IAAIxB,QAAQ,CAACW,SAAT,CAAmBY,UAAnB,MAAmC,MAAvC,EAA+C;AAClDC,UAAM,GAAG,IAAT;AACH,GAFM,MAEA;AACH,WAAO,IAAP;AACH;;AAED,MAAIxB,QAAQ,CAACW,SAAT,CAAmBY,UAAU,GAAG,CAAhC,EAAmC,CAACC,MAApC,MAAgD,MAApD,EAA4D;AACxD,WAAO,IAAP;AACH;;AAED,MAAMC,cAAc,GAAGzB,QAAQ,CAAC0B,SAAT,CAAmBH,UAAU,GAAG,CAAhC,EAAmC,CAACC,MAApC,CAAvB;;AACA,MAAIC,cAAc,GAAG,UAArB,EAAiC;AAC7B,WAAO,IAAP;AACH;;AAED,MAAMhC,IAAI,GAAGkC,QAAQ,CAAC3B,QAAD,EAAWuB,UAAU,GAAGE,cAAxB,EAAwCtB,QAAxC,EAAkDqB,MAAlD,CAArB;AACA,SAAO/B,IAAP;AACH;;AAED,SAASkC,QAAT,CAAkB3B,QAAlB,EAAsC4B,QAAtC,EAAwDC,OAAxD,EAA4FL,MAA5F,EAAmH;AAC/G,MAAMM,OAAO,GAAG9B,QAAQ,CAACW,SAAT,CAAmBiB,QAAnB,EAA6B,CAACJ,MAA9B,CAAhB;AACA,MAAM/B,IAAU,GAAG,EAAnB;;AAEA,OAAK,IAAI/M,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGoP,OAApB,EAA6BpP,CAAC,EAA9B,EAAkC;AAC9B,QAAMqP,WAAW,GAAGH,QAAQ,GAAGlP,CAAC,GAAG,EAAf,GAAoB,CAAxC;AACA,QAAM4N,GAAG,GAAGuB,OAAO,CAAC7B,QAAQ,CAACW,SAAT,CAAmBoB,WAAnB,EAAgC,CAACP,MAAjC,CAAD,CAAnB;;AACA,QAAIlB,GAAJ,EAAS;AACLb,UAAI,CAACa,GAAD,CAAJ,GAAY0B,YAAY,CAAChC,QAAD,EAAW+B,WAAX,EAAwBP,MAAxB,CAAxB;AACH;AACJ;;AAED,SAAO/B,IAAP;AACH;;AAED,SAASuC,YAAT,CAAsBhC,QAAtB,EAA0C+B,WAA1C,EAA+DP,MAA/D,EAAiG;AAC7F,MAAMhS,IAAI,GAAGwQ,QAAQ,CAACW,SAAT,CAAmBoB,WAAW,GAAG,CAAjC,EAAoC,CAACP,MAArC,CAAb;AACA,MAAMS,SAAS,GAAGjC,QAAQ,CAAC0B,SAAT,CAAmBK,WAAW,GAAG,CAAjC,EAAoC,CAACP,MAArC,CAAlB;AAEA,SAAOhS,IAAI,KAAK,CAAT,IAAcyS,SAAS,KAAK,CAA5B,GAAgCjC,QAAQ,CAACW,SAAT,CAAmBoB,WAAW,GAAG,CAAjC,EAAoC,CAACP,MAArC,CAAhC,GAA+EU,SAAtF;AACH,C;;;;;;;;;;;;;;;;;;;;;;;ACzGD,IAAMC,aAAa,GAAGxT,IAAI,CAAC4E,EAAL,GAAU,CAAhC;AAEO,IAAM6O,YAAb;AAAA;AAAA;AAYI,wBAAY7M,WAAZ,EAAsC8M,MAAtC,EAAiE;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAC7D,SAAKC,YAAL,GAAoB/M,WAApB;AACA,SAAKgN,aAAL,GAAqBhN,WAAW,CAACrK,MAAjC;AACA,SAAKsX,YAAL,GAAoBjN,WAAW,CAACkN,WAAhC;AACA,SAAKC,aAAL,GAAqBnN,WAAW,CAACoN,YAAjC;AACA,SAAKC,MAAL,GAAcrN,WAAW,CAACjJ,KAA1B;AACA,SAAKuW,OAAL,GAAetN,WAAW,CAAChJ,MAA3B;AACA,SAAKuW,QAAL,GAAgBvN,WAAW,CAACwN,OAA5B;AACA,SAAKrX,OAAL,GAAe2W,MAAM,IAAI1W,QAAQ,CAACC,aAAT,CAAuB,QAAvB,CAAzB;AACA,SAAKF,OAAL,CAAaY,KAAb,GAAqB,KAAKkW,YAA1B;AACA,SAAK9W,OAAL,CAAaa,MAAb,GAAsB,KAAKmW,aAA3B;AACA,SAAK7W,QAAL,GAAgB,KAAKH,OAAL,CAAaI,UAAb,CAAwB,IAAxB,CAAhB;AACA,SAAKkX,KAAL,GAAa,IAAI9Q,UAAJ,CAAe,KAAK0Q,MAAL,GAAc,KAAKC,OAAlC,CAAb;;AAEA,QAAIlL,IAAJ,EAA2C;AACvCkC,aAAO,CAACC,GAAR,CAAY,cAAZ,EAA4BI,IAAI,CAACC,SAAL,CAAe;AACvCpI,YAAI,EAAE;AACF3D,WAAC,EAAE,KAAKwU,MADN;AAEFvU,WAAC,EAAE,KAAKwU;AAFN,SADiC;AAKvCE,eAAO,EAAE,KAAKD,QALyB;AAMvCG,iBAAS,EAAE;AACP7U,WAAC,EAAEmH,WAAW,CAAC2N,SADR;AAEP7U,WAAC,EAAEkH,WAAW,CAAC4N;AAFR,SAN4B;AAUvCC,kBAAU,EAAE;AACRhV,WAAC,EAAE,KAAKoU,YADA;AAERnU,WAAC,EAAE,KAAKqU;AAFA;AAV2B,OAAf,CAA5B;AAeH;AACJ;AAED;;;;;;AA7CJ;AAAA;AAAA,yBAiDS3W,IAjDT,EAiDoC;AAC5B,WAAKiX,KAAL,GAAajX,IAAb;;AACA,UAAMW,KAAK,GAAG,KAAK4V,YAAL,CAAkBe,QAAlB,EAAd;;AAEA,UAAI3W,KAAJ,EAAW;AACP,aAAK4W,iBAAL;;AAEA,YAAIC,QAAJ;AACA,YAAIC,SAAS,GAAG,CAAhB;;AAEA,YAAI9W,KAAK,YAAY+W,gBAArB,EAAuC;AACnCF,kBAAQ,GAAG7W,KAAX;AACH,SAFD,MAEO;AACH6W,kBAAQ,GAAG7W,KAAK,CAACgX,KAAjB;;AAEA,cAAIhX,KAAK,CAAC+S,IAAV,EAAgB;AACZ,oBAAQ/S,KAAK,CAAC+S,IAAN,CAAWkE,WAAnB;AACI,mBAAK,CAAL;AAAQ;AACJH,2BAAS,GAAGrB,aAAZ;AACA;AACH;;AACD,mBAAK,CAAL;AAAQ;AACJqB,2BAAS,GAAG,CAACrB,aAAb;AACA;AACH;AARL;AAUH;AACJ;;AAED,YAAIqB,SAAS,KAAK,CAAlB,EAAqB;AACjB,cAAMI,SAAS,GAAG,KAAKpB,YAAL,IAAqB,CAAvC;AACA,cAAMqB,UAAU,GAAG,KAAKnB,aAAL,IAAsB,CAAzC;;AAEA,eAAK7W,QAAL,CAAciY,SAAd,CAAwBF,SAAxB,EAAmCC,UAAnC;;AACA,eAAKhY,QAAL,CAAckY,MAAd,CAAqBP,SAArB;;AACA,eAAK3X,QAAL,CAAcY,SAAd,CAAwB8W,QAAxB,EAAkC,CAACM,UAAnC,EAA+C,CAACD,SAAhD,EAA2D,KAAKlB,aAAhE,EAA+E,KAAKF,YAApF;;AACA,eAAK3W,QAAL,CAAckY,MAAd,CAAqB,CAACP,SAAtB;;AACA,eAAK3X,QAAL,CAAciY,SAAd,CAAwB,CAACF,SAAzB,EAAoC,CAACC,UAArC;AACH,SATD,MASO;AACH,eAAKhY,QAAL,CAAcY,SAAd,CAAwB8W,QAAxB,EAAkC,CAAlC,EAAqC,CAArC,EAAwC,KAAKf,YAA7C,EAA2D,KAAKE,aAAhE;AACH;;AAED,YAAMnR,SAAS,GAAG,KAAK1F,QAAL,CAAc4F,YAAd,CAA2B,KAAKqR,QAAL,CAAc1U,CAAzC,EAA4C,KAAK0U,QAAL,CAAczU,CAA1D,EAA6D,KAAKuU,MAAlE,EAA0E,KAAKC,OAA/E,EAAwF9W,IAA1G;;AAEA,YAAI,KAAKwW,aAAL,CAAmB7L,UAAvB,EAAmC;AAC/B,eAAKsN,gCAAL,CAAsCzS,SAAtC;AACH,SAFD,MAEO;AACH,eAAK0S,YAAL,CAAkB1S,SAAlB;AACH;;AAED,eAAO,IAAP;AACH,OA/CD,MA+CO;AACH,eAAO,KAAP;AACH;AACJ;AAvGL;AAAA;AAAA,wCAyGsC;AAC9B,UAAI,KAAK7F,OAAL,CAAaa,MAAb,KAAwB,KAAKmW,aAA7B,IAA8C,KAAKhX,OAAL,CAAaY,KAAb,KAAuB,KAAKkW,YAA9E,EAA4F;AACxF,YAAI7K,IAAJ,EAA2C;AACvCkC,iBAAO,CAACqK,IAAR,CAAa,kCAAb;AACH;;AACD,aAAKxY,OAAL,CAAaa,MAAb,GAAsB,KAAKmW,aAA3B;AACA,aAAKhX,OAAL,CAAaY,KAAb,GAAqB,KAAKkW,YAA1B;AACH;AACJ;AAjHL;AAAA;AAAA,qDAmH6CjR,SAnH7C,EAmHiF;AACzE,UAAM4S,QAAQ,GAAG5S,SAAS,CAAC7C,MAAV,IAAoB,CAArC;AACA,UAAM0V,QAAQ,GAAG,KAAKxB,MAAL,IAAe,CAAhC;AACA,UAAIyB,WAAW,GAAG,CAAlB;AACA,UAAIC,cAAc,GAAG,KAAK1B,MAA1B;AACA,UAAI2B,aAAa,GAAG,CAApB;;AAEA,aAAOD,cAAc,GAAGH,QAAxB,EAAkC;AAC9B,aAAK,IAAIzR,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG0R,QAApB,EAA8B1R,CAAC,EAA/B,EAAmC;AAC/B,cAAM8R,IAAI,GAAGH,WAAW,IAAI,CAA5B;AACA,cAAMI,OAAO,GAAGH,cAAc,IAAI,CAAlC;AACA,eAAKtB,KAAL,CAAWuB,aAAX,IAA4B,CACvB,QAAQhT,SAAS,CAACiT,IAAI,GAAG,CAAR,CAAjB,GAA8B,QAAQjT,SAAS,CAACiT,IAAI,GAAG,CAAR,CAA/C,GAA4D,QAAQjT,SAAS,CAACiT,IAAI,GAAG,CAAR,CAA9E,IACC,QAAQjT,SAAS,CAACiT,IAAI,GAAG,CAAR,CAAjB,GAA8B,QAAQjT,SAAS,CAACiT,IAAI,GAAG,CAAR,CAA/C,GAA4D,QAAQjT,SAAS,CAACiT,IAAI,GAAG,CAAR,CAD9E,KAEC,QAAQjT,SAAS,CAACkT,OAAO,GAAG,CAAX,CAAjB,GAAiC,QAAQlT,SAAS,CAACkT,OAAO,GAAG,CAAX,CAAlD,GAAkE,QAAQlT,SAAS,CAACkT,OAAO,GAAG,CAAX,CAFpF,KAGC,QAAQlT,SAAS,CAACkT,OAAO,GAAG,CAAX,CAAjB,GAAiC,QAAQlT,SAAS,CAACkT,OAAO,GAAG,CAAX,CAAlD,GAAkE,QAAQlT,SAAS,CAACkT,OAAO,GAAG,CAAX,CAHpF,CADwB,IAKxB,CALwB,GAKpB,CALR;AAMAF,uBAAa;AACbF,qBAAW,IAAI,CAAf;AACAC,wBAAc,IAAI,CAAlB;AACH;;AACDD,mBAAW,IAAI,KAAKzB,MAApB;AACA0B,sBAAc,IAAI,KAAK1B,MAAvB;AACH;AACJ;AA3IL;AAAA;AAAA,iCA6IyBrR,SA7IzB,EA6I6D;AACrD,UAAMmT,eAAe,GAAGnT,SAAS,CAAC7C,MAAlC;;AAEA,UAAI,KAAK6T,aAAL,IAAsB,KAAKA,aAAL,CAAmBxM,aAA7C,EAA4D;AACxD,aAAK,IAAIrD,CAAC,GAAG,CAAR,EAAWuK,CAAC,GAAG,CAApB,EAAuBvK,CAAC,GAAGgS,eAA3B,EAA4ChS,CAAC,IAAI,CAAL,EAAQuK,CAAC,EAArD,EAAyD;AACrD,eAAK+F,KAAL,CAAW/F,CAAX,IAAgB1L,SAAS,CAACmB,CAAD,CAAzB;AACH;AACJ,OAJD,MAIO;AACH,aAAK,IAAIA,EAAC,GAAG,CAAR,EAAWuK,EAAC,GAAG,CAApB,EAAuBvK,EAAC,GAAGgS,eAA3B,EAA4ChS,EAAC,IAAI,CAAL,EAAQuK,EAAC,EAArD,EAAyD;AACrD,eAAK+F,KAAL,CAAW/F,EAAX,IAAgB,QAAQ1L,SAAS,CAACmB,EAAD,CAAjB,GAAuB,QAAQnB,SAAS,CAACmB,EAAC,GAAG,CAAL,CAAxC,GAAkD,QAAQnB,SAAS,CAACmB,EAAC,GAAG,CAAL,CAAnE,GAA6E,CAA7F;AACH;AACJ;AACJ;AAzJL;;AAAA;AAAA,I;;;;;;;;;;;;;;;;;;;;;;;;;;;ACNA;AAOO,IAAMiS,WAAb;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+FAEQC,OAFR,EAGQzV,QAHR,EAIQoR,MAJR,EAKQxO,IALR,EAMQ8S,QANR;AAAA,yDA2BuBC,MA3BvB;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yFA2BQ,iBAAsBC,WAAtB;AAAA;AAAA;AAAA;AAAA;AAAA;AACa3W,6BADb,GACiB,CADjB;;AAAA;AAAA,kCACoBA,CAAC,GAAG4W,eAAe,CAACtW,MADxC;AAAA;AAAA;AAAA;;AAAA,kCAEYsW,eAAe,CAAC5W,CAAD,CAAf,KAAuB2W,WAFnC;AAAA;AAAA;AAAA;;AAGYC,2CAAe,CAACC,MAAhB,CAAuB7W,CAAvB,EAA0B,CAA1B,EAHZ,CAIY;;AACSC,6BALrB,GAKyB,CALzB;;AAAA;AAAA,kCAK4BA,CAAC,GAAG6W,SAAS,CAACxW,MAL1C;AAAA;AAAA;AAAA;;AAMsByW,qCANtB,GAMkCD,SAAS,CAAC7W,CAAD,CAAT,CAAa+W,MAAb,CAAoBF,SAAS,CAAC7W,CAAD,CAAT,CAAagX,WAAb,CAAyB,GAAzB,CAApB,CANlC;;AAAA,kCAOoBN,WAAW,CAACvF,GAAZ,CAAgB6F,WAAhB,CAA4BF,SAA5B,MAA2C,CAAC,CAPhE;AAAA;AAAA;AAAA;;AAQoBG,wCAAY,CAACjX,CAAD,CAAZ,GAAkB;AAAEqV,mCAAK,EAAEqB;AAAT,6BAAlB;AARpB;;AAAA;AAKkD1W,6BAAC,EALnD;AAAA;AAAA;;AAAA;AAAA;;AAAA;AACgDD,6BAAC,EADjD;AAAA;AAAA;;AAAA;AAAA,kCAeQ4W,eAAe,CAACtW,MAAhB,KAA2B,CAfnC;AAAA;AAAA;AAAA;;AAgBQ,gCAAIiJ,IAAJ,EAA2C;AACvCkC,qCAAO,CAACC,GAAR,CAAY,eAAZ;AACH;;AAlBT;;AAAA,kCAoBgB+K,QAAQ,KAAK,KApB7B;AAAA;AAAA;AAAA;;AAqBsBU,sCArBtB,GAqBmCD,YAAY,CAAC,CAAD,CArB/C;AAAA;AAAA,mCAsBwC/F,wEAAmB,CAACqF,OAAD,CAtB3D;;AAAA;AAsBgBW,sCAAU,CAAC9F,IAtB3B;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAyBY5F,mCAAO,CAACC,GAAR;;AAzBZ;AAAA;AA2BY3K,oCAAQ,CAACmW,YAAD,CAAR;AA3BZ;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBA3BR;AAAA;AAAA;;AA2BuBR,sBA3BvB;AAAA;AAAA;;AAQcI,yBARd,GAQ0B,IAAI9Z,KAAJ,CAAkB2G,IAAlB,CAR1B;AAScuT,4BATd,GAS6B,IAAIla,KAAJ,CAAqB2G,IAArB,CAT7B;AAUciT,+BAVd,GAUgC,IAAI5Z,KAAJ,EAVhC;;AAYQ,oBAAIyZ,QAAQ,KAAK,KAAjB,EAAwB;AACpBK,2BAAS,CAAC,CAAD,CAAT,GAAeN,OAAf;AACH,iBAFD,MAEO;AACH,uBAASlS,CAAT,GAAa,CAAb,EAAgBA,CAAC,GAAGX,IAApB,EAA0BW,CAAC,EAA3B,EAA+B;AAC3BwS,6BAAS,CAACxS,CAAD,CAAT,aAAkBkS,OAAlB,mBAAkC,CAAC,QAAQrE,MAAM,GAAG7N,CAAjB,CAAD,EAAsBvB,KAAtB,CAA4B,CAAC,CAA7B,CAAlC;AACH;AACJ;;AAED+T,yBAAS,CAACzX,OAAV,CAAkB,UAAA+R,GAAG,EAAI;AACrB,sBAAMkE,KAAK,GAAG,IAAI8B,KAAJ,EAAd;AACAR,iCAAe,CAACpY,IAAhB,CAAqB8W,KAArB;;AACAA,uBAAK,CAAC+B,MAAN,GAAe;AAAA,2BAAMX,MAAM,CAACpB,KAAD,CAAZ;AAAA,mBAAf;;AACAA,uBAAK,CAAClE,GAAN,GAAYA,GAAZ;AACH,iBALD;;AApBR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA,I;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACPA;AACA;AAGO,IAAMkG,WAAb;AAAA;AAAA;AAAA;;AAYI,yBAAc;AAAA;;AAAA;;AACV;;AADU;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAGV,UAAKhD,aAAL,GAAqB,CAArB;AACA,UAAKF,YAAL,GAAoB,CAApB;AACA,UAAKmD,QAAL,GAAgB,IAAhB;AACA,UAAKC,MAAL,GAAc,KAAd;AACA,UAAKC,WAAL,GAAmB,CAAnB;AACA,UAAKhD,OAAL,GAAe,CAAf;AACA,UAAKiD,OAAL,GAAe,IAAf;AACA,UAAKC,OAAL,GAAe,KAAf;AACA,UAAKC,OAAL,GAAe,CAAf;AACA,UAAKC,OAAL,GAAe,IAAf;AACA,UAAKC,KAAL,GAAa,CAAb;AACA,UAAKtD,MAAL,GAAc,CAAd;AAdU;AAeb;;AA3BL;AAAA;AAAA,mCAqDmB,CAAG;AArDtB;AAAA;AAAA,4BAuDkB;AACV,WAAKqD,OAAL,GAAe,IAAf;AACH;AAzDL;AAAA;AAAA,2BA2DiB;AACT,WAAKA,OAAL,GAAe,KAAf;AACH;AA7DL;AAAA;AAAA,+BAmE6C;AAAA;;AACrC,UAAIvZ,KAAgB,GAAG,IAAvB;;AAEA,UAAI,KAAKqZ,OAAL,IAAgB,CAAC,KAAKE,OAA1B,EAAmC;AAC/BvZ,aAAK,GAAG,KAAKoZ,OAAL,CAAa,KAAKD,WAAlB,CAAR;;AAEA,YAAI,KAAKA,WAAL,GAAoB,KAAKK,KAAL,GAAa,CAArC,EAAyC;AACrC,eAAKL,WAAL;AACH,SAFD,MAEO;AACH/V,oBAAU,CAAC,YAAM;AACb,kBAAI,CAAC8V,MAAL,GAAc,IAAd;;AACA,kBAAI,CAACO,OAAL,CAAa,OAAb,EAAsB,EAAtB;AACH,WAHS,EAGP,CAHO,CAAV;AAIH;AACJ;;AAED,aAAOzZ,KAAP;AACH;AApFL;AAAA;AAAA,kCAsFgC;AAAA;;AACxB,WAAKqZ,OAAL,GAAe,KAAf;AACApB,+DAAW,CAACyB,IAAZ,CAAiB,KAAKT,QAAtB,EAAgC,UAAAU,MAAM,EAAI;AACtC,cAAI,CAACP,OAAL,GAAeO,MAAf;;AAEA,gBAAQA,MAAM,CAAC,CAAD,CAAN,CAAU5G,IAAV,IAAkB4G,MAAM,CAAC,CAAD,CAAN,CAAU5G,IAAV,CAAekE,WAAzC;AACI,eAAK,CAAL;AACA,eAAK,CAAL;AAAQ;AACJ,oBAAI,CAACf,MAAL,GAAcyD,MAAM,CAAC,CAAD,CAAN,CAAU3C,KAAV,CAAgBnX,MAA9B;AACA,oBAAI,CAACsW,OAAL,GAAewD,MAAM,CAAC,CAAD,CAAN,CAAU3C,KAAV,CAAgBpX,KAA/B;AACA;AACH;;AACD;AAAS;AACL,oBAAI,CAACsW,MAAL,GAAcyD,MAAM,CAAC,CAAD,CAAN,CAAU3C,KAAV,CAAgBpX,KAA9B;AACA,oBAAI,CAACuW,OAAL,GAAewD,MAAM,CAAC,CAAD,CAAN,CAAU3C,KAAV,CAAgBnX,MAA/B;AACH;AAVL;;AAaA,cAAI,CAACiW,YAAL,GAAoB,MAAI,CAAC8D,gBAAL,GAAwB,MAAI,CAACjb,OAAL,CAAa0G,IAAb,GAAoB,MAAI,CAAC6Q,MAAL,GAAc,MAAI,CAACC,OAAnB,GAC5D,MAAI,CAACxX,OAAL,CAAa0G,IAD+C,GACxC,MAAI,CAAC6Q,MAAL,GAAc,MAAI,CAACvX,OAAL,CAAa0G,IAA3B,GAAkC,MAAI,CAAC8Q,OAAvC,GAAiD,CAD7B,GACiC,MAAI,CAACD,MADlF;AAEA,cAAI,CAACF,aAAL,GAAqB,MAAI,CAAC6D,iBAAL,GAAyB,MAAI,CAAClb,OAAL,CAAa0G,IAAb,GAAoB,MAAI,CAAC6Q,MAAL,GAAc,MAAI,CAACC,OAAnB,GAC9D,MAAI,CAACA,OAAL,GAAe,MAAI,CAACxX,OAAL,CAAa0G,IAA5B,GAAmC,MAAI,CAAC6Q,MAAxC,GAAiD,CADa,GACT,MAAI,CAACvX,OAAL,CAAa0G,IADxB,GAC+B,MAAI,CAAC8Q,OADlF;AAEA,cAAI,CAACkD,OAAL,GAAe,IAAf;AACA,cAAI,CAACF,WAAL,GAAmB,CAAnB;AACA/V,kBAAU,CAAC;AAAA,iBAAM,MAAI,CAACqW,OAAL,CAAa,WAAb,EAA0B,EAA1B,CAAN;AAAA,SAAD,EAAsC,CAAtC,CAAV;AACH,OAvBD,EAuBG,KAAKH,OAvBR,EAuBiB,KAAKE,KAvBtB,EAuB6B,KAAK7a,OAAL,CAAawZ,QAvB1C;AAwBH;AAhHL;AAAA;AAAA,wBA6B6B;AACrB,aAAO,KAAKhC,OAAZ;AACH;AA/BL;AAAA;AAAA,wBAiC4B;AACpB,aAAO,KAAKD,MAAZ;AACH;AAnCL;AAAA;AAAA,wBAqCoC;AAC5B,aAAO,KAAKvX,OAAZ;AACH,KAvCL;AAAA,sBAyCeH,MAzCf,EAyC0C;AAClC,WAAKG,OAAL,qBAAoBH,MAApB;AACA,WAAKya,QAAL,GAAgBza,MAAM,CAACsU,GAAvB;AACA,WAAK0G,KAAL,GAAahb,MAAM,CAAC2Z,QAAP,IAAmB3Z,MAAM,CAACwD,MAA1B,GAAmCxD,MAAM,CAACwD,MAA1C,GAAmD,CAAhE;;AAEA,WAAK8X,WAAL;AACH;AA/CL;AAAA;AAAA,wBAiDyB;AACjB,aAAO,KAAKZ,MAAZ;AACH;AAnDL;AAAA;AAAA,sBA+DoBa,IA/DpB,EA+DkC;AAC1B,WAAKZ,WAAL,GAAmBY,IAAnB;AACH;AAjEL;;AAAA;AAAA,EAAiCC,yDAAjC,E;;;;;;;;;;;;ACMA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SAASC,gBAAT,CAA0BC,CAA1B,EAAoD;AAChD,MAAMC,QAAQ,GAAG,IAAIzb,KAAJ,EAAjB;AACA,MAAM0b,aAAa,GAAG,IAAI1b,KAAJ,EAAtB;;AAEA,OAAK,IAAI2b,OAAO,GAAG,CAAnB,EAAsBA,OAAO,GAAGA,OAAV,IAAqBH,CAA3C,EAA8CG,OAAO,EAArD,EAAyD;AACrD,QAAIH,CAAC,GAAGG,OAAJ,KAAgB,CAApB,EAAuB;AACnBF,cAAQ,CAACja,IAAT,CAAcma,OAAd;;AACA,UAAIA,OAAO,GAAGA,OAAV,KAAsBH,CAA1B,EAA6B;AACzBE,qBAAa,CAACE,OAAd,CAAsBJ,CAAC,GAAGG,OAAJ,GAAc,CAApC;AACH;AACJ;AACJ;;AAED,SAAOF,QAAQ,CAACI,MAAT,CAAgBH,aAAhB,CAAP;AACH;;AAED,SAASI,sBAAT,CAAgC5W,CAAhC,EAA2CsW,CAA3C,EAAqE;AACjE,MAAItW,CAAC,KAAKsW,CAAV,EAAa;AACT,WAAOD,gBAAgB,CAACrW,CAAD,CAAvB;AACH;;AAED,MAAM2L,GAAG,GAAG3L,CAAC,GAAGsW,CAAJ,GAAQtW,CAAR,GAAYsW,CAAxB;AACA,MAAM5K,GAAG,GAAG1L,CAAC,GAAGsW,CAAJ,GAAQA,CAAR,GAAYtW,CAAxB;AACA,MAAMuW,QAAQ,GAAG,IAAIzb,KAAJ,EAAjB;AACA,MAAM0b,aAAa,GAAG,IAAI1b,KAAJ,EAAtB;;AAEA,OAAK,IAAI2b,OAAO,GAAG,CAAnB,EAAsBA,OAAO,GAAGA,OAAV,IAAqB/K,GAA3C,EAAgD+K,OAAO,EAAvD,EAA2D;AACvD,QAAI9K,GAAG,GAAG8K,OAAN,KAAkB,CAAlB,IAAuB/K,GAAG,GAAG+K,OAAN,KAAkB,CAA7C,EAAgD;AAC5CF,cAAQ,CAACja,IAAT,CAAcma,OAAd;AACA,UAAMI,YAAY,GAAGnL,GAAG,GAAG+K,OAAN,GAAgB,CAArC;;AACA,UAAIA,OAAO,KAAKI,YAAZ,IAA4BlL,GAAG,GAAGkL,YAAN,KAAuB,CAAvD,EAA0D;AACtDL,qBAAa,CAACE,OAAd;AACH;AACJ;AACJ;;AAED,SAAOH,QAAQ,CAACI,MAAT,CAAgBH,aAAhB,CAAP;AACH;;AAEM,SAASM,kBAAT,CAA4BzQ,SAA5B,QAAgF;AAAA,MAAtBvI,CAAsB,QAAtBA,CAAsB;AAAA,MAAnBC,CAAmB,QAAnBA,CAAmB;AACnF,MAAMgZ,QAAQ,GAAG1Y,IAAI,CAACsN,GAAL,CAAS7N,CAAC,GAAG,CAAb,EAAgBC,CAAC,GAAG,CAApB,IAAyB,CAA1C;AACA,MAAMiZ,eAAe,GAAG,CAAC,CAAD,EAAI,EAAJ,EAAQ,EAAR,EAAY,EAAZ,EAAgB,EAAhB,EAAoB,EAApB,EAAwB,EAAxB,CAAxB;AACA,MAAMC,cAAc,GAAG;AACnB,eAAW,CADQ;AAEnBC,SAAK,EAAE,CAFY;AAGnBC,UAAM,EAAE,CAHW;AAInBC,SAAK,EAAE,CAJY;AAKnB,eAAW;AALQ,GAAvB;AAOA,MAAMC,gBAAgB,GAAGJ,cAAc,CAAC5Q,SAAD,CAAd,IAA6B4Q,cAAc,CAACE,MAAf,GAAwB,CAA9E;AACA,MAAMG,WAAW,GAAGN,eAAe,CAACK,gBAAD,CAAf,GAAoC,CAAxD;AACA,MAAME,gBAAgB,GAAGR,QAAQ,GAAGO,WAAX,GAAyB,CAAlD;;AAEA,WAASE,wBAAT,CAAkCjB,QAAlC,EAAkE;AAC9D,QAAInU,CAAC,GAAG,CAAR;AACA,QAAIqV,KAAK,GAAGlB,QAAQ,CAACA,QAAQ,CAACnY,MAAT,IAAmB,CAApB,CAAR,GAAiC,CAA7C;;AAEA,WAAOgE,CAAC,GAAImU,QAAQ,CAACnY,MAAT,GAAkB,CAAvB,IAA6BmY,QAAQ,CAACnU,CAAD,CAAR,GAAcmV,gBAAlD,EAAoE;AAChEnV,OAAC;AACJ;;AACD,QAAIA,CAAC,GAAG,CAAR,EAAW;AACP,UAAI/D,IAAI,CAACI,GAAL,CAAS8X,QAAQ,CAACnU,CAAD,CAAR,GAAcmV,gBAAvB,IAA2ClZ,IAAI,CAACI,GAAL,CAAS8X,QAAQ,CAACnU,CAAC,GAAG,CAAL,CAAR,GAAkBmV,gBAA3B,CAA/C,EAA6F;AACzFE,aAAK,GAAGlB,QAAQ,CAACnU,CAAC,GAAG,CAAL,CAAR,GAAkB,CAA1B;AACH,OAFD,MAEO;AACHqV,aAAK,GAAGlB,QAAQ,CAACnU,CAAD,CAAR,GAAc,CAAtB;AACH;AACJ;;AACD,QAAImV,gBAAgB,GAAGE,KAAnB,GAA2BT,eAAe,CAACK,gBAAgB,GAAG,CAApB,CAAf,GAAwCL,eAAe,CAACK,gBAAD,CAAlF,IACAE,gBAAgB,GAAGE,KAAnB,GAA2BT,eAAe,CAACK,gBAAgB,GAAG,CAApB,CAAf,GAAwCL,eAAe,CAACK,gBAAD,CADtF,EAC0G;AACtG,aAAO;AAAEvZ,SAAC,EAAE2Z,KAAL;AAAY1Z,SAAC,EAAE0Z;AAAf,OAAP;AACH;;AACD,WAAO,IAAP;AACH;;AAED,MAAMC,gBAAgB,GAAGF,wBAAwB,CAACZ,sBAAsB,CAAC9Y,CAAD,EAAIC,CAAJ,CAAvB,CAAxB,IACrByZ,wBAAwB,CAACnB,gBAAgB,CAACU,QAAD,CAAjB,CADH,IAErBS,wBAAwB,CAACnB,gBAAgB,CAACkB,gBAAgB,GAAGD,WAApB,CAAjB,CAF5B;AAIA,SAAOI,gBAAP;AACH;AAEM,SAASC,qBAAT,CAA+B1S,WAA/B,EAAyDrK,MAAzD,EAAuF;AAC1F,MAAIoB,KAAK,GAAGiJ,WAAW,CAACjJ,KAAxB;AACA,MAAIC,MAAM,GAAGgJ,WAAW,CAAChJ,MAAzB;AACA,MAAM2b,KAAK,GAAGhd,MAAM,CAACwL,UAAP,GAAoB,CAApB,GAAwB,IAAI,CAA1C;AACA,MAAMyR,iBAAiB,GAAG5S,WAAW,CAACrK,MAAtC,CAJ0F,CAM1F;;AACA,MAAIid,iBAAiB,IAAIA,iBAAiB,CAACzS,IAA3C,EAAiD;AAC7C,QAAMA,IAAI,GAAG0S,gBAAgB,CAAC9b,KAAD,EAAQC,MAAR,EAAgB4b,iBAAiB,CAACzS,IAAlC,CAA7B;AACAH,eAAW,CAACwN,OAAZ,GAAsBrN,IAAI,CAACqN,OAA3B;AACAxN,eAAW,CAAC8S,aAAZ,CAA0B/b,KAA1B,EAAiCC,MAAjC;AACAD,SAAK,GAAGoJ,IAAI,CAACpJ,KAAb;AACAC,UAAM,GAAGmJ,IAAI,CAACnJ,MAAd;AACH;;AAED,MAAMwF,IAAI,GAAG;AACT3D,KAAC,EAAE9B,KAAK,IAAI4b,KADH;AAET7Z,KAAC,EAAE9B,MAAM,IAAI2b;AAFJ,GAAb;AAKA,MAAMvR,SAAS,GAAGyQ,kBAAkB,CAAClc,MAAM,CAACyL,SAAR,EAAmB5E,IAAnB,CAApC;;AACA,MAAI4F,IAAJ,EAA2C;AACvCkC,WAAO,CAACC,GAAR,CAAY,aAAZ,EAA2BI,IAAI,CAACC,SAAL,CAAexD,SAAf,CAA3B;AACH;;AAEDpB,aAAW,CAACjJ,KAAZ,GAAoB,CAACyF,IAAI,CAAC3D,CAAL,GAASuI,SAAS,CAACvI,CAAnB,IAAwB8Z,KAAzB,IAAkCvR,SAAS,CAACvI,CAA5C,GAAgD,CAApE;AACAmH,aAAW,CAAChJ,MAAZ,GAAqB,CAACwF,IAAI,CAAC1D,CAAL,GAASsI,SAAS,CAACtI,CAAnB,IAAwB6Z,KAAzB,IAAkCvR,SAAS,CAACtI,CAA5C,GAAgD,CAArE;;AAEA,MAAKkH,WAAW,CAACjJ,KAAZ,GAAoBqK,SAAS,CAACvI,CAA/B,KAAsC,CAAtC,IAA4CmH,WAAW,CAAChJ,MAAZ,GAAqBoK,SAAS,CAACtI,CAAhC,KAAuC,CAAtF,EAAyF;AACrF,WAAO,IAAP;AACH,GA9ByF,CAgC1F;;;AACA,QAAM,IAAIuG,KAAJ,4EAA8EtI,KAA9E,2BAAoGC,MAApG,qCAAqIoK,SAAS,CAACvI,CAA/I,EAAN;AACH;AAEM,SAASka,wBAAT,CAAkC1W,KAAlC,EAA4D;AAC/D,MAAM2W,SAAoB,GAAG;AACzB3W,SAAK,EAAE4W,UAAU,CAAC5W,KAAD,CADQ;AAEzB6W,QAAI,EAAE7W,KAAK,CAAC8W,OAAN,CAAc,GAAd,MAAuB9W,KAAK,CAAClD,MAAN,GAAe,CAAtC,GAA0C,GAA1C,GAAgDkD,KAAK,CAAC8W,OAAN,CAAc,IAAd,MAAwB9W,KAAK,CAAClD,MAAN,GAAe,CAAvC,GAA2C,IAA3C,GAAkD;AAF/E,GAA7B;AAKA,SAAO6Z,SAAP;AACH;AAEM,IAAMI,qBAAqB,GAAG;AACjC7S,QAAM,EAAE,gBAACyS,SAAD;AAAA,QAAyBhc,MAAzB,SAAyBA,MAAzB;AAAA,WAAsCgc,SAAS,CAACE,IAAV,KAAmB,GAAnB,GAC1Clc,MAAM,GAAGA,MAAM,GAAGgc,SAAS,CAAC3W,KAAnB,GAA2B,GAApC,GAA0C,CADA,GACI2W,SAAS,CAACE,IAAV,KAAmB,IAAnB,GAA0Blc,MAAM,GAAGgc,SAAS,CAAC3W,KAA7C,GAAqDrF,MAD/F;AAAA,GADyB;AAGjCsJ,MAAI,EAAE,cAAC0S,SAAD;AAAA,QAAyBjc,KAAzB,SAAyBA,KAAzB;AAAA,WAAqCic,SAAS,CAACE,IAAV,KAAmB,GAAnB,GACvCnc,KAAK,GAAGic,SAAS,CAAC3W,KAAlB,GAA0B,GAA1B,GAAgC,CADO,GACH2W,SAAS,CAACE,IAAV,KAAmB,IAAnB,GAA0BF,SAAS,CAAC3W,KAApC,GAA4C,CAD9E;AAAA,GAH2B;AAKjCgE,OAAK,EAAE,eAAC2S,SAAD;AAAA,QAAyBjc,KAAzB,SAAyBA,KAAzB;AAAA,WAAqCic,SAAS,CAACE,IAAV,KAAmB,GAAnB,GACxCnc,KAAK,GAAGA,KAAK,GAAGic,SAAS,CAAC3W,KAAlB,GAA0B,GAAlC,GAAwC,CADA,GACI2W,SAAS,CAACE,IAAV,KAAmB,IAAnB,GAA0Bnc,KAAK,GAAGic,SAAS,CAAC3W,KAA5C,GAAoDtF,KAD7F;AAAA,GAL0B;AAOjCqJ,KAAG,EAAE,aAAC4S,SAAD;AAAA,QAAyBhc,MAAzB,SAAyBA,MAAzB;AAAA,WAA8Cgc,SAAS,CAACE,IAAV,KAAmB,GAAnB,GAC/Clc,MAAM,GAAGgc,SAAS,CAAC3W,KAAnB,GAA2B,GAA3B,GAAiC,CADc,GACV2W,SAAS,CAACE,IAAV,KAAmB,IAAnB,GAA0BF,SAAS,CAAC3W,KAApC,GAA4C,CADhF;AAAA;AAP4B,CAA9B;AAWA,SAASwW,gBAAT,CAA0BQ,UAA1B,EAA8CC,WAA9C,EAAmEnT,IAAnE,EAAqF;AACxF,MAAM9E,OAAO,GAAG;AAAEtE,SAAK,EAAEsc,UAAT;AAAqBrc,UAAM,EAAEsc;AAA7B,GAAhB;AACA,MAAMC,UAKL,GAAG9b,MAAM,CAACC,IAAP,CAAYyI,IAAZ,EAAkBnH,MAAlB,CAAyB,UAAClC,MAAD,EAASc,GAAT,EAAiB;AAC1C,QAAMyE,KAAK,GAAG8D,IAAI,CAACvI,GAAD,CAAlB;;AACA,QAAM4b,MAAM,GAAGT,wBAAwB,CAAC1W,KAAD,CAAvC;;AACA,QAAMoX,UAAU,GAAGL,qBAAqB,CAACxb,GAAD,CAArB,CAA2B4b,MAA3B,EAAmCnY,OAAnC,CAAnB;;AAEAvE,UAAM,CAACc,GAAD,CAAN,GAAc6b,UAAd;AACA,WAAO3c,MAAP;AACH,GAPG,EAOD,EAPC,CALJ;AAcA,SAAO;AACH0W,WAAO,EAAE;AAAE3U,OAAC,EAAE0a,UAAU,CAACjT,IAAhB;AAAsBxH,OAAC,EAAEya,UAAU,CAACnT;AAApC,KADN;AAEHrJ,SAAK,EAAEwc,UAAU,CAAClT,KAAX,GAAmBkT,UAAU,CAACjT,IAFlC;AAGHtJ,UAAM,EAAEuc,UAAU,CAAChT,MAAX,GAAoBgT,UAAU,CAACnT;AAHpC,GAAP;AAKH,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpKM,IAAe+Q,WAAtB;AAAA;AAAA;AAUI,yBAAc;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AACV,SAAKlE,YAAL,GAAoB,CAApB;AACA,SAAKE,aAAL,GAAqB,CAArB;AACA,SAAKrX,OAAL,GAAe,IAAf;AACA,SAAK4d,WAAL,GAAmB,CAAC,WAAD,EAAc,OAAd,CAAnB;AACA,SAAKC,cAAL,GAAsB,IAAIC,GAAJ,EAAtB;AACA,SAAKrG,QAAL,GAAgB;AAAE1U,OAAC,EAAE,CAAL;AAAQC,OAAC,EAAE;AAAX,KAAhB;AACH;;AAjBL;AAAA;AAAA,kCAgDkB/B,KAhDlB,EAgDiCC,MAhDjC,EAgDuD;AAC/C,WAAKiW,YAAL,GAAoBlW,KAApB;AACA,WAAKoW,aAAL,GAAqBnW,MAArB;AACH;AAnDL;AAAA;AAAA,qCA2EqB2C,KA3ErB,EA2EoCka,QA3EpC,EA2E6DC,QA3E7D,EA2EuF;AAC/E,UAAI,KAAKJ,WAAL,CAAiBP,OAAjB,CAAyBxZ,KAAzB,MAAoC,CAAC,CAAzC,EAA4C;AACxC,YAAI,CAAC,KAAKga,cAAL,CAAoBI,GAApB,CAAwBpa,KAAxB,CAAL,EAAqC;AACjC,eAAKga,cAAL,CAAoBK,GAApB,CAAwBra,KAAxB,EAA+B,IAAI9D,KAAJ,EAA/B;AACH;;AACD,aAAK8d,cAAL,CAAoB9U,GAApB,CAAwBlF,KAAxB,EAA+BtC,IAA/B,CAAoCwc,QAApC;AACH;AACJ;AAlFL;AAAA;AAAA,yCAoF+B;AACvB,WAAKF,cAAL,CAAoBM,KAApB;AACH;AAtFL;AAAA;AAAA,4BAwFY3Z,SAxFZ,EAwF+B4Z,QAxF/B,EAwF+C;AAAA;;AACvC,UAAMC,QAAQ,GAAG,KAAKR,cAAL,CAAoB9U,GAApB,CAAwBvE,SAAxB,CAAjB;;AAEA,UAAI6Z,QAAJ,EAAc;AACVA,gBAAQ,CAACjc,OAAT,CAAiB,UAAAkc,OAAO;AAAA,iBAAIA,OAAO,CAACC,KAAR,CAAc,KAAd,EAAoBH,QAApB,CAAJ;AAAA,SAAxB;AACH;AACJ;AA9FL;AAAA;AAAA,wBAuByB;AACjB,aAAO,KAAKlD,iBAAZ;AACH,KAzBL;AAAA,sBA2Beha,MA3Bf,EA2B+B;AACvB,WAAKga,iBAAL,GAAyBha,MAAzB;AACH;AA7BL;AAAA;AAAA,wBA+BwB;AAChB,aAAO,KAAK+Z,gBAAZ;AACH,KAjCL;AAAA,sBAmCcha,KAnCd,EAmC6B;AACrB,WAAKga,gBAAL,GAAwBha,KAAxB;AACH;AArCL;AAAA;AAAA,wBAuCyB;AACjB,+BAAY,KAAKwW,QAAjB;AACH,KAzCL;AAAA,sBA2CgBC,OA3ChB,EA2CgC;AACxB,WAAKD,QAAL,CAAc1U,CAAd,GAAkB2U,OAAO,CAAC3U,CAA1B;AACA,WAAK0U,QAAL,CAAczU,CAAd,GAAkB0U,OAAO,CAAC1U,CAA1B;AACH;AA9CL;AAAA;AAAA,wBAqD+B;AACvB,aAAO,KAAKqU,aAAZ;AACH;AAvDL;AAAA;AAAA,wBAyD8B;AACtB,aAAO,KAAKF,YAAZ;AACH;AA3DL;;AAAA;AAAA,I;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACJA;AAEO,IAAMqH,UAAb;AAAA;AAAA;AAAA;;AACI,sBAAYxM,KAAZ,EAAqC;AAAA;;AACjCA,SAAK,CAACK,YAAN,CAAmB,UAAnB,EAA+B,EAA/B;AADiC,6MAE3BL,KAF2B;AAGpC;;AAJL;AAAA;AAAA,wBAMyB;AACjB,aAAO,KAAP;AACH;AARL;;AAAA;AAAA,EAAgCyM,yDAAhC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACDA;AAGO,IAAMA,WAAb;AAAA;AAAA;AAAA;;AAGI,uBAAYzM,KAAZ,EAAqC;AAAA;;AAAA;;AACjC;;AADiC;;AAGjC,UAAK0M,MAAL,GAAc1M,KAAd;AAHiC;AAIpC;;AAPL;AAAA;AAAA,iCA8BiB7H,IA9BjB,EA8B+B5D,KA9B/B,EA8BoD;AAC5C,WAAKmY,MAAL,CAAYrM,YAAZ,CAAyBlI,IAAzB,EAA+B5D,KAA/B;AACH;AAhCL;AAAA;AAAA,4BAkCkB;AACV,WAAKmY,MAAL,CAAYC,KAAZ;AACH;AApCL;AAAA;AAAA,2BAsCiB;AACT,WAAKD,MAAL,CAAYlM,IAAZ;AACH;AAxCL;AAAA;AAAA,qCAgDqB3O,KAhDrB,EAgDoCka,QAhDpC,EAgD6Da,OAhD7D,EAgDsF;AAC9E,kNAAuB/a,KAAvB,EAA8Bka,QAA9B,EAAwCa,OAAxC;;AAEA,UAAI,KAAKhB,WAAL,CAAiBP,OAAjB,CAAyBxZ,KAAzB,MAAoC,CAAC,CAAzC,EAA4C;AACxC,aAAK6a,MAAL,CAAYnM,gBAAZ,CAA6B1O,KAA7B,EAAoCka,QAApC,EAA8Ca,OAA9C;AACH;AACJ;AAtDL;AAAA;AAAA,yCAwD+B;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACH;AAjEL;AAAA;AAAA,4BAmEYpa,SAnEZ,EAmE+B4Z,QAnE/B,EAmE+C;AACvC,UAAI5Z,SAAS,KAAK,WAAlB,EAA+B;AAC3B,aAAKqa,SAAL;AACH;;AAED,yMAAcra,SAAd,EAAyB4Z,QAAzB;AACH;AAzEL;AAAA;AAAA,+BA2E6C;AACrC,aAAO,KAAKM,MAAZ;AACH;AA7EL;AAAA;AAAA,gCA+EwB;AAChB,UAAMzd,KAAK,GAAG,KAAKyd,MAAL,CAAY/K,UAA1B;AACA,UAAMzS,MAAM,GAAG,KAAKwd,MAAL,CAAY9K,WAA3B;AAEA,WAAKuD,YAAL,GAAoB,KAAK8D,gBAAL,GAChB,KAAKjb,OAAL,CAAa0G,IAAb,GAAoBzF,KAAK,GAAGC,MAAR,GAAiB,KAAKlB,OAAL,CAAa0G,IAA9B,GAAqCzF,KAAK,GAAG,KAAKjB,OAAL,CAAa0G,IAArB,GAA4BxF,MAA5B,GAAqC,CAA9F,GAAkGD,KADtG;AAEA,WAAKoW,aAAL,GAAqB,KAAK6D,iBAAL,GACjB,KAAKlb,OAAL,CAAa0G,IAAb,GAAoBzF,KAAK,GAAGC,MAAR,GAAiBA,MAAM,GAAG,KAAKlB,OAAL,CAAa0G,IAAtB,GAA6BzF,KAA7B,GAAqC,CAAtD,GAA0D,KAAKjB,OAAL,CAAa0G,IAA3F,GAAkGxF,MADtG;AAEH;AAvFL;AAAA;AAAA,wBAS6B;AACrB,aAAO,KAAKwd,MAAL,CAAY9K,WAAnB;AACH;AAXL;AAAA;AAAA,wBAa4B;AACpB,aAAO,KAAK8K,MAAL,CAAY/K,UAAnB;AACH;AAfL;AAAA;AAAA,wBAiBoC;AAC5B,aAAO,KAAK3T,OAAZ;AACH,KAnBL;AAAA,sBAqBeH,MArBf,EAqB0C;AAClC,WAAKG,OAAL,qBAAoBH,MAApB;AACA,WAAK6e,MAAL,CAAYvK,GAAZ,GAAkBtU,MAAM,CAACsU,GAAP,IAAc,EAAhC;AACH;AAxBL;AAAA;AAAA,wBA0ByB;AACjB,aAAO,KAAKuK,MAAL,CAAYI,KAAnB;AACH;AA5BL;AAAA;AAAA,sBA0CoB1D,IA1CpB,EA0CkC;AAC1B,UAAI,KAAKpb,OAAL,CAAamE,IAAb,KAAsB,YAA1B,EAAwC;AACpC,aAAKua,MAAL,CAAYK,WAAZ,GAA0B3D,IAA1B;AACH;AACJ;AA9CL;;AAAA;AAAA,EAAiCC,yDAAjC;AA0FO,IAAMmD,UAAb;AAAA;AAAA;AAAA;;AACI,sBAAYxM,KAAZ,EAAqC;AAAA;;AACjCA,SAAK,CAACK,YAAN,CAAmB,UAAnB,EAA+B,EAA/B;AADiC,6MAE3BL,KAF2B;AAGpC;;AAJL;AAAA;AAAA,wBAMyB;AACjB,aAAO,KAAP;AACH;AARL;;AAAA;AAAA,EAAgCyM,WAAhC,E;;;;;;;;;;;;AC3FA;AAAA;AAAA;AAAA;AAAA;AAAA;;;;;AAKO,SAASO,MAAT,CAAgBC,MAAhB,EAAoD;AACvD,MAAMC,EAAE,GAAGD,MAAM,CAAC,CAAD,CAAjB;AACA,MAAME,EAAE,GAAGF,MAAM,CAAC,CAAD,CAAjB;AACA,MAAMG,EAAE,GAAGH,MAAM,CAAC,CAAD,CAAjB;AACA,MAAMI,EAAE,GAAGJ,MAAM,CAAC,CAAD,CAAjB;AACA,MAAMK,WAAW,GAAGJ,EAAE,GAAGG,EAAL,GAAUD,EAAE,GAAGD,EAAnC;;AAEA,MAAI,CAACG,WAAL,EAAkB;AACd,WAAO,IAAP;AACH;;AAED,SAAO,IAAIC,YAAJ,CAAiB,CAACF,EAAE,GAAGC,WAAN,EAAmB,CAACH,EAAD,GAAMG,WAAzB,EAAsC,CAACF,EAAD,GAAME,WAA5C,EAAyDJ,EAAE,GAAGI,WAA9D,CAAjB,CAAP;AACH;AAED;;;;;;;AAMO,SAASE,mBAAT,OAA8CP,MAA9C,EAA2E;AAAA,MAA5Clc,CAA4C,QAA5CA,CAA4C;AAAA,MAAzCC,CAAyC,QAAzCA,CAAyC;AAC9E,SAAO;AACHD,KAAC,EAAEkc,MAAM,CAAC,CAAD,CAAN,GAAYlc,CAAZ,GAAgBkc,MAAM,CAAC,CAAD,CAAN,GAAYjc,CAD5B;AAEHA,KAAC,EAAEic,MAAM,CAAC,CAAD,CAAN,GAAYlc,CAAZ,GAAgBkc,MAAM,CAAC,CAAD,CAAN,GAAYjc;AAF5B,GAAP;AAIH;;AAED,SAASyc,iBAAT,CAA2BzY,YAA3B,EAAuD0Y,YAAvD,EAAyF;AACrF,MAAI,CAACA,YAAL,EAAmB;AACfA,gBAAY,GAAG,CAAf;AACH;;AAED,MAAMxZ,SAAS,GAAGc,YAAY,CAACtG,IAA/B;AACA,MAAMif,QAAQ,GAAG,IAAID,YAArB;AACA,MAAME,WAAW,GAAG,KAAKF,YAAzB;AACA,MAAMG,SAAS,GAAG,IAAIC,UAAJ,CAAeF,WAAf,CAAlB;;AAEA,OAAK,IAAIvY,CAAC,GAAGnB,SAAS,CAAC7C,MAAvB,EAA+BgE,CAAC,EAAhC,GAAqC;AACjCwY,aAAS,CAAC3Z,SAAS,CAACmB,CAAD,CAAT,IAAgBsY,QAAjB,CAAT;AACH;;AAED,SAAOE,SAAP;AACH;;AAED,SAASE,uBAAT,CAAiC/Y,YAAjC,EAA6D0Y,YAA7D,EAA4F;AACxF,MAAI,CAACA,YAAL,EAAmB;AACfA,gBAAY,GAAG,CAAf;AACH;;AAED,MAAMC,QAAQ,GAAG,IAAID,YAArB;;AACA,MAAMM,IAAI,GAAGP,iBAAiB,CAACzY,YAAD,EAAe0Y,YAAf,CAA9B;;AACA,MAAMO,GAAG,GAAG,CAAC,CAAD,CAAZ;AACA,MAAMrP,GAAG,GAAG,CAAC,KAAK8O,YAAN,IAAsB,CAAlC;;AAEA,WAASQ,EAAT,CAAYC,IAAZ,EAA0BC,GAA1B,EAA+C;AAC3C,QAAIjd,GAAG,GAAG,CAAV;;AAEA,SAAK,IAAIkE,CAAC,GAAG8Y,IAAb,EAAmB9Y,CAAC,IAAI+Y,GAAxB,EAA6B/Y,CAAC,EAA9B,EAAkC;AAC9BlE,SAAG,IAAI6c,IAAI,CAAC3Y,CAAD,CAAX;AACH;;AAED,WAAOlE,GAAP;AACH;;AAED,WAASkd,EAAT,CAAYF,IAAZ,EAA0BC,GAA1B,EAA+C;AAC3C,QAAIjd,GAAG,GAAG,CAAV;;AAEA,SAAK,IAAIkE,CAAC,GAAG8Y,IAAb,EAAmB9Y,CAAC,IAAI+Y,GAAxB,EAA6B/Y,CAAC,EAA9B,EAAkC;AAC9BlE,SAAG,IAAIkE,CAAC,GAAG2Y,IAAI,CAAC3Y,CAAD,CAAf;AACH;;AAED,WAAOlE,GAAP;AACH;;AAED,OAAK,IAAImd,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG1P,GAApB,EAAyB0P,CAAC,EAA1B,EAA8B;AAC1B,QAAMlQ,EAAE,GAAG8P,EAAE,CAAC,CAAD,EAAII,CAAJ,CAAb;AACA,QAAMjQ,EAAE,GAAG6P,EAAE,CAACI,CAAC,GAAG,CAAL,EAAQ1P,GAAR,CAAb;AACA,QAAM2P,GAAG,GAAGnQ,EAAE,GAAGC,EAAL,IAAW,CAAvB;AACA,QAAMmQ,EAAE,GAAGH,EAAE,CAAC,CAAD,EAAIC,CAAJ,CAAF,GAAWjQ,EAAtB;AACA,QAAMoQ,EAAE,GAAGJ,EAAE,CAACC,CAAC,GAAG,CAAL,EAAQ1P,GAAR,CAAF,GAAiBR,EAA5B;AACA,QAAMsQ,GAAG,GAAGF,EAAE,GAAGC,EAAjB;AACAR,OAAG,CAACK,CAAD,CAAH,GAASI,GAAG,GAAGA,GAAN,GAAYH,GAArB;AACH,GAtCuF,CAwCxF;;;AACA,MAAMre,SAAS,GAAG+d,GAAG,CAAC/c,MAAJ,CAAW,UAACyd,QAAD,EAAWjf,IAAX,EAAiBsU,KAAjB,EAAwB4K,KAAxB;AAAA,WAAkClf,IAAI,GAAGkf,KAAK,CAACD,QAAD,CAAZ,GAAyB3K,KAAzB,GAAiC2K,QAAnE;AAAA,GAAX,EAAwF,CAAxF,CAAlB;AAEA,SAAOze,SAAS,IAAIyd,QAApB;AACH;;AAEM,SAASkB,aAAT,CAAuB7Z,YAAvB,EAAmD8Z,aAAnD,EAAwF;AAC3F,MAAM5e,SAAS,GAAG6d,uBAAuB,CAAC/Y,YAAD,CAAzC;;AACA,MAAM+Z,UAAU,GAAGD,aAAa,CAACpgB,IAAjC;AAEAsG,cAAY,CAACtG,IAAb,CAAkB0B,OAAlB,CAA0B,UAACmE,KAAD,EAAQyP,KAAR,EAAkB;AACxC+K,cAAU,CAAC/K,KAAD,CAAV,GAAoBzP,KAAK,GAAGrE,SAAR,GAAoB,CAApB,GAAwB,CAA5C;AACH,GAFD;AAIA,SAAOA,SAAP;AACH;AAED;;;;;AAIO,SAASmJ,UAAT,CAAoBrE,YAApB,EAAgDga,eAAhD,EAAqF;AACxF,MAAM3I,KAAK,GAAGrR,YAAY,CAACtG,IAA3B;AACA,MAAMO,KAAK,GAAG+F,YAAY,CAACN,IAAb,CAAkB3D,CAAhC;AACA,MAAMke,QAAQ,GAAGD,eAAe,CAACtgB,IAAjC;AACA,MAAMoY,QAAQ,GAAGT,KAAK,CAAChV,MAAvB;AACA,MAAM0V,QAAQ,GAAG9X,KAAK,IAAI,CAA1B;AACA,MAAI+X,WAAW,GAAG,CAAlB;AACA,MAAIC,cAAc,GAAGhY,KAArB;AACA,MAAIigB,WAAW,GAAG,CAAlB;;AAEA,SAAOjI,cAAc,GAAGH,QAAxB,EAAkC;AAC9B,SAAK,IAAIzR,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG0R,QAApB,EAA8B1R,CAAC,EAA/B,EAAmC;AAC/B4Z,cAAQ,CAACC,WAAD,CAAR,GACK7I,KAAK,CAACW,WAAD,CAAL,GAAqBX,KAAK,CAACW,WAAW,GAAG,CAAf,CAA1B,GAA8CX,KAAK,CAACY,cAAD,CAAnD,GAAsEZ,KAAK,CAACY,cAAc,GAAG,CAAlB,CAA5E,IAAqG,CADzG;AAEAiI,iBAAW;AACXlI,iBAAW,IAAI,CAAf;AACAC,oBAAc,IAAI,CAAlB;AACH;;AACDD,eAAW,IAAI/X,KAAf;AACAgY,kBAAc,IAAIhY,KAAlB;AACH;AACJ,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrID;AACA;AACA;AACA;AAGA;AAEA;AACA;AACA;AACA;AAcA,IAAMkgB,yBAAyB,GAAG,GAAlC;AAEO,IAAMC,cAAb;AAAA;AAAA;AAgBI,0BAAYjV,iBAAZ,EAA6CtM,MAA7C,EAA2E;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AACvE,SAAKG,OAAL,GAAeH,MAAf;AACA,SAAKuM,kBAAL,GAA0BD,iBAA1B;AACA,SAAKkV,WAAL,GAAmB;AAAEte,OAAC,EAAE,CAAL;AAAQC,OAAC,EAAE;AAAX,KAAnB;;AAEA,SAAKse,YAAL;;AACA,SAAKC,WAAL;AACH;;AAvBL;AAAA;AAAA,6BAyBa;AACL,UAAI,KAAKvhB,OAAL,CAAaqL,UAAjB,EAA6B;AACzBA,iFAAU,CAAC,KAAKe,kBAAN,EAA0B,KAAKoV,oBAA/B,CAAV;AACH;;AAED,WAAKC,cAAL;;AACA,UAAMC,YAAY,GAAG,KAAKC,YAAL,EAArB,CANK,CAOL;;;AACA,UAAID,YAAY,CAACre,MAAb,GAAsB,KAAKge,WAAL,CAAiBte,CAAjB,GAAqB,KAAKse,WAAL,CAAiBre,CAAtC,GAA0C,IAApE,EAA0E;AACtE,eAAO,IAAP;AACH,OAVI,CAYL;;;AACA,UAAM4e,QAAQ,GAAG,KAAKC,2BAAL,CAAiCH,YAAjC,CAAjB;;AACA,UAAIE,QAAQ,GAAG,CAAf,EAAkB;AACd,eAAO,IAAP;AACH,OAhBI,CAkBL;;;AACA,UAAME,SAAS,GAAG,KAAKC,0BAAL,CAAgCH,QAAhC,CAAlB;;AACA,UAAIE,SAAS,CAACze,MAAV,KAAqB,CAAzB,EAA4B;AACxB,eAAO,IAAP;AACH;;AAED,UAAM6J,KAAK,GAAG,KAAK8U,UAAL,CAAgBF,SAAhB,EAA2BF,QAA3B,CAAd;;AACA,aAAO1U,KAAP;AACH;AAnDL;AAAA;AAAA,mCAqDiC;AACzB,UAAI,KAAKlN,OAAL,CAAaqL,UAAjB,EAA6B;AACzB,aAAKmW,oBAAL,GAA4B,IAAI/a,kEAAJ,CAAiB;AACzC1D,WAAC,EAAE,KAAKqJ,kBAAL,CAAwB1F,IAAxB,CAA6B3D,CAA7B,GAAiC,CAAjC,GAAqC,CADC;AAEzCC,WAAC,EAAE,KAAKoJ,kBAAL,CAAwB1F,IAAxB,CAA6B1D,CAA7B,GAAiC,CAAjC,GAAqC;AAFC,SAAjB,CAA5B;AAIH,OALD,MAKO;AACH,aAAKwe,oBAAL,GAA4B,KAAKpV,kBAAjC;AACH;;AAED,WAAK6V,UAAL,GAAkBlG,oFAAkB,CAAC,KAAK/b,OAAL,CAAasL,SAAd,EAAyB,KAAKkW,oBAAL,CAA0B9a,IAAnD,CAApC;AAEA,WAAK2a,WAAL,CAAiBte,CAAjB,GAAqB,KAAKye,oBAAL,CAA0B9a,IAA1B,CAA+B3D,CAA/B,GAAmC,KAAKkf,UAAL,CAAgBlf,CAAnD,GAAuD,CAA5E;AACA,WAAKse,WAAL,CAAiBre,CAAjB,GAAqB,KAAKwe,oBAAL,CAA0B9a,IAA1B,CAA+B1D,CAA/B,GAAmC,KAAKif,UAAL,CAAgBjf,CAAnD,GAAuD,CAA5E;AAEA,WAAKkf,mBAAL,GAA2B,IAAIzb,kEAAJ,CAAiB,KAAK+a,oBAAL,CAA0B9a,IAA3C,EAAiDmQ,SAAjD,EAA4DhQ,UAA5D,EAAwE,KAAxE,CAA3B;AAEA,WAAKsb,kBAAL,GAA0B,IAAI1b,kEAAJ,CAAiB,KAAKwb,UAAtB,EAAkCpL,SAAlC,EAA6C9W,KAA7C,EAAoD,IAApD,CAA1B;AAEA,UAAMqiB,iBAAiB,GAAG,IAAIC,WAAJ,CAAgB,KAAK,IAArB,CAA1B;AACA,WAAKC,gBAAL,GAAwB,IAAI7b,kEAAJ,CAAiB,KAAKwb,UAAtB,EAAkC,IAAIpb,UAAJ,CAAeub,iBAAf,EAAkC,CAAlC,EAAqC,KAAKH,UAAL,CAAgBlf,CAAhB,GAAoB,KAAKkf,UAAL,CAAgBjf,CAAzE,CAAlC,CAAxB;AACA,WAAKuf,iBAAL,GAAyB,IAAI9b,kEAAJ,CAAiB,KAAKwb,UAAtB,EACrB,IAAIpb,UAAJ,CAAeub,iBAAf,EAAkC,KAAKH,UAAL,CAAgBlf,CAAhB,GAAoB,KAAKkf,UAAL,CAAgBjf,CAApC,GAAwC,CAA1E,EAA6E,KAAKif,UAAL,CAAgBlf,CAAhB,GAAoB,KAAKkf,UAAL,CAAgBjf,CAAjH,CADqB,EAErB6T,SAFqB,EAEV,IAFU,CAAzB;AAGA,WAAK2L,aAAL,GAAqBC,8DAAY,CAC5B,OAAO1O,MAAP,KAAkB,WAAnB,GAAkCA,MAAlC,GAA4C,OAAO2O,IAAP,KAAgB,WAAjB,GAAgCA,IAAhC,GAAuCC,MADrD,EAE7B;AAAEjc,YAAI,EAAE,KAAKub,UAAL,CAAgBlf;AAAxB,OAF6B,EAG7Bqf,iBAH6B,CAAjC;AAMA,UAAM1b,IAAI,GAAG;AACT3D,SAAC,EAAG,KAAKye,oBAAL,CAA0B9a,IAA1B,CAA+B3D,CAA/B,GAAmC,KAAKuf,gBAAL,CAAsB5b,IAAtB,CAA2B3D,CAA/D,GAAoE,CAD9D;AAETC,SAAC,EAAG,KAAKwe,oBAAL,CAA0B9a,IAA1B,CAA+B1D,CAA/B,GAAmC,KAAKsf,gBAAL,CAAsB5b,IAAtB,CAA2B1D,CAA/D,GAAoE;AAF9D,OAAb;AAIA,WAAK4f,eAAL,GAAuB,IAAInc,kEAAJ,CAAiBC,IAAjB,EAAuBmQ,SAAvB,EAAkCiJ,UAAlC,EAA8C,IAA9C,CAAvB;AACA,WAAK+C,UAAL,GAAkB,IAAIpc,kEAAJ,CAAiBC,IAAjB,EAAuBmQ,SAAvB,EAAkCA,SAAlC,EAA6C,IAA7C,CAAlB;AACA,WAAKiM,iBAAL,GAAyB,IAAI/iB,KAAJ,CAAiB,KAAK6iB,eAAL,CAAqBliB,IAArB,CAA0B2C,MAA3C,CAAzB;AACH;AA1FL;AAAA;AAAA,kCA4F0B;AAClB,UAAI,KAAKrD,OAAL,CAAa+iB,SAAb,IAA0B,OAAOziB,QAAP,KAAoB,WAAlD,EAA+D;AAC3D;AACH;;AAED,UAAM0W,MAAM,GAAG1W,QAAQ,CAACC,aAAT,CAAuB,QAAvB,CAAf;AACAyW,YAAM,CAACtK,SAAP,GAAmB,cAAnB;AACAsK,YAAM,CAAC/V,KAAP,GAAe,KAAKihB,mBAAL,CAAyBxb,IAAzB,CAA8B3D,CAA7C;AACAiU,YAAM,CAAC9V,MAAP,GAAgB,KAAKghB,mBAAL,CAAyBxb,IAAzB,CAA8B1D,CAA9C;;AACA,UAAIsJ,KAAA,IAAyC,KAAKtM,OAAL,CAAa+K,KAAtD,IAA+D,KAAK/K,OAAL,CAAa+K,KAAb,CAAmBQ,UAAtF,EAAkG;AAC9FjL,gBAAQ,CAACkM,aAAT,CAAuB,QAAvB,EAAiCG,WAAjC,CAA6CqK,MAA7C;AACH;;AACD,WAAKgM,cAAL,GAAsBhM,MAAM,CAACvW,UAAP,CAAkB,IAAlB,CAAtB;AACH;AAED;;;;;AA3GJ;AAAA;AAAA,oCA+G4BwiB,OA/G5B,EA+GwD;AAAA;;AAChD,UAAMlY,KAAK,GAAGuB,KAAA,IAAyC,KAAKtM,OAAL,CAAa+K,KAApE;AACA,UAAImY,UAAU,GAAGD,OAAO,CAAC/f,MAAR,CAAe,UAACC,GAAD,QAAuB;AAAA,YAAfsO,GAAe,QAAfA,GAAe;AAAA,YAAV3O,GAAU,QAAVA,GAAU;;AACnD,YAAIiI,KAAK,IAAIA,KAAK,CAACS,WAAnB,EAAgC;AAC5B;AACA,eAAI,CAAC2X,SAAL,CAAe1R,GAAf,EAAoB,KAAI,CAAC6Q,gBAAL,CAAsB5b,IAA1C,EAAgD,KAAhD,EAAuD,CAAvD;AACH;;AAED,eAAOvD,GAAG,GAAGL,GAAb;AACH,OAPgB,EAOd,CAPc,IAOTmgB,OAAO,CAAC5f,MAPhB;AASA6f,gBAAU,GAAG,CAACA,UAAU,GAAG,GAAb,GAAmB5f,IAAI,CAAC4E,EAAxB,GAA6B,EAA9B,IAAoC,GAApC,GAA0C,EAAvD;;AACA,UAAIgb,UAAU,GAAG,CAAjB,EAAoB;AAChBA,kBAAU,IAAI,GAAd;AACH;;AACDA,gBAAU,GAAG,CAAC,MAAMA,UAAP,IAAqB5f,IAAI,CAAC4E,EAA1B,GAA+B,GAA5C;AAEA,UAAM3E,GAAG,GAAGD,IAAI,CAACC,GAAL,CAAS2f,UAAT,CAAZ;AACA,UAAM1f,GAAG,GAAGF,IAAI,CAACE,GAAL,CAAS0f,UAAT,CAAZ;AACA,UAAMjE,MAAM,GAAG,IAAIM,YAAJ,CAAiB,CAAChc,GAAD,EAAMC,GAAN,EAAW,CAACA,GAAZ,EAAiBD,GAAjB,CAAjB,CAAf;AACA,UAAM6f,aAAa,GAAGpE,qEAAM,CAACC,MAAD,CAA5B,CApBgD,CAsBhD;;AACAgE,aAAO,CAAC7gB,OAAR,CAAgB,iBAAa;AAAA,YAAVmL,GAAU,SAAVA,GAAU;;AACzB,aAAK,IAAIqE,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AACxBrE,aAAG,CAACqE,CAAD,CAAH,GAAS4N,kFAAmB,CAACjS,GAAG,CAACqE,CAAD,CAAJ,EAASqN,MAAT,CAA5B;AACH;;AAED,YAAIlU,KAAK,IAAIA,KAAK,CAACe,cAAN,CAAqBC,eAAlC,EAAmD;AAC/C,eAAI,CAAC0B,SAAL,CAAeF,GAAf,EAAoB,SAApB,EAA+B,CAA/B;AACH;AACJ,OARD;AAUA,UAAI8V,IAAI,GAAG,KAAKnB,mBAAL,CAAyBxb,IAAzB,CAA8B3D,CAAzC;AACA,UAAIugB,IAAI,GAAG,KAAKpB,mBAAL,CAAyBxb,IAAzB,CAA8B1D,CAAzC;AACA,UAAIugB,IAAI,GAAG,CAACF,IAAZ;AACA,UAAIG,IAAI,GAAG,CAACF,IAAZ,CApCgD,CAsChD;;AACAL,aAAO,CAAC7gB,OAAR,CAAgB,iBAAa;AAAA,YAAVmL,GAAU,SAAVA,GAAU;AACzBA,WAAG,CAACnL,OAAJ,CAAY,iBAAc;AAAA,cAAXW,CAAW,SAAXA,CAAW;AAAA,cAARC,CAAQ,SAARA,CAAQ;;AACtB,cAAID,CAAC,GAAGsgB,IAAR,EAAc;AACVA,gBAAI,GAAGtgB,CAAP;AACH;;AACD,cAAIA,CAAC,GAAGwgB,IAAR,EAAc;AACVA,gBAAI,GAAGxgB,CAAP;AACH;;AACD,cAAIC,CAAC,GAAGsgB,IAAR,EAAc;AACVA,gBAAI,GAAGtgB,CAAP;AACH;;AACD,cAAIA,CAAC,GAAGwgB,IAAR,EAAc;AACVA,gBAAI,GAAGxgB,CAAP;AACH;AACJ,SAbD;AAcH,OAfD;AAiBA,UAAIuK,GAAQ,GAAG,CAAC;AAAExK,SAAC,EAAEsgB,IAAL;AAAWrgB,SAAC,EAAEsgB;AAAd,OAAD,EAAuB;AAAEvgB,SAAC,EAAEwgB,IAAL;AAAWvgB,SAAC,EAAEsgB;AAAd,OAAvB,EAA6C;AAAEvgB,SAAC,EAAEwgB,IAAL;AAAWvgB,SAAC,EAAEwgB;AAAd,OAA7C,EAAmE;AAAEzgB,SAAC,EAAEsgB,IAAL;AAAWrgB,SAAC,EAAEwgB;AAAd,OAAnE,CAAf;;AAEA,UAAIzY,KAAK,IAAIA,KAAK,CAACe,cAAN,CAAqBE,kBAAlC,EAAsD;AAClD,aAAKyB,SAAL,CAAeF,GAAf,EAAoB,SAApB,EAA+B,CAA/B;AACH,OA5D+C,CA8DhD;;;AACAA,SAAG,GAAGA,GAAG,CAACD,GAAJ,CAAQ,UAAAmW,MAAM;AAAA,eAAIjE,kFAAmB,CAACiE,MAAD,EAASL,aAAT,CAAvB;AAAA,OAAd,CAAN;;AAEA,UAAIrY,KAAK,IAAIA,KAAK,CAACe,cAAN,CAAqBG,MAAlC,EAA0C;AACtC,aAAKwB,SAAL,CAAeF,GAAf,EAAoB,SAApB,EAA+B,CAA/B;AACH;;AAED,UAAI,KAAKvN,OAAL,CAAaqL,UAAjB,EAA6B;AACzB;AACAkC,WAAG,GAAGA,GAAG,CAACD,GAAJ,CAAQ;AAAA,cAAGvK,CAAH,SAAGA,CAAH;AAAA,cAAMC,CAAN,SAAMA,CAAN;AAAA,iBAAe;AAAED,aAAC,EAAEA,CAAC,GAAG,CAAT;AAAYC,aAAC,EAAEA,CAAC,IAAI;AAApB,WAAf;AAAA,SAAR,CAAN;AACH;;AAED,aAAOuK,GAAP;AACH;AAED;;;;AA5LJ;AAAA;AAAA,qCA+LmC;AAC3BsT,kFAAa,CAAC,KAAKW,oBAAN,EAA4B,KAAKU,mBAAjC,CAAb;;AACA,WAAKA,mBAAL,CAAyBwB,UAAzB;;AAEA,UAAIpX,KAAA,IAAyC,KAAKtM,OAAL,CAAa+K,KAAtD,IAA+D,KAAK/K,OAAL,CAAa+K,KAAb,CAAmBQ,UAAtF,EAAkG;AAC9F,aAAK2W,mBAAL,CAAyByB,IAAzB,CAA8B,KAAKX,cAAnC,EAAmD,GAAnD;AACH;AACJ;AAED;;;;AAxMJ;AAAA;AAAA,mCA2MyC;AACjC,UAAMjY,KAAK,GAAGuB,KAAA,IAAyC,KAAKtM,OAAL,CAAa+K,KAApE;AACA,UAAI2W,YAAY,GAAG,IAAI3hB,KAAJ,EAAnB;;AAEA,WAAK,IAAIsH,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,KAAKga,WAAL,CAAiBte,CAArC,EAAwCsE,CAAC,EAAzC,EAA6C;AACzC,aAAK,IAAIuK,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,KAAKyP,WAAL,CAAiBre,CAArC,EAAwC4O,CAAC,EAAzC,EAA6C;AACzC,cAAM7O,CAAC,GAAG,KAAKuf,gBAAL,CAAsB5b,IAAtB,CAA2B3D,CAA3B,GAA+BsE,CAAzC;AACA,cAAMrE,CAAC,GAAG,KAAKsf,gBAAL,CAAsB5b,IAAtB,CAA2B1D,CAA3B,GAA+B4O,CAAzC,CAFyC,CAIzC;;AACA,eAAKgS,YAAL,CAAkB7gB,CAAlB,EAAqBC,CAArB,EALyC,CAOzC;;;AACA,eAAKuf,iBAAL,CAAuBmB,UAAvB;;AACA,eAAKvB,kBAAL,CAAwBzhB,IAAxB,CAA6BoG,IAA7B,CAAkC,CAAlC;;AACA,cAAM+c,UAAU,GAAG,IAAIC,sDAAJ,CAAe,KAAKvB,iBAApB,EAAuC,KAAKJ,kBAA5C,CAAnB;AACA,cAAM4B,YAAY,GAAGF,UAAU,CAACG,SAAX,CAAqB,CAArB,CAArB;;AAEA,cAAIjZ,KAAK,IAAIA,KAAK,CAACY,UAAnB,EAA+B;AAC3B,iBAAKwW,kBAAL,CAAwB8B,OAAxB,CAAgC,KAAKjB,cAArC,EAAqD,MAAMe,YAAY,CAACG,KAAnB,GAA2B,CAAhF,EAAmFnhB,CAAnF,EAAsFC,CAAtF;AACH,WAfwC,CAiBzC;;;AACA,cAAMf,OAAO,GAAG,KAAKkgB,kBAAL,CAAwBlgB,OAAxB,CAAgC8hB,YAAY,CAACG,KAA7C,CAAhB,CAlByC,CAoBzC;;;AACA,cAAMC,KAAK,GAAG,KAAKC,cAAL,CAAoBniB,OAApB,EAA6B2P,CAAC,GAAG,KAAKyP,WAAL,CAAiBte,CAArB,GAAyBsE,CAAtD,EAAyDtE,CAAzD,EAA4DC,CAA5D,CAAd;;AACA,cAAImhB,KAAJ,EAAW;AACPzC,wBAAY,CAACngB,IAAb,CAAkB4iB,KAAlB;;AAEA,gBAAIpZ,KAAK,IAAIA,KAAK,CAACU,gBAAnB,EAAqC;AACjC,mBAAK0X,SAAL,CAAegB,KAAK,CAAC1S,GAArB,EAA0B,KAAK6Q,gBAAL,CAAsB5b,IAAhD,EAAsD,SAAtD,EAAiE,CAAjE;AACH;AACJ;AACJ;AACJ;;AAED,aAAOgb,YAAP;AACH;AAED;;;;;;AAnPJ;AAAA;AAAA,+CAwPuCE,QAxPvC,EAwPwE;AAChE,UAAIyC,SAAS,GAAG,IAAItkB,KAAJ,CAAkB6hB,QAAlB,EAA4B9a,IAA5B,CAAiC,CAAjC,CAAhB;;AAEA,WAAK8b,eAAL,CAAqBliB,IAArB,CAA0B0B,OAA1B,CAAkC,UAAC1B,IAAD,EAAkB;AAChD,YAAIA,IAAI,GAAG,CAAX,EAAc;AACV2jB,mBAAS,CAAC3jB,IAAI,GAAG,CAAR,CAAT;AACH;AACJ,OAJD,EAHgE,CAShE;;;AACA,UAAMohB,SAAS,GAAGuC,SAAS,CAAC/W,GAAV,CAAc,UAAC/G,KAAD,EAAQyP,KAAR;AAAA,eAAmB;AAAEzP,eAAK,EAALA,KAAF;AAASyP,eAAK,EAALA;AAAT,SAAnB;AAAA,OAAd,EACbjU,MADa,CACN;AAAA,YAAGwE,KAAH,SAAGA,KAAH;AAAA,eAAeA,KAAK,IAAI,CAAxB;AAAA,OADM,EACqB+d,IADrB,CAC0B,UAACxT,CAAD,EAAI1L,CAAJ;AAAA,eAAUA,CAAC,CAACmB,KAAF,GAAUuK,CAAC,CAACvK,KAAtB;AAAA,OAD1B,EACuD+G,GADvD,CAC2D;AAAA,YAAG0I,KAAH,SAAGA,KAAH;AAAA,eAAeA,KAAK,GAAG,CAAvB;AAAA,OAD3D,CAAlB;AAGA,aAAO8L,SAAP;AACH;AAED;;;;AAxQJ;AAAA;AAAA,+BA2QuBA,SA3QvB,EA2QiDF,QA3QjD,EA2Q+E;AAAA;;AACvE,UAAM1U,KAAK,GAAG,IAAInN,KAAJ,EAAd;AACA,UAAM8L,wBAAwB,GAAGS,KAAA,IAC7B,KAAKtM,OAAL,CAAa+K,KADgB,IACP,KAAK/K,OAAL,CAAa+K,KAAb,CAAmBc,wBAD7C;AAGAiW,eAAS,CAAC1f,OAAV,CAAkB,UAAA6F,KAAK,EAAI;AACvB,YAAMgb,OAAO,GAAG,IAAIljB,KAAJ,EAAhB;;AAEA,cAAI,CAAC6iB,eAAL,CAAqBliB,IAArB,CAA0B0B,OAA1B,CAAkC,UAAC1B,IAAD,EAAesV,KAAf,EAAiC;AAC/D,cAAItV,IAAI,KAAKuH,KAAb,EAAoB;AAChBgb,mBAAO,CAAC1hB,IAAR,CAAa,MAAI,CAACuhB,iBAAL,CAAuB9M,KAAvB,CAAb;AACH;AACJ,SAJD;;AAMA,YAAMzI,GAAG,GAAG,MAAI,CAACgX,eAAL,CAAqBtB,OAArB,CAAZ;;AAEA,YAAI1V,GAAJ,EAAS;AACLL,eAAK,CAAC3L,IAAN,CAAWgM,GAAX;;AAEA,cAAI1B,wBAAJ,EAA8B;AAC1B;AACA,gBAAMlH,GAAQ,GAAG,CAAEsD,KAAK,IAAI2Z,QAAQ,GAAG,CAAf,CAAN,GAA2B,GAA5B,EAAiC,CAAjC,EAAoC,CAApC,CAAjB;AACA,gBAAMhd,GAAQ,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAjB;AACAF,2EAAO,CAACC,GAAD,EAAMC,GAAN,CAAP;AAEA,gBAAMY,KAAK,iBAAUZ,GAAG,CAAC4f,IAAJ,CAAS,GAAT,CAAV,MAAX;AAEAvB,mBAAO,CAAC7gB,OAAR,CAAgB;AAAA,kBAAGqP,GAAH,SAAGA,GAAH;AAAA,qBAAa,MAAI,CAAC0R,SAAL,CAAe1R,GAAf,EAAoB,MAAI,CAAC6Q,gBAAL,CAAsB5b,IAA1C,EAAgDlB,KAAhD,EAAuD,CAAvD,CAAb;AAAA,aAAhB;AACH;AACJ;AACJ,OAzBD;AA2BA,aAAO0H,KAAP;AACH;AAED;;;;;AA9SJ;AAAA;AAAA,oCAkT4BjL,OAlT5B,EAkTmE;AAC3D,UAAME,QAAQ,GAAGH,uDAAO,CAACyiB,UAAR,CAAmBxiB,OAAnB,EAA4Bkf,yBAA5B,CAAjB;AACA,UAAMuD,UAAU,GAAGviB,QAAQ,CAACe,MAAT,CAAgB,UAACoH,GAAD,EAAM5I,IAAN,EAAe;AAC9C,YAAMwiB,KAAK,GAAGxiB,IAAI,CAACO,OAAL,CAAaoB,MAA3B;AACA,eAAO6gB,KAAK,GAAG5Z,GAAG,CAAC4Z,KAAZ,GAAoB;AAAExiB,cAAI,EAAJA,IAAF;AAAQwiB,eAAK,EAALA;AAAR,SAApB,GAAsC5Z,GAA7C;AACH,OAHkB,EAGhB;AAAE5I,YAAI,EAAE;AAAEO,iBAAO,EAAE;AAAX,SAAR;AAAyBiiB,aAAK,EAAE;AAAhC,OAHgB,CAAnB;AAIA,UAAMljB,MAAM,GAAG0jB,UAAU,CAAChjB,IAAX,CAAgBO,OAA/B;AAEA,aAAOjB,MAAP;AACH;AA3TL;AAAA;AAAA,iCA6TyB+B,CA7TzB,EA6ToCC,CA7TpC,EA6TqD;AAC7C,WAAKkf,mBAAL,CAAyByC,cAAzB,CAAwC,KAAKrC,gBAA7C,EAA+Dvf,CAA/D,EAAkEC,CAAlE;;AACA,WAAKwf,aAAL,CAAmBoC,WAAnB,GAF6C,CAI7C;;;AACA,UAAItY,KAAA,IAAyC,KAAKtM,OAAL,CAAa+K,KAAtD,IAA+D,KAAK/K,OAAL,CAAa+K,KAAb,CAAmBW,YAAtF,EAAoG;AAChG,aAAK6W,iBAAL,CAAuB0B,OAAvB,CAA+B,KAAKjB,cAApC,EAAoD,GAApD,EAAyDjgB,CAAzD,EAA4DC,CAA5D;AACH;AACJ;AAED;;;;;;;;;AAvUJ;AAAA;AAAA,mCA+U2Bf,OA/U3B,EA+UmD+T,KA/UnD,EA+UkEjT,CA/UlE,EA+U6EC,CA/U7E,EA+U+F;AACvF,UAAIf,OAAO,CAACoB,MAAR,GAAiB,CAArB,EAAwB;AACpB,YAAMwhB,kBAAkB,GAAGvhB,IAAI,CAACwhB,IAAL,CAAU,KAAK7C,UAAL,CAAgBlf,CAAhB,GAAoB,CAA9B,CAA3B,CADoB,CAEpB;;AACA,YAAMgiB,eAAe,GAAG9iB,OAAO,CAACF,MAAR,CAAe,UAAAM,MAAM;AAAA,iBAAIA,MAAM,CAACmF,GAAP,GAAaqd,kBAAjB;AAAA,SAArB,CAAxB,CAHoB,CAKpB;;AACA,YAAIE,eAAe,CAAC1hB,MAAhB,GAAyB,CAA7B,EAAgC;AAC5B,cAAM2hB,eAAe,GAAG,KAAKC,eAAL,CAAqBF,eAArB,CAAxB;;AACA,cAAM1hB,MAAM,GAAG2hB,eAAe,CAAC3hB,MAAhB,GAAyB,CAAxC,CAF4B,CAI5B;;AACA,cAAIA,MAAM,GAAG,CAAT,IAAeA,MAAM,IAAI,CAAX,IAAiB0hB,eAAe,CAAC1hB,MAAhB,GAAyB,CAAxD,IAA8DA,MAAM,IAAI,CAAX,GAAgBpB,OAAO,CAACoB,MAAzF,EAAiG;AAC7F;AACA,gBAAMP,GAAG,GAAGkiB,eAAe,CAAC9hB,MAAhB,CAAuB,UAACC,GAAD,EAAcd,MAAd;AAAA,qBAAiCc,GAAG,GAAGd,MAAM,CAACS,GAA9C;AAAA,aAAvB,EAA0E,CAA1E,IAA+EO,MAA3F;AAEA,mBAAO;AACH2S,mBAAK,EAALA,KADG;AAEHvE,iBAAG,EAAE;AAAE1O,iBAAC,EAADA,CAAF;AAAKC,iBAAC,EAADA;AAAL,eAFF;AAGHuK,iBAAG,EAAE,CACD;AAAExK,iBAAC,EAADA,CAAF;AAAKC,iBAAC,EAADA;AAAL,eADC,EAED;AAAED,iBAAC,EAAEA,CAAC,GAAG,KAAKuf,gBAAL,CAAsB5b,IAAtB,CAA2B3D,CAApC;AAAuCC,iBAAC,EAADA;AAAvC,eAFC,EAGD;AAAED,iBAAC,EAAEA,CAAC,GAAG,KAAKuf,gBAAL,CAAsB5b,IAAtB,CAA2B3D,CAApC;AAAuCC,iBAAC,EAAEA,CAAC,GAAG,KAAKsf,gBAAL,CAAsB5b,IAAtB,CAA2B1D;AAAzE,eAHC,EAID;AAAED,iBAAC,EAADA,CAAF;AAAKC,iBAAC,EAAEA,CAAC,GAAG,KAAKsf,gBAAL,CAAsB5b,IAAtB,CAA2B1D;AAAvC,eAJC,CAHF;AASHf,qBAAO,EAAE+iB,eATN;AAUHliB,iBAAG,EAAHA,GAVG;AAWHC,eAAC,EAAEO,IAAI,CAACC,GAAL,CAAST,GAAT,CAXA;AAYHE,eAAC,EAAEM,IAAI,CAACE,GAAL,CAASV,GAAT;AAZA,aAAP;AAcH;AACJ;AACJ;;AAED,aAAO,IAAP;AACH;AAlXL;AAAA;AAAA,uCAoXuC;AAC/B,WAAK,IAAIuE,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,KAAKub,eAAL,CAAqBliB,IAArB,CAA0B2C,MAA9C,EAAsDgE,CAAC,EAAvD,EAA2D;AACvD,YAAI,KAAKub,eAAL,CAAqBliB,IAArB,CAA0B2G,CAA1B,MAAiC,CAAjC,IAAsC,KAAKwb,UAAL,CAAgBniB,IAAhB,CAAqB2G,CAArB,MAA4B,CAAtE,EAAyE;AACrE,iBAAOA,CAAP;AACH;AACJ;;AACD,aAAO,KAAKub,eAAL,CAAqBliB,IAArB,CAA0B2C,MAAjC;AACH;AA3XL;AAAA;AAAA,2BA6XmB6hB,YA7XnB,EA6XyCjd,KA7XzC,EA6X8D;AAAA;;AACtD,UAAM/F,SAAS,GAAG,IAAlB;AACA,UAAM2G,OAAc,GAAG;AACnB9F,SAAC,EAAEmiB,YAAY,GAAG,KAAKtC,eAAL,CAAqBlc,IAArB,CAA0B3D,CADzB;AAEnBC,SAAC,EAAGkiB,YAAY,GAAG,KAAKtC,eAAL,CAAqBlc,IAArB,CAA0B3D,CAA1C,GAA+C;AAF/B,OAAvB;;AAKA,UAAImiB,YAAY,GAAG,KAAKtC,eAAL,CAAqBliB,IAArB,CAA0B2C,MAA7C,EAAqD;AACjD,YAAM8hB,YAAY,GAAG,KAAKrC,iBAAL,CAAuBoC,YAAvB,CAArB,CADiD,CAEjD;;AACA,aAAKtC,eAAL,CAAqBliB,IAArB,CAA0BwkB,YAA1B,IAA0Cjd,KAA1C;AAEAmd,iEAAgB,CAAChjB,OAAjB,CAAyB,UAAAijB,SAAS,EAAI;AAClC,cAAMriB,CAAC,GAAG6F,OAAO,CAAC7F,CAAR,GAAYqiB,SAAS,CAAC,CAAD,CAA/B;AACA,cAAMtiB,CAAC,GAAG8F,OAAO,CAAC9F,CAAR,GAAYsiB,SAAS,CAAC,CAAD,CAA/B;AACA,cAAMrP,KAAK,GAAGhT,CAAC,GAAG,MAAI,CAAC4f,eAAL,CAAqBlc,IAArB,CAA0B3D,CAA9B,GAAkCA,CAAhD,CAHkC,CAKlC;;AACA,cAAI,MAAI,CAAC8f,UAAL,CAAgBniB,IAAhB,CAAqBsV,KAArB,MAAgC,CAApC,EAAuC;AACnC,kBAAI,CAAC4M,eAAL,CAAqBliB,IAArB,CAA0BsV,KAA1B,IAAmCsP,MAAM,CAACC,SAA1C;AACH,WAFD,MAEO,IAAI,MAAI,CAAC3C,eAAL,CAAqBliB,IAArB,CAA0BsV,KAA1B,MAAqC,CAAzC,EAA4C;AAC/C,gBAAMmO,KAAK,GAAG,MAAI,CAACrB,iBAAL,CAAuB9M,KAAvB,CAAd;AACA,gBAAMvS,UAAU,GAAGH,IAAI,CAACI,GAAL,CAASygB,KAAK,CAACphB,CAAN,GAAUoiB,YAAY,CAACpiB,CAAvB,GAA2BohB,KAAK,CAACnhB,CAAN,GAAUmiB,YAAY,CAACniB,CAA3D,CAAnB;;AACA,gBAAIS,UAAU,GAAGvB,SAAjB,EAA4B;AACxB,oBAAI,CAACsjB,MAAL,CAAYxP,KAAZ,EAAmB/N,KAAnB;AACH;AACJ;AACJ,SAfD;AAgBH;AACJ;AAED;;;;;AA5ZJ;AAAA;AAAA,gDAgawCyZ,YAhaxC,EAga4E;AAAA;;AACpE,UAAIzZ,KAAK,GAAG,CAAZ;AACA,UAAMtD,GAAQ,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAjB;AACA,UAAMC,GAAQ,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAjB,CAHoE,CAKpE;;AACA,WAAKie,UAAL,CAAgBniB,IAAhB,CAAqBoG,IAArB,CAA0B,CAA1B;;AACA,WAAK8b,eAAL,CAAqBliB,IAArB,CAA0BoG,IAA1B,CAA+B,CAA/B;;AACA,WAAKgc,iBAAL,CAAuBhc,IAAvB,CAA4B,IAA5B;;AAEA4a,kBAAY,CAACtf,OAAb,CAAqB,UAAA+hB,KAAK,EAAI;AAC1B,cAAI,CAACrB,iBAAL,CAAuBqB,KAAK,CAACnO,KAA7B,IAAsCmO,KAAtC;AACA,cAAI,CAACtB,UAAL,CAAgBniB,IAAhB,CAAqByjB,KAAK,CAACnO,KAA3B,IAAoC,CAApC;AACH,OAHD,EAVoE,CAepE;;AACA,WAAK6M,UAAL,CAAgBa,UAAhB;;AAEA,UAAIwB,YAAY,GAAG,CAAnB;;AACA,aAAO,CAACA,YAAY,GAAG,KAAKO,gBAAL,EAAhB,IAA2C,KAAK7C,eAAL,CAAqBliB,IAArB,CAA0B2C,MAA5E,EAAoF;AAChF4E,aAAK;;AACL,aAAKud,MAAL,CAAYN,YAAZ,EAA0Bjd,KAA1B;AACH,OAtBmE,CAwBpE;;;AACA,UAAIqE,KAAA,IAAyC,KAAKtM,OAAL,CAAa+K,KAAtD,IAA+D,KAAK/K,OAAL,CAAa+K,KAAb,CAAmBa,eAAtF,EAAuG;AACnG,aAAK,IAAIgG,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,KAAKgR,eAAL,CAAqBliB,IAArB,CAA0B2C,MAA9C,EAAsDuO,CAAC,EAAvD,EAA2D;AACvD,cAAI,KAAKgR,eAAL,CAAqBliB,IAArB,CAA0BkR,CAA1B,IAA+B,CAA/B,IAAoC,KAAKgR,eAAL,CAAqBliB,IAArB,CAA0BkR,CAA1B,KAAgC3J,KAAxE,EAA+E;AAC3E,gBAAMkc,KAAK,GAAG,KAAKrB,iBAAL,CAAuBlR,CAAvB,CAAd;AACAjN,eAAG,CAAC,CAAD,CAAH,GAAU,KAAKie,eAAL,CAAqBliB,IAArB,CAA0BkR,CAA1B,KAAgC3J,KAAK,GAAG,CAAxC,CAAD,GAA+C,GAAxD;AACAvD,2EAAO,CAACC,GAAD,EAAMC,GAAN,CAAP;;AACA,iBAAKue,SAAL,CAAegB,KAAK,CAAC1S,GAArB,EAA0B,KAAK6Q,gBAAL,CAAsB5b,IAAhD,gBAA6D9B,GAAG,CAAC4f,IAAJ,CAAS,GAAT,CAA7D,QAA+E,CAA/E;AACH;AACJ;AACJ;;AAED,aAAOvc,KAAP;AACH;AArcL;AAAA;AAAA,qCAucuCvB,IAvcvC,EAucoDlB,KAvcpD,EAucmEC,SAvcnE,EAuc4F;AAAA,UAApE1C,CAAoE,SAApEA,CAAoE;AAAA,UAAjEC,CAAiE,SAAjEA,CAAiE;AACpF,WAAKggB,cAAL,CAAoBtd,WAApB,GAAkCF,KAAlC;AACA,WAAKwd,cAAL,CAAoBrd,SAApB,GAAgCH,KAAhC;AACA,WAAKwd,cAAL,CAAoBvd,SAApB,GAAgCA,SAAS,IAAI,CAA7C;;AACA,WAAKud,cAAL,CAAoB0C,UAApB,CAA+B3iB,CAA/B,EAAkCC,CAAlC,EAAqC0D,IAAI,CAAC3D,CAA1C,EAA6C2D,IAAI,CAAC1D,CAAlD;AACH;AA5cL;AAAA;AAAA,8BA8csBsC,IA9ctB,EA8c0CE,KA9c1C,EA8cyDC,SA9czD,EA8ckF;AAC1EtE,oEAAU,CAACkE,QAAX,CAAoBC,IAApB,EAA0B,KAAK0d,cAA/B,EAA+Cxd,KAA/C,EAAsDC,SAAtD;AACH;AAhdL;;AAAA;AAAA,I;;;;;;;;;;;;;;;;;;;;;;;;;;AC5BA;;;AAKA;IAEKkgB,S;;WAAAA,S;AAAAA,W,CAAAA,S;AAAAA,W,CAAAA,S;GAAAA,S,KAAAA,S;;AAGJ;IAEIC,gB;;WAAAA,gB;AAAAA,kB,CAAAA,gB;AAAAA,kB,CAAAA,gB;AAAAA,kB,CAAAA,gB;GAAAA,gB,KAAAA,gB;;AAIJ;AAgBM,IAAM9B,UAAb;AAAA;AAAA;AAOI,sBAAY9c,YAAZ,EAAoD6e,YAApD,EAA+F;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAC3F,SAAKC,UAAL,GAAkB9e,YAAY,CAACtG,IAA/B;AACA,SAAKqlB,UAAL,GAAkBF,YAAY,CAACnlB,IAA/B;AACA,SAAK6W,MAAL,GAAcvQ,YAAY,CAACN,IAAb,CAAkB3D,CAAhC;AACA,SAAKyU,OAAL,GAAexQ,YAAY,CAACN,IAAb,CAAkB1D,CAAjC;AACA,SAAKgjB,OAAL,GAAe,IAAIC,8CAAJ,CAAWjf,YAAX,EAAyB6e,YAAzB,CAAf;AACH;;AAbL;AAAA;AAAA,8BAecK,UAfd,EAegD;AACxC,UAAMC,QAAQ,GAAG,IAAIpmB,KAAJ,EAAjB;;AAEA,WAAK,IAAIsH,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,GAApB,EAAyBA,CAAC,EAA1B,EAA8B;AAC1B8e,gBAAQ,CAAC9e,CAAD,CAAR,GAAc,CAAd;AACH;;AAED8e,cAAQ,CAAC,CAAD,CAAR,GAAc,KAAKL,UAAL,CAAgB,CAAhB,CAAd;AAEA,UAAIM,EAAW,GAAG,IAAlB;AACA,UAAIC,EAAJ;AACA,UAAIC,cAAc,GAAG,CAArB;;AAEA,WAAK,IAAIC,EAAE,GAAG,CAAd,EAAiBA,EAAE,GAAG,KAAK/O,OAAL,GAAe,CAArC,EAAwC+O,EAAE,EAA1C,EAA8C;AAC1C,YAAIC,UAAU,GAAG,CAAjB;AACA,YAAIC,EAAE,GAAGN,QAAQ,CAAC,CAAD,CAAjB;;AAEA,aAAK,IAAIO,EAAE,GAAG,CAAd,EAAiBA,EAAE,GAAG,KAAKnP,MAAL,GAAc,CAApC,EAAuCmP,EAAE,EAAzC,EAA6C;AACzC,cAAMjV,GAAG,GAAG8U,EAAE,GAAG,KAAKhP,MAAV,GAAmBmP,EAA/B;;AAEA,cAAI,KAAKX,UAAL,CAAgBtU,GAAhB,MAAyB,CAA7B,EAAgC;AAC5B,gBAAMjM,KAAK,GAAG,KAAKsgB,UAAL,CAAgBrU,GAAhB,CAAd;;AACA,gBAAIjM,KAAK,KAAKihB,EAAd,EAAkB;AACd,kBAAID,UAAU,KAAK,CAAnB,EAAsB;AAClB,oBAAMG,EAAE,GAAGL,cAAc,GAAG,CAA5B;AACAH,wBAAQ,CAACQ,EAAD,CAAR,GAAenhB,KAAf;AACAihB,kBAAE,GAAGjhB,KAAL;;AACA,oBAAMie,MAAM,GAAG,KAAKuC,OAAL,CAAaY,cAAb,CAA4BL,EAA5B,EAAgCG,EAAhC,EAAoCC,EAApC,EAAwCnhB,KAAxC,EAA+CmgB,SAAS,CAACkB,OAAzD,CAAf;;AACA,oBAAIpD,MAAM,KAAK,IAAf,EAAqB;AACjB6C,gCAAc;AACdE,4BAAU,GAAGG,EAAb;AACA,sBAAMvjB,CAAU,GAAG;AACf6M,uBAAG,EAAE2V,gBAAgB,CAACkB,EADP;AAEf9Q,yBAAK,EAAEwQ,UAFQ;AAGfO,+BAAW,EAAEtD,MAHE;AAIfuD,4BAAQ,EAAEZ,EAJK;AAKfa,kCAAc,EAAE;AALD,mBAAnB;;AAOA,sBAAIb,EAAE,KAAK,IAAX,EAAiB;AACbA,sBAAE,CAACc,YAAH,GAAkB9jB,CAAlB;AACH;;AACDgjB,oBAAE,GAAGhjB,CAAL;AACH;AACJ,eApBD,MAoBO;AACH,oBAAMqgB,OAAM,GAAG,KAAKuC,OAAL,CAAaY,cAAb,CAA4BL,EAA5B,EAAgCG,EAAhC,EAAoCf,SAAS,CAACwB,MAA9C,EAAsD3hB,KAAtD,EAA6DghB,UAA7D,CAAf;;AACA,oBAAI/C,OAAM,KAAK,IAAf,EAAqB;AACjB,sBAAMrgB,EAAU,GAAG;AACf6M,uBAAG,EAAEiW,UAAU,KAAK,CAAf,GAAmBN,gBAAgB,CAACwB,GAApC,GAA0CxB,gBAAgB,CAACkB,EADjD;AAEfC,+BAAW,EAAEtD,OAFE;AAGfzN,yBAAK,EAAEkQ,UAHQ;AAIfe,kCAAc,EAAE;AAJD,mBAAnB;AAMAZ,oBAAE,GAAGD,EAAL;;AACA,yBAAQC,EAAE,KAAK,IAAR,IAAiBA,EAAE,CAACrQ,KAAH,KAAawQ,UAArC,EAAiD;AAC7CH,sBAAE,GAAGA,EAAE,CAACW,QAAR;AACH;;AACD,sBAAIX,EAAE,KAAK,IAAX,EAAiB;AACbjjB,sBAAC,CAAC4jB,QAAF,GAAaX,EAAE,CAACY,cAAhB;;AACA,wBAAIZ,EAAE,CAACY,cAAH,KAAsB,IAA1B,EAAgC;AAC5BZ,wBAAE,CAACY,cAAH,CAAkBC,YAAlB,GAAiC9jB,EAAjC;AACH;;AACDijB,sBAAE,CAACY,cAAH,GAAoB7jB,EAApB;AACH;AACJ;AACJ;AACJ,aA3CD,MA2CO;AACH,mBAAK2iB,UAAL,CAAgBtU,GAAhB,IAAuB+U,UAAvB;AACH;AACJ,WAhDD,MAgDO,IAAI,KAAKT,UAAL,CAAgBtU,GAAhB,MAAyBkU,SAAS,CAACwB,MAAvC,EAA+C;AAClDX,sBAAU,GAAG,CAAb;AACAC,cAAE,GAAG,KAAKX,UAAL,CAAgBrU,GAAhB,CAAL;AACH,WAHM,MAGA,IAAI,KAAKsU,UAAL,CAAgBtU,GAAhB,MAAyBkU,SAAS,CAACkB,OAAvC,EAAgD;AACnDL,sBAAU,GAAG,CAAb;AACAC,cAAE,GAAGN,QAAQ,CAAC,CAAD,CAAb;AACH,WAHM,MAGA;AACHK,sBAAU,GAAG,KAAKT,UAAL,CAAgBtU,GAAhB,CAAb;AACAgV,cAAE,GAAGN,QAAQ,CAACK,UAAD,CAAb;AACH;AACJ;AACJ;;AAEDH,QAAE,GAAGD,EAAL;;AACA,aAAOC,EAAE,KAAK,IAAd,EAAoB;AAChBA,UAAE,CAACrQ,KAAH,GAAWkQ,UAAX;AACAG,UAAE,GAAGA,EAAE,CAACW,QAAR;AACH;;AAED,aAAO;AACHZ,UAAE,EAAFA,EADG;AAEHlC,aAAK,EAAEoC;AAFJ,OAAP;AAIH;AA1GL;AAAA;AAAA,gCA4GgBtP,MA5GhB,EA4G2CqQ,YA5G3C,EA4GwE;AAChE,UAAM9hB,OAAO,GAAGyR,MAAM,CAACvW,UAAP,CAAkB,IAAlB,CAAhB;AAEA8E,aAAO,CAACG,WAAR,GAAsB,KAAtB;AACAH,aAAO,CAACI,SAAR,GAAoB,KAApB;AACAJ,aAAO,CAACE,SAAR,GAAoB,CAApB;AAEA,UAAI6hB,EAAE,GAAGD,YAAT;AACA,UAAIE,EAAE,GAAGD,EAAE,IAAIA,EAAE,CAACL,cAAlB;;AAEA,aAAOK,EAAE,KAAK,IAAd,EAAoB;AAChB,YAAIE,CAAC,GAAGD,EAAE,IAAID,EAAd;;AAEA,YAAIC,EAAE,KAAK,IAAX,EAAiB;AACbA,YAAE,GAAGA,EAAE,CAACP,QAAR;AACH,SAFD,MAEO;AACHM,YAAE,GAAGA,EAAE,CAACN,QAAR;AACAO,YAAE,GAAGD,EAAE,IAAIA,EAAE,CAACL,cAAd;AACH;;AAED,gBAAQO,CAAC,CAACvX,GAAV;AACI,eAAK2V,gBAAgB,CAACkB,EAAtB;AAA0B;AACtBvhB,qBAAO,CAACG,WAAR,GAAsB,KAAtB;AACA;AACH;;AACD,eAAKkgB,gBAAgB,CAACwB,GAAtB;AAA2B;AACvB7hB,qBAAO,CAACG,WAAR,GAAsB,MAAtB;AACA;AACH;;AACD,eAAKkgB,gBAAgB,CAAC6B,OAAtB;AAA+B;AAC3BliB,qBAAO,CAACG,WAAR,GAAsB,OAAtB;AACA;AACH;AAZL;;AAeA,YAAItC,CAAC,GAAGokB,CAAC,CAACT,WAAV;AACAxhB,eAAO,CAACK,SAAR;AACAL,eAAO,CAACM,MAAR,CAAezC,CAAC,CAACL,CAAjB,EAAoBK,CAAC,CAACJ,CAAtB;;AAEA,WAAG;AACCI,WAAC,GAAGA,CAAC,CAACskB,IAAN;AACAniB,iBAAO,CAACQ,MAAR,CAAe3C,CAAC,CAACL,CAAjB,EAAoBK,CAAC,CAACJ,CAAtB;AACH,SAHD,QAGSI,CAAC,KAAKokB,CAAC,CAACT,WAHjB;;AAKAxhB,eAAO,CAACU,MAAR;AACH;AACJ;AA1JL;;AAAA;AAAA,I;;;;;;;;;;;;AChCA;AAAA;AACA,SAAS0hB,YAAT,CAAsBC,MAAtB,EAA8BC,OAA9B,EAAuCtT,MAAvC,EAA+C;AAC3C;;AAEA,MAAIyG,MAAM,GAAG,IAAI4M,MAAM,CAAC/gB,UAAX,CAAsB0N,MAAtB,CAAb;AAAA,MACI7N,IAAI,GAAGmhB,OAAO,CAACnhB,IAAR,GAAe,CAD1B;AAAA,MAEIohB,IAAI,GAAGF,MAAM,CAACtkB,IAAP,CAAYwkB,IAFvB;;AAIA,WAASC,KAAT,CAAeC,UAAf,EAA2BC,WAA3B,EAAwC;AACpCD,cAAU,GAAGA,UAAU,GAAG,CAA1B;AACAC,eAAW,GAAGA,WAAW,GAAG,CAA5B;AAEA,QAAIljB,CAAC,GAAG,CAAR;AAAA,QACImjB,CAAC,GAAG,CADR;AAAA,QAEI/kB,GAAG,GAAG,CAFV;AAAA,QAGIglB,OAAO,GAAG,CAHd;AAAA,QAIIC,OAAO,GAAG,CAJd;AAAA,QAKIC,OAAO,GAAG,CALd;AAAA,QAMIC,OAAO,GAAG,CANd;AAAA,QAOIpT,MAAM,GAAG,CAPb;;AASA,SAAKnQ,CAAC,GAAG,CAAT,EAAY,CAACA,CAAC,GAAG,CAAL,KAAY2B,IAAI,GAAG,CAAR,GAAa,CAAxB,CAAZ,EAAwC3B,CAAC,GAAIA,CAAC,GAAG,CAAL,GAAU,CAAtD,EAAyD;AACrDmQ,YAAM,GAAIA,MAAM,GAAGxO,IAAV,GAAkB,CAA3B;;AACA,WAAKwhB,CAAC,GAAG,CAAT,EAAY,CAACA,CAAC,GAAG,CAAL,KAAYxhB,IAAI,GAAG,CAAR,GAAa,CAAxB,CAAZ,EAAwCwhB,CAAC,GAAIA,CAAC,GAAG,CAAL,GAAU,CAAtD,EAAyD;AACrDC,eAAO,GAAIjT,MAAM,GAAGxO,IAAV,GAAkB,CAA5B;AACA0hB,eAAO,GAAIlT,MAAM,GAAGxO,IAAV,GAAkB,CAA5B;AACA2hB,eAAO,GAAIH,CAAC,GAAG,CAAL,GAAU,CAApB;AACAI,eAAO,GAAIJ,CAAC,GAAG,CAAL,GAAU,CAApB;AACA/kB,WAAG,GAAI,CAAC6X,MAAM,CAAEgN,UAAU,GAAGG,OAAb,GAAuBE,OAAxB,GAAmC,CAApC,CAAN,GAA+C,CAAhD,KACArN,MAAM,CAAEgN,UAAU,GAAGG,OAAb,GAAuBG,OAAxB,GAAmC,CAApC,CAAN,GAA+C,CAD/C,KAEAtN,MAAM,CAAEgN,UAAU,GAAG9S,MAAb,GAAsBgT,CAAvB,GAA4B,CAA7B,CAAN,GAAwC,CAFxC,KAGAlN,MAAM,CAAEgN,UAAU,GAAGI,OAAb,GAAuBC,OAAxB,GAAmC,CAApC,CAAN,GAA+C,CAH/C,KAIArN,MAAM,CAAEgN,UAAU,GAAGI,OAAb,GAAuBE,OAAxB,GAAmC,CAApC,CAAN,GAA+C,CAJ/C,CAAD,GAIsD,CAJ5D;;AAKA,YAAI,CAACnlB,GAAG,GAAG,CAAP,MAAc,IAAI,CAAlB,CAAJ,EAA0B;AACtB6X,gBAAM,CAAEiN,WAAW,GAAG/S,MAAd,GAAuBgT,CAAxB,GAA6B,CAA9B,CAAN,GAAyC,CAAzC;AACH,SAFD,MAEO;AACHlN,gBAAM,CAAEiN,WAAW,GAAG/S,MAAd,GAAuBgT,CAAxB,GAA6B,CAA9B,CAAN,GAAyC,CAAzC;AACH;AACJ;AACJ;;AACD;AACH;;AAED,WAASK,QAAT,CAAkBC,SAAlB,EAA6BC,SAA7B,EAAwCR,WAAxC,EAAqD;AACjDO,aAAS,GAAGA,SAAS,GAAG,CAAxB;AACAC,aAAS,GAAGA,SAAS,GAAG,CAAxB;AACAR,eAAW,GAAGA,WAAW,GAAG,CAA5B;AAEA,QAAI5kB,MAAM,GAAG,CAAb;AAEAA,UAAM,GAAGykB,IAAI,CAACphB,IAAD,EAAOA,IAAP,CAAJ,GAAmB,CAA5B;;AAEA,WAAO,CAACrD,MAAM,GAAG,CAAV,IAAe,CAAtB,EAAyB;AACrBA,YAAM,GAAIA,MAAM,GAAG,CAAV,GAAe,CAAxB;AACA2X,YAAM,CAAEiN,WAAW,GAAG5kB,MAAf,GAAyB,CAA1B,CAAN,GACK,CAAC2X,MAAM,CAAEwN,SAAS,GAAGnlB,MAAb,GAAuB,CAAxB,CAAN,GAAmC,CAApC,KAA0C2X,MAAM,CAAEyN,SAAS,GAAGplB,MAAb,GAAuB,CAAxB,CAAN,GAAmC,CAA7E,CAAD,GAAoF,CADxF;AAEH;AACJ;;AAED,WAASqlB,SAAT,CAAmBF,SAAnB,EAA8BC,SAA9B,EAAyCR,WAAzC,EAAsD;AAClDO,aAAS,GAAGA,SAAS,GAAG,CAAxB;AACAC,aAAS,GAAGA,SAAS,GAAG,CAAxB;AACAR,eAAW,GAAGA,WAAW,GAAG,CAA5B;AAEA,QAAI5kB,MAAM,GAAG,CAAb;AAEAA,UAAM,GAAGykB,IAAI,CAACphB,IAAD,EAAOA,IAAP,CAAJ,GAAmB,CAA5B;;AAEA,WAAO,CAACrD,MAAM,GAAG,CAAV,IAAe,CAAtB,EAAyB;AACrBA,YAAM,GAAIA,MAAM,GAAG,CAAV,GAAe,CAAxB;AACA2X,YAAM,CAAEiN,WAAW,GAAG5kB,MAAf,GAAyB,CAA1B,CAAN,GACM2X,MAAM,CAAEwN,SAAS,GAAGnlB,MAAb,GAAuB,CAAxB,CAAN,GAAmC,CAApC,IAA0C2X,MAAM,CAAEyN,SAAS,GAAGplB,MAAb,GAAuB,CAAxB,CAAN,GAAmC,CAA7E,CAAD,GAAoF,CADxF;AAEH;AACJ;;AAED,WAASslB,YAAT,CAAsBC,QAAtB,EAAgC;AAC5BA,YAAQ,GAAGA,QAAQ,GAAG,CAAtB;AAEA,QAAIzlB,GAAG,GAAG,CAAV;AAAA,QACIE,MAAM,GAAG,CADb;AAGAA,UAAM,GAAGykB,IAAI,CAACphB,IAAD,EAAOA,IAAP,CAAJ,GAAmB,CAA5B;;AAEA,WAAO,CAACrD,MAAM,GAAG,CAAV,IAAe,CAAtB,EAAyB;AACrBA,YAAM,GAAIA,MAAM,GAAG,CAAV,GAAe,CAAxB;AACAF,SAAG,GAAI,CAACA,GAAG,GAAG,CAAP,KAAa6X,MAAM,CAAE4N,QAAQ,GAAGvlB,MAAZ,GAAsB,CAAvB,CAAN,GAAkC,CAA/C,CAAD,GAAsD,CAA5D;AACH;;AAED,WAAQF,GAAG,GAAG,CAAd;AACH;;AAED,WAASgd,IAAT,CAAcyI,QAAd,EAAwBriB,KAAxB,EAA+B;AAC3BqiB,YAAQ,GAAGA,QAAQ,GAAG,CAAtB;AACAriB,SAAK,GAAGA,KAAK,GAAG,CAAhB;AAEA,QAAIlD,MAAM,GAAG,CAAb;AAEAA,UAAM,GAAGykB,IAAI,CAACphB,IAAD,EAAOA,IAAP,CAAJ,GAAmB,CAA5B;;AAEA,WAAO,CAACrD,MAAM,GAAG,CAAV,IAAe,CAAtB,EAAyB;AACrBA,YAAM,GAAIA,MAAM,GAAG,CAAV,GAAe,CAAxB;AACA2X,YAAM,CAAE4N,QAAQ,GAAGvlB,MAAZ,GAAsB,CAAvB,CAAN,GAAkCkD,KAAlC;AACH;AACJ;;AAED,WAASsiB,MAAT,CAAgBb,UAAhB,EAA4BC,WAA5B,EAAyC;AACrCD,cAAU,GAAGA,UAAU,GAAG,CAA1B;AACAC,eAAW,GAAGA,WAAW,GAAG,CAA5B;AAEA,QAAIljB,CAAC,GAAG,CAAR;AAAA,QACImjB,CAAC,GAAG,CADR;AAAA,QAEI/kB,GAAG,GAAG,CAFV;AAAA,QAGIglB,OAAO,GAAG,CAHd;AAAA,QAIIC,OAAO,GAAG,CAJd;AAAA,QAKIC,OAAO,GAAG,CALd;AAAA,QAMIC,OAAO,GAAG,CANd;AAAA,QAOIpT,MAAM,GAAG,CAPb;;AASA,SAAKnQ,CAAC,GAAG,CAAT,EAAY,CAACA,CAAC,GAAG,CAAL,KAAY2B,IAAI,GAAG,CAAR,GAAa,CAAxB,CAAZ,EAAwC3B,CAAC,GAAIA,CAAC,GAAG,CAAL,GAAU,CAAtD,EAAyD;AACrDmQ,YAAM,GAAIA,MAAM,GAAGxO,IAAV,GAAkB,CAA3B;;AACA,WAAKwhB,CAAC,GAAG,CAAT,EAAY,CAACA,CAAC,GAAG,CAAL,KAAYxhB,IAAI,GAAG,CAAR,GAAa,CAAxB,CAAZ,EAAwCwhB,CAAC,GAAIA,CAAC,GAAG,CAAL,GAAU,CAAtD,EAAyD;AACrDC,eAAO,GAAIjT,MAAM,GAAGxO,IAAV,GAAkB,CAA5B;AACA0hB,eAAO,GAAIlT,MAAM,GAAGxO,IAAV,GAAkB,CAA5B;AACA2hB,eAAO,GAAIH,CAAC,GAAG,CAAL,GAAU,CAApB;AACAI,eAAO,GAAIJ,CAAC,GAAG,CAAL,GAAU,CAApB;AACA/kB,WAAG,GAAI,CAAC6X,MAAM,CAAEgN,UAAU,GAAGG,OAAb,GAAuBE,OAAxB,GAAmC,CAApC,CAAN,GAA+C,CAAhD,KACArN,MAAM,CAAEgN,UAAU,GAAGG,OAAb,GAAuBG,OAAxB,GAAmC,CAApC,CAAN,GAA+C,CAD/C,KAEAtN,MAAM,CAAEgN,UAAU,GAAG9S,MAAb,GAAsBgT,CAAvB,GAA4B,CAA7B,CAAN,GAAwC,CAFxC,KAGAlN,MAAM,CAAEgN,UAAU,GAAGI,OAAb,GAAuBC,OAAxB,GAAmC,CAApC,CAAN,GAA+C,CAH/C,KAIArN,MAAM,CAAEgN,UAAU,GAAGI,OAAb,GAAuBE,OAAxB,GAAmC,CAApC,CAAN,GAA+C,CAJ/C,CAAD,GAIsD,CAJ5D;;AAKA,YAAI,CAACnlB,GAAG,GAAG,CAAP,KAAa,IAAI,CAAjB,CAAJ,EAAyB;AACrB6X,gBAAM,CAAEiN,WAAW,GAAG/S,MAAd,GAAuBgT,CAAxB,GAA6B,CAA9B,CAAN,GAAyC,CAAzC;AACH,SAFD,MAEO;AACHlN,gBAAM,CAAEiN,WAAW,GAAG/S,MAAd,GAAuBgT,CAAxB,GAA6B,CAA9B,CAAN,GAAyC,CAAzC;AACH;AACJ;AACJ;;AACD;AACH;;AAED,WAASY,MAAT,CAAgBC,WAAhB,EAA6BC,WAA7B,EAA0C;AACtCD,eAAW,GAAGA,WAAW,GAAG,CAA5B;AACAC,eAAW,GAAGA,WAAW,GAAG,CAA5B;AAEA,QAAI3lB,MAAM,GAAG,CAAb;AAEAA,UAAM,GAAGykB,IAAI,CAACphB,IAAD,EAAOA,IAAP,CAAJ,GAAmB,CAA5B;;AAEA,WAAO,CAACrD,MAAM,GAAG,CAAV,IAAe,CAAtB,EAAyB;AACrBA,YAAM,GAAIA,MAAM,GAAG,CAAV,GAAe,CAAxB;AACA2X,YAAM,CAAEgO,WAAW,GAAG3lB,MAAf,GAAyB,CAA1B,CAAN,GAAsC2X,MAAM,CAAE+N,WAAW,GAAG1lB,MAAf,GAAyB,CAA1B,CAAN,GAAqC,CAA3E;AACH;AACJ;;AAED,WAASqgB,UAAT,CAAoBkF,QAApB,EAA8B;AAC1BA,YAAQ,GAAGA,QAAQ,GAAG,CAAtB;AAEA,QAAI7lB,CAAC,GAAG,CAAR;AAAA,QACIC,CAAC,GAAG,CADR;;AAGA,SAAKD,CAAC,GAAG,CAAT,EAAY,CAACA,CAAC,GAAG,CAAL,KAAY2D,IAAI,GAAG,CAAR,GAAa,CAAxB,CAAZ,EAAwC3D,CAAC,GAAIA,CAAC,GAAG,CAAL,GAAU,CAAtD,EAAyD;AACrDiY,YAAM,CAAE4N,QAAQ,GAAG7lB,CAAZ,GAAiB,CAAlB,CAAN,GAA6B,CAA7B;AACAiY,YAAM,CAAE4N,QAAQ,GAAG5lB,CAAZ,GAAiB,CAAlB,CAAN,GAA6B,CAA7B;AACAA,OAAC,GAAKA,CAAC,GAAG0D,IAAL,GAAa,CAAd,GAAmB,CAAvB;AACAsU,YAAM,CAAE4N,QAAQ,GAAG5lB,CAAZ,GAAiB,CAAlB,CAAN,GAA6B,CAA7B;AACAA,OAAC,GAAIA,CAAC,GAAG,CAAL,GAAU,CAAd;AACH;;AACD,SAAKD,CAAC,GAAG,CAAT,EAAY,CAACA,CAAC,GAAG,CAAL,KAAW2D,IAAI,GAAG,CAAlB,CAAZ,EAAkC3D,CAAC,GAAIA,CAAC,GAAG,CAAL,GAAU,CAAhD,EAAmD;AAC/CiY,YAAM,CAAE4N,QAAQ,GAAG5lB,CAAZ,GAAiB,CAAlB,CAAN,GAA6B,CAA7B;AACAA,OAAC,GAAIA,CAAC,GAAG,CAAL,GAAU,CAAd;AACH;AACJ;;AAED,WAAS4hB,WAAT,GAAuB;AACnB,QAAIqE,WAAW,GAAG,CAAlB;AAAA,QACIC,cAAc,GAAG,CADrB;AAAA,QAEIC,YAAY,GAAG,CAFnB;AAAA,QAGIC,YAAY,GAAG,CAHnB;AAAA,QAIIjmB,GAAG,GAAG,CAJV;AAAA,QAKIkmB,IAAI,GAAG,CALX;AAOAH,kBAAc,GAAGpB,IAAI,CAACphB,IAAD,EAAOA,IAAP,CAAJ,GAAmB,CAApC;AACAyiB,gBAAY,GAAID,cAAc,GAAGA,cAAlB,GAAoC,CAAnD;AACAE,gBAAY,GAAID,YAAY,GAAGD,cAAhB,GAAkC,CAAjD,CAVmB,CAYnB;;AACA/I,QAAI,CAACiJ,YAAD,EAAe,CAAf,CAAJ;AACA1F,cAAU,CAACuF,WAAD,CAAV;;AAEA,OAAG;AACClB,WAAK,CAACkB,WAAD,EAAcC,cAAd,CAAL;AACAL,YAAM,CAACK,cAAD,EAAiBC,YAAjB,CAAN;AACAZ,cAAQ,CAACU,WAAD,EAAcE,YAAd,EAA4BA,YAA5B,CAAR;AACAT,eAAS,CAACU,YAAD,EAAeD,YAAf,EAA6BC,YAA7B,CAAT;AACAN,YAAM,CAACI,cAAD,EAAiBD,WAAjB,CAAN;AACA9lB,SAAG,GAAGwlB,YAAY,CAACM,WAAD,CAAZ,GAA4B,CAAlC;AACAI,UAAI,GAAI,CAAClmB,GAAG,GAAG,CAAP,KAAa,CAAb,GAAiB,CAAzB;AACH,KARD,QAQS,CAACkmB,IARV;AASH;;AAED,SAAO;AACHzE,eAAW,EAAEA;AADV,GAAP;AAGH;;AACc+C,2EAAf;AACA,0B;;;;;;;;;;;;;;;;;;;;;;;;;AC3MA;;;AAMO,IAAMvC,gBAAyC,GAAG,CAAC,CAAC,CAAD,EAAI,CAAJ,CAAD,EAAS,CAAC,CAAD,EAAI,CAAJ,CAAT,EAAiB,CAAC,CAAD,EAAI,CAAJ,CAAjB,EAAyB,CAAC,CAAD,EAAI,CAAC,CAAL,CAAzB,EAAkC,CAAC,CAAD,EAAI,CAAC,CAAL,CAAlC,EAA2C,CAAC,CAAC,CAAF,EAAK,CAAC,CAAN,CAA3C,EAAqD,CAAC,CAAC,CAAF,EAAK,CAAL,CAArD,EAA8D,CAAC,CAAC,CAAF,EAAK,CAAL,CAA9D,CAAlD;AAgBA,IAAMa,MAAb;AAAA;AAAA;AAKI,kBAAYjf,YAAZ,EAAwC6e,YAAxC,EAAmF;AAAA;;AAAA;;AAAA;;AAAA;;AAC/E,SAAKC,UAAL,GAAkB9e,YAAY,CAACtG,IAA/B;AACA,SAAKqlB,UAAL,GAAkBF,YAAY,CAACnlB,IAA/B;AACA,SAAK6W,MAAL,GAAcvQ,YAAY,CAACN,IAAb,CAAkB3D,CAAhC;AACH;;AATL;AAAA;AAAA,0BAWU8F,OAXV,EAW4BrD,KAX5B,EAW2CyC,KAX3C,EAW0DqhB,SAX1D,EAWsF;AAC9E,WAAK,IAAIjiB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AACxB,YAAMrE,CAAC,GAAG6F,OAAO,CAAC0d,EAAR,GAAanB,gBAAgB,CAACvc,OAAO,CAACoH,GAAT,CAAhB,CAA8B,CAA9B,CAAb,GAAgD,CAA1D;AACA,YAAMlN,CAAC,GAAG8F,OAAO,CAAC6d,EAAR,GAAatB,gBAAgB,CAACvc,OAAO,CAACoH,GAAT,CAAhB,CAA8B,CAA9B,CAAb,GAAgD,CAA1D;AACA,YAAMwB,GAAG,GAAGzO,CAAC,GAAG,KAAKuU,MAAT,GAAkBxU,CAAlB,GAAsB,CAAlC;;AAEA,YAAK,KAAK+iB,UAAL,CAAgBrU,GAAhB,MAAyBjM,KAA1B,KAAsC,KAAKugB,UAAL,CAAgBtU,GAAhB,MAAyB,CAA1B,IAAiC,KAAKsU,UAAL,CAAgBtU,GAAhB,MAAyBxJ,KAA/F,CAAJ,EAA4G;AACxG,eAAK8d,UAAL,CAAgBtU,GAAhB,IAAuBxJ,KAAvB;AACAY,iBAAO,CAAC6d,EAAR,GAAa3jB,CAAb;AACA8F,iBAAO,CAAC0d,EAAR,GAAavjB,CAAb;AAEA,iBAAO,IAAP;AACH,SAND,MAMO;AACH,cAAI,KAAK+iB,UAAL,CAAgBtU,GAAhB,MAAyB,CAA7B,EAAgC;AAC5B,iBAAKsU,UAAL,CAAgBtU,GAAhB,IAAuB6X,SAAvB;AACH;;AACDzgB,iBAAO,CAACoH,GAAR,GAAc,CAACpH,OAAO,CAACoH,GAAR,GAAc,CAAf,IAAoB,CAAlC;AACH;AACJ;;AAED,aAAO,KAAP;AACH;AAhCL;AAAA;AAAA,mCAkCmBsZ,EAlCnB,EAkC+BC,EAlC/B,EAkC2CvhB,KAlC3C,EAkC0DzC,KAlC1D,EAkCyE8jB,SAlCzE,EAkC2G;AACnG,UAAIG,EAAiB,GAAG,IAAxB;AACA,UAAM5gB,OAAgB,GAAG;AACrB6d,UAAE,EAAE8C,EADiB;AAErBjD,UAAE,EAAEgD,EAFiB;AAGrBtZ,WAAG,EAAE;AAHgB,OAAzB;;AAMA,UAAI,KAAKyZ,KAAL,CAAW7gB,OAAX,EAAoBrD,KAApB,EAA2ByC,KAA3B,EAAkCqhB,SAAlC,CAAJ,EAAkD;AAC9CG,UAAE,GAAG;AACD1mB,WAAC,EAAEymB,EADF;AAEDxmB,WAAC,EAAEumB,EAFF;AAGDtZ,aAAG,EAAEpH,OAAO,CAACoH,GAHZ;AAIDyX,cAAI,EAAE,IAJL;AAKD5d,cAAI,EAAE;AALL,SAAL;AAOA,YAAI6f,EAAE,GAAGF,EAAT;AACA,YAAIG,IAAI,GAAG/gB,OAAO,CAACoH,GAAnB;AACA,YAAI4Z,CAAC,GAAG;AACJ9mB,WAAC,EAAE8F,OAAO,CAAC6d,EADP;AAEJ1jB,WAAC,EAAE6F,OAAO,CAAC0d,EAFP;AAGJtW,aAAG,EAAE,CAHD;AAIJyX,cAAI,EAAE,IAJF;AAKJ5d,cAAI,EAAE6f;AALF,SAAR;AAOAA,UAAE,CAACjC,IAAH,GAAUmC,CAAV;AACAF,UAAE,GAAGE,CAAL;;AAEA,WAAG;AACChhB,iBAAO,CAACoH,GAAR,GAAc,CAACpH,OAAO,CAACoH,GAAR,GAAc,CAAf,IAAoB,CAAlC;AAEA,eAAKyZ,KAAL,CAAW7gB,OAAX,EAAoBrD,KAApB,EAA2ByC,KAA3B,EAAkCqhB,SAAlC;;AAEA,cAAIM,IAAI,KAAK/gB,OAAO,CAACoH,GAArB,EAA0B;AACtB0Z,cAAE,CAAC1Z,GAAH,GAASpH,OAAO,CAACoH,GAAjB;AACA4Z,aAAC,GAAG;AACA9mB,eAAC,EAAE8F,OAAO,CAAC6d,EADX;AAEA1jB,eAAC,EAAE6F,OAAO,CAAC0d,EAFX;AAGAtW,iBAAG,EAAE,CAHL;AAIAyX,kBAAI,EAAE,IAJN;AAKA5d,kBAAI,EAAE6f;AALN,aAAJ;AAOAA,cAAE,CAACjC,IAAH,GAAUmC,CAAV;AACAF,cAAE,GAAGE,CAAL;AACH,WAXD,MAWO;AACHF,cAAE,CAAC1Z,GAAH,GAAS2Z,IAAT;AACAD,cAAE,CAAC5mB,CAAH,GAAO8F,OAAO,CAAC6d,EAAf;AACAiD,cAAE,CAAC3mB,CAAH,GAAO6F,OAAO,CAAC0d,EAAf;AACH;;AAEDqD,cAAI,GAAG/gB,OAAO,CAACoH,GAAf;AACH,SAvBD,QAuBSpH,OAAO,CAAC6d,EAAR,KAAe8C,EAAf,IAAqB3gB,OAAO,CAAC0d,EAAR,KAAegD,EAvB7C;;AAyBAE,UAAE,CAAC3f,IAAH,GAAU6f,EAAE,CAAC7f,IAAb;AACA6f,UAAE,CAAC7f,IAAH,CAAQ4d,IAAR,GAAe+B,EAAf;AACH;;AACD,aAAOA,EAAP;AACH;AA3FL;;AAAA;AAAA,I;;;;;;;;;;;;ACvBA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;;AAoBA,IAAIxS,YAAJ;;AACA,IAAI6S,aAAJ;;AACA,IAAIC,QAAJ;;AACA,IAAMC,gBAAuC,GAAG;AAC5CC,KAAG,EAAE;AACD5R,SAAK,EAAE,IADN;AAED4L,WAAO,EAAE;AAFR,GADuC;AAK5CiG,KAAG,EAAE;AACD7R,SAAK,EAAE,IADN;AAED4L,WAAO,EAAE;AAFR;AALuC,CAAhD;;AAUA,IAAI7X,kBAAJ;;AACA,IAAI+d,QAAJ;;AACA,IAAIC,QAAJ;;AACA,IAAIC,QAAJ;;AACA,IAAIC,WAAW,GAAG,IAAIvqB,KAAJ,EAAlB;;AACA,IAAIwqB,WAAJ;;AACA,IAAIC,gBAAJ;;AACA,IAAIxqB,OAAJ;;AAEe;AACXmgB,MADW,gBACNtgB,MADM,EACgB4qB,EADhB,EACgCzjB,YADhC,EAC6D;AACpEujB,eAAW,GAAG,IAAd;AACAvqB,WAAO,GAAG0J,2DAAK,CAACghB,qDAAD,EAAgB7qB,MAAhB,CAAf;;AACA,QAAImH,YAAJ,EAAkB;AACdujB,iBAAW,GAAG,KAAd;;AACAI,qBAAe,CAAC3jB,YAAD,CAAf;;AACAyjB,QAAE;AACL,KAJD,MAIO;AACHG,sBAAgB,CAACH,EAAD,CAAhB;AACH;AACJ,GAXU;AAaX3Y,cAAY,EAAEA,iEAbH;AAeX3Q,YAAU,EAAEA,8DAfD;AAiBXsF,cAAY,EAAEA,kEAjBH;AAmBX7G,iBAAe,EAAEA,2EAnBN;;AAqBX,MAAIoX,MAAJ,GAAoC;AAChC,WAAOgT,gBAAP;AACH,GAvBU;;AAyBXnU,OAzBW,mBAyBG;AACV,QAAI0U,WAAW,IAAIvqB,OAAO,CAACkK,WAAR,CAAoB/F,IAApB,KAA6B,YAAhD,EAA8D;AAC1D0mB,4BAAsB;AACzB,KAFD,MAEO;AACHC,aAAO;AACV;AACJ,GA/BU;AAiCX/X,MAjCW,kBAiCE;AACTgX,YAAQ,GAAG,IAAX;;AACAgB,qBAAiB,CAAC,CAAD,CAAjB;;AACA,QAAI/qB,OAAO,CAACkK,WAAR,CAAoB/F,IAApB,KAA6B,YAAjC,EAA+C;AAC3C2N,uEAAY,CAACc,OAAb;;AACAqE,kBAAY,CAAC+T,kBAAb;AACH;AACJ,GAxCU;AA0CXC,cA1CW,wBA0CEprB,MA1CF,EA0CwBqrB,cA1CxB,EA0C0E;AAAA;;AACjFrrB,UAAM,GAAG6J,2DAAK,CAAC;AACXQ,iBAAW,EAAE;AACT/F,YAAI,EAAE,aADG;AAETqV,gBAAQ,EAAE,KAFD;AAGT9S,YAAI,EAAE,GAHG;AAITyN,WAAG,EAAEtU,MAAM,CAACsU;AAJH,OADF;AAOXvJ,kBAAY,EAAG0B,KAAA,IAAyCzM,MAAM,CAACkL,KAAjD,GAA0D,CAA1D,GAA8D,CAPjE;AAQXK,aAAO,EAAE;AACLC,kBAAU,EAAE;AADP;AARE,KAAD,EAWXxL,MAXW,CAAd;AAaA,SAAKsgB,IAAL,CAAUtgB,MAAV,EAAkB,YAAM;AACpB+D,2DAAM,CAACS,IAAP,CAAY,WAAZ,EAAyB,UAACrD,MAAD,EAA2B;AAChD,aAAI,CAAC+R,IAAL;;AACAmY,sBAAc,CAACC,IAAf,CAAoB,IAApB,EAA0BnqB,MAA1B;AACH,OAHD,EAGG,IAHH;;AAIA,WAAI,CAAC6U,KAAL;AACH,KAND;AAOH,GA/DU;AAiEX8I,OAjEW,mBAiEG;AACVoL,YAAQ,GAAG,IAAX;AACH,GAnEU;AAqEXqB,YArEW,sBAqEAtnB,QArEA,EAqEmD;AAC1DF,yDAAM,CAACW,SAAP,CAAiB,UAAjB,EAA6BT,QAA7B;AACH,GAvEU;AAyEXunB,aAzEW,uBAyECvnB,QAzED,EAyEgC;AACvCF,yDAAM,CAAC0nB,WAAP,CAAmB,UAAnB,EAA+BxnB,QAA/B;AACH,GA3EU;AA6EXynB,aA7EW,uBA6ECznB,QA7ED,EA6EoD;AAC3DF,yDAAM,CAACW,SAAP,CAAiB,WAAjB,EAA8BT,QAA9B;AACH,GA/EU;AAiFX0nB,cAjFW,wBAiFE1nB,QAjFF,EAiFiC;AACxCF,yDAAM,CAAC0nB,WAAP,CAAmB,WAAnB,EAAgCxnB,QAAhC;AACH,GAnFU;AAqFX2nB,YArFW,sBAqFA3gB,OArFA,EAqFgD;AACvD,QAAIuf,QAAJ,EAAc;AACVA,cAAQ,CAACoB,UAAT,CAAoB3gB,OAApB;AACH,KAFD,MAEO,IAAIyf,WAAW,IAAID,WAAW,CAACjnB,MAAZ,GAAqB,CAAxC,EAA2C;AAC9CinB,iBAAW,CAACloB,OAAZ,CAAoB;AAAA,YAAGspB,MAAH,QAAGA,MAAH;AAAA,eAAgBA,MAAM,CAACC,WAAP,CAAmB;AAAEC,aAAG,EAAE,YAAP;AAAqB9gB,iBAAO,EAAPA;AAArB,SAAnB,CAAhB;AAAA,OAApB;AACH;AACJ,GA3FU;AA6FX+gB,yBA7FW,mCA6FaC,eA7Fb,EA6FqD;AAC5D,QAAIA,eAAe,IAAI,OAAOA,eAAe,CAACC,SAAvB,KAAqC,UAA5D,EAAwE;AACpEvB,sBAAgB,GAAGsB,eAAnB;AACH;AACJ;AAjGU,CAAf;;AAoGA,SAASnB,eAAT,CAAyB3jB,YAAzB,EAA4D;AACxDsa,cAAY,CAACta,YAAD,CAAZ;;AACAqjB,UAAQ,GAAG,IAAIne,uEAAJ,CAAmBlM,OAAO,CAAC6K,OAA3B,EAAoCuB,kBAApC,CAAX;AACH;;AAED,SAASwe,gBAAT,CAA0B9mB,QAA1B,EAA+D;AAC3D,MAAIkO,KAAJ;;AACA,MAAIhS,OAAO,CAACkK,WAAR,CAAoB/F,IAApB,KAA6B,aAAjC,EAAgD;AAC5C6N,SAAK,GAAG1R,QAAQ,CAACC,aAAT,CAAuB,OAAvB,CAAR;AACA0W,gBAAY,GAAG,IAAIwH,gEAAJ,CAAgBzM,KAAhB,CAAf;AACH,GAHD,MAGO,IAAIhS,OAAO,CAACkK,WAAR,CAAoB/F,IAApB,KAA6B,aAAjC,EAAgD;AACnD8S,gBAAY,GAAG,IAAIoD,+DAAJ,EAAf;AACH,GAFM,MAEA,IAAIra,OAAO,CAACkK,WAAR,CAAoB/F,IAApB,KAA6B,YAAjC,EAA+C;AAClD,QAAM6nB,QAAQ,GAAGC,YAAY,EAA7B;;AACA,QAAID,QAAJ,EAAc;AACVha,WAAK,GAAGga,QAAQ,CAACxf,aAAT,CAAuB,OAAvB,CAAR;;AACA,UAAI,CAACwF,KAAL,EAAY;AACRA,aAAK,GAAG1R,QAAQ,CAACC,aAAT,CAAuB,OAAvB,CAAR;AACAyrB,gBAAQ,CAACrf,WAAT,CAAqBqF,KAArB;AACH;AACJ;;AACDiF,gBAAY,GAAG,IAAIuH,8DAAJ,CAAexM,KAAf,CAAf;AACAF,qEAAY,CAACC,OAAb,CAAqBC,KAArB,EAA4BhS,OAAO,CAACkK,WAAR,CAAoBT,WAAhD,EACKgJ,IADL,CACU;AAAA,aAAMwE,YAAY,CAAC6D,OAAb,CAAqB,WAArB,CAAN;AAAA,KADV,EACmD,UAAAoR,GAAG;AAAA,aAAIpoB,QAAQ,CAACooB,GAAD,CAAZ;AAAA,KADtD;AAEH;;AAEDjV,cAAY,CAAC5E,YAAb,CAA0B,SAA1B,EAAqC,MAArC;;AACA4E,cAAY,CAACpX,MAAb,GAAsBG,OAAO,CAACkK,WAA9B;;AACA+M,cAAY,CAAC1E,gBAAb,CAA8B,WAA9B,EAA2C4Z,UAAU,CAACxZ,IAAX,CAAgB,IAAhB,EAAsB7O,QAAtB,CAA3C;AACH;;AAED,SAASmoB,YAAT,GAAqC;AACjC,MAAMG,MAAM,GAAGpsB,OAAO,CAACkK,WAAR,CAAoBkiB,MAAnC,CADiC,CAEjC;;AACA,MAAIA,MAAM,YAAYC,WAAtB,EAAmC;AAC/B,WAAOD,MAAP;AACH,GAFD,MAEO;AACH;AACA,QAAME,QAAQ,GAAG,OAAOF,MAAP,KAAkB,QAAlB,GAA6BA,MAA7B,GAAsC,uBAAvD;AACA,WAAO9rB,QAAQ,CAACkM,aAAT,CAAuB8f,QAAvB,CAAP;AACH;AACJ;;AAED,SAASH,UAAT,CAAoB1B,EAApB,EAA0C;AACtC7N,0FAAqB,CAAC3F,YAAD,EAAejX,OAAO,CAACoL,OAAvB,CAArB;;AACAmW,aAAW;;AACXuI,eAAa,GAAG,IAAI/S,iEAAJ,CAAiBE,YAAjB,EAA+B+S,gBAAgB,CAACE,GAAjB,CAAqB7R,KAApD,CAAhB;;AAEA0S,mBAAiB,CAAC/qB,OAAO,CAAC4K,YAAT,EAAuB,YAAM;AAC1C,QAAI5K,OAAO,CAAC4K,YAAR,KAAyB,CAA7B,EAAgC;AAC5B+f,qBAAe;AAClB;;AAED1T,gBAAY,CAACzE,IAAb;;AACAiY,MAAE;AACL,GAPgB,CAAjB;AAQH;;AAED,SAASlJ,WAAT,GAA6B;AACzB,MAAI,OAAOjhB,QAAP,KAAoB,WAAxB,EAAqC;AACjC,QAAM0rB,QAAQ,GAAGC,YAAY,EAA7B;;AACAjC,oBAAgB,CAACE,GAAjB,CAAqB7R,KAArB,GAA6B/X,QAAQ,CAACkM,aAAT,CAAuB,kBAAvB,CAA7B;;AACA,QAAI,CAACwd,gBAAgB,CAACE,GAAjB,CAAqB7R,KAA1B,EAAiC;AAC7B2R,sBAAgB,CAACE,GAAjB,CAAqB7R,KAArB,GAA6B/X,QAAQ,CAACC,aAAT,CAAuB,QAAvB,CAA7B;AACAypB,sBAAgB,CAACE,GAAjB,CAAqB7R,KAArB,CAA2B3L,SAA3B,GAAuC,WAAvC;;AACA,UAAIsf,QAAQ,IAAIhsB,OAAO,CAACkK,WAAR,CAAoB/F,IAApB,KAA6B,aAA7C,EAA4D;AACxD6nB,gBAAQ,CAACrf,WAAT,CAAqBqd,gBAAgB,CAACE,GAAjB,CAAqB7R,KAA1C;AACH;AACJ;;AACD2R,oBAAgB,CAACC,GAAjB,CAAqB5R,KAArB,GAA6B2R,gBAAgB,CAACE,GAAjB,CAAqB7R,KAArB,CAA2B5X,UAA3B,CAAsC,IAAtC,CAA7B;AACAupB,oBAAgB,CAACE,GAAjB,CAAqB7R,KAArB,CAA2BpX,KAA3B,GAAmCgW,YAAY,CAACG,WAAhD;AACA4S,oBAAgB,CAACE,GAAjB,CAAqB7R,KAArB,CAA2BnX,MAA3B,GAAoC+V,YAAY,CAACK,YAAjD;AAEA0S,oBAAgB,CAACE,GAAjB,CAAqBjG,OAArB,GAA+B3jB,QAAQ,CAACkM,aAAT,CAAuB,sBAAvB,CAA/B;;AACA,QAAI,CAACwd,gBAAgB,CAACE,GAAjB,CAAqBjG,OAA1B,EAAmC;AAC/B+F,sBAAgB,CAACE,GAAjB,CAAqBjG,OAArB,GAA+B3jB,QAAQ,CAACC,aAAT,CAAuB,QAAvB,CAA/B;AACAypB,sBAAgB,CAACE,GAAjB,CAAqBjG,OAArB,CAA6BvX,SAA7B,GAAyC,eAAzC;;AACA,UAAIsf,QAAJ,EAAc;AACVA,gBAAQ,CAACrf,WAAT,CAAqBqd,gBAAgB,CAACE,GAAjB,CAAqBjG,OAA1C;AACH;;AACD,UAAMsI,QAAQ,GAAGjsB,QAAQ,CAACC,aAAT,CAAuB,IAAvB,CAAjB;AACAgsB,cAAQ,CAACla,YAAT,CAAsB,OAAtB,EAA+B,KAA/B;;AACA,UAAI2Z,QAAJ,EAAc;AACVA,gBAAQ,CAACrf,WAAT,CAAqB4f,QAArB;AACH;AACJ;;AACDvC,oBAAgB,CAACC,GAAjB,CAAqBhG,OAArB,GAA+B+F,gBAAgB,CAACE,GAAjB,CAAqBjG,OAArB,CAA6BxjB,UAA7B,CAAwC,IAAxC,CAA/B;AACAupB,oBAAgB,CAACE,GAAjB,CAAqBjG,OAArB,CAA6BhjB,KAA7B,GAAqCgW,YAAY,CAACG,WAAlD;AACA4S,oBAAgB,CAACE,GAAjB,CAAqBjG,OAArB,CAA6B/iB,MAA7B,GAAsC+V,YAAY,CAACK,YAAnD;AACH;AACJ;;AAED,SAASgK,YAAT,CAAsBta,YAAtB,EAAyD;AACrD,MAAIA,YAAJ,EAAkB;AACdoF,sBAAkB,GAAGpF,YAArB;AACH,GAFD,MAEO;AACHoF,sBAAkB,GAAG,IAAI3F,kEAAJ,CAAiB;AAClC1D,OAAC,EAAEkU,YAAY,CAAChW,KADkB;AAElC+B,OAAC,EAAEiU,YAAY,CAAC/V;AAFkB,KAAjB,CAArB;AAIH;;AAED,MAAIoL,IAAJ,EAA2C;AACvCkC,WAAO,CAACC,GAAR,CAAYrC,kBAAkB,CAAC1F,IAA/B;AACH;;AACD0jB,UAAQ,GAAG,CACP;AAAErnB,KAAC,EAAE,CAAL;AAAQC,KAAC,EAAE;AAAX,GADO,EAEP;AAAED,KAAC,EAAE,CAAL;AAAQC,KAAC,EAAEoJ,kBAAkB,CAAC1F,IAAnB,CAAwB1D;AAAnC,GAFO,EAGP;AAAED,KAAC,EAAEqJ,kBAAkB,CAAC1F,IAAnB,CAAwB3D,CAA7B;AAAgCC,KAAC,EAAEoJ,kBAAkB,CAAC1F,IAAnB,CAAwB1D;AAA3D,GAHO,EAIP;AAAED,KAAC,EAAEqJ,kBAAkB,CAAC1F,IAAnB,CAAwB3D,CAA7B;AAAgCC,KAAC,EAAE;AAAnC,GAJO,CAAX;AAMAmnB,UAAQ,GAAG,IAAI/I,wEAAJ,CAAmBhV,kBAAnB,EAAuCpM,OAAO,CAACoL,OAA/C,CAAX;AACH;;AAED,SAASohB,UAAT,CAAoBC,OAApB,EAAmDvX,MAAnD,EAAwE;AACpEuX,SAAO,CAACrqB,OAAR,CAAgB,UAAAqhB,MAAM,EAAI;AACtBA,UAAM,CAAC1gB,CAAP,IAAYmS,MAAM,CAACnS,CAAnB;AACA0gB,UAAM,CAACzgB,CAAP,IAAYkS,MAAM,CAAClS,CAAnB;AACH,GAHD;AAIH;;AAED,SAAS0pB,gBAAT,CAA0B1rB,MAA1B,EAAiDkU,MAAjD,EAAsE;AAClE,MAAIlU,MAAM,CAACqM,QAAX,EAAqB;AACjBrM,UAAM,CAACqM,QAAP,CAAgBjL,OAAhB,CAAwB,UAAA+K,OAAO;AAAA,aAAIuf,gBAAgB,CAACvf,OAAD,EAAU+H,MAAV,CAApB;AAAA,KAA/B;AACH;;AAED,MAAIlU,MAAM,CAAC0M,IAAX,EAAiB;AACb8e,cAAU,CAACxrB,MAAM,CAAC0M,IAAR,EAAcwH,MAAd,CAAV;AACH;;AAED,MAAIlU,MAAM,CAACuM,GAAX,EAAgB;AACZif,cAAU,CAACxrB,MAAM,CAACuM,GAAR,EAAa2H,MAAb,CAAV;AACH;;AAED,MAAIlU,MAAM,CAACkM,KAAX,EAAkB;AACdlM,UAAM,CAACkM,KAAP,CAAa9K,OAAb,CAAqB,UAAAmL,GAAG;AAAA,aAAIif,UAAU,CAACjf,GAAD,EAAM2H,MAAN,CAAd;AAAA,KAAxB;AACH;AACJ;;AAED,SAASyX,UAAT,CAAoB3rB,MAApB,EAA2CkF,SAA3C,EAAkEkR,WAAlE,EAAuFE,YAAvF,EAAmH;AAC/G,MAAIpR,SAAS,IAAIskB,gBAAjB,EAAmC;AAC/B,QAAIxpB,MAAM,CAACqM,QAAX,EAAqB;AACjBrM,YAAM,CAACqM,QAAP,CAAgBjL,OAAhB,CAAwB,iBAAoB;AAAA,YAAjBvB,UAAiB,SAAjBA,UAAiB;;AACxC,YAAIA,UAAJ,EAAgB;AACZ2pB,0BAAgB,CAACuB,SAAjB,CAA2B7lB,SAA3B,EAAsCkR,WAAtC,EAAmDE,YAAnD,EAAiEzW,UAAjE;AACH;AACJ,OAJD;AAKH,KAND,MAMO,IAAIG,MAAM,CAACH,UAAX,EAAuB;AAC1B2pB,sBAAgB,CAACuB,SAAjB,CAA2B7lB,SAA3B,EAAsCkR,WAAtC,EAAmDE,YAAnD,EAAiEtW,MAAM,CAACH,UAAxE;AACH;AACJ;AACJ;;AAED,SAAS+rB,cAAT,CAAwB5rB,MAAxB,EAAwD;AACpD,SAAOA,MAAM,KAAK,CAAC,CAACA,MAAM,CAACH,UAAT,IAAuBG,MAAM,CAACqM,QAAP,IAAmBrM,MAAM,CAACqM,QAAP,CAAgB5L,IAAhB,CAAqB,UAAA0L,OAAO;AAAA,WAAI,CAAC,CAACA,OAAO,CAACtM,UAAd;AAAA,GAA5B,CAA/C,CAAb;AACH;;AAED,SAASgsB,cAAT,CAAwB7rB,MAAxB,EAAgDkF,SAAhD,EAA8E;AAC1E,MAAI4mB,eAAqD,GAAG9rB,MAA5D;;AAEA,MAAIA,MAAM,IAAIupB,WAAd,EAA2B;AACvB,QAAMrV,MAAM,GAAG+B,YAAY,CAACS,OAA5B;;AAEA,QAAIxC,MAAM,CAACnS,CAAP,KAAa,CAAb,IAAkBmS,MAAM,CAAClS,CAAP,KAAa,CAAnC,EAAsC;AAClC0pB,sBAAgB,CAAC1rB,MAAD,EAASkU,MAAT,CAAhB;AACH;;AAEDyX,cAAU,CAAC3rB,MAAD,EAASkF,SAAT,EAAoB+Q,YAAY,CAACG,WAAjC,EAA8CH,YAAY,CAACK,YAA3D,CAAV;;AACAwV,mBAAe,GAAG9rB,MAAM,CAACqM,QAAP,IAAmBrM,MAArC;AACH;;AAED4C,uDAAM,CAACmpB,OAAP,CAAe,WAAf,EAA4BD,eAA5B;;AACA,MAAIF,cAAc,CAAC5rB,MAAD,CAAlB,EAA4B;AACxB4C,yDAAM,CAACmpB,OAAP,CAAe,UAAf,EAA2BD,eAA3B;AACH;AACJ;;AAED,SAASE,gBAAT,GAAkC;AAC9B,MAAM9f,KAAK,GAAGlN,OAAO,CAAC2K,MAAR,GAAiBwf,QAAQ,CAACxf,MAAT,EAAjB,GAAqC,CAACyf,QAAD,CAAnD;;AACA,MAAMppB,MAAM,GAAGqpB,QAAQ,CAAC4C,uBAAT,CAAiC/f,KAAjC,CAAf;;AACA2f,gBAAc,CAAC7rB,MAAD,EAASoL,kBAAkB,CAAC1L,IAA5B,CAAd;AACH;;AAED,SAASoqB,OAAT,GAAyB;AACrB,MAAIP,WAAJ,EAAiB;AACb,QAAID,WAAW,CAACjnB,MAAZ,GAAqB,CAAzB,EAA4B;AACxB,UAAM6pB,eAAe,GAAG5C,WAAW,CAAC/nB,IAAZ,CAAiB;AAAA,YAAG4qB,IAAH,SAAGA,IAAH;AAAA,eAAc,CAACA,IAAf;AAAA,OAAjB,CAAxB;;AACA,UAAI,CAACD,eAAL,EAAsB;AAClB,eADkB,CACV;AACX;;AAED,UAAMhnB,SAAS,GAAGgnB,eAAe,CAAChnB,SAAlC;;AAEA,UAAI4jB,aAAa,CAACsD,IAAd,CAAmBlnB,SAAnB,CAAJ,EAAmC;AAC/BgnB,uBAAe,CAACC,IAAhB,GAAuB,IAAvB;AACAD,uBAAe,CAACxB,MAAhB,CAAuBC,WAAvB,CAAmC;AAAEC,aAAG,EAAE,SAAP;AAAkB1lB,mBAAS,EAATA;AAAlB,SAAnC,EAAkE,CAACA,SAAS,CAACqO,MAAX,CAAlE;AACH;AACJ,KAZD,MAYO,IAAIuV,aAAa,CAACsD,IAAd,CAAmBhhB,kBAAkB,CAAC1L,IAAtC,CAAJ,EAAiD;AACpDssB,sBAAgB;AACnB;AACJ,GAhBD,MAgBO;AACHA,oBAAgB;AACnB;AACJ;;AAED,SAASnC,sBAAT,GAAwC;AACpC,MAAMwC,KAAK,GAAG,QAAQrtB,OAAO,CAACstB,SAAR,IAAqB,EAA7B,CAAd;AACA,MAAI5F,IAAI,GAAG,IAAX;AACAqC,UAAQ,GAAG,KAAX;;AAEC,YAAS1oB,KAAT,CAAeksB,SAAf,EAAgC;AAC7B7F,QAAI,GAAGA,IAAI,IAAI6F,SAAf;;AACA,QAAI,CAACxD,QAAL,EAAe;AACX,UAAIwD,SAAS,IAAI7F,IAAjB,EAAuB;AACnBA,YAAI,IAAI2F,KAAR;;AACAvC,eAAO;AACV;;AACD/W,YAAM,CAACyZ,qBAAP,CAA6BnsB,KAA7B;AACH;AACJ,GATA,EASCosB,WAAW,CAACC,GAAZ,EATD,CAAD;AAUH;;AAED,SAASC,WAAT,CAAqBlD,EAArB,EAAqE;AACjE,MAAMmD,OAAO,GAAGC,mBAAmB,EAAnC;;AACA,MAAMC,YAAY,GAAG;AACjBpC,UAAM,EAAE,IAAIqC,MAAJ,CAAWH,OAAX,CADS;AAEjB1nB,aAAS,EAAE,IAAIW,UAAJ,CAAeoQ,YAAY,CAAChW,KAAb,GAAqBgW,YAAY,CAAC/V,MAAjD,CAFM;AAGjBisB,QAAI,EAAE;AAHW,GAArB;;AAMAW,cAAY,CAACpC,MAAb,CAAoBsC,SAApB,GAAgC,iBAAc;AAAA,QAAXttB,IAAW,SAAXA,IAAW;;AAC1C,QAAIA,IAAI,CAACmD,KAAL,KAAe,aAAnB,EAAkC;AAC9BoqB,SAAG,CAACC,eAAJ,CAAoBN,OAApB;AACAE,kBAAY,CAACX,IAAb,GAAoB,KAApB;AACAW,kBAAY,CAAC5nB,SAAb,GAAyB,IAAIW,UAAJ,CAAenG,IAAI,CAACwF,SAApB,CAAzB;;AACA,UAAIoG,IAAJ,EAA2C;AACvCkC,eAAO,CAACC,GAAR,CAAY,oBAAZ;AACH;;AACDgc,QAAE,CAACqD,YAAD,CAAF;AACH,KARD,MAQO,IAAIptB,IAAI,CAACmD,KAAL,KAAe,WAAnB,EAAgC;AACnCiqB,kBAAY,CAACX,IAAb,GAAoB,KAApB;AACAW,kBAAY,CAAC5nB,SAAb,GAAyB,IAAIW,UAAJ,CAAenG,IAAI,CAACwF,SAApB,CAAzB;;AACA2mB,oBAAc,CAACnsB,IAAI,CAACM,MAAN,EAAc8sB,YAAY,CAAC5nB,SAA3B,CAAd;AACH,KAJM,MAIA,IAAIxF,IAAI,CAACmD,KAAL,KAAe,OAAnB,EAA4B;AAC/B,UAAIyI,IAAJ,EAA2C;AACvCkC,eAAO,CAACC,GAAR,CAAY,eAAZ,EAA6B/N,IAAI,CAACytB,OAAlC;AACH;AACJ;AACJ,GAlBD;;AAoBAL,cAAY,CAACpC,MAAb,CAAoBC,WAApB,CAAgC;AAC5BC,OAAG,EAAE,MADuB;AAE5BllB,QAAI,EAAE;AAAE3D,OAAC,EAAEkU,YAAY,CAAChW,KAAlB;AAAyB+B,OAAC,EAAEiU,YAAY,CAAC/V;AAAzC,KAFsB;AAG5BgF,aAAS,EAAE4nB,YAAY,CAAC5nB,SAHI;AAI5BrG,UAAM,EAAE6J,2DAAK,CAAC1J,OAAD,EAAU;AAAEkK,iBAAW,EAAE;AAAEkiB,cAAM,EAAE;AAAV;AAAf,KAAV;AAJe,GAAhC,EAKG,CAAC0B,YAAY,CAAC5nB,SAAb,CAAuBqO,MAAxB,CALH;AAMH;;AAED,SAAS6Z,gBAAT,CAA0BC,OAA1B,EAAmD;AAC/C,MAAIC,MAAJ;AACA,MAAM5C,MAAW,GAAGhJ,IAApB;AACA,MAAI1b,YAAJ;;AAEA,MAAIqnB,OAAJ,EAAa;AACTC,UAAM,GAAGD,OAAO,aAAhB;;AACA,QAAI,CAACC,MAAL,EAAa;AACT5C,YAAM,CAACC,WAAP,CAAmB;AAAE9nB,aAAK,EAAE,OAAT;AAAkBsqB,eAAO,EAAE;AAA3B,OAAnB;AACA;AACH;AACJ;;AAEDzL,MAAI,CAACsL,SAAL,GAAiB,iBAAc;AAAA,QAAXttB,IAAW,SAAXA,IAAW;;AAC3B,QAAIA,IAAI,CAACkrB,GAAL,KAAa,MAAjB,EAAyB;AACrB,UAAM/rB,MAAoB,GAAGa,IAAI,CAACb,MAAlC;AACAA,YAAM,CAAC+K,YAAP,GAAsB,CAAtB;AACA5D,kBAAY,GAAG,IAAIsnB,MAAM,CAAC7nB,YAAX,CAAwB;AAAE1D,SAAC,EAAErC,IAAI,CAACgG,IAAL,CAAU3D,CAAf;AAAkBC,SAAC,EAAEtC,IAAI,CAACgG,IAAL,CAAU1D;AAA/B,OAAxB,EAA4D,IAAI6D,UAAJ,CAAenG,IAAI,CAACwF,SAApB,CAA5D,CAAf;AACAooB,YAAM,CAACnO,IAAP,CACItgB,MADJ,EAEI;AAAA,eAAM6rB,MAAM,CAACC,WAAP,CACF;AAAE9nB,eAAK,EAAE,aAAT;AAAwBqC,mBAAS,EAAEc,YAAY,CAACtG;AAAhD,SADE,EACsD,CAACsG,YAAY,CAACtG,IAAb,CAAkB6T,MAAnB,CADtD,CAAN;AAAA,OAFJ,EAKIvN,YALJ;AAOAsnB,YAAM,CAAC/C,WAAP,CAAmB,UAACvqB,MAAD;AAAA,eACf0qB,MAAM,CAACC,WAAP,CACI;AAAE9nB,eAAK,EAAE,WAAT;AAAsBqC,mBAAS,EAAEc,YAAY,CAACtG,IAA9C;AAAoDM,gBAAM,EAANA;AAApD,SADJ,EACkE,CAACgG,YAAY,CAACtG,IAAb,CAAkB6T,MAAnB,CADlE,CADe;AAAA,OAAnB;AAKH,KAhBD,MAgBO,IAAI7T,IAAI,CAACkrB,GAAL,KAAa,SAAjB,EAA4B;AAC/B5kB,kBAAY,CAACtG,IAAb,GAAoB,IAAImG,UAAJ,CAAenG,IAAI,CAACwF,SAApB,CAApB;AACAooB,YAAM,CAACzY,KAAP;AACH,KAHM,MAGA,IAAInV,IAAI,CAACkrB,GAAL,KAAa,YAAjB,EAA+B;AAClC0C,YAAM,CAAC7C,UAAP,CAAkB/qB,IAAI,CAACoK,OAAvB;AACH;AACJ,GAvBD;AAwBH;;AAED,SAAS+iB,mBAAT,GAAuC;AACnC;AACA,MAAIU,aAAqB,GAAGC,iBAAiB,IAAI,EAAjD;AACA,MAAMC,IAAI,GAAG,IAAIC,IAAJ,CAAS,YAAKN,gBAAgB,CAACO,QAAjB,EAAL,eAAqCJ,aAArC,QAAT,EAAkE;AAAEpqB,QAAI,EAAE;AAAR,GAAlE,CAAb;AAEA,SAAO4P,MAAM,CAACka,GAAP,CAAWW,eAAX,CAA2BH,IAA3B,CAAP;AACH;;AAED,SAAS1D,iBAAT,CAA2B7qB,QAA3B,EAA6CuqB,EAA7C,EAAoE;AAChE,MAAMoE,UAAU,GAAG3uB,QAAQ,GAAGoqB,WAAW,CAACjnB,MAA1C;;AAEA,MAAIwrB,UAAU,GAAG,CAAjB,EAAoB;AAChB,SAAK,IAAIxnB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGwnB,UAApB,EAAgCxnB,CAAC,EAAjC,EAAqC;AACjCsmB,iBAAW,CAAC,UAAAG,YAAY,EAAI;AACxBxD,mBAAW,CAAC/oB,IAAZ,CAAiBusB,YAAjB;;AACA,YAAIxD,WAAW,CAACjnB,MAAZ,IAAsBnD,QAAtB,IAAkCuqB,EAAtC,EAA0C;AACtCA,YAAE;AACL;AACJ,OALU,CAAX;AAMH;AACJ,GATD,MASO;AACH,QAAIoE,UAAU,GAAG,CAAjB,EAAoB;AAChBvE,iBAAW,CAACxkB,KAAZ,CAAkB+oB,UAAlB,EAA8BzsB,OAA9B,CAAsC,iBAAgB;AAAA,YAAbspB,MAAa,SAAbA,MAAa;AAClDA,cAAM,CAACoD,SAAP;;AACA,YAAIxiB,IAAJ,EAA2C;AACvCkC,iBAAO,CAACC,GAAR,CAAY,oBAAZ;AACH;AACJ,OALD;;AAMA6b,iBAAW,GAAGA,WAAW,CAACxkB,KAAZ,CAAkB,CAAlB,EAAqB+oB,UAArB,CAAd;AACH;;AACD,WAAOpE,EAAE,IAAIA,EAAE,EAAf;AACH;AACJ,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxeD;AAEA,IAAMsE,CAAC,GAAG,CAAV;AACA,IAAMC,CAAC,GAAG,CAAV;AACA,IAAMC,aAAa,GAAG,CAACD,CAAD,EAAID,CAAJ,EAAOC,CAAP,EAAUD,CAAV,EAAaA,CAAb,EAAgBA,CAAhB,CAAtB;AACA,IAAMG,YAAY,GAAG,CAACF,CAAD,EAAID,CAAJ,EAAOA,CAAP,EAAUA,CAAV,EAAaC,CAAb,CAArB;AACA,IAAMG,YAAY,GAAG,CACjB,CAACJ,CAAD,EAAIA,CAAJ,EAAOC,CAAP,EAAUA,CAAV,EAAaD,CAAb,CADiB,EAEjB,CAACC,CAAD,EAAID,CAAJ,EAAOA,CAAP,EAAUA,CAAV,EAAaC,CAAb,CAFiB,EAGjB,CAACD,CAAD,EAAIC,CAAJ,EAAOD,CAAP,EAAUA,CAAV,EAAaC,CAAb,CAHiB,EAIjB,CAACA,CAAD,EAAIA,CAAJ,EAAOD,CAAP,EAAUA,CAAV,EAAaA,CAAb,CAJiB,EAKjB,CAACA,CAAD,EAAIA,CAAJ,EAAOC,CAAP,EAAUD,CAAV,EAAaC,CAAb,CALiB,EAMjB,CAACA,CAAD,EAAID,CAAJ,EAAOC,CAAP,EAAUD,CAAV,EAAaA,CAAb,CANiB,EAOjB,CAACA,CAAD,EAAIC,CAAJ,EAAOA,CAAP,EAAUD,CAAV,EAAaA,CAAb,CAPiB,EAQjB,CAACA,CAAD,EAAIA,CAAJ,EAAOA,CAAP,EAAUC,CAAV,EAAaA,CAAb,CARiB,EASjB,CAACA,CAAD,EAAID,CAAJ,EAAOA,CAAP,EAAUC,CAAV,EAAaD,CAAb,CATiB,EAUjB,CAACA,CAAD,EAAIC,CAAJ,EAAOD,CAAP,EAAUC,CAAV,EAAaD,CAAb,CAViB,CAArB;AAYA,IAAMK,kBAAkB,GAAGH,aAAa,CAAC/rB,MAAd,CAAqB,UAACC,GAAD,EAAM6E,GAAN;AAAA,SAAc7E,GAAG,GAAG6E,GAApB;AAAA,CAArB,EAA8C,CAA9C,CAA3B;AAEO,IAAMqnB,eAAb;AAAA;AAAA;AAAA;;AAGI,2BAAYxvB,MAAZ,EAA0C;AAAA;;AAAA;;AACtC,mNAAMA,MAAN;;AADsC;;AAGtC,UAAKyvB,cAAL,GAAsB,CAAC,CAAD,EAAI,CAAJ,CAAtB;AACA,UAAKC,OAAL,GAAe,MAAf;AACA,UAAKC,gBAAL,GAAwB,IAAxB;AACA,UAAKC,iBAAL,GAAyB,IAAzB;AANsC;AAOzC;;AAVL;AAAA;AAAA,6BAYsB;AACd,UAAMC,SAAS,GAAG,KAAKC,UAAL,EAAlB;;AAEA,UAAI,CAACD,SAAL,EAAgB;AACZ,eAAO,IAAP;AACH;;AAED,UAAME,OAAO,GAAG,KAAKC,QAAL,EAAhB;;AAEA,UAAI,CAACD,OAAL,EAAc;AACV,eAAO,IAAP;AACH;;AAED,UAAME,QAAQ,GAAG,KAAKC,aAAL,CAAmBL,SAAS,CAACtP,GAA7B,EAAkCwP,OAAO,CAAC/Z,KAA1C,EAAiD,CAAjD,CAAjB;;AAEA,UAAIia,QAAQ,CAACzsB,MAAT,GAAkB,EAAlB,KAAyB,CAA7B,EAAgC;AAC5B,eAAO,IAAP;AACH;;AAED,UAAMrC,MAAM,GAAG,IAAIjB,KAAJ,EAAf;AACA,UAAMiwB,YAAY,GAAG,IAAIjwB,KAAJ,EAArB;AAEAiwB,kBAAY,CAACzuB,IAAb,CAAkBmuB,SAAlB;;AAEA,UAAMO,IAAI,GAAG,KAAKC,cAAL,CAAoBJ,QAApB,EAA8B9uB,MAA9B,EAAsCgvB,YAAtC,CAAb;;AAEA,UAAI,CAACC,IAAD,IAASjvB,MAAM,CAACqC,MAAP,GAAgB,CAA7B,EAAgC;AAC5B,eAAO,IAAP;AACH;;AAED2sB,kBAAY,CAACzuB,IAAb,CAAkBquB,OAAlB;AAEA,aAAO;AACHK,YAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CADH;AAEH3O,aAAK,EAAE6Z,SAAS,CAAC7Z,KAFd;AAGHuK,WAAG,EAAEwP,OAAO,CAACxP,GAHV;AAIHsP,iBAAS,EAATA,SAJG;AAKHM,oBAAY,EAAZA;AALG,OAAP;AAOH;AAnDL;AAAA;AAAA,iCAqDwC;AAChC,UAAI9a,MAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,CAAb;;AACA,UAAIC,cAAc,GAAG,CAArB;AACA,UAAIX,SAAJ;;AAEA,aAAO,CAACA,SAAR,EAAmB;AACfA,iBAAS,GAAG,KAAKY,YAAL,CAAkBrB,aAAlB,EAAiC/Z,MAAjC,EAAyC,CAAzC,EAA4C,IAA5C,CAAZ;;AAEA,YAAI,CAACwa,SAAL,EAAgB;AACZ,iBAAO,IAAP;AACH;;AAEDW,sBAAc,GAAG,CAACX,SAAS,CAACtP,GAAV,GAAgBsP,SAAS,CAAC7Z,KAA3B,IAAoCuZ,kBAApC,GAAyD,CAA1E;AACA,YAAMmB,sBAAsB,GAAGb,SAAS,CAAC7Z,KAAV,GAAkBwa,cAAc,GAAG,CAAlE;;AAEA,YAAIE,sBAAsB,IAAI,CAA9B,EAAiC;AAC7B,cAAI,KAAKC,WAAL,CAAiBD,sBAAjB,EAAyCb,SAAS,CAAC7Z,KAAnD,EAA0D,CAA1D,CAAJ,EAAkE;AAC9D,mBAAO6Z,SAAP;AACH;AACJ;;AAEDxa,cAAM,GAAGwa,SAAS,CAACtP,GAAnB;AACAsP,iBAAS,GAAG,IAAZ;AACH;;AAED,aAAO,IAAP;AACH;AA/EL;AAAA;AAAA,8CAiFwCE,OAjFxC,EAiF2E;AACnE,UAAMa,qBAAqB,GAAGb,OAAO,CAACxP,GAAR,GAAc,CAACwP,OAAO,CAACxP,GAAR,GAAcwP,OAAO,CAAC/Z,KAAvB,IAAgC,CAA5E;;AAEA,UAAI4a,qBAAqB,GAAG,KAAKL,IAAL,CAAU/sB,MAAtC,EAA8C;AAC1C,YAAI,KAAKmtB,WAAL,CAAiBZ,OAAO,CAACxP,GAAzB,EAA8BqQ,qBAA9B,EAAqD,CAArD,CAAJ,EAA6D;AACzD,iBAAOb,OAAP;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AA3FL;AAAA;AAAA,+BA6FsC;AAC9B,WAAKQ,IAAL,CAAUM,OAAV;;AAEA,UAAMxb,MAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,CAAf;;AACA,UAAMR,OAAO,GAAG,KAAKU,YAAL,CAAkBpB,YAAlB,EAAgCha,MAAhC,EAAwC,CAAxC,EAA2C,IAA3C,CAAhB;;AAEA,WAAKkb,IAAL,CAAUM,OAAV;;AAEA,UAAId,OAAO,KAAK,IAAhB,EAAsB;AAClB,eAAO,IAAP;AACH,OAV6B,CAY9B;;;AACA,UAAM/Z,KAAK,GAAG+Z,OAAO,CAAC/Z,KAAtB;AACA+Z,aAAO,CAAC/Z,KAAR,GAAgB,KAAKua,IAAL,CAAU/sB,MAAV,GAAmBusB,OAAO,CAACxP,GAA3C;AACAwP,aAAO,CAACxP,GAAR,GAAc,KAAKgQ,IAAL,CAAU/sB,MAAV,GAAmBwS,KAAjC;AAEA,aAAO+Z,OAAO,KAAK,IAAZ,GAAmB,KAAKe,yBAAL,CAA+Bf,OAA/B,CAAnB,GAA6D,IAApE;AACH;AA/GL;AAAA;AAAA,gCAiH0BgB,OAjH1B,EAiHuE;AAC/D,UAAMC,SAAsB,GAAG;AAC3B5f,aAAK,EAAEqU,MAAM,CAACC,SADa;AAE3B0K,YAAI,EAAE,CAAC,CAFoB;AAG3Bpa,aAAK,EAAE,CAHoB;AAI3BuK,WAAG,EAAE;AAJsB,OAA/B;;AAOA,WAAK,IAAI6P,IAAI,GAAG,CAAhB,EAAmBA,IAAI,GAAGd,YAAY,CAAC9rB,MAAvC,EAA+C4sB,IAAI,EAAnD,EAAuD;AACnD,YAAMhf,KAAK,GAAG,KAAK6f,aAAL,CAAmBF,OAAnB,EAA4BzB,YAAY,CAACc,IAAD,CAAxC,CAAd;;AACA,YAAIhf,KAAK,GAAG4f,SAAS,CAAC5f,KAAtB,EAA6B;AACzB4f,mBAAS,CAACZ,IAAV,GAAiBA,IAAjB;AACAY,mBAAS,CAAC5f,KAAV,GAAkBA,KAAlB;AACH;AACJ;;AAED,aAAO4f,SAAS,CAAC5f,KAAV,GAAkB,KAAK8f,kBAAvB,GAA4CF,SAA5C,GAAwD,IAA/D;AACH;AAlIL;AAAA;AAAA,mCAoI6Bf,QApI7B,EAoI8D9uB,MApI9D,EAoIqFgvB,YApIrF,EAoIoI;AAC5H,UAAMgB,aAAa,GAAGlB,QAAQ,CAACzsB,MAA/B;AACA,UAAMutB,OAAO,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,CAAhB;AACA,UAAInf,GAAG,GAAG,CAAV;AACA,UAAIwe,IAAJ;;AAEA,aAAOxe,GAAG,GAAGuf,aAAb,EAA4B;AACxB,aAAK,IAAI3pB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AACxBupB,iBAAO,CAACvpB,CAAD,CAAP,GAAayoB,QAAQ,CAACre,GAAD,CAAR,GAAgB,KAAK6d,cAAL,CAAoB,CAApB,CAA7B;AACA7d,aAAG,IAAI,CAAP;AACH;;AAEDwe,YAAI,GAAG,KAAKgB,WAAL,CAAiBL,OAAjB,CAAP;;AAEA,YAAI,CAACX,IAAL,EAAW;AACP,iBAAO,IAAP;AACH;;AAEDjvB,cAAM,CAACO,IAAP,CAAY0uB,IAAI,CAACA,IAAjB;AACAD,oBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AACH;;AAED,aAAOA,IAAP;AACH;AA3JL;;AAAA;AAAA,EAAqCiB,6DAArC,E;;;;;;;;;;;;;;;;;;;;;;;;ACpBO,IAAKC,gBAAZ;;WAAYA,gB;AAAAA,kB,CAAAA,gB;AAAAA,kB,CAAAA,gB;GAAAA,gB,KAAAA,gB;;AAGX;AA0CM,IAAeD,aAAtB;AAAA;AAAA;AAAA;AAAA;AAAA,wBAiBoC;AAC5B,aAAO,KAAK1B,gBAAZ;AACH;AAnBL;AAAA;AAAA,wBAqBqC;AAC7B,aAAO,KAAKC,iBAAZ;AACH;AAvBL;AAAA;AAAA,wBAyBgC;AACxB,aAAO,KAAKF,OAAZ;AACH;AA3BL;AAAA;AAAA,wBAS2B;AACnB,aAAO;AACH6B,8BAAsB,EAAE,2BADrB;AAEHC,6BAAqB,EAAE,0BAFpB;AAGHC,gCAAwB,EAAE;AAHvB,OAAP;AAKH;AAfL;;AA6BI,yBAAYzxB,MAAZ,EAA0CyO,WAA1C,EAA8E;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAC1E,SAAKihB,OAAL,GAAe,SAAf;AACA,SAAKa,IAAL,GAAY,EAAZ;AACA,SAAKvwB,MAAL,GAAcA,MAAM,IAAI,EAAxB;AACA,SAAKyO,WAAL,GAAmBA,WAAnB;AACH;;AAlCL;AAAA;AAAA,iCAsC2BL,OAtC3B,EAsC2DiH,MAtC3D,EAsC2Eqc,OAtC3E,EAsC2FC,SAtC3F,EAsC4H;AACpH,UAAMZ,OAAO,GAAG,IAAI7wB,KAAJ,CAAkBkO,OAAO,CAAC5K,MAA1B,CAAhB;AACA,UAAMwtB,SAAsB,GAAG;AAC3B5f,aAAK,EAAEqU,MAAM,CAACC,SADa;AAE3B0K,YAAI,EAAE,CAAC,CAFoB;AAG3Bpa,aAAK,EAAE,CAHoB;AAI3BuK,WAAG,EAAE;AAJsB,OAA/B;AAMA,UAAMqR,OAAO,GAAG,KAAKV,kBAArB;AACA,UAAIW,UAAU,GAAG,CAAjB;;AAEA,UAAI,CAACxc,MAAL,EAAa;AACTA,cAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,CAAT;AACH;;AAEDQ,aAAO,CAAC9pB,IAAR,CAAa,CAAb;;AAEA,WAAK,IAAIO,CAAC,GAAG6N,MAAb,EAAqB7N,CAAC,GAAG,KAAK+oB,IAAL,CAAU/sB,MAAnC,EAA2CgE,CAAC,EAA5C,EAAgD;AAC5C,YAAI,KAAK+oB,IAAL,CAAU/oB,CAAV,IAAekqB,OAAnB,EAA4B;AACxBX,iBAAO,CAACc,UAAD,CAAP;AACH,SAFD,MAEO;AACH,cAAIA,UAAU,KAAKd,OAAO,CAACvtB,MAAR,GAAiB,CAApC,EAAuC;AACnC,gBAAM4N,KAAK,GAAG,KAAK6f,aAAL,CAAmBF,OAAnB,EAA4B3iB,OAA5B,CAAd;;AAEA,gBAAIgD,KAAK,GAAGwgB,OAAZ,EAAqB;AACjBZ,uBAAS,CAAC5f,KAAV,GAAkBA,KAAlB;AACA4f,uBAAS,CAAChb,KAAV,GAAkBxO,CAAC,GAAGupB,OAAO,CAAC1tB,MAAR,CAAe,UAACC,GAAD,EAAMoD,KAAN;AAAA,uBAAgBpD,GAAG,GAAGoD,KAAtB;AAAA,eAAf,EAA4C,CAA5C,CAAtB;AACAsqB,uBAAS,CAACzQ,GAAV,GAAgB/Y,CAAhB;AACA,qBAAOwpB,SAAP;AACH;;AAED,gBAAIW,SAAJ,EAAe;AACX,mBAAK,IAAI5f,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGgf,OAAO,CAACvtB,MAAR,GAAiB,CAArC,EAAwCuO,CAAC,EAAzC,EAA6C;AACzCgf,uBAAO,CAAChf,CAAD,CAAP,GAAagf,OAAO,CAAChf,CAAC,GAAG,CAAL,CAApB;AACH;;AACDgf,qBAAO,CAACA,OAAO,CAACvtB,MAAR,GAAiB,CAAlB,CAAP,GAA8B,CAA9B;AACAutB,qBAAO,CAACA,OAAO,CAACvtB,MAAR,GAAiB,CAAlB,CAAP,GAA8B,CAA9B;AACAquB,wBAAU;AACb,aAPD,MAOO;AACH,qBAAO,IAAP;AACH;AACJ,WApBD,MAoBO;AACHA,sBAAU;AACb;;AACDd,iBAAO,CAACc,UAAD,CAAP,GAAsB,CAAtB;AACAH,iBAAO,GAAGA,OAAO,GAAG,CAAH,GAAO,CAAxB;AACH;AACJ;;AACD,aAAO,IAAP;AACH;AAvFL;AAAA;AAAA,+BAyFyB7jB,IAzFzB,EAyFsDmI,KAzFtD,EAyF8E;AACtE,WAAK,IAAIxO,CAAC,GAAGwO,KAAK,IAAI,CAAtB,EAAyBxO,CAAC,GAAGqG,IAAI,CAACrK,MAAlC,EAA0CgE,CAAC,EAA3C,EAA+C;AAC3C,YAAI,CAACqG,IAAI,CAACrG,CAAD,CAAT,EAAc;AACV,iBAAOA,CAAP;AACH;AACJ;;AACD,aAAOqG,IAAI,CAACrK,MAAZ;AACH;AAhGL;AAAA;AAAA,6BAkGuBqK,IAlGvB,EAkGoDmI,KAlGpD,EAkG4E;AACpE,WAAK,IAAIxO,CAAC,GAAGwO,KAAK,IAAI,CAAtB,EAAyBxO,CAAC,GAAGqG,IAAI,CAACrK,MAAlC,EAA0CgE,CAAC,EAA3C,EAA+C;AAC3C,YAAIqG,IAAI,CAACrG,CAAD,CAAR,EAAa;AACT,iBAAOA,CAAP;AACH;AACJ;;AACD,aAAOqG,IAAI,CAACrK,MAAZ;AACH;AAzGL;AAAA;AAAA,gCA2G0BwS,KA3G1B,EA2GyCuK,GA3GzC,EA2GsD7Z,KA3GtD,EA2G8E;AACtE,WAAK,IAAIc,CAAC,GAAGwO,KAAK,GAAG,CAAR,GAAY,CAAZ,GAAgBA,KAA7B,EAAoCxO,CAAC,GAAG+Y,GAAxC,EAA6C/Y,CAAC,EAA9C,EAAkD;AAC9C,YAAI,KAAK+oB,IAAL,CAAU/oB,CAAV,MAAiBd,KAArB,EAA4B;AACxB,iBAAO,KAAP;AACH;AACJ;;AACD,aAAO,IAAP;AACH;AAlHL;AAAA;AAAA,kCAoH4BqqB,OApH5B,EAoH4DX,IApH5D,EAoHyF0B,cApHzF,EAoH0H;AAClH,UAAI1gB,KAAK,GAAG,CAAZ;AACA,UAAI9N,GAAG,GAAG,CAAV;AACA,UAAIyuB,MAAM,GAAG,CAAb;AAEAD,oBAAc,GAAGA,cAAc,IAAI,KAAKE,iBAAvB,IAA4C,CAA7D;;AAEA,WAAK,IAAIxqB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGupB,OAAO,CAACvtB,MAA5B,EAAoCgE,CAAC,EAArC,EAAyC;AACrClE,WAAG,IAAIytB,OAAO,CAACvpB,CAAD,CAAd;AACAuqB,cAAM,IAAI3B,IAAI,CAAC5oB,CAAD,CAAd;AACH;;AAED,UAAIlE,GAAG,GAAGyuB,MAAV,EAAkB;AACd,eAAOtM,MAAM,CAACC,SAAd;AACH;;AAED,UAAMuM,QAAQ,GAAG3uB,GAAG,GAAGyuB,MAAvB;AACAD,oBAAc,IAAIG,QAAlB;;AAEA,WAAK,IAAIzqB,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAGupB,OAAO,CAACvtB,MAA5B,EAAoCgE,EAAC,EAArC,EAAyC;AACrC,YAAM6c,KAAK,GAAG0M,OAAO,CAACvpB,EAAD,CAArB;AACA,YAAM0qB,MAAM,GAAG9B,IAAI,CAAC5oB,EAAD,CAAJ,GAAUyqB,QAAzB;AACA,YAAME,WAAW,GAAG1uB,IAAI,CAACI,GAAL,CAASwgB,KAAK,GAAG6N,MAAjB,IAA2BA,MAA/C;;AAEA,YAAIC,WAAW,GAAGL,cAAlB,EAAkC;AAC9B,iBAAOrM,MAAM,CAACC,SAAd;AACH;;AAEDtU,aAAK,IAAI+gB,WAAT;AACH;;AAED,aAAO/gB,KAAK,GAAG2gB,MAAf;AACH;AApJL;AAAA;AAAA,iCAsJ2BhB,OAtJ3B,EAsJmDqB,UAtJnD,EAsJuEC,OAtJvE,EAsJ+F;AACvF,UAAI7uB,MAAM,GAAG6uB,OAAO,CAAC7uB,MAArB;AACA,UAAIqF,GAAG,GAAG,CAAV;;AAEA,aAAOrF,MAAM,EAAb,EAAiB;AACbqF,WAAG,GAAGkoB,OAAO,CAACsB,OAAO,CAAC7uB,MAAD,CAAR,CAAP,IAA4B,IAAK,CAAC,IAAI4uB,UAAL,IAAmB,CAApD,CAAN;;AACA,YAAIvpB,GAAG,GAAG,CAAV,EAAa;AACTkoB,iBAAO,CAACsB,OAAO,CAAC7uB,MAAD,CAAR,CAAP,GAA2BqF,GAA3B;AACH;AACJ;AACJ;AAhKL;AAAA;AAAA,kCAkKkBuF,OAlKlB,EAkKmD;AAC3C,WAAKmiB,IAAL,GAAYniB,OAAZ;AACA,UAAIjN,MAAM,GAAG,KAAKmxB,MAAL,EAAb;;AAEA,UAAInxB,MAAM,KAAK,IAAf,EAAqB;AACjB,aAAKovB,IAAL,CAAUM,OAAV;;AACA1vB,cAAM,GAAG,KAAKmxB,MAAL,EAAT;;AACA,YAAInxB,MAAJ,EAAY;AACRA,gBAAM,CAACqkB,SAAP,GAAmB8L,gBAAgB,CAACiB,OAApC;AACApxB,gBAAM,CAAC6U,KAAP,GAAe,KAAKua,IAAL,CAAU/sB,MAAV,GAAmBrC,MAAM,CAAC6U,KAAzC;AACA7U,gBAAM,CAACof,GAAP,GAAa,KAAKgQ,IAAL,CAAU/sB,MAAV,GAAmBrC,MAAM,CAACof,GAAvC;AACH;AACJ,OARD,MAQO;AACHpf,cAAM,CAACqkB,SAAP,GAAmB8L,gBAAgB,CAACkB,OAApC;AACH;;AAED,UAAIrxB,MAAJ,EAAY;AACRA,cAAM,CAACuN,MAAP,GAAgB,KAAKK,MAArB;AACH;;AAED,aAAO5N,MAAP;AACH;AAvLL;AAAA;AAAA,kCAyLkBkU,MAzLlB,EAyLkCkL,GAzLlC,EAyL+CmR,OAzL/C,EAyL8E;AACtE,UAAMzB,QAAQ,GAAG,IAAI/vB,KAAJ,EAAjB;AACA,UAAI2xB,UAAU,GAAG,CAAjB;AAEA5B,cAAQ,CAAC4B,UAAD,CAAR,GAAuB,CAAvB;;AAEA,WAAK,IAAIrqB,CAAC,GAAG6N,MAAb,EAAqB7N,CAAC,GAAG+Y,GAAzB,EAA8B/Y,CAAC,EAA/B,EAAmC;AAC/B,YAAI,KAAK+oB,IAAL,CAAU/oB,CAAV,IAAekqB,OAAnB,EAA4B;AACxBzB,kBAAQ,CAAC4B,UAAD,CAAR;AACH,SAFD,MAEO;AACHA,oBAAU;AACV5B,kBAAQ,CAAC4B,UAAD,CAAR,GAAuB,CAAvB;AACAH,iBAAO,GAAGA,OAAO,GAAG,CAAH,GAAO,CAAxB;AACH;AACJ;;AAED,aAAOzB,QAAP;AACH;AA1ML;AAAA;AAAA,gCA4M0Bja,KA5M1B,EA4MyCia,QA5MzC,EA4M6E;AACrE,UAAMwC,WAAW,GAAGxC,QAAQ,CAACzsB,MAA7B;AACA,UAAM+c,GAAG,GAAG,KAAKgQ,IAAL,CAAU/sB,MAAtB;AACA,UAAIkuB,OAAc,GAAG,KAAKnB,IAAL,CAAUva,KAAV,IAAmB,CAAnB,GAAuB,CAA5C;AACA,UAAI6b,UAAU,GAAG,CAAjB;AAEA5B,cAAQ,CAAChpB,IAAT,CAAc,CAAd;;AAEA,WAAK,IAAIO,CAAC,GAAGwO,KAAb,EAAoBxO,CAAC,GAAG+Y,GAAxB,EAA6B/Y,CAAC,EAA9B,EAAkC;AAC9B,YAAI,KAAK+oB,IAAL,CAAU/oB,CAAV,IAAekqB,OAAnB,EAA4B;AACxBzB,kBAAQ,CAAC4B,UAAD,CAAR;AACH,SAFD,MAEO;AACHA,oBAAU;;AACV,cAAIA,UAAU,KAAKY,WAAnB,EAAgC;AAC5B;AACH,WAFD,MAEO;AACHxC,oBAAQ,CAAC4B,UAAD,CAAR,GAAuB,CAAvB;AACAH,mBAAO,GAAGA,OAAO,GAAG,CAAH,GAAO,CAAxB;AACH;AACJ;AACJ;;AAED,aAAOzB,QAAP;AACH;AAnOL;;AAAA;AAAA,I;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC7CA;AAEA,IAAMyC,gBAAgB,GAAG,sBAAzB;;AACA,IAAMC,QAAQ,GAAG,gFAAID,gBAAJ,EAAsBjlB,GAAtB,CAA0B,UAAAyI,KAAI;AAAA,SAAIA,KAAI,CAACE,UAAL,CAAgB,CAAhB,CAAJ;AAAA,CAA9B,CAAjB,C,CACA;;;AACA,IAAMwc,mBAAmB,GAAG,CAAC,KAAD,EAAQ,KAAR,EAAe,KAAf,EAAsB,KAAtB,EAA6B,KAA7B,EAAoC,KAApC,EAA2C,KAA3C,EAAkD,KAAlD,EAAyD,KAAzD,EAAgE,KAAhE,EAAuE,KAAvE,EAA8E,KAA9E,EAAqF,KAArF,EACxB,KADwB,EACjB,KADiB,EACV,KADU,EACH,KADG,EACI,KADJ,EACW,KADX,EACkB,KADlB,CAA5B;AAEA,IAAMC,SAAS,GAAG,CAAC,KAAD,EAAQ,KAAR,EAAe,KAAf,EAAsB,KAAtB,CAAlB;AACA,IAAMC,iBAAiB,GAAG,CAA1B;AACA,IAAMC,cAAc,GAAG,GAAvB;AACA,IAAMC,OAAO,GAAG,GAAhB;AAiCO,IAAMC,aAAb;AAAA;AAAA;AAAA;;AAGI,2BAAc;AAAA;;AAAA;;AACV;;AADU;;AAGV,UAAKvD,OAAL,GAAe,SAAf;AACA,UAAKwD,SAAL,GAAiB,EAAjB;AAJU;AAKb;;AARL;AAAA;AAAA,6BAUsB;AACd,WAAKA,SAAL,GAAiB,KAAKhD,aAAL,CAAmB,KAAKiD,UAAL,CAAgB,KAAK5C,IAArB,CAAnB,EAA+C,KAAKA,IAAL,CAAU/sB,MAAzD,EAAiE,CAAjE,CAAjB;;AAEA,UAAMwS,KAAK,GAAG,KAAK8Z,UAAL,EAAd;;AACA,UAAI,CAAC9Z,KAAL,EAAY;AACR,eAAO,IAAP;AACH;;AAED,UAAM7U,MAAM,GAAG,IAAIjB,KAAJ,EAAf;AACA,UAAIkzB,SAAS,GAAGpd,KAAK,CAACqd,YAAtB;AACA,UAAIjlB,OAAJ;;AAEA,SAAG;AACCA,eAAO,GAAG,KAAKklB,UAAL,CAAgBF,SAAhB,CAAV;;AACA,YAAIhlB,OAAO,GAAG,CAAd,EAAiB;AACb,iBAAO,IAAP;AACH;;AACD,YAAMmlB,WAAW,GAAG,KAAKC,cAAL,CAAoBplB,OAApB,CAApB;;AACA,YAAImlB,WAAW,KAAK,IAApB,EAA0B;AACtB,iBAAO,IAAP;AACH;;AACDpyB,cAAM,CAACO,IAAP,CAAY6xB,WAAZ;AACAH,iBAAS,IAAI,CAAb;;AACA,YAAIjyB,MAAM,CAACqC,MAAP,GAAgB,CAAhB,IAAqBqvB,SAAS,CAACjxB,IAAV,CAAe,UAAAwuB,IAAI;AAAA,iBAAIA,IAAI,KAAKhiB,OAAb;AAAA,SAAnB,CAAzB,EAAmE;AAC/D;AACH;AACJ,OAdD,QAcSglB,SAAS,GAAG,KAAKF,SAAL,CAAe1vB,MAdpC,EAZc,CA4Bd;;;AACA,UAAKrC,MAAM,CAACqC,MAAP,GAAgB,CAAjB,GAAsBsvB,iBAAtB,IAA2C,CAACD,SAAS,CAACjxB,IAAV,CAAe,UAAAwuB,IAAI;AAAA,eAAIA,IAAI,KAAKhiB,OAAb;AAAA,OAAnB,CAAhD,EAA0F;AACtF,eAAO,IAAP;AACH,OA/Ba,CAiCd;;;AACA,UAAI,CAAC,KAAKqlB,iBAAL,CAAuBzd,KAAK,CAACqd,YAA7B,EAA2CD,SAAS,GAAG,CAAvD,CAAL,EAAgE;AAC5D,eAAO,IAAP;AACH;;AAED,UAAI,CAAC,KAAKM,eAAL,CAAqBvyB,MAArB,EAA6B6U,KAAK,CAACqd,YAAnC,CAAL,EAAuD;AACnD,eAAO,IAAP;AACH;;AAEDD,eAAS,GAAGA,SAAS,GAAG,KAAKF,SAAL,CAAe1vB,MAA3B,GAAoC,KAAK0vB,SAAL,CAAe1vB,MAAnD,GAA4D4vB,SAAxE;;AACA,UAAM7S,GAAG,GAAGvK,KAAK,CAACA,KAAN,GAAc,KAAK2d,YAAL,CAAkB3d,KAAK,CAACqd,YAAxB,EAAsCD,SAAS,GAAG,CAAlD,CAA1B;;AAEA,aAAO;AACHhD,YAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CADH;AAEH3O,aAAK,EAAEA,KAAK,CAACA,KAFV;AAGHuK,WAAG,EAAHA,GAHG;AAIHsP,iBAAS,EAAE7Z,KAJR;AAKHma,oBAAY,EAAEhvB;AALX,OAAP;AAOH;AA9DL;AAAA;AAAA,sCAgEgCkyB,YAhEhC,EAgEsDO,UAhEtD,EAgEmF;AAC3E,UAAKP,YAAY,GAAG,CAAf,IAAoB,CAArB,IACG,KAAKH,SAAL,CAAeG,YAAY,GAAG,CAA9B,KAAqC,KAAKQ,uBAAL,CAA6BR,YAA7B,IAA6C,GADzF,EAC+F;AAC3F,YAAKO,UAAU,GAAG,CAAb,IAAkB,KAAKV,SAAL,CAAe1vB,MAAlC,IACG,KAAK0vB,SAAL,CAAeU,UAAU,GAAG,CAA5B,KAAmC,KAAKC,uBAAL,CAA6BD,UAA7B,IAA2C,GADrF,EAC2F;AACvF,iBAAO,IAAP;AACH;AACJ;;AAED,aAAO,KAAP;AACH;AA1EL;AAAA;AAAA,4CA4EoCve,MA5EpC,EA4E4D;AACpD,UAAI/R,GAAG,GAAG,CAAV;;AAEA,WAAK,IAAIkE,CAAC,GAAG6N,MAAb,EAAqB7N,CAAC,GAAG6N,MAAM,GAAG,CAAlC,EAAqC7N,CAAC,EAAtC,EAA0C;AACtClE,WAAG,IAAI,KAAK4vB,SAAL,CAAe1rB,CAAf,CAAP;AACH;;AAED,aAAOlE,GAAP;AACH;AApFL;AAAA;AAAA,4CAsFoCnC,MAtFpC,EAsFmEkyB,YAtFnE,EAsFoG;AAC5F,UAAMS,cAAyB,GAAG;AAC9BC,aAAK,EAAE;AACHC,gBAAM,EAAE;AAAEntB,gBAAI,EAAE,CAAR;AAAWotB,kBAAM,EAAE,CAAnB;AAAsBnjB,eAAG,EAAE,CAA3B;AAA8BC,eAAG,EAAE0U,MAAM,CAACC;AAA1C,WADL;AAEHwO,cAAI,EAAE;AAAErtB,gBAAI,EAAE,CAAR;AAAWotB,kBAAM,EAAE,CAAnB;AAAsBnjB,eAAG,EAAE,CAA3B;AAA8BC,eAAG,EAAE0U,MAAM,CAACC;AAA1C;AAFH,SADuB;AAK9ByO,WAAG,EAAE;AACDH,gBAAM,EAAE;AAAEntB,gBAAI,EAAE,CAAR;AAAWotB,kBAAM,EAAE,CAAnB;AAAsBnjB,eAAG,EAAE,CAA3B;AAA8BC,eAAG,EAAE0U,MAAM,CAACC;AAA1C,WADP;AAEDwO,cAAI,EAAE;AAAErtB,gBAAI,EAAE,CAAR;AAAWotB,kBAAM,EAAE,CAAnB;AAAsBnjB,eAAG,EAAE,CAA3B;AAA8BC,eAAG,EAAE0U,MAAM,CAACC;AAA1C;AAFL;AALyB,OAAlC;AAUA,UAAI9T,GAAG,GAAGyhB,YAAV;;AAEA,WAAK,IAAI7rB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGrG,MAAM,CAACqC,MAA3B,EAAmCgE,CAAC,EAApC,EAAwC;AACpC,YAAI4G,OAAO,GAAG,KAAKgmB,cAAL,CAAoBjzB,MAAM,CAACqG,CAAD,CAA1B,CAAd;;AAEA,aAAK,IAAIuK,CAAC,GAAG,CAAb,EAAgBA,CAAC,IAAI,CAArB,EAAwBA,CAAC,EAAzB,EAA6B;AACzB,cAAMsB,IAAI,GAAG,CAACtB,CAAC,GAAG,CAAL,MAAY,CAAZ,GAAgB+hB,cAAc,CAACK,GAA/B,GAAqCL,cAAc,CAACC,KAAjE;AACA,cAAMM,GAAG,GAAG,CAACjmB,OAAO,GAAG,CAAX,MAAkB,CAAlB,GAAsBiF,IAAI,CAAC6gB,IAA3B,GAAkC7gB,IAAI,CAAC2gB,MAAnD;AACAK,aAAG,CAACxtB,IAAJ,IAAY,KAAKqsB,SAAL,CAAethB,GAAG,GAAGG,CAArB,CAAZ;AACAsiB,aAAG,CAACJ,MAAJ;AACA7lB,iBAAO,KAAK,CAAZ;AACH;;AACDwD,WAAG,IAAI,CAAP;AACH;;AAED,OAAC,OAAD,EAAU,KAAV,EAAiBrP,OAAjB,CAAyB,UAAAN,GAAG,EAAI;AAC5B,YAAMoR,IAAI,GAAGygB,cAAc,CAAC7xB,GAAD,CAA3B;AACAoR,YAAI,CAAC6gB,IAAL,CAAUpjB,GAAV,GAAgBrN,IAAI,CAAC6wB,KAAL,CAAW,CAACjhB,IAAI,CAAC2gB,MAAL,CAAYntB,IAAZ,GAAmBwM,IAAI,CAAC2gB,MAAL,CAAYC,MAA/B,GAAwC5gB,IAAI,CAAC6gB,IAAL,CAAUrtB,IAAV,GAAiBwM,IAAI,CAAC6gB,IAAL,CAAUD,MAApE,IAA8E,CAAzF,CAAhB;AACA5gB,YAAI,CAAC2gB,MAAL,CAAYjjB,GAAZ,GAAkBtN,IAAI,CAACwhB,IAAL,CAAU5R,IAAI,CAAC6gB,IAAL,CAAUpjB,GAApB,CAAlB;AACAuC,YAAI,CAAC6gB,IAAL,CAAUnjB,GAAV,GAAgBtN,IAAI,CAACwhB,IAAL,CAAU,CAAC5R,IAAI,CAAC6gB,IAAL,CAAUrtB,IAAV,GAAiBksB,cAAjB,GAAkCC,OAAnC,IAA8C3f,IAAI,CAAC6gB,IAAL,CAAUD,MAAlE,CAAhB;AACH,OALD;AAOA,aAAOH,cAAP;AACH;AAxHL;AAAA;AAAA,mCA0H2B5d,MA1H3B,EA0HiD;AACzC,UAAMqe,QAAQ,GAAGre,MAAI,CAACE,UAAL,CAAgB,CAAhB,CAAjB;;AAEA,WAAK,IAAI5O,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGmrB,QAAQ,CAACnvB,MAA7B,EAAqCgE,CAAC,EAAtC,EAA0C;AACtC,YAAImrB,QAAQ,CAACnrB,CAAD,CAAR,KAAgB+sB,QAApB,EAA8B;AAC1B,iBAAO3B,mBAAmB,CAACprB,CAAD,CAA1B;AACH;AACJ;;AAED,aAAO,GAAP;AACH;AApIL;AAAA;AAAA,oCAsI4BrG,MAtI5B,EAsI2DkyB,YAtI3D,EAsI0F;AAClF,UAAMhxB,SAAS,GAAG,KAAKmyB,uBAAL,CAA6BrzB,MAA7B,EAAqCkyB,YAArC,CAAlB;;AACA,UAAIzhB,GAAG,GAAGyhB,YAAV;;AAEA,WAAK,IAAI7rB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGrG,MAAM,CAACqC,MAA3B,EAAmCgE,CAAC,EAApC,EAAwC;AACpC,YAAI4G,OAAO,GAAG,KAAKgmB,cAAL,CAAoBjzB,MAAM,CAACqG,CAAD,CAA1B,CAAd;;AAEA,aAAK,IAAIuK,CAAC,GAAG,CAAb,EAAgBA,CAAC,IAAI,CAArB,EAAwBA,CAAC,EAAzB,EAA6B;AACzB,cAAMsB,IAAI,GAAG,CAACtB,CAAC,GAAG,CAAL,MAAY,CAAZ,GAAgB1P,SAAS,CAAC8xB,GAA1B,GAAgC9xB,SAAS,CAAC0xB,KAAvD;AACA,cAAMM,GAAG,GAAG,CAACjmB,OAAO,GAAG,CAAX,MAAkB,CAAlB,GAAsBiF,IAAI,CAAC6gB,IAA3B,GAAkC7gB,IAAI,CAAC2gB,MAAnD;AACA,cAAMntB,IAAI,GAAG,KAAKqsB,SAAL,CAAethB,GAAG,GAAGG,CAArB,CAAb;;AACA,cAAIlL,IAAI,GAAGwtB,GAAG,CAACvjB,GAAX,IAAkBjK,IAAI,GAAGwtB,GAAG,CAACtjB,GAAjC,EAAsC;AAClC,mBAAO,KAAP;AACH;;AACD3C,iBAAO,KAAK,CAAZ;AACH;;AACDwD,WAAG,IAAI,CAAP;AACH;;AAED,aAAO,IAAP;AACH;AA1JL;AAAA;AAAA,mCA4J2BxD,OA5J3B,EA4JoD;AAC5C,WAAK,IAAI5G,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGorB,mBAAmB,CAACpvB,MAAxC,EAAgDgE,CAAC,EAAjD,EAAqD;AACjD,YAAIorB,mBAAmB,CAACprB,CAAD,CAAnB,KAA2B4G,OAA/B,EAAwC;AACpC,iBAAOqmB,MAAM,CAACC,YAAP,CAAoB/B,QAAQ,CAACnrB,CAAD,CAA5B,CAAP;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AApKL;AAAA;AAAA,iDAsKyC6N,MAtKzC,EAsKyDkL,GAtKzD,EAsK8E;AACtE,UAAIzP,GAAG,GAAG2U,MAAM,CAACC,SAAjB;AACA,UAAI3U,GAAG,GAAG,CAAV;;AAEA,WAAK,IAAIvJ,CAAC,GAAG6N,MAAb,EAAqB7N,CAAC,GAAG+Y,GAAzB,EAA8B/Y,CAAC,IAAI,CAAnC,EAAsC;AAClC,YAAMupB,OAAO,GAAG,KAAKmC,SAAL,CAAe1rB,CAAf,CAAhB;;AACA,YAAIupB,OAAO,GAAGhgB,GAAd,EAAmB;AACfA,aAAG,GAAGggB,OAAN;AACH;;AACD,YAAIA,OAAO,GAAGjgB,GAAd,EAAmB;AACfA,aAAG,GAAGigB,OAAN;AACH;AACJ;;AAED,aAAQ,CAACjgB,GAAG,GAAGC,GAAP,IAAc,GAAf,GAAsB,CAA7B;AACH;AArLL;AAAA;AAAA,+BAuLuBsE,MAvLvB,EAuL+C;AACvC,UAAMod,WAAW,GAAG,CAApB;AACA,UAAMlS,GAAG,GAAGlL,MAAM,GAAGod,WAArB;;AAEA,UAAIlS,GAAG,GAAG,KAAK2S,SAAL,CAAe1vB,MAAzB,EAAiC;AAC7B,eAAO,CAAC,CAAR;AACH;;AAED,UAAMmxB,YAAY,GAAG,KAAKC,4BAAL,CAAkCvf,MAAlC,EAA0CkL,GAA1C,CAArB;;AACA,UAAMsU,cAAc,GAAG,KAAKD,4BAAL,CAAkCvf,MAAM,GAAG,CAA3C,EAA8CkL,GAA9C,CAAvB;;AACA,UAAIuU,OAAO,GAAG,KAAMrC,WAAW,GAAG,CAAlC;AACA,UAAIrkB,OAAO,GAAG,CAAd;;AAEA,WAAK,IAAI5G,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGirB,WAApB,EAAiCjrB,CAAC,EAAlC,EAAsC;AAClC,YAAMnF,SAAS,GAAG,CAACmF,CAAC,GAAG,CAAL,MAAY,CAAZ,GAAgBmtB,YAAhB,GAA+BE,cAAjD;;AACA,YAAI,KAAK3B,SAAL,CAAe7d,MAAM,GAAG7N,CAAxB,IAA6BnF,SAAjC,EAA4C;AACxC+L,iBAAO,IAAI0mB,OAAX;AACH;;AACDA,eAAO,KAAK,CAAZ;AACH;;AAED,aAAO1mB,OAAP;AACH;AA7ML;AAAA;AAAA,iCA+MyB4H,KA/MzB,EA+MwCuK,GA/MxC,EA+M6D;AACrD,UAAIjd,GAAG,GAAG,CAAV;;AAEA,WAAK,IAAIkE,CAAC,GAAGwO,KAAb,EAAoBxO,CAAC,GAAG+Y,GAAxB,EAA6B/Y,CAAC,EAA9B,EAAkC;AAC9BlE,WAAG,IAAI,KAAK4vB,SAAL,CAAe1rB,CAAf,CAAP;AACH;;AAED,aAAOlE,GAAP;AACH;AAvNL;AAAA;AAAA,iCAyNwC;AAAA;;AAChC,UAAI0S,KAAK,GAAG,KAAKmd,UAAL,CAAgB,KAAK5C,IAArB,CAAZ;;AADgC,iCAGvB/oB,CAHuB;AAI5B,YAAM4G,OAAO,GAAG,MAAI,CAACklB,UAAL,CAAgB9rB,CAAhB,CAAhB;;AACA,YAAI4G,OAAO,KAAK,CAAC,CAAb,IAAkBykB,SAAS,CAACjxB,IAAV,CAAe,UAAAwuB,IAAI;AAAA,iBAAIA,IAAI,KAAKhiB,OAAb;AAAA,SAAnB,CAAtB,EAAgE;AAC5D;AACA4H,eAAK,IAAI,MAAI,CAAC2d,YAAL,CAAkB,CAAlB,EAAqBnsB,CAArB,CAAT;;AACA,cAAM+Y,GAAG,GAAGvK,KAAK,GAAG,MAAI,CAAC2d,YAAL,CAAkBnsB,CAAlB,EAAqBA,CAAC,GAAG,CAAzB,CAApB;;AACA;AAAA,eAAO;AACHwO,mBAAK,EAALA,KADG;AAEHuK,iBAAG,EAAHA,GAFG;AAGH8S,0BAAY,EAAE7rB,CAHX;AAIHosB,wBAAU,EAAEpsB,CAAC,GAAG;AAJb;AAAP;AAMH;AAf2B;;AAGhC,WAAK,IAAIA,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,KAAK0rB,SAAL,CAAe1vB,MAAnC,EAA2CgE,CAAC,EAA5C,EAAgD;AAAA,yBAAvCA,CAAuC;;AAAA;AAa/C;;AAED,aAAO,IAAP;AACH;AA5OL;;AAAA;AAAA,EAAmC6pB,6DAAnC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3CA;AAEA,IAAM0D,UAAU,GAAG,EAAnB;AACA,IAAMC,MAAM,GAAG,EAAf;AACA,IAAMC,MAAM,GAAG,GAAf;AACA,IAAMC,MAAM,GAAG,GAAf;AACA,IAAMC,YAAY,GAAG,GAArB;AACA,IAAMC,YAAY,GAAG,GAArB;AACA,IAAMC,YAAY,GAAG,GAArB;AACA,IAAMC,SAAS,GAAG,GAAlB;AACA,IAAMhG,YAAY,GAAG,CACjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CADiB,EAEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAFiB,EAGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAHiB,EAIjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAJiB,EAKjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CALiB,EAMjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CANiB,EAOjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAPiB,EAQjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CARiB,EASjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CATiB,EAUjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAViB,EAWjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAXiB,EAYjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAZiB,EAajB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAbiB,EAcjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAdiB,EAejB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAfiB,EAgBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAhBiB,EAiBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAjBiB,EAkBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAlBiB,EAmBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAnBiB,EAoBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CApBiB,EAqBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CArBiB,EAsBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAtBiB,EAuBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAvBiB,EAwBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAxBiB,EAyBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAzBiB,EA0BjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA1BiB,EA2BjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA3BiB,EA4BjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA5BiB,EA6BjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA7BiB,EA8BjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA9BiB,EA+BjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA/BiB,EAgCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAhCiB,EAiCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAjCiB,EAkCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAlCiB,EAmCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAnCiB,EAoCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CApCiB,EAqCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CArCiB,EAsCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAtCiB,EAuCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAvCiB,EAwCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAxCiB,EAyCjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAzCiB,EA0CjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA1CiB,EA2CjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA3CiB,EA4CjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA5CiB,EA6CjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA7CiB,EA8CjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA9CiB,EA+CjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA/CiB,EAgDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAhDiB,EAiDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAjDiB,EAkDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAlDiB,EAmDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAnDiB,EAoDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CApDiB,EAqDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CArDiB,EAsDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAtDiB,EAuDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAvDiB,EAwDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAxDiB,EAyDjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAzDiB,EA0DjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA1DiB,EA2DjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA3DiB,EA4DjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA5DiB,EA6DjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA7DiB,EA8DjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA9DiB,EA+DjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA/DiB,EAgEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAhEiB,EAiEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAjEiB,EAkEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAlEiB,EAmEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAnEiB,EAoEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CApEiB,EAqEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CArEiB,EAsEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAtEiB,EAuEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAvEiB,EAwEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAxEiB,EAyEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAzEiB,EA0EjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA1EiB,EA2EjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA3EiB,EA4EjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA5EiB,EA6EjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA7EiB,EA8EjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA9EiB,EA+EjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA/EiB,EAgFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAhFiB,EAiFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAjFiB,EAkFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAlFiB,EAmFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAnFiB,EAoFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CApFiB,EAqFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CArFiB,EAsFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAtFiB,EAuFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAvFiB,EAwFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAxFiB,EAyFjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAzFiB,EA0FjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA1FiB,EA2FjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA3FiB,EA4FjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA5FiB,EA6FjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA7FiB,EA8FjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA9FiB,EA+FjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA/FiB,EAgGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAhGiB,EAiGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAjGiB,EAkGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAlGiB,EAmGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAnGiB,EAoGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CApGiB,EAqGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CArGiB,EAsGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAtGiB,EAuGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAvGiB,EAwGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAxGiB,EAyGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAzGiB,EA0GjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CA1GiB,EA2GjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,EAAmB,CAAnB,CA3GiB,CAArB;AA6GA,IAAMiG,cAAc,GAAG;AAAEpB,KAAG,EAAE,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAP;AAAkBJ,OAAK,EAAE,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP;AAAzB,CAAvB;AAEO,IAAMyB,aAAb;AAAA;AAAA;AAAA;;AACI,2BAAc;AAAA;;AAAA;;AACV;AAEA,UAAK9F,OAAL,GAAe,UAAf;AACA,UAAKC,gBAAL,GAAwB,IAAxB;AACA,UAAKC,iBAAL,GAAyB,IAAzB;AALU;AAMb;;AAPL;AAAA;AAAA,gCAS0B5Z,KAT1B,EASyCoc,UATzC,EASqF;AAC7E,UAAMrB,OAAO,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAAhB;AACA,UAAM1b,MAAM,GAAGW,KAAf;AACA,UAAMgb,SAAsB,GAAG;AAC3B5f,aAAK,EAAEqU,MAAM,CAACC,SADa;AAE3B0K,YAAI,EAAE,CAAC,CAFoB;AAG3Bpa,aAAK,EAAEA,KAHoB;AAI3BuK,WAAG,EAAEvK,KAJsB;AAK3Boc,kBAAU,EAAE;AACR+B,aAAG,EAAE,CADG;AAERJ,eAAK,EAAE;AAFC;AALe,OAA/B;AAUA,UAAMnC,OAAO,GAAG,KAAKV,kBAArB;AACA,UAAIQ,OAAc,GAAG,KAAKnB,IAAL,CAAUlb,MAAV,IAAoB,CAApB,GAAwB,CAA7C;AACA,UAAIwc,UAAU,GAAG,CAAjB;;AAEA,WAAK,IAAIrqB,CAAC,GAAG6N,MAAb,EAAqB7N,CAAC,GAAG,KAAK+oB,IAAL,CAAU/sB,MAAnC,EAA2CgE,CAAC,EAA5C,EAAgD;AAC5C,YAAI,KAAK+oB,IAAL,CAAU/oB,CAAV,IAAekqB,OAAnB,EAA4B;AACxBX,iBAAO,CAACc,UAAD,CAAP;AACH,SAFD,MAEO;AACH,cAAIA,UAAU,KAAKd,OAAO,CAACvtB,MAAR,GAAiB,CAApC,EAAuC;AACnC,gBAAI4uB,UAAJ,EAAgB;AACZ,mBAAKqD,QAAL,CAAc1E,OAAd,EAAuBqB,UAAvB;AACH;;AAED,iBAAK,IAAIhC,IAAI,GAAG,CAAhB,EAAmBA,IAAI,GAAGd,YAAY,CAAC9rB,MAAvC,EAA+C4sB,IAAI,EAAnD,EAAuD;AACnD,kBAAMhf,KAAK,GAAG,KAAK6f,aAAL,CAAmBF,OAAnB,EAA4BzB,YAAY,CAACc,IAAD,CAAxC,CAAd;;AACA,kBAAIhf,KAAK,GAAG4f,SAAS,CAAC5f,KAAtB,EAA6B;AACzB4f,yBAAS,CAACZ,IAAV,GAAiBA,IAAjB;AACAY,yBAAS,CAAC5f,KAAV,GAAkBA,KAAlB;AACH;AACJ;;AAED4f,qBAAS,CAACzQ,GAAV,GAAgB/Y,CAAhB;;AAEA,gBAAIwpB,SAAS,CAACZ,IAAV,KAAmB,CAAC,CAApB,IAAyBY,SAAS,CAAC5f,KAAV,GAAkBwgB,OAA/C,EAAwD;AACpD,qBAAO,IAAP;AACH;;AAED,gBAAM8D,QAAQ,GAAGpG,YAAY,CAAC0B,SAAS,CAACZ,IAAX,CAA7B;;AACA,gBAAIsF,QAAJ,EAAc;AACV1E,uBAAS,CAACoB,UAAV,CAAqB+B,GAArB,GAA2B,KAAKwB,oBAAL,CAA0BD,QAA1B,EAAoC3E,OAApC,EAA6CwE,cAAc,CAACpB,GAA5D,CAA3B;AACAnD,uBAAS,CAACoB,UAAV,CAAqB2B,KAArB,GAA6B,KAAK4B,oBAAL,CAA0BD,QAA1B,EAAoC3E,OAApC,EAA6CwE,cAAc,CAACxB,KAA5D,CAA7B;AACH;;AAED,mBAAO/C,SAAP;AACH,WA1BD,MA0BO;AACHa,sBAAU;AACb;;AAEDd,iBAAO,CAACc,UAAD,CAAP,GAAsB,CAAtB;AACAH,iBAAO,GAAGA,OAAO,GAAG,CAAH,GAAO,CAAxB;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AAlEL;AAAA;AAAA,6BAoEqBX,OApErB,EAoE6CqB,UApE7C,EAoEkF;AAC1E,WAAKwD,YAAL,CAAkB7E,OAAlB,EAA2BqB,UAAU,CAAC+B,GAAtC,EAA2CoB,cAAc,CAACpB,GAA1D;;AACA,WAAKyB,YAAL,CAAkB7E,OAAlB,EAA2BqB,UAAU,CAAC2B,KAAtC,EAA6CwB,cAAc,CAACxB,KAA5D;AACH;AAvEL;AAAA;AAAA,iCAyE2B;AACnB,UAAMhD,OAAO,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB,CAAhB,CAAhB;;AACA,UAAM1b,MAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,CAAf;;AACA,UAAMS,SAAS,GAAG;AACd5f,aAAK,EAAEqU,MAAM,CAACC,SADA;AAEd0K,YAAI,EAAE,CAAC,CAFO;AAGdpa,aAAK,EAAE,CAHO;AAIduK,WAAG,EAAE,CAJS;AAKd6R,kBAAU,EAAE;AACR+B,aAAG,EAAE,CADG;AAERJ,eAAK,EAAE;AAFC;AALE,OAAlB;AAUA,UAAMnC,OAAO,GAAG,KAAKV,kBAArB;AACA,UAAIQ,OAAc,GAAG,CAArB;AACA,UAAIG,UAAU,GAAG,CAAjB;AACA,UAAIvuB,GAAJ;;AAEA,WAAK,IAAIkE,CAAC,GAAG6N,MAAb,EAAqB7N,CAAC,GAAG,KAAK+oB,IAAL,CAAU/sB,MAAnC,EAA2CgE,CAAC,EAA5C,EAAgD;AAC5C,YAAI,KAAK+oB,IAAL,CAAU/oB,CAAV,IAAekqB,OAAnB,EAA4B;AACxBX,iBAAO,CAACc,UAAD,CAAP;AACH,SAFD,MAEO;AACH,cAAIA,UAAU,KAAKd,OAAO,CAACvtB,MAAR,GAAiB,CAApC,EAAuC;AACnCF,eAAG,GAAG,CAAN;;AACA,iBAAK,IAAIyO,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGgf,OAAO,CAACvtB,MAA5B,EAAoCuO,CAAC,EAArC,EAAyC;AACrCzO,iBAAG,IAAIytB,OAAO,CAAChf,CAAD,CAAd;AACH;;AACD,iBAAK,IAAIqe,IAAI,GAAG+E,YAAhB,EAA8B/E,IAAI,IAAIiF,YAAtC,EAAoDjF,IAAI,EAAxD,EAA4D;AACxD,kBAAMhf,KAAK,GAAG,KAAK6f,aAAL,CAAmBF,OAAnB,EAA4BzB,YAAY,CAACc,IAAD,CAAxC,CAAd;;AACA,kBAAIhf,KAAK,GAAG4f,SAAS,CAAC5f,KAAtB,EAA6B;AACzB4f,yBAAS,CAACZ,IAAV,GAAiBA,IAAjB;AACAY,yBAAS,CAAC5f,KAAV,GAAkBA,KAAlB;AACH;AACJ;;AACD,gBAAI4f,SAAS,CAAC5f,KAAV,GAAkBwgB,OAAtB,EAA+B;AAC3BZ,uBAAS,CAAChb,KAAV,GAAkBxO,CAAC,GAAGlE,GAAtB;AACA0tB,uBAAS,CAACzQ,GAAV,GAAgB/Y,CAAhB;AACAwpB,uBAAS,CAACoB,UAAV,CAAqB+B,GAArB,GAA2B,KAAKwB,oBAAL,CAA0BrG,YAAY,CAAC0B,SAAS,CAACZ,IAAX,CAAtC,EAAwDW,OAAxD,EACvBwE,cAAc,CAACpB,GADQ,CAA3B;AAEAnD,uBAAS,CAACoB,UAAV,CAAqB2B,KAArB,GAA6B,KAAK4B,oBAAL,CAA0BrG,YAAY,CAAC0B,SAAS,CAACZ,IAAX,CAAtC,EAAwDW,OAAxD,EACzBwE,cAAc,CAACxB,KADU,CAA7B;AAEA,qBAAO/C,SAAP;AACH;;AAED,iBAAK,IAAIjf,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAG,CAApB,EAAuBA,EAAC,EAAxB,EAA4B;AACxBgf,qBAAO,CAAChf,EAAD,CAAP,GAAagf,OAAO,CAAChf,EAAC,GAAG,CAAL,CAApB;AACH;;AACDgf,mBAAO,CAAC,CAAD,CAAP,GAAa,CAAb;AACAA,mBAAO,CAAC,CAAD,CAAP,GAAa,CAAb;AACAc,sBAAU;AACb,WA5BD,MA4BO;AACHA,sBAAU;AACb;;AACDd,iBAAO,CAACc,UAAD,CAAP,GAAsB,CAAtB;AACAH,iBAAO,GAAGA,OAAO,GAAG,CAAH,GAAO,CAAxB;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AApIL;AAAA;AAAA,6BAsIsB;AACd,UAAMvwB,MAAM,GAAG,IAAIjB,KAAJ,EAAf;;AACA,UAAM2vB,SAAS,GAAG,KAAKC,UAAL,EAAlB;;AACA,UAAIM,IAAiB,GAAG,IAAxB;AACA,UAAI5G,IAAI,GAAG,KAAX;AACA,UAAIqM,UAAU,GAAG,CAAjB;AACA,UAAIC,QAAQ,GAAG,CAAf;AACA,UAAIC,OAAJ;AACA,UAAIC,SAAS,GAAG,IAAI91B,KAAJ,EAAhB;AACA,UAAIiwB,YAAY,GAAG,IAAIjwB,KAAJ,EAAnB;AACA,UAAI+1B,SAAS,GAAG,KAAhB;AACA,UAAIna,OAAJ;AACA,UAAIoa,mBAAmB,GAAG,IAA1B;;AAEA,UAAIrG,SAAS,KAAK,IAAlB,EAAwB;AACpB,eAAO,IAAP;AACH;;AACDO,UAAI,GAAG;AACHA,YAAI,EAAEP,SAAS,CAACO,IADb;AAEHpa,aAAK,EAAE6Z,SAAS,CAAC7Z,KAFd;AAGHuK,WAAG,EAAEsP,SAAS,CAACtP,GAHZ;AAIH6R,kBAAU,EAAE;AACR+B,aAAG,EAAEtE,SAAS,CAACuC,UAAV,CAAqB+B,GADlB;AAERJ,eAAK,EAAElE,SAAS,CAACuC,UAAV,CAAqB2B;AAFpB;AAJT,OAAP;AASA5D,kBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AACA0F,cAAQ,GAAG1F,IAAI,CAACA,IAAhB;;AAEA,cAAQA,IAAI,CAACA,IAAb;AACI,aAAK+E,YAAL;AACIY,iBAAO,GAAGb,MAAV;AACA;;AACJ,aAAKE,YAAL;AACIW,iBAAO,GAAGd,MAAV;AACA;;AACJ,aAAKI,YAAL;AACIU,iBAAO,GAAGf,MAAV;AACA;;AACJ;AACI,iBAAO,IAAP;AAXR;;AAcA,aAAO,CAACxL,IAAR,EAAc;AACV1N,eAAO,GAAGma,SAAV;AACAA,iBAAS,GAAG,KAAZ;AACA7F,YAAI,GAAG,KAAKgB,WAAL,CAAiBhB,IAAI,CAAC7P,GAAtB,EAA2B6P,IAAI,CAACgC,UAAhC,CAAP;;AACA,YAAIhC,IAAI,KAAK,IAAb,EAAmB;AACf,cAAIA,IAAI,CAACA,IAAL,KAAckF,SAAlB,EAA6B;AACzBY,+BAAmB,GAAG,IAAtB;AACH;;AAED,cAAI9F,IAAI,CAACA,IAAL,KAAckF,SAAlB,EAA6B;AACzBU,qBAAS,CAACt0B,IAAV,CAAe0uB,IAAI,CAACA,IAApB;AACAyF,sBAAU;AACVC,oBAAQ,IAAID,UAAU,GAAGzF,IAAI,CAACA,IAA9B;AACH;;AACDD,sBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;;AAEA,kBAAQ2F,OAAR;AACI,iBAAKb,MAAL;AAAa;AACT,oBAAI9E,IAAI,CAACA,IAAL,GAAY,EAAhB,EAAoB;AAChBjvB,wBAAM,CAACO,IAAP,CAAY+yB,MAAM,CAACC,YAAP,CAAoB,KAAKtE,IAAI,CAACA,IAA9B,CAAZ;AACH,iBAFD,MAEO,IAAIA,IAAI,CAACA,IAAL,GAAY,EAAhB,EAAoB;AACvBjvB,wBAAM,CAACO,IAAP,CAAY+yB,MAAM,CAACC,YAAP,CAAoBtE,IAAI,CAACA,IAAL,GAAY,EAAhC,CAAZ;AACH,iBAFM,MAEA;AACH,sBAAIA,IAAI,CAACA,IAAL,KAAckF,SAAlB,EAA6B;AACzBY,uCAAmB,GAAG,KAAtB;AACH;;AACD,0BAAQ9F,IAAI,CAACA,IAAb;AACI,yBAAK2E,UAAL;AACIkB,+BAAS,GAAG,IAAZ;AACAF,6BAAO,GAAGd,MAAV;AACA;;AACJ,yBAAKA,MAAL;AACIc,6BAAO,GAAGd,MAAV;AACA;;AACJ,yBAAKD,MAAL;AACIe,6BAAO,GAAGf,MAAV;AACA;;AACJ,yBAAKM,SAAL;AACI9L,0BAAI,GAAG,IAAP;AACA;AAbR;AAeH;;AACD;AACH;;AACD,iBAAKyL,MAAL;AAAa;AACT,oBAAI7E,IAAI,CAACA,IAAL,GAAY,EAAhB,EAAoB;AAChBjvB,wBAAM,CAACO,IAAP,CAAY+yB,MAAM,CAACC,YAAP,CAAoB,KAAKtE,IAAI,CAACA,IAA9B,CAAZ;AACH,iBAFD,MAEO;AACH,sBAAIA,IAAI,CAACA,IAAL,KAAckF,SAAlB,EAA6B;AACzBY,uCAAmB,GAAG,KAAtB;AACH;;AACD,0BAAQ9F,IAAI,CAACA,IAAb;AACI,yBAAK2E,UAAL;AACIkB,+BAAS,GAAG,IAAZ;AACAF,6BAAO,GAAGb,MAAV;AACA;;AACJ,yBAAKA,MAAL;AACIa,6BAAO,GAAGb,MAAV;AACA;;AACJ,yBAAKF,MAAL;AACIe,6BAAO,GAAGf,MAAV;AACA;;AACJ,yBAAKM,SAAL;AACI9L,0BAAI,GAAG,IAAP;AACA;AAbR;AAeH;;AACD;AACH;;AACD,iBAAKwL,MAAL;AAAa;AACT,oBAAI5E,IAAI,CAACA,IAAL,GAAY,GAAhB,EAAqB;AACjBjvB,wBAAM,CAACO,IAAP,CAAY0uB,IAAI,CAACA,IAAL,GAAY,EAAZ,GAAiB,MAAMA,IAAI,CAACA,IAA5B,GAAmCA,IAAI,CAACA,IAApD;AACH,iBAFD,MAEO;AACH,sBAAIA,IAAI,CAACA,IAAL,KAAckF,SAAlB,EAA6B;AACzBY,uCAAmB,GAAG,KAAtB;AACH;;AACD,0BAAQ9F,IAAI,CAACA,IAAb;AACI,yBAAK8E,MAAL;AACIa,6BAAO,GAAGb,MAAV;AACA;;AACJ,yBAAKD,MAAL;AACIc,6BAAO,GAAGd,MAAV;AACA;;AACJ,yBAAKK,SAAL;AACI9L,0BAAI,GAAG,IAAP;AACA;AATR;AAWH;;AACD;AACH;AAzEL;AA2EH,SAvFD,MAuFO;AACHA,cAAI,GAAG,IAAP;AACH;;AACD,YAAI1N,OAAJ,EAAa;AACTia,iBAAO,GAAGA,OAAO,KAAKb,MAAZ,GAAqBD,MAArB,GAA8BC,MAAxC;AACH;AACJ;;AAED,UAAI9E,IAAI,KAAK,IAAb,EAAmB;AACf,eAAO,IAAP;AACH;;AAEDA,UAAI,CAAC7P,GAAL,GAAW,KAAK4S,UAAL,CAAgB,KAAK5C,IAArB,EAA2BH,IAAI,CAAC7P,GAAhC,CAAX;;AACA,UAAI,CAAC,KAAKuQ,yBAAL,CAA+BV,IAA/B,CAAL,EAA2C;AACvC,eAAO,IAAP;AACH;;AAED0F,cAAQ,IAAID,UAAU,GAAGG,SAAS,CAACA,SAAS,CAACxyB,MAAV,GAAmB,CAApB,CAAlC;;AACA,UAAIsyB,QAAQ,GAAG,GAAX,KAAmBE,SAAS,CAACA,SAAS,CAACxyB,MAAV,GAAmB,CAApB,CAAhC,EAAwD;AACpD,eAAO,IAAP;AACH;;AAED,UAAI,CAACrC,MAAM,CAACqC,MAAZ,EAAoB;AAChB,eAAO,IAAP;AACH,OA9Ja,CAgKd;;;AACA,UAAI0yB,mBAAJ,EAAyB;AACrB/0B,cAAM,CAAC4Y,MAAP,CAAc5Y,MAAM,CAACqC,MAAP,GAAgB,CAA9B,EAAiC,CAAjC;AACH;;AAED,aAAO;AACH4sB,YAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CADH;AAEH3O,aAAK,EAAE6Z,SAAS,CAAC7Z,KAFd;AAGHuK,WAAG,EAAE6P,IAAI,CAAC7P,GAHP;AAIHwV,eAAO,EAAPA,OAJG;AAKHlG,iBAAS,EAATA,SALG;AAMHM,oBAAY,EAAZA,YANG;AAOHJ,eAAO,EAAEK;AAPN,OAAP;AASH;AApTL;AAAA;AAAA,8CAsTwCL,OAtTxC,EAsT2E;AACnE,UAAMa,qBAAqB,GAAGb,OAAO,CAACxP,GAAR,GAAc,CAACwP,OAAO,CAACxP,GAAR,GAAcwP,OAAO,CAAC/Z,KAAvB,IAAgC,CAA5E;;AAEA,UAAI4a,qBAAqB,GAAG,KAAKL,IAAL,CAAU/sB,MAAtC,EAA8C;AAC1C,YAAI,KAAKmtB,WAAL,CAAiBZ,OAAO,CAACxP,GAAzB,EAA8BqQ,qBAA9B,EAAqD,CAArD,CAAJ,EAA6D;AACzD,iBAAOb,OAAP;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AAhUL;AAAA;AAAA,yCAmUQ2F,QAnUR,EAoUQS,UApUR,EAqUQ9D,OArUR,EAsUc;AACN,UAAI+D,aAAa,GAAG,CAApB;AACA,UAAIC,WAAW,GAAG,CAAlB;;AAEA,WAAK,IAAI7yB,MAAM,GAAG6uB,OAAO,CAAC7uB,MAA1B,EAAkCA,MAAM,EAAxC,GAA6C;AACzC6yB,mBAAW,IAAIX,QAAQ,CAACrD,OAAO,CAAC7uB,MAAD,CAAR,CAAvB;AACA4yB,qBAAa,IAAID,UAAU,CAAC9D,OAAO,CAAC7uB,MAAD,CAAR,CAA3B;AACH;;AAED,aAAO6yB,WAAW,GAAGD,aAArB;AACH;AAhVL;;AAAA;AAAA,EAAmC/E,6DAAnC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzHA;AAEA,IAAMiF,QAAQ,GAAG,KAAjB;AACA,IAAM5D,gBAAgB,GAAG,8CAAzB;AACA,IAAMC,QAAQ,GAAG,IAAI4D,WAAJ,CAAgB,gFAAI7D,gBAAJ,EAAsBjlB,GAAtB,CAA0B,UAAAyI,KAAI;AAAA,SAAIA,KAAI,CAACE,UAAL,CAAgB,CAAhB,CAAJ;AAAA,CAA9B,CAAhB,CAAjB,C,CACA;AACA;;AACA,IAAMwc,mBAAmB,GAAG,IAAI2D,WAAJ,CAAgB,CACxC,KADwC,EACjC,KADiC,EAC1B,KAD0B,EACnB,KADmB,EACZ,KADY,EACL,KADK,EACE,KADF,EACS,KADT,EACgB,KADhB,EACuB,KADvB,EAC8B,KAD9B,EACqC,KADrC,EAC4C,KAD5C,EACmD,KADnD,EAC0D,KAD1D,EACiE,KADjE,EAExC,KAFwC,EAEjC,KAFiC,EAE1B,KAF0B,EAEnB,KAFmB,EAEZ,KAFY,EAEL,KAFK,EAEE,KAFF,EAES,KAFT,EAEgB,KAFhB,EAEuB,KAFvB,EAE8B,KAF9B,EAEqC,KAFrC,EAE4C,KAF5C,EAEmD,KAFnD,EAE0D,KAF1D,EAEiE,KAFjE,EAGxC,KAHwC,EAGjC,KAHiC,EAG1B,KAH0B,EAGnB,KAHmB,EAGZ,KAHY,EAGL,KAHK,EAGE,KAHF,EAGS,KAHT,EAGgB,KAHhB,EAGuB,KAHvB,EAG8B,KAH9B,EAGqC,KAHrC,CAAhB,CAA5B;AAMO,IAAMC,YAAb;AAAA;AAAA;AAAA;;AACI,0BAAc;AAAA;;AAAA;;AACV;AAEA,UAAK9G,OAAL,GAAe,SAAf;AAHU;AAIb;;AALL;AAAA;AAAA,6BAOsB;AACd,UAAM1Z,KAAK,GAAG,KAAK8Z,UAAL,EAAd;;AAEA,UAAI,CAAC9Z,KAAL,EAAY;AACR,eAAO,IAAP;AACH;;AAED,UAAM7U,MAAM,GAAG,IAAIjB,KAAJ,EAAf;AACA,UAAI+vB,QAAQ,GAAG,IAAIsG,WAAJ,CAAgB,CAAhB,CAAf;AACA,UAAIhD,WAAJ;AACA,UAAIkD,SAAJ;;AACA,UAAIrD,SAAS,GAAG,KAAK9C,QAAL,CAAc,KAAKC,IAAnB,EAAyBva,KAAK,CAACuK,GAA/B,CAAhB;;AAEA,SAAG;AACC,aAAKmW,WAAL,CAAiBtD,SAAjB,EAA4BnD,QAA5B;;AACA,YAAM7hB,OAAO,GAAG,KAAKklB,UAAL,CAAgBrD,QAAhB,CAAhB;;AACA,YAAI7hB,OAAO,GAAG,CAAd,EAAiB;AACb,iBAAO,IAAP;AACH;;AACDmlB,mBAAW,GAAG,KAAKC,cAAL,CAAoBplB,OAApB,CAAd;;AACA,YAAImlB,WAAW,KAAK,IAApB,EAA0B;AACtB,iBAAO,IAAP;AACH;;AACDpyB,cAAM,CAACO,IAAP,CAAY6xB,WAAZ;AACAkD,iBAAS,GAAGrD,SAAZ;AACAA,iBAAS,IAAInD,QAAQ,CAAC5sB,MAAT,CAAgB,UAACC,GAAD,EAAMzB,IAAN;AAAA,iBAAeyB,GAAG,GAAGzB,IAArB;AAAA,SAAhB,EAA2C,CAA3C,CAAb;AACAuxB,iBAAS,GAAG,KAAK9C,QAAL,CAAc,KAAKC,IAAnB,EAAyB6C,SAAzB,CAAZ;AACH,OAdD,QAcSG,WAAW,KAAK,GAdzB;;AAeApyB,YAAM,CAACw1B,GAAP;;AAEA,UAAI,CAACx1B,MAAM,CAACqC,MAAZ,EAAoB;AAChB,eAAO,IAAP;AACH;;AAED,UAAI,CAAC,KAAKstB,yBAAL,CAA+B2F,SAA/B,EAA0CrD,SAA1C,EAAqDnD,QAArD,CAAL,EAAqE;AACjE,eAAO,IAAP;AACH;;AAED,aAAO;AACHG,YAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CADH;AAEH3O,aAAK,EAAEA,KAAK,CAACA,KAFV;AAGHuK,WAAG,EAAE6S,SAHF;AAIHvD,iBAAS,EAAE7Z,KAJR;AAKHma,oBAAY,EAAEhvB;AALX,OAAP;AAOH;AApDL;AAAA;AAAA,mCAsD6BiN,OAtD7B,EAsD8C;AACtC,WAAK,IAAI5G,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGorB,mBAAmB,CAACpvB,MAAxC,EAAgDgE,CAAC,EAAjD,EAAqD;AACjD,YAAIorB,mBAAmB,CAACprB,CAAD,CAAnB,KAA2B4G,OAA/B,EAAwC;AACpC,iBAAOqmB,MAAM,CAACC,YAAP,CAAoB/B,QAAQ,CAACnrB,CAAD,CAA5B,CAAP;AACH;AACJ;;AACD,aAAO,IAAP;AACH;AA7DL;AAAA;AAAA,8CA+DsCivB,SA/DtC,EA+DyDrD,SA/DzD,EA+D4EnD,QA/D5E,EA+D4G;AACpG,UAAM2G,WAAW,GAAG3G,QAAQ,CAAC5sB,MAAT,CAAgB,UAACC,GAAD,EAAMzB,IAAN;AAAA,eAAeyB,GAAG,GAAGzB,IAArB;AAAA,OAAhB,EAA2C,CAA3C,CAApB;AACA,UAAM+uB,qBAAqB,GAAGwC,SAAS,GAAGqD,SAAZ,GAAwBG,WAAtD;AACA,aAAQhG,qBAAqB,GAAG,CAAzB,IAA+BgG,WAAtC;AACH;AAnEL;AAAA;AAAA,mCAqE2B3G,QArE3B,EAqEkDjnB,OArElD,EAqE2E;AACnE,UAAI6tB,QAAQ,GAAGpR,MAAM,CAACC,SAAtB;;AAEA,WAAK,IAAIle,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGyoB,QAAQ,CAACzsB,MAA7B,EAAqCgE,CAAC,EAAtC,EAA0C;AACtC,YAAIyoB,QAAQ,CAACzoB,CAAD,CAAR,GAAcqvB,QAAd,IAA0B5G,QAAQ,CAACzoB,CAAD,CAAR,GAAcwB,OAA5C,EAAqD;AACjD6tB,kBAAQ,GAAG5G,QAAQ,CAACzoB,CAAD,CAAnB;AACH;AACJ;;AAED,aAAOqvB,QAAP;AACH;AA/EL;AAAA;AAAA,+BAiFuB5G,QAjFvB,EAiFsD;AAC9C,UAAMwC,WAAW,GAAGxC,QAAQ,CAACzsB,MAA7B;AACA,UAAIszB,cAAc,GAAG,CAArB;AACA,UAAIC,WAAW,GAAGtE,WAAlB;AACA,UAAIuE,YAAY,GAAG,CAAnB;AACA,UAAI5oB,OAAJ;;AAEA,aAAO2oB,WAAW,GAAG,CAArB,EAAwB;AACpBD,sBAAc,GAAG,KAAKG,cAAL,CAAoBhH,QAApB,EAA8B6G,cAA9B,CAAjB;AACAC,mBAAW,GAAG,CAAd;AACA3oB,eAAO,GAAG,CAAV;;AACA,aAAK,IAAI5G,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGirB,WAApB,EAAiCjrB,CAAC,EAAlC,EAAsC;AAClC,cAAIyoB,QAAQ,CAACzoB,CAAD,CAAR,GAAcsvB,cAAlB,EAAkC;AAC9B1oB,mBAAO,IAAI,KAAMqkB,WAAW,GAAG,CAAd,GAAkBjrB,CAAnC;AACAuvB,uBAAW;AACXC,wBAAY,IAAI/G,QAAQ,CAACzoB,CAAD,CAAxB;AACH;AACJ;;AAED,YAAIuvB,WAAW,KAAK,CAApB,EAAuB;AACnB,eAAK,IAAIvvB,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAGirB,WAAJ,IAAmBsE,WAAW,GAAG,CAAjD,EAAoDvvB,EAAC,EAArD,EAAyD;AACrD,gBAAIyoB,QAAQ,CAACzoB,EAAD,CAAR,GAAcsvB,cAAlB,EAAkC;AAC9BC,yBAAW;;AACX,kBAAK9G,QAAQ,CAACzoB,EAAD,CAAR,GAAc,CAAf,IAAqBwvB,YAAzB,EAAuC;AACnC,uBAAO,CAAC,CAAR;AACH;AACJ;AACJ;;AACD,iBAAO5oB,OAAP;AACH;AACJ;;AACD,aAAO,CAAC,CAAR;AACH;AAjHL;AAAA;AAAA,iCAmHwC;AAChC,UAAMiH,MAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,CAAf;;AACA,UAAI2G,YAAY,GAAG7hB,MAAnB;AACA,UAAM0b,OAAO,GAAG,IAAIwF,WAAJ,CAAgB,CAAhB,CAAhB;AACA,UAAI1E,UAAU,GAAG,CAAjB;AACA,UAAIH,OAAc,GAAG,CAArB;AACA,UAAIyF,mBAAJ;;AAEA,WAAK,IAAI3vB,CAAC,GAAG6N,MAAb,EAAqB7N,CAAC,GAAG,KAAK+oB,IAAL,CAAU/sB,MAAnC,EAA2CgE,CAAC,EAA5C,EAAgD;AAC5C,YAAI,KAAK+oB,IAAL,CAAU/oB,CAAV,IAAekqB,OAAnB,EAA4B;AACxBX,iBAAO,CAACc,UAAD,CAAP;AACH,SAFD,MAEO;AACH,cAAIA,UAAU,KAAKd,OAAO,CAACvtB,MAAR,GAAiB,CAApC,EAAuC;AACnC;AACA,gBAAI,KAAK8vB,UAAL,CAAgBvC,OAAhB,MAA6BuF,QAAjC,EAA2C;AACvCa,iCAAmB,GAAG1zB,IAAI,CAACsN,GAAL,CAAS,CAAT,EAAYmmB,YAAY,GAAI,CAAC1vB,CAAC,GAAG0vB,YAAL,IAAqB,CAAjD,IAAuD,CAA7E;;AACA,kBAAI,KAAKvG,WAAL,CAAiBwG,mBAAjB,EAAsCD,YAAtC,EAAoD,CAApD,CAAJ,EAA4D;AACxD,uBAAO;AACHlhB,uBAAK,EAAEkhB,YADJ;AAEH3W,qBAAG,EAAE/Y;AAFF,iBAAP;AAIH;AACJ;;AAED0vB,wBAAY,IAAInG,OAAO,CAAC,CAAD,CAAP,GAAaA,OAAO,CAAC,CAAD,CAApC;;AACA,iBAAK,IAAIhf,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AACxBgf,qBAAO,CAAChf,CAAD,CAAP,GAAagf,OAAO,CAAChf,CAAC,GAAG,CAAL,CAApB;AACH;;AACDgf,mBAAO,CAAC,CAAD,CAAP,GAAa,CAAb;AACAA,mBAAO,CAAC,CAAD,CAAP,GAAa,CAAb;AACAc,sBAAU;AACb,WAnBD,MAmBO;AACHA,sBAAU;AACb;;AACDd,iBAAO,CAACc,UAAD,CAAP,GAAsB,CAAtB;AACAH,iBAAO,GAAGA,OAAO,GAAG,CAAH,GAAO,CAAxB;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AA3JL;;AAAA;AAAA,EAAkCL,6DAAlC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACZA;AAEO,IAAM+F,eAAb;AAAA;AAAA;AAAA;;AACI,6BAAc;AAAA;;AAAA;;AACV;AAEA,UAAK1H,OAAL,GAAe,aAAf;AAHU;AAIb;AAED;;;;;;AAPJ;AAAA;AAAA,6BAWsB;AACd,UAAMvuB,MAAM,GAAG,qMAAf;;AACA,UAAI,CAACA,MAAL,EAAa;AACT,eAAO,IAAP;AACH;;AAED,UAAIivB,IAAI,GAAGjvB,MAAM,CAACivB,IAAlB;;AAEA,UAAI,CAACA,IAAL,EAAW;AACP,eAAO,IAAP;AACH;;AAEDA,UAAI,GAAGA,IAAI,CAACiH,OAAL,CAAa,QAAb,EAAuB,EAAvB,CAAP;;AAEA,UAAI,CAAC,eAAe7iB,IAAf,CAAoB4b,IAApB,CAAL,EAAgC;AAC5B,YAAI3jB,IAAJ,EAA2C;AACvCkC,iBAAO,CAACC,GAAR,CAAY,2BAAZ,EAAyCwhB,IAAzC;AACH;;AACD,eAAO,IAAP;AACH;;AAED,UAAI,CAAC,KAAKkH,cAAL,CAAoBlH,IAApB,CAAL,EAAgC;AAC5B,eAAO,IAAP;AACH;;AAEDjvB,YAAM,CAACivB,IAAP,GAAcA,IAAd;AACA,aAAOjvB,MAAP;AACH;AAtCL;AAAA;AAAA,mCAwC2BivB,IAxC3B,EAwCkD;AAC1C;AACA,aAAO,CAAC,CAACA,IAAT;AACH;AA3CL;;AAAA;AAAA,EAAqCoG,4DAArC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACHA;AAEA,IAAM9D,gBAAgB,GAAG,kDAAzB;AACA,IAAMC,QAAQ,GAAG,IAAI4D,WAAJ,CAAgB,gFAAI7D,gBAAJ,EAAsBjlB,GAAtB,CAA0B,UAAAyI,KAAI;AAAA,SAAIA,KAAI,CAACE,UAAL,CAAgB,CAAhB,CAAJ;AAAA,CAA9B,CAAhB,CAAjB;AACA,IAAMwc,mBAAmB,GAAG,IAAI2D,WAAJ,CAAgB,CACxC,KADwC,EACjC,KADiC,EAC1B,KAD0B,EACnB,KADmB,EACZ,KADY,EACL,KADK,EACE,KADF,EACS,KADT,EACgB,KADhB,EACuB,KADvB,EAC8B,KAD9B,EACqC,KADrC,EAC4C,KAD5C,EACmD,KADnD,EAC0D,KAD1D,EACiE,KADjE,EAExC,KAFwC,EAEjC,KAFiC,EAE1B,KAF0B,EAEnB,KAFmB,EAEZ,KAFY,EAEL,KAFK,EAEE,KAFF,EAES,KAFT,EAEgB,KAFhB,EAEuB,KAFvB,EAE8B,KAF9B,EAEqC,KAFrC,EAE4C,KAF5C,EAEmD,KAFnD,EAE0D,KAF1D,EAEiE,KAFjE,EAGxC,KAHwC,EAGjC,KAHiC,EAG1B,KAH0B,EAGnB,KAHmB,EAGZ,KAHY,EAGL,KAHK,EAGE,KAHF,EAGS,KAHT,EAGgB,KAHhB,EAGuB,KAHvB,EAG8B,KAH9B,EAGqC,KAHrC,EAG4C,KAH5C,EAGmD,KAHnD,EAG0D,KAH1D,EAGiE,KAHjE,CAAhB,CAA5B;AAKA,IAAMD,QAAQ,GAAG,KAAjB;AAEO,IAAMiB,YAAb;AAAA;AAAA;AAAA;;AACI,0BAAc;AAAA;;AAAA;;AACV;AAEA,UAAK7H,OAAL,GAAe,SAAf;AAHU;AAIb;;AALL;AAAA;AAAA,6BAOsB;AACd,UAAM1Z,KAAK,GAAG,KAAK8Z,UAAL,EAAd;;AAEA,UAAI,CAAC9Z,KAAL,EAAY;AACR,eAAO,IAAP;AACH;;AAED,UAAI7U,MAAM,GAAG,IAAIjB,KAAJ,EAAb;AACA,UAAI+vB,QAAQ,GAAG,IAAIsG,WAAJ,CAAgB,CAAhB,CAAf;AACA,UAAIhD,WAAJ;AACA,UAAIkD,SAAJ;;AACA,UAAIrD,SAAS,GAAG,KAAK9C,QAAL,CAAc,KAAKC,IAAnB,EAAyBva,KAAK,CAACuK,GAA/B,CAAhB;;AAEA,SAAG;AACC,aAAKmW,WAAL,CAAiBtD,SAAjB,EAA4BnD,QAA5B;;AACA,YAAM7hB,OAAO,GAAG,KAAKklB,UAAL,CAAgBrD,QAAhB,CAAhB;;AACA,YAAI7hB,OAAO,GAAG,CAAd,EAAiB;AACb,iBAAO,IAAP;AACH;;AACDmlB,mBAAW,GAAG,KAAKC,cAAL,CAAoBplB,OAApB,CAAd;;AACA,YAAImlB,WAAW,KAAK,IAApB,EAA0B;AACtB,iBAAO,IAAP;AACH;;AACDpyB,cAAM,CAACO,IAAP,CAAY6xB,WAAZ;AACAkD,iBAAS,GAAGrD,SAAZ;AACAA,iBAAS,IAAInD,QAAQ,CAAC5sB,MAAT,CAAgB,UAACC,GAAD,EAAMzB,IAAN;AAAA,iBAAeyB,GAAG,GAAGzB,IAArB;AAAA,SAAhB,EAA2C,CAA3C,CAAb;AACAuxB,iBAAS,GAAG,KAAK9C,QAAL,CAAc,KAAKC,IAAnB,EAAyB6C,SAAzB,CAAZ;AACH,OAdD,QAcSG,WAAW,KAAK,GAdzB;;AAeApyB,YAAM,CAACw1B,GAAP;;AAEA,UAAI,CAACx1B,MAAM,CAACqC,MAAZ,EAAoB;AAChB,eAAO,IAAP;AACH;;AAED,UAAI,CAAC,KAAKg0B,UAAL,CAAgBf,SAAhB,EAA2BrD,SAA3B,CAAL,EAA4C;AACxC,eAAO,IAAP;AACH;;AAED,UAAI,CAAC,KAAKqE,gBAAL,CAAsBt2B,MAAtB,CAAL,EAAoC;AAChC,eAAO,IAAP;AACH;;AAEDA,YAAM,GAAGA,MAAM,CAAC8E,KAAP,CAAa,CAAb,EAAgB9E,MAAM,CAACqC,MAAP,GAAgB,CAAhC,CAAT;;AACA,UAAI,CAACrC,MAAM,GAAG,KAAKu2B,eAAL,CAAqBv2B,MAArB,CAAV,MAA4C,IAAhD,EAAsD;AAClD,eAAO,IAAP;AACH;;AAED,aAAO;AACHivB,YAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CADH;AAEH3O,aAAK,EAAEA,KAAK,CAACA,KAFV;AAGHuK,WAAG,EAAE6S,SAHF;AAIHvD,iBAAS,EAAE7Z,KAJR;AAKHma,oBAAY,EAAEhvB;AALX,OAAP;AAOH;AA7DL;AAAA;AAAA,mCA+D6BiN,OA/D7B,EA+DsD;AAC9C,WAAK,IAAI5G,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGorB,mBAAmB,CAACpvB,MAAxC,EAAgDgE,CAAC,EAAjD,EAAqD;AACjD,YAAIorB,mBAAmB,CAACprB,CAAD,CAAnB,KAA2B4G,OAA/B,EAAwC;AACpC,iBAAOqmB,MAAM,CAACC,YAAP,CAAoB/B,QAAQ,CAACnrB,CAAD,CAA5B,CAAP;AACH;AACJ;;AACD,aAAO,IAAP;AACH;AAtEL;AAAA;AAAA,+BAwEuBivB,SAxEvB,EAwE0CrD,SAxE1C,EAwEsE;AAC9D,UAAIqD,SAAS,KAAKrD,SAAd,IAA2B,CAAC,KAAK7C,IAAL,CAAU6C,SAAV,CAAhC,EAAsD;AAClD,eAAO,KAAP;AACH;;AACD,aAAO,IAAP;AACH;AA7EL;AAAA;AAAA,+BA+EuBnD,QA/EvB,EA+EsD;AAC9C,UAAMwC,WAAW,GAAGxC,QAAQ,CAACzsB,MAA7B;AACA,UAAI4K,OAAO,GAAG,CAAd;AACA,UAAI9K,GAAG,GAAG,CAAV;;AACA,WAAK,IAAIkE,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGirB,WAApB,EAAiCjrB,CAAC,EAAlC,EAAsC;AAClClE,WAAG,IAAI2sB,QAAQ,CAACzoB,CAAD,CAAf;AACH;;AAED,WAAK,IAAIA,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAGirB,WAApB,EAAiCjrB,EAAC,EAAlC,EAAsC;AAClC,YAAI2uB,UAAU,GAAG1yB,IAAI,CAACk0B,KAAL,CAAW1H,QAAQ,CAACzoB,EAAD,CAAR,GAAc,CAAd,GAAkBlE,GAA7B,CAAjB;;AACA,YAAI6yB,UAAU,GAAG,CAAb,IAAkBA,UAAU,GAAG,CAAnC,EAAsC;AAClC,iBAAO,CAAC,CAAR;AACH;;AACD,YAAI,CAAC3uB,EAAC,GAAG,CAAL,MAAY,CAAhB,EAAmB;AACf,eAAK,IAAIuK,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGokB,UAApB,EAAgCpkB,CAAC,EAAjC,EAAqC;AACjC3D,mBAAO,GAAIA,OAAO,IAAI,CAAZ,GAAiB,CAA3B;AACH;AACJ,SAJD,MAIO;AACHA,iBAAO,KAAK+nB,UAAZ;AACH;AACJ;;AAED,aAAO/nB,OAAP;AACH;AAtGL;AAAA;AAAA,iCAwGsC;AAC9B,UAAM2iB,OAAO,GAAG,IAAIwF,WAAJ,CAAgB,CAAhB,CAAhB;;AACA,UAAMlhB,MAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,CAAf;;AACA,UAAI2G,YAAY,GAAG7hB,MAAnB;AACA,UAAIwc,UAAU,GAAG,CAAjB;AACA,UAAIH,OAAc,GAAG,CAArB;AACA,UAAIyF,mBAAJ;;AAEA,WAAK,IAAI3vB,CAAC,GAAG6N,MAAb,EAAqB7N,CAAC,GAAG,KAAK+oB,IAAL,CAAU/sB,MAAnC,EAA2CgE,CAAC,EAA5C,EAAgD;AAC5C,YAAI,KAAK+oB,IAAL,CAAU/oB,CAAV,IAAekqB,OAAnB,EAA4B;AACxBX,iBAAO,CAACc,UAAD,CAAP;AACH,SAFD,MAEO;AACH,cAAIA,UAAU,KAAKd,OAAO,CAACvtB,MAAR,GAAiB,CAApC,EAAuC;AACnC;AACA,gBAAI,KAAK8vB,UAAL,CAAgBvC,OAAhB,MAA6BuF,QAAjC,EAA2C;AACvCa,iCAAmB,GAAG1zB,IAAI,CAACsN,GAAL,CAAS,CAAT,EAAYmmB,YAAY,GAAI,CAAC1vB,CAAC,GAAG0vB,YAAL,IAAqB,CAAjD,IAAuD,CAA7E;;AACA,kBAAI,KAAKvG,WAAL,CAAiBwG,mBAAjB,EAAsCD,YAAtC,EAAoD,CAApD,CAAJ,EAA4D;AACxD,uBAAO;AACHlhB,uBAAK,EAAEkhB,YADJ;AAEH3W,qBAAG,EAAE/Y;AAFF,iBAAP;AAIH;AACJ;;AAED0vB,wBAAY,IAAInG,OAAO,CAAC,CAAD,CAAP,GAAaA,OAAO,CAAC,CAAD,CAApC;;AACA,iBAAK,IAAIhf,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AACxBgf,qBAAO,CAAChf,CAAD,CAAP,GAAagf,OAAO,CAAChf,CAAC,GAAG,CAAL,CAApB;AACH;;AACDgf,mBAAO,CAAC,CAAD,CAAP,GAAa,CAAb;AACAA,mBAAO,CAAC,CAAD,CAAP,GAAa,CAAb;AACAc,sBAAU;AACb,WAnBD,MAmBO;AACHA,sBAAU;AACb;;AACDd,iBAAO,CAACc,UAAD,CAAP,GAAsB,CAAtB;AACAH,iBAAO,GAAGA,OAAO,GAAG,CAAH,GAAO,CAAxB;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AAhJL;AAAA;AAAA,oCAkJ4BkG,SAlJ5B,EAkJqE;AAC7D,UAAMp0B,MAAM,GAAGo0B,SAAS,CAACp0B,MAAzB;AACA,UAAMrC,MAAM,GAAG,IAAIjB,KAAJ,EAAf;;AACA,WAAK,IAAIsH,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGhE,MAApB,EAA4BgE,CAAC,EAA7B,EAAiC;AAC7B,YAAM0O,MAAI,GAAG0hB,SAAS,CAACpwB,CAAD,CAAtB;;AACA,YAAI0O,MAAI,IAAI,GAAR,IAAeA,MAAI,IAAI,GAA3B,EAAgC;AAC5B,cAAI1O,CAAC,GAAIhE,MAAM,GAAG,CAAlB,EAAsB;AAClB,mBAAO,IAAP;AACH;;AACD,cAAMq0B,QAAQ,GAAGD,SAAS,CAAC,EAAEpwB,CAAH,CAA1B;AACA,cAAMswB,YAAY,GAAGD,QAAQ,CAACzhB,UAAT,CAAoB,CAApB,CAArB;AACA,cAAImd,WAAmB,SAAvB;;AACA,kBAAQrd,MAAR;AACI,iBAAK,GAAL;AAAU;AACN,oBAAI2hB,QAAQ,IAAI,GAAZ,IAAmBA,QAAQ,IAAI,GAAnC,EAAwC;AACpCtE,6BAAW,GAAGkB,MAAM,CAACC,YAAP,CAAoBoD,YAAY,GAAG,EAAnC,CAAd;AACH,iBAFD,MAEO;AACH,yBAAO,IAAP;AACH;;AACD;AACH;;AACD,iBAAK,GAAL;AAAU;AACN,oBAAID,QAAQ,IAAI,GAAZ,IAAmBA,QAAQ,IAAI,GAAnC,EAAwC;AACpCtE,6BAAW,GAAGkB,MAAM,CAACC,YAAP,CAAoBoD,YAAY,GAAG,EAAnC,CAAd;AACH,iBAFD,MAEO,IAAID,QAAQ,IAAI,GAAZ,IAAmBA,QAAQ,IAAI,GAAnC,EAAwC;AAC3CtE,6BAAW,GAAGkB,MAAM,CAACC,YAAP,CAAoBoD,YAAY,GAAG,EAAnC,CAAd;AACH,iBAFM,MAEA,IAAID,QAAQ,IAAI,GAAZ,IAAmBA,QAAQ,IAAI,GAAnC,EAAwC;AAC3CtE,6BAAW,GAAGkB,MAAM,CAACC,YAAP,CAAoBoD,YAAY,GAAG,EAAnC,CAAd;AACH,iBAFM,MAEA,IAAID,QAAQ,IAAI,GAAZ,IAAmBA,QAAQ,IAAI,GAAnC,EAAwC;AAC3CtE,6BAAW,GAAGkB,MAAM,CAACC,YAAP,CAAoBoD,YAAY,GAAG,EAAnC,CAAd;AACH,iBAFM,MAEA,IAAID,QAAQ,IAAI,GAAZ,IAAmBA,QAAQ,IAAI,GAAnC,EAAwC;AAC3CtE,6BAAW,GAAGkB,MAAM,CAACC,YAAP,CAAoB,GAApB,CAAd;AACH,iBAFM,MAEA;AACH,yBAAO,IAAP;AACH;;AACD;AACH;;AACD,iBAAK,GAAL;AAAU;AACN,oBAAImD,QAAQ,IAAI,GAAZ,IAAmBA,QAAQ,IAAI,GAAnC,EAAwC;AACpCtE,6BAAW,GAAGkB,MAAM,CAACC,YAAP,CAAoBoD,YAAY,GAAG,EAAnC,CAAd;AACH,iBAFD,MAEO,IAAID,QAAQ,KAAK,GAAjB,EAAsB;AACzBtE,6BAAW,GAAG,GAAd;AACH,iBAFM,MAEA;AACH,yBAAO,IAAP;AACH;;AACD;AACH;;AACD,iBAAK,GAAL;AAAU;AACN,oBAAIsE,QAAQ,IAAI,GAAZ,IAAmBA,QAAQ,IAAI,GAAnC,EAAwC;AACpCtE,6BAAW,GAAGkB,MAAM,CAACC,YAAP,CAAoBoD,YAAY,GAAG,EAAnC,CAAd;AACH,iBAFD,MAEO;AACH,yBAAO,IAAP;AACH;;AACD;AACH;AA1CL;;AA4CA32B,gBAAM,CAACO,IAAP,CAAY6xB,WAAZ;AACH,SApDD,MAoDO;AACHpyB,gBAAM,CAACO,IAAP,CAAYwU,MAAZ;AACH;AACJ;;AACD,aAAO/U,MAAP;AACH;AAhNL;AAAA;AAAA,qCAkN6By2B,SAlN7B,EAkNgE;AACxD,aAAO,KAAKG,eAAL,CAAqBH,SAArB,EAAgCA,SAAS,CAACp0B,MAAV,GAAmB,CAAnD,EAAsD,EAAtD,KACA,KAAKu0B,eAAL,CAAqBH,SAArB,EAAgCA,SAAS,CAACp0B,MAAV,GAAmB,CAAnD,EAAsD,EAAtD,CADP;AAEH;AArNL;AAAA;AAAA,oCAuN4Bo0B,SAvN5B,EAuNsDzhB,KAvNtD,EAuNqE6hB,SAvNrE,EAuNiG;AACzF,UAAMC,YAAY,GAAGL,SAAS,CAAC3xB,KAAV,CAAgB,CAAhB,EAAmBkQ,KAAnB,CAArB;AACA,UAAM3S,MAAM,GAAGy0B,YAAY,CAACz0B,MAA5B;AACA,UAAM00B,YAAY,GAAGD,YAAY,CAAC50B,MAAb,CAAoB,UAACC,GAAD,EAAM4S,MAAN,EAAY1O,CAAZ,EAAkB;AACvD,YAAM2wB,MAAM,GAAI,CAAE3wB,CAAC,GAAG,CAAC,CAAN,IAAYhE,MAAM,GAAG,CAArB,CAAD,IAA4Bw0B,SAA7B,GAA0C,CAAzD;AACA,YAAMtxB,KAAK,GAAGisB,QAAQ,CAACnV,OAAT,CAAiBtH,MAAI,CAACE,UAAL,CAAgB,CAAhB,CAAjB,CAAd;AACA,eAAO9S,GAAG,GAAI60B,MAAM,GAAGzxB,KAAvB;AACH,OAJoB,EAIlB,CAJkB,CAArB;AAMA,UAAM0xB,SAAS,GAAGzF,QAAQ,CAAEuF,YAAY,GAAG,EAAjB,CAA1B;AACA,aAAOE,SAAS,KAAKR,SAAS,CAACzhB,KAAD,CAAT,CAAiBC,UAAjB,CAA4B,CAA5B,CAArB;AACH;AAlOL;;AAAA;AAAA,EAAkCib,6DAAlC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACVA;AAEO,IAAMgH,UAAb;AAAA;AAAA;AAAA;;AACI,sBAAYr4B,MAAZ,EAA0CyO,WAA1C,EAA8E;AAAA;;AAAA;;AAC1E,8MAAMzO,MAAN,EAAcyO,WAAd;AAEA,UAAKihB,OAAL,GAAe,OAAf;AAH0E;AAI7E;;AALL;AAAA;AAAA,2BAOW4I,GAPX,EAOgCtiB,KAPhC,EAOyD;AACjD,UAAMuK,GAAG,GAAG+X,GAAG,CAAC90B,MAAhB;AACA,UAAMrC,MAAM,GAAG,IAAIjB,KAAJ,EAAf;AACA,UAAMiwB,YAAY,GAAG,IAAIjwB,KAAJ,EAArB;AACA,UAAImV,MAAM,GAAGW,KAAb;AACA,UAAIuiB,aAAa,GAAG,CAApB;AACA,UAAInI,IAAJ;AAEA,WAAKG,IAAL,GAAY+H,GAAZ;;AAEA,WAAK,IAAI9wB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAAJ,IAAS6N,MAAM,GAAGkL,GAAlC,EAAuC/Y,CAAC,EAAxC,EAA4C;AACxC4oB,YAAI,GAAG,KAAKgB,WAAL,CAAiB/b,MAAjB,CAAP;;AACA,YAAI,CAAC+a,IAAL,EAAW;AACP,iBAAO,IAAP;AACH;;AACDD,oBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AACAjvB,cAAM,CAACO,IAAP,CAAY0uB,IAAI,CAACA,IAAL,GAAY,EAAxB;;AACA,YAAIA,IAAI,CAACA,IAAL,IAAa,KAAKoI,YAAtB,EAAoC;AAChCD,uBAAa,IAAI,KAAM,IAAI/wB,CAA3B;AACH;;AACD,YAAIA,CAAC,KAAK,CAAV,EAAa;AACT6N,gBAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,EAAyBH,IAAI,CAAC7P,GAA9B,CAAT;AACAlL,gBAAM,GAAG,KAAK8d,UAAL,CAAgB,KAAK5C,IAArB,EAA2Blb,MAA3B,CAAT;AACH;AACJ;;AAED,UAAIlU,MAAM,CAACqC,MAAP,KAAkB,CAAlB,IAAwBi1B,QAAQ,CAACt3B,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CAAD,CAAR,GAA4B,CAA7B,KAAoC4T,aAA/D,EAA8E;AAC1E,eAAO,IAAP;AACH;;AAED,aAAO;AACHnI,YAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CADH;AAEHwL,oBAAY,EAAZA,YAFG;AAGH5P,WAAG,EAAE6P,IAAI,CAAC7P;AAHP,OAAP;AAKH;AA1CL;;AAAA;AAAA,EAAgCmY,qDAAhC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACFA;AAEO,IAAMC,UAAb;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,wBAC+C;AACvC,aAAO,CAAC,EAAD,EAAK,EAAL,EAAS,EAAT,EAAa,EAAb,EAAiB,EAAjB,EAAqB,CAArB,EAAwB,CAAxB,EAA2B,EAA3B,EAA+B,CAA/B,EAAkC,CAAlC,CAAP;AACH;AAHL;;AAKI,sBAAY34B,MAAZ,EAA0CyO,WAA1C,EAA8E;AAAA;;AAAA;;AAC1E,8MAAMzO,MAAN,EAAcyO,WAAd;AAEA,UAAKihB,OAAL,GAAe,OAAf;AAH0E;AAI7E;;AATL;AAAA;AAAA,2BAWW4I,GAXX,EAWgCtiB,KAXhC,EAWyD;AACjD,UAAMuK,GAAG,GAAG+X,GAAG,CAAC90B,MAAhB;AACA,UAAMrC,MAAM,GAAG,IAAIjB,KAAJ,EAAf;AACA,UAAMiwB,YAAY,GAAG,IAAIjwB,KAAJ,EAArB;AACA,UAAIq4B,aAAa,GAAG,CAApB;AACA,UAAIljB,MAAM,GAAGW,KAAb;AACA,UAAIoa,IAAJ;AAEA,WAAKG,IAAL,GAAY+H,GAAZ;;AAEA,WAAK,IAAI9wB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAAJ,IAAS6N,MAAM,GAAGkL,GAAlC,EAAuC/Y,CAAC,EAAxC,EAA4C;AACxC4oB,YAAI,GAAG,KAAKgB,WAAL,CAAiB/b,MAAjB,CAAP;;AACA,YAAI,CAAC+a,IAAL,EAAW;AACP,iBAAO,IAAP;AACH;;AACDD,oBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AACAjvB,cAAM,CAACO,IAAP,CAAY0uB,IAAI,CAACA,IAAL,GAAY,EAAxB;;AACA,YAAIA,IAAI,CAACA,IAAL,IAAa,KAAKoI,YAAtB,EAAoC;AAChCD,uBAAa,IAAI,KAAM,IAAI/wB,CAA3B;AACH;;AACD,YAAIA,CAAC,KAAK,CAAV,EAAa;AACT6N,gBAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,EAAyBH,IAAI,CAAC7P,GAA9B,CAAT;AACAlL,gBAAM,GAAG,KAAK8d,UAAL,CAAgB,KAAK5C,IAArB,EAA2Blb,MAA3B,CAAT;AACH;AACJ;;AAED,UAAIlU,MAAM,CAACqC,MAAP,KAAkB,CAAtB,EAAyB;AACrB,eAAO,IAAP;AACH;;AAED,UAAI,KAAKo1B,kBAAL,CAAwBz3B,MAAxB,MAAoC,KAAK03B,oBAAL,CAA0BN,aAA1B,CAAxC,EAAkF;AAC9E,eAAO,IAAP;AACH;;AAED,aAAO;AACHnI,YAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CADH;AAEHwL,oBAAY,EAAZA,YAFG;AAGH5P,WAAG,EAAE6P,IAAI,CAAC7P;AAHP,OAAP;AAKH;AAlDL;AAAA;AAAA,yCAoDiCgY,aApDjC,EAoDuE;AAC/D,WAAK,IAAI/wB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,EAApB,EAAwBA,CAAC,EAAzB,EAA6B;AACzB,YAAI+wB,aAAa,KAAK,KAAKO,qBAAL,CAA2BtxB,CAA3B,CAAtB,EAAqD;AACjD,iBAAOA,CAAP;AACH;AACJ;;AACD,aAAO,IAAP;AACH;AA3DL;AAAA;AAAA,uCA6D+BrG,MA7D/B,EA6D8D;AACtD,UAAIqC,MAAM,GAAGrC,MAAM,CAACqC,MAApB;AACA,UAAIF,GAAG,GAAG,CAAV;;AAEA,WAAK,IAAIkE,CAAC,GAAGhE,MAAM,GAAG,CAAtB,EAAyBgE,CAAC,IAAI,CAA9B,EAAiCA,CAAC,IAAI,CAAtC,EAAyC;AACrClE,WAAG,IAAInC,MAAM,CAACqG,CAAD,CAAb;AACH;;AACDlE,SAAG,IAAI,CAAP;;AACA,WAAK,IAAIkE,EAAC,GAAGhE,MAAM,GAAG,CAAtB,EAAyBgE,EAAC,IAAI,CAA9B,EAAiCA,EAAC,IAAI,CAAtC,EAAyC;AACrClE,WAAG,IAAInC,MAAM,CAACqG,EAAD,CAAb;AACH;;AACDlE,SAAG,IAAI,CAAP;AAEA,aAAOA,GAAG,GAAG,EAAb;AACH;AA3EL;;AAAA;AAAA,EAAgCo1B,qDAAhC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACFA;AAEO,IAAMK,UAAb;AAAA;AAAA;AAAA;;AACI,sBAAY/4B,MAAZ,EAA0CyO,WAA1C,EAA8E;AAAA;;AAAA;;AAC1E,8MAAMzO,MAAN,EAAcyO,WAAd;AAEA,UAAKihB,OAAL,GAAe,OAAf;AAH0E;AAI7E;;AALL;AAAA;AAAA,mCAO6BU,IAP7B,EAOgDjvB,MAPhD,EAOuEgvB,YAPvE,EAOsH;AAC9G,WAAK,IAAI3oB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AACxB4oB,YAAI,GAAG,KAAKgB,WAAL,CAAiBhB,IAAI,CAAC7P,GAAtB,EAA2B,KAAKiY,YAAhC,CAAP;;AACA,YAAI,CAACpI,IAAL,EAAW;AACP,iBAAO,IAAP;AACH;;AACDjvB,cAAM,CAACO,IAAP,CAAY0uB,IAAI,CAACA,IAAjB;AACAD,oBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AACH;;AAEDA,UAAI,GAAG,KAAKK,YAAL,CAAkB,KAAKuI,cAAvB,EAAuC5I,IAAI,CAAC7P,GAA5C,EAAiD,CAAjD,EAAoD,KAApD,CAAP;;AAEA,UAAI6P,IAAI,KAAK,IAAb,EAAmB;AACf,eAAO,IAAP;AACH;;AAEDD,kBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;;AAEA,WAAK,IAAI5oB,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAG,CAApB,EAAuBA,EAAC,EAAxB,EAA4B;AACxB4oB,YAAI,GAAG,KAAKgB,WAAL,CAAiBhB,IAAI,CAAC7P,GAAtB,EAA2B,KAAKiY,YAAhC,CAAP;;AAEA,YAAI,CAACpI,IAAL,EAAW;AACP,iBAAO,IAAP;AACH;;AAEDD,oBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AACAjvB,cAAM,CAACO,IAAP,CAAY0uB,IAAI,CAACA,IAAjB;AACH;;AAED,aAAOA,IAAP;AACH;AArCL;;AAAA;AAAA,EAAgCsI,qDAAhC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACHA;AACA;AAEA,IAAMO,uBAAuB,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAhC;AACA,IAAM3J,YAAY,GAAG,CACjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CADiB,EAEjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAFiB,EAGjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAHiB,EAIjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAJiB,EAKjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CALiB,EAMjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CANiB,EAOjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAPiB,EAQjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CARiB,EASjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CATiB,EAUjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAViB,EAWjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAXiB,EAYjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAZiB,EAajB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAbiB,EAcjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAdiB,EAejB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAfiB,EAgBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAhBiB,EAiBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAjBiB,EAkBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAlBiB,EAmBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAnBiB,EAoBjB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CApBiB,CAArB;AAsBA,IAAM4J,cAAc,GAAG,CAAC,CAAD,EAAI,EAAJ,EAAQ,EAAR,EAAY,EAAZ,EAAgB,EAAhB,EAAoB,EAApB,EAAwB,EAAxB,EAA4B,EAA5B,EAAgC,EAAhC,EAAoC,EAApC,CAAvB;AAEO,IAAMR,SAAb;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,wBAC+B;AACvB,aAAO,CAAP;AACH;AAHL;AAAA;AAAA,wBAK+B;AACvB,aAAO,EAAP;AACH;AAPL;AAAA;AAAA,wBASuC;AAC/B,aAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAP;AACH;AAXL;AAAA;AAAA,wBAasC;AAC9B,aAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAP;AACH;AAfL;AAAA;AAAA,wBAiBwC;AAChC,aAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,CAAP;AACH;AAnBL;;AAqBI,qBAAY14B,MAAZ,EAA0CyO,WAA1C,EAA8E;AAAA;;AAAA;;AAC1E,6MAAM5E,2DAAK,CAAC;AACR4E,iBAAW,EAAE,EADL,CACQ;;AADR,KAAD,EAERzO,MAFQ,CAAX,EAEYyO,WAFZ;AAIA,UAAKihB,OAAL,GAAe,QAAf;AACA,UAAKC,gBAAL,GAAwB,IAAxB;AACA,UAAKC,iBAAL,GAAyB,IAAzB;AAP0E;AAQ7E;;AA7BL;AAAA;AAAA,gCA+B0B5Z,KA/B1B,EA+ByCmjB,SA/BzC,EA+B0E;AAClE,UAAMpI,OAAO,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAAhB;AACA,UAAM1b,MAAM,GAAGW,KAAf;AACA,UAAMgb,SAAsB,GAAG;AAC3B5f,aAAK,EAAEqU,MAAM,CAACC,SADa;AAE3B0K,YAAI,EAAE,CAAC,CAFoB;AAG3Bpa,aAAK,EAAEA,KAHoB;AAI3BuK,WAAG,EAAEvK;AAJsB,OAA/B;AAMA,UAAM4b,OAAO,GAAG,KAAKV,kBAArB;AACA,UAAIQ,OAAc,GAAG,KAAKnB,IAAL,CAAUlb,MAAV,IAAoB,CAApB,GAAwB,CAA7C;AACA,UAAIwc,UAAU,GAAG,CAAjB;;AAEA,UAAI,CAACsH,SAAL,EAAgB;AACZA,iBAAS,GAAG7J,YAAY,CAAC9rB,MAAzB;AACH;;AAED,WAAK,IAAIgE,CAAC,GAAG6N,MAAb,EAAqB7N,CAAC,GAAG,KAAK+oB,IAAL,CAAU/sB,MAAnC,EAA2CgE,CAAC,EAA5C,EAAgD;AAC5C,YAAI,KAAK+oB,IAAL,CAAU/oB,CAAV,IAAekqB,OAAnB,EAA4B;AACxBX,iBAAO,CAACc,UAAD,CAAP;AACH,SAFD,MAEO;AACH,cAAIA,UAAU,KAAKd,OAAO,CAACvtB,MAAR,GAAiB,CAApC,EAAuC;AACnC,iBAAK,IAAI4sB,IAAI,GAAG,CAAhB,EAAmBA,IAAI,GAAG+I,SAA1B,EAAqC/I,IAAI,EAAzC,EAA6C;AACzC,kBAAMhf,KAAK,GAAG,KAAK6f,aAAL,CAAmBF,OAAnB,EAA4BzB,YAAY,CAACc,IAAD,CAAxC,CAAd;;AACA,kBAAIhf,KAAK,GAAG4f,SAAS,CAAC5f,KAAtB,EAA6B;AACzB4f,yBAAS,CAACZ,IAAV,GAAiBA,IAAjB;AACAY,yBAAS,CAAC5f,KAAV,GAAkBA,KAAlB;AACH;AACJ;;AACD4f,qBAAS,CAACzQ,GAAV,GAAgB/Y,CAAhB;;AACA,gBAAIwpB,SAAS,CAAC5f,KAAV,GAAkBwgB,OAAtB,EAA+B;AAC3B,qBAAO,IAAP;AACH;;AACD,mBAAOZ,SAAP;AACH,WAbD,MAaO;AACHa,sBAAU;AACb;;AACDd,iBAAO,CAACc,UAAD,CAAP,GAAsB,CAAtB;AACAH,iBAAO,GAAGA,OAAO,GAAG,CAAH,GAAO,CAAxB;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AA1EL;AAAA;AAAA,iCA4EwC;AAChC,UAAIrc,MAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,CAAb;;AACA,UAAIV,SAAJ;;AAEA,aAAO,CAACA,SAAR,EAAmB;AACfA,iBAAS,GAAG,KAAKY,YAAL,CAAkB,KAAKrB,aAAvB,EAAsC/Z,MAAtC,EAA8C,CAA9C,EAAiD,IAAjD,CAAZ;;AAEA,YAAI,CAACwa,SAAL,EAAgB;AACZ,iBAAO,IAAP;AACH;;AAED,YAAMa,sBAAsB,GAAGb,SAAS,CAAC7Z,KAAV,IAAmB6Z,SAAS,CAACtP,GAAV,GAAgBsP,SAAS,CAAC7Z,KAA7C,CAA/B;;AAEA,YAAI0a,sBAAsB,IAAI,CAA9B,EAAiC;AAC7B,cAAI,KAAKC,WAAL,CAAiBD,sBAAjB,EAAyCb,SAAS,CAAC7Z,KAAnD,EAA0D,CAA1D,CAAJ,EAAkE;AAC9D,mBAAO6Z,SAAP;AACH;AACJ;;AAEDxa,cAAM,GAAGwa,SAAS,CAACtP,GAAnB;AACAsP,iBAAS,GAAG,IAAZ;AACH;;AAED,aAAO,IAAP;AACH;AApGL;AAAA;AAAA,8CAsGwCE,OAtGxC,EAsG2E;AACnE,UAAMa,qBAAqB,GAAGb,OAAO,CAACxP,GAAR,IAAewP,OAAO,CAACxP,GAAR,GAAcwP,OAAO,CAAC/Z,KAArC,CAA9B;;AAEA,UAAI4a,qBAAqB,GAAG,KAAKL,IAAL,CAAU/sB,MAAtC,EAA8C;AAC1C,YAAI,KAAKmtB,WAAL,CAAiBZ,OAAO,CAACxP,GAAzB,EAA8BqQ,qBAA9B,EAAqD,CAArD,CAAJ,EAA6D;AACzD,iBAAOb,OAAP;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AAhHL;AAAA;AAAA,6BAkHuB1a,MAlHvB,EAkHuCqc,OAlHvC,EAkHoE;AAC5D,UAAM3B,OAAO,GAAG,KAAKU,YAAL,CAAkB,KAAKpB,YAAvB,EAAqCha,MAArC,EAA6Cqc,OAA7C,EAAsD,KAAtD,CAAhB;;AAEA,aAAO3B,OAAO,KAAK,IAAZ,GAAmB,KAAKe,yBAAL,CAA+Bf,OAA/B,CAAnB,GAA6D,IAApE;AACH;AAtHL;AAAA;AAAA,yCAwHiCwI,aAxHjC,EAwHuE;AAC/D,WAAK,IAAI/wB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG0xB,cAAc,CAAC11B,MAAnC,EAA2CgE,CAAC,EAA5C,EAAgD;AAC5C,YAAI+wB,aAAa,KAAKW,cAAc,CAAC1xB,CAAD,CAApC,EAAyC;AACrC,iBAAOA,CAAP;AACH;AACJ;;AACD,aAAO,IAAP;AACH;AA/HL;AAAA;AAAA,mCAiI6B4oB,IAjI7B,EAiIgDjvB,MAjIhD,EAiIuEgvB,YAjIvE,EAiIsH;AAC9G,UAAIoI,aAAa,GAAG,GAApB;;AAEA,WAAK,IAAI/wB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AACxB4oB,YAAI,GAAG,KAAKgB,WAAL,CAAiBhB,IAAI,CAAC7P,GAAtB,CAAP;;AACA,YAAI,CAAC6P,IAAL,EAAW;AACP,iBAAO,IAAP;AACH;;AACD,YAAIA,IAAI,CAACA,IAAL,IAAa,KAAKoI,YAAtB,EAAoC;AAChCpI,cAAI,CAACA,IAAL,IAAa,KAAKoI,YAAlB;AACAD,uBAAa,IAAI,KAAM,IAAI/wB,CAA3B;AACH,SAHD,MAGO;AACH+wB,uBAAa,IAAI,KAAM,IAAI/wB,CAA3B;AACH;;AACDrG,cAAM,CAACO,IAAP,CAAY0uB,IAAI,CAACA,IAAjB;AACAD,oBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AACH;;AAED,UAAMgJ,UAAU,GAAG,KAAKC,oBAAL,CAA0Bd,aAA1B,CAAnB;;AAEA,UAAIa,UAAU,KAAK,IAAnB,EAAyB;AACrB,eAAO,IAAP;AACH;;AAEDj4B,YAAM,CAAC2a,OAAP,CAAesd,UAAf;AAEAhJ,UAAI,GAAG,KAAKK,YAAL,CAAkB,KAAKuI,cAAvB,EAAuC5I,IAAI,CAAC7P,GAA5C,EAAiD,CAAjD,EAAoD,KAApD,CAAP;;AAEA,UAAI6P,IAAI,KAAK,IAAb,EAAmB;AACf,eAAO,IAAP;AACH;;AAEDD,kBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;;AAEA,WAAK,IAAI5oB,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAG,CAApB,EAAuBA,EAAC,EAAxB,EAA4B;AACxB4oB,YAAI,GAAG,KAAKgB,WAAL,CAAiBhB,IAAI,CAAC7P,GAAtB,EAA2B,KAAKiY,YAAhC,CAAP;;AAEA,YAAI,CAACpI,IAAL,EAAW;AACP,iBAAO,IAAP;AACH;;AAEDD,oBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AACAjvB,cAAM,CAACO,IAAP,CAAY0uB,IAAI,CAACA,IAAjB;AACH;;AAED,aAAOA,IAAP;AACH;AA/KL;AAAA;AAAA,6BAiLsB;AACd,UAAMjvB,MAAM,GAAG,IAAIjB,KAAJ,EAAf;AACA,UAAMiwB,YAAY,GAAG,IAAIjwB,KAAJ,EAArB;AACA,UAAIo5B,UAAmB,GAAG,EAA1B;;AACA,UAAIzJ,SAAS,GAAG,KAAKC,UAAL,EAAhB;;AAEA,UAAI,CAACD,SAAL,EAAgB;AACZ,eAAO,IAAP;AACH;;AAED,UAAIO,IAAiB,GAAG;AACpBA,YAAI,EAAEP,SAAS,CAACO,IADI;AAEpBpa,aAAK,EAAE6Z,SAAS,CAAC7Z,KAFG;AAGpBuK,WAAG,EAAEsP,SAAS,CAACtP;AAHK,OAAxB;AAKA4P,kBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AAEAA,UAAI,GAAG,KAAKC,cAAL,CAAoBD,IAApB,EAA0BjvB,MAA1B,EAAkCgvB,YAAlC,CAAP;;AAEA,UAAI,CAACC,IAAL,EAAW;AACP,eAAO,IAAP;AACH;;AAEDA,UAAI,GAAG,KAAKJ,QAAL,CAAcI,IAAI,CAAC7P,GAAnB,EAAwB,CAAxB,CAAP;;AAEA,UAAI,CAAC6P,IAAL,EAAW;AACP,eAAO,IAAP;AACH;;AAEDD,kBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB,EA7Bc,CA+Bd;;AACA,UAAI,CAAC,KAAKmJ,SAAL,CAAep4B,MAAf,CAAL,EAA6B;AACzB,eAAO,IAAP;AACH;;AAED,UAAI,KAAKsN,WAAL,CAAiBjL,MAAjB,GAA0B,CAA9B,EAAiC;AAC7B,YAAMqL,UAAU,GAAG,KAAK2qB,iBAAL,CAAuBpJ,IAAI,CAAC7P,GAA5B,CAAnB;;AACA,YAAI,CAAC1R,UAAL,EAAiB;AACb,iBAAO,IAAP;AACH;;AAED,YAAM4qB,QAAQ,GAAG5qB,UAAU,CAACshB,YAAX,CAAwBthB,UAAU,CAACshB,YAAX,CAAwB3sB,MAAxB,GAAiC,CAAzD,CAAjB;AACA,YAAMusB,OAAO,GAAG;AACZ/Z,eAAK,EAAEyjB,QAAQ,CAACzjB,KAAT,IAAmB,CAACyjB,QAAQ,CAAClZ,GAAT,GAAekZ,QAAQ,CAACzjB,KAAzB,IAAkC,CAAnC,GAAwC,CAA1D,CADK;AAEZuK,aAAG,EAAEkZ,QAAQ,CAAClZ;AAFF,SAAhB;;AAKA,YAAI,CAAC,KAAKuQ,yBAAL,CAA+Bf,OAA/B,CAAL,EAA8C;AAC1C,iBAAO,IAAP;AACH;;AAEDuJ,kBAAU,GAAG;AACTzqB,oBAAU,EAAVA,UADS;AAETuhB,cAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,IAAkB9V,UAAU,CAACuhB;AAF1B,SAAb;AAIH;;AAED;AACIA,YAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CADV;AAEI3O,aAAK,EAAE6Z,SAAS,CAAC7Z,KAFrB;AAGIuK,WAAG,EAAE6P,IAAI,CAAC7P,GAHd;AAIIsP,iBAAS,EAATA,SAJJ;AAKIM,oBAAY,EAAZA;AALJ,SAMOmJ,UANP;AAQH;AAnPL;AAAA;AAAA,sCAqP8BjkB,MArP9B,EAqPuD;AAC/C,UAAMW,KAAK,GAAG,KAAKsa,QAAL,CAAc,KAAKC,IAAnB,EAAyBlb,MAAzB,CAAd;;AACA,UAAMwa,SAAS,GAAG,KAAKY,YAAL,CAAkBwI,uBAAlB,EAA2CjjB,KAA3C,EAAkD,CAAlD,EAAqD,KAArD,CAAlB;;AAEA,UAAI6Z,SAAS,KAAK,IAAlB,EAAwB;AACpB,eAAO,IAAP;AACH;;AAED,WAAK,IAAIroB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,KAAKiH,WAAL,CAAiBjL,MAArC,EAA6CgE,CAAC,EAA9C,EAAkD;AAC9C,YAAIrG,MAAM,GAAG,KAAKsN,WAAL,CAAiBjH,CAAjB,EAAoB8qB,MAApB,CAA2B,KAAK/B,IAAhC,EAAsCV,SAAS,CAACtP,GAAhD,CAAb;;AACA,YAAIpf,MAAM,KAAK,IAAf,EAAqB;AACjB,iBAAO;AACHivB,gBAAI,EAAEjvB,MAAM,CAACivB,IADV;AAEHpa,iBAAK,EAALA,KAFG;AAGH6Z,qBAAS,EAATA,SAHG;AAIHtP,eAAG,EAAEpf,MAAM,CAACof,GAJT;AAKH4P,wBAAY,EAAEhvB,MAAM,CAACgvB;AALlB,WAAP;AAOH;AACJ;;AAED,aAAO,IAAP;AACH;AA3QL;AAAA;AAAA,8BA6QwBhvB,MA7QxB,EA6QwD;AAChD,UAAImC,GAAG,GAAG,CAAV;;AAEA,WAAK,IAAIkE,CAAC,GAAGrG,MAAM,CAACqC,MAAP,GAAgB,CAA7B,EAAgCgE,CAAC,IAAI,CAArC,EAAwCA,CAAC,IAAI,CAA7C,EAAgD;AAC5ClE,WAAG,IAAInC,MAAM,CAACqG,CAAD,CAAb;AACH;;AAEDlE,SAAG,IAAI,CAAP;;AAEA,WAAK,IAAIkE,GAAC,GAAGrG,MAAM,CAACqC,MAAP,GAAgB,CAA7B,EAAgCgE,GAAC,IAAI,CAArC,EAAwCA,GAAC,IAAI,CAA7C,EAAgD;AAC5ClE,WAAG,IAAInC,MAAM,CAACqG,GAAD,CAAb;AACH;;AAED,aAAOlE,GAAG,GAAG,EAAN,KAAa,CAApB;AACH;AA3RL;;AAAA;AAAA,EAA+B+tB,6DAA/B,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5BA;AACA;AAEA,IAAMnC,CAAC,GAAG,CAAV;AACA,IAAMC,CAAC,GAAG,CAAV;AACA,IAAMC,aAAa,GAAG,CAACF,CAAD,EAAIA,CAAJ,EAAOA,CAAP,EAAUA,CAAV,CAAtB;AACA,IAAMG,YAAY,GAAG,CAACH,CAAD,EAAIA,CAAJ,EAAOC,CAAP,CAArB;AACA,IAAMG,YAAY,GAAG,CACjB,CAACJ,CAAD,EAAIA,CAAJ,EAAOC,CAAP,EAAUA,CAAV,EAAaD,CAAb,CADiB,EAEjB,CAACC,CAAD,EAAID,CAAJ,EAAOA,CAAP,EAAUA,CAAV,EAAaC,CAAb,CAFiB,EAGjB,CAACD,CAAD,EAAIC,CAAJ,EAAOD,CAAP,EAAUA,CAAV,EAAaC,CAAb,CAHiB,EAIjB,CAACA,CAAD,EAAIA,CAAJ,EAAOD,CAAP,EAAUA,CAAV,EAAaA,CAAb,CAJiB,EAKjB,CAACA,CAAD,EAAIA,CAAJ,EAAOC,CAAP,EAAUD,CAAV,EAAaC,CAAb,CALiB,EAMjB,CAACA,CAAD,EAAID,CAAJ,EAAOC,CAAP,EAAUD,CAAV,EAAaA,CAAb,CANiB,EAOjB,CAACA,CAAD,EAAIC,CAAJ,EAAOA,CAAP,EAAUD,CAAV,EAAaA,CAAb,CAPiB,EAQjB,CAACA,CAAD,EAAIA,CAAJ,EAAOA,CAAP,EAAUC,CAAV,EAAaA,CAAb,CARiB,EASjB,CAACA,CAAD,EAAID,CAAJ,EAAOA,CAAP,EAAUC,CAAV,EAAaD,CAAb,CATiB,EAUjB,CAACA,CAAD,EAAIC,CAAJ,EAAOD,CAAP,EAAUC,CAAV,EAAaD,CAAb,CAViB,CAArB;AAYA,IAAMwK,qBAAqB,GAAG,CAA9B;AAEO,IAAMC,WAAb;AAAA;AAAA;AAAA;;AAGI,uBAAY35B,MAAZ,EAA0C;AAAA;;AAAA;;AACtC,+MAAM6J,2DAAK,CAAC;AACR+vB,4BAAsB,EAAE,KADhB,CACsB;;AADtB,KAAD,EAER55B,MAFQ,CAAX;;AADsC;;AAKtC,UAAKyvB,cAAL,GAAsB,CAAC,CAAD,EAAI,CAAJ,CAAtB;AACA,UAAKC,OAAL,GAAe,OAAf;;AAEA,QAAI,MAAK1vB,MAAL,CAAY45B,sBAAhB,EAAwC;AACpC,YAAKjK,gBAAL,GAAwB,IAAxB;AACA,YAAKC,iBAAL,GAAyB,IAAzB;AACH,KAHD,MAGO;AACH,YAAKD,gBAAL,GAAwB,IAAxB;AACA,YAAKC,iBAAL,GAAyB,IAAzB;AACH;;AAdqC;AAezC;;AAlBL;AAAA;AAAA,6BAoBsB;AACd,UAAMC,SAAS,GAAG,KAAKC,UAAL,EAAlB;;AAEA,UAAI,CAACD,SAAL,EAAgB;AACZ,eAAO,IAAP;AACH;;AAED,UAAME,OAAO,GAAG,KAAKC,QAAL,EAAhB;;AAEA,UAAI,CAACD,OAAL,EAAc;AACV,eAAO,IAAP;AACH;;AAED,UAAME,QAAQ,GAAG,KAAKC,aAAL,CAAmBL,SAAS,CAACtP,GAA7B,EAAkCwP,OAAO,CAAC/Z,KAA1C,EAAiD,CAAjD,CAAjB;;AAEA,UAAIia,QAAQ,CAACzsB,MAAT,GAAkB,EAAlB,KAAyB,CAA7B,EAAgC;AAC5B,eAAO,IAAP;AACH;;AAED,UAAMrC,MAAM,GAAG,IAAIjB,KAAJ,EAAf;AACA,UAAMiwB,YAAY,GAAG,IAAIjwB,KAAJ,EAArB;AAEAiwB,kBAAY,CAACzuB,IAAb,CAAkBmuB,SAAlB;;AAEA,UAAMO,IAAI,GAAG,KAAKC,cAAL,CAAoBJ,QAApB,EAA8B9uB,MAA9B,EAAsCgvB,YAAtC,CAAb;;AAEA,UAAI,CAACC,IAAD,IAASjvB,MAAM,CAACqC,MAAP,GAAgB,CAAhB,KAAsB,CAA/B,IAAoCrC,MAAM,CAACqC,MAAP,GAAgB,CAAxD,EAA2D;AACvD,eAAO,IAAP;AACH;;AAED2sB,kBAAY,CAACzuB,IAAb,CAAkBquB,OAAlB;AAEA,aAAO;AACHK,YAAI,EAAEjvB,MAAM,CAACwjB,IAAP,CAAY,EAAZ,CADH;AAEH3O,aAAK,EAAE6Z,SAAS,CAAC7Z,KAFd;AAGHuK,WAAG,EAAEwP,OAAO,CAACxP,GAHV;AAIHsP,iBAAS,EAATA,SAJG;AAKHM,oBAAY,EAAZA;AALG,OAAP;AAOH;AA3DL;AAAA;AAAA,kCA6D4BY,OA7D5B,EA6DoDX,IA7DpD,EA6DyF;AACjF,UAAI,KAAKpwB,MAAL,CAAY45B,sBAAhB,EAAwC;AACpC,YAAMC,UAA4B,GAAG,CAAC,CAAD,EAAI,CAAJ,CAArC;AACA,YAAMC,OAAyB,GAAG,CAAC,CAAD,EAAI,CAAJ,CAAlC;AACA,YAAM1H,UAA4B,GAAG,CAAC,CAAD,EAAI,CAAJ,CAArC;AACA,YAAM2H,eAAe,GAAGL,qBAAxB;AACA,YAAMM,sBAAsB,GAAG,IAAID,eAAnC;;AAEA,aAAK,IAAIvyB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGupB,OAAO,CAACvtB,MAA5B,EAAoCgE,CAAC,EAArC,EAAyC;AACrCqyB,oBAAU,CAACryB,CAAC,GAAG,CAAL,CAAV,IAAqBupB,OAAO,CAACvpB,CAAD,CAA5B;AACAsyB,iBAAO,CAACtyB,CAAC,GAAG,CAAL,CAAP,IAAkB4oB,IAAI,CAAC5oB,CAAD,CAAtB;AACH;;AAED4qB,kBAAU,CAAC,CAAD,CAAV,GAAgB0H,OAAO,CAAC,CAAD,CAAP,GAAaD,UAAU,CAAC,CAAD,CAAvC;AACAzH,kBAAU,CAAC,CAAD,CAAV,GAAgB0H,OAAO,CAAC,CAAD,CAAP,GAAaD,UAAU,CAAC,CAAD,CAAvC;AAEAzH,kBAAU,CAAC,CAAD,CAAV,GAAgB3uB,IAAI,CAACsN,GAAL,CAAStN,IAAI,CAACqN,GAAL,CAASshB,UAAU,CAAC,CAAD,CAAnB,EAAwB2H,eAAxB,CAAT,EAAmDC,sBAAnD,CAAhB;AACA5H,kBAAU,CAAC,CAAD,CAAV,GAAgB3uB,IAAI,CAACsN,GAAL,CAAStN,IAAI,CAACqN,GAAL,CAASshB,UAAU,CAAC,CAAD,CAAnB,EAAwB2H,eAAxB,CAAT,EAAmDC,sBAAnD,CAAhB;AACA,aAAKvK,cAAL,GAAsB2C,UAAtB;;AAEA,aAAK,IAAI5qB,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAGupB,OAAO,CAACvtB,MAA5B,EAAoCgE,EAAC,EAArC,EAAyC;AACrCupB,iBAAO,CAACvpB,EAAD,CAAP,IAAc,KAAKioB,cAAL,CAAoBjoB,EAAC,GAAG,CAAxB,CAAd;AACH;AACJ;;AAED,sNAA2BupB,OAA3B,EAAoCX,IAApC;AACH;AAvFL;AAAA;AAAA,iCAyFwC;AAChC,UAAI/a,MAAM,GAAG,KAAKib,QAAL,CAAc,KAAKC,IAAnB,CAAb;;AACA,UAAIV,SAAJ;;AAEA,aAAO,CAACA,SAAR,EAAmB;AACfA,iBAAS,GAAG,KAAKY,YAAL,CAAkBrB,aAAlB,EAAiC/Z,MAAjC,EAAyC,CAAzC,EAA4C,IAA5C,CAAZ;;AACA,YAAI,CAACwa,SAAL,EAAgB;AACZ,iBAAO,IAAP;AACH;;AAED,YAAMW,cAAc,GAAIX,SAAS,CAACtP,GAAV,GAAgBsP,SAAS,CAAC7Z,KAA3B,IAAqC,CAA5D;AACA,YAAM0a,sBAAsB,GAAGb,SAAS,CAAC7Z,KAAV,GAAkBwa,cAAc,GAAG,EAAlE;;AAEA,YAAIE,sBAAsB,IAAI,CAA9B,EAAiC;AAC7B,cAAI,KAAKC,WAAL,CAAiBD,sBAAjB,EAAyCb,SAAS,CAAC7Z,KAAnD,EAA0D,CAA1D,CAAJ,EAAkE;AAC9D,mBAAO6Z,SAAP;AACH;AACJ;;AAEDxa,cAAM,GAAGwa,SAAS,CAACtP,GAAnB;AACAsP,iBAAS,GAAG,IAAZ;AACH;;AAED,aAAO,IAAP;AACH;AAjHL;AAAA;AAAA,8CAmHwCE,OAnHxC,EAmH2E;AACnE,UAAMa,qBAAqB,GAAGb,OAAO,CAACxP,GAAR,GAAc,CAACwP,OAAO,CAACxP,GAAR,GAAcwP,OAAO,CAAC/Z,KAAvB,IAAgC,CAA5E;;AAEA,UAAI4a,qBAAqB,GAAG,KAAKL,IAAL,CAAU/sB,MAAtC,EAA8C;AAC1C,YAAI,KAAKmtB,WAAL,CAAiBZ,OAAO,CAACxP,GAAzB,EAA8BqQ,qBAA9B,EAAqD,CAArD,CAAJ,EAA6D;AACzD,iBAAOb,OAAP;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AA7HL;AAAA;AAAA,+BA+HsC;AAC9B,WAAKQ,IAAL,CAAUM,OAAV;;AAEA,UAAMd,OAAO,GAAG,KAAKU,YAAL,CAAkBpB,YAAlB,EAAgCrY,SAAhC,EAA2C,CAA3C,EAA8C,KAA9C,CAAhB;;AAEA,WAAKuZ,IAAL,CAAUM,OAAV;;AAEA,UAAId,OAAO,KAAK,IAAhB,EAAsB;AAClB,eAAO,IAAP;AACH,OAT6B,CAW9B;;;AACA,UAAM/Z,KAAK,GAAG+Z,OAAO,CAAC/Z,KAAtB;AACA+Z,aAAO,CAAC/Z,KAAR,GAAgB,KAAKua,IAAL,CAAU/sB,MAAV,GAAmBusB,OAAO,CAACxP,GAA3C;AACAwP,aAAO,CAACxP,GAAR,GAAc,KAAKgQ,IAAL,CAAU/sB,MAAV,GAAmBwS,KAAjC;AAEA,aAAO+Z,OAAO,KAAK,IAAZ,GAAmB,KAAKe,yBAAL,CAA+Bf,OAA/B,CAAnB,GAA6D,IAApE;AACH;AAhJL;AAAA;AAAA,gCAkJ0BgB,OAlJ1B,EAkJ+D;AACvD,UAAMC,SAAsB,GAAG;AAC3B5f,aAAK,EAAEqU,MAAM,CAACC,SADa;AAE3B0K,YAAI,EAAE,CAAC,CAFoB;AAG3Bpa,aAAK,EAAE,CAHoB;AAI3BuK,WAAG,EAAE;AAJsB,OAA/B;;AAOA,WAAK,IAAI6P,IAAI,GAAG,CAAhB,EAAmBA,IAAI,GAAGd,YAAY,CAAC9rB,MAAvC,EAA+C4sB,IAAI,EAAnD,EAAuD;AACnD,YAAMhf,KAAK,GAAG,KAAK6f,aAAL,CAAmBF,OAAnB,EAA4BzB,YAAY,CAACc,IAAD,CAAxC,CAAd;;AACA,YAAIhf,KAAK,GAAG4f,SAAS,CAAC5f,KAAtB,EAA6B;AACzB4f,mBAAS,CAACZ,IAAV,GAAiBA,IAAjB;AACAY,mBAAS,CAAC5f,KAAV,GAAkBA,KAAlB;AACH;AACJ;;AAED,aAAO4f,SAAS,CAAC5f,KAAV,GAAkB,KAAK8f,kBAAvB,GAA4CF,SAA5C,GAAwD,IAA/D;AACH;AAnKL;AAAA;AAAA,mCAqK6Bf,QArK7B,EAqK8D9uB,MArK9D,EAqKqFgvB,YArKrF,EAqKmJ;AAC3I,UAAMgB,aAAa,GAAGlB,QAAQ,CAACzsB,MAA/B;AACA,UAAMy2B,QAAQ,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,CAAjB;AACA,UAAMC,QAAQ,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,CAAjB;AACA,UAAIC,KAAJ;AACA,UAAIC,KAAJ;AACA,UAAIxoB,GAAG,GAAG,CAAV;;AAEA,aAAOA,GAAG,GAAGuf,aAAb,EAA4B;AACxB,aAAK,IAAI3pB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AACxByyB,kBAAQ,CAACzyB,CAAD,CAAR,GAAcyoB,QAAQ,CAACre,GAAD,CAAR,GAAgB,KAAK6d,cAAL,CAAoB,CAApB,CAA9B;AACAyK,kBAAQ,CAAC1yB,CAAD,CAAR,GAAcyoB,QAAQ,CAACre,GAAG,GAAG,CAAP,CAAR,GAAoB,KAAK6d,cAAL,CAAoB,CAApB,CAAlC;AACA7d,aAAG,IAAI,CAAP;AACH;;AAEDuoB,aAAK,GAAG,KAAK/I,WAAL,CAAiB6I,QAAjB,CAAR;;AACA,YAAI,CAACE,KAAL,EAAY;AACR,iBAAO,IAAP;AACH;;AAEDC,aAAK,GAAG,KAAKhJ,WAAL,CAAiB8I,QAAjB,CAAR;;AACA,YAAI,CAACE,KAAL,EAAY;AACR,iBAAO,IAAP;AACH;;AAEDj5B,cAAM,CAACO,IAAP,CAAYy4B,KAAK,CAAC/J,IAAlB,EAAwBgK,KAAK,CAAChK,IAA9B;AACAD,oBAAY,CAACzuB,IAAb,CAAkBy4B,KAAlB,EAAyBC,KAAzB;AACH;;AAED,aAAO,CAACD,KAAD,EAAQC,KAAR,CAAP;AACH;AAnML;;AAAA;AAAA,EAAiC/I,6DAAjC,E;;;;;;;;;;;;ACrBA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEO,IAAMviB,OAAO,GAAG;AACnBurB,iBAAe,EAAE7E,8DADE;AAEnB8E,YAAU,EAAE5B,qDAFO;AAGnB6B,cAAY,EAAE5B,wDAHK;AAInB6B,cAAY,EAAEnC,wDAJK;AAKnBoC,cAAY,EAAE1B,wDALK;AAMnB2B,gBAAc,EAAElE,4DANG;AAOnBmE,oBAAkB,EAAEvD,mEAPD;AAQnBwD,gBAAc,EAAE3H,6DARG;AASnB4H,YAAU,EAAEC,qDATO;AAUnBC,cAAY,EAAEC,wDAVK;AAWnBC,cAAY,EAAEtB,0DAXK;AAYnB,iBAAenK,6DAZI;AAanB0L,gBAAc,EAAE3D,6DAAYA;AAbT,CAAhB,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACbP;AAEA,IAAM2B,cAAc,GAAG,CAAC,CAAC,EAAD,EAAK,EAAL,EAAS,EAAT,EAAa,EAAb,EAAiB,EAAjB,EAAqB,EAArB,EAAyB,EAAzB,EAA6B,EAA7B,EAAiC,EAAjC,EAAqC,EAArC,CAAD,EAA2C,CAAC,CAAD,EAAI,EAAJ,EAAQ,EAAR,EAAY,EAAZ,EAAgB,EAAhB,EAAoB,EAApB,EAAwB,EAAxB,EAA4B,EAA5B,EAAgC,EAAhC,EAAoC,EAApC,CAA3C,CAAvB;AAEO,IAAM8B,UAAb;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,wBACuB;AACf,aAAO,CAAC,IAAI,CAAJ,GAAQ,CAAT,EAAY,IAAI,CAAJ,GAAQ,CAApB,EAAuB,IAAI,CAAJ,GAAQ,CAA/B,EAAkC,IAAI,CAAJ,GAAQ,CAA1C,EAA6C,IAAI,CAAJ,GAAQ,CAArD,EAAwD,IAAI,CAAJ,GAAQ,CAAhE,CAAP;AACH;AAHL;;AAKI,sBAAYh7B,MAAZ,EAA0CyO,WAA1C,EAA8E;AAAA;;AAAA;;AAC1E,8MAAMzO,MAAN,EAAcyO,WAAd;AAEA,UAAKihB,OAAL,GAAe,OAAf;AAH0E;AAI7E;;AATL;AAAA;AAAA,mCAW6BU,IAX7B,EAWgDjvB,MAXhD,EAWuEgvB,YAXvE,EAWsH;AAC9G,UAAIoI,aAAa,GAAG,GAApB;;AAEA,WAAK,IAAI/wB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AACxB4oB,YAAI,GAAG,KAAKgB,WAAL,CAAiBhB,IAAI,CAAC7P,GAAtB,CAAP;;AACA,YAAI,CAAC6P,IAAL,EAAW;AACP,iBAAO,IAAP;AACH;;AACD,YAAIA,IAAI,CAACA,IAAL,IAAa,KAAKoI,YAAtB,EAAoC;AAChCpI,cAAI,CAACA,IAAL,GAAYA,IAAI,CAACA,IAAL,GAAY,KAAKoI,YAA7B;AACAD,uBAAa,IAAI,KAAM,IAAI/wB,CAA3B;AACH;;AACDrG,cAAM,CAACO,IAAP,CAAY0uB,IAAI,CAACA,IAAjB;AACAD,oBAAY,CAACzuB,IAAb,CAAkB0uB,IAAlB;AACH;;AAED,UAAI,CAAC,KAAK+K,gBAAL,CAAsB5C,aAAtB,EAAqCp3B,MAArC,CAAL,EAAmD;AAC/C,eAAO,IAAP;AACH;;AAED,aAAOivB,IAAP;AACH;AAhCL;AAAA;AAAA,qCAkC6BmI,aAlC7B,EAkCoDp3B,MAlCpD,EAkCoF;AAC5E,WAAK,IAAIi6B,QAAQ,GAAG,CAApB,EAAuBA,QAAQ,GAAGlC,cAAc,CAAC11B,MAAjD,EAAyD43B,QAAQ,EAAjE,EAAqE;AACjE,aAAK,IAAI5zB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG0xB,cAAc,CAACkC,QAAD,CAAd,CAAyB53B,MAA7C,EAAqDgE,CAAC,EAAtD,EAA0D;AACtD,cAAI+wB,aAAa,KAAKW,cAAc,CAACkC,QAAD,CAAd,CAAyB5zB,CAAzB,CAAtB,EAAmD;AAC/CrG,kBAAM,CAAC2a,OAAP,CAAesf,QAAf;AACAj6B,kBAAM,CAACO,IAAP,CAAY8F,CAAZ;AACA,mBAAO,IAAP;AACH;AACJ;AACJ;;AACD,aAAO,KAAP;AACH;AA7CL;AAAA;AAAA,mCA+C2BrG,MA/C3B,EA+CiE;AACzD,UAAMk6B,SAAS,GAAGl6B,MAAM,CAACA,MAAM,CAACqC,MAAP,GAAgB,CAAjB,CAAxB;AACA,UAAI83B,IAAI,GAAG,CAACn6B,MAAM,CAAC,CAAD,CAAP,CAAX;;AAEA,UAAIk6B,SAAS,IAAI,CAAjB,EAAoB;AAChBC,YAAI,GAAGA,IAAI,CAACvf,MAAL,CAAY5a,MAAM,CAAC8E,KAAP,CAAa,CAAb,EAAgB,CAAhB,CAAZ,EAAgC8V,MAAhC,CAAuC,CAACsf,SAAD,EAAY,CAAZ,EAAe,CAAf,EAAkB,CAAlB,EAAqB,CAArB,CAAvC,EAAgEtf,MAAhE,CAAuE5a,MAAM,CAAC8E,KAAP,CAAa,CAAb,EAAgB,CAAhB,CAAvE,CAAP;AACH,OAFD,MAEO,IAAIo1B,SAAS,KAAK,CAAlB,EAAqB;AACxBC,YAAI,GAAGA,IAAI,CAACvf,MAAL,CAAY5a,MAAM,CAAC8E,KAAP,CAAa,CAAb,EAAgB,CAAhB,CAAZ,EAAgC8V,MAAhC,CAAuC,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,CAAvC,EAAwDA,MAAxD,CAA+D5a,MAAM,CAAC8E,KAAP,CAAa,CAAb,EAAgB,CAAhB,CAA/D,CAAP;AACH,OAFM,MAEA,IAAIo1B,SAAS,KAAK,CAAlB,EAAqB;AACxBC,YAAI,GAAGA,IAAI,CAACvf,MAAL,CAAY5a,MAAM,CAAC8E,KAAP,CAAa,CAAb,EAAgB,CAAhB,CAAZ,EAAgC8V,MAAhC,CAAuC,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb,EAAgB5a,MAAM,CAAC,CAAD,CAAtB,CAAvC,CAAP;AACH,OAFM,MAEA;AACHm6B,YAAI,GAAGA,IAAI,CAACvf,MAAL,CAAY5a,MAAM,CAAC8E,KAAP,CAAa,CAAb,EAAgB,CAAhB,CAAZ,EAAgC8V,MAAhC,CAAuC,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,EAAasf,SAAb,CAAvC,CAAP;AACH;;AAEDC,UAAI,CAAC55B,IAAL,CAAUP,MAAM,CAACA,MAAM,CAACqC,MAAP,GAAgB,CAAjB,CAAhB;AACA,aAAO83B,IAAP;AACH;AA/DL;AAAA;AAAA,8BAiEwBn6B,MAjExB,EAiEwD;AAChD,iNAAuB,KAAKo6B,cAAL,CAAoBp6B,MAApB,CAAvB;AACH;AAnEL;AAAA;AAAA,6BAqEuBkU,MArEvB,EAqEuCqc,OArEvC,EAqEuD;AAC/CA,aAAO,GAAG,CAAV;AACA,gNAAsBrc,MAAtB,EAA8Bqc,OAA9B;AACH;AAxEL;AAAA;AAAA,8CA0EwC3B,OA1ExC,EA0E2E;AACnE,UAAMa,qBAAqB,GAAGb,OAAO,CAACxP,GAAR,GAAc,CAACwP,OAAO,CAACxP,GAAR,GAAcwP,OAAO,CAAC/Z,KAAvB,IAAgC,CAA5E;;AAEA,UAAI4a,qBAAqB,GAAG,KAAKL,IAAL,CAAU/sB,MAAtC,EAA8C;AAC1C,YAAI,KAAKmtB,WAAL,CAAiBZ,OAAO,CAACxP,GAAzB,EAA8BqQ,qBAA9B,EAAqD,CAArD,CAAJ,EAA6D;AACzD,iBAAOb,OAAP;AACH;AACJ;;AAED,aAAO,IAAP;AACH;AApFL;;AAAA;AAAA,EAAgC2I,qDAAhC,E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACJA;AAEO,IAAMoC,SAAb;AAAA;AAAA;AAAA;;AACI,qBAAY96B,MAAZ,EAA0CyO,WAA1C,EAA8E;AAAA;;AAAA;;AAC1E,6MAAMzO,MAAN,EAAcyO,WAAd;AAEA,UAAKihB,OAAL,GAAe,OAAf;AAH0E;AAI7E;;AALL;AAAA;AAAA,6BAOsB;AACd,UAAMvuB,MAAM,GAAG,+LAAf;;AAEA,UAAIA,MAAM,IAAIA,MAAM,CAACivB,IAAjB,IAAyBjvB,MAAM,CAACivB,IAAP,CAAY5sB,MAAZ,KAAuB,EAAhD,IAAsDrC,MAAM,CAACivB,IAAP,CAAYoL,MAAZ,CAAmB,CAAnB,MAA0B,GAApF,EAAyF;AACrFr6B,cAAM,CAACivB,IAAP,GAAcjvB,MAAM,CAACivB,IAAP,CAAYqL,SAAZ,CAAsB,CAAtB,CAAd;AACA,eAAOt6B,MAAP;AACH;;AAED,aAAO,IAAP;AACH;AAhBL;;AAAA;AAAA,EAA+Bu3B,qDAA/B,E","file":"quagga.js","sourcesContent":["\n(function webpackUniversalModuleDefinition(root, factory) {\n    if (typeof exports === 'object' && typeof module === 'object') {\n        module.exports = factory(factory.toString()).default;\n    } else if (typeof exports === 'object') {\n        exports[\"Quagga\"] = factory(factory.toString()).default;\n    } else {\n        root[\"Quagga\"] = factory(factory.toString()).default;\n    }\n})(this, function(__factorySource__) {\n    return "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./src/quagga.ts\");\n","function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  }\n}\n\nmodule.exports = _arrayWithoutHoles;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nmodule.exports = _classCallCheck;","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nmodule.exports = _createClass;","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;","var getPrototypeOf = require(\"./getPrototypeOf\");\n\nvar superPropBase = require(\"./superPropBase\");\n\nfunction _get(target, property, receiver) {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    module.exports = _get = Reflect.get;\n  } else {\n    module.exports = _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n\n      if (desc.get) {\n        return desc.get.call(receiver);\n      }\n\n      return desc.value;\n    };\n  }\n\n  return _get(target, property, receiver || target);\n}\n\nmodule.exports = _get;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf;","var setPrototypeOf = require(\"./setPrototypeOf\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits;","function _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nmodule.exports = _nonIterableSpread;","var _typeof = require(\"../helpers/typeof\");\n\nvar assertThisInitialized = require(\"./assertThisInitialized\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nmodule.exports = _setPrototypeOf;","var getPrototypeOf = require(\"./getPrototypeOf\");\n\nfunction _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n\n  return object;\n}\n\nmodule.exports = _superPropBase;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","function _typeof2(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof2(obj); }\n\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && _typeof2(Symbol.iterator) === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return _typeof2(obj);\n    };\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : _typeof2(obj);\n    };\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;","module.exports = require(\"regenerator-runtime\");\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n// This method of obtaining a reference to the global object needs to be\n// kept identical to the way it is obtained in runtime.js\nvar g = (function() {\n  return this || (typeof self === \"object\" && self);\n})() || Function(\"return this\")();\n\n// Use `getOwnPropertyNames` because not all browsers support calling\n// `hasOwnProperty` on the global `self` object in a worker. See #183.\nvar hadRuntime = g.regeneratorRuntime &&\n  Object.getOwnPropertyNames(g).indexOf(\"regeneratorRuntime\") >= 0;\n\n// Save the old regeneratorRuntime in case it needs to be restored later.\nvar oldRuntime = hadRuntime && g.regeneratorRuntime;\n\n// Force reevalutation of runtime.js.\ng.regeneratorRuntime = undefined;\n\nmodule.exports = require(\"./runtime\");\n\nif (hadRuntime) {\n  // Restore the original runtime.\n  g.regeneratorRuntime = oldRuntime;\n} else {\n  // Remove the global property added by runtime.js.\n  try {\n    delete g.regeneratorRuntime;\n  } catch(e) {\n    g.regeneratorRuntime = undefined;\n  }\n}\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n!(function(global) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  var inModule = typeof module === \"object\";\n  var runtime = global.regeneratorRuntime;\n  if (runtime) {\n    if (inModule) {\n      // If regeneratorRuntime is defined globally and we're in a module,\n      // make the exports object identical to regeneratorRuntime.\n      module.exports = runtime;\n    }\n    // Don't bother evaluating the rest of this file if the runtime was\n    // already defined globally.\n    return;\n  }\n\n  // Define the runtime globally (as expected by generated code) as either\n  // module.exports (if we're in a module) or a new, empty object.\n  runtime = global.regeneratorRuntime = inModule ? module.exports : {};\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  runtime.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  runtime.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  runtime.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  runtime.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return Promise.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return Promise.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  runtime.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return runtime.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        if (delegate.iterator.return) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  runtime.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  runtime.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n})(\n  // In sloppy mode, unbound `this` refers to the global object, fallback to\n  // Function constructor if we're in global strict mode. That is sadly a form\n  // of indirect eval which violates Content Security Policy.\n  (function() {\n    return this || (typeof self === \"object\" && self);\n  })() || Function(\"return this\")()\n);\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","import { ImageDebug } from '../common/image-debug';\nimport { QuaggaBarcode } from '../decoder/barcode-decoder';\nimport { Barcode } from '../reader/barcode-reader';\n\nexport interface ResultCollectorConfig {\n    capacity?: number;\n    capture?: boolean;\n    blacklist?: Array<Barcode>;\n    filter?: (item: Barcode) => boolean;\n}\n\nexport class ResultCollector {\n    private _canvas: HTMLCanvasElement;\n    private _context: CanvasRenderingContext2D;\n    private _config: ResultCollectorConfig;\n    private _capacity: number;\n    private _capture: boolean;\n    private _results: Array<QuaggaBarcode>;\n\n    constructor(config: ResultCollectorConfig) {\n        this._results = new Array<QuaggaBarcode>();\n        this._config = config;\n        this._capacity = config.capacity || 20;\n        this._capture = config.capture === true;\n\n        if (this._capture) {\n            this._canvas = document.createElement('canvas');\n            this._context = this._canvas.getContext('2d');\n        }\n    }\n\n    addResult(data: Uint8Array, imageWidth: number, imageHeight: number, codeResult: Barcode): void {\n        if (codeResult && this._capacity && !this._contains(codeResult) && this._passesFilter(codeResult)) {\n            const result: QuaggaBarcode = { codeResult };\n\n            this._capacity--;\n\n            if (this._capture) {\n                this._canvas.width = imageWidth;\n                this._canvas.height = imageHeight;\n\n                ImageDebug.drawImage(data, imageWidth, imageHeight, this._context);\n\n                result.frame = this._canvas.toDataURL();\n            }\n\n            this._results.push(result);\n        }\n    }\n\n    getResults(): Array<QuaggaBarcode> {\n        return this._results;\n    }\n\n    private _contains(codeResult: Barcode): boolean {\n        return this._config.blacklist &&\n            this._config.blacklist.some(item => Object.keys(item).every(key => item[key] === codeResult[key]));\n    }\n\n    private _passesFilter(codeResult: Barcode): boolean {\n        return typeof this._config.filter !== 'function' || this._config.filter(codeResult);\n    }\n}\n","import { Moment } from './moment';\n\n\n/**\n * Creates a cluster for grouping similar orientations of moments\n */\nexport class Cluster {\n    private _threshold: number;\n    private _moments: Array<Moment>;\n    private _center: Moment;\n\n    static clusterize(moments: Array<Moment>, threshold: number): Array<Cluster> {\n        const clusters = new Array<Cluster>();\n\n        moments.forEach(moment => {\n            const matchingCluster = clusters.find(cluster => cluster.fits(moment));\n\n            if (matchingCluster) {\n                matchingCluster.add(moment);\n            } else {\n                clusters.push(new Cluster(threshold, moment));\n            }\n        });\n\n        return clusters;\n    }\n\n    constructor(threshold: number, moment: Moment) {\n        this._threshold = threshold;\n        this._moments = new Array<Moment>();\n        this._center = {\n            rad: 0,\n            x: 0,\n            y: 0\n        };\n\n        if (moment) {\n            this.add(moment);\n        }\n    }\n\n    add(point: Moment) {\n        this._moments.push(point);\n\n        // Update center\n        this._center.rad = this._moments.reduce((sum, p) => sum + p.rad, 0) / this._moments.length;\n        this._center.x = Math.cos(this._center.rad);\n        this._center.y = Math.sin(this._center.rad);\n    }\n\n    fits(moment: Moment): boolean {\n        // check cosine similarity to center-angle\n        const similarity = Math.abs(moment.x * this._center.x + moment.y * this._center.y);\n        return similarity > this._threshold;\n    }\n\n    get moments() {\n        return this._moments;\n    }\n}\n","export interface EventCallback {\n    (data: any): void;\n}\n\nexport interface EventSubscription {\n    callback: EventCallback;\n    async?: boolean;\n    once?: boolean;\n}\n\ninterface EventItem {\n    subscriptions: Array<EventSubscription>\n}\n\nlet events: { [name: string]: EventItem } = {};\n\nexport class Events {\n    static subscribe(event: string, callback: EventSubscription | EventCallback, async?: boolean) {\n        let subscription: EventSubscription;\n\n        if (typeof callback === 'function') {\n            subscription = {\n                callback,\n                async\n            };\n        } else {\n            subscription = callback;\n            if (!subscription.callback) {\n                throw 'Callback was not specified on options';\n            }\n        }\n\n        getEvent(event).subscriptions.push(subscription);\n    }\n\n    static publish(type: string, data?: any) {\n        const eventItem = getEvent(type);\n        const subscriptions = eventItem.subscriptions;\n\n        // Publish one-time subscriptions\n        subscriptions.filter(({ once }) => !!once).forEach(subscription => publishSubscription(subscription, data));\n\n        // remove them from the subscription\n        eventItem.subscriptions = subscriptions.filter(({ once }) => !once);\n\n        // publish the rest\n        eventItem.subscriptions.forEach(subscription => publishSubscription(subscription, data));\n    }\n\n    static once(event: string, callback: EventCallback, async?: boolean): void {\n        Events.subscribe(event, { callback, async, once: true });\n    }\n\n    static unsubscribe(eventName?: string, callback?: EventCallback) {\n        if (eventName) {\n            const event = getEvent(eventName);\n            if (event && callback) {\n                event.subscriptions = event.subscriptions.filter(subscription => subscription.callback !== callback);\n            } else {\n                event.subscriptions = [];\n            }\n        } else {\n            events = {};\n        }\n    }\n}\n\nfunction getEvent(eventName: string): EventItem {\n    if (!events[eventName]) {\n        events[eventName] = {\n            subscriptions: []\n        };\n    }\n    return events[eventName];\n}\n\nfunction publishSubscription(subscription: EventSubscription, data: any): void {\n    if (subscription.async) {\n        setTimeout(function () {\n            subscription.callback(data);\n        }, 4);\n    } else {\n        subscription.callback(data);\n    }\n}\n","export type HSV = [number, number, number];\n\nexport type RGB = [number, number, number];\n\nexport function hsv2rgb(hsv: HSV, rgb?: RGB): RGB {\n    const h = hsv[0];\n    const s = hsv[1];\n    const v = hsv[2];\n    const c = v * s;\n    const x = c * (1 - Math.abs((h / 60) % 2 - 1));\n    const m = v - c;\n    let r = 0;\n    let g = 0;\n    let b = 0;\n\n    if (h < 60) {\n        r = c;\n        g = x;\n    } else if (h < 120) {\n        r = x;\n        g = c;\n    } else if (h < 180) {\n        g = c;\n        b = x;\n    } else if (h < 240) {\n        g = x;\n        b = c;\n    } else if (h < 300) {\n        r = x;\n        b = c;\n    } else if (h < 360) {\n        r = c;\n        b = x;\n    }\n\n    rgb = rgb || [0, 0, 0];\n\n    rgb[0] = (r + m) * 255 | 0;\n    rgb[1] = (g + m) * 255 | 0;\n    rgb[2] = (b + m) * 255 | 0;\n\n    return rgb;\n}\n","import { Point } from './point';\n\nexport const ImageDebug = {\n    drawPath(path: Array<Point>, context: CanvasRenderingContext2D, color: string, lineWidth: number): void {\n        if (path && path.length > 1) {\n            context.strokeStyle = color;\n            context.fillStyle = color;\n            context.lineWidth = lineWidth;\n            context.beginPath();\n            context.moveTo(path[0].x, path[0].y);\n            path.slice(1).forEach(({ x, y }) => context.lineTo(x, y));\n            context.closePath();\n            context.stroke();\n        }\n    },\n\n    drawImage(imageData: Uint8Array, width: number, height: number, context: CanvasRenderingContext2D): boolean {\n        const canvasData = context.getImageData(0, 0, width, height);\n        const data = canvasData.data;\n        let imageIndex = imageData.length | 0;\n        let canvasIndex = data.length | 0;\n\n        if (canvasIndex / imageIndex !== 4) {\n            return false;\n        }\n\n        while (imageIndex--) {\n            const value = imageData[imageIndex];\n            data[--canvasIndex] = 255;\n            data[--canvasIndex] = value;\n            data[--canvasIndex] = value;\n            data[--canvasIndex] = value;\n        }\n\n        context.putImageData(canvasData, 0, 0);\n\n        return true;\n    }\n}\n","import { Moment } from './moment';\nimport { Point } from './point';\nimport { HSV, hsv2rgb, RGB } from './hsv2rgb';\n\ntype ArrayType = Array<number> | Uint8Array | Int32Array;\n\n/**\n * Represents a basic image combining the data and size.\n * In addition, some methods for manipulation are contained.\n */\nexport class ImageWrapper<T extends ArrayType = Uint8Array> {\n    data: T | Uint8Array;\n    size: Point;\n\n    /**\n     * @param size The size of the image in pixel\n     * @param data If given, a flat array containing the pixel data\n     * @param arrayType If given, the desired DataType of the Array (may be typed/non-typed)\n     * @param initialize Indicating if the array should be initialized on creation.\n     */\n    constructor(size: Point, data?: T, arrayType?: { new(_: number): T | Uint8Array }, initialize?: boolean) {\n        if (!data) {\n            this.data = new (arrayType || Uint8Array)(size.x * size.y);\n\n            if (initialize) {\n                this.data.fill(0);\n            }\n        } else {\n            this.data = data;\n        }\n\n        this.size = size;\n    }\n\n    /**\n     * Tests if a position is within the image with a given offset\n     * @param point The location to test\n     * @param border The padding value in pixels\n     * @returns true if location inside the image's border, false otherwise\n     * @see cvd/image.h\n     */\n    inImageWithBorder(point: Point, border: number): boolean {\n        return (point.x >= border)\n            && (point.y >= border)\n            && (point.x < (this.size.x - border))\n            && (point.y < (this.size.y - border));\n    }\n\n    /**\n     * Creates an {ImageWrapper) and copies the needed underlying image-data area\n     * @param imageWrapper The target {ImageWrapper} where the data should be copied\n     * @param fromX The horizontal position where to copy from\n     * @param fromY The vertical position where to copy from\n    */\n    subImageAsCopy(imageWrapper: ImageWrapper, fromX: number, fromY: number): void {\n        const sizeY = imageWrapper.size.y;\n        const sizeX = imageWrapper.size.x;\n\n        for (let x = 0; x < sizeX; x++) {\n            for (let y = 0; y < sizeY; y++) {\n                imageWrapper.data[y * sizeX + x] = this.data[(fromY + y) * this.size.x + fromX + x];\n            }\n        }\n    }\n\n    /**\n     * Retrieves a given pixel position from the image\n     * @param x The x-position\n     * @param y The y-position\n     * @returns The grayscale value at the pixel-position\n     */\n    get(x: number, y: number): number {\n        return this.data[y * this.size.x + x];\n    }\n\n    /**\n     * Sets a given pixel position in the image\n     * @param x The x-position\n     * @param y The y-position\n     * @param value The grayscale value to set\n     * @returns The Image itself (for possible chaining)\n     */\n    set(x: number, y: number, value: number): ImageWrapper<T> {\n        this.data[y * this.size.x + x] = value;\n        return this;\n    }\n\n    /**\n     * Sets the border of the image (1 pixel) to zero\n     */\n    zeroBorder(): void {\n        const width = this.size.x;\n        const height = this.size.y;\n        const data = this.data;\n\n        for (let i = 0; i < width; i++) {\n            data[i] = data[(height - 1) * width + i] = 0;\n        }\n\n        for (let i = 1; i < height - 1; i++) {\n            data[i * width] = data[i * width + (width - 1)] = 0;\n        }\n    }\n\n    /**\n     * Inverts a binary image in place\n     */\n    invert(): void {\n        const data = this.data;\n\n        for (let i = data.length; i--;) {\n            data[i] = data[i] ? 0 : 1;\n        }\n    }\n\n    moments(labelCount: number): Array<Moment> {\n        const height = this.size.y;\n        const width = this.size.x;\n        const labelSum = new Array<Moment>();\n        const result = new Array<Moment>();\n\n        if (labelCount <= 0) {\n            return result;\n        }\n\n        for (let i = 0; i < labelCount; i++) {\n            labelSum[i] = {\n                m00: 0,\n                m01: 0,\n                m10: 0,\n                m11: 0,\n                m02: 0,\n                m20: 0,\n                theta: 0,\n                rad: 0\n            };\n        }\n\n        for (let y = 0; y < height; y++) {\n            const ysq = y * y;\n            for (let x = 0; x < width; x++) {\n                const val = this.data[y * width + x];\n                if (val > 0) {\n                    const label = labelSum[val - 1];\n                    label.m00 += 1;\n                    label.m01 += y;\n                    label.m10 += x;\n                    label.m11 += x * y;\n                    label.m02 += ysq;\n                    label.m20 += x * x;\n                }\n            }\n        }\n\n        const PI = Math.PI;\n        const PI_4 = PI / 4;\n\n        for (let i = 0; i < labelCount; i++) {\n            const label = labelSum[i];\n            if (!isNaN(label.m00) && label.m00 !== 0) {\n                const x_ = label.m10 / label.m00;\n                const y_ = label.m01 / label.m00;\n                const mu11 = label.m11 / label.m00 - x_ * y_;\n                const mu02 = label.m02 / label.m00 - y_ * y_;\n                const mu20 = label.m20 / label.m00 - x_ * x_;\n                const tmp = 0.5 * Math.atan((mu02 - mu20) / (2 * mu11)) + (mu11 >= 0 ? PI_4 : -PI_4) + PI;\n                label.theta = (tmp * 180 / PI + 90) % 180 - 90;\n                if (label.theta < 0) {\n                    label.theta += 180;\n                }\n                label.rad = tmp > PI ? tmp - PI : tmp;\n                label.x = Math.cos(tmp);\n                label.y = Math.sin(tmp);\n                result.push(label);\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * Displays the {ImageWrapper} in a given canvas\n     * @param context The rendering context to write to\n     * @param scale Scale which is applied to each pixel-value\n     */\n    show(context: CanvasRenderingContext2D, scale: number): void {\n        const height = this.size.y;\n        const width = this.size.x;\n        // const context = canvas.getContext('2d');\n        // canvas.height = height;\n        // canvas.width = width;\n        const frame = context.getImageData(0, 0, width, height);\n        const data = frame.data;\n        let current = 0;\n\n        if (!scale) {\n            scale = 1.0;\n        }\n\n        for (let y = 0; y < height; y++) {\n            for (let x = 0; x < width; x++) {\n                const pixel = y * width + x;\n                current = this.get(x, y) * scale;\n                data[pixel * 4 + 0] = current;\n                data[pixel * 4 + 1] = current;\n                data[pixel * 4 + 2] = current;\n                data[pixel * 4 + 3] = 255;\n            }\n        }\n\n        //frame.data = data;\n        context.putImageData(frame, 0, 0);\n    }\n\n    /**\n     * Displays the part of the image in a given canvas\n     * @param context The rendering context to write to\n     * @param scale Scale which is applied to each pixel-value\n     * @param fromX The horizontal position where to overlay from\n     * @param fromY The vertical position where to overlay from\n     */\n    overlay(context: CanvasRenderingContext2D, scale: number, fromX: number, fromY: number): void {\n        const hsv: HSV = [0, 1, 1];\n        const whiteRgb: RGB = [255, 255, 255];\n        const blackRgb: RGB = [0, 0, 0];\n        const frame = context.getImageData(fromX, fromY, this.size.x, this.size.y);\n        const data = frame.data;\n\n        if (!scale || scale < 0 || scale > 360) {\n            scale = 360;\n        }\n\n        for (let length = this.data.length; length--;) {\n            hsv[0] = this.data[length] * scale;\n            const rgb: RGB = hsv[0] <= 0 ? whiteRgb : hsv[0] >= 360 ? blackRgb : hsv2rgb(hsv);\n            data[length * 4 + 0] = rgb[0];\n            data[length * 4 + 1] = rgb[1];\n            data[length * 4 + 2] = rgb[2];\n            data[length * 4 + 3] = 255;\n        }\n\n        context.putImageData(frame, fromX, fromY);\n    }\n}\n","\nexport function enumerateDevices(): Promise<Array<MediaDeviceInfo>> {\n    if (navigator.mediaDevices && typeof navigator.mediaDevices.enumerateDevices === 'function') {\n        return navigator.mediaDevices.enumerateDevices();\n    }\n    return Promise.reject(new Error('enumerateDevices is not defined'));\n}\n\nexport function getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream> {\n    if (navigator.mediaDevices && typeof navigator.mediaDevices.getUserMedia === 'function') {\n        return navigator.mediaDevices.getUserMedia(constraints);\n    }\n    return Promise.reject(new Error('getUserMedia is not defined'));\n}\n","/**\n * Performs a deep merge of objects and returns new object.\n * Does not modify objects (immutable).\n * @see https://stackoverflow.com/a/48218209\n *\n * @param objects - Objects to merge\n * @returns New object with merged key/values\n */\nexport function merge(...objects: ReadonlyArray<any>): object {\n    const isObject = (obj: unknown) => obj && typeof obj === 'object';\n\n    return objects.reduce((prev, obj) => {\n        if (obj) {\n            Object.keys(obj).forEach(key => {\n                const pVal = prev[key];\n                const oVal = obj[key];\n\n                if (Array.isArray(pVal) && Array.isArray(oVal)) {\n                    // prev[key] = pVal.concat(...oVal);\n                    prev[key] = oVal;\n                } else if (isObject(pVal) && isObject(oVal)) {\n                    prev[key] = merge(pVal, oVal);\n                } else {\n                    prev[key] = oVal;\n                }\n            });\n        }\n\n        return prev;\n    }, {});\n}","import { QuaggaConfig } from './config';\n\nexport const config: QuaggaConfig = {\n    inputStream: {\n        name: 'Live',\n        type: 'LiveStream',\n        constraints: {\n            width: 640,\n            height: 480,\n            // aspectRatio: 640/480, // optional\n            facingMode: 'environment' // or user\n            // deviceId: '38745983457387598375983759834'\n        },\n        area: {\n            top: '0%',\n            right: '0%',\n            left: '0%',\n            bottom: '0%'\n        },\n        singleChannel: false // true: only the red color-channel is read\n    },\n    locate: true,\n    numOfWorkers: 0,\n    decoder: {\n        readers: [\n            'code_128_reader'\n        ],\n        debug: {\n            drawBoundingBox: false,\n            showFrequency: false,\n            drawScanline: false,\n            showPattern: false\n        }\n    },\n    locator: {\n        halfSample: true,\n        patchSize: 'medium', // x-small, small, medium, large, x-large\n        debug: {\n            showCanvas: false,\n            showPatches: false,\n            showFoundPatches: false,\n            showSkeleton: false,\n            showLabels: false,\n            showPatchLabels: false,\n            showRemainingPatchLabels: false,\n            boxFromPatches: {\n                showTransformed: false,\n                showTransformedBox: false,\n                showBB: false\n            }\n        }\n    }\n};\n","import { Box } from '../common/box';\nimport { ImageWrapper } from '../common/image-wrapper';\nimport { Point } from '../common/point';\nimport { Readers } from '../reader/index';\nimport { Barcode, BarcodeReader, BarcodeReaderConfig, BarcodeReaderDeclaration, BarcodeReaderType } from '../reader/barcode-reader';\nimport { BarcodeLine, Bresenham } from './bresenham';\nimport { ImageDebug } from '../common/image-debug';\n\nexport interface BarcodeDecoderConfig {\n    debug?: {\n        drawBoundingBox?: boolean;\n        drawScanline?: boolean;\n        showFrequency?: boolean;\n        showPattern?: boolean;\n    };\n    multiple?: boolean;\n    readers?: Array<BarcodeReaderDeclaration>;\n}\n\ntype Line = [Point, Point];\n\nexport interface QuaggaBarcode {\n    angle?: number;\n    barcodes?: Array<QuaggaBarcode>; // TOOD: deal with multiple results\n    box?: Box;\n    boxes?: Array<Box>; // TOOD: deal with multiple results\n    codeResult?: Barcode;\n    frame?: string;\n    line?: Line;\n    pattern?: Array<number>;\n    threshold?: number;\n};\n\ninterface BarcodeAndBarcodeLine {\n    codeResult: Barcode;\n    barcodeLine: BarcodeLine;\n}\n\nexport class BarcodeDecoder {\n    private _config: BarcodeDecoderConfig;\n    private _inputImageWrapper: ImageWrapper<Uint8Array>;\n    private _frequencyCanvas: HTMLCanvasElement;\n    private _patternCanvas: HTMLCanvasElement;\n    private _overlayContext: CanvasRenderingContext2D;\n    private _barcodeReaders: Array<BarcodeReader>;\n\n    constructor(config: BarcodeDecoderConfig, inputImageWrapper: ImageWrapper<Uint8Array>) {\n        this._config = config;\n        this._inputImageWrapper = inputImageWrapper;\n        this._barcodeReaders = [];\n\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && typeof document !== 'undefined') {\n            const debugDiv = document.querySelector('#debug.detection');\n\n            this._frequencyCanvas = document.querySelector('canvas.frequency');\n            if (!this._frequencyCanvas) {\n                this._frequencyCanvas = document.createElement('canvas');\n                this._frequencyCanvas.className = 'frequency';\n                if (debugDiv) {\n                    debugDiv.appendChild(this._frequencyCanvas);\n                }\n            }\n            this._frequencyCanvas.style.display = this._config.debug.showFrequency ? 'block' : 'none';\n\n            this._patternCanvas = document.querySelector('canvas.patternBuffer');\n            if (!this._patternCanvas) {\n                this._patternCanvas = document.createElement('canvas');\n                this._patternCanvas.className = 'patternBuffer';\n                if (debugDiv) {\n                    debugDiv.appendChild(this._patternCanvas);\n                }\n            }\n            this._patternCanvas.style.display = this._config.debug.showPattern ? 'block' : 'none';\n\n            const overlayCanvas = document.querySelector<HTMLCanvasElement>('canvas.drawingBuffer');\n            this._overlayContext = overlayCanvas ? overlayCanvas.getContext('2d') : null;\n        }\n\n        this._initReaders();\n    }\n\n    decodeFromBoundingBoxes(boxes: Array<Box>): QuaggaBarcode {\n        let barcode: QuaggaBarcode = null;\n\n        if (boxes) {\n            if (this._config.multiple) {\n                const barcodes = boxes.map(box => this.decodeFromBoundingBox(box));\n                return { barcodes, boxes };\n            }\n            if (boxes.some(box => !!(barcode = this.decodeFromBoundingBox(box)))) {\n                barcode.boxes = boxes;\n            }\n        }\n\n        return barcode;\n    }\n\n    /**\n     * With the help of the configured readers this function tries to detect\n     * a valid barcode pattern within the given area.\n     * @param box The area to search in\n     * @returns The result {codeResult, line, angle, pattern, threshold}\n     */\n    decodeFromBoundingBox(box: Box): QuaggaBarcode {\n        const debug = process.env.NODE_ENV !== 'production' && this._overlayContext && this._config.debug;\n\n        if (debug && debug.drawBoundingBox) {\n            this._drawPath(box, 'blue', 2);\n        }\n\n        let line = this._getLine(box);\n\n        if (line === null) {\n            return null;\n        }\n\n        const angle = Math.atan2(line[1].y - line[0].y, line[1].x - line[0].x);\n        line = this._getExtendedLine(line, angle);\n\n        let result = this._tryDecode(line);\n        if (result === null) {\n            result = this._tryDecodeBruteForce(box, line, angle);\n        }\n\n        if (result === null) {\n            return null;\n        }\n\n        if (debug && debug.drawScanline) {\n            this._drawPath(line, 'red', 3);\n        }\n\n        return {\n            angle,\n            box,\n            codeResult: result.codeResult,\n            line,\n            pattern: result.barcodeLine.line,\n            threshold: result.barcodeLine.threshold\n        };\n    }\n\n    setReaders(readers: Array<BarcodeReaderDeclaration>): void {\n        this._config.readers = readers;\n        this._barcodeReaders.length = 0;\n        this._initReaders();\n    }\n\n    private _initReaders(): void {\n        this._config.readers.forEach(readerConfig => {\n            let reader: BarcodeReaderType;\n            let configuration: BarcodeReaderConfig = {};\n            let supplements = [];\n\n            if (typeof readerConfig === 'object') {\n                reader = readerConfig.format;\n                configuration = readerConfig.config || {};\n            } else if (typeof readerConfig === 'string') {\n                reader = readerConfig;\n            }\n\n            if (process.env.NODE_ENV !== 'production') {\n                console.log('Before registering reader:', reader);\n            }\n\n            if (configuration.supplements) {\n                supplements = configuration.supplements.map(supplement => new Readers[supplement]());\n            }\n\n            this._barcodeReaders.push(new Readers[reader](configuration, supplements));\n        });\n\n        if (process.env.NODE_ENV !== 'production') {\n            console.log('Registered Readers:',\n                ...this._barcodeReaders.map(({ config, FORMAT }) => JSON.stringify({ config, FORMAT })));\n        }\n    }\n\n    /**\n     * extend the line on both ends\n     * @param line\n     * @param angle\n     */\n    private _getExtendedLine(line: Line, angle: number): Line {\n        function extendLine(amount: number) {\n            const extension = {\n                y: amount * Math.sin(angle),\n                x: amount * Math.cos(angle)\n            };\n\n            line[0].y -= extension.y;\n            line[0].x -= extension.x;\n            line[1].y += extension.y;\n            line[1].x += extension.x;\n        }\n\n        const lineLength = Math.sqrt((line[1].y - line[0].y) ** 2 + (line[1].x - line[0].x) ** 2);\n        let extensionLength = lineLength * 0.1 | 0;\n\n        extendLine(extensionLength);\n\n        // check if inside image\n        while (extensionLength > 1 && (!this._inputImageWrapper.inImageWithBorder(line[0], 0)\n            || !this._inputImageWrapper.inImageWithBorder(line[1], 0))) {\n            extensionLength >>= 1;\n            extendLine(-extensionLength);\n        }\n\n        return line;\n    }\n\n    private _getLine(box: Box): Line {\n        return [{\n            x: (box[1].x + box[0].x) / 2,\n            y: (box[1].y + box[0].y) / 2\n        }, {\n            x: (box[3].x + box[2].x) / 2,\n            y: (box[3].y + box[2].y) / 2\n        }];\n    }\n\n    private _tryDecode(line: Line): BarcodeAndBarcodeLine {\n        const debug = process.env.NODE_ENV !== 'production' && this._config.debug;\n\n        if (debug && this._overlayContext) {\n            this._drawPath(line, 'red', 3);\n        }\n\n        let barcodeLine = Bresenham.getBarcodeLine(this._inputImageWrapper, line[0], line[1]);\n\n        if (debug && debug.showFrequency) {\n            this._printFrequency(barcodeLine.line);\n        }\n\n        barcodeLine = Bresenham.toBinaryLine(barcodeLine);\n\n        if (debug && debug.showPattern) {\n            this._printPattern(barcodeLine.line);\n        }\n\n        let codeResult: Barcode = null;\n\n        this._barcodeReaders.some(reader => !!(codeResult = reader.decodePattern(barcodeLine.line)));\n\n        return codeResult ? { codeResult, barcodeLine } : null;\n    }\n\n    /**\n     * This method slices the given area apart and tries to detect a barcode-pattern for each slice.\n     * It returns the decoded barcode, or null if nothing was found\n     * @param box\n     * @param line\n     * @param lineAngle\n     */\n    private _tryDecodeBruteForce(box: Box, line: Line, lineAngle: number): BarcodeAndBarcodeLine {\n        const sideLength = Math.sqrt((box[1].x - box[0].x) ** 2 + (box[1].y - box[0].y) ** 2);\n        const slices = 16;\n        const xdir = Math.sin(lineAngle);\n        const ydir = Math.cos(lineAngle);\n\n        for (let i = 1; i < slices; i++) {\n            // move line perpendicular to angle\n            const dir = sideLength / slices * i * (i % 2 === 0 ? -1 : 1);\n            line[0].y += dir * xdir;\n            line[0].x -= dir * ydir;\n            line[1].y += dir * xdir;\n            line[1].x -= dir * ydir;\n\n            const result = this._tryDecode(line);\n            if (result) {\n                return result;\n            }\n        }\n\n        return null;\n    }\n\n    /**\n     * Used for development only\n     */\n    private _printFrequency(line: Array<number>): void {\n        const context = this._frequencyCanvas.getContext('2d');\n        this._frequencyCanvas.width = line.length;\n        this._frequencyCanvas.height = 256;\n\n        context.beginPath();\n        context.strokeStyle = 'blue';\n\n        for (let i = 0; i < line.length; i++) {\n            context.moveTo(i, 255);\n            context.lineTo(i, 255 - line[i]);\n        }\n\n        context.closePath();\n        context.stroke();\n    }\n\n    /**\n     * Used for development only\n     */\n    private _printPattern(line: Array<number>): void {\n        const context = this._patternCanvas.getContext('2d');\n\n        this._patternCanvas.width = line.length;\n        context.fillStyle = 'black';\n\n        for (let i = 0; i < line.length; i++) {\n            if (line[i] === 1) {\n                context.fillRect(i, 0, 1, 100);\n            }\n        }\n    }\n\n    private _drawPath(path: Array<Point>, color: string, lineWidth: number): void {\n        ImageDebug.drawPath(path, this._overlayContext, color, lineWidth);\n    }\n}\n","import { Point } from '../common/point';\nimport { ImageWrapper } from '../common/image-wrapper';\n\nenum Slope {\n    Up = 1,\n    Down = -1\n};\n\nexport interface BarcodeLine {\n    line: Array<number>;\n    max?: number;\n    min?: number;\n    threshold?: number;\n}\n\nexport const Bresenham = {\n    /**\n     * Scans a line of the given image from point p1 to p2 and returns a result object containing\n     * gray-scale values (0-255) of the underlying pixels in addition to the min and max values.\n     * @param imageWrapper\n     * @param p1 The start point {x,y}\n     * @param p2 The end point {x,y}\n     * @returns {line, min, max}\n     */\n    getBarcodeLine(imageWrapper: ImageWrapper, p1: Point, p2: Point): BarcodeLine {\n        let x0 = p1.x | 0;\n        let y0 = p1.y | 0;\n        let x1 = p2.x | 0;\n        let y1 = p2.y | 0;\n        const steep = Math.abs(y1 - y0) > Math.abs(x1 - x0);\n        let tmp: number;\n        const line = [];\n        const imageData = imageWrapper.data;\n        const width = imageWrapper.size.x;\n        let val: number;\n        let min = 255;\n        let max = 0;\n\n        function read(a: number, b: number) {\n            val = imageData[b * width + a];\n            min = val < min ? val : min;\n            max = val > max ? val : max;\n            line.push(val);\n        }\n\n        if (steep) {\n            tmp = x0;\n            x0 = y0;\n            y0 = tmp;\n\n            tmp = x1;\n            x1 = y1;\n            y1 = tmp;\n        }\n        if (x0 > x1) {\n            tmp = x0;\n            x0 = x1;\n            x1 = tmp;\n\n            tmp = y0;\n            y0 = y1;\n            y1 = tmp;\n        }\n\n        let deltax = x1 - x0;\n        let deltay = Math.abs(y1 - y0);\n        let error = (deltax / 2) | 0;\n        let y = y0;\n        let ystep = y0 < y1 ? 1 : -1;\n\n        for (let x = x0; x < x1; x++) {\n            if (steep) {\n                read(y, x);\n            } else {\n                read(x, y);\n            }\n            error = error - deltay;\n            if (error < 0) {\n                y += ystep;\n                error = error + deltax;\n            }\n        }\n\n        return {\n            line,\n            min,\n            max\n        };\n    },\n\n    /**\n     * Converts the result from getBarcodeLine into a binary representation\n     * also considering the frequency and slope of the signal for more robust results\n     * @param result {line, min, max}\n     */\n    toBinaryLine(result: BarcodeLine): BarcodeLine {\n        const min = result.min;\n        const max = result.max;\n        const line = result.line;\n        const center = min + (max - min) / 2;\n        const extrema = new Array<{ pos: number; val: number; }>();\n        let threshold = (max - min) / 12;\n        const rThreshold = -threshold;\n\n        // 1. find extrema\n        let currentDir = line[0] > center ? Slope.Up : Slope.Down;\n        extrema.push({\n            pos: 0,\n            val: line[0]\n        });\n        for (let i = 0; i < line.length - 2; i++) {\n            const slope = (line[i + 1] - line[i]);\n            const slope2 = (line[i + 2] - line[i + 1]);\n            let dir: Slope;\n            if ((slope + slope2) < rThreshold && line[i + 1] < (center * 1.5)) {\n                dir = Slope.Down;\n            } else if ((slope + slope2) > threshold && line[i + 1] > (center * 0.5)) {\n                dir = Slope.Up;\n            } else {\n                dir = currentDir;\n            }\n\n            if (currentDir !== dir) {\n                extrema.push({\n                    pos: i,\n                    val: line[i]\n                });\n                currentDir = dir;\n            }\n        }\n        extrema.push({\n            pos: line.length,\n            val: line[line.length - 1]\n        });\n\n        for (let j = extrema[0].pos; j < extrema[1].pos; j++) {\n            line[j] = line[j] > center ? 0 : 1;\n        }\n\n        // iterate over extrema and convert to binary based on avg between minmax\n        for (let i = 1; i < extrema.length - 1; i++) {\n            if (extrema[i + 1].val > extrema[i].val) {\n                threshold = (extrema[i].val + ((extrema[i + 1].val - extrema[i].val) / 3) * 2) | 0;\n            } else {\n                threshold = (extrema[i + 1].val + ((extrema[i].val - extrema[i + 1].val) / 3)) | 0;\n            }\n\n            for (let j = extrema[i].pos; j < extrema[i + 1].pos; j++) {\n                line[j] = line[j] > threshold ? 0 : 1;\n            }\n        }\n\n        return {\n            ...result,\n            threshold\n        };\n    }\n};\n","import { getUserMedia, enumerateDevices } from '../common/media-devices';\n\nlet _stream: MediaStream;\n\nexport const CameraAccess = {\n    /**\n     * Attempts to attach the camera-stream to a given video element\n     * and calls the callback function when the content is ready\n     * @param video\n     * @param videoConstraints\n     */\n    async request(video: HTMLVideoElement, videoConstraints: MediaTrackConstraints): Promise<void> {\n        const normalizedConstraints = CameraAccess.pickConstraints(videoConstraints);\n        _stream = await getUserMedia(normalizedConstraints);\n        video.srcObject = _stream;\n        video.setAttribute('autoplay', '');\n        video.setAttribute('muted', '');\n        video.setAttribute('playsinline', '');\n\n        return new Promise(resolve => video.addEventListener('loadedmetadata', () => {\n            video.play();\n            resolve();\n        })).then(_waitForVideo.bind(null, video));\n    },\n\n    release(): void {\n        const tracks = _stream && _stream.getVideoTracks();\n        if (tracks && tracks.length) {\n            tracks[0].stop();\n        }\n        _stream = null;\n    },\n\n    async enumerateVideoDevices(): Promise<Array<MediaDeviceInfo>> {\n        const devices = await enumerateDevices();\n        return devices.filter(({ kind }) => kind === 'videoinput');\n    },\n\n    getActiveStreamLabel(): string {\n        const track = CameraAccess.getActiveTrack();\n        return track ? track.label : '';\n    },\n\n    getActiveTrack() {\n        const tracks = _stream && _stream.getVideoTracks();\n        if (tracks && tracks.length) {\n            return tracks[0];\n        }\n\n        return null;\n    },\n\n    pickConstraints(videoConstraints: MediaTrackConstraints): MediaStreamConstraints {\n        let { width, height, facingMode, aspectRatio, deviceId } = videoConstraints;\n        const { minAspectRatio, facing } = videoConstraints as any;\n\n        if (typeof minAspectRatio !== 'undefined' && minAspectRatio > 0) {\n            aspectRatio = minAspectRatio;\n            console.log(`WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead`);\n        }\n\n        if (typeof facing !== 'undefined') {\n            facingMode = facing;\n            console.log(`WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'`);\n        }\n\n        const normalizedConstraints = deviceId && facingMode ?\n            { width, height, aspectRatio, deviceId } : { width, height, facingMode, aspectRatio, deviceId };\n\n        return {\n            audio: false,\n            video: normalizedConstraints\n        };\n    }\n}\n\nfunction _waitForVideo({ videoWidth, videoHeight }): Promise<void> {\n    return new Promise((resolve, reject) => {\n        let attempts = 10;\n\n        function checkVideo() {\n            if (attempts > 0) {\n                if (videoWidth > 10 && videoHeight > 10) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        console.log(`${videoWidth}px x ${videoHeight}px`);\n                    }\n                    resolve();\n                } else {\n                    window.setTimeout(checkVideo, 500);\n                }\n            } else {\n                reject('Unable to play video stream. Is webcam working?');\n            }\n            attempts--;\n        }\n        checkVideo();\n    });\n}\n","/**\n * @borrows https://github.com/exif-js/exif-js\n */\n\nconst ExifTags = { 0x0112: 'orientation' };\nexport const AvailableTags: Array<string> = Object.keys(ExifTags).map(key => ExifTags[key]);\n\nexport interface Tags {\n    [key: string]: number | string;\n}\n\nexport async function findTagsInObjectURL(src: string, tags = AvailableTags): Promise<Tags> {\n    if (/^blob:/i.test(src)) {\n        const buffer = await objectURLToBlob(src);\n        return findTagsInBuffer(buffer, tags);\n    }\n    return Promise.resolve(null);\n}\n\nexport function findTagsInBuffer(file: ArrayBuffer, selectedTags: Array<string> = AvailableTags): Tags {\n    const dataView = new DataView(file);\n    const length = file.byteLength;\n    const exifTags = selectedTags.reduce((result, selectedTag) => {\n        const exifTag = Object.keys(ExifTags).find(tag => ExifTags[tag] === selectedTag);\n        if (exifTag) {\n            result[exifTag] = selectedTag;\n        }\n        return result;\n    }, {});\n    let offset = 2;\n\n    if ((dataView.getUint8(0) !== 0xFF) || (dataView.getUint8(1) !== 0xD8)) {\n        return null;\n    }\n\n    while (offset < length) {\n        if (dataView.getUint8(offset) !== 0xFF) {\n            return null;\n        }\n\n        const marker = dataView.getUint8(offset + 1);\n        if (marker === 0xE1) {\n            return readEXIFData(dataView, offset + 4, exifTags);\n        } else {\n            offset += 2 + dataView.getUint16(offset + 2);\n        }\n    }\n\n    return null;\n}\n\nasync function objectURLToBlob(url: string): Promise<ArrayBuffer> {\n    const response = await fetch(url);\n    if (response.ok) {\n        return response.arrayBuffer();\n    }\n\n    throw new Error('HTTP Error ' + response.status);\n}\n\nfunction readEXIFData(dataView: DataView, start: number, exifTags: { [key: number]: string }): Tags {\n    if ('Exif'.split('').some((char, index) => dataView.getUint8(start + index) !== char.charCodeAt(0))) {\n        return null;\n    }\n\n    const tiffOffset = start + 6;\n    let bigEnd: boolean;\n\n    if (dataView.getUint16(tiffOffset) === 0x4949) {\n        bigEnd = false;\n    } else if (dataView.getUint16(tiffOffset) === 0x4D4D) {\n        bigEnd = true;\n    } else {\n        return null;\n    }\n\n    if (dataView.getUint16(tiffOffset + 2, !bigEnd) !== 0x002A) {\n        return null;\n    }\n\n    const firstIFDOffset = dataView.getUint32(tiffOffset + 4, !bigEnd);\n    if (firstIFDOffset < 0x00000008) {\n        return null;\n    }\n\n    const tags = readTags(dataView, tiffOffset + firstIFDOffset, exifTags, bigEnd);\n    return tags;\n}\n\nfunction readTags(dataView: DataView, dirStart: number, strings: { [key: number]: string }, bigEnd: boolean): Tags {\n    const entries = dataView.getUint16(dirStart, !bigEnd);\n    const tags: Tags = {};\n\n    for (let i = 0; i < entries; i++) {\n        const entryOffset = dirStart + i * 12 + 2;\n        const tag = strings[dataView.getUint16(entryOffset, !bigEnd)];\n        if (tag) {\n            tags[tag] = readTagValue(dataView, entryOffset, bigEnd);\n        }\n    }\n\n    return tags;\n}\n\nfunction readTagValue(dataView: DataView, entryOffset: number, bigEnd: boolean): number | string {\n    const type = dataView.getUint16(entryOffset + 2, !bigEnd);\n    const numValues = dataView.getUint32(entryOffset + 4, !bigEnd);\n\n    return type === 3 && numValues === 1 ? dataView.getUint16(entryOffset + 8, !bigEnd) : undefined;\n}\n","import { Point } from '../common/point';\nimport { InputStream } from './input-stream';\nimport { InputStreamConfig } from './input-stream-config';\n\nconst QUATER_CIRCLE = Math.PI / 2;\n\nexport class FrameGrabber {\n    private _inputStream: InputStream;\n    private _streamConfig: InputStreamConfig;\n    private _canvas: HTMLCanvasElement;\n    private _context: CanvasRenderingContext2D;\n    private _data: Uint8Array;\n    private _canvasHeight: number;\n    private _canvasWidth: number;\n    private _height: number;\n    private _width: number;\n    private _topLeft: Point;\n\n    constructor(inputStream: InputStream, canvas: HTMLCanvasElement) {\n        this._inputStream = inputStream;\n        this._streamConfig = inputStream.config;\n        this._canvasWidth = inputStream.canvasWidth;\n        this._canvasHeight = inputStream.canvasHeight;\n        this._width = inputStream.width;\n        this._height = inputStream.height;\n        this._topLeft = inputStream.topLeft;\n        this._canvas = canvas || document.createElement('canvas');\n        this._canvas.width = this._canvasWidth;\n        this._canvas.height = this._canvasHeight;\n        this._context = this._canvas.getContext('2d');\n        this._data = new Uint8Array(this._width * this._height);\n\n        if (process.env.NODE_ENV !== 'production') {\n            console.log('FrameGrabber', JSON.stringify({\n                size: {\n                    x: this._width,\n                    y: this._height\n                },\n                topLeft: this._topLeft,\n                videoSize: {\n                    x: inputStream.realWidth,\n                    y: inputStream.realHeight\n                },\n                canvasSize: {\n                    x: this._canvasWidth,\n                    y: this._canvasHeight\n                }\n            }));\n        }\n    }\n\n    /**\n     * Fetches a frame from the input stream and puts into the frame buffer.\n     * The image data is converted to gray scale and then half-sampled if configured.\n     */\n    grab(data: Uint8Array): boolean {\n        this._data = data;\n        const frame = this._inputStream.getFrame();\n\n        if (frame) {\n            this._adjustCanvasSize();\n\n            let drawable: HTMLImageElement | HTMLVideoElement;\n            let drawAngle = 0;\n\n            if (frame instanceof HTMLVideoElement) {\n                drawable = frame;\n            } else {\n                drawable = frame.image;\n\n                if (frame.tags) {\n                    switch (frame.tags.orientation) {\n                        case 6: {\n                            drawAngle = QUATER_CIRCLE;\n                            break;\n                        }\n                        case 8: {\n                            drawAngle = -QUATER_CIRCLE;\n                            break;\n                        }\n                    }\n                }\n            }\n\n            if (drawAngle !== 0) {\n                const halfWidth = this._canvasWidth >> 1;\n                const halfHeight = this._canvasHeight >> 1;\n\n                this._context.translate(halfWidth, halfHeight);\n                this._context.rotate(drawAngle);\n                this._context.drawImage(drawable, -halfHeight, -halfWidth, this._canvasHeight, this._canvasWidth);\n                this._context.rotate(-drawAngle);\n                this._context.translate(-halfWidth, -halfHeight);\n            } else {\n                this._context.drawImage(drawable, 0, 0, this._canvasWidth, this._canvasHeight);\n            }\n\n            const imageData = this._context.getImageData(this._topLeft.x, this._topLeft.y, this._width, this._height).data;\n\n            if (this._streamConfig.halfSample) {\n                this._grayAndHalfSampleFromCanvasData(imageData);\n            } else {\n                this._computeGray(imageData);\n            }\n\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    private _adjustCanvasSize(): void {\n        if (this._canvas.height !== this._canvasHeight || this._canvas.width !== this._canvasWidth) {\n            if (process.env.NODE_ENV !== 'production') {\n                console.warn('Canvas size needs to be adjusted');\n            }\n            this._canvas.height = this._canvasHeight;\n            this._canvas.width = this._canvasWidth;\n        }\n    }\n\n    private _grayAndHalfSampleFromCanvasData(imageData: Uint8ClampedArray): void {\n        const endIndex = imageData.length >> 2;\n        const outWidth = this._width >> 1;\n        let topRowIndex = 0;\n        let bottomRowIndex = this._width;\n        let outImageIndex = 0;\n\n        while (bottomRowIndex < endIndex) {\n            for (let i = 0; i < outWidth; i++) {\n                const top4 = topRowIndex << 2;\n                const bottom4 = bottomRowIndex << 2;\n                this._data[outImageIndex] = (\n                    (0.299 * imageData[top4 + 0] + 0.587 * imageData[top4 + 1] + 0.114 * imageData[top4 + 2]) +\n                    (0.299 * imageData[top4 + 4] + 0.587 * imageData[top4 + 5] + 0.114 * imageData[top4 + 6]) +\n                    (0.299 * imageData[bottom4 + 0] + 0.587 * imageData[bottom4 + 1] + 0.114 * imageData[bottom4 + 2]) +\n                    (0.299 * imageData[bottom4 + 4] + 0.587 * imageData[bottom4 + 5] + 0.114 * imageData[bottom4 + 6])\n                ) / 4 | 0;\n                outImageIndex++;\n                topRowIndex += 2;\n                bottomRowIndex += 2;\n            }\n            topRowIndex += this._width;\n            bottomRowIndex += this._width;\n        }\n    }\n\n    private _computeGray(imageData: Uint8ClampedArray): void {\n        const imageDataLength = imageData.length;\n\n        if (this._streamConfig && this._streamConfig.singleChannel) {\n            for (let i = 0, j = 0; i < imageDataLength; i += 4, j++) {\n                this._data[j] = imageData[i];\n            }\n        } else {\n            for (let i = 0, j = 0; i < imageDataLength; i += 4, j++) {\n                this._data[j] = 0.299 * imageData[i] + 0.587 * imageData[i + 1] + 0.114 * imageData[i + 2] | 0;\n            }\n        }\n    }\n}\n","import { findTagsInObjectURL, Tags } from './exif-helper';\n\nexport interface ImageInfo {\n    image: HTMLImageElement;\n    tags?: Tags;\n}\n\nexport class ImageLoader {\n    static async load(\n        baseUri: string,\n        callback: (_: Array<ImageInfo>) => void,\n        offset: number,\n        size: number,\n        sequence: boolean\n    ): Promise<void> {\n        const imageSrcs = new Array<string>(size);\n        const loadedImages = new Array<ImageInfo>(size);\n        const notLoadedImages = new Array<HTMLImageElement>();\n\n        if (sequence === false) {\n            imageSrcs[0] = baseUri;\n        } else {\n            for (let i = 0; i < size; i++) {\n                imageSrcs[i] = `${baseUri}image-${('00' + (offset + i)).slice(-3)}.jpg`;\n            }\n        }\n\n        imageSrcs.forEach(src => {\n            const image = new Image();\n            notLoadedImages.push(image);\n            image.onload = () => loaded(image);\n            image.src = src;\n        });\n\n        async function loaded(loadedImage: HTMLImageElement): Promise<void> {\n            for (let x = 0; x < notLoadedImages.length; x++) {\n                if (notLoadedImages[x] === loadedImage) {\n                    notLoadedImages.splice(x, 1);\n                    // TODO: assume the index is the same\n                    for (let y = 0; y < imageSrcs.length; y++) {\n                        const imageName = imageSrcs[y].substr(imageSrcs[y].lastIndexOf('/'));\n                        if (loadedImage.src.lastIndexOf(imageName) !== -1) {\n                            loadedImages[y] = { image: loadedImage };\n                            break;\n                        }\n                    }\n                    break;\n                }\n            }\n            if (notLoadedImages.length === 0) {\n                if (process.env.NODE_ENV !== 'production') {\n                    console.log('Images loaded');\n                }\n                try {\n                    if (sequence === false) {\n                        const firstImage = loadedImages[0];\n                        firstImage.tags = await findTagsInObjectURL(baseUri);\n                    }\n                } catch (ex) {\n                    console.log(ex);\n                } finally {\n                    callback(loadedImages);\n                }\n            }\n        }\n    }\n}\n","import { ImageInfo, ImageLoader } from './image-loader';\nimport { InputStream } from './input-stream';\nimport { InputStreamConfig } from './input-stream-config';\n\nexport class ImageStream extends InputStream {\n    private _baseUrl: string;\n    private _ended: boolean;\n    private _frameIndex: number;\n    private _height: number;\n    private _images: Array<ImageInfo>;\n    private _loaded: boolean;\n    private _offset: number;\n    private _paused: boolean;\n    private _size: number;\n    private _width: number;\n\n    constructor() {\n        super();\n\n        this._canvasHeight = 0;\n        this._canvasWidth = 0;\n        this._baseUrl = null;\n        this._ended = false;\n        this._frameIndex = 0;\n        this._height = 0;\n        this._images = null;\n        this._loaded = false;\n        this._offset = 1;\n        this._paused = true;\n        this._size = 0;\n        this._width = 0;\n    }\n\n    get realHeight(): number {\n        return this._height;\n    }\n\n    get realWidth(): number {\n        return this._width;\n    }\n\n    get config(): InputStreamConfig {\n        return this._config;\n    }\n\n    set config(config: InputStreamConfig) {\n        this._config = { ...config };\n        this._baseUrl = config.src;\n        this._size = config.sequence && config.length ? config.length : 1;\n\n        this._loadImages();\n    }\n\n    get ended(): boolean {\n        return this._ended;\n    }\n\n    setAttribute() { }\n\n    pause(): void {\n        this._paused = true;\n    }\n\n    play(): void {\n        this._paused = false;\n    }\n\n    set currentTime(time: number) {\n        this._frameIndex = time;\n    }\n\n    getFrame(): HTMLVideoElement | ImageInfo {\n        let frame: ImageInfo = null;\n\n        if (this._loaded && !this._paused) {\n            frame = this._images[this._frameIndex];\n\n            if (this._frameIndex < (this._size - 1)) {\n                this._frameIndex++;\n            } else {\n                setTimeout(() => {\n                    this._ended = true;\n                    this.trigger('ended', []);\n                }, 0);\n            }\n        }\n\n        return frame;\n    }\n\n    private _loadImages(): void {\n        this._loaded = false;\n        ImageLoader.load(this._baseUrl, images => {\n            this._images = images;\n\n            switch (images[0].tags && images[0].tags.orientation) {\n                case 6:\n                case 8: {\n                    this._width = images[0].image.height;\n                    this._height = images[0].image.width;\n                    break;\n                }\n                default: {\n                    this._width = images[0].image.width;\n                    this._height = images[0].image.height;\n                }\n            }\n\n            this._canvasWidth = this._calculatedWidth = this._config.size ? this._width > this._height ?\n                this._config.size : this._width * this._config.size / this._height | 0 : this._width;\n            this._canvasHeight = this._calculatedHeight = this._config.size ? this._width > this._height ?\n                this._height * this._config.size / this._width | 0 : this._config.size : this._height;\n            this._loaded = true;\n            this._frameIndex = 0;\n            setTimeout(() => this.trigger('canrecord', []), 0);\n        }, this._offset, this._size, this._config.sequence);\n    }\n}\n","import { Point } from '../common/point';\nimport { BarcodeLocatorConfig, PatchSizeConfig } from '../locator/barcode-locator-config';\nimport { InputStream } from './input-stream';\nimport { AreaConfig } from './input-stream-config';\n\nexport interface Dimension {\n    unit: '%' | 'px',\n    value: number;\n}\n\nfunction _computeDivisors(n: number): Array<number> {\n    const divisors = new Array<number>();\n    const largeDivisors = new Array<number>();\n\n    for (let divisor = 1; divisor * divisor <= n; divisor++) {\n        if (n % divisor === 0) {\n            divisors.push(divisor);\n            if (divisor * divisor !== n) {\n                largeDivisors.unshift(n / divisor | 0);\n            }\n        }\n    }\n\n    return divisors.concat(largeDivisors);\n}\n\nfunction _computeCommonDivisors(m: number, n: number): Array<number> {\n    if (m === n) {\n        return _computeDivisors(m);\n    }\n\n    const max = m > n ? m : n;\n    const min = m > n ? n : m;\n    const divisors = new Array<number>();\n    const largeDivisors = new Array<number>();\n\n    for (let divisor = 1; divisor * divisor <= min; divisor++) {\n        if (max % divisor === 0 && min % divisor === 0) {\n            divisors.push(divisor);\n            const largeDivisor = min / divisor | 0;\n            if (divisor !== largeDivisor && max % largeDivisor === 0) {\n                largeDivisors.unshift();\n            }\n        }\n    }\n\n    return divisors.concat(largeDivisors);\n}\n\nexport function calculatePatchSize(patchSize: PatchSizeConfig, { x, y }: Point): Point {\n    const wideSide = Math.max(x | 0, y | 0) | 0;\n    const nrOfPatchesList = [8, 10, 15, 20, 32, 60, 80];\n    const nrOfPatchesMap = {\n        'x-small': 5,\n        small: 4,\n        medium: 3,\n        large: 2,\n        'x-large': 1\n    };\n    const nrOfPatchesIndex = nrOfPatchesMap[patchSize] || nrOfPatchesMap.medium | 0;\n    const nrOfPatches = nrOfPatchesList[nrOfPatchesIndex] | 0;\n    const desiredPatchSize = wideSide / nrOfPatches | 0;\n\n    function findPatchSizeForDivisors(divisors: Array<number>): Point {\n        let i = 0;\n        let found = divisors[divisors.length >> 1] | 0;\n\n        while (i < (divisors.length - 1) && divisors[i] < desiredPatchSize) {\n            i++;\n        }\n        if (i > 0) {\n            if (Math.abs(divisors[i] - desiredPatchSize) > Math.abs(divisors[i - 1] - desiredPatchSize)) {\n                found = divisors[i - 1] | 0;\n            } else {\n                found = divisors[i] | 0;\n            }\n        }\n        if (desiredPatchSize / found < nrOfPatchesList[nrOfPatchesIndex + 1] / nrOfPatchesList[nrOfPatchesIndex] &&\n            desiredPatchSize / found > nrOfPatchesList[nrOfPatchesIndex - 1] / nrOfPatchesList[nrOfPatchesIndex]) {\n            return { x: found, y: found };\n        }\n        return null;\n    }\n\n    const optimalPatchSize = findPatchSizeForDivisors(_computeCommonDivisors(x, y)) ||\n        findPatchSizeForDivisors(_computeDivisors(wideSide)) ||\n        findPatchSizeForDivisors(_computeDivisors(desiredPatchSize * nrOfPatches));\n\n    return optimalPatchSize;\n}\n\nexport function checkImageConstraints(inputStream: InputStream, config: BarcodeLocatorConfig) {\n    let width = inputStream.width;\n    let height = inputStream.height;\n    const shift = config.halfSample ? 1 : 0 | 0;\n    const inputStreamConfig = inputStream.config;\n\n    // calculate width and height based on area\n    if (inputStreamConfig && inputStreamConfig.area) {\n        const area = computeImageArea(width, height, inputStreamConfig.area);\n        inputStream.topLeft = area.topLeft;\n        inputStream.setCanvasSize(width, height);\n        width = area.width;\n        height = area.height;\n    }\n\n    const size = {\n        x: width >> shift,\n        y: height >> shift\n    };\n\n    const patchSize = calculatePatchSize(config.patchSize, size);\n    if (process.env.NODE_ENV !== 'production') {\n        console.log('Patch-Size:', JSON.stringify(patchSize));\n    }\n\n    inputStream.width = (size.x / patchSize.x << shift) * patchSize.x | 0;\n    inputStream.height = (size.y / patchSize.y << shift) * patchSize.y | 0;\n\n    if ((inputStream.width % patchSize.x) === 0 && (inputStream.height % patchSize.y) === 0) {\n        return true;\n    }\n\n    // eslint-disable-next-line max-len\n    throw new Error(`Image dimensions do not comply with the current settings: width (${width}) and height (${height}) must be a multiple of ${patchSize.x}`);\n}\n\nexport function _parseCssDimensionValues(value: string): Dimension {\n    const dimension: Dimension = {\n        value: parseFloat(value),\n        unit: value.indexOf('%') === value.length - 1 ? '%' : value.indexOf('px') === value.length - 2 ? 'px' : '%'\n    };\n\n    return dimension;\n}\n\nexport const _dimensionsConverters = {\n    bottom: (dimension: Dimension, { height }) => dimension.unit === '%' ?\n        height - height * dimension.value / 100 | 0 : dimension.unit === 'px' ? height - dimension.value : height,\n    left: (dimension: Dimension, { width }) => dimension.unit === '%' ?\n        width * dimension.value / 100 | 0 : dimension.unit === 'px' ? dimension.value : 0,\n    right: (dimension: Dimension, { width }) => dimension.unit === '%' ?\n        width - width * dimension.value / 100 | 0 : dimension.unit === 'px' ? width - dimension.value : width,\n    top: (dimension: Dimension, { height }): number => dimension.unit === '%' ?\n        height * dimension.value / 100 | 0 : dimension.unit === 'px' ? dimension.value : 0\n};\n\nexport function computeImageArea(inputWidth: number, inputHeight: number, area: AreaConfig) {\n    const context = { width: inputWidth, height: inputHeight };\n    const parsedArea: {\n        bottom?: number;\n        left?: number;\n        right?: number;\n        top?: number;\n    } = Object.keys(area).reduce((result, key) => {\n        const value = area[key];\n        const parsed = _parseCssDimensionValues(value);\n        const calculated = _dimensionsConverters[key](parsed, context);\n\n        result[key] = calculated;\n        return result;\n    }, {});\n\n    return {\n        topLeft: { x: parsedArea.left, y: parsedArea.top },\n        width: parsedArea.right - parsedArea.left,\n        height: parsedArea.bottom - parsedArea.top\n    };\n}\n","import { Point } from '../common/point';\nimport { ImageInfo } from './image-loader';\nimport { InputStreamConfig } from './input-stream-config';\n\nexport abstract class InputStream {\n    protected _calculatedHeight: number;\n    protected _calculatedWidth: number;\n    protected _canvasHeight: number;\n    protected _canvasWidth: number;\n    protected _config: InputStreamConfig;\n    protected _eventNames: Array<string>;\n    protected _eventHandlers: Map<string, Array<EventListener>>;\n    protected _topLeft: Point;\n\n    constructor() {\n        this._canvasWidth = 0;\n        this._canvasHeight = 0;\n        this._config = null;\n        this._eventNames = ['canrecord', 'ended'];\n        this._eventHandlers = new Map<string, Array<EventListener>>();\n        this._topLeft = { x: 0, y: 0 };\n    }\n\n    abstract get realHeight(): number;\n\n    abstract get realWidth(): number;\n\n    get height(): number {\n        return this._calculatedHeight;\n    }\n\n    set height(height: number) {\n        this._calculatedHeight = height;\n    }\n\n    get width(): number {\n        return this._calculatedWidth;\n    }\n\n    set width(width: number) {\n        this._calculatedWidth = width;\n    }\n\n    get topLeft(): Point {\n        return { ...this._topLeft };\n    }\n\n    set topLeft(topLeft: Point) {\n        this._topLeft.x = topLeft.x;\n        this._topLeft.y = topLeft.y;\n    }\n\n    setCanvasSize(width: number, height: number): void {\n        this._canvasWidth = width;\n        this._canvasHeight = height;\n    }\n\n    get canvasHeight(): number {\n        return this._canvasHeight;\n    }\n\n    get canvasWidth(): number {\n        return this._canvasWidth;\n    }\n\n    abstract get config(): InputStreamConfig;\n\n    abstract set config(config: InputStreamConfig);\n\n    abstract get ended(): boolean;\n\n    abstract setAttribute(name: string, value: string): void;\n\n    abstract pause(): void;\n\n    abstract play(): void;\n\n    abstract set currentTime(time: number);\n\n    addEventListener(event: string, listener: EventListener, _options?: boolean): void {\n        if (this._eventNames.indexOf(event) !== -1) {\n            if (!this._eventHandlers.has(event)) {\n                this._eventHandlers.set(event, new Array<EventListener>());\n            }\n            this._eventHandlers.get(event).push(listener);\n        }\n    }\n\n    clearEventHandlers(): void {\n        this._eventHandlers.clear();\n    }\n\n    trigger(eventName: string, argArray?: any) {\n        const handlers = this._eventHandlers.get(eventName);\n\n        if (handlers) {\n            handlers.forEach(handler => handler.apply(this, argArray));\n        }\n    }\n\n    abstract getFrame(): HTMLVideoElement | ImageInfo;\n}\n","import { VideoStream } from './video-stream';\n\nexport class LiveStream extends VideoStream {\n    constructor(video: HTMLVideoElement) {\n        video.setAttribute('autoplay', '');\n        super(video);\n    }\n\n    get ended(): boolean {\n        return false;\n    }\n}\n","import { ImageInfo } from './image-loader';\nimport { InputStream } from './input-stream';\nimport { InputStreamConfig } from './input-stream-config';\n\nexport class VideoStream extends InputStream {\n    private _video: HTMLVideoElement;\n\n    constructor(video: HTMLVideoElement) {\n        super();\n\n        this._video = video;\n    }\n\n    get realHeight(): number {\n        return this._video.videoHeight;\n    }\n\n    get realWidth(): number {\n        return this._video.videoWidth;\n    }\n\n    get config(): InputStreamConfig {\n        return this._config;\n    }\n\n    set config(config: InputStreamConfig) {\n        this._config = { ...config };\n        this._video.src = config.src || '';\n    }\n\n    get ended(): boolean {\n        return this._video.ended;\n    }\n\n    setAttribute(name: string, value: string): void {\n        this._video.setAttribute(name, value);\n    }\n\n    pause(): void {\n        this._video.pause();\n    }\n\n    play(): void {\n        this._video.play();\n    }\n\n    set currentTime(time: number) {\n        if (this._config.type !== 'LiveStream') {\n            this._video.currentTime = time;\n        }\n    }\n\n    addEventListener(event: string, listener: EventListener, options?: boolean): void {\n        super.addEventListener(event, listener, options);\n\n        if (this._eventNames.indexOf(event) === -1) {\n            this._video.addEventListener(event, listener, options);\n        }\n    }\n\n    clearEventHandlers(): void {\n        // TODO: come up with a way to remove video event handlers\n        // this._eventNames.forEach(eventName => {\n        //     const handlers = this._eventHandlers.get(eventName);\n        //     if (handlers && handlers.length > 0) {\n        //         handlers.forEach(handler => this._video.removeEventListener(eventName, handler));\n        //     }\n        // });\n        super.clearEventHandlers();\n    }\n\n    trigger(eventName: string, argArray?: any) {\n        if (eventName === 'canrecord') {\n            this._initSize();\n        }\n\n        super.trigger(eventName, argArray)\n    }\n\n    getFrame(): HTMLVideoElement | ImageInfo {\n        return this._video;\n    }\n\n    private _initSize() {\n        const width = this._video.videoWidth;\n        const height = this._video.videoHeight;\n\n        this._canvasWidth = this._calculatedWidth =\n            this._config.size ? width > height ? this._config.size : width * this._config.size / height | 0 : width;\n        this._canvasHeight = this._calculatedHeight =\n            this._config.size ? width > height ? height * this._config.size / width | 0 : this._config.size : height;\n    }\n}\n\nexport class LiveStream extends VideoStream {\n    constructor(video: HTMLVideoElement) {\n        video.setAttribute('autoplay', '');\n        super(video);\n    }\n\n    get ended(): boolean {\n        return false;\n    }\n}\n","import { ImageWrapper } from '../common/image-wrapper';\nimport { Point } from '../common/point';\n\n/**\n * Invert matrix\n * @param matrix the matrix to invert\n * @returns the inverted matrix\n */\nexport function invert(matrix: Float32Array): Float32Array {\n    const a0 = matrix[0];\n    const a1 = matrix[1];\n    const a2 = matrix[2];\n    const a3 = matrix[3];\n    const determinant = a0 * a3 - a2 * a1;\n\n    if (!determinant) {\n        return null;\n    }\n\n    return new Float32Array([a3 / determinant, -a1 / determinant, -a2 / determinant, a0 / determinant]);\n}\n\n/**\n * Transforms the vector with a matrix\n * @param { x, y } vector to transform\n * @param matrix matrix to transform with\n * @returns the transformed vector\n */\nexport function transformWithMatrix({ x, y }: Point, matrix: Float32Array): Point {\n    return {\n        x: matrix[0] * x + matrix[2] * y,\n        y: matrix[1] * x + matrix[3] * y\n    };\n}\n\nfunction _computeHistogram(imageWrapper: ImageWrapper, bitsPerPixel: number): Int32Array {\n    if (!bitsPerPixel) {\n        bitsPerPixel = 8;\n    }\n\n    const imageData = imageWrapper.data;\n    const bitShift = 8 - bitsPerPixel;\n    const bucketCount = 1 << bitsPerPixel;\n    const histogram = new Int32Array(bucketCount);\n\n    for (let i = imageData.length; i--;) {\n        histogram[imageData[i] >> bitShift]++;\n    }\n\n    return histogram;\n}\n\nfunction _determineOtsuThreshold(imageWrapper: ImageWrapper, bitsPerPixel?: number): number {\n    if (!bitsPerPixel) {\n        bitsPerPixel = 8;\n    }\n\n    const bitShift = 8 - bitsPerPixel;\n    const hist = _computeHistogram(imageWrapper, bitsPerPixel);\n    const vet = [0];\n    const max = (1 << bitsPerPixel) - 1;\n\n    function px(init: number, end: number): number {\n        let sum = 0;\n\n        for (let i = init; i <= end; i++) {\n            sum += hist[i];\n        }\n\n        return sum;\n    }\n\n    function mx(init: number, end: number): number {\n        let sum = 0;\n\n        for (let i = init; i <= end; i++) {\n            sum += i * hist[i];\n        }\n\n        return sum;\n    }\n\n    for (let k = 1; k < max; k++) {\n        const p1 = px(0, k);\n        const p2 = px(k + 1, max);\n        const p12 = p1 * p2 || 1;\n        const m1 = mx(0, k) * p2;\n        const m2 = mx(k + 1, max) * p1;\n        const m12 = m1 - m2;\n        vet[k] = m12 * m12 / p12;\n    }\n\n    // index of max element\n    const threshold = vet.reduce((maxIndex, item, index, array) => item > array[maxIndex] ? index : maxIndex, 0);\n\n    return threshold << bitShift;\n}\n\nexport function otsuThreshold(imageWrapper: ImageWrapper, targetWrapper: ImageWrapper): number {\n    const threshold = _determineOtsuThreshold(imageWrapper);\n    const targetData = targetWrapper.data;\n\n    imageWrapper.data.forEach((value, index) => {\n        targetData[index] = value < threshold ? 1 : 0;\n    });\n\n    return threshold;\n}\n\n/**\n * @param imageWrapper input image to be sampled\n * @param outImageWrapper {ImageWrapper} to be stored in\n */\nexport function halfSample(imageWrapper: ImageWrapper, outImageWrapper: ImageWrapper): void {\n    const image = imageWrapper.data;\n    const width = imageWrapper.size.x;\n    const outImage = outImageWrapper.data;\n    const endIndex = image.length;\n    const outWidth = width >> 1;\n    let topRowIndex = 0;\n    let bottomRowIndex = width;\n    let outImgIndex = 0;\n\n    while (bottomRowIndex < endIndex) {\n        for (let i = 0; i < outWidth; i++) {\n            outImage[outImgIndex] =\n                (image[topRowIndex] + image[topRowIndex + 1] + image[bottomRowIndex] + image[bottomRowIndex + 1]) >> 2;\n            outImgIndex++;\n            topRowIndex += 2;\n            bottomRowIndex += 2;\n        }\n        topRowIndex += width;\n        bottomRowIndex += width;\n    }\n}\n","import { Box } from '../common/box';\nimport { Cluster } from '../common/cluster';\nimport { HSV, hsv2rgb, RGB } from '../common/hsv2rgb';\nimport { ImageDebug } from '../common/image-debug';\nimport { ImageWrapper } from '../common/image-wrapper';\nimport { Moment } from '../common/moment';\nimport { Point } from '../common/point';\nimport { calculatePatchSize } from '../input/input-stream-utils';\nimport { BarcodeLocatorConfig } from './barcode-locator-config';\nimport { halfSample, invert, otsuThreshold, transformWithMatrix } from './barcode-locator-utils';\nimport { Rasterizer } from './rasterizer';\nimport skeletonizer from './skeletonizer';\nimport { SearchDirections } from './tracer';\n\ninterface Patch {\n    box: Box;\n    index: number;\n    moments: Array<Moment>;\n    pos: Point;\n    rad: number;\n    x: number;\n    y: number;\n}\n\ntype Sceletonizer = any;\n\nconst MomentSimilarityThreshold = 0.9;\n\nexport class BarcodeLocator {\n    private _config: BarcodeLocatorConfig;\n    private _inputImageWrapper: ImageWrapper;\n    private _currentImageWrapper: ImageWrapper;\n    private _skelImageWrapper: ImageWrapper;\n    private _subImageWrapper: ImageWrapper;\n    private _labelImageWrapper: ImageWrapper<Array<number>>;\n    private _binaryImageWrapper: ImageWrapper;\n    private _patchGrid: ImageWrapper;\n    private _patchLabelGrid: ImageWrapper<Int32Array>;\n    private _imageToPatchGrid: Array<Patch>;\n    private _patchSize: Point;\n    private _binaryContext: CanvasRenderingContext2D;\n    private _numPatches: Point;\n    private _skeletonizer: Sceletonizer;\n\n    constructor(inputImageWrapper: ImageWrapper, config: BarcodeLocatorConfig) {\n        this._config = config;\n        this._inputImageWrapper = inputImageWrapper;\n        this._numPatches = { x: 0, y: 0 };\n\n        this._initBuffers();\n        this._initCanvas();\n    }\n\n    locate() {\n        if (this._config.halfSample) {\n            halfSample(this._inputImageWrapper, this._currentImageWrapper);\n        }\n\n        this._binarizeImage();\n        const patchesFound = this._findPatches();\n        // return unless 5% or more patches are found\n        if (patchesFound.length < this._numPatches.x * this._numPatches.y * 0.05) {\n            return null;\n        }\n\n        // rasterize area by comparing angular similarity;\n        const maxLabel = this._rasterizeAngularSimilarity(patchesFound);\n        if (maxLabel < 1) {\n            return null;\n        }\n\n        // search for area with the most patches (biggest connected area)\n        const topLabels = this._findBiggestConnectedAreas(maxLabel);\n        if (topLabels.length === 0) {\n            return null;\n        }\n\n        const boxes = this._findBoxes(topLabels, maxLabel);\n        return boxes;\n    }\n\n    private _initBuffers(): void {\n        if (this._config.halfSample) {\n            this._currentImageWrapper = new ImageWrapper({\n                x: this._inputImageWrapper.size.x / 2 | 0,\n                y: this._inputImageWrapper.size.y / 2 | 0\n            });\n        } else {\n            this._currentImageWrapper = this._inputImageWrapper;\n        }\n\n        this._patchSize = calculatePatchSize(this._config.patchSize, this._currentImageWrapper.size);\n\n        this._numPatches.x = this._currentImageWrapper.size.x / this._patchSize.x | 0;\n        this._numPatches.y = this._currentImageWrapper.size.y / this._patchSize.y | 0;\n\n        this._binaryImageWrapper = new ImageWrapper(this._currentImageWrapper.size, undefined, Uint8Array, false);\n\n        this._labelImageWrapper = new ImageWrapper(this._patchSize, undefined, Array, true);\n\n        const skeletonImageData = new ArrayBuffer(64 * 1024);\n        this._subImageWrapper = new ImageWrapper(this._patchSize, new Uint8Array(skeletonImageData, 0, this._patchSize.x * this._patchSize.y));\n        this._skelImageWrapper = new ImageWrapper(this._patchSize,\n            new Uint8Array(skeletonImageData, this._patchSize.x * this._patchSize.y * 3, this._patchSize.x * this._patchSize.y),\n            undefined, true);\n        this._skeletonizer = skeletonizer(\n            (typeof window !== 'undefined') ? window : (typeof self !== 'undefined') ? self : global,\n            { size: this._patchSize.x },\n            skeletonImageData\n        );\n\n        const size = {\n            x: (this._currentImageWrapper.size.x / this._subImageWrapper.size.x) | 0,\n            y: (this._currentImageWrapper.size.y / this._subImageWrapper.size.y) | 0\n        };\n        this._patchLabelGrid = new ImageWrapper(size, undefined, Int32Array, true);\n        this._patchGrid = new ImageWrapper(size, undefined, undefined, true);\n        this._imageToPatchGrid = new Array<Patch>(this._patchLabelGrid.data.length);\n    }\n\n    private _initCanvas() {\n        if (this._config.useWorker || typeof document === 'undefined') {\n            return;\n        }\n\n        const canvas = document.createElement('canvas');\n        canvas.className = 'binaryBuffer';\n        canvas.width = this._binaryImageWrapper.size.x;\n        canvas.height = this._binaryImageWrapper.size.y;\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && this._config.debug.showCanvas) {\n            document.querySelector('#debug').appendChild(canvas);\n        }\n        this._binaryContext = canvas.getContext('2d');\n    }\n\n    /**\n     * Creates a bounding box which encloses all the given patches\n     * @returns The minimal bounding box\n     */\n    private _boxFromPatches(patches: Array<Patch>): Box {\n        const debug = process.env.NODE_ENV !== 'production' && this._config.debug;\n        let averageRad = patches.reduce((sum, { pos, rad }) => {\n            if (debug && debug.showPatches) {\n                // draw all patches which are to be taken into consideration\n                this._drawRect(pos, this._subImageWrapper.size, 'red', 1);\n            }\n\n            return sum + rad;\n        }, 0) / patches.length;\n\n        averageRad = (averageRad * 180 / Math.PI + 90) % 180 - 90;\n        if (averageRad < 0) {\n            averageRad += 180;\n        }\n        averageRad = (180 - averageRad) * Math.PI / 180;\n\n        const cos = Math.cos(averageRad);\n        const sin = Math.sin(averageRad);\n        const matrix = new Float32Array([cos, sin, -sin, cos]);\n        const inverseMatrix = invert(matrix);\n\n        // iterate over patches and rotate by angle\n        patches.forEach(({ box }) => {\n            for (let j = 0; j < 4; j++) {\n                box[j] = transformWithMatrix(box[j], matrix);\n            }\n\n            if (debug && debug.boxFromPatches.showTransformed) {\n                this._drawPath(box, '#99ff00', 2);\n            }\n        });\n\n        let minX = this._binaryImageWrapper.size.x;\n        let minY = this._binaryImageWrapper.size.y;\n        let maxX = -minX;\n        let maxY = -minY;\n\n        // find bounding box\n        patches.forEach(({ box }) => {\n            box.forEach(({ x, y }) => {\n                if (x < minX) {\n                    minX = x;\n                }\n                if (x > maxX) {\n                    maxX = x;\n                }\n                if (y < minY) {\n                    minY = y;\n                }\n                if (y > maxY) {\n                    maxY = y;\n                }\n            });\n        });\n\n        let box: Box = [{ x: minX, y: minY }, { x: maxX, y: minY }, { x: maxX, y: maxY }, { x: minX, y: maxY }];\n\n        if (debug && debug.boxFromPatches.showTransformedBox) {\n            this._drawPath(box, '#ff0000', 2);\n        }\n\n        // reverse rotation\n        box = box.map(vertex => transformWithMatrix(vertex, inverseMatrix)) as Box;\n\n        if (debug && debug.boxFromPatches.showBB) {\n            this._drawPath(box, '#ff0000', 2);\n        }\n\n        if (this._config.halfSample) {\n            // scale\n            box = box.map(({ x, y }) => ({ x: x * 2, y: y *= 2 })) as Box;\n        }\n\n        return box;\n    }\n\n    /**\n     * Creates a binary image of the current image\n     */\n    private _binarizeImage(): void {\n        otsuThreshold(this._currentImageWrapper, this._binaryImageWrapper);\n        this._binaryImageWrapper.zeroBorder();\n\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && this._config.debug.showCanvas) {\n            this._binaryImageWrapper.show(this._binaryContext, 255);\n        }\n    }\n\n    /**\n     * Iterate over the entire image, extract patches\n     */\n    private _findPatches(): Array<Patch> {\n        const debug = process.env.NODE_ENV !== 'production' && this._config.debug;\n        let patchesFound = new Array<Patch>();\n\n        for (let i = 0; i < this._numPatches.x; i++) {\n            for (let j = 0; j < this._numPatches.y; j++) {\n                const x = this._subImageWrapper.size.x * i;\n                const y = this._subImageWrapper.size.y * j;\n\n                // seperate parts\n                this._skeletonize(x, y);\n\n                // Rasterize, find individual bars\n                this._skelImageWrapper.zeroBorder();\n                this._labelImageWrapper.data.fill(0);\n                const rasterizer = new Rasterizer(this._skelImageWrapper, this._labelImageWrapper);\n                const rasterResult = rasterizer.rasterize(0);\n\n                if (debug && debug.showLabels) {\n                    this._labelImageWrapper.overlay(this._binaryContext, 360 / rasterResult.count | 0, x, y);\n                }\n\n                // calculate moments from the skeletonized patch\n                const moments = this._labelImageWrapper.moments(rasterResult.count);\n\n                // extract eligible patches\n                const patch = this._describePatch(moments, j * this._numPatches.x + i, x, y);\n                if (patch) {\n                    patchesFound.push(patch);\n\n                    if (debug && debug.showFoundPatches) {\n                        this._drawRect(patch.pos, this._subImageWrapper.size, '#99ff00', 2);\n                    }\n                }\n            }\n        }\n\n        return patchesFound;\n    }\n\n    /**\n     * Finds those connected areas which contain at least 6 patches\n     * and returns them ordered DESC by the number of contained patches\n     * @param maxLabel\n     */\n    private _findBiggestConnectedAreas(maxLabel: number): Array<number> {\n        let labelHist = new Array<number>(maxLabel).fill(0);\n\n        this._patchLabelGrid.data.forEach((data: number) => {\n            if (data > 0) {\n                labelHist[data - 1]++;\n            }\n        });\n\n        // extract top areas with at least 6 patches present\n        const topLabels = labelHist.map((value, index) => ({ value, index }))\n            .filter(({ value }) => value >= 5).sort((a, b) => b.value - a.value).map(({ index }) => index + 1);\n\n        return topLabels;\n    }\n\n    /**\n     *\n     */\n    private _findBoxes(topLabels: Array<number>, maxLabel: number): Array<Box> {\n        const boxes = new Array<Box>();\n        const showRemainingPatchLabels = process.env.NODE_ENV !== 'production' &&\n            this._config.debug && this._config.debug.showRemainingPatchLabels;\n\n        topLabels.forEach(label => {\n            const patches = new Array<Patch>();\n\n            this._patchLabelGrid.data.forEach((data: number, index: number) => {\n                if (data === label) {\n                    patches.push(this._imageToPatchGrid[index]);\n                }\n            });\n\n            const box = this._boxFromPatches(patches);\n\n            if (box) {\n                boxes.push(box);\n\n                if (showRemainingPatchLabels) {\n                    // draw patch-labels if requested\n                    const hsv: HSV = [(label / (maxLabel + 1)) * 360, 1, 1];\n                    const rgb: RGB = [0, 0, 0];\n                    hsv2rgb(hsv, rgb);\n\n                    const color = `rgb(${rgb.join(',')})`;\n\n                    patches.forEach(({ pos }) => this._drawRect(pos, this._subImageWrapper.size, color, 2));\n                }\n            }\n        });\n\n        return boxes;\n    }\n\n    /**\n     * Find similar moments (via cluster)\n     * @param moments\n     */\n    private _similarMoments(moments: Array<Moment>): Array<Moment> {\n        const clusters = Cluster.clusterize(moments, MomentSimilarityThreshold);\n        const topCluster = clusters.reduce((top, item) => {\n            const count = item.moments.length;\n            return count > top.count ? { item, count } : top;\n        }, { item: { moments: [] }, count: 0 });\n        const result = topCluster.item.moments;\n\n        return result;\n    }\n\n    private _skeletonize(x: number, y: number): void {\n        this._binaryImageWrapper.subImageAsCopy(this._subImageWrapper, x, y);\n        this._skeletonizer.skeletonize();\n\n        // Show skeleton if requested\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && this._config.debug.showSkeleton) {\n            this._skelImageWrapper.overlay(this._binaryContext, 360, x, y);\n        }\n    }\n\n    /**\n     * Extracts and describes those patches which seem to contain a barcode pattern\n     * @param moments\n     * @param index\n     * @param x\n     * @param y\n     * @returns list of patches\n     */\n    private _describePatch(moments: Array<Moment>, index: number, x: number, y: number): Patch {\n        if (moments.length > 1) {\n            const minComponentWeight = Math.ceil(this._patchSize.x / 3);\n            // only collect moments which area covers at least minComponentWeight pixels\n            const eligibleMoments = moments.filter(moment => moment.m00 > minComponentWeight);\n\n            // if at least 2 moments are found which have at least minComponentWeights covered\n            if (eligibleMoments.length > 1) {\n                const matchingMoments = this._similarMoments(eligibleMoments);\n                const length = matchingMoments.length | 0;\n\n                // Only two of the moments are allowed not to fit into the equation\n                if (length > 1 && (length << 2) >= eligibleMoments.length * 3 && (length << 2) > moments.length) {\n                    // determine the similarity of the moments\n                    const rad = matchingMoments.reduce((sum: number, moment: Moment) => sum + moment.rad, 0) / length;\n\n                    return {\n                        index,\n                        pos: { x, y },\n                        box: [\n                            { x, y },\n                            { x: x + this._subImageWrapper.size.x, y },\n                            { x: x + this._subImageWrapper.size.x, y: y + this._subImageWrapper.size.y },\n                            { x, y: y + this._subImageWrapper.size.y }\n                        ],\n                        moments: matchingMoments,\n                        rad,\n                        x: Math.cos(rad),\n                        y: Math.sin(rad)\n                    };\n                }\n            }\n        }\n\n        return null;\n    }\n\n    private _notYetProcessed(): number {\n        for (let i = 0; i < this._patchLabelGrid.data.length; i++) {\n            if (this._patchLabelGrid.data[i] === 0 && this._patchGrid.data[i] === 1) {\n                return i;\n            }\n        }\n        return this._patchLabelGrid.data.length;\n    }\n\n    private _trace(currentIndex: number, label: number): void {\n        const threshold = 0.95;\n        const current: Point = {\n            x: currentIndex % this._patchLabelGrid.size.x,\n            y: (currentIndex / this._patchLabelGrid.size.x) | 0\n        };\n\n        if (currentIndex < this._patchLabelGrid.data.length) {\n            const currentPatch = this._imageToPatchGrid[currentIndex];\n            // assign label\n            this._patchLabelGrid.data[currentIndex] = label;\n\n            SearchDirections.forEach(direction => {\n                const y = current.y + direction[0];\n                const x = current.x + direction[1];\n                const index = y * this._patchLabelGrid.size.x + x;\n\n                // continue if patch empty\n                if (this._patchGrid.data[index] === 0) {\n                    this._patchLabelGrid.data[index] = Number.MAX_VALUE;\n                } else if (this._patchLabelGrid.data[index] === 0) {\n                    const patch = this._imageToPatchGrid[index];\n                    const similarity = Math.abs(patch.x * currentPatch.x + patch.y * currentPatch.y);\n                    if (similarity > threshold) {\n                        this._trace(index, label);\n                    }\n                }\n            });\n        }\n    }\n\n    /**\n     * Finds patches which are connected and share the same orientation\n     * @param patchesFound\n     */\n    private _rasterizeAngularSimilarity(patchesFound: Array<Patch>): number {\n        let label = 0;\n        const hsv: HSV = [0, 1, 1];\n        const rgb: RGB = [0, 0, 0];\n\n        // prepare for finding the right patches\n        this._patchGrid.data.fill(0);\n        this._patchLabelGrid.data.fill(0);\n        this._imageToPatchGrid.fill(null);\n\n        patchesFound.forEach(patch => {\n            this._imageToPatchGrid[patch.index] = patch;\n            this._patchGrid.data[patch.index] = 1;\n        });\n\n        // rasterize the patches found to determine area\n        this._patchGrid.zeroBorder();\n\n        let currentIndex = 0;\n        while ((currentIndex = this._notYetProcessed()) < this._patchLabelGrid.data.length) {\n            label++;\n            this._trace(currentIndex, label);\n        }\n\n        // draw patch-labels if requested\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && this._config.debug.showPatchLabels) {\n            for (let j = 0; j < this._patchLabelGrid.data.length; j++) {\n                if (this._patchLabelGrid.data[j] > 0 && this._patchLabelGrid.data[j] <= label) {\n                    const patch = this._imageToPatchGrid[j];\n                    hsv[0] = (this._patchLabelGrid.data[j] / (label + 1)) * 360;\n                    hsv2rgb(hsv, rgb);\n                    this._drawRect(patch.pos, this._subImageWrapper.size, `rgb(${rgb.join(',')})`, 2);\n                }\n            }\n        }\n\n        return label;\n    }\n\n    private _drawRect({ x, y }: Point, size: Point, color: string, lineWidth: number): void {\n        this._binaryContext.strokeStyle = color;\n        this._binaryContext.fillStyle = color;\n        this._binaryContext.lineWidth = lineWidth || 1;\n        this._binaryContext.strokeRect(x, y, size.x, size.y);\n    }\n\n    private _drawPath(path: Array<Point>, color: string, lineWidth: number): void {\n        ImageDebug.drawPath(path, this._binaryContext, color, lineWidth);\n    }\n}\n","/**\n * @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization\n */\n\nimport { ImageWrapper } from '../common/image-wrapper';\nimport { ContourVertex, Tracer } from './tracer';\n\nenum EdgeLabel {\n    Outside = -32767,\n    Inside = -32766\n};\n\nenum ContourDirection {\n    CW = 0,\n    CCW = 1,\n    Unknown = 2\n};\n\ninterface Contour {\n    dir: ContourDirection;\n    index: number;\n    firstVertex: ContourVertex;\n    previousPeer?: Contour;\n    nextPeer?: Contour;\n    insideContours: Contour;\n}\n\nexport interface RasterResult {\n    cc: Contour;\n    count: number;\n}\n\nexport class Rasterizer {\n    private _width: number;\n    private _height: number;\n    private _tracer: Tracer;\n    private _imageData: Uint8Array;\n    private _labelData: Array<number>;\n\n    constructor(imageWrapper: ImageWrapper<Uint8Array>, labelWrapper: ImageWrapper<Array<number>>) {\n        this._imageData = imageWrapper.data;\n        this._labelData = labelWrapper.data as Array<number>;\n        this._width = imageWrapper.size.x;\n        this._height = imageWrapper.size.y;\n        this._tracer = new Tracer(imageWrapper, labelWrapper);\n    }\n\n    rasterize(depthLabel: number): RasterResult {\n        const colorMap = new Array<number>();\n\n        for (let i = 0; i < 400; i++) {\n            colorMap[i] = 0;\n        }\n\n        colorMap[0] = this._imageData[0];\n\n        let cc: Contour = null;\n        let sc: Contour;\n        let connectedCount = 0;\n\n        for (let cy = 1; cy < this._height - 1; cy++) {\n            let labelIndex = 0;\n            let bc = colorMap[0];\n\n            for (let cx = 1; cx < this._width - 1; cx++) {\n                const pos = cy * this._width + cx;\n\n                if (this._labelData[pos] === 0) {\n                    const color = this._imageData[pos];\n                    if (color !== bc) {\n                        if (labelIndex === 0) {\n                            const lc = connectedCount + 1;\n                            colorMap[lc] = color;\n                            bc = color;\n                            const vertex = this._tracer.contourTracing(cy, cx, lc, color, EdgeLabel.Outside);\n                            if (vertex !== null) {\n                                connectedCount++;\n                                labelIndex = lc;\n                                const p: Contour = {\n                                    dir: ContourDirection.CW,\n                                    index: labelIndex,\n                                    firstVertex: vertex,\n                                    nextPeer: cc,\n                                    insideContours: null\n                                };\n                                if (cc !== null) {\n                                    cc.previousPeer = p;\n                                }\n                                cc = p;\n                            }\n                        } else {\n                            const vertex = this._tracer.contourTracing(cy, cx, EdgeLabel.Inside, color, labelIndex);\n                            if (vertex !== null) {\n                                const p: Contour = {\n                                    dir: depthLabel === 0 ? ContourDirection.CCW : ContourDirection.CW,\n                                    firstVertex: vertex,\n                                    index: depthLabel,\n                                    insideContours: null\n                                };\n                                sc = cc;\n                                while ((sc !== null) && sc.index !== labelIndex) {\n                                    sc = sc.nextPeer;\n                                }\n                                if (sc !== null) {\n                                    p.nextPeer = sc.insideContours;\n                                    if (sc.insideContours !== null) {\n                                        sc.insideContours.previousPeer = p;\n                                    }\n                                    sc.insideContours = p;\n                                }\n                            }\n                        }\n                    } else {\n                        this._labelData[pos] = labelIndex;\n                    }\n                } else if (this._labelData[pos] === EdgeLabel.Inside) {\n                    labelIndex = 0;\n                    bc = this._imageData[pos];\n                } else if (this._labelData[pos] === EdgeLabel.Outside) {\n                    labelIndex = 0;\n                    bc = colorMap[0];\n                } else {\n                    labelIndex = this._labelData[pos];\n                    bc = colorMap[labelIndex];\n                }\n            }\n        }\n\n        sc = cc;\n        while (sc !== null) {\n            sc.index = depthLabel;\n            sc = sc.nextPeer;\n        }\n\n        return {\n            cc,\n            count: connectedCount\n        };\n    }\n\n    drawContour(canvas: HTMLCanvasElement, firstContour: Contour): void {\n        const context = canvas.getContext('2d');\n\n        context.strokeStyle = 'red';\n        context.fillStyle = 'red';\n        context.lineWidth = 1;\n\n        let pq = firstContour;\n        let iq = pq && pq.insideContours;\n\n        while (pq !== null) {\n            let q = iq || pq;\n\n            if (iq !== null) {\n                iq = iq.nextPeer;\n            } else {\n                pq = pq.nextPeer;\n                iq = pq && pq.insideContours;\n            }\n\n            switch (q.dir) {\n                case ContourDirection.CW: {\n                    context.strokeStyle = 'red';\n                    break;\n                }\n                case ContourDirection.CCW: {\n                    context.strokeStyle = 'blue';\n                    break;\n                }\n                case ContourDirection.Unknown: {\n                    context.strokeStyle = 'green';\n                    break;\n                }\n            }\n\n            let p = q.firstVertex;\n            context.beginPath();\n            context.moveTo(p.x, p.y);\n\n            do {\n                p = p.next;\n                context.lineTo(p.x, p.y);\n            } while (p !== q.firstVertex);\n\n            context.stroke();\n        }\n    }\n}\n","/* eslint-disable eqeqeq */\nfunction Skeletonizer(stdlib, foreign, buffer) {\n    \"use asm\";\n\n    var images = new stdlib.Uint8Array(buffer),\n        size = foreign.size | 0,\n        imul = stdlib.Math.imul;\n\n    function erode(inImagePtr, outImagePtr) {\n        inImagePtr = inImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var v = 0,\n            u = 0,\n            sum = 0,\n            yStart1 = 0,\n            yStart2 = 0,\n            xStart1 = 0,\n            xStart2 = 0,\n            offset = 0;\n\n        for (v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) {\n            offset = (offset + size) | 0;\n            for (u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) {\n                yStart1 = (offset - size) | 0;\n                yStart2 = (offset + size) | 0;\n                xStart1 = (u - 1) | 0;\n                xStart2 = (u + 1) | 0;\n                sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0)\n                    + (images[(inImagePtr + offset + u) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0;\n                if ((sum | 0) == (5 | 0)) {\n                    images[(outImagePtr + offset + u) | 0] = 1;\n                } else {\n                    images[(outImagePtr + offset + u) | 0] = 0;\n                }\n            }\n        }\n        return;\n    }\n\n    function subtract(aImagePtr, bImagePtr, outImagePtr) {\n        aImagePtr = aImagePtr | 0;\n        bImagePtr = bImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(outImagePtr + length) | 0] =\n                ((images[(aImagePtr + length) | 0] | 0) - (images[(bImagePtr + length) | 0] | 0)) | 0;\n        }\n    }\n\n    function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) {\n        aImagePtr = aImagePtr | 0;\n        bImagePtr = bImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(outImagePtr + length) | 0] =\n                ((images[(aImagePtr + length) | 0] | 0) | (images[(bImagePtr + length) | 0] | 0)) | 0;\n        }\n    }\n\n    function countNonZero(imagePtr) {\n        imagePtr = imagePtr | 0;\n\n        var sum = 0,\n            length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            sum = ((sum | 0) + (images[(imagePtr + length) | 0] | 0)) | 0;\n        }\n\n        return (sum | 0);\n    }\n\n    function init(imagePtr, value) {\n        imagePtr = imagePtr | 0;\n        value = value | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(imagePtr + length) | 0] = value;\n        }\n    }\n\n    function dilate(inImagePtr, outImagePtr) {\n        inImagePtr = inImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var v = 0,\n            u = 0,\n            sum = 0,\n            yStart1 = 0,\n            yStart2 = 0,\n            xStart1 = 0,\n            xStart2 = 0,\n            offset = 0;\n\n        for (v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) {\n            offset = (offset + size) | 0;\n            for (u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) {\n                yStart1 = (offset - size) | 0;\n                yStart2 = (offset + size) | 0;\n                xStart1 = (u - 1) | 0;\n                xStart2 = (u + 1) | 0;\n                sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0)\n                    + (images[(inImagePtr + offset + u) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0;\n                if ((sum | 0) > (0 | 0)) {\n                    images[(outImagePtr + offset + u) | 0] = 1;\n                } else {\n                    images[(outImagePtr + offset + u) | 0] = 0;\n                }\n            }\n        }\n        return;\n    }\n\n    function memcpy(srcImagePtr, dstImagePtr) {\n        srcImagePtr = srcImagePtr | 0;\n        dstImagePtr = dstImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(dstImagePtr + length) | 0] = (images[(srcImagePtr + length) | 0] | 0);\n        }\n    }\n\n    function zeroBorder(imagePtr) {\n        imagePtr = imagePtr | 0;\n\n        var x = 0,\n            y = 0;\n\n        for (x = 0; (x | 0) < ((size - 1) | 0); x = (x + 1) | 0) {\n            images[(imagePtr + x) | 0] = 0;\n            images[(imagePtr + y) | 0] = 0;\n            y = ((y + size) - 1) | 0;\n            images[(imagePtr + y) | 0] = 0;\n            y = (y + 1) | 0;\n        }\n        for (x = 0; (x | 0) < (size | 0); x = (x + 1) | 0) {\n            images[(imagePtr + y) | 0] = 0;\n            y = (y + 1) | 0;\n        }\n    }\n\n    function skeletonize() {\n        var subImagePtr = 0,\n            erodedImagePtr = 0,\n            tempImagePtr = 0,\n            skelImagePtr = 0,\n            sum = 0,\n            done = 0;\n\n        erodedImagePtr = imul(size, size) | 0;\n        tempImagePtr = (erodedImagePtr + erodedImagePtr) | 0;\n        skelImagePtr = (tempImagePtr + erodedImagePtr) | 0;\n\n        // init skel-image\n        init(skelImagePtr, 0);\n        zeroBorder(subImagePtr);\n\n        do {\n            erode(subImagePtr, erodedImagePtr);\n            dilate(erodedImagePtr, tempImagePtr);\n            subtract(subImagePtr, tempImagePtr, tempImagePtr);\n            bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr);\n            memcpy(erodedImagePtr, subImagePtr);\n            sum = countNonZero(subImagePtr) | 0;\n            done = ((sum | 0) == 0 | 0);\n        } while (!done);\n    }\n\n    return {\n        skeletonize: skeletonize\n    };\n}\nexport default Skeletonizer;\n/* eslint-enable eqeqeq */\n","import { ImageWrapper } from \"../common/image-wrapper\";\n\n/**\n * @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization\n */\n\ntype Direction = number;\n\nexport const SearchDirections: Array<Array<Direction>> = [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]];\n\nexport interface ContourVertex {\n    x: number,\n    y: number,\n    dir: Direction,\n    next: ContourVertex,\n    prev: ContourVertex\n}\n\ninterface Current {\n    cx: number,\n    cy: number,\n    dir: Direction\n}\n\nexport class Tracer {\n    private _imageData: Uint8Array;\n    private _labelData: Array<number>;\n    private _width: number;\n\n    constructor(imageWrapper: ImageWrapper, labelWrapper: ImageWrapper<Array<number>>) {\n        this._imageData = imageWrapper.data;\n        this._labelData = labelWrapper.data as Array<number>;\n        this._width = imageWrapper.size.x;\n    }\n\n    trace(current: Current, color: number, label: number, edgeLabel: number): boolean {\n        for (let i = 0; i < 7; i++) {\n            const y = current.cy + SearchDirections[current.dir][0] | 0;\n            const x = current.cx + SearchDirections[current.dir][1] | 0;\n            const pos = y * this._width + x | 0;\n\n            if ((this._imageData[pos] === color) && ((this._labelData[pos] === 0) || (this._labelData[pos] === label))) {\n                this._labelData[pos] = label;\n                current.cx = x;\n                current.cy = y;\n\n                return true;\n            } else {\n                if (this._labelData[pos] === 0) {\n                    this._labelData[pos] = edgeLabel;\n                }\n                current.dir = (current.dir + 1) % 8;\n            }\n        }\n\n        return false;\n    }\n\n    contourTracing(sy: number, sx: number, label: number, color: number, edgeLabel: number): ContourVertex {\n        let Fv: ContourVertex = null;\n        const current: Current = {\n            cx: sx,\n            cy: sy,\n            dir: 0\n        };\n\n        if (this.trace(current, color, label, edgeLabel)) {\n            Fv = {\n                x: sx,\n                y: sy,\n                dir: current.dir,\n                next: null,\n                prev: null\n            };\n            let Cv = Fv;\n            let ldir = current.dir;\n            let P = {\n                x: current.cx,\n                y: current.cy,\n                dir: 0,\n                next: null,\n                prev: Cv\n            };\n            Cv.next = P;\n            Cv = P;\n\n            do {\n                current.dir = (current.dir + 6) % 8;\n\n                this.trace(current, color, label, edgeLabel);\n\n                if (ldir !== current.dir) {\n                    Cv.dir = current.dir;\n                    P = {\n                        x: current.cx,\n                        y: current.cy,\n                        dir: 0,\n                        next: null,\n                        prev: Cv\n                    };\n                    Cv.next = P;\n                    Cv = P;\n                } else {\n                    Cv.dir = ldir;\n                    Cv.x = current.cx;\n                    Cv.y = current.cy;\n                }\n\n                ldir = current.dir;\n            } while (current.cx !== sx || current.cy !== sy);\n\n            Fv.prev = Cv.prev;\n            Cv.prev.next = Fv;\n        }\n        return Fv;\n    }\n}\n","import _polyfills from './common/polyfills';\nimport { ResultCollector } from './analytics/result-collector';\nimport { Box } from './common/box';\nimport { EventCallback, Events, EventSubscription } from './common/events';\nimport { ImageDebug } from './common/image-debug';\nimport { ImageWrapper } from './common/image-wrapper';\nimport { merge } from './common/merge';\nimport { Point } from './common/point';\nimport { config as defaultConfig, QuaggaConfig } from './config/config';\nimport { BarcodeDecoder, QuaggaBarcode } from './decoder/barcode-decoder';\nimport { CameraAccess } from './input/camera-access';\nimport { FrameGrabber } from './input/frame-grabber';\nimport { ImageStream } from './input/image-stream';\nimport { InputStream } from './input/input-stream';\nimport { LiveStream } from './input/live-stream';\nimport { VideoStream } from './input/video-stream';\nimport { checkImageConstraints } from './input/input-stream-utils';\nimport { BarcodeLocator } from './locator/barcode-locator';\nimport { BarcodeReaderDeclaration } from './reader/barcode-reader';\n\ninterface WorkerThread {\n    worker: Worker;\n    imageData: Uint8Array;\n    busy: boolean;\n}\n\nexport interface QuaggaCanvasContainer {\n    ctx: {\n        image: CanvasRenderingContext2D,\n        overlay: CanvasRenderingContext2D\n    },\n    dom: {\n        image: HTMLCanvasElement,\n        overlay: HTMLCanvasElement\n    }\n}\n\nlet _inputStream: InputStream;\nlet _frameGrabber: FrameGrabber;\nlet _stopped: boolean;\nconst _canvasContainer: QuaggaCanvasContainer = {\n    ctx: {\n        image: null,\n        overlay: null\n    },\n    dom: {\n        image: null,\n        overlay: null\n    }\n};\nlet _inputImageWrapper: ImageWrapper;\nlet _locator: BarcodeLocator;\nlet _boxSize: Box;\nlet _decoder: BarcodeDecoder;\nlet _workerPool = new Array<WorkerThread>();\nlet _onUIThread: boolean;\nlet _resultCollector: ResultCollector;\nlet _config: QuaggaConfig;\n\nexport default {\n    init(config: QuaggaConfig, cb: () => void, imageWrapper?: ImageWrapper) {\n        _onUIThread = true;\n        _config = merge(defaultConfig, config);\n        if (imageWrapper) {\n            _onUIThread = false;\n            _initializeData(imageWrapper);\n            cb();\n        } else {\n            _initInputStream(cb);\n        }\n    },\n\n    CameraAccess: CameraAccess,\n\n    ImageDebug: ImageDebug,\n\n    ImageWrapper: ImageWrapper,\n\n    ResultCollector: ResultCollector,\n\n    get canvas(): QuaggaCanvasContainer {\n        return _canvasContainer;\n    },\n\n    start(): void {\n        if (_onUIThread && _config.inputStream.type === 'LiveStream') {\n            _startContinuousUpdate();\n        } else {\n            _update();\n        }\n    },\n\n    stop(): void {\n        _stopped = true;\n        _adjustWorkerPool(0);\n        if (_config.inputStream.type === 'LiveStream') {\n            CameraAccess.release();\n            _inputStream.clearEventHandlers();\n        }\n    },\n\n    decodeSingle(config: QuaggaConfig, resultCallback: (_: QuaggaBarcode) => void): void {\n        config = merge({\n            inputStream: {\n                type: 'ImageStream',\n                sequence: false,\n                size: 800,\n                src: config.src\n            },\n            numOfWorkers: (process.env.NODE_ENV !== 'production' && config.debug) ? 0 : 1,\n            locator: {\n                halfSample: false\n            }\n        }, config);\n\n        this.init(config, () => {\n            Events.once('processed', (result: QuaggaBarcode) => {\n                this.stop();\n                resultCallback.call(null, result);\n            }, true);\n            this.start();\n        });\n    },\n\n    pause(): void {\n        _stopped = true;\n    },\n\n    onDetected(callback: EventSubscription | EventCallback): void {\n        Events.subscribe('detected', callback);\n    },\n\n    offDetected(callback: EventCallback): void {\n        Events.unsubscribe('detected', callback);\n    },\n\n    onProcessed(callback: EventSubscription | EventCallback): void {\n        Events.subscribe('processed', callback);\n    },\n\n    offProcessed(callback: EventCallback): void {\n        Events.unsubscribe('processed', callback);\n    },\n\n    setReaders(readers: Array<BarcodeReaderDeclaration>): void {\n        if (_decoder) {\n            _decoder.setReaders(readers);\n        } else if (_onUIThread && _workerPool.length > 0) {\n            _workerPool.forEach(({ worker }) => worker.postMessage({ cmd: 'setReaders', readers }));\n        }\n    },\n\n    registerResultCollector(resultCollector: ResultCollector): void {\n        if (resultCollector && typeof resultCollector.addResult === 'function') {\n            _resultCollector = resultCollector;\n        }\n    }\n};\n\nfunction _initializeData(imageWrapper?: ImageWrapper): void {\n    _initBuffers(imageWrapper);\n    _decoder = new BarcodeDecoder(_config.decoder, _inputImageWrapper);\n}\n\nfunction _initInputStream(callback: (err?: any) => void): void {\n    let video: HTMLVideoElement;\n    if (_config.inputStream.type === 'VideoStream') {\n        video = document.createElement('video');\n        _inputStream = new VideoStream(video);\n    } else if (_config.inputStream.type === 'ImageStream') {\n        _inputStream = new ImageStream();\n    } else if (_config.inputStream.type === 'LiveStream') {\n        const viewport = _getViewPort();\n        if (viewport) {\n            video = viewport.querySelector('video');\n            if (!video) {\n                video = document.createElement('video');\n                viewport.appendChild(video);\n            }\n        }\n        _inputStream = new LiveStream(video);\n        CameraAccess.request(video, _config.inputStream.constraints)\n            .then(() => _inputStream.trigger('canrecord'), err => callback(err));\n    }\n\n    _inputStream.setAttribute('preload', 'auto');\n    _inputStream.config = _config.inputStream;\n    _inputStream.addEventListener('canrecord', _canRecord.bind(this, callback));\n}\n\nfunction _getViewPort(): HTMLElement {\n    const target = _config.inputStream.target;\n    // Check if target is already a DOM element\n    if (target instanceof HTMLElement) {\n        return target;\n    } else {\n        // Use '#interactive.viewport' as a fallback selector (backwards compatibility)\n        const selector = typeof target === 'string' ? target : '#interactive.viewport';\n        return document.querySelector(selector);\n    }\n}\n\nfunction _canRecord(cb: () => void): void {\n    checkImageConstraints(_inputStream, _config.locator);\n    _initCanvas();\n    _frameGrabber = new FrameGrabber(_inputStream, _canvasContainer.dom.image);\n\n    _adjustWorkerPool(_config.numOfWorkers, () => {\n        if (_config.numOfWorkers === 0) {\n            _initializeData();\n        }\n\n        _inputStream.play();\n        cb();\n    });\n}\n\nfunction _initCanvas(): void {\n    if (typeof document !== 'undefined') {\n        const viewport = _getViewPort();\n        _canvasContainer.dom.image = document.querySelector('canvas.imgBuffer');\n        if (!_canvasContainer.dom.image) {\n            _canvasContainer.dom.image = document.createElement('canvas');\n            _canvasContainer.dom.image.className = 'imgBuffer';\n            if (viewport && _config.inputStream.type === 'ImageStream') {\n                viewport.appendChild(_canvasContainer.dom.image);\n            }\n        }\n        _canvasContainer.ctx.image = _canvasContainer.dom.image.getContext('2d');\n        _canvasContainer.dom.image.width = _inputStream.canvasWidth;\n        _canvasContainer.dom.image.height = _inputStream.canvasHeight;\n\n        _canvasContainer.dom.overlay = document.querySelector('canvas.drawingBuffer');\n        if (!_canvasContainer.dom.overlay) {\n            _canvasContainer.dom.overlay = document.createElement('canvas');\n            _canvasContainer.dom.overlay.className = 'drawingBuffer';\n            if (viewport) {\n                viewport.appendChild(_canvasContainer.dom.overlay);\n            }\n            const clearFix = document.createElement('br');\n            clearFix.setAttribute('clear', 'all');\n            if (viewport) {\n                viewport.appendChild(clearFix);\n            }\n        }\n        _canvasContainer.ctx.overlay = _canvasContainer.dom.overlay.getContext('2d');\n        _canvasContainer.dom.overlay.width = _inputStream.canvasWidth;\n        _canvasContainer.dom.overlay.height = _inputStream.canvasHeight;\n    }\n}\n\nfunction _initBuffers(imageWrapper?: ImageWrapper): void {\n    if (imageWrapper) {\n        _inputImageWrapper = imageWrapper;\n    } else {\n        _inputImageWrapper = new ImageWrapper({\n            x: _inputStream.width,\n            y: _inputStream.height\n        });\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n        console.log(_inputImageWrapper.size);\n    }\n    _boxSize = [\n        { x: 0, y: 0 },\n        { x: 0, y: _inputImageWrapper.size.y },\n        { x: _inputImageWrapper.size.x, y: _inputImageWrapper.size.y },\n        { x: _inputImageWrapper.size.x, y: 0 }\n    ];\n    _locator = new BarcodeLocator(_inputImageWrapper, _config.locator);\n}\n\nfunction _transform(polygon: ReadonlyArray<Point>, offset: Point): void {\n    polygon.forEach(vertex => {\n        vertex.x += offset.x;\n        vertex.y += offset.y;\n    })\n}\n\nfunction _transformResult(result: QuaggaBarcode, offset: Point): void {\n    if (result.barcodes) {\n        result.barcodes.forEach(barcode => _transformResult(barcode, offset));\n    }\n\n    if (result.line) {\n        _transform(result.line, offset);\n    }\n\n    if (result.box) {\n        _transform(result.box, offset);\n    }\n\n    if (result.boxes) {\n        result.boxes.forEach(box => _transform(box, offset));\n    }\n}\n\nfunction _addResult(result: QuaggaBarcode, imageData: Uint8Array, canvasWidth: number, canvasHeight: number): void {\n    if (imageData && _resultCollector) {\n        if (result.barcodes) {\n            result.barcodes.forEach(({ codeResult }) => {\n                if (codeResult) {\n                    _resultCollector.addResult(imageData, canvasWidth, canvasHeight, codeResult)\n                }\n            });\n        } else if (result.codeResult) {\n            _resultCollector.addResult(imageData, canvasWidth, canvasHeight, result.codeResult);\n        }\n    }\n}\n\nfunction _hasCodeResult(result: QuaggaBarcode): boolean {\n    return result && (!!result.codeResult || result.barcodes && result.barcodes.some(barcode => !!barcode.codeResult));\n}\n\nfunction _publishResult(result?: QuaggaBarcode, imageData?: Uint8Array): void {\n    let resultToPublish: QuaggaBarcode | Array<QuaggaBarcode> = result;\n\n    if (result && _onUIThread) {\n        const offset = _inputStream.topLeft;\n\n        if (offset.x !== 0 || offset.y !== 0) {\n            _transformResult(result, offset);\n        }\n\n        _addResult(result, imageData, _inputStream.canvasWidth, _inputStream.canvasHeight);\n        resultToPublish = result.barcodes || result;\n    }\n\n    Events.publish('processed', resultToPublish);\n    if (_hasCodeResult(result)) {\n        Events.publish('detected', resultToPublish);\n    }\n}\n\nfunction _locateAndDecode(): void {\n    const boxes = _config.locate ? _locator.locate() : [_boxSize];\n    const result = _decoder.decodeFromBoundingBoxes(boxes);\n    _publishResult(result, _inputImageWrapper.data);\n}\n\nfunction _update(): void {\n    if (_onUIThread) {\n        if (_workerPool.length > 0) {\n            const availableWorker = _workerPool.find(({ busy }) => !busy);\n            if (!availableWorker) {\n                return; // all workers are busy\n            }\n\n            const imageData = availableWorker.imageData;\n\n            if (_frameGrabber.grab(imageData)) {\n                availableWorker.busy = true;\n                availableWorker.worker.postMessage({ cmd: 'process', imageData }, [imageData.buffer]);\n            }\n        } else if (_frameGrabber.grab(_inputImageWrapper.data)) {\n            _locateAndDecode();\n        }\n    } else {\n        _locateAndDecode();\n    }\n}\n\nfunction _startContinuousUpdate(): void {\n    const delay = 1000 / (_config.frequency || 60);\n    let next = null;\n    _stopped = false;\n\n    (function frame(timestamp): void {\n        next = next || timestamp;\n        if (!_stopped) {\n            if (timestamp >= next) {\n                next += delay;\n                _update();\n            }\n            window.requestAnimationFrame(frame);\n        }\n    }(performance.now()));\n}\n\nfunction _initWorker(cb: (workerThread: WorkerThread) => void): void {\n    const blobURL = _generateWorkerBlob();\n    const workerThread = {\n        worker: new Worker(blobURL),\n        imageData: new Uint8Array(_inputStream.width * _inputStream.height),\n        busy: true\n    };\n\n    workerThread.worker.onmessage = ({ data }) => {\n        if (data.event === 'initialized') {\n            URL.revokeObjectURL(blobURL);\n            workerThread.busy = false;\n            workerThread.imageData = new Uint8Array(data.imageData);\n            if (process.env.NODE_ENV !== 'production') {\n                console.log('Worker initialized');\n            }\n            cb(workerThread);\n        } else if (data.event === 'processed') {\n            workerThread.busy = false;\n            workerThread.imageData = new Uint8Array(data.imageData);\n            _publishResult(data.result, workerThread.imageData);\n        } else if (data.event === 'error') {\n            if (process.env.NODE_ENV !== 'production') {\n                console.log('Worker error:', data.message);\n            }\n        }\n    };\n\n    workerThread.worker.postMessage({\n        cmd: 'init',\n        size: { x: _inputStream.width, y: _inputStream.height },\n        imageData: workerThread.imageData,\n        config: merge(_config, { inputStream: { target: null } })\n    }, [workerThread.imageData.buffer]);\n}\n\nfunction _workerInterface(factory: Function): void {\n    let Quagga: any;\n    const worker: any = self;\n    let imageWrapper: ImageWrapper;\n\n    if (factory) {\n        Quagga = factory().default;\n        if (!Quagga) {\n            worker.postMessage({ event: 'error', message: 'Quagga could not be created' });\n            return;\n        }\n    }\n\n    self.onmessage = ({ data }) => {\n        if (data.cmd === 'init') {\n            const config: QuaggaConfig = data.config;\n            config.numOfWorkers = 0;\n            imageWrapper = new Quagga.ImageWrapper({ x: data.size.x, y: data.size.y }, new Uint8Array(data.imageData));\n            Quagga.init(\n                config,\n                () => worker.postMessage(\n                    { event: 'initialized', imageData: imageWrapper.data }, [imageWrapper.data.buffer]\n                ),\n                imageWrapper\n            );\n            Quagga.onProcessed((result: QuaggaBarcode) =>\n                worker.postMessage(\n                    { event: 'processed', imageData: imageWrapper.data, result }, [imageWrapper.data.buffer]\n                )\n            );\n        } else if (data.cmd === 'process') {\n            imageWrapper.data = new Uint8Array(data.imageData);\n            Quagga.start();\n        } else if (data.cmd === 'setReaders') {\n            Quagga.setReaders(data.readers);\n        }\n    };\n}\n\nfunction _generateWorkerBlob(): string {\n    // @ts-ignore\n    let factorySource: string = __factorySource__ || '';\n    const blob = new Blob([`(${_workerInterface.toString()})(${factorySource});`], { type: 'text/javascript' });\n\n    return window.URL.createObjectURL(blob);\n}\n\nfunction _adjustWorkerPool(capacity: number, cb?: () => void): void {\n    const increaseBy = capacity - _workerPool.length;\n\n    if (increaseBy > 0) {\n        for (let i = 0; i < increaseBy; i++) {\n            _initWorker(workerThread => {\n                _workerPool.push(workerThread);\n                if (_workerPool.length >= capacity && cb) {\n                    cb();\n                }\n            });\n        }\n    } else {\n        if (increaseBy < 0) {\n            _workerPool.slice(increaseBy).forEach(({ worker }) => {\n                worker.terminate();\n                if (process.env.NODE_ENV !== 'production') {\n                    console.log('Worker terminated!');\n                }\n            });\n            _workerPool = _workerPool.slice(0, increaseBy);\n        }\n        return cb && cb();\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\n\nconst N = 1;\nconst W = 3;\nconst START_PATTERN = [W, N, W, N, N, N];\nconst STOP_PATTERN = [W, N, N, N, W];\nconst CODE_PATTERN = [\n    [N, N, W, W, N],\n    [W, N, N, N, W],\n    [N, W, N, N, W],\n    [W, W, N, N, N],\n    [N, N, W, N, W],\n    [W, N, W, N, N],\n    [N, W, W, N, N],\n    [N, N, N, W, W],\n    [W, N, N, W, N],\n    [N, W, N, W, N]\n];\nconst startPatternLength = START_PATTERN.reduce((sum, val) => sum + val, 0);\n\nexport class TwoOfFiveReader extends BarcodeReader {\n    private _barSpaceRatio: [number, number];\n\n    constructor(config?: BarcodeReaderConfig) {\n        super(config);\n\n        this._barSpaceRatio = [1, 1];\n        this._format = '2of5';\n        this._singleCodeError = 0.78;\n        this._averageCodeError = 0.30;\n    }\n\n    decode(): Barcode {\n        const startInfo = this._findStart();\n\n        if (!startInfo) {\n            return null;\n        }\n\n        const endInfo = this._findEnd();\n\n        if (!endInfo) {\n            return null;\n        }\n\n        const counters = this._fillCounters(startInfo.end, endInfo.start, 0);\n\n        if (counters.length % 10 !== 0) {\n            return null;\n        }\n\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n\n        decodedCodes.push(startInfo);\n\n        const code = this._decodePayload(counters, result, decodedCodes);\n\n        if (!code || result.length < 5) {\n            return null;\n        }\n\n        decodedCodes.push(endInfo);\n\n        return {\n            code: result.join(''),\n            start: startInfo.start,\n            end: endInfo.end,\n            startInfo,\n            decodedCodes\n        };\n    }\n\n    protected _findStart(): BarcodeInfo {\n        let offset = this._nextSet(this._row);\n        let narrowBarWidth = 1;\n        let startInfo: BarcodeInfo;\n\n        while (!startInfo) {\n            startInfo = this._findPattern(START_PATTERN, offset, 0, true);\n\n            if (!startInfo) {\n                return null;\n            }\n\n            narrowBarWidth = (startInfo.end - startInfo.start) / startPatternLength | 0;\n            const leadingWhitespaceStart = startInfo.start - narrowBarWidth * 5;\n\n            if (leadingWhitespaceStart >= 0) {\n                if (this._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                    return startInfo;\n                }\n            }\n\n            offset = startInfo.end;\n            startInfo = null;\n        }\n\n        return null;\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n\n    protected _findEnd(): BarcodeInfo {\n        this._row.reverse();\n\n        const offset = this._nextSet(this._row);\n        const endInfo = this._findPattern(STOP_PATTERN, offset, 0, true);\n\n        this._row.reverse();\n\n        if (endInfo === null) {\n            return null;\n        }\n\n        // reverse numbers\n        const start = endInfo.start;\n        endInfo.start = this._row.length - endInfo.end;\n        endInfo.end = this._row.length - start;\n\n        return endInfo !== null ? this._verifyTrailingWhitespace(endInfo) : null;\n    }\n\n    protected _decodeCode(counter: ReadonlyArray<number>): BarcodeInfo {\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        };\n\n        for (let code = 0; code < CODE_PATTERN.length; code++) {\n            const error = this._matchPattern(counter, CODE_PATTERN[code]);\n            if (error < bestMatch.error) {\n                bestMatch.code = code;\n                bestMatch.error = error;\n            }\n        }\n\n        return bestMatch.error < this.AVERAGE_CODE_ERROR ? bestMatch : null;\n    }\n\n    protected _decodePayload(counters: ReadonlyArray<number>, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo {\n        const counterLength = counters.length;\n        const counter = [0, 0, 0, 0, 0];\n        let pos = 0;\n        let code: BarcodeInfo;\n\n        while (pos < counterLength) {\n            for (let i = 0; i < 5; i++) {\n                counter[i] = counters[pos] * this._barSpaceRatio[0];\n                pos += 2;\n            }\n\n            code = this._decodeCode(counter);\n\n            if (!code) {\n                return null;\n            }\n\n            result.push(code.code);\n            decodedCodes.push(code);\n        }\n\n        return code;\n    }\n}\n","export enum BarcodeDirection {\n    Forward = 1,\n    Reverse = -1\n};\n\nexport type BarcodeFormat = string;\n\nexport type BarcodeReaderType = string;\n\nexport type BarcodeReaderDeclaration = BarcodeReaderType | { format: BarcodeReaderType; config: BarcodeReaderConfig; };\n\nexport interface BarcodeReaderConfig {\n    normalizeBarSpaceWidth?: boolean;\n    supplements?: Array<BarcodeReaderType>;\n}\n\nexport interface BarcodeCorrection {\n    bar: number;\n    space: number;\n}\n\nexport interface BarcodeInfo {\n    code?: number;\n    correction?: BarcodeCorrection;\n    end?: number;\n    endCounter?: number;\n    error?: number;\n    start?: number;\n    startCounter?: number;\n}\n\nexport interface Barcode {\n    code?: string;\n    codeset?: number;\n    correction?: BarcodeCorrection;\n    decodedCodes?: Array<string | BarcodeInfo>;\n    direction?: BarcodeDirection;\n    end?: number;\n    endInfo?: BarcodeInfo;\n    format?: BarcodeFormat;\n    start?: number;\n    startInfo?: BarcodeInfo;\n    supplement?: Barcode;\n}\n\nexport abstract class BarcodeReader {\n    protected _singleCodeError: number;\n    protected _averageCodeError: number;\n    protected _format: BarcodeFormat;\n    protected _row: Array<number>;\n\n    config: BarcodeReaderConfig;\n    supplements: Array<BarcodeReader>;\n\n    static get Exception() {\n        return {\n            StartNotFoundException: 'Start-Info was not found!',\n            CodeNotFoundException: 'Code could not be found!',\n            PatternNotFoundException: 'Pattern could not be found!'\n        };\n    }\n\n    get SINGLE_CODE_ERROR(): number {\n        return this._singleCodeError;\n    }\n\n    get AVERAGE_CODE_ERROR(): number {\n        return this._averageCodeError;\n    }\n\n    get FORMAT(): BarcodeFormat {\n        return this._format;\n    }\n\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        this._format = 'unknown';\n        this._row = [];\n        this.config = config || {};\n        this.supplements = supplements;\n    }\n\n    abstract decode(row?: Array<number>, start?: number): Barcode;\n\n    protected _findPattern(pattern: ReadonlyArray<number>, offset: number, isWhite: 0 | 1, tryHarder: boolean): BarcodeInfo {\n        const counter = new Array<number>(pattern.length);\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        };\n        const epsilon = this.AVERAGE_CODE_ERROR;\n        let counterPos = 0;\n\n        if (!offset) {\n            offset = this._nextSet(this._row);\n        }\n\n        counter.fill(0);\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    const error = this._matchPattern(counter, pattern);\n\n                    if (error < epsilon) {\n                        bestMatch.error = error;\n                        bestMatch.start = i - counter.reduce((sum, value) => sum + value, 0);\n                        bestMatch.end = i;\n                        return bestMatch;\n                    }\n\n                    if (tryHarder) {\n                        for (let j = 0; j < counter.length - 2; j++) {\n                            counter[j] = counter[j + 2];\n                        }\n                        counter[counter.length - 2] = 0;\n                        counter[counter.length - 1] = 0;\n                        counterPos--;\n                    } else {\n                        return null;\n                    }\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n        return null;\n    }\n\n    protected _nextUnset(line: ReadonlyArray<number>, start?: number): number {\n        for (let i = start || 0; i < line.length; i++) {\n            if (!line[i]) {\n                return i;\n            }\n        }\n        return line.length;\n    }\n\n    protected _nextSet(line: ReadonlyArray<number>, start?: number): number {\n        for (let i = start || 0; i < line.length; i++) {\n            if (line[i]) {\n                return i;\n            }\n        }\n        return line.length;\n    }\n\n    protected _matchRange(start: number, end: number, value: number): boolean {\n        for (let i = start < 0 ? 0 : start; i < end; i++) {\n            if (this._row[i] !== value) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    protected _matchPattern(counter: ReadonlyArray<number>, code: ReadonlyArray<number>, maxSingleError?: number): number {\n        let error = 0;\n        let sum = 0;\n        let modulo = 0;\n\n        maxSingleError = maxSingleError || this.SINGLE_CODE_ERROR || 1;\n\n        for (let i = 0; i < counter.length; i++) {\n            sum += counter[i];\n            modulo += code[i];\n        }\n\n        if (sum < modulo) {\n            return Number.MAX_VALUE;\n        }\n\n        const barWidth = sum / modulo;\n        maxSingleError *= barWidth;\n\n        for (let i = 0; i < counter.length; i++) {\n            const count = counter[i];\n            const scaled = code[i] * barWidth;\n            const singleError = Math.abs(count - scaled) / scaled;\n\n            if (singleError > maxSingleError) {\n                return Number.MAX_VALUE;\n            }\n\n            error += singleError;\n        }\n\n        return error / modulo;\n    }\n\n    protected _correctBars(counter: Array<number>, correction: number, indices: Array<number>) {\n        let length = indices.length;\n        let tmp = 0;\n\n        while (length--) {\n            tmp = counter[indices[length]] * (1 - ((1 - correction) / 2));\n            if (tmp > 1) {\n                counter[indices[length]] = tmp;\n            }\n        }\n    }\n\n    decodePattern(pattern: Array<number>): Barcode {\n        this._row = pattern;\n        let result = this.decode();\n\n        if (result === null) {\n            this._row.reverse();\n            result = this.decode();\n            if (result) {\n                result.direction = BarcodeDirection.Reverse;\n                result.start = this._row.length - result.start;\n                result.end = this._row.length - result.end;\n            }\n        } else {\n            result.direction = BarcodeDirection.Forward;\n        }\n\n        if (result) {\n            result.format = this.FORMAT;\n        }\n\n        return result;\n    }\n\n    _fillCounters(offset: number, end: number, isWhite: 0 | 1): Array<number> {\n        const counters = new Array<number>();\n        let counterPos = 0;\n\n        counters[counterPos] = 0;\n\n        for (let i = offset; i < end; i++) {\n            if (this._row[i] ^ isWhite) {\n                counters[counterPos]++;\n            } else {\n                counterPos++;\n                counters[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return counters;\n    }\n\n    protected _toCounters(start: number, counters: Uint16Array): Uint16Array {\n        const numCounters = counters.length;\n        const end = this._row.length;\n        let isWhite: 0 | 1 = this._row[start] ? 0 : 1;\n        let counterPos = 0;\n\n        counters.fill(0);\n\n        for (let i = start; i < end; i++) {\n            if (this._row[i] ^ isWhite) {\n                counters[counterPos]++;\n            } else {\n                counterPos++;\n                if (counterPos === numCounters) {\n                    break;\n                } else {\n                    counters[counterPos] = 1;\n                    isWhite = isWhite ? 0 : 1;\n                }\n            }\n        }\n\n        return counters;\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader } from './barcode-reader';\n\nconst ALPHABETH_STRING = '0123456789-$:/.+ABCD';\nconst ALPHABET = [...ALPHABETH_STRING].map(char => char.charCodeAt(0));\n// const ALPHABET = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 36, 58, 47, 46, 43, 65, 66, 67, 68];\nconst CHARACTER_ENCODINGS = [0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, 0x00c, 0x018, 0x045,\n    0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E];\nconst START_END = [0x01A, 0x029, 0x00B, 0x00E];\nconst MIN_ENCODED_CHARS = 4;\nconst MAX_ACCEPTABLE = 2.0;\nconst PADDING = 1.5;\n\ninterface Threshold {\n    space: {\n        narrow: {\n            size: number;\n            counts: number;\n            min: number;\n            max: number;\n        };\n        wide: {\n            size: number;\n            counts: number;\n            min: number;\n            max: number;\n        };\n    };\n    bar: {\n        narrow: {\n            size: number;\n            counts: number;\n            min: number;\n            max: number;\n        };\n        wide: {\n            size: number;\n            counts: number;\n            min: number;\n            max: number;\n        };\n    };\n}\n\nexport class CodabarReader extends BarcodeReader {\n    private _counters: Array<number>;\n\n    constructor() {\n        super();\n\n        this._format = 'codabar';\n        this._counters = [];\n    }\n\n    decode(): Barcode {\n        this._counters = this._fillCounters(this._nextUnset(this._row), this._row.length, 1);\n\n        const start = this._findStart();\n        if (!start) {\n            return null;\n        }\n\n        const result = new Array<string>();\n        let nextStart = start.startCounter;\n        let pattern: number;\n\n        do {\n            pattern = this._toPattern(nextStart);\n            if (pattern < 0) {\n                return null;\n            }\n            const decodedChar = this._patternToChar(pattern);\n            if (decodedChar === null) {\n                return null;\n            }\n            result.push(decodedChar);\n            nextStart += 8;\n            if (result.length > 1 && START_END.some(code => code === pattern)) {\n                break;\n            }\n        } while (nextStart < this._counters.length);\n\n        // verify end\n        if ((result.length - 2) < MIN_ENCODED_CHARS || !START_END.some(code => code === pattern)) {\n            return null;\n        }\n\n        // verify end white space\n        if (!this._verifyWhitespace(start.startCounter, nextStart - 8)) {\n            return null;\n        }\n\n        if (!this._validateResult(result, start.startCounter)) {\n            return null;\n        }\n\n        nextStart = nextStart > this._counters.length ? this._counters.length : nextStart;\n        const end = start.start + this._sumCounters(start.startCounter, nextStart - 8);\n\n        return {\n            code: result.join(''),\n            start: start.start,\n            end,\n            startInfo: start,\n            decodedCodes: result\n        };\n    }\n\n    protected _verifyWhitespace(startCounter: number, endCounter: number): boolean {\n        if ((startCounter - 1 <= 0)\n            || this._counters[startCounter - 1] >= (this._calculatePatternLength(startCounter) / 2.0)) {\n            if ((endCounter + 8 >= this._counters.length)\n                || this._counters[endCounter + 7] >= (this._calculatePatternLength(endCounter) / 2.0)) {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n    private _calculatePatternLength(offset: number): number {\n        let sum = 0;\n\n        for (let i = offset; i < offset + 7; i++) {\n            sum += this._counters[i];\n        }\n\n        return sum;\n    }\n\n    private _thresholdResultPattern(result: ReadonlyArray<string>, startCounter: number): Threshold {\n        const categorization: Threshold = {\n            space: {\n                narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE },\n                wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE }\n            },\n            bar: {\n                narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE },\n                wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE }\n            }\n        };\n        let pos = startCounter;\n\n        for (let i = 0; i < result.length; i++) {\n            let pattern = this._charToPattern(result[i]);\n\n            for (let j = 6; j >= 0; j--) {\n                const kind = (j & 1) === 2 ? categorization.bar : categorization.space;\n                const cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;\n                cat.size += this._counters[pos + j];\n                cat.counts++;\n                pattern >>= 1;\n            }\n            pos += 8;\n        }\n\n        ['space', 'bar'].forEach(key => {\n            const kind = categorization[key];\n            kind.wide.min = Math.floor((kind.narrow.size / kind.narrow.counts + kind.wide.size / kind.wide.counts) / 2);\n            kind.narrow.max = Math.ceil(kind.wide.min);\n            kind.wide.max = Math.ceil((kind.wide.size * MAX_ACCEPTABLE + PADDING) / kind.wide.counts);\n        });\n\n        return categorization;\n    }\n\n    private _charToPattern(char: string): number {\n        const charCode = char.charCodeAt(0);\n\n        for (let i = 0; i < ALPHABET.length; i++) {\n            if (ALPHABET[i] === charCode) {\n                return CHARACTER_ENCODINGS[i];\n            }\n        }\n\n        return 0x0;\n    }\n\n    private _validateResult(result: ReadonlyArray<string>, startCounter: number): boolean {\n        const threshold = this._thresholdResultPattern(result, startCounter);\n        let pos = startCounter;\n\n        for (let i = 0; i < result.length; i++) {\n            let pattern = this._charToPattern(result[i]);\n\n            for (let j = 6; j >= 0; j--) {\n                const kind = (j & 1) === 0 ? threshold.bar : threshold.space;\n                const cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;\n                const size = this._counters[pos + j];\n                if (size < cat.min || size > cat.max) {\n                    return false;\n                }\n                pattern >>= 1;\n            }\n            pos += 8;\n        }\n\n        return true;\n    }\n\n    private _patternToChar(pattern: number): string {\n        for (let i = 0; i < CHARACTER_ENCODINGS.length; i++) {\n            if (CHARACTER_ENCODINGS[i] === pattern) {\n                return String.fromCharCode(ALPHABET[i]);\n            }\n        }\n\n        return null;\n    }\n\n    private _computeAlternatingThreshold(offset: number, end: number): number {\n        let min = Number.MAX_VALUE;\n        let max = 0;\n\n        for (let i = offset; i < end; i += 2) {\n            const counter = this._counters[i];\n            if (counter > max) {\n                max = counter;\n            }\n            if (counter < min) {\n                min = counter;\n            }\n        }\n\n        return ((min + max) / 2.0) | 0;\n    }\n\n    private _toPattern(offset: number): number {\n        const numCounters = 7;\n        const end = offset + numCounters;\n\n        if (end > this._counters.length) {\n            return -1;\n        }\n\n        const barThreshold = this._computeAlternatingThreshold(offset, end);\n        const spaceThreshold = this._computeAlternatingThreshold(offset + 1, end);\n        let bitmask = 1 << (numCounters - 1);\n        let pattern = 0;\n\n        for (let i = 0; i < numCounters; i++) {\n            const threshold = (i & 1) === 0 ? barThreshold : spaceThreshold;\n            if (this._counters[offset + i] > threshold) {\n                pattern |= bitmask;\n            }\n            bitmask >>= 1;\n        }\n\n        return pattern;\n    }\n\n    private _sumCounters(start: number, end: number): number {\n        let sum = 0;\n\n        for (let i = start; i < end; i++) {\n            sum += this._counters[i];\n        }\n\n        return sum;\n    }\n\n    protected _findStart(): BarcodeInfo {\n        let start = this._nextUnset(this._row);\n\n        for (let i = 1; i < this._counters.length; i++) {\n            const pattern = this._toPattern(i);\n            if (pattern !== -1 && START_END.some(code => code === pattern)) {\n                // TODO: Look for whitespace ahead\n                start += this._sumCounters(0, i);\n                const end = start + this._sumCounters(i, i + 8);\n                return {\n                    start,\n                    end,\n                    startCounter: i,\n                    endCounter: i + 8\n                };\n            }\n        }\n\n        return null;\n    }\n}\n","import { Barcode, BarcodeCorrection, BarcodeInfo, BarcodeReader } from './barcode-reader';\n\nconst CODE_SHIFT = 98;\nconst CODE_C = 99;\nconst CODE_B = 100;\nconst CODE_A = 101;\nconst START_CODE_A = 103;\nconst START_CODE_B = 104;\nconst START_CODE_C = 105;\nconst STOP_CODE = 106;\nconst CODE_PATTERN = [\n    [2, 1, 2, 2, 2, 2],\n    [2, 2, 2, 1, 2, 2],\n    [2, 2, 2, 2, 2, 1],\n    [1, 2, 1, 2, 2, 3],\n    [1, 2, 1, 3, 2, 2],\n    [1, 3, 1, 2, 2, 2],\n    [1, 2, 2, 2, 1, 3],\n    [1, 2, 2, 3, 1, 2],\n    [1, 3, 2, 2, 1, 2],\n    [2, 2, 1, 2, 1, 3],\n    [2, 2, 1, 3, 1, 2],\n    [2, 3, 1, 2, 1, 2],\n    [1, 1, 2, 2, 3, 2],\n    [1, 2, 2, 1, 3, 2],\n    [1, 2, 2, 2, 3, 1],\n    [1, 1, 3, 2, 2, 2],\n    [1, 2, 3, 1, 2, 2],\n    [1, 2, 3, 2, 2, 1],\n    [2, 2, 3, 2, 1, 1],\n    [2, 2, 1, 1, 3, 2],\n    [2, 2, 1, 2, 3, 1],\n    [2, 1, 3, 2, 1, 2],\n    [2, 2, 3, 1, 1, 2],\n    [3, 1, 2, 1, 3, 1],\n    [3, 1, 1, 2, 2, 2],\n    [3, 2, 1, 1, 2, 2],\n    [3, 2, 1, 2, 2, 1],\n    [3, 1, 2, 2, 1, 2],\n    [3, 2, 2, 1, 1, 2],\n    [3, 2, 2, 2, 1, 1],\n    [2, 1, 2, 1, 2, 3],\n    [2, 1, 2, 3, 2, 1],\n    [2, 3, 2, 1, 2, 1],\n    [1, 1, 1, 3, 2, 3],\n    [1, 3, 1, 1, 2, 3],\n    [1, 3, 1, 3, 2, 1],\n    [1, 1, 2, 3, 1, 3],\n    [1, 3, 2, 1, 1, 3],\n    [1, 3, 2, 3, 1, 1],\n    [2, 1, 1, 3, 1, 3],\n    [2, 3, 1, 1, 1, 3],\n    [2, 3, 1, 3, 1, 1],\n    [1, 1, 2, 1, 3, 3],\n    [1, 1, 2, 3, 3, 1],\n    [1, 3, 2, 1, 3, 1],\n    [1, 1, 3, 1, 2, 3],\n    [1, 1, 3, 3, 2, 1],\n    [1, 3, 3, 1, 2, 1],\n    [3, 1, 3, 1, 2, 1],\n    [2, 1, 1, 3, 3, 1],\n    [2, 3, 1, 1, 3, 1],\n    [2, 1, 3, 1, 1, 3],\n    [2, 1, 3, 3, 1, 1],\n    [2, 1, 3, 1, 3, 1],\n    [3, 1, 1, 1, 2, 3],\n    [3, 1, 1, 3, 2, 1],\n    [3, 3, 1, 1, 2, 1],\n    [3, 1, 2, 1, 1, 3],\n    [3, 1, 2, 3, 1, 1],\n    [3, 3, 2, 1, 1, 1],\n    [3, 1, 4, 1, 1, 1],\n    [2, 2, 1, 4, 1, 1],\n    [4, 3, 1, 1, 1, 1],\n    [1, 1, 1, 2, 2, 4],\n    [1, 1, 1, 4, 2, 2],\n    [1, 2, 1, 1, 2, 4],\n    [1, 2, 1, 4, 2, 1],\n    [1, 4, 1, 1, 2, 2],\n    [1, 4, 1, 2, 2, 1],\n    [1, 1, 2, 2, 1, 4],\n    [1, 1, 2, 4, 1, 2],\n    [1, 2, 2, 1, 1, 4],\n    [1, 2, 2, 4, 1, 1],\n    [1, 4, 2, 1, 1, 2],\n    [1, 4, 2, 2, 1, 1],\n    [2, 4, 1, 2, 1, 1],\n    [2, 2, 1, 1, 1, 4],\n    [4, 1, 3, 1, 1, 1],\n    [2, 4, 1, 1, 1, 2],\n    [1, 3, 4, 1, 1, 1],\n    [1, 1, 1, 2, 4, 2],\n    [1, 2, 1, 1, 4, 2],\n    [1, 2, 1, 2, 4, 1],\n    [1, 1, 4, 2, 1, 2],\n    [1, 2, 4, 1, 1, 2],\n    [1, 2, 4, 2, 1, 1],\n    [4, 1, 1, 2, 1, 2],\n    [4, 2, 1, 1, 1, 2],\n    [4, 2, 1, 2, 1, 1],\n    [2, 1, 2, 1, 4, 1],\n    [2, 1, 4, 1, 2, 1],\n    [4, 1, 2, 1, 2, 1],\n    [1, 1, 1, 1, 4, 3],\n    [1, 1, 1, 3, 4, 1],\n    [1, 3, 1, 1, 4, 1],\n    [1, 1, 4, 1, 1, 3],\n    [1, 1, 4, 3, 1, 1],\n    [4, 1, 1, 1, 1, 3],\n    [4, 1, 1, 3, 1, 1],\n    [1, 1, 3, 1, 4, 1],\n    [1, 1, 4, 1, 3, 1],\n    [3, 1, 1, 1, 4, 1],\n    [4, 1, 1, 1, 3, 1],\n    [2, 1, 1, 4, 1, 2],\n    [2, 1, 1, 2, 1, 4],\n    [2, 1, 1, 2, 3, 2],\n    [2, 3, 3, 1, 1, 1, 2]\n];\nconst MODULE_INDICES = { bar: [0, 2, 4], space: [1, 3, 5] };\n\nexport class Code128Reader extends BarcodeReader {\n    constructor() {\n        super();\n\n        this._format = 'code_128';\n        this._singleCodeError = 0.64;\n        this._averageCodeError = 0.30;\n    }\n\n    protected _decodeCode(start: number, correction: BarcodeCorrection): BarcodeInfo {\n        const counter = [0, 0, 0, 0, 0, 0];\n        const offset = start;\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: start,\n            end: start,\n            correction: {\n                bar: 1,\n                space: 1\n            }\n        };\n        const epsilon = this.AVERAGE_CODE_ERROR;\n        let isWhite: 0 | 1 = this._row[offset] ? 0 : 1;\n        let counterPos = 0;\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    if (correction) {\n                        this._correct(counter, correction);\n                    }\n\n                    for (let code = 0; code < CODE_PATTERN.length; code++) {\n                        const error = this._matchPattern(counter, CODE_PATTERN[code]);\n                        if (error < bestMatch.error) {\n                            bestMatch.code = code;\n                            bestMatch.error = error;\n                        }\n                    }\n\n                    bestMatch.end = i;\n\n                    if (bestMatch.code === -1 || bestMatch.error > epsilon) {\n                        return null;\n                    }\n\n                    const expected = CODE_PATTERN[bestMatch.code];\n                    if (expected) {\n                        bestMatch.correction.bar = this._calculateCorrection(expected, counter, MODULE_INDICES.bar);\n                        bestMatch.correction.space = this._calculateCorrection(expected, counter, MODULE_INDICES.space);\n                    }\n\n                    return bestMatch;\n                } else {\n                    counterPos++;\n                }\n\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n\n    private _correct(counter: Array<number>, correction: BarcodeCorrection): void {\n        this._correctBars(counter, correction.bar, MODULE_INDICES.bar);\n        this._correctBars(counter, correction.space, MODULE_INDICES.space);\n    }\n\n    protected _findStart() {\n        const counter = [0, 0, 0, 0, 0, 0];\n        const offset = this._nextSet(this._row);\n        const bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0,\n            correction: {\n                bar: 1,\n                space: 1\n            }\n        };\n        const epsilon = this.AVERAGE_CODE_ERROR;\n        let isWhite: 0 | 1 = 0;\n        let counterPos = 0;\n        let sum: number;\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    sum = 0;\n                    for (let j = 0; j < counter.length; j++) {\n                        sum += counter[j];\n                    }\n                    for (let code = START_CODE_A; code <= START_CODE_C; code++) {\n                        const error = this._matchPattern(counter, CODE_PATTERN[code]);\n                        if (error < bestMatch.error) {\n                            bestMatch.code = code;\n                            bestMatch.error = error;\n                        }\n                    }\n                    if (bestMatch.error < epsilon) {\n                        bestMatch.start = i - sum;\n                        bestMatch.end = i;\n                        bestMatch.correction.bar = this._calculateCorrection(CODE_PATTERN[bestMatch.code], counter,\n                            MODULE_INDICES.bar);\n                        bestMatch.correction.space = this._calculateCorrection(CODE_PATTERN[bestMatch.code], counter,\n                            MODULE_INDICES.space);\n                        return bestMatch;\n                    }\n\n                    for (let j = 0; j < 4; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[4] = 0;\n                    counter[5] = 0;\n                    counterPos--;\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n\n    decode(): Barcode {\n        const result = new Array<string | number>();\n        const startInfo = this._findStart();\n        let code: BarcodeInfo = null;\n        let done = false;\n        let multiplier = 0;\n        let checksum = 0;\n        let codeset: number;\n        let rawResult = new Array<number>();\n        let decodedCodes = new Array<BarcodeInfo>();\n        let shiftNext = false;\n        let unshift: boolean;\n        let removeLastCharacter = true;\n\n        if (startInfo === null) {\n            return null;\n        }\n        code = {\n            code: startInfo.code,\n            start: startInfo.start,\n            end: startInfo.end,\n            correction: {\n                bar: startInfo.correction.bar,\n                space: startInfo.correction.space\n            }\n        };\n        decodedCodes.push(code);\n        checksum = code.code;\n\n        switch (code.code) {\n            case START_CODE_A:\n                codeset = CODE_A;\n                break;\n            case START_CODE_B:\n                codeset = CODE_B;\n                break;\n            case START_CODE_C:\n                codeset = CODE_C;\n                break;\n            default:\n                return null;\n        }\n\n        while (!done) {\n            unshift = shiftNext;\n            shiftNext = false;\n            code = this._decodeCode(code.end, code.correction);\n            if (code !== null) {\n                if (code.code !== STOP_CODE) {\n                    removeLastCharacter = true;\n                }\n\n                if (code.code !== STOP_CODE) {\n                    rawResult.push(code.code);\n                    multiplier++;\n                    checksum += multiplier * code.code;\n                }\n                decodedCodes.push(code);\n\n                switch (codeset) {\n                    case CODE_A: {\n                        if (code.code < 64) {\n                            result.push(String.fromCharCode(32 + code.code));\n                        } else if (code.code < 96) {\n                            result.push(String.fromCharCode(code.code - 64));\n                        } else {\n                            if (code.code !== STOP_CODE) {\n                                removeLastCharacter = false;\n                            }\n                            switch (code.code) {\n                                case CODE_SHIFT:\n                                    shiftNext = true;\n                                    codeset = CODE_B;\n                                    break;\n                                case CODE_B:\n                                    codeset = CODE_B;\n                                    break;\n                                case CODE_C:\n                                    codeset = CODE_C;\n                                    break;\n                                case STOP_CODE:\n                                    done = true;\n                                    break;\n                            }\n                        }\n                        break;\n                    }\n                    case CODE_B: {\n                        if (code.code < 96) {\n                            result.push(String.fromCharCode(32 + code.code));\n                        } else {\n                            if (code.code !== STOP_CODE) {\n                                removeLastCharacter = false;\n                            }\n                            switch (code.code) {\n                                case CODE_SHIFT:\n                                    shiftNext = true;\n                                    codeset = CODE_A;\n                                    break;\n                                case CODE_A:\n                                    codeset = CODE_A;\n                                    break;\n                                case CODE_C:\n                                    codeset = CODE_C;\n                                    break;\n                                case STOP_CODE:\n                                    done = true;\n                                    break;\n                            }\n                        }\n                        break;\n                    }\n                    case CODE_C: {\n                        if (code.code < 100) {\n                            result.push(code.code < 10 ? '0' + code.code : code.code);\n                        } else {\n                            if (code.code !== STOP_CODE) {\n                                removeLastCharacter = false;\n                            }\n                            switch (code.code) {\n                                case CODE_A:\n                                    codeset = CODE_A;\n                                    break;\n                                case CODE_B:\n                                    codeset = CODE_B;\n                                    break;\n                                case STOP_CODE:\n                                    done = true;\n                                    break;\n                            }\n                        }\n                        break;\n                    }\n                }\n            } else {\n                done = true;\n            }\n            if (unshift) {\n                codeset = codeset === CODE_A ? CODE_B : CODE_A;\n            }\n        }\n\n        if (code === null) {\n            return null;\n        }\n\n        code.end = this._nextUnset(this._row, code.end);\n        if (!this._verifyTrailingWhitespace(code)) {\n            return null;\n        }\n\n        checksum -= multiplier * rawResult[rawResult.length - 1];\n        if (checksum % 103 !== rawResult[rawResult.length - 1]) {\n            return null;\n        }\n\n        if (!result.length) {\n            return null;\n        }\n\n        // remove last code from result (checksum)\n        if (removeLastCharacter) {\n            result.splice(result.length - 1, 1);\n        }\n\n        return {\n            code: result.join(''),\n            start: startInfo.start,\n            end: code.end,\n            codeset,\n            startInfo,\n            decodedCodes,\n            endInfo: code\n        };\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n\n    private _calculateCorrection(\n        expected: ReadonlyArray<number>,\n        normalized: ReadonlyArray<number>,\n        indices: ReadonlyArray<number>\n    ): number {\n        let sumNormalized = 0;\n        let sumExpected = 0;\n\n        for (let length = indices.length; length--;) {\n            sumExpected += expected[indices[length]];\n            sumNormalized += normalized[indices[length]];\n        }\n\n        return sumExpected / sumNormalized;\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader } from './barcode-reader';\n\nconst ASTERISK = 0x094;\nconst ALPHABETH_STRING = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%';\nconst ALPHABET = new Uint16Array([...ALPHABETH_STRING].map(char => char.charCodeAt(0)));\n// const ALPHABET = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,\n//     79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 45, 46, 32, 42, 36, 47, 43, 37];\nconst CHARACTER_ENCODINGS = new Uint16Array([\n    0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, 0x109, 0x049, 0x148, 0x019, 0x118, 0x058,\n    0x00D, 0x10C, 0x04C, 0x01C, 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, 0x181, 0x0C1,\n    0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, 0x0A8, 0x0A2, 0x08A, 0x02A\n]);\n\nexport class Code39Reader extends BarcodeReader {\n    constructor() {\n        super();\n\n        this._format = 'code_39';\n    }\n\n    decode(): Barcode {\n        const start = this._findStart();\n\n        if (!start) {\n            return null;\n        }\n\n        const result = new Array<string>();\n        let counters = new Uint16Array(9);\n        let decodedChar: string;\n        let lastStart: number;\n        let nextStart = this._nextSet(this._row, start.end);\n\n        do {\n            this._toCounters(nextStart, counters);\n            const pattern = this._toPattern(counters);\n            if (pattern < 0) {\n                return null;\n            }\n            decodedChar = this._patternToChar(pattern);\n            if (decodedChar === null) {\n                return null;\n            }\n            result.push(decodedChar);\n            lastStart = nextStart;\n            nextStart += counters.reduce((sum, item) => sum + item, 0);\n            nextStart = this._nextSet(this._row, nextStart);\n        } while (decodedChar !== '*');\n        result.pop();\n\n        if (!result.length) {\n            return null;\n        }\n\n        if (!this._verifyTrailingWhitespace(lastStart, nextStart, counters)) {\n            return null;\n        }\n\n        return {\n            code: result.join(''),\n            start: start.start,\n            end: nextStart,\n            startInfo: start,\n            decodedCodes: result\n        };\n    }\n\n    protected _patternToChar(pattern): string {\n        for (let i = 0; i < CHARACTER_ENCODINGS.length; i++) {\n            if (CHARACTER_ENCODINGS[i] === pattern) {\n                return String.fromCharCode(ALPHABET[i]);\n            }\n        }\n        return null;\n    }\n\n    private _verifyTrailingWhitespace(lastStart: number, nextStart: number, counters: Uint16Array): boolean {\n        const patternSize = counters.reduce((sum, item) => sum + item, 0);\n        const trailingWhitespaceEnd = nextStart - lastStart - patternSize;\n        return (trailingWhitespaceEnd * 3) >= patternSize;\n    }\n\n    private _findNextWidth(counters: Uint16Array, current: number): number {\n        let minWidth = Number.MAX_VALUE;\n\n        for (let i = 0; i < counters.length; i++) {\n            if (counters[i] < minWidth && counters[i] > current) {\n                minWidth = counters[i];\n            }\n        }\n\n        return minWidth;\n    }\n\n    private _toPattern(counters: Uint16Array): number {\n        const numCounters = counters.length;\n        let maxNarrowWidth = 0;\n        let numWideBars = numCounters;\n        let wideBarWidth = 0;\n        let pattern: number;\n\n        while (numWideBars > 3) {\n            maxNarrowWidth = this._findNextWidth(counters, maxNarrowWidth);\n            numWideBars = 0;\n            pattern = 0;\n            for (let i = 0; i < numCounters; i++) {\n                if (counters[i] > maxNarrowWidth) {\n                    pattern |= 1 << (numCounters - 1 - i);\n                    numWideBars++;\n                    wideBarWidth += counters[i];\n                }\n            }\n\n            if (numWideBars === 3) {\n                for (let i = 0; i < numCounters && numWideBars > 0; i++) {\n                    if (counters[i] > maxNarrowWidth) {\n                        numWideBars--;\n                        if ((counters[i] * 2) >= wideBarWidth) {\n                            return -1;\n                        }\n                    }\n                }\n                return pattern;\n            }\n        }\n        return -1;\n    }\n\n    protected _findStart(): BarcodeInfo {\n        const offset = this._nextSet(this._row);\n        let patternStart = offset;\n        const counter = new Uint16Array(9);\n        let counterPos = 0;\n        let isWhite: 0 | 1 = 0;\n        let whiteSpaceMustStart: number;\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    // find start pattern\n                    if (this._toPattern(counter) === ASTERISK) {\n                        whiteSpaceMustStart = Math.max(0, patternStart - ((i - patternStart) / 4)) | 0;\n                        if (this._matchRange(whiteSpaceMustStart, patternStart, 0)) {\n                            return {\n                                start: patternStart,\n                                end: i\n                            };\n                        }\n                    }\n\n                    patternStart += counter[0] + counter[1];\n                    for (let j = 0; j < 7; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[7] = 0;\n                    counter[8] = 0;\n                    counterPos--;\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n}\n","import { Barcode } from './barcode-reader';\nimport { Code39Reader } from './code-39-reader';\n\nexport class Code39VINReader extends Code39Reader {\n    constructor() {\n        super();\n\n        this._format = 'code_39_vin';\n    }\n\n    /**\n     * @borrows\n     * https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/client/result/VINResultParser.java\n     */\n    decode(): Barcode {\n        const result = super.decode();\n        if (!result) {\n            return null;\n        }\n\n        let code = result.code;\n\n        if (!code) {\n            return null;\n        }\n\n        code = code.replace(/[IOQ]/g, '');\n\n        if (!/[A-Z0-9]{17}/.test(code)) {\n            if (process.env.NODE_ENV !== 'production') {\n                console.log('Failed AZ09 pattern code:', code);\n            }\n            return null;\n        }\n\n        if (!this._checkChecksum(code)) {\n            return null;\n        }\n\n        result.code = code;\n        return result;\n    }\n\n    private _checkChecksum(code: string): boolean {\n        // TODO\n        return !!code;\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader } from './barcode-reader';\n\nconst ALPHABETH_STRING = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*';\nconst ALPHABET = new Uint16Array([...ALPHABETH_STRING].map(char => char.charCodeAt(0)));\nconst CHARACTER_ENCODINGS = new Uint16Array([\n    0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, 0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A,\n    0x168, 0x164, 0x162, 0x134, 0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, 0x196, 0x19A,\n    0x16C, 0x166, 0x136, 0x13A, 0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, 0x126, 0x1DA, 0x1D6, 0x132, 0x15E\n]);\nconst ASTERISK = 0x15E;\n\nexport class Code93Reader extends BarcodeReader {\n    constructor() {\n        super();\n\n        this._format = 'code_93';\n    }\n\n    decode(): Barcode {\n        const start = this._findStart();\n\n        if (!start) {\n            return null;\n        }\n\n        let result = new Array<string>();\n        let counters = new Uint16Array(6);\n        let decodedChar: string;\n        let lastStart: number;\n        let nextStart = this._nextSet(this._row, start.end);\n\n        do {\n            this._toCounters(nextStart, counters);\n            const pattern = this._toPattern(counters);\n            if (pattern < 0) {\n                return null;\n            }\n            decodedChar = this._patternToChar(pattern);\n            if (decodedChar === null) {\n                return null;\n            }\n            result.push(decodedChar);\n            lastStart = nextStart;\n            nextStart += counters.reduce((sum, item) => sum + item, 0);\n            nextStart = this._nextSet(this._row, nextStart);\n        } while (decodedChar !== '*');\n        result.pop();\n\n        if (!result.length) {\n            return null;\n        }\n\n        if (!this._verifyEnd(lastStart, nextStart)) {\n            return null;\n        }\n\n        if (!this._verifyChecksums(result)) {\n            return null;\n        }\n\n        result = result.slice(0, result.length - 2);\n        if ((result = this._decodeExtended(result)) === null) {\n            return null;\n        }\n\n        return {\n            code: result.join(''),\n            start: start.start,\n            end: nextStart,\n            startInfo: start,\n            decodedCodes: result\n        };\n    }\n\n    protected _patternToChar(pattern: number): string {\n        for (let i = 0; i < CHARACTER_ENCODINGS.length; i++) {\n            if (CHARACTER_ENCODINGS[i] === pattern) {\n                return String.fromCharCode(ALPHABET[i]);\n            }\n        }\n        return null;\n    }\n\n    private _verifyEnd(lastStart: number, nextStart: number): boolean {\n        if (lastStart === nextStart || !this._row[nextStart]) {\n            return false;\n        }\n        return true;\n    }\n\n    private _toPattern(counters: Uint16Array): number {\n        const numCounters = counters.length;\n        let pattern = 0;\n        let sum = 0;\n        for (let i = 0; i < numCounters; i++) {\n            sum += counters[i];\n        }\n\n        for (let i = 0; i < numCounters; i++) {\n            let normalized = Math.round(counters[i] * 9 / sum);\n            if (normalized < 1 || normalized > 4) {\n                return -1;\n            }\n            if ((i & 1) === 0) {\n                for (let j = 0; j < normalized; j++) {\n                    pattern = (pattern << 1) | 1;\n                }\n            } else {\n                pattern <<= normalized;\n            }\n        }\n\n        return pattern;\n    }\n\n    private _findStart(): BarcodeInfo {\n        const counter = new Uint16Array(6);\n        const offset = this._nextSet(this._row);\n        let patternStart = offset;\n        let counterPos = 0;\n        let isWhite: 0 | 1 = 0;\n        let whiteSpaceMustStart: number;\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    // find start pattern\n                    if (this._toPattern(counter) === ASTERISK) {\n                        whiteSpaceMustStart = Math.max(0, patternStart - ((i - patternStart) / 4)) | 0;\n                        if (this._matchRange(whiteSpaceMustStart, patternStart, 0)) {\n                            return {\n                                start: patternStart,\n                                end: i\n                            };\n                        }\n                    }\n\n                    patternStart += counter[0] + counter[1];\n                    for (let j = 0; j < 4; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[4] = 0;\n                    counter[5] = 0;\n                    counterPos--;\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n\n    private _decodeExtended(charArray: Array<string>): Array<string> {\n        const length = charArray.length;\n        const result = new Array<string>();\n        for (let i = 0; i < length; i++) {\n            const char = charArray[i];\n            if (char >= 'a' && char <= 'd') {\n                if (i > (length - 2)) {\n                    return null;\n                }\n                const nextChar = charArray[++i];\n                const nextCharCode = nextChar.charCodeAt(0);\n                let decodedChar: string;\n                switch (char) {\n                    case 'a': {\n                        if (nextChar >= 'A' && nextChar <= 'Z') {\n                            decodedChar = String.fromCharCode(nextCharCode - 64);\n                        } else {\n                            return null;\n                        }\n                        break;\n                    }\n                    case 'b': {\n                        if (nextChar >= 'A' && nextChar <= 'E') {\n                            decodedChar = String.fromCharCode(nextCharCode - 38);\n                        } else if (nextChar >= 'F' && nextChar <= 'J') {\n                            decodedChar = String.fromCharCode(nextCharCode - 11);\n                        } else if (nextChar >= 'K' && nextChar <= 'O') {\n                            decodedChar = String.fromCharCode(nextCharCode + 16);\n                        } else if (nextChar >= 'P' && nextChar <= 'S') {\n                            decodedChar = String.fromCharCode(nextCharCode + 43);\n                        } else if (nextChar >= 'T' && nextChar <= 'Z') {\n                            decodedChar = String.fromCharCode(127);\n                        } else {\n                            return null;\n                        }\n                        break;\n                    }\n                    case 'c': {\n                        if (nextChar >= 'A' && nextChar <= 'O') {\n                            decodedChar = String.fromCharCode(nextCharCode - 32);\n                        } else if (nextChar === 'Z') {\n                            decodedChar = ':';\n                        } else {\n                            return null;\n                        }\n                        break;\n                    }\n                    case 'd': {\n                        if (nextChar >= 'A' && nextChar <= 'Z') {\n                            decodedChar = String.fromCharCode(nextCharCode + 32);\n                        } else {\n                            return null;\n                        }\n                        break;\n                    }\n                }\n                result.push(decodedChar);\n            } else {\n                result.push(char);\n            }\n        }\n        return result;\n    }\n\n    private _verifyChecksums(charArray: Array<string>): boolean {\n        return this._matchCheckChar(charArray, charArray.length - 2, 20)\n            && this._matchCheckChar(charArray, charArray.length - 1, 15);\n    }\n\n    private _matchCheckChar(charArray: Array<string>, index: number, maxWeight: number): boolean {\n        const arrayToCheck = charArray.slice(0, index);\n        const length = arrayToCheck.length;\n        const weightedSums = arrayToCheck.reduce((sum, char, i) => {\n            const weight = (((i * -1) + (length - 1)) % maxWeight) + 1;\n            const value = ALPHABET.indexOf(char.charCodeAt(0));\n            return sum + (weight * value);\n        }, 0);\n\n        const checkChar = ALPHABET[(weightedSums % 47)];\n        return checkChar === charArray[index].charCodeAt(0);\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nexport class EAN2Reader extends EANReader {\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'ean_2';\n    }\n\n    decode(row?: Array<number>, start?: number): Barcode {\n        const end = row.length;\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n        let offset = start;\n        let codeFrequency = 0;\n        let code: BarcodeInfo;\n\n        this._row = row;\n\n        for (let i = 0; i < 2 && offset < end; i++) {\n            code = this._decodeCode(offset);\n            if (!code) {\n                return null;\n            }\n            decodedCodes.push(code);\n            result.push(code.code % 10);\n            if (code.code >= this.CODE_G_START) {\n                codeFrequency |= 1 << (1 - i);\n            }\n            if (i !== 1) {\n                offset = this._nextSet(this._row, code.end);\n                offset = this._nextUnset(this._row, offset);\n            }\n        }\n\n        if (result.length !== 2 || (parseInt(result.join('')) % 4) !== codeFrequency) {\n            return null;\n        }\n\n        return {\n            code: result.join(''),\n            decodedCodes,\n            end: code.end\n        };\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nexport class EAN5Reader extends EANReader {\n    get CHECK_DIGIT_ENCODINGS(): Array<number> {\n        return [24, 20, 18, 17, 12, 6, 3, 10, 9, 5];\n    }\n\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'ean_5';\n    }\n\n    decode(row?: Array<number>, start?: number): Barcode {\n        const end = row.length;\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n        let codeFrequency = 0;\n        let offset = start;\n        let code: BarcodeInfo;\n\n        this._row = row;\n\n        for (let i = 0; i < 5 && offset < end; i++) {\n            code = this._decodeCode(offset);\n            if (!code) {\n                return null;\n            }\n            decodedCodes.push(code);\n            result.push(code.code % 10);\n            if (code.code >= this.CODE_G_START) {\n                codeFrequency |= 1 << (4 - i);\n            }\n            if (i !== 4) {\n                offset = this._nextSet(this._row, code.end);\n                offset = this._nextUnset(this._row, offset);\n            }\n        }\n\n        if (result.length !== 5) {\n            return null;\n        }\n\n        if (this._extensionChecksum(result) !== this._determineCheckDigit(codeFrequency)) {\n            return null;\n        }\n\n        return {\n            code: result.join(''),\n            decodedCodes,\n            end: code.end\n        };\n    }\n\n    private _determineCheckDigit(codeFrequency: number): number | null {\n        for (let i = 0; i < 10; i++) {\n            if (codeFrequency === this.CHECK_DIGIT_ENCODINGS[i]) {\n                return i;\n            }\n        }\n        return null;\n    }\n\n    private _extensionChecksum(result: Array<number>): number {\n        let length = result.length;\n        let sum = 0;\n\n        for (let i = length - 2; i >= 0; i -= 2) {\n            sum += result[i];\n        }\n        sum *= 3;\n        for (let i = length - 1; i >= 0; i -= 2) {\n            sum += result[i];\n        }\n        sum *= 3;\n\n        return sum % 10;\n    }\n}\n","import { BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nexport class EAN8Reader extends EANReader {\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'ean_8';\n    }\n\n    protected _decodePayload(code: BarcodeInfo, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo {\n        for (let i = 0; i < 4; i++) {\n            code = this._decodeCode(code.end, this.CODE_G_START);\n            if (!code) {\n                return null;\n            }\n            result.push(code.code);\n            decodedCodes.push(code);\n        }\n\n        code = this._findPattern(this.MIDDLE_PATTERN, code.end, 1, false);\n\n        if (code === null) {\n            return null;\n        }\n\n        decodedCodes.push(code);\n\n        for (let i = 0; i < 4; i++) {\n            code = this._decodeCode(code.end, this.CODE_G_START);\n\n            if (!code) {\n                return null;\n            }\n\n            decodedCodes.push(code);\n            result.push(code.code);\n        }\n\n        return code;\n    }\n}\n","import { merge } from '../common/merge';\nimport { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\n\nconst EXTENSION_START_PATTERN = [1, 1, 2];\nconst CODE_PATTERN = [\n    [3, 2, 1, 1],\n    [2, 2, 2, 1],\n    [2, 1, 2, 2],\n    [1, 4, 1, 1],\n    [1, 1, 3, 2],\n    [1, 2, 3, 1],\n    [1, 1, 1, 4],\n    [1, 3, 1, 2],\n    [1, 2, 1, 3],\n    [3, 1, 1, 2],\n    [1, 1, 2, 3],\n    [1, 2, 2, 2],\n    [2, 2, 1, 2],\n    [1, 1, 4, 1],\n    [2, 3, 1, 1],\n    [1, 3, 2, 1],\n    [4, 1, 1, 1],\n    [2, 1, 3, 1],\n    [3, 1, 2, 1],\n    [2, 1, 1, 3]\n];\nconst CODE_FREQUENCY = [0, 11, 13, 14, 19, 25, 28, 21, 22, 26];\n\nexport class EANReader extends BarcodeReader {\n    get CODE_L_START(): number {\n        return 0;\n    }\n\n    get CODE_G_START(): number {\n        return 10;\n    }\n\n    get START_PATTERN(): Array<number> {\n        return [1, 1, 1];\n    }\n\n    get STOP_PATTERN(): Array<number> {\n        return [1, 1, 1];\n    }\n\n    get MIDDLE_PATTERN(): Array<number> {\n        return [1, 1, 1, 1, 1];\n    }\n\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(merge({\n            supplements: [] // Allowed extensions to be decoded (2 and/or 5)\n        }, config), supplements);\n\n        this._format = 'ean_13';\n        this._singleCodeError = 0.70;\n        this._averageCodeError = 0.48;\n    }\n\n    protected _decodeCode(start: number, coderange?: number): BarcodeInfo {\n        const counter = [0, 0, 0, 0];\n        const offset = start;\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: start,\n            end: start\n        };\n        const epsilon = this.AVERAGE_CODE_ERROR;\n        let isWhite: 0 | 1 = this._row[offset] ? 0 : 1;\n        let counterPos = 0;\n\n        if (!coderange) {\n            coderange = CODE_PATTERN.length;\n        }\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    for (let code = 0; code < coderange; code++) {\n                        const error = this._matchPattern(counter, CODE_PATTERN[code]);\n                        if (error < bestMatch.error) {\n                            bestMatch.code = code;\n                            bestMatch.error = error;\n                        }\n                    }\n                    bestMatch.end = i;\n                    if (bestMatch.error > epsilon) {\n                        return null;\n                    }\n                    return bestMatch;\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n\n    protected _findStart(): BarcodeInfo {\n        let offset = this._nextSet(this._row);\n        let startInfo: BarcodeInfo;\n\n        while (!startInfo) {\n            startInfo = this._findPattern(this.START_PATTERN, offset, 0, true);\n\n            if (!startInfo) {\n                return null;\n            }\n\n            const leadingWhitespaceStart = startInfo.start - (startInfo.end - startInfo.start);\n\n            if (leadingWhitespaceStart >= 0) {\n                if (this._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                    return startInfo;\n                }\n            }\n\n            offset = startInfo.end;\n            startInfo = null;\n        }\n\n        return null;\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start);\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n\n    protected _findEnd(offset: number, isWhite: 0 | 1): BarcodeInfo {\n        const endInfo = this._findPattern(this.STOP_PATTERN, offset, isWhite, false);\n\n        return endInfo !== null ? this._verifyTrailingWhitespace(endInfo) : null;\n    }\n\n    private _calculateFirstDigit(codeFrequency: number): number | null {\n        for (let i = 0; i < CODE_FREQUENCY.length; i++) {\n            if (codeFrequency === CODE_FREQUENCY[i]) {\n                return i;\n            }\n        }\n        return null;\n    }\n\n    protected _decodePayload(code: BarcodeInfo, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo {\n        let codeFrequency = 0x0;\n\n        for (let i = 0; i < 6; i++) {\n            code = this._decodeCode(code.end);\n            if (!code) {\n                return null;\n            }\n            if (code.code >= this.CODE_G_START) {\n                code.code -= this.CODE_G_START;\n                codeFrequency |= 1 << (5 - i);\n            } else {\n                codeFrequency |= 0 << (5 - i);\n            }\n            result.push(code.code);\n            decodedCodes.push(code);\n        }\n\n        const firstDigit = this._calculateFirstDigit(codeFrequency);\n\n        if (firstDigit === null) {\n            return null;\n        }\n\n        result.unshift(firstDigit);\n\n        code = this._findPattern(this.MIDDLE_PATTERN, code.end, 1, false);\n\n        if (code === null) {\n            return null;\n        }\n\n        decodedCodes.push(code);\n\n        for (let i = 0; i < 6; i++) {\n            code = this._decodeCode(code.end, this.CODE_G_START);\n\n            if (!code) {\n                return null;\n            }\n\n            decodedCodes.push(code);\n            result.push(code.code);\n        }\n\n        return code;\n    }\n\n    decode(): Barcode {\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n        let resultInfo: Barcode = {};\n        let startInfo = this._findStart();\n\n        if (!startInfo) {\n            return null;\n        }\n\n        let code: BarcodeInfo = {\n            code: startInfo.code,\n            start: startInfo.start,\n            end: startInfo.end\n        };\n        decodedCodes.push(code);\n\n        code = this._decodePayload(code, result, decodedCodes);\n\n        if (!code) {\n            return null;\n        }\n\n        code = this._findEnd(code.end, 0);\n\n        if (!code) {\n            return null;\n        }\n\n        decodedCodes.push(code);\n\n        // Checksum\n        if (!this._checksum(result)) {\n            return null;\n        }\n\n        if (this.supplements.length > 0) {\n            const supplement = this._decodeExtensions(code.end);\n            if (!supplement) {\n                return null;\n            }\n\n            const lastCode = supplement.decodedCodes[supplement.decodedCodes.length - 1] as BarcodeInfo;\n            const endInfo = {\n                start: lastCode.start + (((lastCode.end - lastCode.start) / 2) | 0),\n                end: lastCode.end\n            };\n\n            if (!this._verifyTrailingWhitespace(endInfo)) {\n                return null;\n            }\n\n            resultInfo = {\n                supplement,\n                code: result.join('') + supplement.code\n            };\n        }\n\n        return {\n            code: result.join(''),\n            start: startInfo.start,\n            end: code.end,\n            startInfo,\n            decodedCodes,\n            ...resultInfo\n        };\n    }\n\n    private _decodeExtensions(offset: number): Barcode {\n        const start = this._nextSet(this._row, offset);\n        const startInfo = this._findPattern(EXTENSION_START_PATTERN, start, 0, false);\n\n        if (startInfo === null) {\n            return null;\n        }\n\n        for (let i = 0; i < this.supplements.length; i++) {\n            let result = this.supplements[i].decode(this._row, startInfo.end);\n            if (result !== null) {\n                return {\n                    code: result.code,\n                    start,\n                    startInfo,\n                    end: result.end,\n                    decodedCodes: result.decodedCodes\n                };\n            }\n        }\n\n        return null;\n    }\n\n    protected _checksum(result: Array<number>): boolean {\n        let sum = 0;\n\n        for (let i = result.length - 2; i >= 0; i -= 2) {\n            sum += result[i];\n        }\n\n        sum *= 3;\n\n        for (let i = result.length - 1; i >= 0; i -= 2) {\n            sum += result[i];\n        }\n\n        return sum % 10 === 0;\n    }\n}","import { merge } from '../common/merge';\nimport { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\n\nconst N = 1;\nconst W = 3;\nconst START_PATTERN = [N, N, N, N];\nconst STOP_PATTERN = [N, N, W];\nconst CODE_PATTERN = [\n    [N, N, W, W, N],\n    [W, N, N, N, W],\n    [N, W, N, N, W],\n    [W, W, N, N, N],\n    [N, N, W, N, W],\n    [W, N, W, N, N],\n    [N, W, W, N, N],\n    [N, N, N, W, W],\n    [W, N, N, W, N],\n    [N, W, N, W, N]\n];\nconst MAX_CORRECTION_FACTOR = 5;\n\nexport class I2of5Reader extends BarcodeReader {\n    private _barSpaceRatio: [number, number];\n\n    constructor(config?: BarcodeReaderConfig) {\n        super(merge({\n            normalizeBarSpaceWidth: false // Normalize the width difference between bars and spaces\n        }, config));\n\n        this._barSpaceRatio = [1, 1];\n        this._format = 'i2of5';\n\n        if (this.config.normalizeBarSpaceWidth) {\n            this._singleCodeError = 0.38;\n            this._averageCodeError = 0.09;\n        } else {\n            this._singleCodeError = 0.78;\n            this._averageCodeError = 0.38;\n        }\n    }\n\n    decode(): Barcode {\n        const startInfo = this._findStart();\n\n        if (!startInfo) {\n            return null;\n        }\n\n        const endInfo = this._findEnd();\n\n        if (!endInfo) {\n            return null;\n        }\n\n        const counters = this._fillCounters(startInfo.end, endInfo.start, 0);\n\n        if (counters.length % 10 !== 0) {\n            return null;\n        }\n\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n\n        decodedCodes.push(startInfo);\n\n        const code = this._decodePayload(counters, result, decodedCodes);\n\n        if (!code || result.length % 2 !== 0 || result.length < 6) {\n            return null;\n        }\n\n        decodedCodes.push(endInfo);\n\n        return {\n            code: result.join(''),\n            start: startInfo.start,\n            end: endInfo.end,\n            startInfo,\n            decodedCodes\n        };\n    }\n\n    protected _matchPattern(counter: Array<number>, code: ReadonlyArray<number>): number {\n        if (this.config.normalizeBarSpaceWidth) {\n            const counterSum: [number, number] = [0, 0];\n            const codeSum: [number, number] = [0, 0];\n            const correction: [number, number] = [0, 0];\n            const correctionRatio = MAX_CORRECTION_FACTOR;\n            const correctionRatioInverse = 1 / correctionRatio;\n\n            for (let i = 0; i < counter.length; i++) {\n                counterSum[i % 2] += counter[i];\n                codeSum[i % 2] += code[i];\n            }\n\n            correction[0] = codeSum[0] / counterSum[0];\n            correction[1] = codeSum[1] / counterSum[1];\n\n            correction[0] = Math.max(Math.min(correction[0], correctionRatio), correctionRatioInverse);\n            correction[1] = Math.max(Math.min(correction[1], correctionRatio), correctionRatioInverse);\n            this._barSpaceRatio = correction;\n\n            for (let i = 0; i < counter.length; i++) {\n                counter[i] *= this._barSpaceRatio[i % 2];\n            }\n        }\n\n        return super._matchPattern(counter, code);\n    }\n\n    protected _findStart(): BarcodeInfo {\n        let offset = this._nextSet(this._row);\n        let startInfo: BarcodeInfo;\n\n        while (!startInfo) {\n            startInfo = this._findPattern(START_PATTERN, offset, 0, true);\n            if (!startInfo) {\n                return null;\n            }\n\n            const narrowBarWidth = (startInfo.end - startInfo.start) >> 2;\n            const leadingWhitespaceStart = startInfo.start - narrowBarWidth * 10;\n\n            if (leadingWhitespaceStart >= 0) {\n                if (this._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                    return startInfo;\n                }\n            }\n\n            offset = startInfo.end;\n            startInfo = null;\n        }\n\n        return null;\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n\n    protected _findEnd(): BarcodeInfo {\n        this._row.reverse();\n\n        const endInfo = this._findPattern(STOP_PATTERN, undefined, 0, false);\n\n        this._row.reverse();\n\n        if (endInfo === null) {\n            return null;\n        }\n\n        // reverse numbers\n        const start = endInfo.start;\n        endInfo.start = this._row.length - endInfo.end;\n        endInfo.end = this._row.length - start;\n\n        return endInfo !== null ? this._verifyTrailingWhitespace(endInfo) : null;\n    }\n\n    protected _decodeCode(counter: Array<number>): BarcodeInfo {\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        };\n\n        for (let code = 0; code < CODE_PATTERN.length; code++) {\n            const error = this._matchPattern(counter, CODE_PATTERN[code]);\n            if (error < bestMatch.error) {\n                bestMatch.code = code;\n                bestMatch.error = error;\n            }\n        }\n\n        return bestMatch.error < this.AVERAGE_CODE_ERROR ? bestMatch : null;\n    }\n\n    protected _decodePayload(counters: ReadonlyArray<number>, result: Array<number>, decodedCodes: Array<BarcodeInfo>): [BarcodeInfo, BarcodeInfo] {\n        const counterLength = counters.length;\n        const counter0 = [0, 0, 0, 0, 0];\n        const counter1 = [0, 0, 0, 0, 0];\n        let code0: BarcodeInfo;\n        let code1: BarcodeInfo;\n        let pos = 0;\n\n        while (pos < counterLength) {\n            for (let i = 0; i < 5; i++) {\n                counter0[i] = counters[pos] * this._barSpaceRatio[0];\n                counter1[i] = counters[pos + 1] * this._barSpaceRatio[1];\n                pos += 2;\n            }\n\n            code0 = this._decodeCode(counter0);\n            if (!code0) {\n                return null;\n            }\n\n            code1 = this._decodeCode(counter1);\n            if (!code1) {\n                return null;\n            }\n\n            result.push(code0.code, code1.code);\n            decodedCodes.push(code0, code1);\n        }\n\n        return [code0, code1];\n    }\n}\n","import { Code128Reader } from './code-128-reader';\nimport { Code39Reader } from './code-39-reader';\nimport { Code39VINReader } from './code-39-vin-reader';\nimport { CodabarReader } from './codabar-reader';\nimport { EANReader } from './ean-reader';\nimport { EAN8Reader } from './ean-8-reader';\nimport { EAN2Reader } from './ean-2-reader';\nimport { EAN5Reader } from './ean-5-reader';\nimport { UPCReader } from './upc-reader';\nimport { UPCEReader } from './upc-e-reader';\nimport { I2of5Reader } from './i2of5-reader';\nimport { TwoOfFiveReader } from './2of5-reader';\nimport { Code93Reader } from './code-93-reader';\n\nexport const Readers = {\n    code_128_reader: Code128Reader,\n    ean_reader: EANReader,\n    ean_5_reader: EAN5Reader,\n    ean_2_reader: EAN2Reader,\n    ean_8_reader: EAN8Reader,\n    code_39_reader: Code39Reader,\n    code_39_vin_reader: Code39VINReader,\n    codabar_reader: CodabarReader,\n    upc_reader: UPCReader,\n    upc_e_reader: UPCEReader,\n    i2of5_reader: I2of5Reader,\n    '2of5_reader': TwoOfFiveReader,\n    code_93_reader: Code93Reader\n};\n","import { BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nconst CODE_FREQUENCY = [[56, 52, 50, 49, 44, 38, 35, 42, 41, 37], [7, 11, 13, 14, 19, 25, 28, 21, 22, 26]];\n\nexport class UPCEReader extends EANReader {\n    get STOP_PATTERN() {\n        return [1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7];\n    }\n\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'upc_e';\n    }\n\n    protected _decodePayload(code: BarcodeInfo, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo {\n        let codeFrequency = 0x0;\n\n        for (let i = 0; i < 6; i++) {\n            code = this._decodeCode(code.end);\n            if (!code) {\n                return null;\n            }\n            if (code.code >= this.CODE_G_START) {\n                code.code = code.code - this.CODE_G_START;\n                codeFrequency |= 1 << (5 - i);\n            }\n            result.push(code.code);\n            decodedCodes.push(code);\n        }\n\n        if (!this._determineParity(codeFrequency, result)) {\n            return null;\n        }\n\n        return code;\n    }\n\n    private _determineParity(codeFrequency: number, result: Array<number>): boolean {\n        for (let nrSystem = 0; nrSystem < CODE_FREQUENCY.length; nrSystem++) {\n            for (let i = 0; i < CODE_FREQUENCY[nrSystem].length; i++) {\n                if (codeFrequency === CODE_FREQUENCY[nrSystem][i]) {\n                    result.unshift(nrSystem);\n                    result.push(i);\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n\n    private _convertToUPCA(result: Array<number>): Array<number> {\n        const lastDigit = result[result.length - 2];\n        let upca = [result[0]];\n\n        if (lastDigit <= 2) {\n            upca = upca.concat(result.slice(1, 3)).concat([lastDigit, 0, 0, 0, 0]).concat(result.slice(3, 6));\n        } else if (lastDigit === 3) {\n            upca = upca.concat(result.slice(1, 4)).concat([0, 0, 0, 0, 0]).concat(result.slice(4, 6));\n        } else if (lastDigit === 4) {\n            upca = upca.concat(result.slice(1, 5)).concat([0, 0, 0, 0, 0, result[5]]);\n        } else {\n            upca = upca.concat(result.slice(1, 6)).concat([0, 0, 0, 0, lastDigit]);\n        }\n\n        upca.push(result[result.length - 1]);\n        return upca;\n    }\n\n    protected _checksum(result: Array<number>): boolean {\n        return super._checksum(this._convertToUPCA(result));\n    }\n\n    protected _findEnd(offset: number, isWhite: 0 | 1) {\n        isWhite = 1;\n        return super._findEnd(offset, isWhite);\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n}","import { Barcode, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nexport class UPCReader extends EANReader {\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'upc_a';\n    }\n\n    decode(): Barcode {\n        const result = super.decode();\n\n        if (result && result.code && result.code.length === 13 && result.code.charAt(0) === '0') {\n            result.code = result.code.substring(1);\n            return result;\n        }\n\n        return null;\n    }\n}"],"sourceRoot":""}
\ No newline at end of file
diff --git a/dist/quagga.min.js b/dist/quagga.min.js
index f7a30f41..69987eba 100644
--- a/dist/quagga.min.js
+++ b/dist/quagga.min.js
@@ -1 +1 @@
-!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e(e.toString()).default:"object"==typeof exports?exports.Quagga=e(e.toString()).default:t.Quagga=e(e.toString()).default}(this,function(t){return function(t){function e(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return t[r].call(o.exports,o,o.exports,e),o.l=!0,o.exports}var n={};return e.m=t,e.c=n,e.i=function(t){return t},e.d=function(t,n,r){e.o(t,n)||Object.defineProperty(t,n,{configurable:!1,enumerable:!0,get:r})},e.n=function(t){var n=t&&t.__esModule?function(){return t.default}:function(){return t};return e.d(n,"a",n),n},e.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},e.p="/",e(e.s=166)}([function(t,e){function n(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}t.exports=n},function(t,e,n){"use strict";function r(t,e){return this._row=[],this.config=t||{},this.supplements=e,this}var o=n(3);r.prototype._nextUnset=function(t,e){var n;for(void 0===e&&(e=0),n=e;nn)return Number.MAX_VALUE;u+=c}return u/f},r.prototype._nextSet=function(t,e){var n;for(e=e||0,n=e;n1&&(t[n[r]]=o)},r.prototype._matchTrace=function(t,e){var n,r,o=[],i=this,a=i._nextSet(i._row),u=!i._row[a],c=0,s={error:Number.MAX_VALUE,code:-1,start:0};if(t){for(n=0;n=0;r--)e=Math.floor(Math.random()*r),n=t[r],t[r]=t[e],t[e]=n;return t},toPointList:function(t){var e,n,r=[],o=[];for(e=0;e=e&&o.push(t[r]);return o},maxIndex:function(t){var e,n=0;for(e=0;et[n]&&(n=e);return n},max:function t(e){var n,t=0;for(n=0;nt&&(t=e[n]);return t},sum:function t(e){for(var n=e.length,t=0;n--;)t+=e[n];return t}}},function(t,e,n){"use strict";function r(t,e){t=a()(o(),t),u.a.call(this,t,e)}function o(){var t={};return Object.keys(r.CONFIG_KEYS).forEach(function(e){t[e]=r.CONFIG_KEYS[e].default}),t}var i=n(28),a=n.n(i),u=n(1),c=Object.assign||function(t){for(var e=1;ea.AVG_CODE_ERROR?null:f}s++,i[s]=1,c=!c}return null},r.prototype._findPattern=function(t,e,n,r,o){var i,a,u,c,s=[],f=this,l=0,d={error:Number.MAX_VALUE,code:-1,start:0,end:0};for(e||(e=f._nextSet(f._row)),void 0===n&&(n=!1),void 0===r&&(r=!0),void 0===o&&(o=f.AVG_CODE_ERROR),i=0;i=0&&n._matchRange(t,e.start,0))return e;r=e.end,e=null}},r.prototype._verifyTrailingWhitespace=function(t){var e,n=this;return e=t.end+(t.end-t.start),e=i.CODE_G_START?(t.code=t.code-i.CODE_G_START,a|=1<<5-r):a|=0<<5-r,e.push(t.code),n.push(t)}if(null===(o=i._calculateFirstDigit(a)))return null;if(e.unshift(o),null===(t=i._findPattern(i.MIDDLE_PATTERN,t.end,!0,!1)))return null;for(n.push(t),r=0;r<6;r++){if(!(t=i._decodeCode(t.end,i.CODE_G_START)))return null;n.push(t),e.push(t.code)}return t},r.prototype._decode=function(){var t,e,n=this,r=[],o=[],i={};if(!(t=n._findStart()))return null;if(e={code:t.code,start:t.start,end:t.end},o.push(e),!(e=n._decodePayload(e,r,o)))return null;if(!(e=n._findEnd(e.end,!1)))return null;if(o.push(e),!n._checksum(r))return null;if(this.supplements.length>0){var a=this._decodeExtensions(e.end);if(!a)return null;var u=a.decodedCodes[a.decodedCodes.length-1],s={start:u.start+((u.end-u.start)/2|0),end:u.end};if(!n._verifyTrailingWhitespace(s))return null;i={supplement:a,code:r.join("")+a.code}}return c({code:r.join(""),start:t.start,end:e.end,codeset:"",startInfo:t,decodedCodes:o},i)},r.prototype._decodeExtensions=function(t){var e,n,r=this._nextSet(this._row,t),o=this._findPattern(this.EXTENSION_START_PATTERN,r,!1,!1);if(null===o)return null;for(e=0;e=0;e-=2)n+=t[e];for(n*=3,e=t.length-1;e>=0;e-=2)n+=t[e];return n%10==0},r.CONFIG_KEYS={supplements:{type:"arrayOf(string)",default:[],description:"Allowed extensions to be decoded (2 and/or 5)"}},e.a=r},function(t,e,n){var r=n(38),o="object"==typeof self&&self&&self.Object===Object&&self,i=r||o||Function("return this")();t.exports=i},function(t,e){function n(t){return null!=t&&"object"==typeof t}t.exports=n},function(t,e){function n(t){var e=new Float32Array(2);return e[0]=t[0],e[1]=t[1],e}t.exports=n},function(t,e,n){function r(t){return null==t?void 0===t?c:u:s&&s in Object(t)?i(t):a(t)}var o=n(11),i=n(119),a=n(146),u="[object Null]",c="[object Undefined]",s=o?o.toStringTag:void 0;t.exports=r},function(t,e,n){"use strict";e.a={drawRect:function(t,e,n,r){n.strokeStyle=r.color,n.fillStyle=r.color,n.lineWidth=1,n.beginPath(),n.strokeRect(t.x,t.y,e.x,e.y)},drawPath:function(t,e,n,r){n.strokeStyle=r.color,n.fillStyle=r.color,n.lineWidth=r.lineWidth,n.beginPath(),n.moveTo(t[0][e.x],t[0][e.y]);for(var o=1;o-1&&t%1==0&&t0?Math.floor(this.x+.5):Math.floor(this.x-.5),this.y=this.y>0?Math.floor(this.y+.5):Math.floor(this.y-.5),this}}}function o(t,e,n){n||(n=t);for(var r=t.data,o=r.length,i=n.data;o--;)i[o]=r[o]>o]++;return a}function a(t,e){function n(t,e){var n,r=0;for(n=t;n<=e;n++)r+=a[n];return r}function r(t,e){var n,r=0;for(n=t;n<=e;n++)r+=n*a[n];return r}function o(){var o,u,c,s,f,l,d,h=[0],p=(1<c)for(i=s[u],i.score=o,i.item=t[r],c=Number.MAX_VALUE,a=0;ae[r]?r++:n++;return o}function _(t,e){function n(t){for(var e=0,n=t[Math.floor(t.length/2)];e0&&(n=Math.abs(t[e]-d)>Math.abs(t[e-1]-d)?t[e-1]:t[e]),d/nc[f-1]/c[f]?{x:n,y:n}:null}var r,o=p(e.x),i=p(e.y),a=Math.max(e.x,e.y),u=v(o,i),c=[8,10,15,20,32,60,80],s={"x-small":5,small:4,medium:3,large:2,"x-large":1},f=s[t]||s.medium,l=c[f],d=Math.floor(a/l);return r=n(u),r||(r=n(p(a)))||(r=n(p(d*l))),r}function g(t){return{value:parseFloat(t),unit:(t.indexOf("%"),t.length,"%")}}function y(t,e,n){var r={width:t,height:e},o=Object.keys(n).reduce(function(t,e){var o=n[e],i=g(o),a=C[e](i,r);return t[e]=a,t},{});return{sx:o.left,sy:o.top,sw:o.right-o.left,sh:o.bottom-o.top}}var m=n(50),x=n(3);e.b=r,e.f=u,e.g=c,e.h=s,e.c=f,e.d=l,e.i=d,e.a=h,e.e=_,e.j=y;var b={clone:n(7)},E={clone:n(83)},C={top:function(t,e){if("%"===t.unit)return Math.floor(e.height*(t.value/100))},right:function(t,e){if("%"===t.unit)return Math.floor(e.width-e.width*(t.value/100))},bottom:function(t,e){if("%"===t.unit)return Math.floor(e.height-e.height*(t.value/100))},left:function(t,e){if("%"===t.unit)return Math.floor(e.width*(t.value/100))}}},function(t,e,n){"use strict";function r(t,e,n,r){e?this.data=e:n?(this.data=new n(t.x*t.y),n===Array&&r&&a.a.init(this.data,0)):(this.data=new Uint8Array(t.x*t.y),Uint8Array===Array&&r&&a.a.init(this.data,0)),this.size=t}var o=n(53),i=n(19),a=n(3),u={clone:n(7)};r.prototype.inImageWithBorder=function(t,e){return t.x>=e&&t.y>=e&&t.x0&&(a=g[r-1],a.m00+=1,a.m01+=n,a.m10+=e,a.m11+=e*n,a.m02+=o,a.m20+=e*e);for(i=0;i=0?x:-x)+m,a.theta=(180*h/m+90)%180-90,a.theta<0&&(a.theta+=180),a.rad=h>m?h-m:h,a.vec=u.clone([Math.cos(h),Math.sin(h)]),y.push(a));return y},r.prototype.show=function(t,e){var n,r,o,i,a,u,c;for(e||(e=1),n=t.getContext("2d"),t.width=this.size.x,t.height=this.size.y,r=n.getImageData(0,0,t.width,t.height),o=r.data,i=0,c=0;c360)&&(e=360);for(var o=[0,1,1],a=[0,0,0],u=[255,255,255],c=[0,0,0],s=[],f=t.getContext("2d"),l=f.getImageData(r.x,r.y,this.size.x,this.size.y),d=l.data,h=this.data.length;h--;)o[0]=this.data[h]*e,s=o[0]<=0?u:o[0]>=360?c:n.i(i.a)(o,a),d[4*h+0]=s[0],d[4*h+1]=s[1],d[4*h+2]=s[2],d[4*h+3]=255;f.putImageData(l,r.x,r.y)},e.a=r},function(t,e,n){function r(t,e,n){"__proto__"==e&&o?o(t,e,{configurable:!0,enumerable:!0,value:n,writable:!0}):t[e]=n}var o=n(37);t.exports=r},function(t,e,n){function r(t,e){var n=i(t,e);return o(n)?n:void 0}var o=n(97),i=n(120);t.exports=r},function(t,e,n){function r(t){if("string"==typeof t||o(t))return t;var e=t+"";return"0"==e&&1/t==-i?"-0":e}var o=n(27),i=1/0;t.exports=r},function(t,e,n){function r(t){return null!=t&&i(t.length)&&!o(t)}var o=n(25),i=n(26);t.exports=r},function(t,e,n){function r(t){if(!i(t))return!1;var e=o(t);return e==u||e==c||e==a||e==s}var o=n(8),i=n(0),a="[object AsyncFunction]",u="[object Function]",c="[object GeneratorFunction]",s="[object Proxy]";t.exports=r},function(t,e){function n(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=r}var r=9007199254740991;t.exports=n},function(t,e,n){function r(t){return"symbol"==typeof t||i(t)&&o(t)==a}var o=n(8),i=n(6),a="[object Symbol]";t.exports=r},function(t,e,n){var r=n(100),o=n(116),i=o(function(t,e,n){r(t,e,n)});t.exports=i},function(t,e){t.exports=function(t){return t.webpackPolyfill||(t.deprecate=function(){},t.paths=[],t.children||(t.children=[]),Object.defineProperty(t,"loaded",{enumerable:!0,get:function(){return t.l}}),Object.defineProperty(t,"id",{enumerable:!0,get:function(){return t.i}}),t.webpackPolyfill=1),t}},function(t,e,n){"use strict";var r={searchDirections:[[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1],[-1,0],[-1,1]],create:function(t,e){function n(t,e,n,r){var o,f,l;for(o=0;o<7;o++){if(f=t.cy+c[t.dir][0],l=t.cx+c[t.dir][1],i=f*s+l,a[i]===e&&(0===u[i]||u[i]===n))return u[i]=n,t.cy=f,t.cx=l,!0;0===u[i]&&(u[i]=r),t.dir=(t.dir+1)%8}return!1}function r(t,e,n){return{dir:n,x:t,y:e,next:null,prev:null}}function o(t,e,o,i,a){var u,c,s,f=null,l={cx:e,cy:t,dir:0};if(n(l,i,o,a)){f=r(e,t,l.dir),u=f,s=l.dir,c=r(l.cx,l.cy,0),c.prev=u,u.next=c,c.next=null,u=c;do l.dir=(l.dir+6)%8,n(l,i,o,a),s!==l.dir?(u.dir=l.dir,c=r(l.cx,l.cy,0),c.prev=u,u.next=c,c.next=null,u=c):(u.dir=s,u.x=l.cx,u.y=l.cy),s=l.dir;while(l.cx!==e||l.cy!==t);f.prev=u.prev,u.prev.next=f}return f}var i,a=t.data,u=e.data,c=this.searchDirections,s=t.size.x;return{trace:function(t,e,r,o){return n(t,e,r,o)},contourTracing:function(t,e,n,r,i){return o(t,e,n,r,i)}}}};e.a=r},function(t,e,n){"use strict";function r(){o.a.call(this)}var o=n(1),i=n(3),a={ALPHABETH_STRING:{value:"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%"},ALPHABET:{value:[48,49,50,51,52,53,54,55,56,57,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,45,46,32,42,36,47,43,37]},CHARACTER_ENCODINGS:{value:[52,289,97,352,49,304,112,37,292,100,265,73,328,25,280,88,13,268,76,28,259,67,322,19,274,82,7,262,70,22,385,193,448,145,400,208,133,388,196,148,168,162,138,42]},ASTERISK:{value:148},FORMAT:{value:"code_39",writeable:!1}};r.prototype=Object.create(o.a.prototype,a),r.prototype.constructor=r,r.prototype._decode=function(){var t,e,n,r,o=this,a=[0,0,0,0,0,0,0,0,0],u=[],c=o._findStart();if(!c)return null;r=o._nextSet(o._row,c.end);do{if(a=o._toCounters(r,a),(n=o._toPattern(a))<0)return null;if((t=o._patternToChar(n))<0)return null;u.push(t),e=r,r+=i.a.sum(a),r=o._nextSet(o._row,r)}while("*"!==t);return u.pop(),u.length&&o._verifyTrailingWhitespace(e,r,a)?{code:u.join(""),start:c.start,end:r,startInfo:c,decodedCodes:u}:null},r.prototype._verifyTrailingWhitespace=function(t,e,n){var r=i.a.sum(n);return 3*(e-t-r)>=r},r.prototype._patternToChar=function(t){var e,n=this;for(e=0;ee&&(r=t[n]);return r},r.prototype._toPattern=function(t){for(var e,n,r=t.length,o=0,i=r,a=0,u=this;i>3;){for(o=u._findNextWidth(t,o),i=0,e=0,n=0;no&&(e|=1<0;n++)if(t[n]>o&&(i--,2*t[n]>=a))return-1;return e}}return-1},r.prototype._findStart=function(){var t,e,n,r=this,o=r._nextSet(r._row),i=o,a=[0,0,0,0,0,0,0,0,0],u=0,c=!1;for(t=o;t0)for(r=0;r0){if(!(t=Y.filter(function(t){return!t.busy})[0]))return;w.attachData(t.imageData)}else w.attachData(S.data);w.grab()&&(t?(t.busy=!0,t.worker.postMessage({cmd:"process",imageData:t.imageData},[t.imageData.buffer])):_())}else _()}function y(){var t=null,e=1e3/($.frequency||60);T=!1,function n(r){t=t||r,T||(r>=t&&(t+=e,g()),window.requestAnimFrame(n))}(performance.now())}function m(){Q&&"LiveStream"===$.inputStream.type?y():g()}function x(t){var e,n={worker:void 0,imageData:new Uint8Array(R.getWidth()*R.getHeight()),busy:!0};e=C(),n.worker=new Worker(e),n.worker.onmessage=function(r){if("initialized"===r.data.event)return URL.revokeObjectURL(e),n.busy=!1,n.imageData=new Uint8Array(r.data.imageData),t(n);"processed"===r.data.event?(n.imageData=new Uint8Array(r.data.imageData),n.busy=!1,v(r.data.result,n.imageData)):r.data.event},n.worker.postMessage({cmd:"init",size:{x:R.getWidth(),y:R.getHeight()},imageData:n.imageData,config:b($)},[n.imageData.buffer])}function b(t){return X({},t,{inputStream:X({},t.inputStream,{target:null})})}function E(t){function e(t){self.postMessage({event:"processed",imageData:o.data,result:t},[o.data.buffer])}function n(){self.postMessage({event:"initialized",imageData:o.data},[o.data.buffer])}if(t){var r=t().default;if(!r)return void self.postMessage({event:"error",message:"Quagga could not be created"})}var o;self.onmessage=function(t){if("init"===t.data.cmd){var i=t.data.config;i.numOfWorkers=0,o=new r.ImageWrapper({x:t.data.size.x,y:t.data.size.y},new Uint8Array(t.data.imageData)),r.init(i,n,o),r.onProcessed(e)}else"process"===t.data.cmd?(o.data=new Uint8Array(t.data.imageData),r.start()):"setReaders"===t.data.cmd&&r.setReaders(t.data.readers)}}function C(){var e,n;return void 0!==t&&(n=t),e=new Blob(["("+E.toString()+")("+n+");"],{type:"text/javascript"}),window.URL.createObjectURL(e)}function O(t){P?P.setReaders(t):Q&&Y.length>0&&Y.forEach(function(e){e.worker.postMessage({cmd:"setReaders",readers:t})})}function A(t,e){var n=t-Y.length;if(0===n)return e&&e();if(n<0){return Y.slice(n).forEach(function(t){t.worker.terminate()}),Y=Y.slice(0,n),e&&e()}for(var r=function(n){Y.push(n),Y.length>=t&&e&&e()},o=0;oe},getPoints:function(){return a},getCenter:function(){return u}}},createPoint:function(t,e,n){return{rad:t[n],point:t,id:e}}}},function(t,e,n){"use strict";e.a=function(){function t(t){return o[t]||(o[t]={subscribers:[]}),o[t]}function e(){o={}}function n(t,e){t.async?setTimeout(function(){t.callback(e)},4):t.callback(e)}function r(e,n,r){var o;if("function"==typeof n)o={callback:n,async:r};else if(o=n,!o.callback)throw"Callback was not specified on options";t(e).subscribers.push(o)}var o={};return{subscribe:function(t,e,n){return r(t,e,n)},publish:function(e,r){var o=t(e),i=o.subscribers;i.filter(function(t){return!!t.once}).forEach(function(t){n(t,r)}),o.subscribers=i.filter(function(t){return!t.once}),o.subscribers.forEach(function(t){n(t,r)})},once:function(t,e,n){r(t,{callback:e,async:n,once:!0})},unsubscribe:function(n,r){var o;n?(o=t(n),o.subscribers=o&&r?o.subscribers.filter(function(t){return t.callback!==r}):[]):e()}}}()},function(t,e,n){"use strict";function r(){return navigator.mediaDevices&&"function"==typeof navigator.mediaDevices.enumerateDevices?navigator.mediaDevices.enumerateDevices():Promise.reject(new Error("enumerateDevices is not defined"))}function o(t){return navigator.mediaDevices&&"function"==typeof navigator.mediaDevices.getUserMedia?navigator.mediaDevices.getUserMedia(t):Promise.reject(new Error("getUserMedia is not defined"))}e.b=r,e.a=o},function(t,e,n){"use strict";function r(t,e,n){n||(n={data:null,size:e}),this.data=n.data,this.originalSize=n.size,this.I=n,this.from=t,this.size=e}r.prototype.show=function(t,e){var n,r,o,i,a,u,c;for(e||(e=1),n=t.getContext("2d"),t.width=this.size.x,t.height=this.size.y,r=n.getImageData(0,0,t.width,t.height),o=r.data,i=0,a=0;a>>16&65535,r=65535&t,o=e>>>16&65535,i=65535&e;return r*i+(n*i+r*o<<16>>>0)|0},"function"!=typeof Object.assign&&(Object.assign=function(t){"use strict";if(null===t)throw new TypeError("Cannot convert undefined or null to object");for(var e=Object(t),n=1;n1&&(!e.inImageWithBorder(t[0],0)||!e.inImageWithBorder(t[1],0));)r-=Math.ceil(r/2),o(-r);return t}function u(t){return[{x:(t[1][0]-t[0][0])/2+t[0][0],y:(t[1][1]-t[0][1])/2+t[0][1]},{x:(t[3][0]-t[2][0])/2+t[2][0],y:(t[3][1]-t[2][1])/2+t[2][1]}]}function c(t){var n,o=null,i=r.a.getBarcodeLine(e,t[0],t[1]);for(r.a.toBinaryLine(i),n=0;nE?l:E,g.push(l)}var o,i,a,u,c,s,f,l,d=0|e.x,h=0|e.y,p=0|n.x,v=0|n.y,_=Math.abs(v-h)>Math.abs(p-d),g=[],y=t.data,m=t.size.x,x=0,b=255,E=0;for(_&&(s=d,d=h,h=s,s=p,p=v,v=s),d>p&&(s=d,d=p,p=s,s=h,h=v,v=s),o=p-d,i=Math.abs(v-h),a=o/2|0,c=h,u=hl?o.DIR.UP:o.DIR.DOWN,d.push({pos:0,val:f[0]}),a=0;ah&&f[a+1]>.5*l?o.DIR.UP:r,r!==i&&(d.push({pos:a,val:f[a]}),r=i);for(d.push({pos:f.length,val:f[f.length-1]}),u=d[0].pos;ul?0:1;for(a=1;ad[a].val?d[a].val+(d[a+1].val-d[a].val)/3*2|0:d[a+1].val+(d[a].val-d[a+1].val)/3|0,u=d[a].pos;uh?0:1;return{line:f,threshold:h}},r.debug={printFrequency:function(t,e){var n,r=e.getContext("2d");for(e.width=t.length,e.height=256,r.beginPath(),r.strokeStyle="blue",n=0;n0?t.videoWidth>10&&t.videoHeight>10?e():window.setTimeout(r,500):n("Unable to play video stream. Is webcam working?"),o--}var o=10;r()})}function o(t,e){return n.i(d.a)(e).then(function(e){return new Promise(function(n){s=e,t.setAttribute("autoplay",!0),t.setAttribute("muted",!0),t.setAttribute("playsinline",!0),t.srcObject=e,t.addEventListener("loadedmetadata",function(){t.play(),n()})})}).then(r.bind(null,t))}function i(t){var e=l()(t,["width","height","facingMode","aspectRatio","deviceId"]);return void 0!==t.minAspectRatio&&t.minAspectRatio>0&&(e.aspectRatio=t.minAspectRatio,console.log("WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead")),void 0!==t.facing&&(e.facingMode=t.facing,console.log("WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'")),e}function a(t){var e={audio:!1,video:i(t)};return e.video.deviceId&&e.video.facingMode&&delete e.video.facingMode,Promise.resolve(e)}function u(){return n.i(d.b)().then(function(t){return t.filter(function(t){return"videoinput"===t.kind})})}function c(){if(s){var t=s.getVideoTracks();if(t&&t.length)return t[0]}}var s,f=n(162),l=n.n(f),d=n(52);e.a={request:function(t,e){return a(e).then(o.bind(null,t))},release:function(){var t=s&&s.getVideoTracks();t&&t.length&&t[0].stop(),s=null},enumerateVideoDevices:u,getActiveStreamLabel:function(){var t=c();return t?t.label:""},getActiveTrack:c}},function(t,e,n){"use strict";function r(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:d;return/^blob\:/i.test(t)?i(t).then(o).then(function(t){return a(t,e)}):Promise.resolve(null)}function o(t){return new Promise(function(e){var n=new FileReader;n.onload=function(t){return e(t.target.result)},n.readAsArrayBuffer(t)})}function i(t){return new Promise(function(e,n){var r=new XMLHttpRequest;r.open("GET",t,!0),r.responseType="blob",r.onreadystatechange=function(){r.readyState!==XMLHttpRequest.DONE||200!==r.status&&0!==r.status||e(this.response)},r.onerror=n,r.send()})}function a(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:d,n=new DataView(t),r=t.byteLength,o=e.reduce(function(t,e){var n=Object.keys(l).filter(function(t){return l[t]===e})[0];return n&&(t[n]=e),t},{}),i=2;if(255!==n.getUint8(0)||216!==n.getUint8(1))return!1;for(;i1?i.size:Math.floor(e/o*i.size):e,r=i.size?e/o>1?Math.floor(o/e*i.size):i.size:o,s.x=n,s.y=r}var n,r,o={},i=null,a=["canrecord","ended"],u={},c={x:0,y:0},s={x:0,y:0};return o.getRealWidth=function(){return t.videoWidth},o.getRealHeight=function(){return t.videoHeight},o.getWidth=function(){return n},o.getHeight=function(){return r},o.setWidth=function(t){n=t},o.setHeight=function(t){r=t},o.setInputStream=function(e){i=e,t.src=void 0!==e.src?e.src:""},o.ended=function(){return t.ended},o.getConfig=function(){return i},o.setAttribute=function(e,n){t.setAttribute(e,n)},o.pause=function(){t.pause()},o.play=function(){t.play()},o.setCurrentTime=function(e){"LiveStream"!==i.type&&(t.currentTime=e)},o.addEventListener=function(e,n,r){a.indexOf(e)!==-1?(u[e]||(u[e]=[]),u[e].push(n)):t.addEventListener(e,n,r)},o.clearEventHandlers=function(){a.forEach(function(e){var n=u[e];n&&n.length>0&&n.forEach(function(n){t.removeEventListener(e,n)})})},o.trigger=function(t,n){var r,i=u[t];if("canrecord"===t&&e(),i&&i.length>0)for(r=0;r1?a.size:Math.floor(u/c*a.size):u,o=a.size?u/c>1?Math.floor(c/u*a.size):a.size:c,x.x=n,x.y=o,l=!0,s=0,setTimeout(function(){e("canrecord",[])},0)},p,h,a.sequence)}function e(t,e){var n,r=y[t];if(r&&r.length>0)for(n=0;nf&&(f=o.box[r][0]),o.box[r][1]l&&(l=o.box[r][1]);for(a=[[c,s],[f,s],[f,l],[c,l]],u=p.halfSample?2:1,i=M.invert(i,i),r=0;r<4;r++)I.transformMat2(a[r],a[r],i);for(r=0;r<4;r++)I.scale(a[r],a[r],u);return a}function a(){n.i(w.f)(v,E),E.zeroBorder()}function u(){var t,e,n,r,o,i,a,u=[];for(t=0;t0&&r[x.data[n]-1]++;return r=r.map(function(t,e){return{val:t,label:e+1}}),r.sort(function(t,e){return e.val-t.val}),r.filter(function(t){return t.val>=5})}function s(t,e){var n,r,o,a,u=[],c=[];for(n=0;n=2){for(o=0;ol&&c.push(t[o]);if(c.length>=2){for(a=f(c),i=0,o=0;o1&&a.length>=c.length/4*3&&a.length>t.length/4&&(i/=a.length,u={index:e[1]*z.x+e[0],pos:{x:n,y:r},box:[I.clone([n,r]),I.clone([n+g.size.x,r]),I.clone([n+g.size.x,r+g.size.y]),I.clone([n,r+g.size.y])],moments:a,rad:i,vec:I.clone([Math.cos(i),Math.sin(i)])},s.push(u))}}return s}function h(t){function e(){var t;for(t=0;ta&&n(u):x.data[u]=Number.MAX_VALUE}var r,o,i=0,a=.95,u=0;for(T.a.init(m.data,0),T.a.init(x.data,0),T.a.init(b.data,null),r=0;r0) {length=length - 1|0;images[outImagePtr+length|0]=(images[aImagePtr+length|0]|0) - (images[bImagePtr+length|0]|0)|0;}}function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) {aImagePtr=aImagePtr|0;bImagePtr=bImagePtr|0;outImagePtr=outImagePtr|0;var length=0;length=imul(size, size)|0;while ((length|0)>0) {length=length - 1|0;images[outImagePtr+length|0]=images[aImagePtr+length|0]|0|(images[bImagePtr+length|0]|0)|0;}}function countNonZero(imagePtr) {imagePtr=imagePtr|0;var sum=0,length=0;length=imul(size, size)|0;while ((length|0)>0) {length=length - 1|0;sum=(sum|0)+(images[imagePtr+length|0]|0)|0;}return sum|0;}function init(imagePtr, value) {imagePtr=imagePtr|0;value=value|0;var length=0;length=imul(size, size)|0;while ((length|0)>0) {length=length - 1|0;images[imagePtr+length|0]=value;}}function dilate(inImagePtr, outImagePtr) {inImagePtr=inImagePtr|0;outImagePtr=outImagePtr|0;var v=0,u=0,sum=0,yStart1=0,yStart2=0,xStart1=0,xStart2=0,offset=0;for (v=1; (v|0)<(size - 1|0); v=v+1|0) {offset=offset+size|0;for (u=1; (u|0)<(size - 1|0); u=u+1|0) {yStart1=offset - size|0;yStart2=offset+size|0;xStart1=u - 1|0;xStart2=u+1|0;sum=(images[inImagePtr+yStart1+xStart1|0]|0)+(images[inImagePtr+yStart1+xStart2|0]|0)+(images[inImagePtr+offset+u|0]|0)+(images[inImagePtr+yStart2+xStart1|0]|0)+(images[inImagePtr+yStart2+xStart2|0]|0)|0;if ((sum|0)>(0|0)) {images[outImagePtr+offset+u|0]=1;} else {images[outImagePtr+offset+u|0]=0;}}}return;}function memcpy(srcImagePtr, dstImagePtr) {srcImagePtr=srcImagePtr|0;dstImagePtr=dstImagePtr|0;var length=0;length=imul(size, size)|0;while ((length|0)>0) {length=length - 1|0;images[dstImagePtr+length|0]=images[srcImagePtr+length|0]|0;}}function zeroBorder(imagePtr) {imagePtr=imagePtr|0;var x=0,y=0;for (x=0; (x|0)<(size - 1|0); x=x+1|0) {images[imagePtr+x|0]=0;images[imagePtr+y|0]=0;y=y+size - 1|0;images[imagePtr+y|0]=0;y=y+1|0;}for (x=0; (x|0)<(size|0); x=x+1|0) {images[imagePtr+y|0]=0;y=y+1|0;}}function skeletonize() {var subImagePtr=0,erodedImagePtr=0,tempImagePtr=0,skelImagePtr=0,sum=0,done=0;erodedImagePtr=imul(size, size)|0;tempImagePtr=erodedImagePtr+erodedImagePtr|0;skelImagePtr=tempImagePtr+erodedImagePtr|0;init(skelImagePtr, 0);zeroBorder(subImagePtr);do {erode(subImagePtr, erodedImagePtr);dilate(erodedImagePtr, tempImagePtr);subtract(subImagePtr, tempImagePtr, tempImagePtr);bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr);memcpy(erodedImagePtr, subImagePtr);sum=countNonZero(subImagePtr)|0;done=(sum|0) == 0|0;} while (!done);}return {skeletonize: skeletonize};} __webpack_exports__["a"]=Skeletonizer; },function(t,e,n){"use strict";function r(t){o.a.call(this,t),this.barSpaceRatio=[1,1]}var o=n(1),i=1,a=3,u={START_PATTERN:{value:[a,i,a,i,i,i]},STOP_PATTERN:{value:[a,i,i,i,a]},CODE_PATTERN:{value:[[i,i,a,a,i],[a,i,i,i,a],[i,a,i,i,a],[a,a,i,i,i],[i,i,a,i,a],[a,i,a,i,i],[i,a,a,i,i],[i,i,i,a,a],[a,i,i,a,i],[i,a,i,a,i]]},SINGLE_CODE_ERROR:{value:.78,writable:!0},AVG_CODE_ERROR:{value:.3,writable:!0},FORMAT:{value:"2of5"}},c=u.START_PATTERN.value.reduce(function(t,e){return t+e},0);r.prototype=Object.create(o.a.prototype,u),r.prototype.constructor=r,r.prototype._findPattern=function(t,e,n,r){var o,i,a,u,c=[],s=this,f=0,l={error:Number.MAX_VALUE,code:-1,start:0,end:0},d=s.AVG_CODE_ERROR;for(n=n||!1,r=r||!1,e||(e=s._nextSet(s._row)),o=0;o=0&&n._matchRange(t,e.start,0))return e;r=e.end,e=null}},r.prototype._verifyTrailingWhitespace=function(t){var e,n=this;return e=t.end+(t.end-t.start)/2,e1&&i._isStartEnd(n))break}while(ri._counters.length?i._counters.length:r,o=t.start+i._sumCounters(t.startCounter,r-8),{code:a.join(""),start:t.start,end:o,startInfo:t,decodedCodes:a}):null},r.prototype._verifyWhitespace=function(t,e){return(t-1<=0||this._counters[t-1]>=this._calculatePatternLength(t)/2)&&(e+8>=this._counters.length||this._counters[e+7]>=this._calculatePatternLength(e)/2)},r.prototype._calculatePatternLength=function(t){var e,n=0;for(e=t;e=0;i--)n=2==(1&i)?c.bar:c.space,r=1==(1&a)?n.wide:n.narrow,r.size+=u._counters[s+i],r.counts++,a>>=1;s+=8}return["space","bar"].forEach(function(t){var e=c[t];e.wide.min=Math.floor((e.narrow.size/e.narrow.counts+e.wide.size/e.wide.counts)/2),e.narrow.max=Math.ceil(e.wide.min),e.wide.max=Math.ceil((e.wide.size*u.MAX_ACCEPTABLE+u.PADDING)/e.wide.counts)}),c},r.prototype._charToPattern=function(t){var e,n=this,r=t.charCodeAt(0);for(e=0;e=0;r--){if(o=0==(1&r)?s.bar:s.space,i=1==(1&u)?o.wide:o.narrow,(a=c._counters[f+r])i.max)return!1;u>>=1}f+=8}return!0},r.prototype._patternToChar=function(t){var e,n=this;for(e=0;ei&&(i=r),rthis._counters.length)return-1;for(e=this._computeAlternatingThreshold(t,a),n=this._computeAlternatingThreshold(t+1,a),r=0;ro&&(c|=u),u>>=1;return c},r.prototype._isStartEnd=function(t){var e;for(e=0;eu.AVG_CODE_ERROR?null:(u.CODE_PATTERN[l.code]&&(l.correction.bar=o(u.CODE_PATTERN[l.code],a,this.MODULE_INDICES.bar),l.correction.space=o(u.CODE_PATTERN[l.code],a,this.MODULE_INDICES.space)),l)}f++,a[f]=1,s=!s}return null},r.prototype._correct=function(t,e){this._correctBars(t,e.bar,this.MODULE_INDICES.bar),this._correctBars(t,e.space,this.MODULE_INDICES.space)},r.prototype._findStart=function(){var t,e,n,r,i,a=[0,0,0,0,0,0],u=this,c=u._nextSet(u._row),s=!1,f=0,l={error:Number.MAX_VALUE,code:-1,start:0,end:0,correction:{bar:1,space:1}};for(t=c;t4)return-1;if(0==(1&i))for(var u=0;u="a"&&o<="d"){if(r>e-2)return null;var i=t[++r],a=i.charCodeAt(0),u=void 0;switch(o){case"a":if(!(i>="A"&&i<="Z"))return null;u=String.fromCharCode(a-64);break;case"b":if(i>="A"&&i<="E")u=String.fromCharCode(a-38);else if(i>="F"&&i<="J")u=String.fromCharCode(a-11);else if(i>="K"&&i<="O")u=String.fromCharCode(a+16);else if(i>="P"&&i<="S")u=String.fromCharCode(a+43);else{if(!(i>="T"&&i<="Z"))return null;u=String.fromCharCode(127)}break;case"c":if(i>="A"&&i<="O")u=String.fromCharCode(a-32);else{if("Z"!==i)return null;u=":"}break;case"d":if(!(i>="A"&&i<="Z"))return null;u=String.fromCharCode(a+32)}n.push(u)}else n.push(o)}return n},r.prototype._verifyChecksums=function(t){return this._matchCheckChar(t,t.length-2,20)&&this._matchCheckChar(t,t.length-1,15)},r.prototype._matchCheckChar=function(t,e,n){var r=this,o=t.slice(0,e),i=o.length,a=o.reduce(function(t,e,o){return t+((o*-1+(i-1))%n+1)*r.ALPHABET.indexOf(e.charCodeAt(0))},0);return this.ALPHABET[a%47]===t[e].charCodeAt(0)},e.a=r},function(t,e,n){"use strict";function r(){o.a.call(this)}var o=n(4),i={FORMAT:{value:"ean_2",writeable:!1}};r.prototype=Object.create(o.a.prototype,i),r.prototype.constructor=r,r.prototype.decode=function(t,e){this._row=t;var n,r=0,o=0,i=e,a=this._row.length,u=[],c=[];for(o=0;o<2&&i=this.CODE_G_START&&(r|=1<<1-o),1!=o&&(i=this._nextSet(this._row,n.end),i=this._nextUnset(this._row,i))}return 2!=u.length||parseInt(u.join(""))%4!==r?null:{code:u.join(""),decodedCodes:c,end:n.end}},e.a=r},function(t,e,n){"use strict";function r(){a.a.call(this)}function o(t){var e;for(e=0;e<10;e++)if(t===c[e])return e;return null}function i(t){var e,n=t.length,r=0;for(e=n-2;e>=0;e-=2)r+=t[e];for(r*=3,e=n-1;e>=0;e-=2)r+=t[e];return(r*=3)%10}var a=n(4),u={FORMAT:{value:"ean_5",writeable:!1}},c=[24,20,18,17,12,6,3,10,9,5];r.prototype=Object.create(a.a.prototype,u),r.prototype.constructor=r,r.prototype.decode=function(t,e){this._row=t;var n,r=0,a=0,u=e,c=this._row.length,s=[],f=[];for(a=0;a<5&&u=this.CODE_G_START&&(r|=1<<4-a),4!=a&&(u=this._nextSet(this._row,n.end),u=this._nextUnset(this._row,u))}return 5!=s.length?null:i(s)!==o(r)?null:{code:s.join(""),decodedCodes:f,end:n.end}},e.a=r},function(t,e,n){"use strict";function r(t,e){o.a.call(this,t,e)}var o=n(4),i={FORMAT:{value:"ean_8",writeable:!1}};r.prototype=Object.create(o.a.prototype,i),r.prototype.constructor=r,r.prototype._decodePayload=function(t,e,n){var r,o=this;for(r=0;r<4;r++){if(!(t=o._decodeCode(t.end,o.CODE_G_START)))return null;e.push(t.code),n.push(t)}if(null===(t=o._findPattern(o.MIDDLE_PATTERN,t.end,!0,!1)))return null;for(n.push(t),r=0;r<4;r++){if(!(t=o._decodeCode(t.end,o.CODE_G_START)))return null;n.push(t),e.push(t.code)}return t},e.a=r},function(t,e,n){"use strict";function r(t){t=a()(o(),t),u.a.call(this,t),this.barSpaceRatio=[1,1],t.normalizeBarSpaceWidth&&(this.SINGLE_CODE_ERROR=.38,this.AVG_CODE_ERROR=.09)}function o(){var t={};return Object.keys(r.CONFIG_KEYS).forEach(function(e){t[e]=r.CONFIG_KEYS[e].default}),t}var i=n(28),a=n.n(i),u=n(1),c=1,s=3,f={START_PATTERN:{value:[c,c,c,c]},STOP_PATTERN:{value:[c,c,s]},CODE_PATTERN:{value:[[c,c,s,s,c],[s,c,c,c,s],[c,s,c,c,s],[s,s,c,c,c],[c,c,s,c,s],[s,c,s,c,c],[c,s,s,c,c],[c,c,c,s,s],[s,c,c,s,c],[c,s,c,s,c]]},SINGLE_CODE_ERROR:{value:.78,writable:!0},AVG_CODE_ERROR:{value:.38,writable:!0},MAX_CORRECTION_FACTOR:{value:5},FORMAT:{value:"i2of5"}};r.prototype=Object.create(u.a.prototype,f),r.prototype.constructor=r,r.prototype._matchPattern=function(t,e){if(this.config.normalizeBarSpaceWidth){var n,r=[0,0],o=[0,0],i=[0,0],a=this.MAX_CORRECTION_FACTOR,c=1/a;for(n=0;n=0&&n._matchRange(t,e.start,0))return e;r=e.end,e=null}},r.prototype._verifyTrailingWhitespace=function(t){var e,n=this;return e=t.end+(t.end-t.start)/2,e=o.CODE_G_START&&(t.code=t.code-o.CODE_G_START,i|=1<<5-r),e.push(t.code),n.push(t)}return o._determineParity(i,e)?t:null},r.prototype._determineParity=function(t,e){var n,r;for(r=0;r0&&n(f)?e>1?r(f,e-1,n,a,u):o(u,f):a||(u[u.length]=f)}return u}var o=n(90),i=n(128);t.exports=r},function(t,e,n){var r=n(117),o=r();t.exports=o},function(t,e,n){function r(t,e){e=o(e,t);for(var n=0,r=e.length;null!=t&&n1?n[o-1]:void 0,u=o>2?n[2]:void 0;for(a=t.length>3&&"function"==typeof a?(o--,a):void 0,u&&i(n[0],n[1],u)&&(a=o<3?void 0:a,o=1),e=Object(e);++r-1}var o=n(12);t.exports=r},function(t,e,n){function r(t,e){var n=this.__data__,r=o(n,t);return r<0?(++this.size,n.push([t,e])):n[r][1]=e,this}var o=n(12);t.exports=r},function(t,e,n){function r(){this.size=0,this.__data__={hash:new o,map:new(a||i),string:new o}}var o=n(84),i=n(10),a=n(33);t.exports=r},function(t,e,n){function r(t){var e=o(this,t).delete(t);return this.size-=e?1:0,e}var o=n(14);t.exports=r},function(t,e,n){function r(t){return o(this,t).get(t)}var o=n(14);t.exports=r},function(t,e,n){function r(t){return o(this,t).has(t)}var o=n(14);t.exports=r},function(t,e,n){function r(t,e){var n=o(this,t),r=n.size;return n.set(t,e),this.size+=n.size==r?0:1,this}var o=n(14);t.exports=r},function(t,e,n){function r(t){var e=o(t,function(t){return n.size===i&&n.clear(),t}),n=e.cache;return e}var o=n(161),i=500;t.exports=r},function(t,e){function n(t){var e=[];if(null!=t)for(var n in Object(t))e.push(n);return e}t.exports=n},function(t,e,n){(function(t){var r=n(38),o="object"==typeof e&&e&&!e.nodeType&&e,i=o&&"object"==typeof t&&t&&!t.nodeType&&t,a=i&&i.exports===o,u=a&&r.process,c=function(){try{return u&&u.binding&&u.binding("util")}catch(t){}}();t.exports=c}).call(e,n(29)(t))},function(t,e){function n(t){return o.call(t)}var r=Object.prototype,o=r.toString;t.exports=n},function(t,e){function n(t,e){return function(n){return t(e(n))}}t.exports=n},function(t,e){function n(t){var e=0,n=0;return function(){var a=i(),u=o-(a-n);if(n=a,u>0){if(++e>=r)return arguments[0]}else e=0;return t.apply(void 0,arguments)}}var r=800,o=16,i=Date.now;t.exports=n},function(t,e,n){function r(){this.__data__=new o,this.size=0}var o=n(10);t.exports=r},function(t,e){function n(t){var e=this.__data__,n=e.delete(t);return this.size=e.size,n}t.exports=n},function(t,e){function n(t){return this.__data__.get(t)}t.exports=n},function(t,e){function n(t){return this.__data__.has(t)}t.exports=n},function(t,e,n){function r(t,e){var n=this.__data__;if(n instanceof o){var r=n.__data__;if(!i||r.length=e&&t.y>=e&&t.x0){var h=n[c-1];h.m00+=1,h.m01+=o,h.m10+=u,h.m11+=u*o,h.m02+=s,h.m20+=u*u}}for(var l=Math.PI,f=l/4,d=0;d=0?f:-f)+l;v.theta=(180*b/l+90)%180-90,v.theta<0&&(v.theta+=180),v.rad=b>l?b-l:b,v.x=Math.cos(b),v.y=Math.sin(b),i.push(v)}}return i}},{key:"show",value:function(t,e){var r=this.size.y,n=this.size.x,i=t.getImageData(0,0,n,r),a=i.data,o=0;e||(e=1);for(var s=0;s360)&&(e=360);for(var h=this.data.length;h--;){i[0]=this.data[h]*e;var l=i[0]<=0?a:i[0]>=360?o:Object(c.a)(i);u[4*h+0]=l[0],u[4*h+1]=l[1],u[4*h+2]=l[2],u[4*h+3]=255}t.putImageData(s,r,n)}}]),t}()},function(t,e){function r(t,e,r,n,i,a,o){try{var s=t[a](o),u=s.value}catch(t){return void r(t)}s.done?e(u):Promise.resolve(u).then(n,i)}t.exports=function(t){return function(){var e=this,n=arguments;return new Promise(function(i,a){var o=t.apply(e,n);function s(t){r(o,i,a,s,u,"next",t)}function u(t){r(o,i,a,s,u,"throw",t)}s(void 0)})}}},function(t,e,r){"use strict";r.d(e,"a",function(){return n});var n={drawPath:function(t,e,r,n){t&&t.length>1&&(e.strokeStyle=r,e.fillStyle=r,e.lineWidth=n,e.beginPath(),e.moveTo(t[0].x,t[0].y),t.slice(1).forEach(function(t){var r=t.x,n=t.y;return e.lineTo(r,n)}),e.closePath(),e.stroke())},drawImage:function(t,e,r,n){var i=n.getImageData(0,0,e,r),a=i.data,o=0|t.length,s=0|a.length;if(s/o!=4)return!1;for(;o--;){var u=t[o];a[--s]=255,a[--s]=u,a[--s]=u,a[--s]=u}return n.putImageData(i,0,0),!0}}},function(t,e){function r(t){return(r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function n(e){return"function"==typeof Symbol&&"symbol"===r(Symbol.iterator)?t.exports=n=function(t){return r(t)}:t.exports=n=function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":r(t)},n(e)}t.exports=n},function(t,e,r){var n=r(22),i=r(23),a=r(24);t.exports=function(t){return n(t)||i(t)||a()}},function(t,e,r){"use strict";function n(t){var e=t[0],r=t[1],n=t[2],i=t[3],a=e*i-n*r;return a?new Float32Array([i/a,-r/a,-n/a,e/a]):null}function i(t,e){var r=t.x,n=t.y;return{x:e[0]*r+e[2]*n,y:e[1]*r+e[3]*n}}function a(t,e){e||(e=8);var r=8-e,n=function(t,e){e||(e=8);for(var r=t.data,n=8-e,i=new Int32Array(1<>n]++;return i}(t,e),i=[0],a=(1<n[t]?r:t},0)<>1,s=0,u=n,c=0;u>2,c++,s+=2,u+=2;s+=n,u+=n}}r.d(e,"b",function(){return n}),r.d(e,"d",function(){return i}),r.d(e,"c",function(){return o}),r.d(e,"a",function(){return s})},function(t,e,r){"use strict";function n(t,e){var r=t[0],n=t[1],i=t[2],a=i*n,o=a*(1-Math.abs(r/60%2-1)),s=i-a,u=0,c=0,h=0;return r<60?(u=a,c=o):r<120?(u=o,c=a):r<180?(c=a,h=o):r<240?(c=o,h=a):r<300?(u=o,h=a):r<360&&(u=a,h=o),(e=e||[0,0,0])[0]=255*(u+s)|0,e[1]=255*(c+s)|0,e[2]=255*(h+s)|0,e}r.d(e,"a",function(){return n})},function(t,e,r){"use strict";function n(t){for(var e=new Array,r=new Array,n=1;n*n<=t;n++)t%n==0&&(e.push(n),n*n!==t&&r.unshift(t/n|0));return e.concat(r)}function i(t,e){var r=e.x,i=e.y,a=0|Math.max(0|r,0|i),o=[8,10,15,20,32,60,80],s={"x-small":5,small:4,medium:3,large:2,"x-large":1},u=s[t]||0|s.medium,c=0|o[u],h=a/c|0;function l(t){for(var e=0,r=0|t[t.length>>1];e0&&(r=Math.abs(t[e]-h)>Math.abs(t[e-1]-h)?0|t[e-1]:0|t[e]),h/ro[u-1]/o[u]?{x:r,y:r}:null}return l(function(t,e){if(t===e)return n(t);for(var r=t>e?t:e,i=t>e?e:t,a=new Array,o=new Array,s=1;s*s<=i;s++)if(r%s==0&&i%s==0){a.push(s);var u=i/s|0;s!==u&&r%u==0&&o.unshift()}return a.concat(o)}(r,i))||l(n(a))||l(n(h*c))}function a(t,e){var r=t.width,n=t.height,a=e.halfSample?1:0,s=t.config;if(s&&s.area){var u=function(t,e,r){var n={width:t,height:e},i=Object.keys(r).reduce(function(t,e){var i=r[e],a=function(t){return{value:parseFloat(t),unit:t.indexOf("%")===t.length-1?"%":t.indexOf("px")===t.length-2?"px":"%"}}(i),s=o[e](a,n);return t[e]=s,t},{});return{topLeft:{x:i.left,y:i.top},width:i.right-i.left,height:i.bottom-i.top}}(r,n,s.area);t.topLeft=u.topLeft,t.setCanvasSize(r,n),r=u.width,n=u.height}var c={x:r>>a,y:n>>a},h=i(e.patchSize,c);if(t.width=(c.x/h.x<u&&(u=e),rc&&(c=r)})});var h=[{x:o,y:s},{x:u,y:s},{x:u,y:c},{x:o,y:c}];return h=h.map(function(t){return Object(d.d)(t,a)}),this._config.halfSample&&(h=h.map(function(t){var e=t.x,r=t.y;return{x:2*e,y:r*=2}})),h}},{key:"_binarizeImage",value:function(){Object(d.c)(this._currentImageWrapper,this._binaryImageWrapper),this._binaryImageWrapper.zeroBorder()}},{key:"_findPatches",value:function(){for(var t=new Array,e=0;e0&&e[t-1]++}),e.map(function(t,e){return{value:t,index:e}}).filter(function(t){return t.value>=5}).sort(function(t,e){return e.value-t.value}).map(function(t){return t.index+1})}},{key:"_findBoxes",value:function(t,e){var r=this,n=new Array;return t.forEach(function(t){var e=new Array;r._patchLabelGrid.data.forEach(function(n,i){n===t&&e.push(r._imageToPatchGrid[i])});var i=r._boxFromPatches(e);i&&n.push(i)}),n}},{key:"_similarMoments",value:function(t){return c.a.clusterize(t,.9).reduce(function(t,e){var r=e.moments.length;return r>t.count?{item:e,count:r}:t},{item:{moments:[]},count:0}).item.moments}},{key:"_skeletonize",value:function(t,e){this._binaryImageWrapper.subImageAsCopy(this._subImageWrapper,t,e),this._skeletonizer.skeletonize()}},{key:"_describePatch",value:function(t,e,r,n){if(t.length>1){var i=Math.ceil(this._patchSize.x/3),a=t.filter(function(t){return t.m00>i});if(a.length>1){var o=this._similarMoments(a),s=0|o.length;if(s>1&&s<<2>=3*a.length&&s<<2>t.length){var u=o.reduce(function(t,e){return t+e.rad},0)/s;return{index:e,pos:{x:r,y:n},box:[{x:r,y:n},{x:r+this._subImageWrapper.size.x,y:n},{x:r+this._subImageWrapper.size.x,y:n+this._subImageWrapper.size.y},{x:r,y:n+this._subImageWrapper.size.y}],moments:o,rad:u,x:Math.cos(u),y:Math.sin(u)}}}}return null}},{key:"_notYetProcessed",value:function(){for(var t=0;t.95&&r._trace(u,e)}})}}},{key:"_rasterizeAngularSimilarity",value:function(t){var e=this,r=0;this._patchGrid.data.fill(0),this._patchLabelGrid.data.fill(0),this._imageToPatchGrid.fill(null),t.forEach(function(t){e._imageToPatchGrid[t.index]=t,e._patchGrid.data[t.index]=1}),this._patchGrid.zeroBorder();for(var n=0;(n=this._notYetProcessed())this._threshold}},{key:"moments",get:function(){return this._moments}}]),t}()},function(t,e,r){"use strict";r.d(e,"a",function(){return f});var n,i,a=r(2),o=r.n(a),s=r(1),u=r.n(s),c=r(0),h=r.n(c),l=r(17);!function(t){t[t.Outside=-32767]="Outside",t[t.Inside=-32766]="Inside"}(n||(n={})),function(t){t[t.CW=0]="CW",t[t.CCW=1]="CCW",t[t.Unknown=2]="Unknown"}(i||(i={}));var f=function(){function t(e,r){o()(this,t),h()(this,"_width",void 0),h()(this,"_height",void 0),h()(this,"_tracer",void 0),h()(this,"_imageData",void 0),h()(this,"_labelData",void 0),this._imageData=e.data,this._labelData=r.data,this._width=e.size.x,this._height=e.size.y,this._tracer=new l.b(e,r)}return u()(t,[{key:"rasterize",value:function(t){for(var e=new Array,r=0;r<400;r++)e[r]=0;e[0]=this._imageData[0];for(var a,o=null,s=0,u=1;u0){o=o-1|0;n[r+o|0]=(n[t+o|0]|0)-(n[e+o|0]|0)|0}}function u(t,e,r){t=t|0;e=e|0;r=r|0;var o=0;o=a(i,i)|0;while((o|0)>0){o=o-1|0;n[r+o|0]=n[t+o|0]|0|(n[e+o|0]|0)|0}}function c(t){t=t|0;var e=0,r=0;r=a(i,i)|0;while((r|0)>0){r=r-1|0;e=(e|0)+(n[t+r|0]|0)|0}return e|0}function h(t,e){t=t|0;e=e|0;var r=0;r=a(i,i)|0;while((r|0)>0){r=r-1|0;n[t+r|0]=e}}function l(t,e){t=t|0;e=e|0;var r=0,a=0,o=0,s=0,u=0,c=0,h=0,l=0;for(r=1;(r|0)<(i-1|0);r=r+1|0){l=l+i|0;for(a=1;(a|0)<(i-1|0);a=a+1|0){s=l-i|0;u=l+i|0;c=a-1|0;h=a+1|0;o=(n[t+s+c|0]|0)+(n[t+s+h|0]|0)+(n[t+l+a|0]|0)+(n[t+u+c|0]|0)+(n[t+u+h|0]|0)|0;if((o|0)>(0|0)){n[e+l+a|0]=1}else{n[e+l+a|0]=0}}}return}function f(t,e){t=t|0;e=e|0;var r=0;r=a(i,i)|0;while((r|0)>0){r=r-1|0;n[e+r|0]=n[t+r|0]|0}}function d(t){t=t|0;var e=0,r=0;for(e=0;(e|0)<(i-1|0);e=e+1|0){n[t+e|0]=0;n[t+r|0]=0;r=r+i-1|0;n[t+r|0]=0;r=r+1|0}for(e=0;(e|0)<(i|0);e=e+1|0){n[t+r|0]=0;r=r+1|0}}function v(){var t=0,e=0,r=0,n=0,v=0,_=0;e=a(i,i)|0;r=e+e|0;n=r+e|0;h(n,0);d(t);do{o(t,e);l(e,r);s(t,r,r);u(n,r,n);f(e,t);v=c(t)|0;_=(v|0)==0|0}while(!_)}return{skeletonize:v}}},function(t,e){t.exports=function(t){if(Array.isArray(t)){for(var e=0,r=new Array(t.length);e=0,a=i&&n.regeneratorRuntime;if(n.regeneratorRuntime=void 0,t.exports=r(28),i)n.regeneratorRuntime=a;else try{delete n.regeneratorRuntime}catch(t){n.regeneratorRuntime=void 0}},function(t,e){!function(e){"use strict";var r,n=Object.prototype,i=n.hasOwnProperty,a="function"==typeof Symbol?Symbol:{},o=a.iterator||"@@iterator",s=a.asyncIterator||"@@asyncIterator",u=a.toStringTag||"@@toStringTag",c="object"==typeof t,h=e.regeneratorRuntime;if(h)c&&(t.exports=h);else{(h=e.regeneratorRuntime=c?t.exports:{}).wrap=b;var l="suspendedStart",f="suspendedYield",d="executing",v="completed",_={},p={};p[o]=function(){return this};var g=Object.getPrototypeOf,y=g&&g(g(I([])));y&&y!==n&&i.call(y,o)&&(p=y);var m=C.prototype=x.prototype=Object.create(p);k.prototype=m.constructor=C,C.constructor=k,C[u]=k.displayName="GeneratorFunction",h.isGeneratorFunction=function(t){var e="function"==typeof t&&t.constructor;return!!e&&(e===k||"GeneratorFunction"===(e.displayName||e.name))},h.mark=function(t){return Object.setPrototypeOf?Object.setPrototypeOf(t,C):(t.__proto__=C,u in t||(t[u]="GeneratorFunction")),t.prototype=Object.create(m),t},h.awrap=function(t){return{__await:t}},E(S.prototype),S.prototype[s]=function(){return this},h.AsyncIterator=S,h.async=function(t,e,r,n){var i=new S(b(t,e,r,n));return h.isGeneratorFunction(e)?i:i.next().then(function(t){return t.done?t.value:i.next()})},E(m),m[u]="Generator",m[o]=function(){return this},m.toString=function(){return"[object Generator]"},h.keys=function(t){var e=[];for(var r in t)e.push(r);return e.reverse(),function r(){for(;e.length;){var n=e.pop();if(n in t)return r.value=n,r.done=!1,r}return r.done=!0,r}},h.values=I,R.prototype={constructor:R,reset:function(t){if(this.prev=0,this.next=0,this.sent=this._sent=r,this.done=!1,this.delegate=null,this.method="next",this.arg=r,this.tryEntries.forEach(P),!t)for(var e in this)"t"===e.charAt(0)&&i.call(this,e)&&!isNaN(+e.slice(1))&&(this[e]=r)},stop:function(){this.done=!0;var t=this.tryEntries[0].completion;if("throw"===t.type)throw t.arg;return this.rval},dispatchException:function(t){if(this.done)throw t;var e=this;function n(n,i){return s.type="throw",s.arg=t,e.next=n,i&&(e.method="next",e.arg=r),!!i}for(var a=this.tryEntries.length-1;a>=0;--a){var o=this.tryEntries[a],s=o.completion;if("root"===o.tryLoc)return n("end");if(o.tryLoc<=this.prev){var u=i.call(o,"catchLoc"),c=i.call(o,"finallyLoc");if(u&&c){if(this.prev=0;--r){var n=this.tryEntries[r];if(n.tryLoc<=this.prev&&i.call(n,"finallyLoc")&&this.prev=0;--e){var r=this.tryEntries[e];if(r.finallyLoc===t)return this.complete(r.completion,r.afterLoc),P(r),_}},catch:function(t){for(var e=this.tryEntries.length-1;e>=0;--e){var r=this.tryEntries[e];if(r.tryLoc===t){var n=r.completion;if("throw"===n.type){var i=n.arg;P(r)}return i}}throw new Error("illegal catch attempt")},delegateYield:function(t,e,n){return this.delegate={iterator:I(t),resultName:e,nextLoc:n},"next"===this.method&&(this.arg=r),_}}}function b(t,e,r,n){var i=e&&e.prototype instanceof x?e:x,a=Object.create(i.prototype),o=new R(n||[]);return a._invoke=function(t,e,r){var n=l;return function(i,a){if(n===d)throw new Error("Generator is already running");if(n===v){if("throw"===i)throw a;return z()}for(r.method=i,r.arg=a;;){var o=r.delegate;if(o){var s=A(o,r);if(s){if(s===_)continue;return s}}if("next"===r.method)r.sent=r._sent=r.arg;else if("throw"===r.method){if(n===l)throw n=v,r.arg;r.dispatchException(r.arg)}else"return"===r.method&&r.abrupt("return",r.arg);n=d;var u=w(t,e,r);if("normal"===u.type){if(n=r.done?v:f,u.arg===_)continue;return{value:u.arg,done:r.done}}"throw"===u.type&&(n=v,r.method="throw",r.arg=u.arg)}}}(t,r,o),a}function w(t,e,r){try{return{type:"normal",arg:t.call(e,r)}}catch(t){return{type:"throw",arg:t}}}function x(){}function k(){}function C(){}function E(t){["next","throw","return"].forEach(function(e){t[e]=function(t){return this._invoke(e,t)}})}function S(t){var e;this._invoke=function(r,n){function a(){return new Promise(function(e,a){!function e(r,n,a,o){var s=w(t[r],t,n);if("throw"!==s.type){var u=s.arg,c=u.value;return c&&"object"==typeof c&&i.call(c,"__await")?Promise.resolve(c.__await).then(function(t){e("next",t,a,o)},function(t){e("throw",t,a,o)}):Promise.resolve(c).then(function(t){u.value=t,a(u)},function(t){return e("throw",t,a,o)})}o(s.arg)}(r,n,e,a)})}return e=e?e.then(a,a):a()}}function A(t,e){var n=t.iterator[e.method];if(n===r){if(e.delegate=null,"throw"===e.method){if(t.iterator.return&&(e.method="return",e.arg=r,A(t,e),"throw"===e.method))return _;e.method="throw",e.arg=new TypeError("The iterator does not provide a 'throw' method")}return _}var i=w(n,t.iterator,e.arg);if("throw"===i.type)return e.method="throw",e.arg=i.arg,e.delegate=null,_;var a=i.arg;return a?a.done?(e[t.resultName]=a.value,e.next=t.nextLoc,"return"!==e.method&&(e.method="next",e.arg=r),e.delegate=null,_):a:(e.method="throw",e.arg=new TypeError("iterator result is not an object"),e.delegate=null,_)}function O(t){var e={tryLoc:t[0]};1 in t&&(e.catchLoc=t[1]),2 in t&&(e.finallyLoc=t[2],e.afterLoc=t[3]),this.tryEntries.push(e)}function P(t){var e=t.completion||{};e.type="normal",delete e.arg,t.completion=e}function R(t){this.tryEntries=[{tryLoc:"root"}],t.forEach(O,this),this.reset(!0)}function I(t){if(t){var e=t[o];if(e)return e.call(t);if("function"==typeof t.next)return t;if(!isNaN(t.length)){var n=-1,a=function e(){for(;++nr)return Number.MAX_VALUE;n+=l}return n/a}},{key:"_correctBars",value:function(t,e,r){for(var n=r.length,i=0;n--;)(i=t[r[n]]*(1-(1-e)/2))>1&&(t[r[n]]=i)}},{key:"decodePattern",value:function(t){this._row=t;var e=this.decode();return null===e?(this._row.reverse(),(e=this.decode())&&(e.direction=b.Reverse,e.start=this._row.length-e.start,e.end=this._row.length-e.end)):e.direction=b.Forward,e&&(e.format=this.FORMAT),e}},{key:"_fillCounters",value:function(t,e,r){var n=new Array,i=0;n[i]=0;for(var a=t;aa)return null;var l=I[i.code];return l&&(i.correction.bar=this._calculateCorrection(l,r,z),i.correction.space=this._calculateCorrection(l,r,D)),i}r[++s]=1,o=o?0:1}return null}},{key:"_correct",value:function(t,e){this._correctBars(t,e.bar,z),this._correctBars(t,e.space,D)}},{key:"_findStart",value:function(){for(var t,e=[0,0,0,0,0,0],r=this._nextSet(this._row),n={error:Number.MAX_VALUE,code:-1,start:0,end:0,correction:{bar:1,space:1}},i=this.AVERAGE_CODE_ERROR,a=0,o=0,s=r;s=n}},{key:"_findNextWidth",value:function(t,e){for(var r=Number.MAX_VALUE,n=0;ne&&(r=t[n]);return r}},{key:"_toPattern",value:function(t){for(var e,r=t.length,n=0,i=r,a=0;i>3;){n=this._findNextWidth(t,n),i=0,e=0;for(var o=0;on&&(e|=1<0;s++)if(t[s]>n&&(i--,2*t[s]>=a))return-1;return e}}return-1}},{key:"_findStart",value:function(){for(var t,e=this._nextSet(this._row),r=e,n=new Uint16Array(9),i=0,a=0,o=e;o1&&V.some(function(t){return t===e}))break}while(nthis._counters.length?this._counters.length:n;var a=t.start+this._sumCounters(t.startCounter,n-8);return{code:r.join(""),start:t.start,end:a,startInfo:t,decodedCodes:r}}},{key:"_verifyWhitespace",value:function(t,e){return(t-1<=0||this._counters[t-1]>=this._calculatePatternLength(t)/2)&&(e+8>=this._counters.length||this._counters[e+7]>=this._calculatePatternLength(e)/2)}},{key:"_calculatePatternLength",value:function(t){for(var e=0,r=t;r=0;o--){var s=2==(1&o)?r.bar:r.space,u=1==(1&a)?s.wide:s.narrow;u.size+=this._counters[n+o],u.counts++,a>>=1}n+=8}return["space","bar"].forEach(function(t){var e=r[t];e.wide.min=Math.floor((e.narrow.size/e.narrow.counts+e.wide.size/e.wide.counts)/2),e.narrow.max=Math.ceil(e.wide.min),e.wide.max=Math.ceil((2*e.wide.size+1.5)/e.wide.counts)}),r}},{key:"_charToPattern",value:function(t){for(var e=t.charCodeAt(0),r=0;r=0;o--){var s=0==(1&o)?r.bar:r.space,u=1==(1&a)?s.wide:s.narrow,c=this._counters[n+o];if(cu.max)return!1;a>>=1}n+=8}return!0}},{key:"_patternToChar",value:function(t){for(var e=0;en&&(n=a),athis._counters.length)return-1;for(var r=this._computeAlternatingThreshold(t,e),n=this._computeAlternatingThreshold(t+1,e),i=64,a=0,o=0;o<7;o++){var s=0==(1&o)?r:n;this._counters[t+o]>s&&(a|=i),i>>=1}return a}},{key:"_sumCounters",value:function(t,e){for(var r=0,n=t;na?null:i}r[++s]=1,o=o?0:1}return null}},{key:"_findStart",value:function(){for(var t,e=this._nextSet(this._row);!t;){if(!(t=this._findPattern(this.START_PATTERN,e,0,!0)))return null;var r=t.start-(t.end-t.start);if(r>=0&&this._matchRange(r,t.start,0))return t;e=t.end,t=null}return null}},{key:"_verifyTrailingWhitespace",value:function(t){var e=t.end+(t.end-t.start);return e=this.CODE_G_START?(t.code-=this.CODE_G_START,n|=1<<5-i):n|=0<<5-i,e.push(t.code),r.push(t)}var a=this._calculateFirstDigit(n);if(null===a)return null;if(e.unshift(a),null===(t=this._findPattern(this.MIDDLE_PATTERN,t.end,1,!1)))return null;r.push(t);for(var o=0;o<6;o++){if(!(t=this._decodeCode(t.end,this.CODE_G_START)))return null;r.push(t),e.push(t.code)}return t}},{key:"decode",value:function(){var t=new Array,e=new Array,r={},n=this._findStart();if(!n)return null;var i={code:n.code,start:n.start,end:n.end};if(e.push(i),!(i=this._decodePayload(i,t,e)))return null;if(!(i=this._findEnd(i.end,0)))return null;if(e.push(i),!this._checksum(t))return null;if(this.supplements.length>0){var a=this._decodeExtensions(i.end);if(!a)return null;var o=a.decodedCodes[a.decodedCodes.length-1],s={start:o.start+((o.end-o.start)/2|0),end:o.end};if(!this._verifyTrailingWhitespace(s))return null;r={supplement:a,code:t.join("")+a.code}}return function(t){for(var e=1;e=0;r-=2)e+=t[r];e*=3;for(var n=t.length-1;n>=0;n-=2)e+=t[n];return e%10==0}}]),e}(R),$=function(t){function e(t,r){var n;return a()(this,e),(n=E()(this,A()(e).call(this,t,r)))._format="ean_8",n}return P()(e,t),s()(e,[{key:"_decodePayload",value:function(t,e,r){for(var n=0;n<4;n++){if(!(t=this._decodeCode(t.end,this.CODE_G_START)))return null;e.push(t.code),r.push(t)}if(null===(t=this._findPattern(this.MIDDLE_PATTERN,t.end,1,!1)))return null;r.push(t);for(var i=0;i<4;i++){if(!(t=this._decodeCode(t.end,this.CODE_G_START)))return null;r.push(t),e.push(t.code)}return t}}]),e}(J),tt=function(t){function e(t,r){var n;return a()(this,e),(n=E()(this,A()(e).call(this,t,r)))._format="ean_2",n}return P()(e,t),s()(e,[{key:"decode",value:function(t,e){var r,n=t.length,i=new Array,a=new Array,o=e,s=0;this._row=t;for(var u=0;u<2&&o=this.CODE_G_START&&(s|=1<<1-u),1!==u&&(o=this._nextSet(this._row,r.end),o=this._nextUnset(this._row,o))}return 2!==i.length||parseInt(i.join(""))%4!==s?null:{code:i.join(""),decodedCodes:a,end:r.end}}}]),e}(J),et=function(t){function e(t,r){var n;return a()(this,e),(n=E()(this,A()(e).call(this,t,r)))._format="ean_5",n}return P()(e,t),s()(e,[{key:"CHECK_DIGIT_ENCODINGS",get:function(){return[24,20,18,17,12,6,3,10,9,5]}}]),s()(e,[{key:"decode",value:function(t,e){var r,n=t.length,i=new Array,a=new Array,o=0,s=e;this._row=t;for(var u=0;u<5&&s=this.CODE_G_START&&(o|=1<<4-u),4!==u&&(s=this._nextSet(this._row,r.end),s=this._nextUnset(this._row,s))}return 5!==i.length?null:this._extensionChecksum(i)!==this._determineCheckDigit(o)?null:{code:i.join(""),decodedCodes:a,end:r.end}}},{key:"_determineCheckDigit",value:function(t){for(var e=0;e<10;e++)if(t===this.CHECK_DIGIT_ENCODINGS[e])return e;return null}},{key:"_extensionChecksum",value:function(t){for(var e=t.length,r=0,n=e-2;n>=0;n-=2)r+=t[n];r*=3;for(var i=e-1;i>=0;i-=2)r+=t[i];return(r*=3)%10}}]),e}(J),rt=function(t){function e(t,r){var n;return a()(this,e),(n=E()(this,A()(e).call(this,t,r)))._format="upc_a",n}return P()(e,t),s()(e,[{key:"decode",value:function(){var t=U()(A()(e.prototype),"decode",this).call(this);return t&&t.code&&13===t.code.length&&"0"===t.code.charAt(0)?(t.code=t.code.substring(1),t):null}}]),e}(J),nt=[[56,52,50,49,44,38,35,42,41,37],[7,11,13,14,19,25,28,21,22,26]],it=function(t){function e(t,r){var n;return a()(this,e),(n=E()(this,A()(e).call(this,t,r)))._format="upc_e",n}return P()(e,t),s()(e,[{key:"STOP_PATTERN",get:function(){return[1/6*7,1/6*7,1/6*7,1/6*7,1/6*7,1/6*7]}}]),s()(e,[{key:"_decodePayload",value:function(t,e,r){for(var n=0,i=0;i<6;i++){if(!(t=this._decodeCode(t.end)))return null;t.code>=this.CODE_G_START&&(t.code=t.code-this.CODE_G_START,n|=1<<5-i),e.push(t.code),r.push(t)}return this._determineParity(n,e)?t:null}},{key:"_determineParity",value:function(t,e){for(var r=0;r>2,n=t.start-10*r;if(n>=0&&this._matchRange(n,t.start,0))return t;e=t.end,t=null}return null}},{key:"_verifyTrailingWhitespace",value:function(t){var e=t.end+(t.end-t.start)/2;return e=0&&this._matchRange(n,t.start,0))return t;e=t.end,t=null}return null}},{key:"_verifyTrailingWhitespace",value:function(t){var e=t.end+(t.end-t.start)/2;return e4)return-1;if(0==(1&a))for(var s=0;s="a"&&i<="d"){if(n>e-2)return null;var a=t[++n],o=a.charCodeAt(0),s=void 0;switch(i){case"a":if(!(a>="A"&&a<="Z"))return null;s=String.fromCharCode(o-64);break;case"b":if(a>="A"&&a<="E")s=String.fromCharCode(o-38);else if(a>="F"&&a<="J")s=String.fromCharCode(o-11);else if(a>="K"&&a<="O")s=String.fromCharCode(o+16);else if(a>="P"&&a<="S")s=String.fromCharCode(o+43);else{if(!(a>="T"&&a<="Z"))return null;s=String.fromCharCode(127)}break;case"c":if(a>="A"&&a<="O")s=String.fromCharCode(o-32);else{if("Z"!==a)return null;s=":"}break;case"d":if(!(a>="A"&&a<="Z"))return null;s=String.fromCharCode(o+32)}r.push(s)}else r.push(i)}return r}},{key:"_verifyChecksums",value:function(t){return this._matchCheckChar(t,t.length-2,20)&&this._matchCheckChar(t,t.length-1,15)}},{key:"_matchCheckChar",value:function(t,e,r){var n=t.slice(0,e),i=n.length,a=n.reduce(function(t,e,n){return t+((-1*n+(i-1))%r+1)*vt.indexOf(e.charCodeAt(0))},0);return vt[a%47]===t[e].charCodeAt(0)}}]),e}(R)};function gt(t,e){var r=Object.keys(t);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(t);e&&(n=n.filter(function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable})),r.push.apply(r,n)}return r}!function(t){t[t.Up=1]="Up",t[t.Down=-1]="Down"}(Q||(Q={}));var yt,mt=function(t,e,r){var n,i,a=0|e.x,o=0|e.y,s=0|r.x,u=0|r.y,c=Math.abs(u-o)>Math.abs(s-a),h=[],l=t.data,f=t.size.x,d=255,v=0;function _(t,e){i=l[e*f+t],d=iv?i:v,h.push(i)}c&&(n=a,a=o,o=n,n=s,s=u,u=n),a>s&&(n=a,a=s,s=n,n=o,o=u,u=n);for(var p=s-a,g=Math.abs(u-o),y=p/2|0,m=o,b=oi?Q.Up:Q.Down;a.push({pos:0,val:n[0]});for(var h=0;ho&&n[h+1]>.5*i?Q.Up:u)&&(a.push({pos:h,val:n[h]}),u=d)}a.push({pos:n.length,val:n[n.length-1]});for(var v=a[0].pos;vi?0:1;for(var _=1;_a[_].val?a[_].val+(a[_+1].val-a[_].val)/3*2|0:a[_+1].val+(a[_].val-a[_+1].val)/3|0;for(var p=a[_].pos;po?0:1}return function(t){for(var e=1;e1&&(!this._inputImageWrapper.inImageWithBorder(t[0],0)||!this._inputImageWrapper.inImageWithBorder(t[1],0));)r(-(n>>=1));return t}},{key:"_getLine",value:function(t){return[{x:(t[1].x+t[0].x)/2,y:(t[1].y+t[0].y)/2},{x:(t[3].x+t[2].x)/2,y:(t[3].y+t[2].y)/2}]}},{key:"_tryDecode",value:function(t){var e=mt(this._inputImageWrapper,t[0],t[1]);e=bt(e);var r=null;return this._barcodeReaders.some(function(t){return!!(r=t.decodePattern(e.line))}),r?{codeResult:r,barcodeLine:e}:null}},{key:"_tryDecodeBruteForce",value:function(t,e,r){for(var n=Math.sqrt(Math.pow(t[1].x-t[0].x,2)+Math.pow(t[1].y-t[0].y,2)),i=Math.sin(r),a=Math.cos(r),o=1;o<16;o++){var s=n/16*o*(o%2==0?-1:1);e[0].y+=s*i,e[0].x-=s*a,e[1].y+=s*i,e[1].x-=s*a;var u=this._tryDecode(e);if(u)return u}return null}},{key:"_printFrequency",value:function(t){var e=this._frequencyCanvas.getContext("2d");this._frequencyCanvas.width=t.length,this._frequencyCanvas.height=256,e.beginPath(),e.strokeStyle="blue";for(var r=0;r0&&(i=s,console.log("WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead")),void 0!==u&&(n=u,console.log("WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'")),{audio:!1,video:a&&n?{width:e,height:r,aspectRatio:i,deviceId:a}:{width:e,height:r,facingMode:n,aspectRatio:i,deviceId:a}}}};function Pt(t){var e=t.videoWidth,r=t.videoHeight;return new Promise(function(t,n){var i=10;!function a(){i>0?e>10&&r>10?t():window.setTimeout(a,500):n("Unable to play video stream. Is webcam working?"),i--}()})}var Rt=Math.PI/2,It=function(){function t(e,r){a()(this,t),c()(this,"_inputStream",void 0),c()(this,"_streamConfig",void 0),c()(this,"_canvas",void 0),c()(this,"_context",void 0),c()(this,"_data",void 0),c()(this,"_canvasHeight",void 0),c()(this,"_canvasWidth",void 0),c()(this,"_height",void 0),c()(this,"_width",void 0),c()(this,"_topLeft",void 0),this._inputStream=e,this._streamConfig=e.config,this._canvasWidth=e.canvasWidth,this._canvasHeight=e.canvasHeight,this._width=e.width,this._height=e.height,this._topLeft=e.topLeft,this._canvas=r||document.createElement("canvas"),this._canvas.width=this._canvasWidth,this._canvas.height=this._canvasHeight,this._context=this._canvas.getContext("2d"),this._data=new Uint8Array(this._width*this._height)}return s()(t,[{key:"grab",value:function(t){this._data=t;var e=this._inputStream.getFrame();if(e){var r;this._adjustCanvasSize();var n=0;if(e instanceof HTMLVideoElement)r=e;else if(r=e.image,e.tags)switch(e.tags.orientation){case 6:n=Rt;break;case 8:n=-Rt}if(0!==n){var i=this._canvasWidth>>1,a=this._canvasHeight>>1;this._context.translate(i,a),this._context.rotate(n),this._context.drawImage(r,-a,-i,this._canvasHeight,this._canvasWidth),this._context.rotate(-n),this._context.translate(-i,-a)}else this._context.drawImage(r,0,0,this._canvasWidth,this._canvasHeight);var o=this._context.getImageData(this._topLeft.x,this._topLeft.y,this._width,this._height).data;return this._streamConfig.halfSample?this._grayAndHalfSampleFromCanvasData(o):this._computeGray(o),!0}return!1}},{key:"_adjustCanvasSize",value:function(){this._canvas.height===this._canvasHeight&&this._canvas.width===this._canvasWidth||(this._canvas.height=this._canvasHeight,this._canvas.width=this._canvasWidth)}},{key:"_grayAndHalfSampleFromCanvasData",value:function(t){for(var e=t.length>>2,r=this._width>>1,n=0,i=this._width,a=0;i1&&void 0!==i[1]?i[1]:Dt,!/^blob:/i.test(e)){t.next=6;break}return t.next=4,Lt(e);case 4:return n=t.sent,t.abrupt("return",Tt(n,r));case 6:return t.abrupt("return",Promise.resolve(null));case 7:case"end":return t.stop()}},t)}))).apply(this,arguments)}function Tt(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Dt,r=new DataView(t),n=t.byteLength,i=e.reduce(function(t,e){var r=Object.keys(zt).find(function(t){return zt[t]===e});return r&&(t[r]=e),t},{}),a=2;if(255!==r.getUint8(0)||216!==r.getUint8(1))return null;for(;at._height?t._config.size:t._width*t._config.size/t._height|0:t._width,t._canvasHeight=t._calculatedHeight=t._config.size?t._width>t._height?t._height*t._config.size/t._width|0:t._config.size:t._height,t._loaded=!0,t._frameIndex=0,setTimeout(function(){return t.trigger("canrecord",[])},0)},this._offset,this._size,this._config.sequence)}},{key:"realHeight",get:function(){return this._height}},{key:"realWidth",get:function(){return this._width}},{key:"config",get:function(){return this._config},set:function(t){this._config=function(t){for(var e=1;ee?this._config.size:t*this._config.size/e|0:t,this._canvasHeight=this._calculatedHeight=this._config.size?t>e?e*this._config.size/t|0:this._config.size:e}},{key:"realHeight",get:function(){return this._video.videoHeight}},{key:"realWidth",get:function(){return this._video.videoWidth}},{key:"config",get:function(){return this._config},set:function(t){this._config=function(t){for(var e=1;e=e&&(e+=t,ve()),window.requestAnimationFrame(r))}(performance.now())):ve()},stop:function(){Zt=!0,ge(0),"LiveStream"===re.inputStream.type&&(Ot.release(),Xt.clearEventHandlers())},decodeSingle:function(t,e){var r=this;t=m({inputStream:{type:"ImageStream",sequence:!1,size:800,src:t.src},numOfWorkers:1,locator:{halfSample:!1}},t),this.init(t,function(){d.once("processed",function(t){r.stop(),e.call(null,t)},!0),r.start()})},pause:function(){Zt=!0},onDetected:function(t){d.subscribe("detected",t)},offDetected:function(t){d.unsubscribe("detected",t)},onProcessed:function(t){d.subscribe("processed",t)},offProcessed:function(t){d.unsubscribe("processed",t)},setReaders:function(t){$t?$t.setReaders(t):te&&ue.length>0&&ue.forEach(function(e){return e.worker.postMessage({cmd:"setReaders",readers:t})})},registerResultCollector:function(t){t&&"function"==typeof t.addResult&&(ee=t)}};function ce(t){!function(t){Yt=t||new p.a({x:Xt.width,y:Xt.height});0;Jt=[{x:0,y:0},{x:0,y:Yt.size.y},{x:Yt.size.x,y:Yt.size.y},{x:Yt.size.x,y:0}],Kt=new oe.a(Yt,re.locator)}(t),$t=new wt(re.decoder,Yt)}function he(){var t=re.inputStream.target;if(t instanceof HTMLElement)return t;var e="string"==typeof t?t:"#interactive.viewport";return document.querySelector(e)}function le(t,e){t.forEach(function(t){t.x+=e.x,t.y+=e.y})}function fe(t,e){var r=t;if(t&&te){var n=Xt.topLeft;0===n.x&&0===n.y||function t(e,r){e.barcodes&&e.barcodes.forEach(function(e){return t(e,r)}),e.line&&le(e.line,r),e.box&&le(e.box,r),e.boxes&&e.boxes.forEach(function(t){return le(t,r)})}(t,n),function(t,e,r,n){e&&ee&&(t.barcodes?t.barcodes.forEach(function(t){var i=t.codeResult;i&&ee.addResult(e,r,n,i)}):t.codeResult&&ee.addResult(e,r,n,t.codeResult))}(t,e,Xt.canvasWidth,Xt.canvasHeight),r=t.barcodes||t}d.publish("processed",r),function(t){return t&&(!!t.codeResult||t.barcodes&&t.barcodes.some(function(t){return!!t.codeResult}))}(t)&&d.publish("detected",r)}function de(){var t=re.locate?Kt.locate():[Jt];fe($t.decodeFromBoundingBoxes(t),Yt.data)}function ve(){if(te)if(ue.length>0){var t=ue.find(function(t){return!t.busy});if(!t)return;var e=t.imageData;Qt.grab(e)&&(t.busy=!0,t.worker.postMessage({cmd:"process",imageData:e},[e.buffer]))}else Qt.grab(Yt.data)&&de();else de()}function _e(e){var r,n,i=(r=t||"",n=new Blob(["(".concat(pe.toString(),")(").concat(r,");")],{type:"text/javascript"}),window.URL.createObjectURL(n)),a={worker:new Worker(i),imageData:new Uint8Array(Xt.width*Xt.height),busy:!0};a.worker.onmessage=function(t){var r=t.data;"initialized"===r.event?(URL.revokeObjectURL(i),a.busy=!1,a.imageData=new Uint8Array(r.imageData),e(a)):"processed"===r.event?(a.busy=!1,a.imageData=new Uint8Array(r.imageData),fe(r.result,a.imageData)):r.event},a.worker.postMessage({cmd:"init",size:{x:Xt.width,y:Xt.height},imageData:a.imageData,config:m(re,{inputStream:{target:null}})},[a.imageData.buffer])}function pe(t){var e,r,n=self;!t||(e=t().default)?self.onmessage=function(t){var i=t.data;if("init"===i.cmd){var a=i.config;a.numOfWorkers=0,r=new e.ImageWrapper({x:i.size.x,y:i.size.y},new Uint8Array(i.imageData)),e.init(a,function(){return n.postMessage({event:"initialized",imageData:r.data},[r.data.buffer])},r),e.onProcessed(function(t){return n.postMessage({event:"processed",imageData:r.data,result:t},[r.data.buffer])})}else"process"===i.cmd?(r.data=new Uint8Array(i.imageData),e.start()):"setReaders"===i.cmd&&e.setReaders(i.readers)}:n.postMessage({event:"error",message:"Quagga could not be created"})}function ge(t,e){var r=t-ue.length;if(!(r>0))return r<0&&(ue.slice(r).forEach(function(t){t.worker.terminate()}),ue=ue.slice(0,r)),e&&e();for(var n=0;n=t&&e&&e()})}}])});
\ No newline at end of file
diff --git a/dist/quagga.node.js b/dist/quagga.node.js
new file mode 100644
index 00000000..77b1e486
--- /dev/null
+++ b/dist/quagga.node.js
@@ -0,0 +1,2 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t(require("ndarray"),require("get-pixels")):"function"==typeof define&&define.amd?define("Quagga",["ndarray","get-pixels"],t):"object"==typeof exports?exports.Quagga=t(require("ndarray"),require("get-pixels")):e.Quagga=t(e.ndarray,e["get-pixels"])}(global,function(e,t){return function(e){var t={};function r(n){if(t[n])return t[n].exports;var i=t[n]={i:n,l:!1,exports:{}};return e[n].call(i.exports,i,i.exports,r),i.l=!0,i.exports}return r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var i in e)r.d(n,i,function(t){return e[t]}.bind(null,i));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="/",r(r.s=21)}([function(e,t){e.exports=function(e,t,r){return t in e?Object.defineProperty(e,t,{value:r,enumerable:!0,configurable:!0,writable:!0}):e[t]=r,e}},function(e,t){function r(e,t){for(var r=0;r=0,a=i&&n.regeneratorRuntime;if(n.regeneratorRuntime=void 0,e.exports=r(18),i)n.regeneratorRuntime=a;else try{delete n.regeneratorRuntime}catch(e){n.regeneratorRuntime=void 0}},function(e,t){!function(t){"use strict";var r,n=Object.prototype,i=n.hasOwnProperty,a="function"==typeof Symbol?Symbol:{},o=a.iterator||"@@iterator",s=a.asyncIterator||"@@asyncIterator",u=a.toStringTag||"@@toStringTag",c="object"==typeof e,h=t.regeneratorRuntime;if(h)c&&(e.exports=h);else{(h=t.regeneratorRuntime=c?e.exports:{}).wrap=b;var l="suspendedStart",f="suspendedYield",d="executing",v="completed",_={},p={};p[o]=function(){return this};var g=Object.getPrototypeOf,y=g&&g(g(z([])));y&&y!==n&&i.call(y,o)&&(p=y);var m=C.prototype=x.prototype=Object.create(p);k.prototype=m.constructor=C,C.constructor=k,C[u]=k.displayName="GeneratorFunction",h.isGeneratorFunction=function(e){var t="function"==typeof e&&e.constructor;return!!t&&(t===k||"GeneratorFunction"===(t.displayName||t.name))},h.mark=function(e){return Object.setPrototypeOf?Object.setPrototypeOf(e,C):(e.__proto__=C,u in e||(e[u]="GeneratorFunction")),e.prototype=Object.create(m),e},h.awrap=function(e){return{__await:e}},A(S.prototype),S.prototype[s]=function(){return this},h.AsyncIterator=S,h.async=function(e,t,r,n){var i=new S(b(e,t,r,n));return h.isGeneratorFunction(t)?i:i.next().then(function(e){return e.done?e.value:i.next()})},A(m),m[u]="Generator",m[o]=function(){return this},m.toString=function(){return"[object Generator]"},h.keys=function(e){var t=[];for(var r in e)t.push(r);return t.reverse(),function r(){for(;t.length;){var n=t.pop();if(n in e)return r.value=n,r.done=!1,r}return r.done=!0,r}},h.values=z,R.prototype={constructor:R,reset:function(e){if(this.prev=0,this.next=0,this.sent=this._sent=r,this.done=!1,this.delegate=null,this.method="next",this.arg=r,this.tryEntries.forEach(O),!e)for(var t in this)"t"===t.charAt(0)&&i.call(this,t)&&!isNaN(+t.slice(1))&&(this[t]=r)},stop:function(){this.done=!0;var e=this.tryEntries[0].completion;if("throw"===e.type)throw e.arg;return this.rval},dispatchException:function(e){if(this.done)throw e;var t=this;function n(n,i){return s.type="throw",s.arg=e,t.next=n,i&&(t.method="next",t.arg=r),!!i}for(var a=this.tryEntries.length-1;a>=0;--a){var o=this.tryEntries[a],s=o.completion;if("root"===o.tryLoc)return n("end");if(o.tryLoc<=this.prev){var u=i.call(o,"catchLoc"),c=i.call(o,"finallyLoc");if(u&&c){if(this.prev=0;--r){var n=this.tryEntries[r];if(n.tryLoc<=this.prev&&i.call(n,"finallyLoc")&&this.prev=0;--t){var r=this.tryEntries[t];if(r.finallyLoc===e)return this.complete(r.completion,r.afterLoc),O(r),_}},catch:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var r=this.tryEntries[t];if(r.tryLoc===e){var n=r.completion;if("throw"===n.type){var i=n.arg;O(r)}return i}}throw new Error("illegal catch attempt")},delegateYield:function(e,t,n){return this.delegate={iterator:z(e),resultName:t,nextLoc:n},"next"===this.method&&(this.arg=r),_}}}function b(e,t,r,n){var i=t&&t.prototype instanceof x?t:x,a=Object.create(i.prototype),o=new R(n||[]);return a._invoke=function(e,t,r){var n=l;return function(i,a){if(n===d)throw new Error("Generator is already running");if(n===v){if("throw"===i)throw a;return I()}for(r.method=i,r.arg=a;;){var o=r.delegate;if(o){var s=E(o,r);if(s){if(s===_)continue;return s}}if("next"===r.method)r.sent=r._sent=r.arg;else if("throw"===r.method){if(n===l)throw n=v,r.arg;r.dispatchException(r.arg)}else"return"===r.method&&r.abrupt("return",r.arg);n=d;var u=w(e,t,r);if("normal"===u.type){if(n=r.done?v:f,u.arg===_)continue;return{value:u.arg,done:r.done}}"throw"===u.type&&(n=v,r.method="throw",r.arg=u.arg)}}}(e,r,o),a}function w(e,t,r){try{return{type:"normal",arg:e.call(t,r)}}catch(e){return{type:"throw",arg:e}}}function x(){}function k(){}function C(){}function A(e){["next","throw","return"].forEach(function(t){e[t]=function(e){return this._invoke(t,e)}})}function S(e){var t;this._invoke=function(r,n){function a(){return new Promise(function(t,a){!function t(r,n,a,o){var s=w(e[r],e,n);if("throw"!==s.type){var u=s.arg,c=u.value;return c&&"object"==typeof c&&i.call(c,"__await")?Promise.resolve(c.__await).then(function(e){t("next",e,a,o)},function(e){t("throw",e,a,o)}):Promise.resolve(c).then(function(e){u.value=e,a(u)},function(e){return t("throw",e,a,o)})}o(s.arg)}(r,n,t,a)})}return t=t?t.then(a,a):a()}}function E(e,t){var n=e.iterator[t.method];if(n===r){if(t.delegate=null,"throw"===t.method){if(e.iterator.return&&(t.method="return",t.arg=r,E(e,t),"throw"===t.method))return _;t.method="throw",t.arg=new TypeError("The iterator does not provide a 'throw' method")}return _}var i=w(n,e.iterator,t.arg);if("throw"===i.type)return t.method="throw",t.arg=i.arg,t.delegate=null,_;var a=i.arg;return a?a.done?(t[e.resultName]=a.value,t.next=e.nextLoc,"return"!==t.method&&(t.method="next",t.arg=r),t.delegate=null,_):a:(t.method="throw",t.arg=new TypeError("iterator result is not an object"),t.delegate=null,_)}function P(e){var t={tryLoc:e[0]};1 in e&&(t.catchLoc=e[1]),2 in e&&(t.finallyLoc=e[2],t.afterLoc=e[3]),this.tryEntries.push(t)}function O(e){var t=e.completion||{};t.type="normal",delete t.arg,e.completion=t}function R(e){this.tryEntries=[{tryLoc:"root"}],e.forEach(P,this),this.reset(!0)}function z(e){if(e){var t=e[o];if(t)return t.call(e);if("function"==typeof e.next)return e;if(!isNaN(e.length)){var n=-1,a=function t(){for(;++n1&&(t.strokeStyle=r,t.fillStyle=r,t.lineWidth=n,t.beginPath(),t.moveTo(e[0].x,e[0].y),e.slice(1).forEach(function(e){var r=e.x,n=e.y;return t.lineTo(r,n)}),t.closePath(),t.stroke())},drawImage:function(e,t,r,n){var i=n.getImageData(0,0,t,r),a=i.data,o=0|e.length,s=0|a.length;if(s/o!=4)return!1;for(;o--;){var u=e[o];a[--s]=255,a[--s]=u,a[--s]=u,a[--s]=u}return n.putImageData(i,0,0),!0}},h=function(){function e(t){i()(this,e),u()(this,"_canvas",void 0),u()(this,"_context",void 0),u()(this,"_config",void 0),u()(this,"_capacity",void 0),u()(this,"_capture",void 0),u()(this,"_results",void 0),this._results=new Array,this._config=t,this._capacity=t.capacity||20,this._capture=!0===t.capture,this._capture&&(this._canvas=document.createElement("canvas"),this._context=this._canvas.getContext("2d"))}return o()(e,[{key:"addResult",value:function(e,t,r,n){if(n&&this._capacity&&!this._contains(n)&&this._passesFilter(n)){var i={codeResult:n};this._capacity--,this._capture&&(this._canvas.width=t,this._canvas.height=r,c.drawImage(e,t,r,this._context),i.frame=this._canvas.toDataURL()),this._results.push(i)}}},{key:"getResults",value:function(){return this._results}},{key:"_contains",value:function(e){return this._config.blacklist&&this._config.blacklist.some(function(t){return Object.keys(t).every(function(r){return t[r]===e[r]})})}},{key:"_passesFilter",value:function(e){return"function"!=typeof this._config.filter||this._config.filter(e)}}]),e}(),l={},f=function(){function e(){i()(this,e)}return o()(e,null,[{key:"subscribe",value:function(e,t,r){var n;if("function"==typeof t)n={callback:t,async:r};else if(!(n=t).callback)throw"Callback was not specified on options";d(e).subscriptions.push(n)}},{key:"publish",value:function(e,t){var r=d(e),n=r.subscriptions;n.filter(function(e){return!!e.once}).forEach(function(e){return v(e,t)}),r.subscriptions=n.filter(function(e){return!e.once}),r.subscriptions.forEach(function(e){return v(e,t)})}},{key:"once",value:function(t,r,n){e.subscribe(t,{callback:r,async:n,once:!0})}},{key:"unsubscribe",value:function(e,t){if(e){var r=d(e);r.subscriptions=r&&t?r.subscriptions.filter(function(e){return e.callback!==t}):[]}else l={}}}]),e}();function d(e){return l[e]||(l[e]={subscriptions:[]}),l[e]}function v(e,t){e.async?setTimeout(function(){e.callback(t)},4):e.callback(t)}function _(e,t){var r=e[0],n=e[1],i=e[2],a=i*n,o=a*(1-Math.abs(r/60%2-1)),s=i-a,u=0,c=0,h=0;return r<60?(u=a,c=o):r<120?(u=o,c=a):r<180?(c=a,h=o):r<240?(c=o,h=a):r<300?(u=o,h=a):r<360&&(u=a,h=o),(t=t||[0,0,0])[0]=255*(u+s)|0,t[1]=255*(c+s)|0,t[2]=255*(h+s)|0,t}var p=function(){function e(t,r,n,a){i()(this,e),u()(this,"data",void 0),u()(this,"size",void 0),r?this.data=r:(this.data=new(n||Uint8Array)(t.x*t.y),a&&this.data.fill(0)),this.size=t}return o()(e,[{key:"inImageWithBorder",value:function(e,t){return e.x>=t&&e.y>=t&&e.x0){var h=n[c-1];h.m00+=1,h.m01+=o,h.m10+=u,h.m11+=u*o,h.m02+=s,h.m20+=u*u}}for(var l=Math.PI,f=l/4,d=0;d=0?f:-f)+l;v.theta=(180*b/l+90)%180-90,v.theta<0&&(v.theta+=180),v.rad=b>l?b-l:b,v.x=Math.cos(b),v.y=Math.sin(b),i.push(v)}}return i}},{key:"show",value:function(e,t){var r=this.size.y,n=this.size.x,i=e.getImageData(0,0,n,r),a=i.data,o=0;t||(t=1);for(var s=0;s360)&&(t=360);for(var c=this.data.length;c--;){i[0]=this.data[c]*t;var h=i[0]<=0?a:i[0]>=360?o:_(i);u[4*c+0]=h[0],u[4*c+1]=h[1],u[4*c+2]=h[2],u[4*c+3]=255}e.putImageData(s,r,n)}}]),e}(),g=r(8),y=r.n(g);function m(){for(var e=function(e){return e&&"object"===y()(e)},t=arguments.length,r=new Array(t),n=0;nr)return Number.MAX_VALUE;n+=l}return n/a}},{key:"_correctBars",value:function(e,t,r){for(var n=r.length,i=0;n--;)(i=e[r[n]]*(1-(1-t)/2))>1&&(e[r[n]]=i)}},{key:"decodePattern",value:function(e){this._row=e;var t=this.decode();return null===t?(this._row.reverse(),(t=this.decode())&&(t.direction=b.Reverse,t.start=this._row.length-t.start,t.end=this._row.length-t.end)):t.direction=b.Forward,t&&(t.format=this.FORMAT),t}},{key:"_fillCounters",value:function(e,t,r){var n=new Array,i=0;n[i]=0;for(var a=e;aa)return null;var l=z[i.code];return l&&(i.correction.bar=this._calculateCorrection(l,r,I),i.correction.space=this._calculateCorrection(l,r,W)),i}r[++s]=1,o=o?0:1}return null}},{key:"_correct",value:function(e,t){this._correctBars(e,t.bar,I),this._correctBars(e,t.space,W)}},{key:"_findStart",value:function(){for(var e,t=[0,0,0,0,0,0],r=this._nextSet(this._row),n={error:Number.MAX_VALUE,code:-1,start:0,end:0,correction:{bar:1,space:1}},i=this.AVERAGE_CODE_ERROR,a=0,o=0,s=r;s=n}},{key:"_findNextWidth",value:function(e,t){for(var r=Number.MAX_VALUE,n=0;nt&&(r=e[n]);return r}},{key:"_toPattern",value:function(e){for(var t,r=e.length,n=0,i=r,a=0;i>3;){n=this._findNextWidth(e,n),i=0,t=0;for(var o=0;on&&(t|=1<0;s++)if(e[s]>n&&(i--,2*e[s]>=a))return-1;return t}}return-1}},{key:"_findStart",value:function(){for(var e,t=this._nextSet(this._row),r=t,n=new Uint16Array(9),i=0,a=0,o=t;o1&&V.some(function(e){return e===t}))break}while(nthis._counters.length?this._counters.length:n;var a=e.start+this._sumCounters(e.startCounter,n-8);return{code:r.join(""),start:e.start,end:a,startInfo:e,decodedCodes:r}}},{key:"_verifyWhitespace",value:function(e,t){return(e-1<=0||this._counters[e-1]>=this._calculatePatternLength(e)/2)&&(t+8>=this._counters.length||this._counters[t+7]>=this._calculatePatternLength(t)/2)}},{key:"_calculatePatternLength",value:function(e){for(var t=0,r=e;r=0;o--){var s=2==(1&o)?r.bar:r.space,u=1==(1&a)?s.wide:s.narrow;u.size+=this._counters[n+o],u.counts++,a>>=1}n+=8}return["space","bar"].forEach(function(e){var t=r[e];t.wide.min=Math.floor((t.narrow.size/t.narrow.counts+t.wide.size/t.wide.counts)/2),t.narrow.max=Math.ceil(t.wide.min),t.wide.max=Math.ceil((2*t.wide.size+1.5)/t.wide.counts)}),r}},{key:"_charToPattern",value:function(e){for(var t=e.charCodeAt(0),r=0;r=0;o--){var s=0==(1&o)?r.bar:r.space,u=1==(1&a)?s.wide:s.narrow,c=this._counters[n+o];if(cu.max)return!1;a>>=1}n+=8}return!0}},{key:"_patternToChar",value:function(e){for(var t=0;tn&&(n=a),athis._counters.length)return-1;for(var r=this._computeAlternatingThreshold(e,t),n=this._computeAlternatingThreshold(e+1,t),i=64,a=0,o=0;o<7;o++){var s=0==(1&o)?r:n;this._counters[e+o]>s&&(a|=i),i>>=1}return a}},{key:"_sumCounters",value:function(e,t){for(var r=0,n=e;na?null:i}r[++s]=1,o=o?0:1}return null}},{key:"_findStart",value:function(){for(var e,t=this._nextSet(this._row);!e;){if(!(e=this._findPattern(this.START_PATTERN,t,0,!0)))return null;var r=e.start-(e.end-e.start);if(r>=0&&this._matchRange(r,e.start,0))return e;t=e.end,e=null}return null}},{key:"_verifyTrailingWhitespace",value:function(e){var t=e.end+(e.end-e.start);return t=this.CODE_G_START?(e.code-=this.CODE_G_START,n|=1<<5-i):n|=0<<5-i,t.push(e.code),r.push(e)}var a=this._calculateFirstDigit(n);if(null===a)return null;if(t.unshift(a),null===(e=this._findPattern(this.MIDDLE_PATTERN,e.end,1,!1)))return null;r.push(e);for(var o=0;o<6;o++){if(!(e=this._decodeCode(e.end,this.CODE_G_START)))return null;r.push(e),t.push(e.code)}return e}},{key:"decode",value:function(){var e=new Array,t=new Array,r={},n=this._findStart();if(!n)return null;var i={code:n.code,start:n.start,end:n.end};if(t.push(i),!(i=this._decodePayload(i,e,t)))return null;if(!(i=this._findEnd(i.end,0)))return null;if(t.push(i),!this._checksum(e))return null;if(this.supplements.length>0){var a=this._decodeExtensions(i.end);if(!a)return null;var o=a.decodedCodes[a.decodedCodes.length-1],s={start:o.start+((o.end-o.start)/2|0),end:o.end};if(!this._verifyTrailingWhitespace(s))return null;r={supplement:a,code:e.join("")+a.code}}return function(e){for(var t=1;t=0;r-=2)t+=e[r];t*=3;for(var n=e.length-1;n>=0;n-=2)t+=e[n];return t%10==0}}]),t}(R),$=function(e){function t(e,r){var n;return i()(this,t),(n=A()(this,E()(t).call(this,e,r)))._format="ean_8",n}return O()(t,e),o()(t,[{key:"_decodePayload",value:function(e,t,r){for(var n=0;n<4;n++){if(!(e=this._decodeCode(e.end,this.CODE_G_START)))return null;t.push(e.code),r.push(e)}if(null===(e=this._findPattern(this.MIDDLE_PATTERN,e.end,1,!1)))return null;r.push(e);for(var i=0;i<4;i++){if(!(e=this._decodeCode(e.end,this.CODE_G_START)))return null;r.push(e),t.push(e.code)}return e}}]),t}(J),ee=function(e){function t(e,r){var n;return i()(this,t),(n=A()(this,E()(t).call(this,e,r)))._format="ean_2",n}return O()(t,e),o()(t,[{key:"decode",value:function(e,t){var r,n=e.length,i=new Array,a=new Array,o=t,s=0;this._row=e;for(var u=0;u<2&&o=this.CODE_G_START&&(s|=1<<1-u),1!==u&&(o=this._nextSet(this._row,r.end),o=this._nextUnset(this._row,o))}return 2!==i.length||parseInt(i.join(""))%4!==s?null:{code:i.join(""),decodedCodes:a,end:r.end}}}]),t}(J),te=function(e){function t(e,r){var n;return i()(this,t),(n=A()(this,E()(t).call(this,e,r)))._format="ean_5",n}return O()(t,e),o()(t,[{key:"CHECK_DIGIT_ENCODINGS",get:function(){return[24,20,18,17,12,6,3,10,9,5]}}]),o()(t,[{key:"decode",value:function(e,t){var r,n=e.length,i=new Array,a=new Array,o=0,s=t;this._row=e;for(var u=0;u<5&&s=this.CODE_G_START&&(o|=1<<4-u),4!==u&&(s=this._nextSet(this._row,r.end),s=this._nextUnset(this._row,s))}return 5!==i.length?null:this._extensionChecksum(i)!==this._determineCheckDigit(o)?null:{code:i.join(""),decodedCodes:a,end:r.end}}},{key:"_determineCheckDigit",value:function(e){for(var t=0;t<10;t++)if(e===this.CHECK_DIGIT_ENCODINGS[t])return t;return null}},{key:"_extensionChecksum",value:function(e){for(var t=e.length,r=0,n=t-2;n>=0;n-=2)r+=e[n];r*=3;for(var i=t-1;i>=0;i-=2)r+=e[i];return(r*=3)%10}}]),t}(J),re=function(e){function t(e,r){var n;return i()(this,t),(n=A()(this,E()(t).call(this,e,r)))._format="upc_a",n}return O()(t,e),o()(t,[{key:"decode",value:function(){var e=G()(E()(t.prototype),"decode",this).call(this);return e&&e.code&&13===e.code.length&&"0"===e.code.charAt(0)?(e.code=e.code.substring(1),e):null}}]),t}(J),ne=[[56,52,50,49,44,38,35,42,41,37],[7,11,13,14,19,25,28,21,22,26]],ie=function(e){function t(e,r){var n;return i()(this,t),(n=A()(this,E()(t).call(this,e,r)))._format="upc_e",n}return O()(t,e),o()(t,[{key:"STOP_PATTERN",get:function(){return[1/6*7,1/6*7,1/6*7,1/6*7,1/6*7,1/6*7]}}]),o()(t,[{key:"_decodePayload",value:function(e,t,r){for(var n=0,i=0;i<6;i++){if(!(e=this._decodeCode(e.end)))return null;e.code>=this.CODE_G_START&&(e.code=e.code-this.CODE_G_START,n|=1<<5-i),t.push(e.code),r.push(e)}return this._determineParity(n,t)?e:null}},{key:"_determineParity",value:function(e,t){for(var r=0;r>2,n=e.start-10*r;if(n>=0&&this._matchRange(n,e.start,0))return e;t=e.end,e=null}return null}},{key:"_verifyTrailingWhitespace",value:function(e){var t=e.end+(e.end-e.start)/2;return t=0&&this._matchRange(n,e.start,0))return e;t=e.end,e=null}return null}},{key:"_verifyTrailingWhitespace",value:function(e){var t=e.end+(e.end-e.start)/2;return t4)return-1;if(0==(1&a))for(var s=0;s="a"&&i<="d"){if(n>t-2)return null;var a=e[++n],o=a.charCodeAt(0),s=void 0;switch(i){case"a":if(!(a>="A"&&a<="Z"))return null;s=String.fromCharCode(o-64);break;case"b":if(a>="A"&&a<="E")s=String.fromCharCode(o-38);else if(a>="F"&&a<="J")s=String.fromCharCode(o-11);else if(a>="K"&&a<="O")s=String.fromCharCode(o+16);else if(a>="P"&&a<="S")s=String.fromCharCode(o+43);else{if(!(a>="T"&&a<="Z"))return null;s=String.fromCharCode(127)}break;case"c":if(a>="A"&&a<="O")s=String.fromCharCode(o-32);else{if("Z"!==a)return null;s=":"}break;case"d":if(!(a>="A"&&a<="Z"))return null;s=String.fromCharCode(o+32)}r.push(s)}else r.push(i)}return r}},{key:"_verifyChecksums",value:function(e){return this._matchCheckChar(e,e.length-2,20)&&this._matchCheckChar(e,e.length-1,15)}},{key:"_matchCheckChar",value:function(e,t,r){var n=e.slice(0,t),i=n.length,a=n.reduce(function(e,t,n){return e+((-1*n+(i-1))%r+1)*ve.indexOf(t.charCodeAt(0))},0);return ve[a%47]===e[t].charCodeAt(0)}}]),t}(R)};function ge(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),r.push.apply(r,n)}return r}!function(e){e[e.Up=1]="Up",e[e.Down=-1]="Down"}(Y||(Y={}));var ye,me=function(e,t,r){var n,i,a=0|t.x,o=0|t.y,s=0|r.x,u=0|r.y,c=Math.abs(u-o)>Math.abs(s-a),h=[],l=e.data,f=e.size.x,d=255,v=0;function _(e,t){i=l[t*f+e],d=iv?i:v,h.push(i)}c&&(n=a,a=o,o=n,n=s,s=u,u=n),a>s&&(n=a,a=s,s=n,n=o,o=u,u=n);for(var p=s-a,g=Math.abs(u-o),y=p/2|0,m=o,b=oi?Y.Up:Y.Down;a.push({pos:0,val:n[0]});for(var h=0;ho&&n[h+1]>.5*i?Y.Up:c)&&(a.push({pos:h,val:n[h]}),c=d)}a.push({pos:n.length,val:n[n.length-1]});for(var v=a[0].pos;vi?0:1;for(var _=1;_a[_].val?a[_].val+(a[_+1].val-a[_].val)/3*2|0:a[_+1].val+(a[_].val-a[_+1].val)/3|0;for(var p=a[_].pos;po?0:1}return function(e){for(var t=1;t1&&(!this._inputImageWrapper.inImageWithBorder(e[0],0)||!this._inputImageWrapper.inImageWithBorder(e[1],0));)r(-(n>>=1));return e}},{key:"_getLine",value:function(e){return[{x:(e[1].x+e[0].x)/2,y:(e[1].y+e[0].y)/2},{x:(e[3].x+e[2].x)/2,y:(e[3].y+e[2].y)/2}]}},{key:"_tryDecode",value:function(e){var t=me(this._inputImageWrapper,e[0],e[1]);t=be(t);var r=null;return this._barcodeReaders.some(function(e){return!!(r=e.decodePattern(t.line))}),r?{codeResult:r,barcodeLine:t}:null}},{key:"_tryDecodeBruteForce",value:function(e,t,r){for(var n=Math.sqrt(Math.pow(e[1].x-e[0].x,2)+Math.pow(e[1].y-e[0].y,2)),i=Math.sin(r),a=Math.cos(r),o=1;o<16;o++){var s=n/16*o*(o%2==0?-1:1);t[0].y+=s*i,t[0].x-=s*a,t[1].y+=s*i,t[1].x-=s*a;var u=this._tryDecode(t);if(u)return u}return null}},{key:"_printFrequency",value:function(e){var t=this._frequencyCanvas.getContext("2d");this._frequencyCanvas.width=e.length,this._frequencyCanvas.height=256,t.beginPath(),t.strokeStyle="blue";for(var r=0;r0&&(i=s,console.log("WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead")),void 0!==u&&(n=u,console.log("WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'")),{audio:!1,video:a&&n?{width:t,height:r,aspectRatio:i,deviceId:a}:{width:t,height:r,facingMode:n,aspectRatio:i,deviceId:a}}}};function Oe(e){var t=e.videoWidth,r=e.videoHeight;return new Promise(function(e,n){var i=10;!function a(){i>0?t>10&&r>10?e():window.setTimeout(a,500):n("Unable to play video stream. Is webcam working?"),i--}()})}var Re=r(19),ze=function(){function e(t){i()(this,e),u()(this,"_inputStream",void 0),u()(this,"_streamConfig",void 0),u()(this,"_data",void 0),u()(this,"_canvasData",void 0),u()(this,"_grayData",void 0),u()(this,"_canvasImageArray",void 0),u()(this,"_grayImageArray",void 0),u()(this,"_targetImageArray",void 0),u()(this,"_canvasHeight",void 0),u()(this,"_canvasWidth",void 0),u()(this,"_videoHeight",void 0),u()(this,"_videoWidth",void 0),u()(this,"_height",void 0),u()(this,"_width",void 0),u()(this,"_stepSizeX",void 0),u()(this,"_stepSizeY",void 0),u()(this,"_topLeft",void 0),this._inputStream=t,this._streamConfig=t.config,this._videoHeight=t.realHeight,this._videoWidth=t.realWidth,this._canvasHeight=t.canvasHeight,this._canvasWidth=t.canvasWidth,this._width=t.width,this._height=t.height,this._topLeft=t.topLeft,this._data=new Uint8Array(this._width*this._height),this._grayData=new Uint8Array(this._videoWidth*this._videoHeight),this._canvasData=new Uint8Array(this._canvasWidth*this._canvasHeight),this._grayImageArray=Re(this._grayData,[this._videoHeight,this._videoWidth]).transpose(1,0),this._canvasImageArray=Re(this._canvasData,[this._canvasHeight,this._canvasWidth]).transpose(1,0),this._targetImageArray=this._canvasImageArray.hi(this._topLeft.x+this._width,this._topLeft.y+this._height).lo(this._topLeft.x,this._topLeft.y),this._stepSizeX=this._videoWidth/this._canvasWidth,this._stepSizeY=this._videoHeight/this._canvasHeight,console.log("FrameGrabber",JSON.stringify({videoSize:this._grayImageArray.shape,canvasSize:this._canvasImageArray.shape,stepSize:[this._stepSizeX,this._stepSizeY],size:this._targetImageArray.shape,topLeft:this._topLeft}))}return o()(e,[{key:"grab",value:function(e){this._data=e;var t=this._inputStream.getFrame();return!!t&&(this._scaleAndCrop(t),!0)}},{key:"_scaleAndCrop",value:function(e){this._computeGray(e.data);for(var t=0;te._height?e._config.size:e._width*e._config.size/e._height|0:e._width,e._canvasHeight=e._calculatedHeight=e._config.size?e._width>e._height?e._height*e._config.size/e._width|0:e._config.size:e._height,setTimeout(function(){return e.trigger("canrecord",[])},0)},this._offset,this._size,this._config.sequence)}},{key:"realHeight",get:function(){return this._height}},{key:"realWidth",get:function(){return this._width}},{key:"config",get:function(){return this._config},set:function(e){this._config=function(e){for(var t=1;tt?this._config.size:e*this._config.size/t|0:e,this._canvasHeight=this._calculatedHeight=this._config.size?e>t?t*this._config.size/e|0:this._config.size:t}},{key:"realHeight",get:function(){return this._video.videoHeight}},{key:"realWidth",get:function(){return this._video.videoWidth}},{key:"config",get:function(){return this._config},set:function(e){this._config=function(e){for(var t=1;t>1];t0&&(r=Math.abs(e[t]-c)>Math.abs(e[t-1]-c)?0|e[t-1]:0|e[t]),c/ra[s-1]/a[s]?{x:r,y:r}:null}return h(function(e,t){if(e===t)return Ne(e);for(var r=e>t?e:t,n=e>t?t:e,i=new Array,a=new Array,o=1;o*o<=n;o++)if(r%o==0&&n%o==0){i.push(o);var s=n/o|0;o!==s&&r%s==0&&a.unshift()}return i.concat(a)}(r,n))||h(Ne(i))||h(Ne(c*u))}function Be(e,t){var r=e.width,n=e.height,i=t.halfSample?1:0,a=e.config;if(a&&a.area){var o=function(e,t,r){var n={width:e,height:t},i=Object.keys(r).reduce(function(e,t){var i=r[t],a=function(e){return{value:parseFloat(e),unit:e.indexOf("%")===e.length-1?"%":e.indexOf("px")===e.length-2?"px":"%"}}(i),o=Fe[t](a,n);return e[t]=o,e},{});return{topLeft:{x:i.left,y:i.top},width:i.right-i.left,height:i.bottom-i.top}}(r,n,a.area);e.topLeft=o.topLeft,e.setCanvasSize(r,n),r=o.width,n=o.height}var s={x:r>>i,y:n>>i},u=He(t.patchSize,s);if(e.width=(s.x/u.x<this._threshold}},{key:"moments",get:function(){return this._moments}}]),e}();function qe(e,t){var r=e.x,n=e.y;return{x:t[0]*r+t[2]*n,y:t[1]*r+t[3]*n}}function Xe(e,t){t||(t=8);var r=8-t,n=function(e,t){t||(t=8);for(var r=e.data,n=8-t,i=new Int32Array(1<>n]++;return i}(e,t),i=[0],a=(1<n[e]?r:e},0)<0){o=o-1|0;n[r+o|0]=(n[e+o|0]|0)-(n[t+o|0]|0)|0}}function u(e,t,r){e=e|0;t=t|0;r=r|0;var o=0;o=a(i,i)|0;while((o|0)>0){o=o-1|0;n[r+o|0]=n[e+o|0]|0|(n[t+o|0]|0)|0}}function c(e){e=e|0;var t=0,r=0;r=a(i,i)|0;while((r|0)>0){r=r-1|0;t=(t|0)+(n[e+r|0]|0)|0}return t|0}function h(e,t){e=e|0;t=t|0;var r=0;r=a(i,i)|0;while((r|0)>0){r=r-1|0;n[e+r|0]=t}}function l(e,t){e=e|0;t=t|0;var r=0,a=0,o=0,s=0,u=0,c=0,h=0,l=0;for(r=1;(r|0)<(i-1|0);r=r+1|0){l=l+i|0;for(a=1;(a|0)<(i-1|0);a=a+1|0){s=l-i|0;u=l+i|0;c=a-1|0;h=a+1|0;o=(n[e+s+c|0]|0)+(n[e+s+h|0]|0)+(n[e+l+a|0]|0)+(n[e+u+c|0]|0)+(n[e+u+h|0]|0)|0;if((o|0)>(0|0)){n[t+l+a|0]=1}else{n[t+l+a|0]=0}}}return}function f(e,t){e=e|0;t=t|0;var r=0;r=a(i,i)|0;while((r|0)>0){r=r-1|0;n[t+r|0]=n[e+r|0]|0}}function d(e){e=e|0;var t=0,r=0;for(t=0;(t|0)<(i-1|0);t=t+1|0){n[e+t|0]=0;n[e+r|0]=0;r=r+i-1|0;n[e+r|0]=0;r=r+1|0}for(t=0;(t|0)<(i|0);t=t+1|0){n[e+r|0]=0;r=r+1|0}}function v(){var e=0,t=0,r=0,n=0,v=0,_=0;t=a(i,i)|0;r=t+t|0;n=r+t|0;h(n,0);d(e);do{o(e,t);l(t,r);s(e,r,r);u(n,r,n);f(t,e);v=c(e)|0;_=(v|0)==0|0}while(!_)}return{skeletonize:v}},ht=function(){function e(t,r){i()(this,e),u()(this,"_config",void 0),u()(this,"_inputImageWrapper",void 0),u()(this,"_currentImageWrapper",void 0),u()(this,"_skelImageWrapper",void 0),u()(this,"_subImageWrapper",void 0),u()(this,"_labelImageWrapper",void 0),u()(this,"_binaryImageWrapper",void 0),u()(this,"_patchGrid",void 0),u()(this,"_patchLabelGrid",void 0),u()(this,"_imageToPatchGrid",void 0),u()(this,"_patchSize",void 0),u()(this,"_binaryContext",void 0),u()(this,"_numPatches",void 0),u()(this,"_skeletonizer",void 0),this._config=r,this._inputImageWrapper=t,this._numPatches={x:0,y:0},this._initBuffers(),this._initCanvas()}return o()(e,[{key:"locate",value:function(){this._config.halfSample&&function(e,t){for(var r=e.data,n=e.size.x,i=t.data,a=r.length,o=n>>1,s=0,u=n,c=0;u>2,c++,s+=2,u+=2;s+=n,u+=n}}(this._inputImageWrapper,this._currentImageWrapper),this._binarizeImage();var e=this._findPatches();if(e.lengthu&&(u=t),rc&&(c=r)})});var h=[{x:o,y:s},{x:u,y:s},{x:u,y:c},{x:o,y:c}];return h=h.map(function(e){return qe(e,a)}),this._config.halfSample&&(h=h.map(function(e){var t=e.x,r=e.y;return{x:2*t,y:r*=2}})),h}},{key:"_binarizeImage",value:function(){var e,t,r,n;e=this._currentImageWrapper,t=this._binaryImageWrapper,r=Xe(e),n=t.data,e.data.forEach(function(e,t){n[t]=e0&&t[e-1]++}),t.map(function(e,t){return{value:e,index:t}}).filter(function(e){return e.value>=5}).sort(function(e,t){return t.value-e.value}).map(function(e){return e.index+1})}},{key:"_findBoxes",value:function(e,t){var r=this,n=new Array;return e.forEach(function(e){var t=new Array;r._patchLabelGrid.data.forEach(function(n,i){n===e&&t.push(r._imageToPatchGrid[i])});var i=r._boxFromPatches(t);i&&n.push(i)}),n}},{key:"_similarMoments",value:function(e){return Ve.clusterize(e,.9).reduce(function(e,t){var r=t.moments.length;return r>e.count?{item:t,count:r}:e},{item:{moments:[]},count:0}).item.moments}},{key:"_skeletonize",value:function(e,t){this._binaryImageWrapper.subImageAsCopy(this._subImageWrapper,e,t),this._skeletonizer.skeletonize()}},{key:"_describePatch",value:function(e,t,r,n){if(e.length>1){var i=Math.ceil(this._patchSize.x/3),a=e.filter(function(e){return e.m00>i});if(a.length>1){var o=this._similarMoments(a),s=0|o.length;if(s>1&&s<<2>=3*a.length&&s<<2>e.length){var u=o.reduce(function(e,t){return e+t.rad},0)/s;return{index:t,pos:{x:r,y:n},box:[{x:r,y:n},{x:r+this._subImageWrapper.size.x,y:n},{x:r+this._subImageWrapper.size.x,y:n+this._subImageWrapper.size.y},{x:r,y:n+this._subImageWrapper.size.y}],moments:o,rad:u,x:Math.cos(u),y:Math.sin(u)}}}}return null}},{key:"_notYetProcessed",value:function(){for(var e=0;e.95&&r._trace(u,t)}})}}},{key:"_rasterizeAngularSimilarity",value:function(e){var t=this,r=0;this._patchGrid.data.fill(0),this._patchLabelGrid.data.fill(0),this._imageToPatchGrid.fill(null),e.forEach(function(e){t._imageToPatchGrid[e.index]=e,t._patchGrid.data[e.index]=1}),this._patchGrid.zeroBorder();for(var n=0;(n=this._notYetProcessed())=t&&(t+=e,yt()),window.requestAnimationFrame(r))}(performance.now())):yt()},stop:function(){tt=!0,wt(0),"LiveStream"===ut.inputStream.type&&(Pe.release(),$e.clearEventHandlers())},decodeSingle:function(e,t){var r=this;e=m({inputStream:{type:"ImageStream",sequence:!1,size:800,src:e.src},numOfWorkers:1,locator:{halfSample:!1}},e),this.init(e,function(){f.once("processed",function(e){r.stop(),t.call(null,e)},!0),r.start()})},pause:function(){tt=!0},onDetected:function(e){f.subscribe("detected",e)},offDetected:function(e){f.unsubscribe("detected",e)},onProcessed:function(e){f.subscribe("processed",e)},offProcessed:function(e){f.unsubscribe("processed",e)},setReaders:function(e){at?at.setReaders(e):ot&&ft.length>0&&ft.forEach(function(t){return t.worker.postMessage({cmd:"setReaders",readers:e})})},registerResultCollector:function(e){e&&"function"==typeof e.addResult&&(st=e)}};function dt(e){!function(e){rt=e||new p({x:$e.width,y:$e.height});0;it=[{x:0,y:0},{x:0,y:rt.size.y},{x:rt.size.x,y:rt.size.y},{x:rt.size.x,y:0}],nt=new ht(rt,ut.locator)}(e),at=new we(ut.decoder,rt)}function vt(){var e=ut.inputStream.target;if(e instanceof HTMLElement)return e;var t="string"==typeof e?e:"#interactive.viewport";return document.querySelector(t)}function _t(e,t){e.forEach(function(e){e.x+=t.x,e.y+=t.y})}function pt(e,t){var r=e;if(e&&ot){var n=$e.topLeft;0===n.x&&0===n.y||function e(t,r){t.barcodes&&t.barcodes.forEach(function(t){return e(t,r)}),t.line&&_t(t.line,r),t.box&&_t(t.box,r),t.boxes&&t.boxes.forEach(function(e){return _t(e,r)})}(e,n),function(e,t,r,n){t&&st&&(e.barcodes?e.barcodes.forEach(function(e){var i=e.codeResult;i&&st.addResult(t,r,n,i)}):e.codeResult&&st.addResult(t,r,n,e.codeResult))}(e,t,$e.canvasWidth,$e.canvasHeight),r=e.barcodes||e}f.publish("processed",r),function(e){return e&&(!!e.codeResult||e.barcodes&&e.barcodes.some(function(e){return!!e.codeResult}))}(e)&&f.publish("detected",r)}function gt(){var e=ut.locate?nt.locate():[it];pt(at.decodeFromBoundingBoxes(e),rt.data)}function yt(){if(ot)if(ft.length>0){var e=ft.find(function(e){return!e.busy});if(!e)return;var t=e.imageData;et.grab(t)&&(e.busy=!0,e.worker.postMessage({cmd:"process",imageData:t},[t.buffer]))}else et.grab(rt.data)&>();else gt()}function mt(e){var t,r,n=(t=__factorySource__||"",r=new Blob(["(".concat(bt.toString(),")(").concat(t,");")],{type:"text/javascript"}),window.URL.createObjectURL(r)),i={worker:new Worker(n),imageData:new Uint8Array($e.width*$e.height),busy:!0};i.worker.onmessage=function(t){var r=t.data;"initialized"===r.event?(URL.revokeObjectURL(n),i.busy=!1,i.imageData=new Uint8Array(r.imageData),e(i)):"processed"===r.event?(i.busy=!1,i.imageData=new Uint8Array(r.imageData),pt(r.result,i.imageData)):r.event},i.worker.postMessage({cmd:"init",size:{x:$e.width,y:$e.height},imageData:i.imageData,config:m(ut,{inputStream:{target:null}})},[i.imageData.buffer])}function bt(e){var t,r,n=self;!e||(t=e().default)?self.onmessage=function(e){var i=e.data;if("init"===i.cmd){var a=i.config;a.numOfWorkers=0,r=new t.ImageWrapper({x:i.size.x,y:i.size.y},new Uint8Array(i.imageData)),t.init(a,function(){return n.postMessage({event:"initialized",imageData:r.data},[r.data.buffer])},r),t.onProcessed(function(e){return n.postMessage({event:"processed",imageData:r.data,result:e},[r.data.buffer])})}else"process"===i.cmd?(r.data=new Uint8Array(i.imageData),t.start()):"setReaders"===i.cmd&&t.setReaders(i.readers)}:n.postMessage({event:"error",message:"Quagga could not be created"})}function wt(e,t){var r=e-ft.length;if(!(r>0))return r<0&&(ft.slice(r).forEach(function(e){e.worker.terminate()}),ft=ft.slice(0,r)),t&&t();for(var n=0;n=e&&t&&t()})}}])});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://Quagga/webpack/universalModuleDefinition","webpack://Quagga/webpack/bootstrap","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/defineProperty.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/createClass.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/classCallCheck.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/inherits.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/get.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/typeof.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/regenerator/index.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/iterableToArray.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack://Quagga//Users/adomratchev/node_modules/@babel/runtime/helpers/superPropBase.js","webpack://Quagga//Users/adomratchev/node_modules/regenerator-runtime/runtime-module.js","webpack://Quagga//Users/adomratchev/node_modules/regenerator-runtime/runtime.js","webpack://Quagga/external \"ndarray\"","webpack://Quagga/external \"get-pixels\"","webpack://Quagga/./src/common/image-debug.ts","webpack://Quagga/./src/analytics/result-collector.ts","webpack://Quagga/./src/common/events.ts","webpack://Quagga/./src/common/hsv2rgb.ts","webpack://Quagga/./src/common/image-wrapper.ts","webpack://Quagga/./src/common/merge.ts","webpack://Quagga/./src/config/config.node.ts","webpack://Quagga/./src/reader/barcode-reader.ts","webpack://Quagga/./src/reader/code-128-reader.ts","webpack://Quagga/./src/reader/code-39-reader.ts","webpack://Quagga/./src/reader/code-39-vin-reader.ts","webpack://Quagga/./src/reader/codabar-reader.ts","webpack://Quagga/./src/reader/ean-reader.ts","webpack://Quagga/./src/decoder/bresenham.ts","webpack://Quagga/./src/reader/ean-8-reader.ts","webpack://Quagga/./src/reader/ean-2-reader.ts","webpack://Quagga/./src/reader/ean-5-reader.ts","webpack://Quagga/./src/reader/upc-reader.ts","webpack://Quagga/./src/reader/upc-e-reader.ts","webpack://Quagga/./src/reader/i2of5-reader.ts","webpack://Quagga/./src/reader/2of5-reader.ts","webpack://Quagga/./src/reader/code-93-reader.ts","webpack://Quagga/./src/reader/index.ts","webpack://Quagga/./src/input/camera-access.ts","webpack://Quagga/./src/decoder/barcode-decoder.ts","webpack://Quagga/./src/common/media-devices.ts","webpack://Quagga/./src/input/frame-grabber.node.ts","webpack://Quagga/./src/input/input-stream.ts","webpack://Quagga/./src/input/image-stream.node.ts","webpack://Quagga/./src/input/video-stream.ts","webpack://Quagga/./src/input/live-stream.ts","webpack://Quagga/./src/input/input-stream-utils.ts","webpack://Quagga/./src/common/cluster.ts","webpack://Quagga/./src/locator/barcode-locator-utils.ts","webpack://Quagga/./src/locator/tracer.ts","webpack://Quagga/./src/locator/rasterizer.ts","webpack://Quagga/./src/locator/skeletonizer.js","webpack://Quagga/./src/quagga.ts","webpack://Quagga/./src/locator/barcode-locator.ts"],"names":["root","factory","exports","module","require","define","amd","global","__WEBPACK_EXTERNAL_MODULE__19__","__WEBPACK_EXTERNAL_MODULE__20__","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","obj","configurable","writable","_defineProperties","target","props","length","descriptor","Constructor","protoProps","staticProps","instance","TypeError","_getPrototypeOf","setPrototypeOf","getPrototypeOf","__proto__","_typeof","assertThisInitialized","self","subClass","superClass","constructor","ReferenceError","superPropBase","_get","receiver","Reflect","base","desc","getOwnPropertyDescriptor","_typeof2","iterator","arrayWithoutHoles","iterableToArray","nonIterableSpread","arr","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","error","done","Promise","then","fn","this","args","arguments","apply","err","undefined","Array","isArray","arr2","iter","toString","from","_setPrototypeOf","g","Function","hadRuntime","regeneratorRuntime","getOwnPropertyNames","indexOf","oldRuntime","e","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","inModule","runtime","wrap","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","IteratorPrototype","getProto","NativeIteratorPrototype","values","Gp","GeneratorFunctionPrototype","Generator","GeneratorFunction","displayName","isGeneratorFunction","genFun","ctor","mark","awrap","__await","defineIteratorMethods","AsyncIterator","async","innerFn","outerFn","tryLocsList","next","result","keys","push","reverse","pop","Context","reset","skipTempReset","prev","sent","_sent","delegate","method","tryEntries","forEach","resetTryEntry","charAt","isNaN","slice","stop","rootRecord","completion","type","rval","dispatchException","exception","context","handle","loc","caught","record","entry","tryLoc","hasCatch","hasFinally","catchLoc","finallyLoc","Error","abrupt","finallyEntry","complete","afterLoc","finish","catch","thrown","delegateYield","iterable","resultName","nextLoc","protoGenerator","generator","_invoke","state","doneResult","delegateResult","maybeInvokeDelegate","tryCatch","makeInvokeMethod","previousPromise","callInvokeWithMethodAndArg","invoke","unwrapped","return","pushTryEntry","locs","iteratorMethod","ImageDebug","drawPath","path","color","lineWidth","strokeStyle","fillStyle","beginPath","moveTo","x","y","_ref","lineTo","closePath","stroke","drawImage","imageData","width","height","canvasData","getImageData","data","imageIndex","canvasIndex","putImageData","ResultCollector","config","classCallCheck_default","defineProperty_default","_results","_config","_capacity","capacity","_capture","capture","_canvas","document","createElement","_context","getContext","createClass_default","imageWidth","imageHeight","codeResult","_contains","_passesFilter","frame","toDataURL","blacklist","some","item","every","filter","events","Events","event","callback","subscription","getEvent","subscriptions","eventItem","once","publishSubscription","_ref2","subscribe","eventName","setTimeout","hsv2rgb","hsv","rgb","h","v","Math","abs","b","ImageWrapper","size","arrayType","initialize","Uint8Array","fill","point","border","imageWrapper","fromX","fromY","sizeY","sizeX","labelCount","labelSum","m00","m01","m10","m11","m02","m20","theta","rad","ysq","val","label","PI","PI_4","x_","y_","mu11","mu02","mu20","tmp","atan","cos","sin","scale","current","pixel","whiteRgb","blackRgb","merge","isObject","typeof_default","_len","objects","_key","reduce","pVal","oVal","BarcodeDirection","inputStream","sequence","area","top","right","left","bottom","singleChannel","locate","numOfWorkers","decoder","readers","locator","halfSample","patchSize","BarcodeReader","supplements","_format","_row","_singleCodeError","_averageCodeError","StartNotFoundException","CodeNotFoundException","PatternNotFoundException","pattern","offset","isWhite","tryHarder","counter","bestMatch","Number","MAX_VALUE","code","start","end","epsilon","AVERAGE_CODE_ERROR","counterPos","_nextSet","_matchPattern","sum","j","line","maxSingleError","modulo","SINGLE_CODE_ERROR","barWidth","count","scaled","singleError","correction","indices","decode","direction","Reverse","Forward","format","FORMAT","counters","numCounters","CODE_PATTERN","MODULE_INDICES","Code128Reader","_BarcodeReader","_this","possibleConstructorReturn_default","getPrototypeOf_default","inherits_default","bar","space","_correct","expected","_calculateCorrection","_correctBars","codeset","unshift","startInfo","_findStart","multiplier","checksum","rawResult","decodedCodes","shiftNext","removeLastCharacter","_decodeCode","String","fromCharCode","_nextUnset","_verifyTrailingWhitespace","splice","join","endInfo","trailingWhitespaceEnd","_matchRange","normalized","sumNormalized","sumExpected","ALPHABET","Uint16Array","toConsumableArray_default","map","char","charCodeAt","CHARACTER_ENCODINGS","Code39Reader","decodedChar","lastStart","nextStart","_toCounters","_toPattern","_patternToChar","patternSize","minWidth","maxNarrowWidth","numWideBars","wideBarWidth","_findNextWidth","whiteSpaceMustStart","patternStart","max","Code39VINReader","_Code39Reader","get_default","replace","test","_checkChecksum","START_END","CodabarReader","assertThisInitialized_default","_counters","_fillCounters","startCounter","_verifyWhitespace","_validateResult","_sumCounters","endCounter","_calculatePatternLength","categorization","narrow","counts","min","wide","pos","_charToPattern","kind","cat","floor","ceil","charCode","threshold","_thresholdResultPattern","barThreshold","_computeAlternatingThreshold","spaceThreshold","bitmask","_this2","_loop","_ret","Slope","EXTENSION_START_PATTERN","CODE_FREQUENCY","EANReader","coderange","_findPattern","START_PATTERN","leadingWhitespaceStart","STOP_PATTERN","codeFrequency","CODE_G_START","firstDigit","_calculateFirstDigit","MIDDLE_PATTERN","resultInfo","_decodePayload","_findEnd","_checksum","supplement","_decodeExtensions","lastCode","_objectSpread","EAN8Reader","_EANReader","EAN2Reader","row","parseInt","EAN5Reader","_extensionChecksum","_determineCheckDigit","CHECK_DIGIT_ENCODINGS","UPCReader","substring","UPCEReader","_determineParity","nrSystem","lastDigit","upca","concat","_convertToUPCA","I2of5Reader","normalizeBarSpaceWidth","_barSpaceRatio","counterSum","codeSum","narrowBarWidth","code0","code1","counterLength","counter0","counter1","startPatternLength","TwoOfFiveReader","Readers","code_128_reader","ean_reader","ean_5_reader","ean_2_reader","ean_8_reader","code_39_reader","code_39_vin_reader","codabar_reader","upc_reader","upc_e_reader","i2of5_reader","2of5_reader","code_93_reader","Code93Reader","_verifyEnd","_verifyChecksums","_decodeExtended","round","charArray","nextChar","nextCharCode","_matchCheckChar","index","maxWeight","arrayToCheck","weightedSums","_stream","Bresenham","p1","p2","x0","y0","x1","y1","steep","read","a","deltax","deltay","ystep","center","extrema","rThreshold","currentDir","Up","Down","slope","slope2","dir","bresenham_objectSpread","BarcodeDecoder","inputImageWrapper","_inputImageWrapper","_barcodeReaders","_initReaders","boxes","barcode","multiple","barcodes","box","decodeFromBoundingBox","_getLine","angle","atan2","_getExtendedLine","_tryDecode","_tryDecodeBruteForce","barcodeLine","readerConfig","reader","configuration","extendLine","amount","extension","extensionLength","sqrt","pow","inImageWithBorder","decodePattern","lineAngle","sideLength","xdir","ydir","_frequencyCanvas","_patternCanvas","fillRect","_overlayContext","_enumerateVideoDevices","_request","CameraAccess","request","asyncToGenerator_default","regenerator_default","_callee","video","videoConstraints","normalizedConstraints","pickConstraints","constraints","navigator","mediaDevices","getUserMedia","srcObject","setAttribute","addEventListener","play","_waitForVideo","_x","_x2","release","tracks","getVideoTracks","enumerateVideoDevices","_callee2","devices","_context2","enumerateDevices","getActiveStreamLabel","track","getActiveTrack","facingMode","aspectRatio","deviceId","minAspectRatio","facing","console","log","audio","_ref3","videoWidth","videoHeight","attempts","checkVideo","window","ndarray","FrameGrabber","_inputStream","_streamConfig","_videoHeight","realHeight","_videoWidth","realWidth","_canvasHeight","canvasHeight","_canvasWidth","canvasWidth","_width","_height","_topLeft","topLeft","_data","_grayData","_canvasData","_grayImageArray","transpose","_canvasImageArray","_targetImageArray","hi","lo","_stepSizeX","_stepSizeY","JSON","stringify","videoSize","shape","canvasSize","stepSize","getFrame","_scaleAndCrop","_computeGray","set","interp2d","imageDataLength","ix","fx","s0","s1","iy","fy","t0","t1","w00","w01","InputStream","_eventNames","_eventHandlers","Map","listener","_options","has","clear","argArray","handlers","handler","_calculatedHeight","_calculatedWidth","input_stream_objectSpread","getPixels","ImageStream","_InputStream","_baseUrl","_ended","_frame","_loaded","_offset","_size","mime","pixels","process","exit","trigger","image_stream_node_objectSpread","src","_loadImages","_time","VideoStream","_video","pause","options","_initSize","video_stream_objectSpread","ended","time","currentTime","LiveStream","_VideoStream","_computeDivisors","divisors","largeDivisors","divisor","calculatePatchSize","wideSide","nrOfPatchesList","nrOfPatchesMap","x-small","small","medium","large","x-large","nrOfPatchesIndex","nrOfPatches","desiredPatchSize","findPatchSizeForDivisors","found","largeDivisor","_computeCommonDivisors","checkImageConstraints","shift","inputStreamConfig","inputWidth","inputHeight","parsedArea","parsed","parseFloat","unit","_parseCssDimensionValues","calculated","_dimensionsConverters","computeImageArea","setCanvasSize","dimension","_ref4","_ref5","Cluster","moment","_threshold","_moments","_center","add","moments","clusters","matchingCluster","find","cluster","fits","transformWithMatrix","matrix","_determineOtsuThreshold","bitsPerPixel","bitShift","hist","histogram","Int32Array","_computeHistogram","vet","px","init","mx","k","p12","m12","maxIndex","array","EdgeLabel","ContourDirection","SearchDirections","Tracer","labelWrapper","_imageData","_labelData","edgeLabel","cy","cx","sy","sx","Fv","trace","Cv","ldir","P","Rasterizer","_tracer","depthLabel","colorMap","sc","cc","connectedCount","labelIndex","bc","lc","vertex","contourTracing","Outside","CW","firstVertex","nextPeer","insideContours","previousPeer","Inside","CCW","canvas","firstContour","pq","iq","q","Unknown","Skeletonizer","_frameGrabber","_stopped","_locator","_boxSize","_decoder","_onUIThread","_resultCollector","stdlib","foreign","buffer","images","imul","erode","inImagePtr","outImagePtr","u","yStart1","yStart2","xStart1","xStart2","subtract","aImagePtr","bImagePtr","bitwiseOr","countNonZero","imagePtr","dilate","memcpy","srcImagePtr","dstImagePtr","zeroBorder","skeletonize","subImagePtr","erodedImagePtr","tempImagePtr","skelImagePtr","BarcodeLocator","_numPatches","_initBuffers","_initCanvas","outImageWrapper","image","outImage","endIndex","outWidth","topRowIndex","bottomRowIndex","outImgIndex","_currentImageWrapper","_binarizeImage","patchesFound","_findPatches","maxLabel","_rasterizeAngularSimilarity","topLabels","_findBiggestConnectedAreas","_findBoxes","_patchSize","_binaryImageWrapper","_labelImageWrapper","skeletonImageData","ArrayBuffer","_subImageWrapper","_skelImageWrapper","_skeletonizer","skeletonizer","_patchLabelGrid","_patchGrid","_imageToPatchGrid","useWorker","className","_binaryContext","patches","averageRad","Float32Array","inverseMatrix","a0","a1","a2","a3","determinant","invert","minX","minY","maxX","maxY","targetWrapper","targetData","_skeletonize","rasterResult","rasterize","patch","_describePatch","labelHist","_ref6","sort","_ref7","_boxFromPatches","clusterize","subImageAsCopy","minComponentWeight","eligibleMoments","matchingMoments","_similarMoments","currentIndex","_this3","currentPatch","_trace","_this4","_notYetProcessed","_ref9","strokeRect","_canvasContainer","ctx","overlay","dom","_workerPool","__webpack_exports__","cb","defaultConfig","_initializeData","viewport","_getViewPort","querySelector","appendChild","clearFix","_adjustWorkerPool","_initInputStream","delay","frequency","timestamp","_update","requestAnimationFrame","performance","now","clearEventHandlers","decodeSingle","resultCallback","onDetected","offDetected","unsubscribe","onProcessed","offProcessed","setReaders","worker","postMessage","cmd","registerResultCollector","resultCollector","addResult","HTMLElement","selector","_transform","polygon","_publishResult","resultToPublish","_transformResult","_addResult","publish","_hasCodeResult","_locateAndDecode","decodeFromBoundingBoxes","availableWorker","busy","grab","_initWorker","factorySource","blob","blobURL","__factorySource__","Blob","_workerInterface","URL","createObjectURL","workerThread","Worker","onmessage","revokeObjectURL","Quagga","message","increaseBy","terminate"],"mappings":"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AAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChB,CAAC,EAAG,E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","file":"quagga.node.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"ndarray\"), require(\"get-pixels\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"Quagga\", [\"ndarray\", \"get-pixels\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Quagga\"] = factory(require(\"ndarray\"), require(\"get-pixels\"));\n\telse\n\t\troot[\"Quagga\"] = factory(root[\"ndarray\"], root[\"get-pixels\"]);\n})(global, function(__WEBPACK_EXTERNAL_MODULE__19__, __WEBPACK_EXTERNAL_MODULE__20__) {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 21);\n","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nmodule.exports = _createClass;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nmodule.exports = _classCallCheck;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf;","var _typeof = require(\"../helpers/typeof\");\n\nvar assertThisInitialized = require(\"./assertThisInitialized\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn;","var setPrototypeOf = require(\"./setPrototypeOf\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;","var getPrototypeOf = require(\"./getPrototypeOf\");\n\nvar superPropBase = require(\"./superPropBase\");\n\nfunction _get(target, property, receiver) {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    module.exports = _get = Reflect.get;\n  } else {\n    module.exports = _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n\n      if (desc.get) {\n        return desc.get.call(receiver);\n      }\n\n      return desc.value;\n    };\n  }\n\n  return _get(target, property, receiver || target);\n}\n\nmodule.exports = _get;","function _typeof2(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof2(obj); }\n\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && _typeof2(Symbol.iterator) === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return _typeof2(obj);\n    };\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : _typeof2(obj);\n    };\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","module.exports = require(\"regenerator-runtime\");\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;","function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  }\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nmodule.exports = _nonIterableSpread;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nmodule.exports = _setPrototypeOf;","var getPrototypeOf = require(\"./getPrototypeOf\");\n\nfunction _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n\n  return object;\n}\n\nmodule.exports = _superPropBase;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n// This method of obtaining a reference to the global object needs to be\n// kept identical to the way it is obtained in runtime.js\nvar g = (function() {\n  return this || (typeof self === \"object\" && self);\n})() || Function(\"return this\")();\n\n// Use `getOwnPropertyNames` because not all browsers support calling\n// `hasOwnProperty` on the global `self` object in a worker. See #183.\nvar hadRuntime = g.regeneratorRuntime &&\n  Object.getOwnPropertyNames(g).indexOf(\"regeneratorRuntime\") >= 0;\n\n// Save the old regeneratorRuntime in case it needs to be restored later.\nvar oldRuntime = hadRuntime && g.regeneratorRuntime;\n\n// Force reevalutation of runtime.js.\ng.regeneratorRuntime = undefined;\n\nmodule.exports = require(\"./runtime\");\n\nif (hadRuntime) {\n  // Restore the original runtime.\n  g.regeneratorRuntime = oldRuntime;\n} else {\n  // Remove the global property added by runtime.js.\n  try {\n    delete g.regeneratorRuntime;\n  } catch(e) {\n    g.regeneratorRuntime = undefined;\n  }\n}\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n!(function(global) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  var inModule = typeof module === \"object\";\n  var runtime = global.regeneratorRuntime;\n  if (runtime) {\n    if (inModule) {\n      // If regeneratorRuntime is defined globally and we're in a module,\n      // make the exports object identical to regeneratorRuntime.\n      module.exports = runtime;\n    }\n    // Don't bother evaluating the rest of this file if the runtime was\n    // already defined globally.\n    return;\n  }\n\n  // Define the runtime globally (as expected by generated code) as either\n  // module.exports (if we're in a module) or a new, empty object.\n  runtime = global.regeneratorRuntime = inModule ? module.exports : {};\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  runtime.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  runtime.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  runtime.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  runtime.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return Promise.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return Promise.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  runtime.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return runtime.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        if (delegate.iterator.return) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  runtime.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  runtime.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n})(\n  // In sloppy mode, unbound `this` refers to the global object, fallback to\n  // Function constructor if we're in global strict mode. That is sadly a form\n  // of indirect eval which violates Content Security Policy.\n  (function() {\n    return this || (typeof self === \"object\" && self);\n  })() || Function(\"return this\")()\n);\n","module.exports = __WEBPACK_EXTERNAL_MODULE__19__;","module.exports = __WEBPACK_EXTERNAL_MODULE__20__;","import { Point } from './point';\n\nexport const ImageDebug = {\n    drawPath(path: Array<Point>, context: CanvasRenderingContext2D, color: string, lineWidth: number): void {\n        if (path && path.length > 1) {\n            context.strokeStyle = color;\n            context.fillStyle = color;\n            context.lineWidth = lineWidth;\n            context.beginPath();\n            context.moveTo(path[0].x, path[0].y);\n            path.slice(1).forEach(({ x, y }) => context.lineTo(x, y));\n            context.closePath();\n            context.stroke();\n        }\n    },\n\n    drawImage(imageData: Uint8Array, width: number, height: number, context: CanvasRenderingContext2D): boolean {\n        const canvasData = context.getImageData(0, 0, width, height);\n        const data = canvasData.data;\n        let imageIndex = imageData.length | 0;\n        let canvasIndex = data.length | 0;\n\n        if (canvasIndex / imageIndex !== 4) {\n            return false;\n        }\n\n        while (imageIndex--) {\n            const value = imageData[imageIndex];\n            data[--canvasIndex] = 255;\n            data[--canvasIndex] = value;\n            data[--canvasIndex] = value;\n            data[--canvasIndex] = value;\n        }\n\n        context.putImageData(canvasData, 0, 0);\n\n        return true;\n    }\n}\n","import { ImageDebug } from '../common/image-debug';\nimport { QuaggaBarcode } from '../decoder/barcode-decoder';\nimport { Barcode } from '../reader/barcode-reader';\n\nexport interface ResultCollectorConfig {\n    capacity?: number;\n    capture?: boolean;\n    blacklist?: Array<Barcode>;\n    filter?: (item: Barcode) => boolean;\n}\n\nexport class ResultCollector {\n    private _canvas: HTMLCanvasElement;\n    private _context: CanvasRenderingContext2D;\n    private _config: ResultCollectorConfig;\n    private _capacity: number;\n    private _capture: boolean;\n    private _results: Array<QuaggaBarcode>;\n\n    constructor(config: ResultCollectorConfig) {\n        this._results = new Array<QuaggaBarcode>();\n        this._config = config;\n        this._capacity = config.capacity || 20;\n        this._capture = config.capture === true;\n\n        if (this._capture) {\n            this._canvas = document.createElement('canvas');\n            this._context = this._canvas.getContext('2d');\n        }\n    }\n\n    addResult(data: Uint8Array, imageWidth: number, imageHeight: number, codeResult: Barcode): void {\n        if (codeResult && this._capacity && !this._contains(codeResult) && this._passesFilter(codeResult)) {\n            const result: QuaggaBarcode = { codeResult };\n\n            this._capacity--;\n\n            if (this._capture) {\n                this._canvas.width = imageWidth;\n                this._canvas.height = imageHeight;\n\n                ImageDebug.drawImage(data, imageWidth, imageHeight, this._context);\n\n                result.frame = this._canvas.toDataURL();\n            }\n\n            this._results.push(result);\n        }\n    }\n\n    getResults(): Array<QuaggaBarcode> {\n        return this._results;\n    }\n\n    private _contains(codeResult: Barcode): boolean {\n        return this._config.blacklist &&\n            this._config.blacklist.some(item => Object.keys(item).every(key => item[key] === codeResult[key]));\n    }\n\n    private _passesFilter(codeResult: Barcode): boolean {\n        return typeof this._config.filter !== 'function' || this._config.filter(codeResult);\n    }\n}\n","export interface EventCallback {\n    (data: any): void;\n}\n\nexport interface EventSubscription {\n    callback: EventCallback;\n    async?: boolean;\n    once?: boolean;\n}\n\ninterface EventItem {\n    subscriptions: Array<EventSubscription>\n}\n\nlet events: { [name: string]: EventItem } = {};\n\nexport class Events {\n    static subscribe(event: string, callback: EventSubscription | EventCallback, async?: boolean) {\n        let subscription: EventSubscription;\n\n        if (typeof callback === 'function') {\n            subscription = {\n                callback,\n                async\n            };\n        } else {\n            subscription = callback;\n            if (!subscription.callback) {\n                throw 'Callback was not specified on options';\n            }\n        }\n\n        getEvent(event).subscriptions.push(subscription);\n    }\n\n    static publish(type: string, data?: any) {\n        const eventItem = getEvent(type);\n        const subscriptions = eventItem.subscriptions;\n\n        // Publish one-time subscriptions\n        subscriptions.filter(({ once }) => !!once).forEach(subscription => publishSubscription(subscription, data));\n\n        // remove them from the subscription\n        eventItem.subscriptions = subscriptions.filter(({ once }) => !once);\n\n        // publish the rest\n        eventItem.subscriptions.forEach(subscription => publishSubscription(subscription, data));\n    }\n\n    static once(event: string, callback: EventCallback, async?: boolean): void {\n        Events.subscribe(event, { callback, async, once: true });\n    }\n\n    static unsubscribe(eventName?: string, callback?: EventCallback) {\n        if (eventName) {\n            const event = getEvent(eventName);\n            if (event && callback) {\n                event.subscriptions = event.subscriptions.filter(subscription => subscription.callback !== callback);\n            } else {\n                event.subscriptions = [];\n            }\n        } else {\n            events = {};\n        }\n    }\n}\n\nfunction getEvent(eventName: string): EventItem {\n    if (!events[eventName]) {\n        events[eventName] = {\n            subscriptions: []\n        };\n    }\n    return events[eventName];\n}\n\nfunction publishSubscription(subscription: EventSubscription, data: any): void {\n    if (subscription.async) {\n        setTimeout(function () {\n            subscription.callback(data);\n        }, 4);\n    } else {\n        subscription.callback(data);\n    }\n}\n","export type HSV = [number, number, number];\n\nexport type RGB = [number, number, number];\n\nexport function hsv2rgb(hsv: HSV, rgb?: RGB): RGB {\n    const h = hsv[0];\n    const s = hsv[1];\n    const v = hsv[2];\n    const c = v * s;\n    const x = c * (1 - Math.abs((h / 60) % 2 - 1));\n    const m = v - c;\n    let r = 0;\n    let g = 0;\n    let b = 0;\n\n    if (h < 60) {\n        r = c;\n        g = x;\n    } else if (h < 120) {\n        r = x;\n        g = c;\n    } else if (h < 180) {\n        g = c;\n        b = x;\n    } else if (h < 240) {\n        g = x;\n        b = c;\n    } else if (h < 300) {\n        r = x;\n        b = c;\n    } else if (h < 360) {\n        r = c;\n        b = x;\n    }\n\n    rgb = rgb || [0, 0, 0];\n\n    rgb[0] = (r + m) * 255 | 0;\n    rgb[1] = (g + m) * 255 | 0;\n    rgb[2] = (b + m) * 255 | 0;\n\n    return rgb;\n}\n","import { Moment } from './moment';\nimport { Point } from './point';\nimport { HSV, hsv2rgb, RGB } from './hsv2rgb';\n\ntype ArrayType = Array<number> | Uint8Array | Int32Array;\n\n/**\n * Represents a basic image combining the data and size.\n * In addition, some methods for manipulation are contained.\n */\nexport class ImageWrapper<T extends ArrayType = Uint8Array> {\n    data: T | Uint8Array;\n    size: Point;\n\n    /**\n     * @param size The size of the image in pixel\n     * @param data If given, a flat array containing the pixel data\n     * @param arrayType If given, the desired DataType of the Array (may be typed/non-typed)\n     * @param initialize Indicating if the array should be initialized on creation.\n     */\n    constructor(size: Point, data?: T, arrayType?: { new(_: number): T | Uint8Array }, initialize?: boolean) {\n        if (!data) {\n            this.data = new (arrayType || Uint8Array)(size.x * size.y);\n\n            if (initialize) {\n                this.data.fill(0);\n            }\n        } else {\n            this.data = data;\n        }\n\n        this.size = size;\n    }\n\n    /**\n     * Tests if a position is within the image with a given offset\n     * @param point The location to test\n     * @param border The padding value in pixels\n     * @returns true if location inside the image's border, false otherwise\n     * @see cvd/image.h\n     */\n    inImageWithBorder(point: Point, border: number): boolean {\n        return (point.x >= border)\n            && (point.y >= border)\n            && (point.x < (this.size.x - border))\n            && (point.y < (this.size.y - border));\n    }\n\n    /**\n     * Creates an {ImageWrapper) and copies the needed underlying image-data area\n     * @param imageWrapper The target {ImageWrapper} where the data should be copied\n     * @param fromX The horizontal position where to copy from\n     * @param fromY The vertical position where to copy from\n    */\n    subImageAsCopy(imageWrapper: ImageWrapper, fromX: number, fromY: number): void {\n        const sizeY = imageWrapper.size.y;\n        const sizeX = imageWrapper.size.x;\n\n        for (let x = 0; x < sizeX; x++) {\n            for (let y = 0; y < sizeY; y++) {\n                imageWrapper.data[y * sizeX + x] = this.data[(fromY + y) * this.size.x + fromX + x];\n            }\n        }\n    }\n\n    /**\n     * Retrieves a given pixel position from the image\n     * @param x The x-position\n     * @param y The y-position\n     * @returns The grayscale value at the pixel-position\n     */\n    get(x: number, y: number): number {\n        return this.data[y * this.size.x + x];\n    }\n\n    /**\n     * Sets a given pixel position in the image\n     * @param x The x-position\n     * @param y The y-position\n     * @param value The grayscale value to set\n     * @returns The Image itself (for possible chaining)\n     */\n    set(x: number, y: number, value: number): ImageWrapper<T> {\n        this.data[y * this.size.x + x] = value;\n        return this;\n    }\n\n    /**\n     * Sets the border of the image (1 pixel) to zero\n     */\n    zeroBorder(): void {\n        const width = this.size.x;\n        const height = this.size.y;\n        const data = this.data;\n\n        for (let i = 0; i < width; i++) {\n            data[i] = data[(height - 1) * width + i] = 0;\n        }\n\n        for (let i = 1; i < height - 1; i++) {\n            data[i * width] = data[i * width + (width - 1)] = 0;\n        }\n    }\n\n    /**\n     * Inverts a binary image in place\n     */\n    invert(): void {\n        const data = this.data;\n\n        for (let i = data.length; i--;) {\n            data[i] = data[i] ? 0 : 1;\n        }\n    }\n\n    moments(labelCount: number): Array<Moment> {\n        const height = this.size.y;\n        const width = this.size.x;\n        const labelSum = new Array<Moment>();\n        const result = new Array<Moment>();\n\n        if (labelCount <= 0) {\n            return result;\n        }\n\n        for (let i = 0; i < labelCount; i++) {\n            labelSum[i] = {\n                m00: 0,\n                m01: 0,\n                m10: 0,\n                m11: 0,\n                m02: 0,\n                m20: 0,\n                theta: 0,\n                rad: 0\n            };\n        }\n\n        for (let y = 0; y < height; y++) {\n            const ysq = y * y;\n            for (let x = 0; x < width; x++) {\n                const val = this.data[y * width + x];\n                if (val > 0) {\n                    const label = labelSum[val - 1];\n                    label.m00 += 1;\n                    label.m01 += y;\n                    label.m10 += x;\n                    label.m11 += x * y;\n                    label.m02 += ysq;\n                    label.m20 += x * x;\n                }\n            }\n        }\n\n        const PI = Math.PI;\n        const PI_4 = PI / 4;\n\n        for (let i = 0; i < labelCount; i++) {\n            const label = labelSum[i];\n            if (!isNaN(label.m00) && label.m00 !== 0) {\n                const x_ = label.m10 / label.m00;\n                const y_ = label.m01 / label.m00;\n                const mu11 = label.m11 / label.m00 - x_ * y_;\n                const mu02 = label.m02 / label.m00 - y_ * y_;\n                const mu20 = label.m20 / label.m00 - x_ * x_;\n                const tmp = 0.5 * Math.atan((mu02 - mu20) / (2 * mu11)) + (mu11 >= 0 ? PI_4 : -PI_4) + PI;\n                label.theta = (tmp * 180 / PI + 90) % 180 - 90;\n                if (label.theta < 0) {\n                    label.theta += 180;\n                }\n                label.rad = tmp > PI ? tmp - PI : tmp;\n                label.x = Math.cos(tmp);\n                label.y = Math.sin(tmp);\n                result.push(label);\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * Displays the {ImageWrapper} in a given canvas\n     * @param context The rendering context to write to\n     * @param scale Scale which is applied to each pixel-value\n     */\n    show(context: CanvasRenderingContext2D, scale: number): void {\n        const height = this.size.y;\n        const width = this.size.x;\n        // const context = canvas.getContext('2d');\n        // canvas.height = height;\n        // canvas.width = width;\n        const frame = context.getImageData(0, 0, width, height);\n        const data = frame.data;\n        let current = 0;\n\n        if (!scale) {\n            scale = 1.0;\n        }\n\n        for (let y = 0; y < height; y++) {\n            for (let x = 0; x < width; x++) {\n                const pixel = y * width + x;\n                current = this.get(x, y) * scale;\n                data[pixel * 4 + 0] = current;\n                data[pixel * 4 + 1] = current;\n                data[pixel * 4 + 2] = current;\n                data[pixel * 4 + 3] = 255;\n            }\n        }\n\n        //frame.data = data;\n        context.putImageData(frame, 0, 0);\n    }\n\n    /**\n     * Displays the part of the image in a given canvas\n     * @param context The rendering context to write to\n     * @param scale Scale which is applied to each pixel-value\n     * @param fromX The horizontal position where to overlay from\n     * @param fromY The vertical position where to overlay from\n     */\n    overlay(context: CanvasRenderingContext2D, scale: number, fromX: number, fromY: number): void {\n        const hsv: HSV = [0, 1, 1];\n        const whiteRgb: RGB = [255, 255, 255];\n        const blackRgb: RGB = [0, 0, 0];\n        const frame = context.getImageData(fromX, fromY, this.size.x, this.size.y);\n        const data = frame.data;\n\n        if (!scale || scale < 0 || scale > 360) {\n            scale = 360;\n        }\n\n        for (let length = this.data.length; length--;) {\n            hsv[0] = this.data[length] * scale;\n            const rgb: RGB = hsv[0] <= 0 ? whiteRgb : hsv[0] >= 360 ? blackRgb : hsv2rgb(hsv);\n            data[length * 4 + 0] = rgb[0];\n            data[length * 4 + 1] = rgb[1];\n            data[length * 4 + 2] = rgb[2];\n            data[length * 4 + 3] = 255;\n        }\n\n        context.putImageData(frame, fromX, fromY);\n    }\n}\n","/**\n * Performs a deep merge of objects and returns new object.\n * Does not modify objects (immutable).\n * @see https://stackoverflow.com/a/48218209\n *\n * @param objects - Objects to merge\n * @returns New object with merged key/values\n */\nexport function merge(...objects: ReadonlyArray<any>): object {\n    const isObject = (obj: unknown) => obj && typeof obj === 'object';\n\n    return objects.reduce((prev, obj) => {\n        if (obj) {\n            Object.keys(obj).forEach(key => {\n                const pVal = prev[key];\n                const oVal = obj[key];\n\n                if (Array.isArray(pVal) && Array.isArray(oVal)) {\n                    // prev[key] = pVal.concat(...oVal);\n                    prev[key] = oVal;\n                } else if (isObject(pVal) && isObject(oVal)) {\n                    prev[key] = merge(pVal, oVal);\n                } else {\n                    prev[key] = oVal;\n                }\n            });\n        }\n\n        return prev;\n    }, {});\n}","import { QuaggaConfig } from './config';\n\nexport const config: QuaggaConfig = {\n    inputStream: {\n        type: 'ImageStream',\n        sequence: false,\n        size: 800,\n        area: {\n            top: '0%',\n            right: '0%',\n            left: '0%',\n            bottom: '0%'\n        },\n        singleChannel: false // true: only the red color-channel is read\n    },\n    locate: true,\n    numOfWorkers: 0,\n    decoder: {\n        readers: [\n            'code_128_reader'\n        ]\n    },\n    locator: {\n        halfSample: true,\n        patchSize: 'medium' // x-small, small, medium, large, x-large\n    }\n};\n","export enum BarcodeDirection {\n    Forward = 1,\n    Reverse = -1\n};\n\nexport type BarcodeFormat = string;\n\nexport type BarcodeReaderType = string;\n\nexport type BarcodeReaderDeclaration = BarcodeReaderType | { format: BarcodeReaderType; config: BarcodeReaderConfig; };\n\nexport interface BarcodeReaderConfig {\n    normalizeBarSpaceWidth?: boolean;\n    supplements?: Array<BarcodeReaderType>;\n}\n\nexport interface BarcodeCorrection {\n    bar: number;\n    space: number;\n}\n\nexport interface BarcodeInfo {\n    code?: number;\n    correction?: BarcodeCorrection;\n    end?: number;\n    endCounter?: number;\n    error?: number;\n    start?: number;\n    startCounter?: number;\n}\n\nexport interface Barcode {\n    code?: string;\n    codeset?: number;\n    correction?: BarcodeCorrection;\n    decodedCodes?: Array<string | BarcodeInfo>;\n    direction?: BarcodeDirection;\n    end?: number;\n    endInfo?: BarcodeInfo;\n    format?: BarcodeFormat;\n    start?: number;\n    startInfo?: BarcodeInfo;\n    supplement?: Barcode;\n}\n\nexport abstract class BarcodeReader {\n    protected _singleCodeError: number;\n    protected _averageCodeError: number;\n    protected _format: BarcodeFormat;\n    protected _row: Array<number>;\n\n    config: BarcodeReaderConfig;\n    supplements: Array<BarcodeReader>;\n\n    static get Exception() {\n        return {\n            StartNotFoundException: 'Start-Info was not found!',\n            CodeNotFoundException: 'Code could not be found!',\n            PatternNotFoundException: 'Pattern could not be found!'\n        };\n    }\n\n    get SINGLE_CODE_ERROR(): number {\n        return this._singleCodeError;\n    }\n\n    get AVERAGE_CODE_ERROR(): number {\n        return this._averageCodeError;\n    }\n\n    get FORMAT(): BarcodeFormat {\n        return this._format;\n    }\n\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        this._format = 'unknown';\n        this._row = [];\n        this.config = config || {};\n        this.supplements = supplements;\n    }\n\n    abstract decode(row?: Array<number>, start?: number): Barcode;\n\n    protected _findPattern(pattern: ReadonlyArray<number>, offset: number, isWhite: 0 | 1, tryHarder: boolean): BarcodeInfo {\n        const counter = new Array<number>(pattern.length);\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        };\n        const epsilon = this.AVERAGE_CODE_ERROR;\n        let counterPos = 0;\n\n        if (!offset) {\n            offset = this._nextSet(this._row);\n        }\n\n        counter.fill(0);\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    const error = this._matchPattern(counter, pattern);\n\n                    if (error < epsilon) {\n                        bestMatch.error = error;\n                        bestMatch.start = i - counter.reduce((sum, value) => sum + value, 0);\n                        bestMatch.end = i;\n                        return bestMatch;\n                    }\n\n                    if (tryHarder) {\n                        for (let j = 0; j < counter.length - 2; j++) {\n                            counter[j] = counter[j + 2];\n                        }\n                        counter[counter.length - 2] = 0;\n                        counter[counter.length - 1] = 0;\n                        counterPos--;\n                    } else {\n                        return null;\n                    }\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n        return null;\n    }\n\n    protected _nextUnset(line: ReadonlyArray<number>, start?: number): number {\n        for (let i = start || 0; i < line.length; i++) {\n            if (!line[i]) {\n                return i;\n            }\n        }\n        return line.length;\n    }\n\n    protected _nextSet(line: ReadonlyArray<number>, start?: number): number {\n        for (let i = start || 0; i < line.length; i++) {\n            if (line[i]) {\n                return i;\n            }\n        }\n        return line.length;\n    }\n\n    protected _matchRange(start: number, end: number, value: number): boolean {\n        for (let i = start < 0 ? 0 : start; i < end; i++) {\n            if (this._row[i] !== value) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    protected _matchPattern(counter: ReadonlyArray<number>, code: ReadonlyArray<number>, maxSingleError?: number): number {\n        let error = 0;\n        let sum = 0;\n        let modulo = 0;\n\n        maxSingleError = maxSingleError || this.SINGLE_CODE_ERROR || 1;\n\n        for (let i = 0; i < counter.length; i++) {\n            sum += counter[i];\n            modulo += code[i];\n        }\n\n        if (sum < modulo) {\n            return Number.MAX_VALUE;\n        }\n\n        const barWidth = sum / modulo;\n        maxSingleError *= barWidth;\n\n        for (let i = 0; i < counter.length; i++) {\n            const count = counter[i];\n            const scaled = code[i] * barWidth;\n            const singleError = Math.abs(count - scaled) / scaled;\n\n            if (singleError > maxSingleError) {\n                return Number.MAX_VALUE;\n            }\n\n            error += singleError;\n        }\n\n        return error / modulo;\n    }\n\n    protected _correctBars(counter: Array<number>, correction: number, indices: Array<number>) {\n        let length = indices.length;\n        let tmp = 0;\n\n        while (length--) {\n            tmp = counter[indices[length]] * (1 - ((1 - correction) / 2));\n            if (tmp > 1) {\n                counter[indices[length]] = tmp;\n            }\n        }\n    }\n\n    decodePattern(pattern: Array<number>): Barcode {\n        this._row = pattern;\n        let result = this.decode();\n\n        if (result === null) {\n            this._row.reverse();\n            result = this.decode();\n            if (result) {\n                result.direction = BarcodeDirection.Reverse;\n                result.start = this._row.length - result.start;\n                result.end = this._row.length - result.end;\n            }\n        } else {\n            result.direction = BarcodeDirection.Forward;\n        }\n\n        if (result) {\n            result.format = this.FORMAT;\n        }\n\n        return result;\n    }\n\n    _fillCounters(offset: number, end: number, isWhite: 0 | 1): Array<number> {\n        const counters = new Array<number>();\n        let counterPos = 0;\n\n        counters[counterPos] = 0;\n\n        for (let i = offset; i < end; i++) {\n            if (this._row[i] ^ isWhite) {\n                counters[counterPos]++;\n            } else {\n                counterPos++;\n                counters[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return counters;\n    }\n\n    protected _toCounters(start: number, counters: Uint16Array): Uint16Array {\n        const numCounters = counters.length;\n        const end = this._row.length;\n        let isWhite: 0 | 1 = this._row[start] ? 0 : 1;\n        let counterPos = 0;\n\n        counters.fill(0);\n\n        for (let i = start; i < end; i++) {\n            if (this._row[i] ^ isWhite) {\n                counters[counterPos]++;\n            } else {\n                counterPos++;\n                if (counterPos === numCounters) {\n                    break;\n                } else {\n                    counters[counterPos] = 1;\n                    isWhite = isWhite ? 0 : 1;\n                }\n            }\n        }\n\n        return counters;\n    }\n}\n","import { Barcode, BarcodeCorrection, BarcodeInfo, BarcodeReader } from './barcode-reader';\n\nconst CODE_SHIFT = 98;\nconst CODE_C = 99;\nconst CODE_B = 100;\nconst CODE_A = 101;\nconst START_CODE_A = 103;\nconst START_CODE_B = 104;\nconst START_CODE_C = 105;\nconst STOP_CODE = 106;\nconst CODE_PATTERN = [\n    [2, 1, 2, 2, 2, 2],\n    [2, 2, 2, 1, 2, 2],\n    [2, 2, 2, 2, 2, 1],\n    [1, 2, 1, 2, 2, 3],\n    [1, 2, 1, 3, 2, 2],\n    [1, 3, 1, 2, 2, 2],\n    [1, 2, 2, 2, 1, 3],\n    [1, 2, 2, 3, 1, 2],\n    [1, 3, 2, 2, 1, 2],\n    [2, 2, 1, 2, 1, 3],\n    [2, 2, 1, 3, 1, 2],\n    [2, 3, 1, 2, 1, 2],\n    [1, 1, 2, 2, 3, 2],\n    [1, 2, 2, 1, 3, 2],\n    [1, 2, 2, 2, 3, 1],\n    [1, 1, 3, 2, 2, 2],\n    [1, 2, 3, 1, 2, 2],\n    [1, 2, 3, 2, 2, 1],\n    [2, 2, 3, 2, 1, 1],\n    [2, 2, 1, 1, 3, 2],\n    [2, 2, 1, 2, 3, 1],\n    [2, 1, 3, 2, 1, 2],\n    [2, 2, 3, 1, 1, 2],\n    [3, 1, 2, 1, 3, 1],\n    [3, 1, 1, 2, 2, 2],\n    [3, 2, 1, 1, 2, 2],\n    [3, 2, 1, 2, 2, 1],\n    [3, 1, 2, 2, 1, 2],\n    [3, 2, 2, 1, 1, 2],\n    [3, 2, 2, 2, 1, 1],\n    [2, 1, 2, 1, 2, 3],\n    [2, 1, 2, 3, 2, 1],\n    [2, 3, 2, 1, 2, 1],\n    [1, 1, 1, 3, 2, 3],\n    [1, 3, 1, 1, 2, 3],\n    [1, 3, 1, 3, 2, 1],\n    [1, 1, 2, 3, 1, 3],\n    [1, 3, 2, 1, 1, 3],\n    [1, 3, 2, 3, 1, 1],\n    [2, 1, 1, 3, 1, 3],\n    [2, 3, 1, 1, 1, 3],\n    [2, 3, 1, 3, 1, 1],\n    [1, 1, 2, 1, 3, 3],\n    [1, 1, 2, 3, 3, 1],\n    [1, 3, 2, 1, 3, 1],\n    [1, 1, 3, 1, 2, 3],\n    [1, 1, 3, 3, 2, 1],\n    [1, 3, 3, 1, 2, 1],\n    [3, 1, 3, 1, 2, 1],\n    [2, 1, 1, 3, 3, 1],\n    [2, 3, 1, 1, 3, 1],\n    [2, 1, 3, 1, 1, 3],\n    [2, 1, 3, 3, 1, 1],\n    [2, 1, 3, 1, 3, 1],\n    [3, 1, 1, 1, 2, 3],\n    [3, 1, 1, 3, 2, 1],\n    [3, 3, 1, 1, 2, 1],\n    [3, 1, 2, 1, 1, 3],\n    [3, 1, 2, 3, 1, 1],\n    [3, 3, 2, 1, 1, 1],\n    [3, 1, 4, 1, 1, 1],\n    [2, 2, 1, 4, 1, 1],\n    [4, 3, 1, 1, 1, 1],\n    [1, 1, 1, 2, 2, 4],\n    [1, 1, 1, 4, 2, 2],\n    [1, 2, 1, 1, 2, 4],\n    [1, 2, 1, 4, 2, 1],\n    [1, 4, 1, 1, 2, 2],\n    [1, 4, 1, 2, 2, 1],\n    [1, 1, 2, 2, 1, 4],\n    [1, 1, 2, 4, 1, 2],\n    [1, 2, 2, 1, 1, 4],\n    [1, 2, 2, 4, 1, 1],\n    [1, 4, 2, 1, 1, 2],\n    [1, 4, 2, 2, 1, 1],\n    [2, 4, 1, 2, 1, 1],\n    [2, 2, 1, 1, 1, 4],\n    [4, 1, 3, 1, 1, 1],\n    [2, 4, 1, 1, 1, 2],\n    [1, 3, 4, 1, 1, 1],\n    [1, 1, 1, 2, 4, 2],\n    [1, 2, 1, 1, 4, 2],\n    [1, 2, 1, 2, 4, 1],\n    [1, 1, 4, 2, 1, 2],\n    [1, 2, 4, 1, 1, 2],\n    [1, 2, 4, 2, 1, 1],\n    [4, 1, 1, 2, 1, 2],\n    [4, 2, 1, 1, 1, 2],\n    [4, 2, 1, 2, 1, 1],\n    [2, 1, 2, 1, 4, 1],\n    [2, 1, 4, 1, 2, 1],\n    [4, 1, 2, 1, 2, 1],\n    [1, 1, 1, 1, 4, 3],\n    [1, 1, 1, 3, 4, 1],\n    [1, 3, 1, 1, 4, 1],\n    [1, 1, 4, 1, 1, 3],\n    [1, 1, 4, 3, 1, 1],\n    [4, 1, 1, 1, 1, 3],\n    [4, 1, 1, 3, 1, 1],\n    [1, 1, 3, 1, 4, 1],\n    [1, 1, 4, 1, 3, 1],\n    [3, 1, 1, 1, 4, 1],\n    [4, 1, 1, 1, 3, 1],\n    [2, 1, 1, 4, 1, 2],\n    [2, 1, 1, 2, 1, 4],\n    [2, 1, 1, 2, 3, 2],\n    [2, 3, 3, 1, 1, 1, 2]\n];\nconst MODULE_INDICES = { bar: [0, 2, 4], space: [1, 3, 5] };\n\nexport class Code128Reader extends BarcodeReader {\n    constructor() {\n        super();\n\n        this._format = 'code_128';\n        this._singleCodeError = 0.64;\n        this._averageCodeError = 0.30;\n    }\n\n    protected _decodeCode(start: number, correction: BarcodeCorrection): BarcodeInfo {\n        const counter = [0, 0, 0, 0, 0, 0];\n        const offset = start;\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: start,\n            end: start,\n            correction: {\n                bar: 1,\n                space: 1\n            }\n        };\n        const epsilon = this.AVERAGE_CODE_ERROR;\n        let isWhite: 0 | 1 = this._row[offset] ? 0 : 1;\n        let counterPos = 0;\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    if (correction) {\n                        this._correct(counter, correction);\n                    }\n\n                    for (let code = 0; code < CODE_PATTERN.length; code++) {\n                        const error = this._matchPattern(counter, CODE_PATTERN[code]);\n                        if (error < bestMatch.error) {\n                            bestMatch.code = code;\n                            bestMatch.error = error;\n                        }\n                    }\n\n                    bestMatch.end = i;\n\n                    if (bestMatch.code === -1 || bestMatch.error > epsilon) {\n                        return null;\n                    }\n\n                    const expected = CODE_PATTERN[bestMatch.code];\n                    if (expected) {\n                        bestMatch.correction.bar = this._calculateCorrection(expected, counter, MODULE_INDICES.bar);\n                        bestMatch.correction.space = this._calculateCorrection(expected, counter, MODULE_INDICES.space);\n                    }\n\n                    return bestMatch;\n                } else {\n                    counterPos++;\n                }\n\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n\n    private _correct(counter: Array<number>, correction: BarcodeCorrection): void {\n        this._correctBars(counter, correction.bar, MODULE_INDICES.bar);\n        this._correctBars(counter, correction.space, MODULE_INDICES.space);\n    }\n\n    protected _findStart() {\n        const counter = [0, 0, 0, 0, 0, 0];\n        const offset = this._nextSet(this._row);\n        const bestMatch = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0,\n            correction: {\n                bar: 1,\n                space: 1\n            }\n        };\n        const epsilon = this.AVERAGE_CODE_ERROR;\n        let isWhite: 0 | 1 = 0;\n        let counterPos = 0;\n        let sum: number;\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    sum = 0;\n                    for (let j = 0; j < counter.length; j++) {\n                        sum += counter[j];\n                    }\n                    for (let code = START_CODE_A; code <= START_CODE_C; code++) {\n                        const error = this._matchPattern(counter, CODE_PATTERN[code]);\n                        if (error < bestMatch.error) {\n                            bestMatch.code = code;\n                            bestMatch.error = error;\n                        }\n                    }\n                    if (bestMatch.error < epsilon) {\n                        bestMatch.start = i - sum;\n                        bestMatch.end = i;\n                        bestMatch.correction.bar = this._calculateCorrection(CODE_PATTERN[bestMatch.code], counter,\n                            MODULE_INDICES.bar);\n                        bestMatch.correction.space = this._calculateCorrection(CODE_PATTERN[bestMatch.code], counter,\n                            MODULE_INDICES.space);\n                        return bestMatch;\n                    }\n\n                    for (let j = 0; j < 4; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[4] = 0;\n                    counter[5] = 0;\n                    counterPos--;\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n\n    decode(): Barcode {\n        const result = new Array<string | number>();\n        const startInfo = this._findStart();\n        let code: BarcodeInfo = null;\n        let done = false;\n        let multiplier = 0;\n        let checksum = 0;\n        let codeset: number;\n        let rawResult = new Array<number>();\n        let decodedCodes = new Array<BarcodeInfo>();\n        let shiftNext = false;\n        let unshift: boolean;\n        let removeLastCharacter = true;\n\n        if (startInfo === null) {\n            return null;\n        }\n        code = {\n            code: startInfo.code,\n            start: startInfo.start,\n            end: startInfo.end,\n            correction: {\n                bar: startInfo.correction.bar,\n                space: startInfo.correction.space\n            }\n        };\n        decodedCodes.push(code);\n        checksum = code.code;\n\n        switch (code.code) {\n            case START_CODE_A:\n                codeset = CODE_A;\n                break;\n            case START_CODE_B:\n                codeset = CODE_B;\n                break;\n            case START_CODE_C:\n                codeset = CODE_C;\n                break;\n            default:\n                return null;\n        }\n\n        while (!done) {\n            unshift = shiftNext;\n            shiftNext = false;\n            code = this._decodeCode(code.end, code.correction);\n            if (code !== null) {\n                if (code.code !== STOP_CODE) {\n                    removeLastCharacter = true;\n                }\n\n                if (code.code !== STOP_CODE) {\n                    rawResult.push(code.code);\n                    multiplier++;\n                    checksum += multiplier * code.code;\n                }\n                decodedCodes.push(code);\n\n                switch (codeset) {\n                    case CODE_A: {\n                        if (code.code < 64) {\n                            result.push(String.fromCharCode(32 + code.code));\n                        } else if (code.code < 96) {\n                            result.push(String.fromCharCode(code.code - 64));\n                        } else {\n                            if (code.code !== STOP_CODE) {\n                                removeLastCharacter = false;\n                            }\n                            switch (code.code) {\n                                case CODE_SHIFT:\n                                    shiftNext = true;\n                                    codeset = CODE_B;\n                                    break;\n                                case CODE_B:\n                                    codeset = CODE_B;\n                                    break;\n                                case CODE_C:\n                                    codeset = CODE_C;\n                                    break;\n                                case STOP_CODE:\n                                    done = true;\n                                    break;\n                            }\n                        }\n                        break;\n                    }\n                    case CODE_B: {\n                        if (code.code < 96) {\n                            result.push(String.fromCharCode(32 + code.code));\n                        } else {\n                            if (code.code !== STOP_CODE) {\n                                removeLastCharacter = false;\n                            }\n                            switch (code.code) {\n                                case CODE_SHIFT:\n                                    shiftNext = true;\n                                    codeset = CODE_A;\n                                    break;\n                                case CODE_A:\n                                    codeset = CODE_A;\n                                    break;\n                                case CODE_C:\n                                    codeset = CODE_C;\n                                    break;\n                                case STOP_CODE:\n                                    done = true;\n                                    break;\n                            }\n                        }\n                        break;\n                    }\n                    case CODE_C: {\n                        if (code.code < 100) {\n                            result.push(code.code < 10 ? '0' + code.code : code.code);\n                        } else {\n                            if (code.code !== STOP_CODE) {\n                                removeLastCharacter = false;\n                            }\n                            switch (code.code) {\n                                case CODE_A:\n                                    codeset = CODE_A;\n                                    break;\n                                case CODE_B:\n                                    codeset = CODE_B;\n                                    break;\n                                case STOP_CODE:\n                                    done = true;\n                                    break;\n                            }\n                        }\n                        break;\n                    }\n                }\n            } else {\n                done = true;\n            }\n            if (unshift) {\n                codeset = codeset === CODE_A ? CODE_B : CODE_A;\n            }\n        }\n\n        if (code === null) {\n            return null;\n        }\n\n        code.end = this._nextUnset(this._row, code.end);\n        if (!this._verifyTrailingWhitespace(code)) {\n            return null;\n        }\n\n        checksum -= multiplier * rawResult[rawResult.length - 1];\n        if (checksum % 103 !== rawResult[rawResult.length - 1]) {\n            return null;\n        }\n\n        if (!result.length) {\n            return null;\n        }\n\n        // remove last code from result (checksum)\n        if (removeLastCharacter) {\n            result.splice(result.length - 1, 1);\n        }\n\n        return {\n            code: result.join(''),\n            start: startInfo.start,\n            end: code.end,\n            codeset,\n            startInfo,\n            decodedCodes,\n            endInfo: code\n        };\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n\n    private _calculateCorrection(\n        expected: ReadonlyArray<number>,\n        normalized: ReadonlyArray<number>,\n        indices: ReadonlyArray<number>\n    ): number {\n        let sumNormalized = 0;\n        let sumExpected = 0;\n\n        for (let length = indices.length; length--;) {\n            sumExpected += expected[indices[length]];\n            sumNormalized += normalized[indices[length]];\n        }\n\n        return sumExpected / sumNormalized;\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader } from './barcode-reader';\n\nconst ASTERISK = 0x094;\nconst ALPHABETH_STRING = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%';\nconst ALPHABET = new Uint16Array([...ALPHABETH_STRING].map(char => char.charCodeAt(0)));\n// const ALPHABET = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,\n//     79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 45, 46, 32, 42, 36, 47, 43, 37];\nconst CHARACTER_ENCODINGS = new Uint16Array([\n    0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, 0x109, 0x049, 0x148, 0x019, 0x118, 0x058,\n    0x00D, 0x10C, 0x04C, 0x01C, 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, 0x181, 0x0C1,\n    0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, 0x0A8, 0x0A2, 0x08A, 0x02A\n]);\n\nexport class Code39Reader extends BarcodeReader {\n    constructor() {\n        super();\n\n        this._format = 'code_39';\n    }\n\n    decode(): Barcode {\n        const start = this._findStart();\n\n        if (!start) {\n            return null;\n        }\n\n        const result = new Array<string>();\n        let counters = new Uint16Array(9);\n        let decodedChar: string;\n        let lastStart: number;\n        let nextStart = this._nextSet(this._row, start.end);\n\n        do {\n            this._toCounters(nextStart, counters);\n            const pattern = this._toPattern(counters);\n            if (pattern < 0) {\n                return null;\n            }\n            decodedChar = this._patternToChar(pattern);\n            if (decodedChar === null) {\n                return null;\n            }\n            result.push(decodedChar);\n            lastStart = nextStart;\n            nextStart += counters.reduce((sum, item) => sum + item, 0);\n            nextStart = this._nextSet(this._row, nextStart);\n        } while (decodedChar !== '*');\n        result.pop();\n\n        if (!result.length) {\n            return null;\n        }\n\n        if (!this._verifyTrailingWhitespace(lastStart, nextStart, counters)) {\n            return null;\n        }\n\n        return {\n            code: result.join(''),\n            start: start.start,\n            end: nextStart,\n            startInfo: start,\n            decodedCodes: result\n        };\n    }\n\n    protected _patternToChar(pattern): string {\n        for (let i = 0; i < CHARACTER_ENCODINGS.length; i++) {\n            if (CHARACTER_ENCODINGS[i] === pattern) {\n                return String.fromCharCode(ALPHABET[i]);\n            }\n        }\n        return null;\n    }\n\n    private _verifyTrailingWhitespace(lastStart: number, nextStart: number, counters: Uint16Array): boolean {\n        const patternSize = counters.reduce((sum, item) => sum + item, 0);\n        const trailingWhitespaceEnd = nextStart - lastStart - patternSize;\n        return (trailingWhitespaceEnd * 3) >= patternSize;\n    }\n\n    private _findNextWidth(counters: Uint16Array, current: number): number {\n        let minWidth = Number.MAX_VALUE;\n\n        for (let i = 0; i < counters.length; i++) {\n            if (counters[i] < minWidth && counters[i] > current) {\n                minWidth = counters[i];\n            }\n        }\n\n        return minWidth;\n    }\n\n    private _toPattern(counters: Uint16Array): number {\n        const numCounters = counters.length;\n        let maxNarrowWidth = 0;\n        let numWideBars = numCounters;\n        let wideBarWidth = 0;\n        let pattern: number;\n\n        while (numWideBars > 3) {\n            maxNarrowWidth = this._findNextWidth(counters, maxNarrowWidth);\n            numWideBars = 0;\n            pattern = 0;\n            for (let i = 0; i < numCounters; i++) {\n                if (counters[i] > maxNarrowWidth) {\n                    pattern |= 1 << (numCounters - 1 - i);\n                    numWideBars++;\n                    wideBarWidth += counters[i];\n                }\n            }\n\n            if (numWideBars === 3) {\n                for (let i = 0; i < numCounters && numWideBars > 0; i++) {\n                    if (counters[i] > maxNarrowWidth) {\n                        numWideBars--;\n                        if ((counters[i] * 2) >= wideBarWidth) {\n                            return -1;\n                        }\n                    }\n                }\n                return pattern;\n            }\n        }\n        return -1;\n    }\n\n    protected _findStart(): BarcodeInfo {\n        const offset = this._nextSet(this._row);\n        let patternStart = offset;\n        const counter = new Uint16Array(9);\n        let counterPos = 0;\n        let isWhite: 0 | 1 = 0;\n        let whiteSpaceMustStart: number;\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    // find start pattern\n                    if (this._toPattern(counter) === ASTERISK) {\n                        whiteSpaceMustStart = Math.max(0, patternStart - ((i - patternStart) / 4)) | 0;\n                        if (this._matchRange(whiteSpaceMustStart, patternStart, 0)) {\n                            return {\n                                start: patternStart,\n                                end: i\n                            };\n                        }\n                    }\n\n                    patternStart += counter[0] + counter[1];\n                    for (let j = 0; j < 7; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[7] = 0;\n                    counter[8] = 0;\n                    counterPos--;\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n}\n","import { Barcode } from './barcode-reader';\nimport { Code39Reader } from './code-39-reader';\n\nexport class Code39VINReader extends Code39Reader {\n    constructor() {\n        super();\n\n        this._format = 'code_39_vin';\n    }\n\n    /**\n     * @borrows\n     * https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/client/result/VINResultParser.java\n     */\n    decode(): Barcode {\n        const result = super.decode();\n        if (!result) {\n            return null;\n        }\n\n        let code = result.code;\n\n        if (!code) {\n            return null;\n        }\n\n        code = code.replace(/[IOQ]/g, '');\n\n        if (!/[A-Z0-9]{17}/.test(code)) {\n            if (process.env.NODE_ENV !== 'production') {\n                console.log('Failed AZ09 pattern code:', code);\n            }\n            return null;\n        }\n\n        if (!this._checkChecksum(code)) {\n            return null;\n        }\n\n        result.code = code;\n        return result;\n    }\n\n    private _checkChecksum(code: string): boolean {\n        // TODO\n        return !!code;\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader } from './barcode-reader';\n\nconst ALPHABETH_STRING = '0123456789-$:/.+ABCD';\nconst ALPHABET = [...ALPHABETH_STRING].map(char => char.charCodeAt(0));\n// const ALPHABET = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 36, 58, 47, 46, 43, 65, 66, 67, 68];\nconst CHARACTER_ENCODINGS = [0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, 0x00c, 0x018, 0x045,\n    0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E];\nconst START_END = [0x01A, 0x029, 0x00B, 0x00E];\nconst MIN_ENCODED_CHARS = 4;\nconst MAX_ACCEPTABLE = 2.0;\nconst PADDING = 1.5;\n\ninterface Threshold {\n    space: {\n        narrow: {\n            size: number;\n            counts: number;\n            min: number;\n            max: number;\n        };\n        wide: {\n            size: number;\n            counts: number;\n            min: number;\n            max: number;\n        };\n    };\n    bar: {\n        narrow: {\n            size: number;\n            counts: number;\n            min: number;\n            max: number;\n        };\n        wide: {\n            size: number;\n            counts: number;\n            min: number;\n            max: number;\n        };\n    };\n}\n\nexport class CodabarReader extends BarcodeReader {\n    private _counters: Array<number>;\n\n    constructor() {\n        super();\n\n        this._format = 'codabar';\n        this._counters = [];\n    }\n\n    decode(): Barcode {\n        this._counters = this._fillCounters(this._nextUnset(this._row), this._row.length, 1);\n\n        const start = this._findStart();\n        if (!start) {\n            return null;\n        }\n\n        const result = new Array<string>();\n        let nextStart = start.startCounter;\n        let pattern: number;\n\n        do {\n            pattern = this._toPattern(nextStart);\n            if (pattern < 0) {\n                return null;\n            }\n            const decodedChar = this._patternToChar(pattern);\n            if (decodedChar === null) {\n                return null;\n            }\n            result.push(decodedChar);\n            nextStart += 8;\n            if (result.length > 1 && START_END.some(code => code === pattern)) {\n                break;\n            }\n        } while (nextStart < this._counters.length);\n\n        // verify end\n        if ((result.length - 2) < MIN_ENCODED_CHARS || !START_END.some(code => code === pattern)) {\n            return null;\n        }\n\n        // verify end white space\n        if (!this._verifyWhitespace(start.startCounter, nextStart - 8)) {\n            return null;\n        }\n\n        if (!this._validateResult(result, start.startCounter)) {\n            return null;\n        }\n\n        nextStart = nextStart > this._counters.length ? this._counters.length : nextStart;\n        const end = start.start + this._sumCounters(start.startCounter, nextStart - 8);\n\n        return {\n            code: result.join(''),\n            start: start.start,\n            end,\n            startInfo: start,\n            decodedCodes: result\n        };\n    }\n\n    protected _verifyWhitespace(startCounter: number, endCounter: number): boolean {\n        if ((startCounter - 1 <= 0)\n            || this._counters[startCounter - 1] >= (this._calculatePatternLength(startCounter) / 2.0)) {\n            if ((endCounter + 8 >= this._counters.length)\n                || this._counters[endCounter + 7] >= (this._calculatePatternLength(endCounter) / 2.0)) {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n    private _calculatePatternLength(offset: number): number {\n        let sum = 0;\n\n        for (let i = offset; i < offset + 7; i++) {\n            sum += this._counters[i];\n        }\n\n        return sum;\n    }\n\n    private _thresholdResultPattern(result: ReadonlyArray<string>, startCounter: number): Threshold {\n        const categorization: Threshold = {\n            space: {\n                narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE },\n                wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE }\n            },\n            bar: {\n                narrow: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE },\n                wide: { size: 0, counts: 0, min: 0, max: Number.MAX_VALUE }\n            }\n        };\n        let pos = startCounter;\n\n        for (let i = 0; i < result.length; i++) {\n            let pattern = this._charToPattern(result[i]);\n\n            for (let j = 6; j >= 0; j--) {\n                const kind = (j & 1) === 2 ? categorization.bar : categorization.space;\n                const cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;\n                cat.size += this._counters[pos + j];\n                cat.counts++;\n                pattern >>= 1;\n            }\n            pos += 8;\n        }\n\n        ['space', 'bar'].forEach(key => {\n            const kind = categorization[key];\n            kind.wide.min = Math.floor((kind.narrow.size / kind.narrow.counts + kind.wide.size / kind.wide.counts) / 2);\n            kind.narrow.max = Math.ceil(kind.wide.min);\n            kind.wide.max = Math.ceil((kind.wide.size * MAX_ACCEPTABLE + PADDING) / kind.wide.counts);\n        });\n\n        return categorization;\n    }\n\n    private _charToPattern(char: string): number {\n        const charCode = char.charCodeAt(0);\n\n        for (let i = 0; i < ALPHABET.length; i++) {\n            if (ALPHABET[i] === charCode) {\n                return CHARACTER_ENCODINGS[i];\n            }\n        }\n\n        return 0x0;\n    }\n\n    private _validateResult(result: ReadonlyArray<string>, startCounter: number): boolean {\n        const threshold = this._thresholdResultPattern(result, startCounter);\n        let pos = startCounter;\n\n        for (let i = 0; i < result.length; i++) {\n            let pattern = this._charToPattern(result[i]);\n\n            for (let j = 6; j >= 0; j--) {\n                const kind = (j & 1) === 0 ? threshold.bar : threshold.space;\n                const cat = (pattern & 1) === 1 ? kind.wide : kind.narrow;\n                const size = this._counters[pos + j];\n                if (size < cat.min || size > cat.max) {\n                    return false;\n                }\n                pattern >>= 1;\n            }\n            pos += 8;\n        }\n\n        return true;\n    }\n\n    private _patternToChar(pattern: number): string {\n        for (let i = 0; i < CHARACTER_ENCODINGS.length; i++) {\n            if (CHARACTER_ENCODINGS[i] === pattern) {\n                return String.fromCharCode(ALPHABET[i]);\n            }\n        }\n\n        return null;\n    }\n\n    private _computeAlternatingThreshold(offset: number, end: number): number {\n        let min = Number.MAX_VALUE;\n        let max = 0;\n\n        for (let i = offset; i < end; i += 2) {\n            const counter = this._counters[i];\n            if (counter > max) {\n                max = counter;\n            }\n            if (counter < min) {\n                min = counter;\n            }\n        }\n\n        return ((min + max) / 2.0) | 0;\n    }\n\n    private _toPattern(offset: number): number {\n        const numCounters = 7;\n        const end = offset + numCounters;\n\n        if (end > this._counters.length) {\n            return -1;\n        }\n\n        const barThreshold = this._computeAlternatingThreshold(offset, end);\n        const spaceThreshold = this._computeAlternatingThreshold(offset + 1, end);\n        let bitmask = 1 << (numCounters - 1);\n        let pattern = 0;\n\n        for (let i = 0; i < numCounters; i++) {\n            const threshold = (i & 1) === 0 ? barThreshold : spaceThreshold;\n            if (this._counters[offset + i] > threshold) {\n                pattern |= bitmask;\n            }\n            bitmask >>= 1;\n        }\n\n        return pattern;\n    }\n\n    private _sumCounters(start: number, end: number): number {\n        let sum = 0;\n\n        for (let i = start; i < end; i++) {\n            sum += this._counters[i];\n        }\n\n        return sum;\n    }\n\n    protected _findStart(): BarcodeInfo {\n        let start = this._nextUnset(this._row);\n\n        for (let i = 1; i < this._counters.length; i++) {\n            const pattern = this._toPattern(i);\n            if (pattern !== -1 && START_END.some(code => code === pattern)) {\n                // TODO: Look for whitespace ahead\n                start += this._sumCounters(0, i);\n                const end = start + this._sumCounters(i, i + 8);\n                return {\n                    start,\n                    end,\n                    startCounter: i,\n                    endCounter: i + 8\n                };\n            }\n        }\n\n        return null;\n    }\n}\n","import { merge } from '../common/merge';\nimport { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\n\nconst EXTENSION_START_PATTERN = [1, 1, 2];\nconst CODE_PATTERN = [\n    [3, 2, 1, 1],\n    [2, 2, 2, 1],\n    [2, 1, 2, 2],\n    [1, 4, 1, 1],\n    [1, 1, 3, 2],\n    [1, 2, 3, 1],\n    [1, 1, 1, 4],\n    [1, 3, 1, 2],\n    [1, 2, 1, 3],\n    [3, 1, 1, 2],\n    [1, 1, 2, 3],\n    [1, 2, 2, 2],\n    [2, 2, 1, 2],\n    [1, 1, 4, 1],\n    [2, 3, 1, 1],\n    [1, 3, 2, 1],\n    [4, 1, 1, 1],\n    [2, 1, 3, 1],\n    [3, 1, 2, 1],\n    [2, 1, 1, 3]\n];\nconst CODE_FREQUENCY = [0, 11, 13, 14, 19, 25, 28, 21, 22, 26];\n\nexport class EANReader extends BarcodeReader {\n    get CODE_L_START(): number {\n        return 0;\n    }\n\n    get CODE_G_START(): number {\n        return 10;\n    }\n\n    get START_PATTERN(): Array<number> {\n        return [1, 1, 1];\n    }\n\n    get STOP_PATTERN(): Array<number> {\n        return [1, 1, 1];\n    }\n\n    get MIDDLE_PATTERN(): Array<number> {\n        return [1, 1, 1, 1, 1];\n    }\n\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(merge({\n            supplements: [] // Allowed extensions to be decoded (2 and/or 5)\n        }, config), supplements);\n\n        this._format = 'ean_13';\n        this._singleCodeError = 0.70;\n        this._averageCodeError = 0.48;\n    }\n\n    protected _decodeCode(start: number, coderange?: number): BarcodeInfo {\n        const counter = [0, 0, 0, 0];\n        const offset = start;\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: start,\n            end: start\n        };\n        const epsilon = this.AVERAGE_CODE_ERROR;\n        let isWhite: 0 | 1 = this._row[offset] ? 0 : 1;\n        let counterPos = 0;\n\n        if (!coderange) {\n            coderange = CODE_PATTERN.length;\n        }\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    for (let code = 0; code < coderange; code++) {\n                        const error = this._matchPattern(counter, CODE_PATTERN[code]);\n                        if (error < bestMatch.error) {\n                            bestMatch.code = code;\n                            bestMatch.error = error;\n                        }\n                    }\n                    bestMatch.end = i;\n                    if (bestMatch.error > epsilon) {\n                        return null;\n                    }\n                    return bestMatch;\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n\n    protected _findStart(): BarcodeInfo {\n        let offset = this._nextSet(this._row);\n        let startInfo: BarcodeInfo;\n\n        while (!startInfo) {\n            startInfo = this._findPattern(this.START_PATTERN, offset, 0, true);\n\n            if (!startInfo) {\n                return null;\n            }\n\n            const leadingWhitespaceStart = startInfo.start - (startInfo.end - startInfo.start);\n\n            if (leadingWhitespaceStart >= 0) {\n                if (this._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                    return startInfo;\n                }\n            }\n\n            offset = startInfo.end;\n            startInfo = null;\n        }\n\n        return null;\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start);\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n\n    protected _findEnd(offset: number, isWhite: 0 | 1): BarcodeInfo {\n        const endInfo = this._findPattern(this.STOP_PATTERN, offset, isWhite, false);\n\n        return endInfo !== null ? this._verifyTrailingWhitespace(endInfo) : null;\n    }\n\n    private _calculateFirstDigit(codeFrequency: number): number | null {\n        for (let i = 0; i < CODE_FREQUENCY.length; i++) {\n            if (codeFrequency === CODE_FREQUENCY[i]) {\n                return i;\n            }\n        }\n        return null;\n    }\n\n    protected _decodePayload(code: BarcodeInfo, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo {\n        let codeFrequency = 0x0;\n\n        for (let i = 0; i < 6; i++) {\n            code = this._decodeCode(code.end);\n            if (!code) {\n                return null;\n            }\n            if (code.code >= this.CODE_G_START) {\n                code.code -= this.CODE_G_START;\n                codeFrequency |= 1 << (5 - i);\n            } else {\n                codeFrequency |= 0 << (5 - i);\n            }\n            result.push(code.code);\n            decodedCodes.push(code);\n        }\n\n        const firstDigit = this._calculateFirstDigit(codeFrequency);\n\n        if (firstDigit === null) {\n            return null;\n        }\n\n        result.unshift(firstDigit);\n\n        code = this._findPattern(this.MIDDLE_PATTERN, code.end, 1, false);\n\n        if (code === null) {\n            return null;\n        }\n\n        decodedCodes.push(code);\n\n        for (let i = 0; i < 6; i++) {\n            code = this._decodeCode(code.end, this.CODE_G_START);\n\n            if (!code) {\n                return null;\n            }\n\n            decodedCodes.push(code);\n            result.push(code.code);\n        }\n\n        return code;\n    }\n\n    decode(): Barcode {\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n        let resultInfo: Barcode = {};\n        let startInfo = this._findStart();\n\n        if (!startInfo) {\n            return null;\n        }\n\n        let code: BarcodeInfo = {\n            code: startInfo.code,\n            start: startInfo.start,\n            end: startInfo.end\n        };\n        decodedCodes.push(code);\n\n        code = this._decodePayload(code, result, decodedCodes);\n\n        if (!code) {\n            return null;\n        }\n\n        code = this._findEnd(code.end, 0);\n\n        if (!code) {\n            return null;\n        }\n\n        decodedCodes.push(code);\n\n        // Checksum\n        if (!this._checksum(result)) {\n            return null;\n        }\n\n        if (this.supplements.length > 0) {\n            const supplement = this._decodeExtensions(code.end);\n            if (!supplement) {\n                return null;\n            }\n\n            const lastCode = supplement.decodedCodes[supplement.decodedCodes.length - 1] as BarcodeInfo;\n            const endInfo = {\n                start: lastCode.start + (((lastCode.end - lastCode.start) / 2) | 0),\n                end: lastCode.end\n            };\n\n            if (!this._verifyTrailingWhitespace(endInfo)) {\n                return null;\n            }\n\n            resultInfo = {\n                supplement,\n                code: result.join('') + supplement.code\n            };\n        }\n\n        return {\n            code: result.join(''),\n            start: startInfo.start,\n            end: code.end,\n            startInfo,\n            decodedCodes,\n            ...resultInfo\n        };\n    }\n\n    private _decodeExtensions(offset: number): Barcode {\n        const start = this._nextSet(this._row, offset);\n        const startInfo = this._findPattern(EXTENSION_START_PATTERN, start, 0, false);\n\n        if (startInfo === null) {\n            return null;\n        }\n\n        for (let i = 0; i < this.supplements.length; i++) {\n            let result = this.supplements[i].decode(this._row, startInfo.end);\n            if (result !== null) {\n                return {\n                    code: result.code,\n                    start,\n                    startInfo,\n                    end: result.end,\n                    decodedCodes: result.decodedCodes\n                };\n            }\n        }\n\n        return null;\n    }\n\n    protected _checksum(result: Array<number>): boolean {\n        let sum = 0;\n\n        for (let i = result.length - 2; i >= 0; i -= 2) {\n            sum += result[i];\n        }\n\n        sum *= 3;\n\n        for (let i = result.length - 1; i >= 0; i -= 2) {\n            sum += result[i];\n        }\n\n        return sum % 10 === 0;\n    }\n}","import { Point } from '../common/point';\nimport { ImageWrapper } from '../common/image-wrapper';\n\nenum Slope {\n    Up = 1,\n    Down = -1\n};\n\nexport interface BarcodeLine {\n    line: Array<number>;\n    max?: number;\n    min?: number;\n    threshold?: number;\n}\n\nexport const Bresenham = {\n    /**\n     * Scans a line of the given image from point p1 to p2 and returns a result object containing\n     * gray-scale values (0-255) of the underlying pixels in addition to the min and max values.\n     * @param imageWrapper\n     * @param p1 The start point {x,y}\n     * @param p2 The end point {x,y}\n     * @returns {line, min, max}\n     */\n    getBarcodeLine(imageWrapper: ImageWrapper, p1: Point, p2: Point): BarcodeLine {\n        let x0 = p1.x | 0;\n        let y0 = p1.y | 0;\n        let x1 = p2.x | 0;\n        let y1 = p2.y | 0;\n        const steep = Math.abs(y1 - y0) > Math.abs(x1 - x0);\n        let tmp: number;\n        const line = [];\n        const imageData = imageWrapper.data;\n        const width = imageWrapper.size.x;\n        let val: number;\n        let min = 255;\n        let max = 0;\n\n        function read(a: number, b: number) {\n            val = imageData[b * width + a];\n            min = val < min ? val : min;\n            max = val > max ? val : max;\n            line.push(val);\n        }\n\n        if (steep) {\n            tmp = x0;\n            x0 = y0;\n            y0 = tmp;\n\n            tmp = x1;\n            x1 = y1;\n            y1 = tmp;\n        }\n        if (x0 > x1) {\n            tmp = x0;\n            x0 = x1;\n            x1 = tmp;\n\n            tmp = y0;\n            y0 = y1;\n            y1 = tmp;\n        }\n\n        let deltax = x1 - x0;\n        let deltay = Math.abs(y1 - y0);\n        let error = (deltax / 2) | 0;\n        let y = y0;\n        let ystep = y0 < y1 ? 1 : -1;\n\n        for (let x = x0; x < x1; x++) {\n            if (steep) {\n                read(y, x);\n            } else {\n                read(x, y);\n            }\n            error = error - deltay;\n            if (error < 0) {\n                y += ystep;\n                error = error + deltax;\n            }\n        }\n\n        return {\n            line,\n            min,\n            max\n        };\n    },\n\n    /**\n     * Converts the result from getBarcodeLine into a binary representation\n     * also considering the frequency and slope of the signal for more robust results\n     * @param result {line, min, max}\n     */\n    toBinaryLine(result: BarcodeLine): BarcodeLine {\n        const min = result.min;\n        const max = result.max;\n        const line = result.line;\n        const center = min + (max - min) / 2;\n        const extrema = new Array<{ pos: number; val: number; }>();\n        let threshold = (max - min) / 12;\n        const rThreshold = -threshold;\n\n        // 1. find extrema\n        let currentDir = line[0] > center ? Slope.Up : Slope.Down;\n        extrema.push({\n            pos: 0,\n            val: line[0]\n        });\n        for (let i = 0; i < line.length - 2; i++) {\n            const slope = (line[i + 1] - line[i]);\n            const slope2 = (line[i + 2] - line[i + 1]);\n            let dir: Slope;\n            if ((slope + slope2) < rThreshold && line[i + 1] < (center * 1.5)) {\n                dir = Slope.Down;\n            } else if ((slope + slope2) > threshold && line[i + 1] > (center * 0.5)) {\n                dir = Slope.Up;\n            } else {\n                dir = currentDir;\n            }\n\n            if (currentDir !== dir) {\n                extrema.push({\n                    pos: i,\n                    val: line[i]\n                });\n                currentDir = dir;\n            }\n        }\n        extrema.push({\n            pos: line.length,\n            val: line[line.length - 1]\n        });\n\n        for (let j = extrema[0].pos; j < extrema[1].pos; j++) {\n            line[j] = line[j] > center ? 0 : 1;\n        }\n\n        // iterate over extrema and convert to binary based on avg between minmax\n        for (let i = 1; i < extrema.length - 1; i++) {\n            if (extrema[i + 1].val > extrema[i].val) {\n                threshold = (extrema[i].val + ((extrema[i + 1].val - extrema[i].val) / 3) * 2) | 0;\n            } else {\n                threshold = (extrema[i + 1].val + ((extrema[i].val - extrema[i + 1].val) / 3)) | 0;\n            }\n\n            for (let j = extrema[i].pos; j < extrema[i + 1].pos; j++) {\n                line[j] = line[j] > threshold ? 0 : 1;\n            }\n        }\n\n        return {\n            ...result,\n            threshold\n        };\n    }\n};\n","import { BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nexport class EAN8Reader extends EANReader {\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'ean_8';\n    }\n\n    protected _decodePayload(code: BarcodeInfo, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo {\n        for (let i = 0; i < 4; i++) {\n            code = this._decodeCode(code.end, this.CODE_G_START);\n            if (!code) {\n                return null;\n            }\n            result.push(code.code);\n            decodedCodes.push(code);\n        }\n\n        code = this._findPattern(this.MIDDLE_PATTERN, code.end, 1, false);\n\n        if (code === null) {\n            return null;\n        }\n\n        decodedCodes.push(code);\n\n        for (let i = 0; i < 4; i++) {\n            code = this._decodeCode(code.end, this.CODE_G_START);\n\n            if (!code) {\n                return null;\n            }\n\n            decodedCodes.push(code);\n            result.push(code.code);\n        }\n\n        return code;\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nexport class EAN2Reader extends EANReader {\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'ean_2';\n    }\n\n    decode(row?: Array<number>, start?: number): Barcode {\n        const end = row.length;\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n        let offset = start;\n        let codeFrequency = 0;\n        let code: BarcodeInfo;\n\n        this._row = row;\n\n        for (let i = 0; i < 2 && offset < end; i++) {\n            code = this._decodeCode(offset);\n            if (!code) {\n                return null;\n            }\n            decodedCodes.push(code);\n            result.push(code.code % 10);\n            if (code.code >= this.CODE_G_START) {\n                codeFrequency |= 1 << (1 - i);\n            }\n            if (i !== 1) {\n                offset = this._nextSet(this._row, code.end);\n                offset = this._nextUnset(this._row, offset);\n            }\n        }\n\n        if (result.length !== 2 || (parseInt(result.join('')) % 4) !== codeFrequency) {\n            return null;\n        }\n\n        return {\n            code: result.join(''),\n            decodedCodes,\n            end: code.end\n        };\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nexport class EAN5Reader extends EANReader {\n    get CHECK_DIGIT_ENCODINGS(): Array<number> {\n        return [24, 20, 18, 17, 12, 6, 3, 10, 9, 5];\n    }\n\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'ean_5';\n    }\n\n    decode(row?: Array<number>, start?: number): Barcode {\n        const end = row.length;\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n        let codeFrequency = 0;\n        let offset = start;\n        let code: BarcodeInfo;\n\n        this._row = row;\n\n        for (let i = 0; i < 5 && offset < end; i++) {\n            code = this._decodeCode(offset);\n            if (!code) {\n                return null;\n            }\n            decodedCodes.push(code);\n            result.push(code.code % 10);\n            if (code.code >= this.CODE_G_START) {\n                codeFrequency |= 1 << (4 - i);\n            }\n            if (i !== 4) {\n                offset = this._nextSet(this._row, code.end);\n                offset = this._nextUnset(this._row, offset);\n            }\n        }\n\n        if (result.length !== 5) {\n            return null;\n        }\n\n        if (this._extensionChecksum(result) !== this._determineCheckDigit(codeFrequency)) {\n            return null;\n        }\n\n        return {\n            code: result.join(''),\n            decodedCodes,\n            end: code.end\n        };\n    }\n\n    private _determineCheckDigit(codeFrequency: number): number | null {\n        for (let i = 0; i < 10; i++) {\n            if (codeFrequency === this.CHECK_DIGIT_ENCODINGS[i]) {\n                return i;\n            }\n        }\n        return null;\n    }\n\n    private _extensionChecksum(result: Array<number>): number {\n        let length = result.length;\n        let sum = 0;\n\n        for (let i = length - 2; i >= 0; i -= 2) {\n            sum += result[i];\n        }\n        sum *= 3;\n        for (let i = length - 1; i >= 0; i -= 2) {\n            sum += result[i];\n        }\n        sum *= 3;\n\n        return sum % 10;\n    }\n}\n","import { Barcode, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nexport class UPCReader extends EANReader {\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'upc_a';\n    }\n\n    decode(): Barcode {\n        const result = super.decode();\n\n        if (result && result.code && result.code.length === 13 && result.code.charAt(0) === '0') {\n            result.code = result.code.substring(1);\n            return result;\n        }\n\n        return null;\n    }\n}","import { BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\nimport { EANReader } from './ean-reader';\n\nconst CODE_FREQUENCY = [[56, 52, 50, 49, 44, 38, 35, 42, 41, 37], [7, 11, 13, 14, 19, 25, 28, 21, 22, 26]];\n\nexport class UPCEReader extends EANReader {\n    get STOP_PATTERN() {\n        return [1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7, 1 / 6 * 7];\n    }\n\n    constructor(config?: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {\n        super(config, supplements);\n\n        this._format = 'upc_e';\n    }\n\n    protected _decodePayload(code: BarcodeInfo, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo {\n        let codeFrequency = 0x0;\n\n        for (let i = 0; i < 6; i++) {\n            code = this._decodeCode(code.end);\n            if (!code) {\n                return null;\n            }\n            if (code.code >= this.CODE_G_START) {\n                code.code = code.code - this.CODE_G_START;\n                codeFrequency |= 1 << (5 - i);\n            }\n            result.push(code.code);\n            decodedCodes.push(code);\n        }\n\n        if (!this._determineParity(codeFrequency, result)) {\n            return null;\n        }\n\n        return code;\n    }\n\n    private _determineParity(codeFrequency: number, result: Array<number>): boolean {\n        for (let nrSystem = 0; nrSystem < CODE_FREQUENCY.length; nrSystem++) {\n            for (let i = 0; i < CODE_FREQUENCY[nrSystem].length; i++) {\n                if (codeFrequency === CODE_FREQUENCY[nrSystem][i]) {\n                    result.unshift(nrSystem);\n                    result.push(i);\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n\n    private _convertToUPCA(result: Array<number>): Array<number> {\n        const lastDigit = result[result.length - 2];\n        let upca = [result[0]];\n\n        if (lastDigit <= 2) {\n            upca = upca.concat(result.slice(1, 3)).concat([lastDigit, 0, 0, 0, 0]).concat(result.slice(3, 6));\n        } else if (lastDigit === 3) {\n            upca = upca.concat(result.slice(1, 4)).concat([0, 0, 0, 0, 0]).concat(result.slice(4, 6));\n        } else if (lastDigit === 4) {\n            upca = upca.concat(result.slice(1, 5)).concat([0, 0, 0, 0, 0, result[5]]);\n        } else {\n            upca = upca.concat(result.slice(1, 6)).concat([0, 0, 0, 0, lastDigit]);\n        }\n\n        upca.push(result[result.length - 1]);\n        return upca;\n    }\n\n    protected _checksum(result: Array<number>): boolean {\n        return super._checksum(this._convertToUPCA(result));\n    }\n\n    protected _findEnd(offset: number, isWhite: 0 | 1) {\n        isWhite = 1;\n        return super._findEnd(offset, isWhite);\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n}","import { merge } from '../common/merge';\nimport { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\n\nconst N = 1;\nconst W = 3;\nconst START_PATTERN = [N, N, N, N];\nconst STOP_PATTERN = [N, N, W];\nconst CODE_PATTERN = [\n    [N, N, W, W, N],\n    [W, N, N, N, W],\n    [N, W, N, N, W],\n    [W, W, N, N, N],\n    [N, N, W, N, W],\n    [W, N, W, N, N],\n    [N, W, W, N, N],\n    [N, N, N, W, W],\n    [W, N, N, W, N],\n    [N, W, N, W, N]\n];\nconst MAX_CORRECTION_FACTOR = 5;\n\nexport class I2of5Reader extends BarcodeReader {\n    private _barSpaceRatio: [number, number];\n\n    constructor(config?: BarcodeReaderConfig) {\n        super(merge({\n            normalizeBarSpaceWidth: false // Normalize the width difference between bars and spaces\n        }, config));\n\n        this._barSpaceRatio = [1, 1];\n        this._format = 'i2of5';\n\n        if (this.config.normalizeBarSpaceWidth) {\n            this._singleCodeError = 0.38;\n            this._averageCodeError = 0.09;\n        } else {\n            this._singleCodeError = 0.78;\n            this._averageCodeError = 0.38;\n        }\n    }\n\n    decode(): Barcode {\n        const startInfo = this._findStart();\n\n        if (!startInfo) {\n            return null;\n        }\n\n        const endInfo = this._findEnd();\n\n        if (!endInfo) {\n            return null;\n        }\n\n        const counters = this._fillCounters(startInfo.end, endInfo.start, 0);\n\n        if (counters.length % 10 !== 0) {\n            return null;\n        }\n\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n\n        decodedCodes.push(startInfo);\n\n        const code = this._decodePayload(counters, result, decodedCodes);\n\n        if (!code || result.length % 2 !== 0 || result.length < 6) {\n            return null;\n        }\n\n        decodedCodes.push(endInfo);\n\n        return {\n            code: result.join(''),\n            start: startInfo.start,\n            end: endInfo.end,\n            startInfo,\n            decodedCodes\n        };\n    }\n\n    protected _matchPattern(counter: Array<number>, code: ReadonlyArray<number>): number {\n        if (this.config.normalizeBarSpaceWidth) {\n            const counterSum: [number, number] = [0, 0];\n            const codeSum: [number, number] = [0, 0];\n            const correction: [number, number] = [0, 0];\n            const correctionRatio = MAX_CORRECTION_FACTOR;\n            const correctionRatioInverse = 1 / correctionRatio;\n\n            for (let i = 0; i < counter.length; i++) {\n                counterSum[i % 2] += counter[i];\n                codeSum[i % 2] += code[i];\n            }\n\n            correction[0] = codeSum[0] / counterSum[0];\n            correction[1] = codeSum[1] / counterSum[1];\n\n            correction[0] = Math.max(Math.min(correction[0], correctionRatio), correctionRatioInverse);\n            correction[1] = Math.max(Math.min(correction[1], correctionRatio), correctionRatioInverse);\n            this._barSpaceRatio = correction;\n\n            for (let i = 0; i < counter.length; i++) {\n                counter[i] *= this._barSpaceRatio[i % 2];\n            }\n        }\n\n        return super._matchPattern(counter, code);\n    }\n\n    protected _findStart(): BarcodeInfo {\n        let offset = this._nextSet(this._row);\n        let startInfo: BarcodeInfo;\n\n        while (!startInfo) {\n            startInfo = this._findPattern(START_PATTERN, offset, 0, true);\n            if (!startInfo) {\n                return null;\n            }\n\n            const narrowBarWidth = (startInfo.end - startInfo.start) >> 2;\n            const leadingWhitespaceStart = startInfo.start - narrowBarWidth * 10;\n\n            if (leadingWhitespaceStart >= 0) {\n                if (this._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                    return startInfo;\n                }\n            }\n\n            offset = startInfo.end;\n            startInfo = null;\n        }\n\n        return null;\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n\n    protected _findEnd(): BarcodeInfo {\n        this._row.reverse();\n\n        const endInfo = this._findPattern(STOP_PATTERN, undefined, 0, false);\n\n        this._row.reverse();\n\n        if (endInfo === null) {\n            return null;\n        }\n\n        // reverse numbers\n        const start = endInfo.start;\n        endInfo.start = this._row.length - endInfo.end;\n        endInfo.end = this._row.length - start;\n\n        return endInfo !== null ? this._verifyTrailingWhitespace(endInfo) : null;\n    }\n\n    protected _decodeCode(counter: Array<number>): BarcodeInfo {\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        };\n\n        for (let code = 0; code < CODE_PATTERN.length; code++) {\n            const error = this._matchPattern(counter, CODE_PATTERN[code]);\n            if (error < bestMatch.error) {\n                bestMatch.code = code;\n                bestMatch.error = error;\n            }\n        }\n\n        return bestMatch.error < this.AVERAGE_CODE_ERROR ? bestMatch : null;\n    }\n\n    protected _decodePayload(counters: ReadonlyArray<number>, result: Array<number>, decodedCodes: Array<BarcodeInfo>): [BarcodeInfo, BarcodeInfo] {\n        const counterLength = counters.length;\n        const counter0 = [0, 0, 0, 0, 0];\n        const counter1 = [0, 0, 0, 0, 0];\n        let code0: BarcodeInfo;\n        let code1: BarcodeInfo;\n        let pos = 0;\n\n        while (pos < counterLength) {\n            for (let i = 0; i < 5; i++) {\n                counter0[i] = counters[pos] * this._barSpaceRatio[0];\n                counter1[i] = counters[pos + 1] * this._barSpaceRatio[1];\n                pos += 2;\n            }\n\n            code0 = this._decodeCode(counter0);\n            if (!code0) {\n                return null;\n            }\n\n            code1 = this._decodeCode(counter1);\n            if (!code1) {\n                return null;\n            }\n\n            result.push(code0.code, code1.code);\n            decodedCodes.push(code0, code1);\n        }\n\n        return [code0, code1];\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader, BarcodeReaderConfig } from './barcode-reader';\n\nconst N = 1;\nconst W = 3;\nconst START_PATTERN = [W, N, W, N, N, N];\nconst STOP_PATTERN = [W, N, N, N, W];\nconst CODE_PATTERN = [\n    [N, N, W, W, N],\n    [W, N, N, N, W],\n    [N, W, N, N, W],\n    [W, W, N, N, N],\n    [N, N, W, N, W],\n    [W, N, W, N, N],\n    [N, W, W, N, N],\n    [N, N, N, W, W],\n    [W, N, N, W, N],\n    [N, W, N, W, N]\n];\nconst startPatternLength = START_PATTERN.reduce((sum, val) => sum + val, 0);\n\nexport class TwoOfFiveReader extends BarcodeReader {\n    private _barSpaceRatio: [number, number];\n\n    constructor(config?: BarcodeReaderConfig) {\n        super(config);\n\n        this._barSpaceRatio = [1, 1];\n        this._format = '2of5';\n        this._singleCodeError = 0.78;\n        this._averageCodeError = 0.30;\n    }\n\n    decode(): Barcode {\n        const startInfo = this._findStart();\n\n        if (!startInfo) {\n            return null;\n        }\n\n        const endInfo = this._findEnd();\n\n        if (!endInfo) {\n            return null;\n        }\n\n        const counters = this._fillCounters(startInfo.end, endInfo.start, 0);\n\n        if (counters.length % 10 !== 0) {\n            return null;\n        }\n\n        const result = new Array<number>();\n        const decodedCodes = new Array<BarcodeInfo>();\n\n        decodedCodes.push(startInfo);\n\n        const code = this._decodePayload(counters, result, decodedCodes);\n\n        if (!code || result.length < 5) {\n            return null;\n        }\n\n        decodedCodes.push(endInfo);\n\n        return {\n            code: result.join(''),\n            start: startInfo.start,\n            end: endInfo.end,\n            startInfo,\n            decodedCodes\n        };\n    }\n\n    protected _findStart(): BarcodeInfo {\n        let offset = this._nextSet(this._row);\n        let narrowBarWidth = 1;\n        let startInfo: BarcodeInfo;\n\n        while (!startInfo) {\n            startInfo = this._findPattern(START_PATTERN, offset, 0, true);\n\n            if (!startInfo) {\n                return null;\n            }\n\n            narrowBarWidth = (startInfo.end - startInfo.start) / startPatternLength | 0;\n            const leadingWhitespaceStart = startInfo.start - narrowBarWidth * 5;\n\n            if (leadingWhitespaceStart >= 0) {\n                if (this._matchRange(leadingWhitespaceStart, startInfo.start, 0)) {\n                    return startInfo;\n                }\n            }\n\n            offset = startInfo.end;\n            startInfo = null;\n        }\n\n        return null;\n    }\n\n    protected _verifyTrailingWhitespace(endInfo: BarcodeInfo): BarcodeInfo {\n        const trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start) / 2;\n\n        if (trailingWhitespaceEnd < this._row.length) {\n            if (this._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) {\n                return endInfo;\n            }\n        }\n\n        return null;\n    }\n\n    protected _findEnd(): BarcodeInfo {\n        this._row.reverse();\n\n        const offset = this._nextSet(this._row);\n        const endInfo = this._findPattern(STOP_PATTERN, offset, 0, true);\n\n        this._row.reverse();\n\n        if (endInfo === null) {\n            return null;\n        }\n\n        // reverse numbers\n        const start = endInfo.start;\n        endInfo.start = this._row.length - endInfo.end;\n        endInfo.end = this._row.length - start;\n\n        return endInfo !== null ? this._verifyTrailingWhitespace(endInfo) : null;\n    }\n\n    protected _decodeCode(counter: ReadonlyArray<number>): BarcodeInfo {\n        const bestMatch: BarcodeInfo = {\n            error: Number.MAX_VALUE,\n            code: -1,\n            start: 0,\n            end: 0\n        };\n\n        for (let code = 0; code < CODE_PATTERN.length; code++) {\n            const error = this._matchPattern(counter, CODE_PATTERN[code]);\n            if (error < bestMatch.error) {\n                bestMatch.code = code;\n                bestMatch.error = error;\n            }\n        }\n\n        return bestMatch.error < this.AVERAGE_CODE_ERROR ? bestMatch : null;\n    }\n\n    protected _decodePayload(counters: ReadonlyArray<number>, result: Array<number>, decodedCodes: Array<BarcodeInfo>): BarcodeInfo {\n        const counterLength = counters.length;\n        const counter = [0, 0, 0, 0, 0];\n        let pos = 0;\n        let code: BarcodeInfo;\n\n        while (pos < counterLength) {\n            for (let i = 0; i < 5; i++) {\n                counter[i] = counters[pos] * this._barSpaceRatio[0];\n                pos += 2;\n            }\n\n            code = this._decodeCode(counter);\n\n            if (!code) {\n                return null;\n            }\n\n            result.push(code.code);\n            decodedCodes.push(code);\n        }\n\n        return code;\n    }\n}\n","import { Barcode, BarcodeInfo, BarcodeReader } from './barcode-reader';\n\nconst ALPHABETH_STRING = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*';\nconst ALPHABET = new Uint16Array([...ALPHABETH_STRING].map(char => char.charCodeAt(0)));\nconst CHARACTER_ENCODINGS = new Uint16Array([\n    0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, 0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A,\n    0x168, 0x164, 0x162, 0x134, 0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, 0x196, 0x19A,\n    0x16C, 0x166, 0x136, 0x13A, 0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, 0x126, 0x1DA, 0x1D6, 0x132, 0x15E\n]);\nconst ASTERISK = 0x15E;\n\nexport class Code93Reader extends BarcodeReader {\n    constructor() {\n        super();\n\n        this._format = 'code_93';\n    }\n\n    decode(): Barcode {\n        const start = this._findStart();\n\n        if (!start) {\n            return null;\n        }\n\n        let result = new Array<string>();\n        let counters = new Uint16Array(6);\n        let decodedChar: string;\n        let lastStart: number;\n        let nextStart = this._nextSet(this._row, start.end);\n\n        do {\n            this._toCounters(nextStart, counters);\n            const pattern = this._toPattern(counters);\n            if (pattern < 0) {\n                return null;\n            }\n            decodedChar = this._patternToChar(pattern);\n            if (decodedChar === null) {\n                return null;\n            }\n            result.push(decodedChar);\n            lastStart = nextStart;\n            nextStart += counters.reduce((sum, item) => sum + item, 0);\n            nextStart = this._nextSet(this._row, nextStart);\n        } while (decodedChar !== '*');\n        result.pop();\n\n        if (!result.length) {\n            return null;\n        }\n\n        if (!this._verifyEnd(lastStart, nextStart)) {\n            return null;\n        }\n\n        if (!this._verifyChecksums(result)) {\n            return null;\n        }\n\n        result = result.slice(0, result.length - 2);\n        if ((result = this._decodeExtended(result)) === null) {\n            return null;\n        }\n\n        return {\n            code: result.join(''),\n            start: start.start,\n            end: nextStart,\n            startInfo: start,\n            decodedCodes: result\n        };\n    }\n\n    protected _patternToChar(pattern: number): string {\n        for (let i = 0; i < CHARACTER_ENCODINGS.length; i++) {\n            if (CHARACTER_ENCODINGS[i] === pattern) {\n                return String.fromCharCode(ALPHABET[i]);\n            }\n        }\n        return null;\n    }\n\n    private _verifyEnd(lastStart: number, nextStart: number): boolean {\n        if (lastStart === nextStart || !this._row[nextStart]) {\n            return false;\n        }\n        return true;\n    }\n\n    private _toPattern(counters: Uint16Array): number {\n        const numCounters = counters.length;\n        let pattern = 0;\n        let sum = 0;\n        for (let i = 0; i < numCounters; i++) {\n            sum += counters[i];\n        }\n\n        for (let i = 0; i < numCounters; i++) {\n            let normalized = Math.round(counters[i] * 9 / sum);\n            if (normalized < 1 || normalized > 4) {\n                return -1;\n            }\n            if ((i & 1) === 0) {\n                for (let j = 0; j < normalized; j++) {\n                    pattern = (pattern << 1) | 1;\n                }\n            } else {\n                pattern <<= normalized;\n            }\n        }\n\n        return pattern;\n    }\n\n    private _findStart(): BarcodeInfo {\n        const counter = new Uint16Array(6);\n        const offset = this._nextSet(this._row);\n        let patternStart = offset;\n        let counterPos = 0;\n        let isWhite: 0 | 1 = 0;\n        let whiteSpaceMustStart: number;\n\n        for (let i = offset; i < this._row.length; i++) {\n            if (this._row[i] ^ isWhite) {\n                counter[counterPos]++;\n            } else {\n                if (counterPos === counter.length - 1) {\n                    // find start pattern\n                    if (this._toPattern(counter) === ASTERISK) {\n                        whiteSpaceMustStart = Math.max(0, patternStart - ((i - patternStart) / 4)) | 0;\n                        if (this._matchRange(whiteSpaceMustStart, patternStart, 0)) {\n                            return {\n                                start: patternStart,\n                                end: i\n                            };\n                        }\n                    }\n\n                    patternStart += counter[0] + counter[1];\n                    for (let j = 0; j < 4; j++) {\n                        counter[j] = counter[j + 2];\n                    }\n                    counter[4] = 0;\n                    counter[5] = 0;\n                    counterPos--;\n                } else {\n                    counterPos++;\n                }\n                counter[counterPos] = 1;\n                isWhite = isWhite ? 0 : 1;\n            }\n        }\n\n        return null;\n    }\n\n    private _decodeExtended(charArray: Array<string>): Array<string> {\n        const length = charArray.length;\n        const result = new Array<string>();\n        for (let i = 0; i < length; i++) {\n            const char = charArray[i];\n            if (char >= 'a' && char <= 'd') {\n                if (i > (length - 2)) {\n                    return null;\n                }\n                const nextChar = charArray[++i];\n                const nextCharCode = nextChar.charCodeAt(0);\n                let decodedChar: string;\n                switch (char) {\n                    case 'a': {\n                        if (nextChar >= 'A' && nextChar <= 'Z') {\n                            decodedChar = String.fromCharCode(nextCharCode - 64);\n                        } else {\n                            return null;\n                        }\n                        break;\n                    }\n                    case 'b': {\n                        if (nextChar >= 'A' && nextChar <= 'E') {\n                            decodedChar = String.fromCharCode(nextCharCode - 38);\n                        } else if (nextChar >= 'F' && nextChar <= 'J') {\n                            decodedChar = String.fromCharCode(nextCharCode - 11);\n                        } else if (nextChar >= 'K' && nextChar <= 'O') {\n                            decodedChar = String.fromCharCode(nextCharCode + 16);\n                        } else if (nextChar >= 'P' && nextChar <= 'S') {\n                            decodedChar = String.fromCharCode(nextCharCode + 43);\n                        } else if (nextChar >= 'T' && nextChar <= 'Z') {\n                            decodedChar = String.fromCharCode(127);\n                        } else {\n                            return null;\n                        }\n                        break;\n                    }\n                    case 'c': {\n                        if (nextChar >= 'A' && nextChar <= 'O') {\n                            decodedChar = String.fromCharCode(nextCharCode - 32);\n                        } else if (nextChar === 'Z') {\n                            decodedChar = ':';\n                        } else {\n                            return null;\n                        }\n                        break;\n                    }\n                    case 'd': {\n                        if (nextChar >= 'A' && nextChar <= 'Z') {\n                            decodedChar = String.fromCharCode(nextCharCode + 32);\n                        } else {\n                            return null;\n                        }\n                        break;\n                    }\n                }\n                result.push(decodedChar);\n            } else {\n                result.push(char);\n            }\n        }\n        return result;\n    }\n\n    private _verifyChecksums(charArray: Array<string>): boolean {\n        return this._matchCheckChar(charArray, charArray.length - 2, 20)\n            && this._matchCheckChar(charArray, charArray.length - 1, 15);\n    }\n\n    private _matchCheckChar(charArray: Array<string>, index: number, maxWeight: number): boolean {\n        const arrayToCheck = charArray.slice(0, index);\n        const length = arrayToCheck.length;\n        const weightedSums = arrayToCheck.reduce((sum, char, i) => {\n            const weight = (((i * -1) + (length - 1)) % maxWeight) + 1;\n            const value = ALPHABET.indexOf(char.charCodeAt(0));\n            return sum + (weight * value);\n        }, 0);\n\n        const checkChar = ALPHABET[(weightedSums % 47)];\n        return checkChar === charArray[index].charCodeAt(0);\n    }\n}\n","import { Code128Reader } from './code-128-reader';\nimport { Code39Reader } from './code-39-reader';\nimport { Code39VINReader } from './code-39-vin-reader';\nimport { CodabarReader } from './codabar-reader';\nimport { EANReader } from './ean-reader';\nimport { EAN8Reader } from './ean-8-reader';\nimport { EAN2Reader } from './ean-2-reader';\nimport { EAN5Reader } from './ean-5-reader';\nimport { UPCReader } from './upc-reader';\nimport { UPCEReader } from './upc-e-reader';\nimport { I2of5Reader } from './i2of5-reader';\nimport { TwoOfFiveReader } from './2of5-reader';\nimport { Code93Reader } from './code-93-reader';\n\nexport const Readers = {\n    code_128_reader: Code128Reader,\n    ean_reader: EANReader,\n    ean_5_reader: EAN5Reader,\n    ean_2_reader: EAN2Reader,\n    ean_8_reader: EAN8Reader,\n    code_39_reader: Code39Reader,\n    code_39_vin_reader: Code39VINReader,\n    codabar_reader: CodabarReader,\n    upc_reader: UPCReader,\n    upc_e_reader: UPCEReader,\n    i2of5_reader: I2of5Reader,\n    '2of5_reader': TwoOfFiveReader,\n    code_93_reader: Code93Reader\n};\n","import { getUserMedia, enumerateDevices } from '../common/media-devices';\n\nlet _stream: MediaStream;\n\nexport const CameraAccess = {\n    /**\n     * Attempts to attach the camera-stream to a given video element\n     * and calls the callback function when the content is ready\n     * @param video\n     * @param videoConstraints\n     */\n    async request(video: HTMLVideoElement, videoConstraints: MediaTrackConstraints): Promise<void> {\n        const normalizedConstraints = CameraAccess.pickConstraints(videoConstraints);\n        _stream = await getUserMedia(normalizedConstraints);\n        video.srcObject = _stream;\n        video.setAttribute('autoplay', '');\n        video.setAttribute('muted', '');\n        video.setAttribute('playsinline', '');\n\n        return new Promise(resolve => video.addEventListener('loadedmetadata', () => {\n            video.play();\n            resolve();\n        })).then(_waitForVideo.bind(null, video));\n    },\n\n    release(): void {\n        const tracks = _stream && _stream.getVideoTracks();\n        if (tracks && tracks.length) {\n            tracks[0].stop();\n        }\n        _stream = null;\n    },\n\n    async enumerateVideoDevices(): Promise<Array<MediaDeviceInfo>> {\n        const devices = await enumerateDevices();\n        return devices.filter(({ kind }) => kind === 'videoinput');\n    },\n\n    getActiveStreamLabel(): string {\n        const track = CameraAccess.getActiveTrack();\n        return track ? track.label : '';\n    },\n\n    getActiveTrack() {\n        const tracks = _stream && _stream.getVideoTracks();\n        if (tracks && tracks.length) {\n            return tracks[0];\n        }\n\n        return null;\n    },\n\n    pickConstraints(videoConstraints: MediaTrackConstraints): MediaStreamConstraints {\n        let { width, height, facingMode, aspectRatio, deviceId } = videoConstraints;\n        const { minAspectRatio, facing } = videoConstraints as any;\n\n        if (typeof minAspectRatio !== 'undefined' && minAspectRatio > 0) {\n            aspectRatio = minAspectRatio;\n            console.log(`WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead`);\n        }\n\n        if (typeof facing !== 'undefined') {\n            facingMode = facing;\n            console.log(`WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'`);\n        }\n\n        const normalizedConstraints = deviceId && facingMode ?\n            { width, height, aspectRatio, deviceId } : { width, height, facingMode, aspectRatio, deviceId };\n\n        return {\n            audio: false,\n            video: normalizedConstraints\n        };\n    }\n}\n\nfunction _waitForVideo({ videoWidth, videoHeight }): Promise<void> {\n    return new Promise((resolve, reject) => {\n        let attempts = 10;\n\n        function checkVideo() {\n            if (attempts > 0) {\n                if (videoWidth > 10 && videoHeight > 10) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        console.log(`${videoWidth}px x ${videoHeight}px`);\n                    }\n                    resolve();\n                } else {\n                    window.setTimeout(checkVideo, 500);\n                }\n            } else {\n                reject('Unable to play video stream. Is webcam working?');\n            }\n            attempts--;\n        }\n        checkVideo();\n    });\n}\n","import { Box } from '../common/box';\nimport { ImageWrapper } from '../common/image-wrapper';\nimport { Point } from '../common/point';\nimport { Readers } from '../reader/index';\nimport { Barcode, BarcodeReader, BarcodeReaderConfig, BarcodeReaderDeclaration, BarcodeReaderType } from '../reader/barcode-reader';\nimport { BarcodeLine, Bresenham } from './bresenham';\nimport { ImageDebug } from '../common/image-debug';\n\nexport interface BarcodeDecoderConfig {\n    debug?: {\n        drawBoundingBox?: boolean;\n        drawScanline?: boolean;\n        showFrequency?: boolean;\n        showPattern?: boolean;\n    };\n    multiple?: boolean;\n    readers?: Array<BarcodeReaderDeclaration>;\n}\n\ntype Line = [Point, Point];\n\nexport interface QuaggaBarcode {\n    angle?: number;\n    barcodes?: Array<QuaggaBarcode>; // TOOD: deal with multiple results\n    box?: Box;\n    boxes?: Array<Box>; // TOOD: deal with multiple results\n    codeResult?: Barcode;\n    frame?: string;\n    line?: Line;\n    pattern?: Array<number>;\n    threshold?: number;\n};\n\ninterface BarcodeAndBarcodeLine {\n    codeResult: Barcode;\n    barcodeLine: BarcodeLine;\n}\n\nexport class BarcodeDecoder {\n    private _config: BarcodeDecoderConfig;\n    private _inputImageWrapper: ImageWrapper<Uint8Array>;\n    private _frequencyCanvas: HTMLCanvasElement;\n    private _patternCanvas: HTMLCanvasElement;\n    private _overlayContext: CanvasRenderingContext2D;\n    private _barcodeReaders: Array<BarcodeReader>;\n\n    constructor(config: BarcodeDecoderConfig, inputImageWrapper: ImageWrapper<Uint8Array>) {\n        this._config = config;\n        this._inputImageWrapper = inputImageWrapper;\n        this._barcodeReaders = [];\n\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && typeof document !== 'undefined') {\n            const debugDiv = document.querySelector('#debug.detection');\n\n            this._frequencyCanvas = document.querySelector('canvas.frequency');\n            if (!this._frequencyCanvas) {\n                this._frequencyCanvas = document.createElement('canvas');\n                this._frequencyCanvas.className = 'frequency';\n                if (debugDiv) {\n                    debugDiv.appendChild(this._frequencyCanvas);\n                }\n            }\n            this._frequencyCanvas.style.display = this._config.debug.showFrequency ? 'block' : 'none';\n\n            this._patternCanvas = document.querySelector('canvas.patternBuffer');\n            if (!this._patternCanvas) {\n                this._patternCanvas = document.createElement('canvas');\n                this._patternCanvas.className = 'patternBuffer';\n                if (debugDiv) {\n                    debugDiv.appendChild(this._patternCanvas);\n                }\n            }\n            this._patternCanvas.style.display = this._config.debug.showPattern ? 'block' : 'none';\n\n            const overlayCanvas = document.querySelector<HTMLCanvasElement>('canvas.drawingBuffer');\n            this._overlayContext = overlayCanvas ? overlayCanvas.getContext('2d') : null;\n        }\n\n        this._initReaders();\n    }\n\n    decodeFromBoundingBoxes(boxes: Array<Box>): QuaggaBarcode {\n        let barcode: QuaggaBarcode = null;\n\n        if (boxes) {\n            if (this._config.multiple) {\n                const barcodes = boxes.map(box => this.decodeFromBoundingBox(box));\n                return { barcodes, boxes };\n            }\n            if (boxes.some(box => !!(barcode = this.decodeFromBoundingBox(box)))) {\n                barcode.boxes = boxes;\n            }\n        }\n\n        return barcode;\n    }\n\n    /**\n     * With the help of the configured readers this function tries to detect\n     * a valid barcode pattern within the given area.\n     * @param box The area to search in\n     * @returns The result {codeResult, line, angle, pattern, threshold}\n     */\n    decodeFromBoundingBox(box: Box): QuaggaBarcode {\n        const debug = process.env.NODE_ENV !== 'production' && this._overlayContext && this._config.debug;\n\n        if (debug && debug.drawBoundingBox) {\n            this._drawPath(box, 'blue', 2);\n        }\n\n        let line = this._getLine(box);\n\n        if (line === null) {\n            return null;\n        }\n\n        const angle = Math.atan2(line[1].y - line[0].y, line[1].x - line[0].x);\n        line = this._getExtendedLine(line, angle);\n\n        let result = this._tryDecode(line);\n        if (result === null) {\n            result = this._tryDecodeBruteForce(box, line, angle);\n        }\n\n        if (result === null) {\n            return null;\n        }\n\n        if (debug && debug.drawScanline) {\n            this._drawPath(line, 'red', 3);\n        }\n\n        return {\n            angle,\n            box,\n            codeResult: result.codeResult,\n            line,\n            pattern: result.barcodeLine.line,\n            threshold: result.barcodeLine.threshold\n        };\n    }\n\n    setReaders(readers: Array<BarcodeReaderDeclaration>): void {\n        this._config.readers = readers;\n        this._barcodeReaders.length = 0;\n        this._initReaders();\n    }\n\n    private _initReaders(): void {\n        this._config.readers.forEach(readerConfig => {\n            let reader: BarcodeReaderType;\n            let configuration: BarcodeReaderConfig = {};\n            let supplements = [];\n\n            if (typeof readerConfig === 'object') {\n                reader = readerConfig.format;\n                configuration = readerConfig.config || {};\n            } else if (typeof readerConfig === 'string') {\n                reader = readerConfig;\n            }\n\n            if (process.env.NODE_ENV !== 'production') {\n                console.log('Before registering reader:', reader);\n            }\n\n            if (configuration.supplements) {\n                supplements = configuration.supplements.map(supplement => new Readers[supplement]());\n            }\n\n            this._barcodeReaders.push(new Readers[reader](configuration, supplements));\n        });\n\n        if (process.env.NODE_ENV !== 'production') {\n            console.log('Registered Readers:',\n                ...this._barcodeReaders.map(({ config, FORMAT }) => JSON.stringify({ config, FORMAT })));\n        }\n    }\n\n    /**\n     * extend the line on both ends\n     * @param line\n     * @param angle\n     */\n    private _getExtendedLine(line: Line, angle: number): Line {\n        function extendLine(amount: number) {\n            const extension = {\n                y: amount * Math.sin(angle),\n                x: amount * Math.cos(angle)\n            };\n\n            line[0].y -= extension.y;\n            line[0].x -= extension.x;\n            line[1].y += extension.y;\n            line[1].x += extension.x;\n        }\n\n        const lineLength = Math.sqrt((line[1].y - line[0].y) ** 2 + (line[1].x - line[0].x) ** 2);\n        let extensionLength = lineLength * 0.1 | 0;\n\n        extendLine(extensionLength);\n\n        // check if inside image\n        while (extensionLength > 1 && (!this._inputImageWrapper.inImageWithBorder(line[0], 0)\n            || !this._inputImageWrapper.inImageWithBorder(line[1], 0))) {\n            extensionLength >>= 1;\n            extendLine(-extensionLength);\n        }\n\n        return line;\n    }\n\n    private _getLine(box: Box): Line {\n        return [{\n            x: (box[1].x + box[0].x) / 2,\n            y: (box[1].y + box[0].y) / 2\n        }, {\n            x: (box[3].x + box[2].x) / 2,\n            y: (box[3].y + box[2].y) / 2\n        }];\n    }\n\n    private _tryDecode(line: Line): BarcodeAndBarcodeLine {\n        const debug = process.env.NODE_ENV !== 'production' && this._config.debug;\n\n        if (debug && this._overlayContext) {\n            this._drawPath(line, 'red', 3);\n        }\n\n        let barcodeLine = Bresenham.getBarcodeLine(this._inputImageWrapper, line[0], line[1]);\n\n        if (debug && debug.showFrequency) {\n            this._printFrequency(barcodeLine.line);\n        }\n\n        barcodeLine = Bresenham.toBinaryLine(barcodeLine);\n\n        if (debug && debug.showPattern) {\n            this._printPattern(barcodeLine.line);\n        }\n\n        let codeResult: Barcode = null;\n\n        this._barcodeReaders.some(reader => !!(codeResult = reader.decodePattern(barcodeLine.line)));\n\n        return codeResult ? { codeResult, barcodeLine } : null;\n    }\n\n    /**\n     * This method slices the given area apart and tries to detect a barcode-pattern for each slice.\n     * It returns the decoded barcode, or null if nothing was found\n     * @param box\n     * @param line\n     * @param lineAngle\n     */\n    private _tryDecodeBruteForce(box: Box, line: Line, lineAngle: number): BarcodeAndBarcodeLine {\n        const sideLength = Math.sqrt((box[1].x - box[0].x) ** 2 + (box[1].y - box[0].y) ** 2);\n        const slices = 16;\n        const xdir = Math.sin(lineAngle);\n        const ydir = Math.cos(lineAngle);\n\n        for (let i = 1; i < slices; i++) {\n            // move line perpendicular to angle\n            const dir = sideLength / slices * i * (i % 2 === 0 ? -1 : 1);\n            line[0].y += dir * xdir;\n            line[0].x -= dir * ydir;\n            line[1].y += dir * xdir;\n            line[1].x -= dir * ydir;\n\n            const result = this._tryDecode(line);\n            if (result) {\n                return result;\n            }\n        }\n\n        return null;\n    }\n\n    /**\n     * Used for development only\n     */\n    private _printFrequency(line: Array<number>): void {\n        const context = this._frequencyCanvas.getContext('2d');\n        this._frequencyCanvas.width = line.length;\n        this._frequencyCanvas.height = 256;\n\n        context.beginPath();\n        context.strokeStyle = 'blue';\n\n        for (let i = 0; i < line.length; i++) {\n            context.moveTo(i, 255);\n            context.lineTo(i, 255 - line[i]);\n        }\n\n        context.closePath();\n        context.stroke();\n    }\n\n    /**\n     * Used for development only\n     */\n    private _printPattern(line: Array<number>): void {\n        const context = this._patternCanvas.getContext('2d');\n\n        this._patternCanvas.width = line.length;\n        context.fillStyle = 'black';\n\n        for (let i = 0; i < line.length; i++) {\n            if (line[i] === 1) {\n                context.fillRect(i, 0, 1, 100);\n            }\n        }\n    }\n\n    private _drawPath(path: Array<Point>, color: string, lineWidth: number): void {\n        ImageDebug.drawPath(path, this._overlayContext, color, lineWidth);\n    }\n}\n","\nexport function enumerateDevices(): Promise<Array<MediaDeviceInfo>> {\n    if (navigator.mediaDevices && typeof navigator.mediaDevices.enumerateDevices === 'function') {\n        return navigator.mediaDevices.enumerateDevices();\n    }\n    return Promise.reject(new Error('enumerateDevices is not defined'));\n}\n\nexport function getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream> {\n    if (navigator.mediaDevices && typeof navigator.mediaDevices.getUserMedia === 'function') {\n        return navigator.mediaDevices.getUserMedia(constraints);\n    }\n    return Promise.reject(new Error('getUserMedia is not defined'));\n}\n","import { Point } from '../common/point';\nimport { InputStream } from './input-stream';\nimport { InputStreamConfig } from './input-stream-config';\n\nconst ndarray = require('ndarray');\ntype ndarray<_T = number> = any;\n\nexport class FrameGrabber {\n    private _inputStream: InputStream;\n    private _streamConfig: InputStreamConfig;\n    private _data: Uint8Array;\n    private _canvasData: Uint8Array;\n    private _grayData: Uint8Array;\n    private _canvasImageArray: ndarray<number>;\n    private _grayImageArray: ndarray<number>;\n    private _targetImageArray: ndarray<number>;\n    private _canvasHeight: number;\n    private _canvasWidth: number;\n    private _videoHeight: number;\n    private _videoWidth: number;\n    private _height: number;\n    private _width: number;\n    private _stepSizeX: number;\n    private _stepSizeY: number;\n    private _topLeft: Point;\n\n    constructor(inputStream: InputStream) {\n        this._inputStream = inputStream;\n        this._streamConfig = inputStream.config;\n        this._videoHeight = inputStream.realHeight;\n        this._videoWidth = inputStream.realWidth;\n        this._canvasHeight = inputStream.canvasHeight;\n        this._canvasWidth = inputStream.canvasWidth;\n        this._width = inputStream.width;\n        this._height = inputStream.height;\n        this._topLeft = inputStream.topLeft;\n        this._data = new Uint8Array(this._width * this._height);\n        this._grayData = new Uint8Array(this._videoWidth * this._videoHeight);\n        this._canvasData = new Uint8Array(this._canvasWidth * this._canvasHeight);\n        this._grayImageArray = ndarray(this._grayData, [this._videoHeight, this._videoWidth]).transpose(1, 0);\n        this._canvasImageArray = ndarray(this._canvasData, [this._canvasHeight, this._canvasWidth]).transpose(1, 0);\n        this._targetImageArray = this._canvasImageArray\n            .hi(this._topLeft.x + this._width, this._topLeft.y + this._height).lo(this._topLeft.x, this._topLeft.y);\n        this._stepSizeX = this._videoWidth / this._canvasWidth;\n        this._stepSizeY = this._videoHeight / this._canvasHeight;\n\n        console.log('FrameGrabber', JSON.stringify({\n            videoSize: this._grayImageArray.shape,\n            canvasSize: this._canvasImageArray.shape,\n            stepSize: [this._stepSizeX, this._stepSizeY],\n            size: this._targetImageArray.shape,\n            topLeft: this._topLeft\n        }));\n    }\n\n    /**\n     * Fetches a frame from the input stream and puts into the frame buffer.\n     * The image data is converted to gray scale and then half-sampled if configured.\n     */\n    grab(data: Uint8Array): boolean {\n        this._data = data;\n        const frame = this._inputStream.getFrame();\n\n        if (frame) {\n            this._scaleAndCrop(frame);\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    private _scaleAndCrop(frame: ndarray<number>) {\n        // 1. compute full-sized gray image\n        this._computeGray(frame.data);\n\n        // 2. interpolate\n        for (let y = 0; y < this._canvasHeight; y++) {\n            for (let x = 0; x < this._canvasWidth; x++) {\n                this._canvasImageArray\n                    .set(x, y, (interp2d(this._grayImageArray, x * this._stepSizeX, y * this._stepSizeY)) | 0);\n            }\n        }\n\n        // targetImageArray must be equal to targetSize\n        if (this._targetImageArray.shape[0] !== this._width || this._targetImageArray.shape[1] !== this._height) {\n            throw new Error('Shapes do not match!');\n        }\n\n        // 3. crop\n        for (let y = 0; y < this._height; y++) {\n            for (let x = 0; x < this._width; x++) {\n                this._data[y * this._width + x] = this._targetImageArray.get(x, y);\n            }\n        }\n    }\n\n    private _computeGray(imageData: Uint8ClampedArray): void {\n        const imageDataLength = imageData.length;\n\n        if (this._streamConfig && this._streamConfig.singleChannel) {\n            for (let i = 0, j = 0; i < imageDataLength; i += 4, j++) {\n                this._data[j] = imageData[i];\n            }\n        } else {\n            for (let i = 0, j = 0; i < imageDataLength; i += 4, j++) {\n                this._data[j] = 0.299 * imageData[i] + 0.587 * imageData[i + 1] + 0.114 * imageData[i + 2] | 0;\n            }\n        }\n    }\n}\n\n/**\n * @borrows https://github.com/scijs/ndarray-linear-interpolate\n */\nfunction interp2d(arr: ndarray<number>, x: number, y: number): number {\n    const ix = Math.floor(x);\n    const fx = x - ix;\n    const s0 = 0 <= ix && ix < arr.shape[0];\n    const s1 = 0 <= ix + 1 && ix + 1 < arr.shape[0];\n    const iy = Math.floor(y);\n    const fy = y - iy;\n    const t0 = 0 <= iy && iy < arr.shape[1];\n    const t1 = 0 <= iy + 1 && iy + 1 < arr.shape[1];\n    const w00 = s0 && t0 ? arr.get(ix, iy) : 0.0;\n    const w01 = s0 && t1 ? arr.get(ix, iy + 1) : 0.0;\n    const w10 = s1 && t0 ? arr.get(ix + 1, iy) : 0.0;\n    const w11 = s1 && t1 ? arr.get(ix + 1, iy + 1) : 0.0;\n    return (1.0 - fy) * ((1.0 - fx) * w00 + fx * w10) + fy * ((1.0 - fx) * w01 + fx * w11);\n}\n","import { Point } from '../common/point';\nimport { ImageInfo } from './image-loader';\nimport { InputStreamConfig } from './input-stream-config';\n\nexport abstract class InputStream {\n    protected _calculatedHeight: number;\n    protected _calculatedWidth: number;\n    protected _canvasHeight: number;\n    protected _canvasWidth: number;\n    protected _config: InputStreamConfig;\n    protected _eventNames: Array<string>;\n    protected _eventHandlers: Map<string, Array<EventListener>>;\n    protected _topLeft: Point;\n\n    constructor() {\n        this._canvasWidth = 0;\n        this._canvasHeight = 0;\n        this._config = null;\n        this._eventNames = ['canrecord', 'ended'];\n        this._eventHandlers = new Map<string, Array<EventListener>>();\n        this._topLeft = { x: 0, y: 0 };\n    }\n\n    abstract get realHeight(): number;\n\n    abstract get realWidth(): number;\n\n    get height(): number {\n        return this._calculatedHeight;\n    }\n\n    set height(height: number) {\n        this._calculatedHeight = height;\n    }\n\n    get width(): number {\n        return this._calculatedWidth;\n    }\n\n    set width(width: number) {\n        this._calculatedWidth = width;\n    }\n\n    get topLeft(): Point {\n        return { ...this._topLeft };\n    }\n\n    set topLeft(topLeft: Point) {\n        this._topLeft.x = topLeft.x;\n        this._topLeft.y = topLeft.y;\n    }\n\n    setCanvasSize(width: number, height: number): void {\n        this._canvasWidth = width;\n        this._canvasHeight = height;\n    }\n\n    get canvasHeight(): number {\n        return this._canvasHeight;\n    }\n\n    get canvasWidth(): number {\n        return this._canvasWidth;\n    }\n\n    abstract get config(): InputStreamConfig;\n\n    abstract set config(config: InputStreamConfig);\n\n    abstract get ended(): boolean;\n\n    abstract setAttribute(name: string, value: string): void;\n\n    abstract pause(): void;\n\n    abstract play(): void;\n\n    abstract set currentTime(time: number);\n\n    addEventListener(event: string, listener: EventListener, _options?: boolean): void {\n        if (this._eventNames.indexOf(event) !== -1) {\n            if (!this._eventHandlers.has(event)) {\n                this._eventHandlers.set(event, new Array<EventListener>());\n            }\n            this._eventHandlers.get(event).push(listener);\n        }\n    }\n\n    clearEventHandlers(): void {\n        this._eventHandlers.clear();\n    }\n\n    trigger(eventName: string, argArray?: any) {\n        const handlers = this._eventHandlers.get(eventName);\n\n        if (handlers) {\n            handlers.forEach(handler => handler.apply(this, argArray));\n        }\n    }\n\n    abstract getFrame(): HTMLVideoElement | ImageInfo;\n}\n","import { ImageInfo } from './image-loader';\nimport { InputStream } from './input-stream';\nimport { InputStreamConfig } from './input-stream-config';\n\nconst getPixels = require('get-pixels');\n\ntype ndarray<_T = number> = any;\n\nexport class ImageStream extends InputStream {\n    private _baseUrl: string;\n    private _ended: boolean;\n    private _frame: ndarray<number>;\n    private _height: number;\n    private _loaded: boolean;\n    private _offset: number;\n    private _size: number;\n    private _width: number;\n\n    constructor() {\n        super();\n\n        this._canvasHeight = 0;\n        this._canvasWidth = 0;\n        this._baseUrl = null;\n        this._ended = false;\n        this._frame = null;\n        this._height = 0;\n        this._loaded = false;\n        this._offset = 1;\n        this._size = 0;\n        this._width = 0;\n    }\n\n    get realHeight(): number {\n        return this._height;\n    }\n\n    get realWidth(): number {\n        return this._width;\n    }\n\n    get config(): InputStreamConfig {\n        return this._config;\n    }\n\n    set config(config: InputStreamConfig) {\n        this._config = { ...config };\n        this._baseUrl = config.src || '';\n\n        this._loadImages();\n    }\n\n    get ended(): boolean {\n        return this._ended;\n    }\n\n    setAttribute() { }\n\n    pause(): void { }\n\n    play(): void { }\n\n    set currentTime(_time: number) { }\n\n    getFrame(): HTMLVideoElement | ImageInfo {\n        if (!this._loaded) {\n            return null;\n        }\n        return this._frame as any;\n    }\n\n    private _loadImages(): void {\n        this._loaded = false;\n\n        getPixels(this._baseUrl, this._config.mime, (err: any, pixels: ndarray<number>) => {\n            if (err) {\n                console.log(err);\n                process.exit(1);\n            }\n\n            this._loaded = true;\n            this._frame = pixels;\n            console.log(pixels.shape);\n\n            this._width = pixels.shape[0] | 0;\n            this._height = pixels.shape[1] | 0;\n\n            this._canvasWidth = this._calculatedWidth = this._config.size ? this._width > this._height ?\n                this._config.size : this._width * this._config.size / this._height | 0 : this._width;\n            this._canvasHeight = this._calculatedHeight = this._config.size ? this._width > this._height ?\n                this._height * this._config.size / this._width | 0 : this._config.size : this._height;\n\n            setTimeout(() => this.trigger('canrecord', []), 0);\n        }, this._offset, this._size, this._config.sequence);\n    }\n}\n","import { ImageInfo } from './image-loader';\nimport { InputStream } from './input-stream';\nimport { InputStreamConfig } from './input-stream-config';\n\nexport class VideoStream extends InputStream {\n    private _video: HTMLVideoElement;\n\n    constructor(video: HTMLVideoElement) {\n        super();\n\n        this._video = video;\n    }\n\n    get realHeight(): number {\n        return this._video.videoHeight;\n    }\n\n    get realWidth(): number {\n        return this._video.videoWidth;\n    }\n\n    get config(): InputStreamConfig {\n        return this._config;\n    }\n\n    set config(config: InputStreamConfig) {\n        this._config = { ...config };\n        this._video.src = config.src || '';\n    }\n\n    get ended(): boolean {\n        return this._video.ended;\n    }\n\n    setAttribute(name: string, value: string): void {\n        this._video.setAttribute(name, value);\n    }\n\n    pause(): void {\n        this._video.pause();\n    }\n\n    play(): void {\n        this._video.play();\n    }\n\n    set currentTime(time: number) {\n        if (this._config.type !== 'LiveStream') {\n            this._video.currentTime = time;\n        }\n    }\n\n    addEventListener(event: string, listener: EventListener, options?: boolean): void {\n        super.addEventListener(event, listener, options);\n\n        if (this._eventNames.indexOf(event) === -1) {\n            this._video.addEventListener(event, listener, options);\n        }\n    }\n\n    clearEventHandlers(): void {\n        // TODO: come up with a way to remove video event handlers\n        // this._eventNames.forEach(eventName => {\n        //     const handlers = this._eventHandlers.get(eventName);\n        //     if (handlers && handlers.length > 0) {\n        //         handlers.forEach(handler => this._video.removeEventListener(eventName, handler));\n        //     }\n        // });\n        super.clearEventHandlers();\n    }\n\n    trigger(eventName: string, argArray?: any) {\n        if (eventName === 'canrecord') {\n            this._initSize();\n        }\n\n        super.trigger(eventName, argArray)\n    }\n\n    getFrame(): HTMLVideoElement | ImageInfo {\n        return this._video;\n    }\n\n    private _initSize() {\n        const width = this._video.videoWidth;\n        const height = this._video.videoHeight;\n\n        this._canvasWidth = this._calculatedWidth =\n            this._config.size ? width > height ? this._config.size : width * this._config.size / height | 0 : width;\n        this._canvasHeight = this._calculatedHeight =\n            this._config.size ? width > height ? height * this._config.size / width | 0 : this._config.size : height;\n    }\n}\n\nexport class LiveStream extends VideoStream {\n    constructor(video: HTMLVideoElement) {\n        video.setAttribute('autoplay', '');\n        super(video);\n    }\n\n    get ended(): boolean {\n        return false;\n    }\n}\n","import { VideoStream } from './video-stream';\n\nexport class LiveStream extends VideoStream {\n    constructor(video: HTMLVideoElement) {\n        video.setAttribute('autoplay', '');\n        super(video);\n    }\n\n    get ended(): boolean {\n        return false;\n    }\n}\n","import { Point } from '../common/point';\nimport { BarcodeLocatorConfig, PatchSizeConfig } from '../locator/barcode-locator-config';\nimport { InputStream } from './input-stream';\nimport { AreaConfig } from './input-stream-config';\n\nexport interface Dimension {\n    unit: '%' | 'px',\n    value: number;\n}\n\nfunction _computeDivisors(n: number): Array<number> {\n    const divisors = new Array<number>();\n    const largeDivisors = new Array<number>();\n\n    for (let divisor = 1; divisor * divisor <= n; divisor++) {\n        if (n % divisor === 0) {\n            divisors.push(divisor);\n            if (divisor * divisor !== n) {\n                largeDivisors.unshift(n / divisor | 0);\n            }\n        }\n    }\n\n    return divisors.concat(largeDivisors);\n}\n\nfunction _computeCommonDivisors(m: number, n: number): Array<number> {\n    if (m === n) {\n        return _computeDivisors(m);\n    }\n\n    const max = m > n ? m : n;\n    const min = m > n ? n : m;\n    const divisors = new Array<number>();\n    const largeDivisors = new Array<number>();\n\n    for (let divisor = 1; divisor * divisor <= min; divisor++) {\n        if (max % divisor === 0 && min % divisor === 0) {\n            divisors.push(divisor);\n            const largeDivisor = min / divisor | 0;\n            if (divisor !== largeDivisor && max % largeDivisor === 0) {\n                largeDivisors.unshift();\n            }\n        }\n    }\n\n    return divisors.concat(largeDivisors);\n}\n\nexport function calculatePatchSize(patchSize: PatchSizeConfig, { x, y }: Point): Point {\n    const wideSide = Math.max(x | 0, y | 0) | 0;\n    const nrOfPatchesList = [8, 10, 15, 20, 32, 60, 80];\n    const nrOfPatchesMap = {\n        'x-small': 5,\n        small: 4,\n        medium: 3,\n        large: 2,\n        'x-large': 1\n    };\n    const nrOfPatchesIndex = nrOfPatchesMap[patchSize] || nrOfPatchesMap.medium | 0;\n    const nrOfPatches = nrOfPatchesList[nrOfPatchesIndex] | 0;\n    const desiredPatchSize = wideSide / nrOfPatches | 0;\n\n    function findPatchSizeForDivisors(divisors: Array<number>): Point {\n        let i = 0;\n        let found = divisors[divisors.length >> 1] | 0;\n\n        while (i < (divisors.length - 1) && divisors[i] < desiredPatchSize) {\n            i++;\n        }\n        if (i > 0) {\n            if (Math.abs(divisors[i] - desiredPatchSize) > Math.abs(divisors[i - 1] - desiredPatchSize)) {\n                found = divisors[i - 1] | 0;\n            } else {\n                found = divisors[i] | 0;\n            }\n        }\n        if (desiredPatchSize / found < nrOfPatchesList[nrOfPatchesIndex + 1] / nrOfPatchesList[nrOfPatchesIndex] &&\n            desiredPatchSize / found > nrOfPatchesList[nrOfPatchesIndex - 1] / nrOfPatchesList[nrOfPatchesIndex]) {\n            return { x: found, y: found };\n        }\n        return null;\n    }\n\n    const optimalPatchSize = findPatchSizeForDivisors(_computeCommonDivisors(x, y)) ||\n        findPatchSizeForDivisors(_computeDivisors(wideSide)) ||\n        findPatchSizeForDivisors(_computeDivisors(desiredPatchSize * nrOfPatches));\n\n    return optimalPatchSize;\n}\n\nexport function checkImageConstraints(inputStream: InputStream, config: BarcodeLocatorConfig) {\n    let width = inputStream.width;\n    let height = inputStream.height;\n    const shift = config.halfSample ? 1 : 0 | 0;\n    const inputStreamConfig = inputStream.config;\n\n    // calculate width and height based on area\n    if (inputStreamConfig && inputStreamConfig.area) {\n        const area = computeImageArea(width, height, inputStreamConfig.area);\n        inputStream.topLeft = area.topLeft;\n        inputStream.setCanvasSize(width, height);\n        width = area.width;\n        height = area.height;\n    }\n\n    const size = {\n        x: width >> shift,\n        y: height >> shift\n    };\n\n    const patchSize = calculatePatchSize(config.patchSize, size);\n    if (process.env.NODE_ENV !== 'production') {\n        console.log('Patch-Size:', JSON.stringify(patchSize));\n    }\n\n    inputStream.width = (size.x / patchSize.x << shift) * patchSize.x | 0;\n    inputStream.height = (size.y / patchSize.y << shift) * patchSize.y | 0;\n\n    if ((inputStream.width % patchSize.x) === 0 && (inputStream.height % patchSize.y) === 0) {\n        return true;\n    }\n\n    // eslint-disable-next-line max-len\n    throw new Error(`Image dimensions do not comply with the current settings: width (${width}) and height (${height}) must be a multiple of ${patchSize.x}`);\n}\n\nexport function _parseCssDimensionValues(value: string): Dimension {\n    const dimension: Dimension = {\n        value: parseFloat(value),\n        unit: value.indexOf('%') === value.length - 1 ? '%' : value.indexOf('px') === value.length - 2 ? 'px' : '%'\n    };\n\n    return dimension;\n}\n\nexport const _dimensionsConverters = {\n    bottom: (dimension: Dimension, { height }) => dimension.unit === '%' ?\n        height - height * dimension.value / 100 | 0 : dimension.unit === 'px' ? height - dimension.value : height,\n    left: (dimension: Dimension, { width }) => dimension.unit === '%' ?\n        width * dimension.value / 100 | 0 : dimension.unit === 'px' ? dimension.value : 0,\n    right: (dimension: Dimension, { width }) => dimension.unit === '%' ?\n        width - width * dimension.value / 100 | 0 : dimension.unit === 'px' ? width - dimension.value : width,\n    top: (dimension: Dimension, { height }): number => dimension.unit === '%' ?\n        height * dimension.value / 100 | 0 : dimension.unit === 'px' ? dimension.value : 0\n};\n\nexport function computeImageArea(inputWidth: number, inputHeight: number, area: AreaConfig) {\n    const context = { width: inputWidth, height: inputHeight };\n    const parsedArea: {\n        bottom?: number;\n        left?: number;\n        right?: number;\n        top?: number;\n    } = Object.keys(area).reduce((result, key) => {\n        const value = area[key];\n        const parsed = _parseCssDimensionValues(value);\n        const calculated = _dimensionsConverters[key](parsed, context);\n\n        result[key] = calculated;\n        return result;\n    }, {});\n\n    return {\n        topLeft: { x: parsedArea.left, y: parsedArea.top },\n        width: parsedArea.right - parsedArea.left,\n        height: parsedArea.bottom - parsedArea.top\n    };\n}\n","import { Moment } from './moment';\n\n\n/**\n * Creates a cluster for grouping similar orientations of moments\n */\nexport class Cluster {\n    private _threshold: number;\n    private _moments: Array<Moment>;\n    private _center: Moment;\n\n    static clusterize(moments: Array<Moment>, threshold: number): Array<Cluster> {\n        const clusters = new Array<Cluster>();\n\n        moments.forEach(moment => {\n            const matchingCluster = clusters.find(cluster => cluster.fits(moment));\n\n            if (matchingCluster) {\n                matchingCluster.add(moment);\n            } else {\n                clusters.push(new Cluster(threshold, moment));\n            }\n        });\n\n        return clusters;\n    }\n\n    constructor(threshold: number, moment: Moment) {\n        this._threshold = threshold;\n        this._moments = new Array<Moment>();\n        this._center = {\n            rad: 0,\n            x: 0,\n            y: 0\n        };\n\n        if (moment) {\n            this.add(moment);\n        }\n    }\n\n    add(point: Moment) {\n        this._moments.push(point);\n\n        // Update center\n        this._center.rad = this._moments.reduce((sum, p) => sum + p.rad, 0) / this._moments.length;\n        this._center.x = Math.cos(this._center.rad);\n        this._center.y = Math.sin(this._center.rad);\n    }\n\n    fits(moment: Moment): boolean {\n        // check cosine similarity to center-angle\n        const similarity = Math.abs(moment.x * this._center.x + moment.y * this._center.y);\n        return similarity > this._threshold;\n    }\n\n    get moments() {\n        return this._moments;\n    }\n}\n","import { ImageWrapper } from '../common/image-wrapper';\nimport { Point } from '../common/point';\n\n/**\n * Invert matrix\n * @param matrix the matrix to invert\n * @returns the inverted matrix\n */\nexport function invert(matrix: Float32Array): Float32Array {\n    const a0 = matrix[0];\n    const a1 = matrix[1];\n    const a2 = matrix[2];\n    const a3 = matrix[3];\n    const determinant = a0 * a3 - a2 * a1;\n\n    if (!determinant) {\n        return null;\n    }\n\n    return new Float32Array([a3 / determinant, -a1 / determinant, -a2 / determinant, a0 / determinant]);\n}\n\n/**\n * Transforms the vector with a matrix\n * @param { x, y } vector to transform\n * @param matrix matrix to transform with\n * @returns the transformed vector\n */\nexport function transformWithMatrix({ x, y }: Point, matrix: Float32Array): Point {\n    return {\n        x: matrix[0] * x + matrix[2] * y,\n        y: matrix[1] * x + matrix[3] * y\n    };\n}\n\nfunction _computeHistogram(imageWrapper: ImageWrapper, bitsPerPixel: number): Int32Array {\n    if (!bitsPerPixel) {\n        bitsPerPixel = 8;\n    }\n\n    const imageData = imageWrapper.data;\n    const bitShift = 8 - bitsPerPixel;\n    const bucketCount = 1 << bitsPerPixel;\n    const histogram = new Int32Array(bucketCount);\n\n    for (let i = imageData.length; i--;) {\n        histogram[imageData[i] >> bitShift]++;\n    }\n\n    return histogram;\n}\n\nfunction _determineOtsuThreshold(imageWrapper: ImageWrapper, bitsPerPixel?: number): number {\n    if (!bitsPerPixel) {\n        bitsPerPixel = 8;\n    }\n\n    const bitShift = 8 - bitsPerPixel;\n    const hist = _computeHistogram(imageWrapper, bitsPerPixel);\n    const vet = [0];\n    const max = (1 << bitsPerPixel) - 1;\n\n    function px(init: number, end: number): number {\n        let sum = 0;\n\n        for (let i = init; i <= end; i++) {\n            sum += hist[i];\n        }\n\n        return sum;\n    }\n\n    function mx(init: number, end: number): number {\n        let sum = 0;\n\n        for (let i = init; i <= end; i++) {\n            sum += i * hist[i];\n        }\n\n        return sum;\n    }\n\n    for (let k = 1; k < max; k++) {\n        const p1 = px(0, k);\n        const p2 = px(k + 1, max);\n        const p12 = p1 * p2 || 1;\n        const m1 = mx(0, k) * p2;\n        const m2 = mx(k + 1, max) * p1;\n        const m12 = m1 - m2;\n        vet[k] = m12 * m12 / p12;\n    }\n\n    // index of max element\n    const threshold = vet.reduce((maxIndex, item, index, array) => item > array[maxIndex] ? index : maxIndex, 0);\n\n    return threshold << bitShift;\n}\n\nexport function otsuThreshold(imageWrapper: ImageWrapper, targetWrapper: ImageWrapper): number {\n    const threshold = _determineOtsuThreshold(imageWrapper);\n    const targetData = targetWrapper.data;\n\n    imageWrapper.data.forEach((value, index) => {\n        targetData[index] = value < threshold ? 1 : 0;\n    });\n\n    return threshold;\n}\n\n/**\n * @param imageWrapper input image to be sampled\n * @param outImageWrapper {ImageWrapper} to be stored in\n */\nexport function halfSample(imageWrapper: ImageWrapper, outImageWrapper: ImageWrapper): void {\n    const image = imageWrapper.data;\n    const width = imageWrapper.size.x;\n    const outImage = outImageWrapper.data;\n    const endIndex = image.length;\n    const outWidth = width >> 1;\n    let topRowIndex = 0;\n    let bottomRowIndex = width;\n    let outImgIndex = 0;\n\n    while (bottomRowIndex < endIndex) {\n        for (let i = 0; i < outWidth; i++) {\n            outImage[outImgIndex] =\n                (image[topRowIndex] + image[topRowIndex + 1] + image[bottomRowIndex] + image[bottomRowIndex + 1]) >> 2;\n            outImgIndex++;\n            topRowIndex += 2;\n            bottomRowIndex += 2;\n        }\n        topRowIndex += width;\n        bottomRowIndex += width;\n    }\n}\n","import { ImageWrapper } from \"../common/image-wrapper\";\n\n/**\n * @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization\n */\n\ntype Direction = number;\n\nexport const SearchDirections: Array<Array<Direction>> = [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]];\n\nexport interface ContourVertex {\n    x: number,\n    y: number,\n    dir: Direction,\n    next: ContourVertex,\n    prev: ContourVertex\n}\n\ninterface Current {\n    cx: number,\n    cy: number,\n    dir: Direction\n}\n\nexport class Tracer {\n    private _imageData: Uint8Array;\n    private _labelData: Array<number>;\n    private _width: number;\n\n    constructor(imageWrapper: ImageWrapper, labelWrapper: ImageWrapper<Array<number>>) {\n        this._imageData = imageWrapper.data;\n        this._labelData = labelWrapper.data as Array<number>;\n        this._width = imageWrapper.size.x;\n    }\n\n    trace(current: Current, color: number, label: number, edgeLabel: number): boolean {\n        for (let i = 0; i < 7; i++) {\n            const y = current.cy + SearchDirections[current.dir][0] | 0;\n            const x = current.cx + SearchDirections[current.dir][1] | 0;\n            const pos = y * this._width + x | 0;\n\n            if ((this._imageData[pos] === color) && ((this._labelData[pos] === 0) || (this._labelData[pos] === label))) {\n                this._labelData[pos] = label;\n                current.cx = x;\n                current.cy = y;\n\n                return true;\n            } else {\n                if (this._labelData[pos] === 0) {\n                    this._labelData[pos] = edgeLabel;\n                }\n                current.dir = (current.dir + 1) % 8;\n            }\n        }\n\n        return false;\n    }\n\n    contourTracing(sy: number, sx: number, label: number, color: number, edgeLabel: number): ContourVertex {\n        let Fv: ContourVertex = null;\n        const current: Current = {\n            cx: sx,\n            cy: sy,\n            dir: 0\n        };\n\n        if (this.trace(current, color, label, edgeLabel)) {\n            Fv = {\n                x: sx,\n                y: sy,\n                dir: current.dir,\n                next: null,\n                prev: null\n            };\n            let Cv = Fv;\n            let ldir = current.dir;\n            let P = {\n                x: current.cx,\n                y: current.cy,\n                dir: 0,\n                next: null,\n                prev: Cv\n            };\n            Cv.next = P;\n            Cv = P;\n\n            do {\n                current.dir = (current.dir + 6) % 8;\n\n                this.trace(current, color, label, edgeLabel);\n\n                if (ldir !== current.dir) {\n                    Cv.dir = current.dir;\n                    P = {\n                        x: current.cx,\n                        y: current.cy,\n                        dir: 0,\n                        next: null,\n                        prev: Cv\n                    };\n                    Cv.next = P;\n                    Cv = P;\n                } else {\n                    Cv.dir = ldir;\n                    Cv.x = current.cx;\n                    Cv.y = current.cy;\n                }\n\n                ldir = current.dir;\n            } while (current.cx !== sx || current.cy !== sy);\n\n            Fv.prev = Cv.prev;\n            Cv.prev.next = Fv;\n        }\n        return Fv;\n    }\n}\n","/**\n * @borrows http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization\n */\n\nimport { ImageWrapper } from '../common/image-wrapper';\nimport { ContourVertex, Tracer } from './tracer';\n\nenum EdgeLabel {\n    Outside = -32767,\n    Inside = -32766\n};\n\nenum ContourDirection {\n    CW = 0,\n    CCW = 1,\n    Unknown = 2\n};\n\ninterface Contour {\n    dir: ContourDirection;\n    index: number;\n    firstVertex: ContourVertex;\n    previousPeer?: Contour;\n    nextPeer?: Contour;\n    insideContours: Contour;\n}\n\nexport interface RasterResult {\n    cc: Contour;\n    count: number;\n}\n\nexport class Rasterizer {\n    private _width: number;\n    private _height: number;\n    private _tracer: Tracer;\n    private _imageData: Uint8Array;\n    private _labelData: Array<number>;\n\n    constructor(imageWrapper: ImageWrapper<Uint8Array>, labelWrapper: ImageWrapper<Array<number>>) {\n        this._imageData = imageWrapper.data;\n        this._labelData = labelWrapper.data as Array<number>;\n        this._width = imageWrapper.size.x;\n        this._height = imageWrapper.size.y;\n        this._tracer = new Tracer(imageWrapper, labelWrapper);\n    }\n\n    rasterize(depthLabel: number): RasterResult {\n        const colorMap = new Array<number>();\n\n        for (let i = 0; i < 400; i++) {\n            colorMap[i] = 0;\n        }\n\n        colorMap[0] = this._imageData[0];\n\n        let cc: Contour = null;\n        let sc: Contour;\n        let connectedCount = 0;\n\n        for (let cy = 1; cy < this._height - 1; cy++) {\n            let labelIndex = 0;\n            let bc = colorMap[0];\n\n            for (let cx = 1; cx < this._width - 1; cx++) {\n                const pos = cy * this._width + cx;\n\n                if (this._labelData[pos] === 0) {\n                    const color = this._imageData[pos];\n                    if (color !== bc) {\n                        if (labelIndex === 0) {\n                            const lc = connectedCount + 1;\n                            colorMap[lc] = color;\n                            bc = color;\n                            const vertex = this._tracer.contourTracing(cy, cx, lc, color, EdgeLabel.Outside);\n                            if (vertex !== null) {\n                                connectedCount++;\n                                labelIndex = lc;\n                                const p: Contour = {\n                                    dir: ContourDirection.CW,\n                                    index: labelIndex,\n                                    firstVertex: vertex,\n                                    nextPeer: cc,\n                                    insideContours: null\n                                };\n                                if (cc !== null) {\n                                    cc.previousPeer = p;\n                                }\n                                cc = p;\n                            }\n                        } else {\n                            const vertex = this._tracer.contourTracing(cy, cx, EdgeLabel.Inside, color, labelIndex);\n                            if (vertex !== null) {\n                                const p: Contour = {\n                                    dir: depthLabel === 0 ? ContourDirection.CCW : ContourDirection.CW,\n                                    firstVertex: vertex,\n                                    index: depthLabel,\n                                    insideContours: null\n                                };\n                                sc = cc;\n                                while ((sc !== null) && sc.index !== labelIndex) {\n                                    sc = sc.nextPeer;\n                                }\n                                if (sc !== null) {\n                                    p.nextPeer = sc.insideContours;\n                                    if (sc.insideContours !== null) {\n                                        sc.insideContours.previousPeer = p;\n                                    }\n                                    sc.insideContours = p;\n                                }\n                            }\n                        }\n                    } else {\n                        this._labelData[pos] = labelIndex;\n                    }\n                } else if (this._labelData[pos] === EdgeLabel.Inside) {\n                    labelIndex = 0;\n                    bc = this._imageData[pos];\n                } else if (this._labelData[pos] === EdgeLabel.Outside) {\n                    labelIndex = 0;\n                    bc = colorMap[0];\n                } else {\n                    labelIndex = this._labelData[pos];\n                    bc = colorMap[labelIndex];\n                }\n            }\n        }\n\n        sc = cc;\n        while (sc !== null) {\n            sc.index = depthLabel;\n            sc = sc.nextPeer;\n        }\n\n        return {\n            cc,\n            count: connectedCount\n        };\n    }\n\n    drawContour(canvas: HTMLCanvasElement, firstContour: Contour): void {\n        const context = canvas.getContext('2d');\n\n        context.strokeStyle = 'red';\n        context.fillStyle = 'red';\n        context.lineWidth = 1;\n\n        let pq = firstContour;\n        let iq = pq && pq.insideContours;\n\n        while (pq !== null) {\n            let q = iq || pq;\n\n            if (iq !== null) {\n                iq = iq.nextPeer;\n            } else {\n                pq = pq.nextPeer;\n                iq = pq && pq.insideContours;\n            }\n\n            switch (q.dir) {\n                case ContourDirection.CW: {\n                    context.strokeStyle = 'red';\n                    break;\n                }\n                case ContourDirection.CCW: {\n                    context.strokeStyle = 'blue';\n                    break;\n                }\n                case ContourDirection.Unknown: {\n                    context.strokeStyle = 'green';\n                    break;\n                }\n            }\n\n            let p = q.firstVertex;\n            context.beginPath();\n            context.moveTo(p.x, p.y);\n\n            do {\n                p = p.next;\n                context.lineTo(p.x, p.y);\n            } while (p !== q.firstVertex);\n\n            context.stroke();\n        }\n    }\n}\n","/* eslint-disable eqeqeq */\nfunction Skeletonizer(stdlib, foreign, buffer) {\n    \"use asm\";\n\n    var images = new stdlib.Uint8Array(buffer),\n        size = foreign.size | 0,\n        imul = stdlib.Math.imul;\n\n    function erode(inImagePtr, outImagePtr) {\n        inImagePtr = inImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var v = 0,\n            u = 0,\n            sum = 0,\n            yStart1 = 0,\n            yStart2 = 0,\n            xStart1 = 0,\n            xStart2 = 0,\n            offset = 0;\n\n        for (v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) {\n            offset = (offset + size) | 0;\n            for (u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) {\n                yStart1 = (offset - size) | 0;\n                yStart2 = (offset + size) | 0;\n                xStart1 = (u - 1) | 0;\n                xStart2 = (u + 1) | 0;\n                sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0)\n                    + (images[(inImagePtr + offset + u) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0;\n                if ((sum | 0) == (5 | 0)) {\n                    images[(outImagePtr + offset + u) | 0] = 1;\n                } else {\n                    images[(outImagePtr + offset + u) | 0] = 0;\n                }\n            }\n        }\n        return;\n    }\n\n    function subtract(aImagePtr, bImagePtr, outImagePtr) {\n        aImagePtr = aImagePtr | 0;\n        bImagePtr = bImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(outImagePtr + length) | 0] =\n                ((images[(aImagePtr + length) | 0] | 0) - (images[(bImagePtr + length) | 0] | 0)) | 0;\n        }\n    }\n\n    function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) {\n        aImagePtr = aImagePtr | 0;\n        bImagePtr = bImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(outImagePtr + length) | 0] =\n                ((images[(aImagePtr + length) | 0] | 0) | (images[(bImagePtr + length) | 0] | 0)) | 0;\n        }\n    }\n\n    function countNonZero(imagePtr) {\n        imagePtr = imagePtr | 0;\n\n        var sum = 0,\n            length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            sum = ((sum | 0) + (images[(imagePtr + length) | 0] | 0)) | 0;\n        }\n\n        return (sum | 0);\n    }\n\n    function init(imagePtr, value) {\n        imagePtr = imagePtr | 0;\n        value = value | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(imagePtr + length) | 0] = value;\n        }\n    }\n\n    function dilate(inImagePtr, outImagePtr) {\n        inImagePtr = inImagePtr | 0;\n        outImagePtr = outImagePtr | 0;\n\n        var v = 0,\n            u = 0,\n            sum = 0,\n            yStart1 = 0,\n            yStart2 = 0,\n            xStart1 = 0,\n            xStart2 = 0,\n            offset = 0;\n\n        for (v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) {\n            offset = (offset + size) | 0;\n            for (u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) {\n                yStart1 = (offset - size) | 0;\n                yStart2 = (offset + size) | 0;\n                xStart1 = (u - 1) | 0;\n                xStart2 = (u + 1) | 0;\n                sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0)\n                    + (images[(inImagePtr + offset + u) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0)\n                    + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0;\n                if ((sum | 0) > (0 | 0)) {\n                    images[(outImagePtr + offset + u) | 0] = 1;\n                } else {\n                    images[(outImagePtr + offset + u) | 0] = 0;\n                }\n            }\n        }\n        return;\n    }\n\n    function memcpy(srcImagePtr, dstImagePtr) {\n        srcImagePtr = srcImagePtr | 0;\n        dstImagePtr = dstImagePtr | 0;\n\n        var length = 0;\n\n        length = imul(size, size) | 0;\n\n        while ((length | 0) > 0) {\n            length = (length - 1) | 0;\n            images[(dstImagePtr + length) | 0] = (images[(srcImagePtr + length) | 0] | 0);\n        }\n    }\n\n    function zeroBorder(imagePtr) {\n        imagePtr = imagePtr | 0;\n\n        var x = 0,\n            y = 0;\n\n        for (x = 0; (x | 0) < ((size - 1) | 0); x = (x + 1) | 0) {\n            images[(imagePtr + x) | 0] = 0;\n            images[(imagePtr + y) | 0] = 0;\n            y = ((y + size) - 1) | 0;\n            images[(imagePtr + y) | 0] = 0;\n            y = (y + 1) | 0;\n        }\n        for (x = 0; (x | 0) < (size | 0); x = (x + 1) | 0) {\n            images[(imagePtr + y) | 0] = 0;\n            y = (y + 1) | 0;\n        }\n    }\n\n    function skeletonize() {\n        var subImagePtr = 0,\n            erodedImagePtr = 0,\n            tempImagePtr = 0,\n            skelImagePtr = 0,\n            sum = 0,\n            done = 0;\n\n        erodedImagePtr = imul(size, size) | 0;\n        tempImagePtr = (erodedImagePtr + erodedImagePtr) | 0;\n        skelImagePtr = (tempImagePtr + erodedImagePtr) | 0;\n\n        // init skel-image\n        init(skelImagePtr, 0);\n        zeroBorder(subImagePtr);\n\n        do {\n            erode(subImagePtr, erodedImagePtr);\n            dilate(erodedImagePtr, tempImagePtr);\n            subtract(subImagePtr, tempImagePtr, tempImagePtr);\n            bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr);\n            memcpy(erodedImagePtr, subImagePtr);\n            sum = countNonZero(subImagePtr) | 0;\n            done = ((sum | 0) == 0 | 0);\n        } while (!done);\n    }\n\n    return {\n        skeletonize: skeletonize\n    };\n}\nexport default Skeletonizer;\n/* eslint-enable eqeqeq */\n","import _polyfills from './common/polyfills';\nimport { ResultCollector } from './analytics/result-collector';\nimport { Box } from './common/box';\nimport { EventCallback, Events, EventSubscription } from './common/events';\nimport { ImageDebug } from './common/image-debug';\nimport { ImageWrapper } from './common/image-wrapper';\nimport { merge } from './common/merge';\nimport { Point } from './common/point';\nimport { config as defaultConfig, QuaggaConfig } from './config/config';\nimport { BarcodeDecoder, QuaggaBarcode } from './decoder/barcode-decoder';\nimport { CameraAccess } from './input/camera-access';\nimport { FrameGrabber } from './input/frame-grabber';\nimport { ImageStream } from './input/image-stream';\nimport { InputStream } from './input/input-stream';\nimport { LiveStream } from './input/live-stream';\nimport { VideoStream } from './input/video-stream';\nimport { checkImageConstraints } from './input/input-stream-utils';\nimport { BarcodeLocator } from './locator/barcode-locator';\nimport { BarcodeReaderDeclaration } from './reader/barcode-reader';\n\ninterface WorkerThread {\n    worker: Worker;\n    imageData: Uint8Array;\n    busy: boolean;\n}\n\nexport interface QuaggaCanvasContainer {\n    ctx: {\n        image: CanvasRenderingContext2D,\n        overlay: CanvasRenderingContext2D\n    },\n    dom: {\n        image: HTMLCanvasElement,\n        overlay: HTMLCanvasElement\n    }\n}\n\nlet _inputStream: InputStream;\nlet _frameGrabber: FrameGrabber;\nlet _stopped: boolean;\nconst _canvasContainer: QuaggaCanvasContainer = {\n    ctx: {\n        image: null,\n        overlay: null\n    },\n    dom: {\n        image: null,\n        overlay: null\n    }\n};\nlet _inputImageWrapper: ImageWrapper;\nlet _locator: BarcodeLocator;\nlet _boxSize: Box;\nlet _decoder: BarcodeDecoder;\nlet _workerPool = new Array<WorkerThread>();\nlet _onUIThread: boolean;\nlet _resultCollector: ResultCollector;\nlet _config: QuaggaConfig;\n\nexport default {\n    init(config: QuaggaConfig, cb: () => void, imageWrapper?: ImageWrapper) {\n        _onUIThread = true;\n        _config = merge(defaultConfig, config);\n        if (imageWrapper) {\n            _onUIThread = false;\n            _initializeData(imageWrapper);\n            cb();\n        } else {\n            _initInputStream(cb);\n        }\n    },\n\n    CameraAccess: CameraAccess,\n\n    ImageDebug: ImageDebug,\n\n    ImageWrapper: ImageWrapper,\n\n    ResultCollector: ResultCollector,\n\n    get canvas(): QuaggaCanvasContainer {\n        return _canvasContainer;\n    },\n\n    start(): void {\n        if (_onUIThread && _config.inputStream.type === 'LiveStream') {\n            _startContinuousUpdate();\n        } else {\n            _update();\n        }\n    },\n\n    stop(): void {\n        _stopped = true;\n        _adjustWorkerPool(0);\n        if (_config.inputStream.type === 'LiveStream') {\n            CameraAccess.release();\n            _inputStream.clearEventHandlers();\n        }\n    },\n\n    decodeSingle(config: QuaggaConfig, resultCallback: (_: QuaggaBarcode) => void): void {\n        config = merge({\n            inputStream: {\n                type: 'ImageStream',\n                sequence: false,\n                size: 800,\n                src: config.src\n            },\n            numOfWorkers: (process.env.NODE_ENV !== 'production' && config.debug) ? 0 : 1,\n            locator: {\n                halfSample: false\n            }\n        }, config);\n\n        this.init(config, () => {\n            Events.once('processed', (result: QuaggaBarcode) => {\n                this.stop();\n                resultCallback.call(null, result);\n            }, true);\n            this.start();\n        });\n    },\n\n    pause(): void {\n        _stopped = true;\n    },\n\n    onDetected(callback: EventSubscription | EventCallback): void {\n        Events.subscribe('detected', callback);\n    },\n\n    offDetected(callback: EventCallback): void {\n        Events.unsubscribe('detected', callback);\n    },\n\n    onProcessed(callback: EventSubscription | EventCallback): void {\n        Events.subscribe('processed', callback);\n    },\n\n    offProcessed(callback: EventCallback): void {\n        Events.unsubscribe('processed', callback);\n    },\n\n    setReaders(readers: Array<BarcodeReaderDeclaration>): void {\n        if (_decoder) {\n            _decoder.setReaders(readers);\n        } else if (_onUIThread && _workerPool.length > 0) {\n            _workerPool.forEach(({ worker }) => worker.postMessage({ cmd: 'setReaders', readers }));\n        }\n    },\n\n    registerResultCollector(resultCollector: ResultCollector): void {\n        if (resultCollector && typeof resultCollector.addResult === 'function') {\n            _resultCollector = resultCollector;\n        }\n    }\n};\n\nfunction _initializeData(imageWrapper?: ImageWrapper): void {\n    _initBuffers(imageWrapper);\n    _decoder = new BarcodeDecoder(_config.decoder, _inputImageWrapper);\n}\n\nfunction _initInputStream(callback: (err?: any) => void): void {\n    let video: HTMLVideoElement;\n    if (_config.inputStream.type === 'VideoStream') {\n        video = document.createElement('video');\n        _inputStream = new VideoStream(video);\n    } else if (_config.inputStream.type === 'ImageStream') {\n        _inputStream = new ImageStream();\n    } else if (_config.inputStream.type === 'LiveStream') {\n        const viewport = _getViewPort();\n        if (viewport) {\n            video = viewport.querySelector('video');\n            if (!video) {\n                video = document.createElement('video');\n                viewport.appendChild(video);\n            }\n        }\n        _inputStream = new LiveStream(video);\n        CameraAccess.request(video, _config.inputStream.constraints)\n            .then(() => _inputStream.trigger('canrecord'), err => callback(err));\n    }\n\n    _inputStream.setAttribute('preload', 'auto');\n    _inputStream.config = _config.inputStream;\n    _inputStream.addEventListener('canrecord', _canRecord.bind(this, callback));\n}\n\nfunction _getViewPort(): HTMLElement {\n    const target = _config.inputStream.target;\n    // Check if target is already a DOM element\n    if (target instanceof HTMLElement) {\n        return target;\n    } else {\n        // Use '#interactive.viewport' as a fallback selector (backwards compatibility)\n        const selector = typeof target === 'string' ? target : '#interactive.viewport';\n        return document.querySelector(selector);\n    }\n}\n\nfunction _canRecord(cb: () => void): void {\n    checkImageConstraints(_inputStream, _config.locator);\n    _initCanvas();\n    _frameGrabber = new FrameGrabber(_inputStream, _canvasContainer.dom.image);\n\n    _adjustWorkerPool(_config.numOfWorkers, () => {\n        if (_config.numOfWorkers === 0) {\n            _initializeData();\n        }\n\n        _inputStream.play();\n        cb();\n    });\n}\n\nfunction _initCanvas(): void {\n    if (typeof document !== 'undefined') {\n        const viewport = _getViewPort();\n        _canvasContainer.dom.image = document.querySelector('canvas.imgBuffer');\n        if (!_canvasContainer.dom.image) {\n            _canvasContainer.dom.image = document.createElement('canvas');\n            _canvasContainer.dom.image.className = 'imgBuffer';\n            if (viewport && _config.inputStream.type === 'ImageStream') {\n                viewport.appendChild(_canvasContainer.dom.image);\n            }\n        }\n        _canvasContainer.ctx.image = _canvasContainer.dom.image.getContext('2d');\n        _canvasContainer.dom.image.width = _inputStream.canvasWidth;\n        _canvasContainer.dom.image.height = _inputStream.canvasHeight;\n\n        _canvasContainer.dom.overlay = document.querySelector('canvas.drawingBuffer');\n        if (!_canvasContainer.dom.overlay) {\n            _canvasContainer.dom.overlay = document.createElement('canvas');\n            _canvasContainer.dom.overlay.className = 'drawingBuffer';\n            if (viewport) {\n                viewport.appendChild(_canvasContainer.dom.overlay);\n            }\n            const clearFix = document.createElement('br');\n            clearFix.setAttribute('clear', 'all');\n            if (viewport) {\n                viewport.appendChild(clearFix);\n            }\n        }\n        _canvasContainer.ctx.overlay = _canvasContainer.dom.overlay.getContext('2d');\n        _canvasContainer.dom.overlay.width = _inputStream.canvasWidth;\n        _canvasContainer.dom.overlay.height = _inputStream.canvasHeight;\n    }\n}\n\nfunction _initBuffers(imageWrapper?: ImageWrapper): void {\n    if (imageWrapper) {\n        _inputImageWrapper = imageWrapper;\n    } else {\n        _inputImageWrapper = new ImageWrapper({\n            x: _inputStream.width,\n            y: _inputStream.height\n        });\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n        console.log(_inputImageWrapper.size);\n    }\n    _boxSize = [\n        { x: 0, y: 0 },\n        { x: 0, y: _inputImageWrapper.size.y },\n        { x: _inputImageWrapper.size.x, y: _inputImageWrapper.size.y },\n        { x: _inputImageWrapper.size.x, y: 0 }\n    ];\n    _locator = new BarcodeLocator(_inputImageWrapper, _config.locator);\n}\n\nfunction _transform(polygon: ReadonlyArray<Point>, offset: Point): void {\n    polygon.forEach(vertex => {\n        vertex.x += offset.x;\n        vertex.y += offset.y;\n    })\n}\n\nfunction _transformResult(result: QuaggaBarcode, offset: Point): void {\n    if (result.barcodes) {\n        result.barcodes.forEach(barcode => _transformResult(barcode, offset));\n    }\n\n    if (result.line) {\n        _transform(result.line, offset);\n    }\n\n    if (result.box) {\n        _transform(result.box, offset);\n    }\n\n    if (result.boxes) {\n        result.boxes.forEach(box => _transform(box, offset));\n    }\n}\n\nfunction _addResult(result: QuaggaBarcode, imageData: Uint8Array, canvasWidth: number, canvasHeight: number): void {\n    if (imageData && _resultCollector) {\n        if (result.barcodes) {\n            result.barcodes.forEach(({ codeResult }) => {\n                if (codeResult) {\n                    _resultCollector.addResult(imageData, canvasWidth, canvasHeight, codeResult)\n                }\n            });\n        } else if (result.codeResult) {\n            _resultCollector.addResult(imageData, canvasWidth, canvasHeight, result.codeResult);\n        }\n    }\n}\n\nfunction _hasCodeResult(result: QuaggaBarcode): boolean {\n    return result && (!!result.codeResult || result.barcodes && result.barcodes.some(barcode => !!barcode.codeResult));\n}\n\nfunction _publishResult(result?: QuaggaBarcode, imageData?: Uint8Array): void {\n    let resultToPublish: QuaggaBarcode | Array<QuaggaBarcode> = result;\n\n    if (result && _onUIThread) {\n        const offset = _inputStream.topLeft;\n\n        if (offset.x !== 0 || offset.y !== 0) {\n            _transformResult(result, offset);\n        }\n\n        _addResult(result, imageData, _inputStream.canvasWidth, _inputStream.canvasHeight);\n        resultToPublish = result.barcodes || result;\n    }\n\n    Events.publish('processed', resultToPublish);\n    if (_hasCodeResult(result)) {\n        Events.publish('detected', resultToPublish);\n    }\n}\n\nfunction _locateAndDecode(): void {\n    const boxes = _config.locate ? _locator.locate() : [_boxSize];\n    const result = _decoder.decodeFromBoundingBoxes(boxes);\n    _publishResult(result, _inputImageWrapper.data);\n}\n\nfunction _update(): void {\n    if (_onUIThread) {\n        if (_workerPool.length > 0) {\n            const availableWorker = _workerPool.find(({ busy }) => !busy);\n            if (!availableWorker) {\n                return; // all workers are busy\n            }\n\n            const imageData = availableWorker.imageData;\n\n            if (_frameGrabber.grab(imageData)) {\n                availableWorker.busy = true;\n                availableWorker.worker.postMessage({ cmd: 'process', imageData }, [imageData.buffer]);\n            }\n        } else if (_frameGrabber.grab(_inputImageWrapper.data)) {\n            _locateAndDecode();\n        }\n    } else {\n        _locateAndDecode();\n    }\n}\n\nfunction _startContinuousUpdate(): void {\n    const delay = 1000 / (_config.frequency || 60);\n    let next = null;\n    _stopped = false;\n\n    (function frame(timestamp): void {\n        next = next || timestamp;\n        if (!_stopped) {\n            if (timestamp >= next) {\n                next += delay;\n                _update();\n            }\n            window.requestAnimationFrame(frame);\n        }\n    }(performance.now()));\n}\n\nfunction _initWorker(cb: (workerThread: WorkerThread) => void): void {\n    const blobURL = _generateWorkerBlob();\n    const workerThread = {\n        worker: new Worker(blobURL),\n        imageData: new Uint8Array(_inputStream.width * _inputStream.height),\n        busy: true\n    };\n\n    workerThread.worker.onmessage = ({ data }) => {\n        if (data.event === 'initialized') {\n            URL.revokeObjectURL(blobURL);\n            workerThread.busy = false;\n            workerThread.imageData = new Uint8Array(data.imageData);\n            if (process.env.NODE_ENV !== 'production') {\n                console.log('Worker initialized');\n            }\n            cb(workerThread);\n        } else if (data.event === 'processed') {\n            workerThread.busy = false;\n            workerThread.imageData = new Uint8Array(data.imageData);\n            _publishResult(data.result, workerThread.imageData);\n        } else if (data.event === 'error') {\n            if (process.env.NODE_ENV !== 'production') {\n                console.log('Worker error:', data.message);\n            }\n        }\n    };\n\n    workerThread.worker.postMessage({\n        cmd: 'init',\n        size: { x: _inputStream.width, y: _inputStream.height },\n        imageData: workerThread.imageData,\n        config: merge(_config, { inputStream: { target: null } })\n    }, [workerThread.imageData.buffer]);\n}\n\nfunction _workerInterface(factory: Function): void {\n    let Quagga: any;\n    const worker: any = self;\n    let imageWrapper: ImageWrapper;\n\n    if (factory) {\n        Quagga = factory().default;\n        if (!Quagga) {\n            worker.postMessage({ event: 'error', message: 'Quagga could not be created' });\n            return;\n        }\n    }\n\n    self.onmessage = ({ data }) => {\n        if (data.cmd === 'init') {\n            const config: QuaggaConfig = data.config;\n            config.numOfWorkers = 0;\n            imageWrapper = new Quagga.ImageWrapper({ x: data.size.x, y: data.size.y }, new Uint8Array(data.imageData));\n            Quagga.init(\n                config,\n                () => worker.postMessage(\n                    { event: 'initialized', imageData: imageWrapper.data }, [imageWrapper.data.buffer]\n                ),\n                imageWrapper\n            );\n            Quagga.onProcessed((result: QuaggaBarcode) =>\n                worker.postMessage(\n                    { event: 'processed', imageData: imageWrapper.data, result }, [imageWrapper.data.buffer]\n                )\n            );\n        } else if (data.cmd === 'process') {\n            imageWrapper.data = new Uint8Array(data.imageData);\n            Quagga.start();\n        } else if (data.cmd === 'setReaders') {\n            Quagga.setReaders(data.readers);\n        }\n    };\n}\n\nfunction _generateWorkerBlob(): string {\n    // @ts-ignore\n    let factorySource: string = __factorySource__ || '';\n    const blob = new Blob([`(${_workerInterface.toString()})(${factorySource});`], { type: 'text/javascript' });\n\n    return window.URL.createObjectURL(blob);\n}\n\nfunction _adjustWorkerPool(capacity: number, cb?: () => void): void {\n    const increaseBy = capacity - _workerPool.length;\n\n    if (increaseBy > 0) {\n        for (let i = 0; i < increaseBy; i++) {\n            _initWorker(workerThread => {\n                _workerPool.push(workerThread);\n                if (_workerPool.length >= capacity && cb) {\n                    cb();\n                }\n            });\n        }\n    } else {\n        if (increaseBy < 0) {\n            _workerPool.slice(increaseBy).forEach(({ worker }) => {\n                worker.terminate();\n                if (process.env.NODE_ENV !== 'production') {\n                    console.log('Worker terminated!');\n                }\n            });\n            _workerPool = _workerPool.slice(0, increaseBy);\n        }\n        return cb && cb();\n    }\n}\n","import { Box } from '../common/box';\nimport { Cluster } from '../common/cluster';\nimport { HSV, hsv2rgb, RGB } from '../common/hsv2rgb';\nimport { ImageDebug } from '../common/image-debug';\nimport { ImageWrapper } from '../common/image-wrapper';\nimport { Moment } from '../common/moment';\nimport { Point } from '../common/point';\nimport { calculatePatchSize } from '../input/input-stream-utils';\nimport { BarcodeLocatorConfig } from './barcode-locator-config';\nimport { halfSample, invert, otsuThreshold, transformWithMatrix } from './barcode-locator-utils';\nimport { Rasterizer } from './rasterizer';\nimport skeletonizer from './skeletonizer';\nimport { SearchDirections } from './tracer';\n\ninterface Patch {\n    box: Box;\n    index: number;\n    moments: Array<Moment>;\n    pos: Point;\n    rad: number;\n    x: number;\n    y: number;\n}\n\ntype Sceletonizer = any;\n\nconst MomentSimilarityThreshold = 0.9;\n\nexport class BarcodeLocator {\n    private _config: BarcodeLocatorConfig;\n    private _inputImageWrapper: ImageWrapper;\n    private _currentImageWrapper: ImageWrapper;\n    private _skelImageWrapper: ImageWrapper;\n    private _subImageWrapper: ImageWrapper;\n    private _labelImageWrapper: ImageWrapper<Array<number>>;\n    private _binaryImageWrapper: ImageWrapper;\n    private _patchGrid: ImageWrapper;\n    private _patchLabelGrid: ImageWrapper<Int32Array>;\n    private _imageToPatchGrid: Array<Patch>;\n    private _patchSize: Point;\n    private _binaryContext: CanvasRenderingContext2D;\n    private _numPatches: Point;\n    private _skeletonizer: Sceletonizer;\n\n    constructor(inputImageWrapper: ImageWrapper, config: BarcodeLocatorConfig) {\n        this._config = config;\n        this._inputImageWrapper = inputImageWrapper;\n        this._numPatches = { x: 0, y: 0 };\n\n        this._initBuffers();\n        this._initCanvas();\n    }\n\n    locate() {\n        if (this._config.halfSample) {\n            halfSample(this._inputImageWrapper, this._currentImageWrapper);\n        }\n\n        this._binarizeImage();\n        const patchesFound = this._findPatches();\n        // return unless 5% or more patches are found\n        if (patchesFound.length < this._numPatches.x * this._numPatches.y * 0.05) {\n            return null;\n        }\n\n        // rasterize area by comparing angular similarity;\n        const maxLabel = this._rasterizeAngularSimilarity(patchesFound);\n        if (maxLabel < 1) {\n            return null;\n        }\n\n        // search for area with the most patches (biggest connected area)\n        const topLabels = this._findBiggestConnectedAreas(maxLabel);\n        if (topLabels.length === 0) {\n            return null;\n        }\n\n        const boxes = this._findBoxes(topLabels, maxLabel);\n        return boxes;\n    }\n\n    private _initBuffers(): void {\n        if (this._config.halfSample) {\n            this._currentImageWrapper = new ImageWrapper({\n                x: this._inputImageWrapper.size.x / 2 | 0,\n                y: this._inputImageWrapper.size.y / 2 | 0\n            });\n        } else {\n            this._currentImageWrapper = this._inputImageWrapper;\n        }\n\n        this._patchSize = calculatePatchSize(this._config.patchSize, this._currentImageWrapper.size);\n\n        this._numPatches.x = this._currentImageWrapper.size.x / this._patchSize.x | 0;\n        this._numPatches.y = this._currentImageWrapper.size.y / this._patchSize.y | 0;\n\n        this._binaryImageWrapper = new ImageWrapper(this._currentImageWrapper.size, undefined, Uint8Array, false);\n\n        this._labelImageWrapper = new ImageWrapper(this._patchSize, undefined, Array, true);\n\n        const skeletonImageData = new ArrayBuffer(64 * 1024);\n        this._subImageWrapper = new ImageWrapper(this._patchSize, new Uint8Array(skeletonImageData, 0, this._patchSize.x * this._patchSize.y));\n        this._skelImageWrapper = new ImageWrapper(this._patchSize,\n            new Uint8Array(skeletonImageData, this._patchSize.x * this._patchSize.y * 3, this._patchSize.x * this._patchSize.y),\n            undefined, true);\n        this._skeletonizer = skeletonizer(\n            (typeof window !== 'undefined') ? window : (typeof self !== 'undefined') ? self : global,\n            { size: this._patchSize.x },\n            skeletonImageData\n        );\n\n        const size = {\n            x: (this._currentImageWrapper.size.x / this._subImageWrapper.size.x) | 0,\n            y: (this._currentImageWrapper.size.y / this._subImageWrapper.size.y) | 0\n        };\n        this._patchLabelGrid = new ImageWrapper(size, undefined, Int32Array, true);\n        this._patchGrid = new ImageWrapper(size, undefined, undefined, true);\n        this._imageToPatchGrid = new Array<Patch>(this._patchLabelGrid.data.length);\n    }\n\n    private _initCanvas() {\n        if (this._config.useWorker || typeof document === 'undefined') {\n            return;\n        }\n\n        const canvas = document.createElement('canvas');\n        canvas.className = 'binaryBuffer';\n        canvas.width = this._binaryImageWrapper.size.x;\n        canvas.height = this._binaryImageWrapper.size.y;\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && this._config.debug.showCanvas) {\n            document.querySelector('#debug').appendChild(canvas);\n        }\n        this._binaryContext = canvas.getContext('2d');\n    }\n\n    /**\n     * Creates a bounding box which encloses all the given patches\n     * @returns The minimal bounding box\n     */\n    private _boxFromPatches(patches: Array<Patch>): Box {\n        const debug = process.env.NODE_ENV !== 'production' && this._config.debug;\n        let averageRad = patches.reduce((sum, { pos, rad }) => {\n            if (debug && debug.showPatches) {\n                // draw all patches which are to be taken into consideration\n                this._drawRect(pos, this._subImageWrapper.size, 'red', 1);\n            }\n\n            return sum + rad;\n        }, 0) / patches.length;\n\n        averageRad = (averageRad * 180 / Math.PI + 90) % 180 - 90;\n        if (averageRad < 0) {\n            averageRad += 180;\n        }\n        averageRad = (180 - averageRad) * Math.PI / 180;\n\n        const cos = Math.cos(averageRad);\n        const sin = Math.sin(averageRad);\n        const matrix = new Float32Array([cos, sin, -sin, cos]);\n        const inverseMatrix = invert(matrix);\n\n        // iterate over patches and rotate by angle\n        patches.forEach(({ box }) => {\n            for (let j = 0; j < 4; j++) {\n                box[j] = transformWithMatrix(box[j], matrix);\n            }\n\n            if (debug && debug.boxFromPatches.showTransformed) {\n                this._drawPath(box, '#99ff00', 2);\n            }\n        });\n\n        let minX = this._binaryImageWrapper.size.x;\n        let minY = this._binaryImageWrapper.size.y;\n        let maxX = -minX;\n        let maxY = -minY;\n\n        // find bounding box\n        patches.forEach(({ box }) => {\n            box.forEach(({ x, y }) => {\n                if (x < minX) {\n                    minX = x;\n                }\n                if (x > maxX) {\n                    maxX = x;\n                }\n                if (y < minY) {\n                    minY = y;\n                }\n                if (y > maxY) {\n                    maxY = y;\n                }\n            });\n        });\n\n        let box: Box = [{ x: minX, y: minY }, { x: maxX, y: minY }, { x: maxX, y: maxY }, { x: minX, y: maxY }];\n\n        if (debug && debug.boxFromPatches.showTransformedBox) {\n            this._drawPath(box, '#ff0000', 2);\n        }\n\n        // reverse rotation\n        box = box.map(vertex => transformWithMatrix(vertex, inverseMatrix)) as Box;\n\n        if (debug && debug.boxFromPatches.showBB) {\n            this._drawPath(box, '#ff0000', 2);\n        }\n\n        if (this._config.halfSample) {\n            // scale\n            box = box.map(({ x, y }) => ({ x: x * 2, y: y *= 2 })) as Box;\n        }\n\n        return box;\n    }\n\n    /**\n     * Creates a binary image of the current image\n     */\n    private _binarizeImage(): void {\n        otsuThreshold(this._currentImageWrapper, this._binaryImageWrapper);\n        this._binaryImageWrapper.zeroBorder();\n\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && this._config.debug.showCanvas) {\n            this._binaryImageWrapper.show(this._binaryContext, 255);\n        }\n    }\n\n    /**\n     * Iterate over the entire image, extract patches\n     */\n    private _findPatches(): Array<Patch> {\n        const debug = process.env.NODE_ENV !== 'production' && this._config.debug;\n        let patchesFound = new Array<Patch>();\n\n        for (let i = 0; i < this._numPatches.x; i++) {\n            for (let j = 0; j < this._numPatches.y; j++) {\n                const x = this._subImageWrapper.size.x * i;\n                const y = this._subImageWrapper.size.y * j;\n\n                // seperate parts\n                this._skeletonize(x, y);\n\n                // Rasterize, find individual bars\n                this._skelImageWrapper.zeroBorder();\n                this._labelImageWrapper.data.fill(0);\n                const rasterizer = new Rasterizer(this._skelImageWrapper, this._labelImageWrapper);\n                const rasterResult = rasterizer.rasterize(0);\n\n                if (debug && debug.showLabels) {\n                    this._labelImageWrapper.overlay(this._binaryContext, 360 / rasterResult.count | 0, x, y);\n                }\n\n                // calculate moments from the skeletonized patch\n                const moments = this._labelImageWrapper.moments(rasterResult.count);\n\n                // extract eligible patches\n                const patch = this._describePatch(moments, j * this._numPatches.x + i, x, y);\n                if (patch) {\n                    patchesFound.push(patch);\n\n                    if (debug && debug.showFoundPatches) {\n                        this._drawRect(patch.pos, this._subImageWrapper.size, '#99ff00', 2);\n                    }\n                }\n            }\n        }\n\n        return patchesFound;\n    }\n\n    /**\n     * Finds those connected areas which contain at least 6 patches\n     * and returns them ordered DESC by the number of contained patches\n     * @param maxLabel\n     */\n    private _findBiggestConnectedAreas(maxLabel: number): Array<number> {\n        let labelHist = new Array<number>(maxLabel).fill(0);\n\n        this._patchLabelGrid.data.forEach((data: number) => {\n            if (data > 0) {\n                labelHist[data - 1]++;\n            }\n        });\n\n        // extract top areas with at least 6 patches present\n        const topLabels = labelHist.map((value, index) => ({ value, index }))\n            .filter(({ value }) => value >= 5).sort((a, b) => b.value - a.value).map(({ index }) => index + 1);\n\n        return topLabels;\n    }\n\n    /**\n     *\n     */\n    private _findBoxes(topLabels: Array<number>, maxLabel: number): Array<Box> {\n        const boxes = new Array<Box>();\n        const showRemainingPatchLabels = process.env.NODE_ENV !== 'production' &&\n            this._config.debug && this._config.debug.showRemainingPatchLabels;\n\n        topLabels.forEach(label => {\n            const patches = new Array<Patch>();\n\n            this._patchLabelGrid.data.forEach((data: number, index: number) => {\n                if (data === label) {\n                    patches.push(this._imageToPatchGrid[index]);\n                }\n            });\n\n            const box = this._boxFromPatches(patches);\n\n            if (box) {\n                boxes.push(box);\n\n                if (showRemainingPatchLabels) {\n                    // draw patch-labels if requested\n                    const hsv: HSV = [(label / (maxLabel + 1)) * 360, 1, 1];\n                    const rgb: RGB = [0, 0, 0];\n                    hsv2rgb(hsv, rgb);\n\n                    const color = `rgb(${rgb.join(',')})`;\n\n                    patches.forEach(({ pos }) => this._drawRect(pos, this._subImageWrapper.size, color, 2));\n                }\n            }\n        });\n\n        return boxes;\n    }\n\n    /**\n     * Find similar moments (via cluster)\n     * @param moments\n     */\n    private _similarMoments(moments: Array<Moment>): Array<Moment> {\n        const clusters = Cluster.clusterize(moments, MomentSimilarityThreshold);\n        const topCluster = clusters.reduce((top, item) => {\n            const count = item.moments.length;\n            return count > top.count ? { item, count } : top;\n        }, { item: { moments: [] }, count: 0 });\n        const result = topCluster.item.moments;\n\n        return result;\n    }\n\n    private _skeletonize(x: number, y: number): void {\n        this._binaryImageWrapper.subImageAsCopy(this._subImageWrapper, x, y);\n        this._skeletonizer.skeletonize();\n\n        // Show skeleton if requested\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && this._config.debug.showSkeleton) {\n            this._skelImageWrapper.overlay(this._binaryContext, 360, x, y);\n        }\n    }\n\n    /**\n     * Extracts and describes those patches which seem to contain a barcode pattern\n     * @param moments\n     * @param index\n     * @param x\n     * @param y\n     * @returns list of patches\n     */\n    private _describePatch(moments: Array<Moment>, index: number, x: number, y: number): Patch {\n        if (moments.length > 1) {\n            const minComponentWeight = Math.ceil(this._patchSize.x / 3);\n            // only collect moments which area covers at least minComponentWeight pixels\n            const eligibleMoments = moments.filter(moment => moment.m00 > minComponentWeight);\n\n            // if at least 2 moments are found which have at least minComponentWeights covered\n            if (eligibleMoments.length > 1) {\n                const matchingMoments = this._similarMoments(eligibleMoments);\n                const length = matchingMoments.length | 0;\n\n                // Only two of the moments are allowed not to fit into the equation\n                if (length > 1 && (length << 2) >= eligibleMoments.length * 3 && (length << 2) > moments.length) {\n                    // determine the similarity of the moments\n                    const rad = matchingMoments.reduce((sum: number, moment: Moment) => sum + moment.rad, 0) / length;\n\n                    return {\n                        index,\n                        pos: { x, y },\n                        box: [\n                            { x, y },\n                            { x: x + this._subImageWrapper.size.x, y },\n                            { x: x + this._subImageWrapper.size.x, y: y + this._subImageWrapper.size.y },\n                            { x, y: y + this._subImageWrapper.size.y }\n                        ],\n                        moments: matchingMoments,\n                        rad,\n                        x: Math.cos(rad),\n                        y: Math.sin(rad)\n                    };\n                }\n            }\n        }\n\n        return null;\n    }\n\n    private _notYetProcessed(): number {\n        for (let i = 0; i < this._patchLabelGrid.data.length; i++) {\n            if (this._patchLabelGrid.data[i] === 0 && this._patchGrid.data[i] === 1) {\n                return i;\n            }\n        }\n        return this._patchLabelGrid.data.length;\n    }\n\n    private _trace(currentIndex: number, label: number): void {\n        const threshold = 0.95;\n        const current: Point = {\n            x: currentIndex % this._patchLabelGrid.size.x,\n            y: (currentIndex / this._patchLabelGrid.size.x) | 0\n        };\n\n        if (currentIndex < this._patchLabelGrid.data.length) {\n            const currentPatch = this._imageToPatchGrid[currentIndex];\n            // assign label\n            this._patchLabelGrid.data[currentIndex] = label;\n\n            SearchDirections.forEach(direction => {\n                const y = current.y + direction[0];\n                const x = current.x + direction[1];\n                const index = y * this._patchLabelGrid.size.x + x;\n\n                // continue if patch empty\n                if (this._patchGrid.data[index] === 0) {\n                    this._patchLabelGrid.data[index] = Number.MAX_VALUE;\n                } else if (this._patchLabelGrid.data[index] === 0) {\n                    const patch = this._imageToPatchGrid[index];\n                    const similarity = Math.abs(patch.x * currentPatch.x + patch.y * currentPatch.y);\n                    if (similarity > threshold) {\n                        this._trace(index, label);\n                    }\n                }\n            });\n        }\n    }\n\n    /**\n     * Finds patches which are connected and share the same orientation\n     * @param patchesFound\n     */\n    private _rasterizeAngularSimilarity(patchesFound: Array<Patch>): number {\n        let label = 0;\n        const hsv: HSV = [0, 1, 1];\n        const rgb: RGB = [0, 0, 0];\n\n        // prepare for finding the right patches\n        this._patchGrid.data.fill(0);\n        this._patchLabelGrid.data.fill(0);\n        this._imageToPatchGrid.fill(null);\n\n        patchesFound.forEach(patch => {\n            this._imageToPatchGrid[patch.index] = patch;\n            this._patchGrid.data[patch.index] = 1;\n        });\n\n        // rasterize the patches found to determine area\n        this._patchGrid.zeroBorder();\n\n        let currentIndex = 0;\n        while ((currentIndex = this._notYetProcessed()) < this._patchLabelGrid.data.length) {\n            label++;\n            this._trace(currentIndex, label);\n        }\n\n        // draw patch-labels if requested\n        if (process.env.NODE_ENV !== 'production' && this._config.debug && this._config.debug.showPatchLabels) {\n            for (let j = 0; j < this._patchLabelGrid.data.length; j++) {\n                if (this._patchLabelGrid.data[j] > 0 && this._patchLabelGrid.data[j] <= label) {\n                    const patch = this._imageToPatchGrid[j];\n                    hsv[0] = (this._patchLabelGrid.data[j] / (label + 1)) * 360;\n                    hsv2rgb(hsv, rgb);\n                    this._drawRect(patch.pos, this._subImageWrapper.size, `rgb(${rgb.join(',')})`, 2);\n                }\n            }\n        }\n\n        return label;\n    }\n\n    private _drawRect({ x, y }: Point, size: Point, color: string, lineWidth: number): void {\n        this._binaryContext.strokeStyle = color;\n        this._binaryContext.fillStyle = color;\n        this._binaryContext.lineWidth = lineWidth || 1;\n        this._binaryContext.strokeRect(x, y, size.x, size.y);\n    }\n\n    private _drawPath(path: Array<Point>, color: string, lineWidth: number): void {\n        ImageDebug.drawPath(path, this._binaryContext, color, lineWidth);\n    }\n}\n"],"sourceRoot":""}
\ No newline at end of file
diff --git a/env/development.js b/env/development.js
deleted file mode 100644
index 2f3a3f5f..00000000
--- a/env/development.js
+++ /dev/null
@@ -1,5 +0,0 @@
-module.exports = {
- production: false,
- development: true,
- node: false
-};
diff --git a/env/node.js b/env/node.js
deleted file mode 100644
index b5f04958..00000000
--- a/env/node.js
+++ /dev/null
@@ -1,5 +0,0 @@
-module.exports = {
- production: true,
- development: false,
- node: true
-};
diff --git a/env/production.js b/env/production.js
deleted file mode 100644
index 08f6692d..00000000
--- a/env/production.js
+++ /dev/null
@@ -1,5 +0,0 @@
-module.exports = {
- production: true,
- development: false,
- node: false
-};
diff --git a/example/camera_example.html b/example/camera_example.html
index 55120795..d4d3a78e 100644
--- a/example/camera_example.html
+++ b/example/camera_example.html
@@ -1,83 +1,82 @@
-
-