https://store.grupobscit.com/web/static/lib/zxing-library/zxing-library.js

1(function (global, factory) {
2  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
3  typeof define === 'function' && define.amd ? define(['exports'], factory) :
4  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ZXing = {}));
5})(this, (function (exports) { 'use strict';
6
7  function fixProto(target, prototype) {
8    var setPrototypeOf = Object.setPrototypeOf;
9    setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
10  }
11  function fixStack(target, fn) {
12    if (fn === void 0) {
13      fn = target.constructor;
14    }
15
16    var captureStackTrace = Error.captureStackTrace;
17    captureStackTrace && captureStackTrace(target, fn);
18  }
19
20  var __extends = function () {
21    var _extendStatics = function extendStatics(d, b) {
22      _extendStatics = Object.setPrototypeOf || {
23        __proto__: []
24      } instanceof Array && function (d, b) {
25        d.__proto__ = b;
26      } || function (d, b) {
27        for (var p in b) {
28          if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
29        }
30      };
31
32      return _extendStatics(d, b);
33    };
34
35    return function (d, b) {
36      if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
37
38      _extendStatics(d, b);
39
40      function __() {
41        this.constructor = d;
42      }
43
44      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
45    };
46  }();
47
48  var CustomError = function (_super) {
49    __extends(CustomError, _super);
50
51    function CustomError(message, options) {
52      var _newTarget = this.constructor;
53
54      var _this = _super.call(this, message, options) || this;
55
56      Object.defineProperty(_this, 'name', {
57        value: _newTarget.name,
58        enumerable: false,
59        configurable: true
60      });
61      fixProto(_this, _newTarget.prototype);
62      fixStack(_this);
63      return _this;
64    }
65
66    return CustomError;
67  }(Error);
68
69  /**
70   * Custom Error class of type Exception.
71   */
72  class Exception extends CustomError {
73      /**
74       * Allows Exception to be constructed directly
75       * with some message and prototype definition.
76       */
77      constructor(message = undefined) {
78          super(message);
79          this.message = message;
80      }
81      getKind() {
82          const ex = this.constructor;
83          return ex.kind;
84      }
85  }
86  /**
87   * It's typed as string so it can be extended and overriden.
88   */
89  Exception.kind = 'Exception';
90
91  /**
92   * Custom Error class of type Exception.
93   */
94  class ArgumentException extends Exception {
95  }
96  ArgumentException.kind = 'ArgumentException';
97
98  /**
99   * Custom Error class of type Exception.
100   */
101  class IllegalArgumentException extends Exception {
102  }
103  IllegalArgumentException.kind = 'IllegalArgumentException';
104
105  /*
106   * Copyright 2009 ZXing authors
107   *
108   * Licensed under the Apache License, Version 2.0 (the "License");
109   * you may not use this file except in compliance with the License.
110   * You may obtain a copy of the License at
111   *
112   *      http://www.apache.org/licenses/LICENSE-2.0
113   *
114   * Unless required by applicable law or agreed to in writing, software
115   * distributed under the License is distributed on an "AS IS" BASIS,
116   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
117   * See the License for the specific language governing permissions and
118   * limitations under the License.
119   */
120  class BinaryBitmap {
121      constructor(binarizer) {
122          this.binarizer = binarizer;
123          if (binarizer === null) {
124              throw new IllegalArgumentException('Binarizer must be non-null.');
125          }
126      }
127      /**
128       * @return The width of the bitmap.
129       */
130      getWidth() {
131          return this.binarizer.getWidth();
132      }
133      /**
134       * @return The height of the bitmap.
135       */
136      getHeight() {
137          return this.binarizer.getHeight();
138      }
139      /**
140       * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
141       * cached data. Callers should assume this method is expensive and call it as seldom as possible.
142       * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
143       *
144       * @param y The row to fetch, which must be in [0, bitmap height)
145       * @param row An optional preallocated array. If null or too small, it will be ignored.
146       *            If used, the Binarizer will call BitArray.clear(). Always use the returned object.
147       * @return The array of bits for this row (true means black).
148       * @throws NotFoundException if row can't be binarized
149       */
150      getBlackRow(y /*int*/, row) {
151          return this.binarizer.getBlackRow(y, row);
152      }
153      /**
154       * Converts a 2D array of luminance data to 1 bit. As above, assume this method is expensive
155       * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
156       * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
157       * fetched using getBlackRow(), so don't mix and match between them.
158       *
159       * @return The 2D array of bits for the image (true means black).
160       * @throws NotFoundException if image can't be binarized to make a matrix
161       */
162      getBlackMatrix() {
163          // The matrix is created on demand the first time it is requested, then cached. There are two
164          // reasons for this:
165          // 1. This work will never be done if the caller only installs 1D Reader objects, or if a
166          //    1D Reader finds a barcode before the 2D Readers run.
167          // 2. This work will only be done once even if the caller installs multiple 2D Readers.
168          if (this.matrix === null || this.matrix === undefined) {
169              this.matrix = this.binarizer.getBlackMatrix();
170          }
171          return this.matrix;
172      }
173      /**
174       * @return Whether this bitmap can be cropped.
175       */
176      isCropSupported() {
177          return this.binarizer.getLuminanceSource().isCropSupported();
178      }
179      /**
180       * Returns a new object with cropped image data. Implementations may keep a reference to the
181       * original data rather than a copy. Only callable if isCropSupported() is true.
182       *
183       * @param left The left coordinate, which must be in [0,getWidth())
184       * @param top The top coordinate, which must be in [0,getHeight())
185       * @param width The width of the rectangle to crop.
186       * @param height The height of the rectangle to crop.
187       * @return A cropped version of this object.
188       */
189      crop(left /*int*/, top /*int*/, width /*int*/, height /*int*/) {
190          const newSource = this.binarizer.getLuminanceSource().crop(left, top, width, height);
191          return new BinaryBitmap(this.binarizer.createBinarizer(newSource));
192      }
193      /**
194       * @return Whether this bitmap supports counter-clockwise rotation.
195       */
196      isRotateSupported() {
197          return this.binarizer.getLuminanceSource().isRotateSupported();
198      }
199      /**
200       * Returns a new object with rotated image data by 90 degrees counterclockwise.
201       * Only callable if {@link #isRotateSupported()} is true.
202       *
203       * @return A rotated version of this object.
204       */
205      rotateCounterClockwise() {
206          const newSource = this.binarizer.getLuminanceSource().rotateCounterClockwise();
207          return new BinaryBitmap(this.binarizer.createBinarizer(newSource));
208      }
209      /**
210       * Returns a new object with rotated image data by 45 degrees counterclockwise.
211       * Only callable if {@link #isRotateSupported()} is true.
212       *
213       * @return A rotated version of this object.
214       */
215      rotateCounterClockwise45() {
216          const newSource = this.binarizer.getLuminanceSource().rotateCounterClockwise45();
217          return new BinaryBitmap(this.binarizer.createBinarizer(newSource));
218      }
219      /*@Override*/
220      toString() {
221          try {
222              return this.getBlackMatrix().toString();
223          }
224          catch (e /*: NotFoundException*/) {
225              return '';
226          }
227      }
228  }
229
230  /**
231   * Custom Error class of type Exception.
232   */
233  class ChecksumException extends Exception {
234      static getChecksumInstance() {
235          return new ChecksumException();
236      }
237  }
238  ChecksumException.kind = 'ChecksumException';
239
240  /*
241   * Copyright 2009 ZXing authors
242   *
243   * Licensed under the Apache License, Version 2.0 (the "License");
244   * you may not use this file except in compliance with the License.
245   * You may obtain a copy of the License at
246   *
247   *      http://www.apache.org/licenses/LICENSE-2.0
248   *
249   * Unless required by applicable law or agreed to in writing, software
250   * distributed under the License is distributed on an "AS IS" BASIS,
251   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
252   * See the License for the specific language governing permissions and
253   * limitations under the License.
254   */
255  /**
256   * This class hierarchy provides a set of methods to convert luminance data to 1 bit data.
257   * It allows the algorithm to vary polymorphically, for example allowing a very expensive
258   * thresholding technique for servers and a fast one for mobile. It also permits the implementation
259   * to vary, e.g. a JNI version for Android and a Java fallback version for other platforms.
260   *
261   * @author [email protected] (Daniel Switkin)
262   */
263  class Binarizer {
264      constructor(source) {
265          this.source = source;
266      }
267      getLuminanceSource() {
268          return this.source;
269      }
270      getWidth() {
271          return this.source.getWidth();
272      }
273      getHeight() {
274          return this.source.getHeight();
275      }
276  }
277
278  class System {
279      // public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
280      /**
281       * Makes a copy of a array.
282       */
283      static arraycopy(src, srcPos, dest, destPos, length) {
284          

286
287          }
288      }
289      /**
290       * Returns the current time in milliseconds.
291       */
292      static currentTimeMillis() {
293          return Date.now();
294      }
295  }
296
297  /**
298   * Custom Error class of type Exception.
299   */
300  class IndexOutOfBoundsException extends Exception {
301  }
302  IndexOutOfBoundsException.kind = 'IndexOutOfBoundsException';
303
304  /**
305   * Custom Error class of type Exception.
306   */
307  class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException {
308      constructor(index = undefined, message = undefined) {
309          super(message);
310          this.index = index;
311          this.message = message;
312      }
313  }
314  ArrayIndexOutOfBoundsException.kind = 'ArrayIndexOutOfBoundsException';
315
316  class Arrays {
317      /**
318       * Assigns the specified int value to each element of the specified array
319       * of ints.
320       *
321       * @param a the array to be filled
322       * @param val the value to be stored in all elements of the array
323       */
324      static fill(a, val) {
325          for (let i = 0, len = a.length; i < len; i++)
326              a[i] = val;
327      }
328      /**
329       * Assigns the specified int value to each element of the specified
330       * range of the specified array of ints.  The range to be filled
331       * extends from index {@code fromIndex}, inclusive, to index
332       * {@code toIndex}, exclusive.  (If {@code fromIndex==toIndex}, the
333       * range to be filled is empty.)
334       *
335       * @param a the array to be filled
336       * @param fromIndex the index of the first element (inclusive) to be
337       *        filled with the specified value
338       * @param toIndex the index of the last element (exclusive) to be
339       *        filled with the specified value
340       * @param val the value to be stored in all elements of the array
341       * @throws IllegalArgumentException if {@code fromIndex > toIndex}
342       * @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
343       *         {@code toIndex > a.length}
344       */
345      static fillWithin(a, fromIndex, toIndex, val) {
346          Arrays.rangeCheck(a.length, fromIndex, toIndex);
347          for (let i = fromIndex; i < toIndex; i++)
348              a[i] = val;
349      }
350      /**
351       * Checks that {@code fromIndex} and {@code toIndex} are in
352       * the range and throws an exception if they aren't.
353       */
354      static rangeCheck(arrayLength, fromIndex, toIndex) {
355          if (fromIndex > toIndex) {
356              throw new IllegalArgumentException('fromIndex(' + fromIndex + ') > toIndex(' + toIndex + ')');
357          }
358          if (fromIndex < 0) {
359              throw new ArrayIndexOutOfBoundsException(fromIndex);
360          }
361          if (toIndex > arrayLength) {
362              throw new ArrayIndexOutOfBoundsException(toIndex);
363          }
364      }
365      static asList(...args) {
366          return args;
367      }
368      static create(rows, cols, value) {
369          let arr = Array.from({ length: rows });
370          return arr.map(x => Array.from({ length: cols }).fill(value));
371      }
372      static createInt32Array(rows, cols, value) {
373          let arr = Array.from({ length: rows });
374          return arr.map(x => Int32Array.from({ length: cols }).fill(value));
375      }
376      static equals(first, second) {
377          if (!first) {
378              return false;
379          }
380          if (!second) {
381              return false;
382          }
383          if (!first.length) {
384              return false;
385          }
386          if (!second.length) {
387              return false;
388          }
389          if (first.length !== second.length) {
390              return false;
391          }
392          for (let i = 0, length = first.length; i < length; i++) {
393              if (first[i] !== second[i]) {
394                  return false;
395              }
396          }
397          return true;
398      }
399      static hashCode(a) {
400          if (a === null) {
401              return 0;
402          }
403          let result = 1;
404          for (const element of a) {
405              result = 31 * result + element;
406          }
407          return result;
408      }
409      static fillUint8Array(a, value) {
410          for (let i = 0; i !== a.length; i++) {
411              a[i] = value;
412          }
413      }
414      static copyOf(original, newLength) {
415          return original.slice(0, newLength);
416      }
417      static copyOfUint8Array(original, newLength) {
418          if (original.length <= newLength) {
419              const newArray = new Uint8Array(newLength);
420              newArray.set(original);
421              return newArray;
422          }
423          return original.slice(0, newLength);
424      }
425      static copyOfRange(original, from, to) {
426          const newLength = to - from;
427          const copy = new Int32Array(newLength);
428          System.arraycopy(original, from, copy, 0, newLength);
429          return copy;
430      }
431      /*
432      * Returns the index of of the element in a sorted array or (-n-1) where n is the insertion point
433      * for the new element.
434      * Parameters:
435      *     ar - A sorted array
436      *     el - An element to search for
437      *     comparator - A comparator function. The function takes two arguments: (a, b) and returns:
438      *        a negative number  if a is less than b;
439      *        0 if a is equal to b;
440      *        a positive number of a is greater than b.
441      * The array may contain duplicate elements. If there are more than one equal elements in the array,
442      * the returned value can be the index of any one of the equal elements.
443      *
444      * http://jsfiddle.net/aryzhov/pkfst550/
445      */
446      static binarySearch(ar, el, comparator) {
447          if (undefined === comparator) {
448              comparator = Arrays.numberComparator;
449          }
450          let m = 0;
451          let n = ar.length - 1;
452          while (m <= n) {
453              const k = (n + m) >> 1;
454              const cmp = comparator(el, ar[k]);
455              if (cmp > 0) {
456                  m = k + 1;
457              }
458              else if (cmp < 0) {
459                  n = k - 1;
460              }
461              else {
462                  return k;
463              }
464          }
465          return -m - 1;
466      }
467      static numberComparator(a, b) {
468          return a - b;
469      }
470  }
471
472  /**
473   * Ponyfill for Java's Integer class.
474   */
475  class Integer {
476      static numberOfTrailingZeros(i) {
477          let y;
478          if (i === 0)
479              return 32;
480          let n = 31;
481          y = i << 16;
482          if (y !== 0) {
483              n -= 16;
484              i = y;
485          }
486          y = i << 8;
487          if (y !== 0) {
488              n -= 8;
489              i = y;
490          }
491          y = i << 4;
492          if (y !== 0) {
493              n -= 4;
494              i = y;
495          }
496          y = i << 2;
497          if (y !== 0) {
498              n -= 2;
499              i = y;
500          }
501          return n - ((i << 1) >>> 31);
502      }
503      static numberOfLeadingZeros(i) {
504          // HD, Figure 5-6
505          if (i === 0) {
506              return 32;
507          }
508          let n = 1;
509          if (i >>> 16 === 0) {
510              n += 16;
511              i <<= 16;
512          }
513          if (i >>> 24 === 0) {
514              n += 8;
515              i <<= 8;
516          }
517          if (i >>> 28 === 0) {
518              n += 4;
519              i <<= 4;
520          }
521          if (i >>> 30 === 0) {
522              n += 2;
523              i <<= 2;
524          }
525          n -= i >>> 31;
526          return n;
527      }
528      static toHexString(i) {
529          return i.toString(16);
530      }
531      static toBinaryString(intNumber) {
532          return String(parseInt(String(intNumber), 2));
533      }
534      // Returns the number of one-bits in the two's complement binary representation of the specified int value. This function is sometimes referred to as the population count.
535      // Returns:
536      // the number of one-bits in the two's complement binary representation of the specified int value.
537      static bitCount(i) {
538          // HD, Figure 5-2
539          i = i - ((i >>> 1) & 0x55555555);
540          i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
541          i = (i + (i >>> 4)) & 0x0f0f0f0f;
542          i = i + (i >>> 8);
543          i = i + (i >>> 16);
544          return i & 0x3f;
545      }
546      static truncDivision(dividend, divisor) {
547          return Math.trunc(dividend / divisor);
548      }
549      /**
550       * Converts A string to an integer.
551       * @param s A string to convert into a number.
552       * @param radix A value between 2 and 36 that specifies the base of the number in numString. If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal. All other strings are considered decimal.
553       */
554      static parseInt(num, radix = undefined) {
555          return parseInt(num, radix);
556      }
557  }
558  Integer.MIN_VALUE_32_BITS = -2147483648;
559  Integer.MAX_VALUE = Number.MAX_SAFE_INTEGER;
560
561  /*
562   * Copyright 2007 ZXing authors
563   *
564   * Licensed under the Apache License, Version 2.0 (the "License");
565   * you may not use this file except in compliance with the License.
566   * You may obtain a copy of the License at
567   *
568   *      http://www.apache.org/licenses/LICENSE-2.0
569   *
570   * Unless required by applicable law or agreed to in writing, software
571   * distributed under the License is distributed on an "AS IS" BASIS,
572   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
573   * See the License for the specific language governing permissions and
574   * limitations under the License.
575   */
576  /**
577   * <p>A simple, fast array of bits, represented compactly by an array of ints internally.</p>
578   *
579   * @author Sean Owen
580   */
581  class BitArray /*implements Cloneable*/ {
582      // public constructor() {
583      //   this.size = 0
584      //   this.bits = new Int32Array(1)
585      // }
586      // public constructor(size?: number /*int*/) {
587      //   if (undefined === size) {
588      //     this.size = 0
589      //   } else {
590      //     this.size = size
591      //   }
592      //   this.bits = this.makeArray(size)
593      // }
594      // For testing only
595      constructor(size /*int*/, bits) {
596          if (undefined === size) {
597              this.size = 0;
598              this.bits = new Int32Array(1);
599          }
600          else {
601              this.size = size;
602              if (undefined === bits || null === bits) {
603                  this.bits = BitArray.makeArray(size);
604              }
605              else {
606                  this.bits = bits;
607              }
608          }
609      }
610      getSize() {
611          return this.size;
612      }
613      getSizeInBytes() {
614          return Math.floor((this.size + 7) / 8);
615      }
616      ensureCapacity(size /*int*/) {
617          if (size > this.bits.length * 32) {
618              const newBits = BitArray.makeArray(size);
619              System.arraycopy(this.bits, 0, newBits, 0, this.bits.length);
620              this.bits = newBits;
621          }
622      }
623      /**
624       * @param i bit to get
625       * @return true iff bit i is set
626       */
627      get(i /*int*/) {
628          return (this.bits[Math.floor(i / 32)] & (1 << (i & 0x1F))) !== 0;
629      }
630      /**
631       * Sets bit i.
632       *
633       * @param i bit to set
634       */
635      set(i /*int*/) {
636          this.bits[Math.floor(i / 32)] |= 1 << (i & 0x1F);
637      }
638      /**
639       * Flips bit i.
640       *
641       * @param i bit to set
642       */
643      flip(i /*int*/) {
644          this.bits[Math.floor(i / 32)] ^= 1 << (i & 0x1F);
645      }
646      /**
647       * @param from first bit to check
648       * @return index of first bit that is set, starting from the given index, or size if none are set
649       *  at or beyond this given index
650       * @see #getNextUnset(int)
651       */
652      getNextSet(from /*int*/) {
653          const size = this.size;
654          if (from >= size) {
655              return size;
656          }
657          const bits = this.bits;
658          let bitsOffset = Math.floor(from / 32);
659          let currentBits = bits[bitsOffset];
660          // mask off lesser bits first
661          currentBits &= ~((1 << (from & 0x1F)) - 1);
662          const length = bits.length;
663          while (currentBits === 0) {
664              if (++bitsOffset === length) {
665                  return size;
666              }
667              currentBits = bits[bitsOffset];
668          }
669          const result = (bitsOffset * 32) + Integer.numberOfTrailingZeros(currentBits);
670          return result > size ? size : result;
671      }
672      /**
673       * @param from index to start looking for unset bit
674       * @return index of next unset bit, or {@code size} if none are unset until the end
675       * @see #getNextSet(int)
676       */
677      getNextUnset(from /*int*/) {
678          const size = this.size;
679          if (from >= size) {
680              return size;
681          }
682          const bits = this.bits;
683          let bitsOffset = Math.floor(from / 32);
684          let currentBits = ~bits[bitsOffset];
685          // mask off lesser bits first
686          currentBits &= ~((1 << (from & 0x1F)) - 1);
687          const length = bits.length;
688          while (currentBits === 0) {
689              if (++bitsOffset === length) {
690                  return size;
691              }
692              currentBits = ~bits[bitsOffset];
693          }
694          const result = (bitsOffset * 32) + Integer.numberOfTrailingZeros(currentBits);
695          return result > size ? size : result;
696      }
697      /**
698       * Sets a block of 32 bits, starting at bit i.
699       *
700       * @param i first bit to set
701       * @param newBits the new value of the next 32 bits. Note again that the least-significant bit
702       * corresponds to bit i, the next-least-significant to i+1, and so on.
703       */
704      setBulk(i /*int*/, newBits /*int*/) {
705          this.bits[Math.floor(i / 32)] = newBits;
706      }
707      /**
708       * Sets a range of bits.
709       *
710       * @param start start of range, inclusive.
711       * @param end end of range, exclusive
712       */
713      setRange(start /*int*/, end /*int*/) {
714          if (end < start || start < 0 || end > this.size) {
715              throw new IllegalArgumentException();
716          }
717          if (end === start) {
718              return;
719          }
720          end--; // will be easier to treat this as the last actually set bit -- inclusive
721          const firstInt = Math.floor(start / 32);
722          const lastInt = Math.floor(end / 32);
723          const bits = this.bits;
724          for (let i = firstInt; i <= lastInt; i++) {
725              const firstBit = i > firstInt ? 0 : start & 0x1F;
726              const lastBit = i < lastInt ? 31 : end & 0x1F;
727              // Ones from firstBit to lastBit, inclusive
728              const mask = (2 << lastBit) - (1 << firstBit);
729              bits[i] |= mask;
730          }
731      }
732      /**
733       * Clears all bits (sets to false).
734       */
735      clear() {
736          const max = this.bits.length;
737          const bits = this.bits;
738          for (let i = 0; i < max; i++) {
739              bits[i] = 0;
740          }
741      }
742      /**
743       * Efficient method to check if a range of bits is set, or not set.
744       *
745       * @param start start of range, inclusive.
746       * @param end end of range, exclusive
747       * @param value if true, checks that bits in range are set, otherwise checks that they are not set
748       * @return true iff all bits are set or not set in range, according to value argument
749       * @throws IllegalArgumentException if end is less than start or the range is not contained in the array
750       */
751      isRange(start /*int*/, end /*int*/, value) {
752          if (end < start || start < 0 || end > this.size) {
753              throw new IllegalArgumentException();
754          }
755          if (end === start) {
756              return true; // empty range matches
757          }
758          end--; // will be easier to treat this as the last actually set bit -- inclusive
759          const firstInt = Math.floor(start / 32);
760          const lastInt = Math.floor(end / 32);
761          const bits = this.bits;
762          for (let i = firstInt; i <= lastInt; i++) {
763              const firstBit = i > firstInt ? 0 : start & 0x1F;
764              const lastBit = i < lastInt ? 31 : end & 0x1F;
765              // Ones from firstBit to lastBit, inclusive
766              const mask = (2 << lastBit) - (1 << firstBit) & 0xFFFFFFFF;
767              // TYPESCRIPTPORT: & 0xFFFFFFFF added to discard anything after 32 bits, as ES has 53 bits
768              // Return false if we're looking for 1s and the masked bits[i] isn't all 1s (is: that,
769              // equals the mask, or we're looking for 0s and the masked portion is not all 0s
770              if ((bits[i] & mask) !== (value ? mask : 0)) {
771                  return false;
772              }
773          }
774          return true;
775      }
776      appendBit(bit) {
777          this.ensureCapacity(this.size + 1);
778          if (bit) {
779              this.bits[Math.floor(this.size / 32)] |= 1 << (this.size & 0x1F);
780          }
781          this.size++;
782      }
783      /**
784       * Appends the least-significant bits, from value, in order from most-significant to
785       * least-significant. For example, appending 6 bits from 0x000001E will append the bits
786       * 0, 1, 1, 1, 1, 0 in that order.
787       *
788       * @param value {@code int} containing bits to append
789       * @param numBits bits from value to append
790       */
791      appendBits(value /*int*/, numBits /*int*/) {
792          if (numBits < 0 || numBits > 32) {
793              throw new IllegalArgumentException('Num bits must be between 0 and 32');
794          }
795          this.ensureCapacity(this.size + numBits);
796          // const appendBit = this.appendBit;
797          for (let numBitsLeft = numBits; numBitsLeft > 0; numBitsLeft--) {
798              this.appendBit(((value >> (numBitsLeft - 1)) & 0x01) === 1);
799          }
800      }
801      appendBitArray(other) {
802          const otherSize = other.size;
803          this.ensureCapacity(this.size + otherSize);
804          // const appendBit = this.appendBit;
805          for (let i = 0; i < otherSize; i++) {
806              this.appendBit(other.get(i));
807          }
808      }
809      xor(other) {
810          if (this.size !== other.size) {
811              throw new IllegalArgumentException('Sizes don\'t match');
812          }
813          const bits = this.bits;
814          for (let i = 0, length = bits.length; i < length; i++) {
815              // The last int could be incomplete (i.e. not have 32 bits in
816              // it) but there is no problem since 0 XOR 0 == 0.
817              bits[i] ^= other.bits[i];
818          }
819      }
820      /**
821       *
822       * @param bitOffset first bit to start writing
823       * @param array array to write into. Bytes are written most-significant byte first. This is the opposite
824       *  of the internal representation, which is exposed by {@link #getBitArray()}
825       * @param offset position in array to start writing
826       * @param numBytes how many bytes to write
827       */
828      toBytes(bitOffset /*int*/, array, offset /*int*/, numBytes /*int*/) {
829          for (let i = 0; i < numBytes; i++) {
830              let theByte = 0;
831              for (let j = 0; j < 8; j++) {
832                  if (this.get(bitOffset)) {
833                      theByte |= 1 << (7 - j);
834                  }
835                  bitOffset++;
836              }
837              array[offset + i] = /*(byte)*/ theByte;
838          }
839      }
840      /**
841       * @return underlying array of ints. The first element holds the first 32 bits, and the least
842       *         significant bit is bit 0.
843       */
844      getBitArray() {
845          return this.bits;
846      }
847      /**
848       * Reverses all bits in the array.
849       */
850      reverse() {
851          const newBits = new Int32Array(this.bits.length);
852          // reverse all int's first
853          const len = Math.floor((this.size - 1) / 32);
854          const oldBitsLen = len + 1;
855          const bits = this.bits;
856          for (let i = 0; i < oldBitsLen; i++) {
857              let x = bits[i];
858              x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
859              x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
860              x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
861              x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
862              x = ((x >> 16) & 0x0000ffff) | ((x & 0x0000ffff) << 16);
863              newBits[len - i] = /*(int)*/ x;
864          }
865          // now correct the int's if the bit size isn't a multiple of 32
866          if (this.size !== oldBitsLen * 32) {
867              const leftOffset = oldBitsLen * 32 - this.size;
868              let currentInt = newBits[0] >>> leftOffset;
869              for (let i = 1; i < oldBitsLen; i++) {
870                  const nextInt = newBits[i];
871                  currentInt |= nextInt << (32 - leftOffset);
872                  newBits[i - 1] = currentInt;
873                  currentInt = nextInt >>> leftOffset;
874              }
875              newBits[oldBitsLen - 1] = currentInt;
876          }
877          this.bits = newBits;
878      }
879      static makeArray(size /*int*/) {
880          return new Int32Array(Math.floor((size + 31) / 32));
881      }
882      /*@Override*/
883      equals(o) {
884          if (!(o instanceof BitArray)) {
885              return false;
886          }
887          const other = o;
888          return this.size === other.size && Arrays.equals(this.bits, other.bits);
889      }
890      /*@Override*/
891      hashCode() {
892          return 31 * this.size + Arrays.hashCode(this.bits);
893      }
894      /*@Override*/
895      toString() {
896          let result = '';
897          for (let i = 0, size = this.size; i < size; i++) {
898              if ((i & 0x07) === 0) {
899                  result += ' ';
900              }
901              result += this.get(i) ? 'X' : '.';
902          }
903          return result;
904      }
905      /*@Override*/
906      clone() {
907          return new BitArray(this.size, this.bits.slice());
908      }
909      /**
910       * converts to boolean array.
911       */
912      toArray() {
913          let result = [];
914          for (let i = 0, size = this.size; i < size; i++) {
915              result.push(this.get(i));
916          }
917          return result;
918      }
919  }
920
921  /*
922   * Copyright 2009 ZXing authors
923   *
924   * Licensed under the Apache License, Version 2.0 (the "License");
925   * you may not use this file except in compliance with the License.
926   * You may obtain a copy of the License at
927   *
928   *      http://www.apache.org/licenses/LICENSE-2.0
929   *
930   * Unless required by applicable law or agreed to in writing, software
931   * distributed under the License is distributed on an "AS IS" BASIS,
932   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
933   * See the License for the specific language governing permissions and
934   * limitations under the License.
935   */
936  /*namespace com.google.zxing {*/
937  /**
938   * Encapsulates a type of hint that a caller may pass to a barcode reader to help it
939   * more quickly or accurately decode it. It is up to implementations to decide what,
940   * if anything, to do with the information that is supplied.
941   *
942   * @author Sean Owen
943   * @author [email protected] (Daniel Switkin)
944   * @see Reader#decode(BinaryBitmap,java.util.Map)
945   */
946  var DecodeHintType;
947  (function (DecodeHintType) {
948      /**
949       * Unspecified, application-specific hint. Maps to an unspecified {@link Object}.
950       */
951      DecodeHintType[DecodeHintType["OTHER"] = 0] = "OTHER"; /*(Object.class)*/
952      /**
953       * Image is a pure monochrome image of a barcode. Doesn't matter what it maps to;
954       * use {@link Boolean#TRUE}.
955       */
956      DecodeHintType[DecodeHintType["PURE_BARCODE"] = 1] = "PURE_BARCODE"; /*(Void.class)*/
957      /**
958       * Image is known to be of one of a few possible formats.
959       * Maps to a {@link List} of {@link BarcodeFormat}s.
960       */
961      DecodeHintType[DecodeHintType["POSSIBLE_FORMATS"] = 2] = "POSSIBLE_FORMATS"; /*(List.class)*/
962      /**
963       * Spend more time to try to find a barcode; optimize for accuracy, not speed.
964       * Doesn't matter what it maps to; use {@link Boolean#TRUE}.
965       */
966      DecodeHintType[DecodeHintType["TRY_HARDER"] = 3] = "TRY_HARDER"; /*(Void.class)*/
967      /**
968       * Specifies what character encoding to use when decoding, where applicable (type String)
969       */
970      DecodeHintType[DecodeHintType["CHARACTER_SET"] = 4] = "CHARACTER_SET"; /*(String.class)*/
971      /**
972       * Allowed lengths of encoded data -- reject anything else. Maps to an {@code Int32Array}.
973       */
974      DecodeHintType[DecodeHintType["ALLOWED_LENGTHS"] = 5] = "ALLOWED_LENGTHS"; /*(Int32Array.class)*/
975      /**
976       * Assume Code 39 codes employ a check digit. Doesn't matter what it maps to;
977       * use {@link Boolean#TRUE}.
978       */
979      DecodeHintType[DecodeHintType["ASSUME_CODE_39_CHECK_DIGIT"] = 6] = "ASSUME_CODE_39_CHECK_DIGIT"; /*(Void.class)*/
980      /**
981       * Enable extended mode for Code 39 codes. Doesn't matter what it maps to;
982       * use {@link Boolean#TRUE}.
983       */
984      DecodeHintType[DecodeHintType["ENABLE_CODE_39_EXTENDED_MODE"] = 7] = "ENABLE_CODE_39_EXTENDED_MODE"; /*(Void.class)*/
985      /**
986       * Assume the barcode is being processed as a GS1 barcode, and modify behavior as needed.
987       * For example this affects FNC1 handling for Code 128 (aka GS1-128). Doesn't matter what it maps to;
988       * use {@link Boolean#TRUE}.
989       */
990      DecodeHintType[DecodeHintType["ASSUME_GS1"] = 8] = "ASSUME_GS1"; /*(Void.class)*/
991      /**
992       * If true, return the start and end digits in a Codabar barcode instead of stripping them. They
993       * are alpha, whereas the rest are numeric. By default, they are stripped, but this causes them
994       * to not be. Doesn't matter what it maps to; use {@link Boolean#TRUE}.
995       */
996      DecodeHintType[DecodeHintType["RETURN_CODABAR_START_END"] = 9] = "RETURN_CODABAR_START_END"; /*(Void.class)*/
997      /**
998       * The caller needs to be notified via callback when a possible {@link ResultPoint}
999       * is found. Maps to a {@link ResultPointCallback}.
1000       */
1001      DecodeHintType[DecodeHintType["NEED_RESULT_POINT_CALLBACK"] = 10] = "NEED_RESULT_POINT_CALLBACK"; /*(ResultPointCallback.class)*/
1002      /**
1003       * Allowed extension lengths for EAN or UPC barcodes. Other formats will ignore this.
1004       * Maps to an {@code Int32Array} of the allowed extension lengths, for example [2], [5], or [2, 5].
1005       * If it is optional to have an extension, do not set this hint. If this is set,
1006       * and a UPC or EAN barcode is found but an extension is not, then no result will be returned
1007       * at all.
1008       */
1009      DecodeHintType[DecodeHintType["ALLOWED_EAN_EXTENSIONS"] = 11] = "ALLOWED_EAN_EXTENSIONS"; /*(Int32Array.class)*/
1010      // End of enumeration values.
1011      /**
1012       * Data type the hint is expecting.
1013       * Among the possible values the {@link Void} stands out as being used for
1014       * hints that do not expect a value to be supplied (flag hints). Such hints
1015       * will possibly have their value ignored, or replaced by a
1016       * {@link Boolean#TRUE}. Hint suppliers should probably use
1017       * {@link Boolean#TRUE} as directed by the actual hint documentation.
1018       */
1019      // private valueType: Class<?>
1020      // DecodeHintType(valueType: Class<?>) {
1021      //   this.valueType = valueType
1022      // }
1023      // public getValueType(): Class<?> {
1024      //   return valueType
1025      // }
1026  })(DecodeHintType || (DecodeHintType = {}));
1027  var DecodeHintType$1 = DecodeHintType;
1028
1029  /**
1030   * Custom Error class of type Exception.
1031   */
1032  class FormatException extends Exception {
1033      static getFormatInstance() {
1034          return new FormatException();
1035      }
1036  }
1037  FormatException.kind = 'FormatException';
1038
1039  /*
1040   * Copyright 2008 ZXing authors
1041   *
1042   * Licensed under the Apache License, Version 2.0 (the "License");
1043   * you may not use this file except in compliance with the License.
1044   * You may obtain a copy of the License at
1045   *
1046   *      http://www.apache.org/licenses/LICENSE-2.0
1047   *
1048   * Unless required by applicable law or agreed to in writing, software
1049   * distributed under the License is distributed on an "AS IS" BASIS,
1050   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1051   * See the License for the specific language governing permissions and
1052   * limitations under the License.
1053   */
1054  /*import java.util.HashMap;*/
1055  /*import java.util.Map;*/
1056  var CharacterSetValueIdentifiers;
1057  (function (CharacterSetValueIdentifiers) {
1058      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["Cp437"] = 0] = "Cp437";
1059      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_1"] = 1] = "ISO8859_1";
1060      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_2"] = 2] = "ISO8859_2";
1061      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_3"] = 3] = "ISO8859_3";
1062      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_4"] = 4] = "ISO8859_4";
1063      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_5"] = 5] = "ISO8859_5";
1064      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_6"] = 6] = "ISO8859_6";
1065      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_7"] = 7] = "ISO8859_7";
1066      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_8"] = 8] = "ISO8859_8";
1067      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_9"] = 9] = "ISO8859_9";
1068      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_10"] = 10] = "ISO8859_10";
1069      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_11"] = 11] = "ISO8859_11";
1070      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_13"] = 12] = "ISO8859_13";
1071      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_14"] = 13] = "ISO8859_14";
1072      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_15"] = 14] = "ISO8859_15";
1073      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ISO8859_16"] = 15] = "ISO8859_16";
1074      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["SJIS"] = 16] = "SJIS";
1075      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["Cp1250"] = 17] = "Cp1250";
1076      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["Cp1251"] = 18] = "Cp1251";
1077      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["Cp1252"] = 19] = "Cp1252";
1078      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["Cp1256"] = 20] = "Cp1256";
1079      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["UnicodeBigUnmarked"] = 21] = "UnicodeBigUnmarked";
1080      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["UTF8"] = 22] = "UTF8";
1081      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["ASCII"] = 23] = "ASCII";
1082      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["Big5"] = 24] = "Big5";
1083      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["GB18030"] = 25] = "GB18030";
1084      CharacterSetValueIdentifiers[CharacterSetValueIdentifiers["EUC_KR"] = 26] = "EUC_KR";
1085  })(CharacterSetValueIdentifiers || (CharacterSetValueIdentifiers = {}));
1086  /**
1087   * Encapsulates a Character Set ECI, according to "Extended Channel Interpretations" 5.3.1.1
1088   * of ISO 18004.
1089   *
1090   * @author Sean Owen
1091   */
1092  class CharacterSetECI {
1093      constructor(valueIdentifier, valuesParam, name, ...otherEncodingNames) {
1094          this.valueIdentifier = valueIdentifier;
1095          this.name = name;
1096          if (typeof valuesParam === 'number') {
1097              this.values = Int32Array.from([valuesParam]);
1098          }
1099          else {
1100              this.values = valuesParam;
1101          }
1102          this.otherEncodingNames = otherEncodingNames;
1103          CharacterSetECI.VALUE_IDENTIFIER_TO_ECI.set(valueIdentifier, this);
1104          CharacterSetECI.NAME_TO_ECI.set(name, this);
1105          const values = this.values;
1106          for (let i = 0, length = values.length; i !== length; i++) {
1107              const v = values[i];
1108              CharacterSetECI.VALUES_TO_ECI.set(v, this);
1109          }
1110          for (const otherName of otherEncodingNames) {
1111              CharacterSetECI.NAME_TO_ECI.set(otherName, this);
1112          }
1113      }
1114      // CharacterSetECI(value: number /*int*/) {
1115      //   this(new Int32Array {value})
1116      // }
1117      // CharacterSetECI(value: number /*int*/, String... otherEncodingNames) {
1118      //   this.values = new Int32Array {value}
1119      //   this.otherEncodingNames = otherEncodingNames
1120      // }
1121      // CharacterSetECI(values: Int32Array, String... otherEncodingNames) {
1122      //   this.values = values
1123      //   this.otherEncodingNames = otherEncodingNames
1124      // }
1125      getValueIdentifier() {
1126          return this.valueIdentifier;
1127      }
1128      getName() {
1129          return this.name;
1130      }
1131      getValue() {
1132          return this.values[0];
1133      }
1134      /**
1135       * @param value character set ECI value
1136       * @return {@code CharacterSetECI} representing ECI of given value, or null if it is legal but
1137       *   unsupported
1138       * @throws FormatException if ECI value is invalid
1139       */
1140      static getCharacterSetECIByValue(value /*int*/) {
1141          if (value < 0 || value >= 900) {
1142              throw new FormatException('incorect value');
1143          }
1144          const characterSet = CharacterSetECI.VALUES_TO_ECI.get(value);
1145          if (undefined === characterSet) {
1146              throw new FormatException('incorect value');
1147          }
1148          return characterSet;
1149      }
1150      /**
1151       * @param name character set ECI encoding name
1152       * @return CharacterSetECI representing ECI for character encoding, or null if it is legal
1153       *   but unsupported
1154       */
1155      static getCharacterSetECIByName(name) {
1156          const characterSet = CharacterSetECI.NAME_TO_ECI.get(name);
1157          if (undefined === characterSet) {
1158              throw new FormatException('incorect value');
1159          }
1160          return characterSet;
1161      }
1162      equals(o) {
1163          if (!(o instanceof CharacterSetECI)) {
1164              return false;
1165          }
1166          const other = o;
1167          return this.getName() === other.getName();
1168      }
1169  }
1170  CharacterSetECI.VALUE_IDENTIFIER_TO_ECI = new Map();
1171  CharacterSetECI.VALUES_TO_ECI = new Map();
1172  CharacterSetECI.NAME_TO_ECI = new Map();
1173  // Enum name is a Java encoding valid for java.lang and java.io
1174  // TYPESCRIPTPORT: changed the main label for ISO as the TextEncoder did not recognized them in the form from java
1175  // (eg ISO8859_1 must be ISO88591 or ISO8859-1 or ISO-8859-1)
1176  // later on: well, except 16 wich does not work with ISO885916 so used ISO-8859-1 form for default
1177  CharacterSetECI.Cp437 = new CharacterSetECI(CharacterSetValueIdentifiers.Cp437, Int32Array.from([0, 2]), 'Cp437');
1178  CharacterSetECI.ISO8859_1 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_1, Int32Array.from([1, 3]), 'ISO-8859-1', 'ISO88591', 'ISO8859_1');
1179  CharacterSetECI.ISO8859_2 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_2, 4, 'ISO-8859-2', 'ISO88592', 'ISO8859_2');
1180  CharacterSetECI.ISO8859_3 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_3, 5, 'ISO-8859-3', 'ISO88593', 'ISO8859_3');
1181  CharacterSetECI.ISO8859_4 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_4, 6, 'ISO-8859-4', 'ISO88594', 'ISO8859_4');
1182  CharacterSetECI.ISO8859_5 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_5, 7, 'ISO-8859-5', 'ISO88595', 'ISO8859_5');
1183  CharacterSetECI.ISO8859_6 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_6, 8, 'ISO-8859-6', 'ISO88596', 'ISO8859_6');
1184  CharacterSetECI.ISO8859_7 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_7, 9, 'ISO-8859-7', 'ISO88597', 'ISO8859_7');
1185  CharacterSetECI.ISO8859_8 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_8, 10, 'ISO-8859-8', 'ISO88598', 'ISO8859_8');
1186  CharacterSetECI.ISO8859_9 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_9, 11, 'ISO-8859-9', 'ISO88599', 'ISO8859_9');
1187  CharacterSetECI.ISO8859_10 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_10, 12, 'ISO-8859-10', 'ISO885910', 'ISO8859_10');
1188  CharacterSetECI.ISO8859_11 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_11, 13, 'ISO-8859-11', 'ISO885911', 'ISO8859_11');
1189  CharacterSetECI.ISO8859_13 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_13, 15, 'ISO-8859-13', 'ISO885913', 'ISO8859_13');
1190  CharacterSetECI.ISO8859_14 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_14, 16, 'ISO-8859-14', 'ISO885914', 'ISO8859_14');
1191  CharacterSetECI.ISO8859_15 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_15, 17, 'ISO-8859-15', 'ISO885915', 'ISO8859_15');
1192  CharacterSetECI.ISO8859_16 = new CharacterSetECI(CharacterSetValueIdentifiers.ISO8859_16, 18, 'ISO-8859-16', 'ISO885916', 'ISO8859_16');
1193  CharacterSetECI.SJIS = new CharacterSetECI(CharacterSetValueIdentifiers.SJIS, 20, 'SJIS', 'Shift_JIS');
1194  CharacterSetECI.Cp1250 = new CharacterSetECI(CharacterSetValueIdentifiers.Cp1250, 21, 'Cp1250', 'windows-1250');
1195  CharacterSetECI.Cp1251 = new CharacterSetECI(CharacterSetValueIdentifiers.Cp1251, 22, 'Cp1251', 'windows-1251');
1196  CharacterSetECI.Cp1252 = new CharacterSetECI(CharacterSetValueIdentifiers.Cp1252, 23, 'Cp1252', 'windows-1252');
1197  CharacterSetECI.Cp1256 = new CharacterSetECI(CharacterSetValueIdentifiers.Cp1256, 24, 'Cp1256', 'windows-1256');
1198  CharacterSetECI.UnicodeBigUnmarked = new CharacterSetECI(CharacterSetValueIdentifiers.UnicodeBigUnmarked, 25, 'UnicodeBigUnmarked', 'UTF-16BE', 'UnicodeBig');
1199  CharacterSetECI.UTF8 = new CharacterSetECI(CharacterSetValueIdentifiers.UTF8, 26, 'UTF8', 'UTF-8');
1200  CharacterSetECI.ASCII = new CharacterSetECI(CharacterSetValueIdentifiers.ASCII, Int32Array.from([27, 170]), 'ASCII', 'US-ASCII');
1201  CharacterSetECI.Big5 = new CharacterSetECI(CharacterSetValueIdentifiers.Big5, 28, 'Big5');
1202  CharacterSetECI.GB18030 = new CharacterSetECI(CharacterSetValueIdentifiers.GB18030, 29, 'GB18030', 'GB2312', 'EUC_CN', 'GBK');
1203  CharacterSetECI.EUC_KR = new CharacterSetECI(CharacterSetValueIdentifiers.EUC_KR, 30, 'EUC_KR', 'EUC-KR');
1204
1205  /**
1206   * Custom Error class of type Exception.
1207   */
1208  class UnsupportedOperationException extends Exception {
1209  }
1210  UnsupportedOperationException.kind = 'UnsupportedOperationException';
1211
1212  /**
1213   * Responsible for en/decoding strings.
1214   */
1215  class StringEncoding {
1216      /**
1217       * Decodes some Uint8Array to a string format.
1218       */
1219      static decode(bytes, encoding) {
1220          const encodingName = this.encodingName(encoding);
1221          if (this.customDecoder) {
1222              return this.customDecoder(bytes, encodingName);
1223          }
1224          // Increases browser support.
1225          if (typeof TextDecoder === 'undefined' || this.shouldDecodeOnFallback(encodingName)) {
1226              return this.decodeFallback(bytes, encodingName);
1227          }
1228          return new TextDecoder(encodingName).decode(bytes);
1229      }
1230      /**
1231       * Checks if the decoding method should use the fallback for decoding

1330*/
1331  /**
1332   * Common string-related functions.
1333   *
1334   * @author Sean Owen
1335   * @author Alex Dupre
1336   */
1337  class StringUtils {
1338      // SHIFT_JIS.equalsIgnoreCase(PLATFORM_DEFAULT_ENCODING) ||
1339      // EUC_JP.equalsIgnoreCase(PLATFORM_DEFAULT_ENCODING);
1340      static castAsNonUtf8Char(code, encoding = null) {
1341          // ISO 8859-1 is the Java default as UTF-8 is JavaScripts
1342          // you can see this method as a Java version of String.fromCharCode
1343          const e = encoding ? encoding.getName() : this.ISO88591;
1344          // use passed format (fromCharCode will return UTF8 encoding)
1345          return StringEncoding.decode(new Uint8Array([code]), e);
1346      }
1347      /**
1348       * @param bytes bytes encoding a string, whose encoding should be guessed
1349       * @param hints decode hints if applicable
1350       * @return name of guessed encoding; at the moment will only guess one of:
1351       *  {@link #SHIFT_JIS}, {@link #UTF8}, {@link #ISO88591}, or the platform
1352       *  default encoding if none of these can possibly be correct
1353       */
1354      static guessEncoding(bytes, hints) {
1355          if (hints !== null && hints !== undefined && undefined !== hints.get(DecodeHintType$1.CHARACTER_SET)) {
1356              return hints.get(DecodeHintType$1.CHARACTER_SET).toString();
1357          }
1358          // For now, merely tries to distinguish ISO-8859-1, UTF-8 and Shift_JIS,
1359          // which should be by far the most common encodings.
1360          const length = bytes.length;
1361          let canBeISO88591 = true;
1362          let canBeShiftJIS = true;
1363          let canBeUTF8 = true;
1364          let utf8BytesLeft = 0;
1365          // int utf8LowChars = 0
1366          let utf2BytesChars = 0;
1367          let utf3BytesChars = 0;
1368          let utf4BytesChars = 0;
1369          let sjisBytesLeft = 0;
1370          // int sjisLowChars = 0
1371          let sjisKatakanaChars = 0;
1372          // int sjisDoubleBytesChars = 0
1373          let sjisCurKatakanaWordLength = 0;
1374          let sjisCurDoubleBytesWordLength = 0;
1375          let sjisMaxKatakanaWordLength = 0;
1376          let sjisMaxDoubleBytesWordLength = 0;
1377          // int isoLowChars = 0
1378          // int isoHighChars = 0
1379          let isoHighOther = 0;
1380          const utf8bom = bytes.length > 3 &&
1381              bytes[0] === /*(byte) */ 0xEF &&
1382              bytes[1] === /*(byte) */ 0xBB &&
1383              bytes[2] === /*(byte) */ 0xBF;
1384          for (let i = 0; i < length && (canBeISO88591 || canBeShiftJIS || canBeUTF8); i++) {
1385              const value = bytes[i] & 0xFF;
1386              // UTF-8 stuff
1387              if (canBeUTF8) {
1388                  if (utf8BytesLeft > 0) {
1389                      if ((value & 0x80) === 0) {
1390                          canBeUTF8 = false;
1391                      }
1392                      else {
1393                          utf8BytesLeft--;
1394                      }
1395                  }
1396                  else if ((value & 0x80) !== 0) {
1397                      if ((value & 0x40) === 0) {
1398                          canBeUTF8 = false;
1399                      }
1400                      else {
1401                          utf8BytesLeft++;
1402                          if ((value & 0x20) === 0) {
1403                              utf2BytesChars++;
1404                          }
1405                          else {
1406                              utf8BytesLeft++;
1407                              if ((value & 0x10) === 0) {
1408                                  utf3BytesChars++;
1409                              }
1410                              else {
1411                                  utf8BytesLeft++;
1412                                  if ((value & 0x08) === 0) {
1413                                      utf4BytesChars++;
1414                                  }
1415                                  else {
1416                                      canBeUTF8 = false;
1417                                  }
1418                              }
1419                          }
1420                      }
1421                  } // else {
1422                  // utf8LowChars++
1423                  // }
1424              }
1425              // ISO-8859-1 stuff
1426              if (canBeISO88591) {
1427                  if (value > 0x7F && value < 0xA0) {
1428                      canBeISO88591 = false;
1429                  }
1430                  else if (value > 0x9F) {
1431                      if (value < 0xC0 || value === 0xD7 || value === 0xF7) {
1432                          isoHighOther++;
1433                      } // else {
1434                      // isoHighChars++
1435                      // }
1436                  } // else {
1437                  // isoLowChars++
1438                  // }
1439              }
1440              // Shift_JIS stuff
1441              if (canBeShiftJIS) {
1442                  if (sjisBytesLeft > 0) {
1443                      if (value < 0x40 || value === 0x7F || value > 0xFC) {
1444                          canBeShiftJIS = false;
1445                      }
1446                      else {
1447                          sjisBytesLeft--;
1448                      }
1449                  }
1450                  else if (value === 0x80 || value === 0xA0 || value > 0xEF) {
1451                      canBeShiftJIS = false;
1452                  }
1453                  else if (value > 0xA0 && value < 0xE0) {
1454                      sjisKatakanaChars++;
1455                      sjisCurDoubleBytesWordLength = 0;
1456                      sjisCurKatakanaWordLength++;
1457                      if (sjisCurKatakanaWordLength > sjisMaxKatakanaWordLength) {
1458                          sjisMaxKatakanaWordLength = sjisCurKatakanaWordLength;
1459                      }
1460                  }
1461                  else if (value > 0x7F) {
1462                      sjisBytesLeft++;
1463                      // sjisDoubleBytesChars++
1464                      sjisCurKatakanaWordLength = 0;
1465                      sjisCurDoubleBytesWordLength++;
1466                      if (sjisCurDoubleBytesWordLength > sjisMaxDoubleBytesWordLength) {
1467                          sjisMaxDoubleBytesWordLength = sjisCurDoubleBytesWordLength;
1468                      }
1469                  }
1470                  else {
1471                      // sjisLowChars++
1472                      sjisCurKatakanaWordLength = 0;
1473                      sjisCurDoubleBytesWordLength = 0;
1474                  }
1475              }
1476          }
1477          if (canBeUTF8 && utf8BytesLeft > 0) {
1478              canBeUTF8 = false;
1479          }
1480          if (canBeShiftJIS && sjisBytesLeft > 0) {
1481              canBeShiftJIS = false;
1482          }
1483          // Easy -- if there is BOM or at least 1 valid not-single byte character (and no evidence it can't be UTF-8), done
1484          if (canBeUTF8 && (utf8bom || utf2BytesChars + utf3BytesChars + utf4BytesChars > 0)) {
1485              return StringUtils.UTF8;
1486          }
1487          // Easy -- if assuming Shift_JIS or at least 3 valid consecutive not-ascii characters (and no evidence it can't be), done
1488          if (canBeShiftJIS && (StringUtils.ASSUME_SHIFT_JIS || sjisMaxKatakanaWordLength >= 3 || sjisMaxDoubleBytesWordLength >= 3)) {
1489              return StringUtils.SHIFT_JIS;
1490          }
1491          // Distinguishing Shift_JIS and ISO-8859-1 can be a little tough for short words. The crude heuristic is:
1492          // - If we saw
1493          //   - only two consecutive katakana chars in the whole text, or
1494          //   - at least 10% of bytes that could be "upper" not-alphanumeric Latin1,
1495          // - then we conclude Shift_JIS, else ISO-8859-1
1496          if (canBeISO88591 && canBeShiftJIS) {
1497              return (sjisMaxKatakanaWordLength === 2 && sjisKatakanaChars === 2) || isoHighOther * 10 >= length
1498                  ? StringUtils.SHIFT_JIS : StringUtils.ISO88591;
1499          }
1500          // Otherwise, try in order ISO-8859-1, Shift JIS, UTF-8 and fall back to default platform encoding
1501          if (canBeISO88591) {
1502              return StringUtils.ISO88591;
1503          }
1504          if (canBeShiftJIS) {
1505              return StringUtils.SHIFT_JIS;
1506          }
1507          if (canBeUTF8) {
1508              return StringUtils.UTF8;
1509          }
1510          // Otherwise, we take a wild guess with platform encoding
1511          return StringUtils.PLATFORM_DEFAULT_ENCODING;
1512      }
1513      /**
1514       *
1515       * @see https://stackoverflow.com/a/13439711/4367683
1516       *
1517       * @param append The new string to append.
1518       * @param args Argumets values to be formated.
1519       */
1520      static format(append, ...args) {
1521          let i = -1;
1522          function callback(exp, p0, p1, p2, p3, p4) {
1523              if (exp === '%%')
1524                  return '%';
1525              if (args[++i] === undefined)
1526                  return undefined;
1527              exp = p2 ? parseInt(p2.substr(1)) : undefined;
1528              let base = p3 ? parseInt(p3.substr(1)) : undefined;
1529              let val;
1530              switch (p4) {
1531                  case 's':
1532                      val = args[i];
1533                      break;
1534                  case 'c':
1535                      val = args[i][0];
1536                      break;
1537                  case 'f':
1538                      val = parseFloat(args[i]).toFixed(exp);
1539                      break;
1540                  case 'p':
1541                      val = parseFloat(args[i]).toPrecision(exp);
1542                      break;
1543                  case 'e':
1544                      val = parseFloat(args[i]).toExponential(exp);
1545                      break;
1546                  case 'x':
1547                      val = parseInt(args[i]).toString(base ? base : 16);
1548                      break;
1549                  case 'd':
1550                      val = parseFloat(parseInt(args[i], base ? base : 10).toPrecision(exp)).toFixed(0);
1551                      break;
1552              }
1553              val = typeof val === 'object' ? JSON.stringify(val) : (+val).toString(base);
1554              let size = parseInt(p1); /* padding size */
1555              let ch = p1 && (p1[0] + '') === '0' ? '0' : ' '; /* isnull? */
1556              while (val.length < size)
1557                  val = p0 !== undefined ? val + ch : ch + val; /* isminus? */
1558              return val;
1559          }
1560          let regex = /%(-)?(0?[0-9]+)?([.][0-9]+)?([#][0-9]+)?([scfpexd%])/g;
1561          return append.replace(regex, callback);
1562      }
1563      /**
1564       *
1565       */
1566      static getBytes(str, encoding) {
1567          return StringEncoding.encode(str, encoding);
1568      }
1569      /**
1570       * Returns the charcode at the specified index or at index zero.
1571       */
1572      static getCharCode(str, index = 0) {
1573          return str.charCodeAt(index);
1574      }
1575      /**
1576       * Returns char for given charcode
1577       */
1578      static getCharAt(charCode) {
1579          return String.fromCharCode(charCode);
1580      }
1581  }
1582  StringUtils.SHIFT_JIS = CharacterSetECI.SJIS.getName(); // "SJIS"
1583  StringUtils.GB2312 = 'GB2312';
1584  StringUtils.ISO88591 = CharacterSetECI.ISO8859_1.getName(); // "ISO8859_1"
1585  StringUtils.EUC_JP = 'EUC_JP';
1586  StringUtils.UTF8 = CharacterSetECI.UTF8.getName(); // "UTF8"
1587  StringUtils.PLATFORM_DEFAULT_ENCODING = StringUtils.UTF8; // "UTF8"//Charset.defaultCharset().name()
1588  StringUtils.ASSUME_SHIFT_JIS = false;
1589
1590  class StringBuilder {
1591      constructor(value = '') {
1592          this.value = value;
1593      }
1594      enableDecoding(encoding) {
1595          this.encoding = encoding;
1596          return this;
1597      }
1598      append(s) {
1599          if (typeof s === 'string') {
1600              this.value += s.toString();
1601          }
1602          else if (this.encoding) {
1603              // use passed format (fromCharCode will return UTF8 encoding)
1604              this.value += StringUtils.castAsNonUtf8Char(s, this.encoding);
1605          }
1606          else {
1607              // correctly converts from UTF-8, but not other encodings
1608              this.value += String.fromCharCode(s);
1609          }
1610          return this;
1611      }
1612      appendChars(str, offset, len) {
1613          for (let i = offset; offset < offset + len; i++) {
1614              this.append(str[i]);
1615          }
1616          return this;
1617      }
1618      length() {
1619          return this.value.length;
1620      }
1621      charAt(n) {
1622          return this.value.charAt(n);
1623      }
1624      deleteCharAt(n) {
1625          this.value = this.value.substr(0, n) + this.value.substring(n + 1);
1626      }
1627      setCharAt(n, c) {
1628          this.value = this.value.substr(0, n) + c + this.value.substr(n + 1);
1629      }
1630      substring(start, end) {
1631          return this.value.substring(start, end);
1632      }
1633      /**
1634       * @note helper method for RSS Expanded
1635       */
1636      setLengthToZero() {
1637          this.value = '';
1638      }
1639      toString() {
1640          return this.value;
1641      }
1642      insert(n, c) {
1643          this.value = this.value.substring(0, n) + c + this.value.substring(n);
1644      }
1645  }
1646
1647  /*
1648   * Copyright 2007 ZXing authors
1649   *
1650   * Licensed under the Apache License, Version 2.0 (the "License");
1651   * you may not use this file except in compliance with the License.
1652   * You may obtain a copy of the License at
1653   *
1654   *      http://www.apache.org/licenses/LICENSE-2.0
1655   *
1656   * Unless required by applicable law or agreed to in writing, software
1657   * distributed under the License is distributed on an "AS IS" BASIS,
1658   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1659   * See the License for the specific language governing permissions and
1660   * limitations under the License.
1661   */
1662  /*

1751              throw new IllegalArgumentException('stringRepresentation cannot be null');
1752          }
1753          const bits = new Array(stringRepresentation.length);
1754          let bitsPos = 0;
1755          let rowStartPos = 0;
1756          let rowLength = -1;
1757          let nRows = 0;
1758          let pos = 0;
1759          while (pos < stringRepresentation.length) {
1760              if (stringRepresentation.charAt(pos) === '\n' ||
1761                  stringRepresentation.charAt(pos) === '\r') {
1762                  if (bitsPos > rowStartPos) {
1763                      if (rowLength === -1) {
1764                          rowLength = bitsPos - rowStartPos;
1765                      }
1766                      else if (bitsPos - rowStartPos !== rowLength) {
1767                          throw new IllegalArgumentException('row lengths do not match');
1768                      }
1769                      rowStartPos = bitsPos;
1770                      nRows++;
1771                  }
1772                  pos++;
1773              }
1774              else if (stringRepresentation.substring(pos, pos + setString.length) === setString) {
1775                  pos += setString.length;
1776                  bits[bitsPos] = true;
1777                  bitsPos++;
1778              }
1779              else if (stringRepresentation.substring(pos, pos + unsetString.length) === unsetString) {
1780                  pos += unsetString.length;
1781                  bits[bitsPos] = false;
1782                  bitsPos++;
1783              }
1784              else {
1785                  throw new IllegalArgumentException('illegal character encountered: ' + stringRepresentation.substring(pos));
1786              }
1787          }
1788          // no EOL at end?
1789          if (bitsPos > rowStartPos) {
1790              if (rowLength === -1) {
1791                  rowLength = bitsPos - rowStartPos;
1792              }
1793              else if (bitsPos - rowStartPos !== rowLength) {
1794                  throw new IllegalArgumentException('row lengths do not match');
1795              }
1796              nRows++;
1797          }
1798          const matrix = new BitMatrix(rowLength, nRows);
1799          for (let i = 0; i < bitsPos; i++) {
1800              if (bits[i]) {
1801                  matrix.set(Math.floor(i % rowLength), Math.floor(i / rowLength));
1802              }
1803          }
1804          return matrix;
1805      }
1806      /**
1807       * <p>Gets the requested bit, where true means black.</p>
1808       *
1809       * @param x The horizontal component (i.e. which column)
1810       * @param y The vertical component (i.e. which row)
1811       * @return value of given bit in matrix
1812       */
1813      get(x /*int*/, y /*int*/) {
1814          const offset = y * this.rowSize + Math.floor(x / 32);
1815          return ((this.bits[offset] >>> (x & 0x1f)) & 1) !== 0;
1816      }
1817      /**
1818       * <p>Sets the given bit to true.</p>
1819       *
1820       * @param x The horizontal component (i.e. which column)
1821       * @param y The vertical component (i.e. which row)
1822       */
1823      set(x /*int*/, y /*int*/) {
1824          const offset = y * this.rowSize + Math.floor(x / 32);
1825          this.bits[offset] |= (1 << (x & 0x1f)) & 0xFFFFFFFF;
1826      }
1827      unset(x /*int*/, y /*int*/) {
1828          const offset = y * this.rowSize + Math.floor(x / 32);
1829          this.bits[offset] &= ~((1 << (x & 0x1f)) & 0xFFFFFFFF);
1830      }
1831      /**
1832       * <p>Flips the given bit.</p>
1833       *
1834       * @param x The horizontal component (i.e. which column)
1835       * @param y The vertical component (i.e. which row)
1836       */
1837      flip(x /*int*/, y /*int*/) {
1838          const offset = y * this.rowSize + Math.floor(x / 32);
1839          this.bits[offset] ^= ((1 << (x & 0x1f)) & 0xFFFFFFFF);
1840      }
1841      /**
1842       * Exclusive-or (XOR): Flip the bit in this {@code BitMatrix} if the corresponding
1843       * mask bit is set.
1844       *
1845       * @param mask XOR mask
1846       */
1847      xor(mask) {
1848          if (this.width !== mask.getWidth() || this.height !== mask.getHeight()
1849              || this.rowSize !== mask.getRowSize()) {
1850              throw new IllegalArgumentException('input matrix dimensions do not match');
1851          }
1852          const rowArray = new BitArray(Math.floor(this.width / 32) + 1);
1853          const rowSize = this.rowSize;
1854          const bits = this.bits;
1855          for (let y = 0, height = this.height; y < height; y++) {
1856              const offset = y * rowSize;
1857              const row = mask.getRow(y, rowArray).getBitArray();
1858              for (let x = 0; x < rowSize; x++) {
1859                  bits[offset + x] ^= row[x];
1860              }
1861          }
1862      }
1863      /**
1864       * Clears all bits (sets to false).
1865       */
1866      clear() {
1867          const bits = this.bits;
1868          const max = bits.length;
1869          for (let i = 0; i < max; i++) {
1870              bits[i] = 0;
1871          }
1872      }
1873      /**
1874       * <p>Sets a square region of the bit matrix to true.</p>
1875       *
1876       * @param left The horizontal position to begin at (inclusive)
1877       * @param top The vertical position to begin at (inclusive)
1878       * @param width The width of the region
1879       * @param height The height of the region
1880       */
1881      setRegion(left /*int*/, top /*int*/, width /*int*/, height /*int*/) {
1882          if (top < 0 || left < 0) {
1883              throw new IllegalArgumentException('Left and top must be nonnegative');
1884          }
1885          if (height < 1 || width < 1) {
1886              throw new IllegalArgumentException('Height and width must be at least 1');
1887          }
1888          const right = left + width;
1889          const bottom = top + height;
1890          if (bottom > this.height || right > this.width) {
1891              throw new IllegalArgumentException('The region must fit inside the matrix');
1892          }
1893          const rowSize = this.rowSize;
1894          const bits = this.bits;
1895          for (let y = top; y < bottom; y++) {
1896              const offset = y * rowSize;
1897              for (let x = left; x < right; x++) {
1898                  bits[offset + Math.floor(x / 32

1898)] |= ((1 << (x & 0x1f)) & 0xFFFFFFFF);
1899              }
1900          }
1901      }
1902      /**
1903       * A fast method to retrieve one row of data from the matrix as a BitArray.
1904       *
1905       * @param y The row to retrieve
1906       * @param row An optional caller-allocated BitArray, will be allocated if null or too small
1907       * @return The resulting BitArray - this reference should always be used even when passing
1908       *         your own row
1909       */
1910      getRow(y /*int*/, row) {
1911          if (row === null || row === undefined || row.getSize() < this.width) {
1912              row = new BitArray(this.width);
1913          }
1914          else {
1915              row.clear();
1916          }
1917          const rowSize = this.rowSize;
1918          const bits = this.bits;
1919          const offset = y * rowSize;
1920          for (let x = 0; x < rowSize; x++) {
1921              row.setBulk(x * 32, bits[offset + x]);
1922          }
1923          return row;
1924      }
1925      /**
1926       * @param y row to set
1927       * @param row {@link BitArray} to copy from
1928       */
1929      setRow(y /*int*/, row) {
1930          System.arraycopy(row.getBitArray(), 0, this.bits, y * this.rowSize, this.rowSize);
1931      }
1932      /**
1933       * Modifies this {@code BitMatrix} to represent the same but rotated 180 degrees
1934       */
1935      rotate180() {
1936          const width = this.getWidth();
1937          const height = this.getHeight();
1938          let topRow = new BitArray(width);
1939          let bottomRow = new BitArray(width);
1940          for (let i = 0, length = Math.floor((height + 1) / 2); i < length; i++) {
1941              topRow = this.getRow(i, topRow);
1942              bottomRow = this.getRow(height - 1 - i, bottomRow);
1943              topRow.reverse();
1944              bottomRow.reverse();
1945              this.setRow(i, bottomRow);
1946              this.setRow(height - 1 - i, topRow);
1947          }
1948      }
1949      /**
1950       * This is useful in detecting the enclosing rectangle of a 'pure' barcode.
1951       *
1952       * @return {@code left,top,width,height} enclosing rectangle of all 1 bits, or null if it is all white
1953       */
1954      getEnclosingRectangle() {
1955          const width = this.width;
1956          const height = this.height;
1957          const rowSize = this.rowSize;
1958          const bits = this.bits;
1959          let left = width;
1960          let top = height;
1961          let right = -1;
1962          let bottom = -1;
1963          for (let y = 0; y < height; y++) {
1964              for (let x32 = 0; x32 < rowSize; x32++) {
1965                  const theBits = bits[y * rowSize + x32];
1966                  if (theBits !== 0) {
1967                      if (y < top) {
1968                          top = y;
1969                      }
1970                      if (y > bottom) {
1971                          bottom = y;
1972                      }
1973                      if (x32 * 32 < left) {
1974                          let bit = 0;
1975                          while (((theBits << (31 - bit)) & 0xFFFFFFFF) === 0) {
1976                              bit++;
1977                          }
1978                          if ((x32 * 32 + bit) < left) {
1979                              left = x32 * 32 + bit;
1980                          }
1981                      }
1982                      if (x32 * 32 + 31 > right) {
1983                          let bit = 31;
1984                          while ((theBits >>> bit) === 0) {
1985                              bit--;
1986                          }
1987                          if ((x32 * 32 + bit) > right) {
1988                              right = x32 * 32 + bit;
1989                          }
1990                      }
1991                  }
1992              }
1993          }
1994          if (right < left || bottom < top) {
1995              return null;
1996          }
1997          return Int32Array.from([left, top, right - left + 1, bottom - top + 1]);
1998      }
1999      /**
2000       * This is useful in detecting a corner of a 'pure' barcode.
2001       *
2002       * @return {@code x,y} coordinate of top-left-most 1 bit, or null if it is all white
2003       */
2004      getTopLeftOnBit() {
2005          const rowSize = this.rowSize;
2006          const bits = this.bits;
2007          let bitsOffset = 0;
2008          while (bitsOffset < bits.length && bits[bitsOffset] === 0) {
2009              bitsOffset++;
2010          }
2011          if (bitsOffset === bits.length) {
2012              return null;
2013          }
2014          const y = bitsOffset / rowSize;
2015          let x = (bitsOffset % rowSize) * 32;
2016          const theBits = bits[bitsOffset];
2017          let bit = 0;
2018          while (((theBits << (31 - bit)) & 0xFFFFFFFF) === 0) {
2019              bit++;
2020          }
2021          x += bit;
2022          return Int32Array.from([x, y]);
2023      }
2024      getBottomRightOnBit() {
2025          const rowSize = this.rowSize;
2026          const bits = this.bits;
2027          let bitsOffset = bits.length - 1;
2028          while (bitsOffset >= 0 && bits[bitsOffset] === 0) {
2029              bitsOffset--;
2030          }
2031          if (bitsOffset < 0) {
2032              return null;
2033          }
2034          const y = Math.floor(bitsOffset / rowSize);
2035          let x = Math.floor(bitsOffset % rowSize) * 32;
2036          const theBits = bits[bitsOffset];
2037          let bit = 31;
2038          while ((theBits >>> bit) === 0) {
2039              bit--;
2040          }
2041          x += bit;
2042          return Int32Array.from([x, y]);
2043      }
2044      /**
2045       * @return The width of the matrix
2046       */
2047      getWidth() {
2048          return this.width;
2049      }
2050      /**
2051       * @return The height of the matrix
2052       */
2053      getHeight() {
2054          return this.height;
2055      }
2056      /**
2057       * @return The row size of the matrix
2058       */
2059      getRowSize() {
2060          return this.rowSize;
2061      }
2062      /*@Override*/
2063      equals(o) {
2064          if (!(o instanceof BitMatrix)) {
2065              return false;
2066          }
2067          const other = o;
2068          return this.width === other.width && this.height === other.height && this.rowSize === other.rowSize &&
2069              Arrays.equals(this.bits, other.bits);
2070      }
2071      /*@Override*/
2072      hashCode() {
2073          let hash = this.width;
2074          hash = 31 * hash + this.width;
2075          hash = 31 * hash + this.height;
2076          hash = 31 * hash + this.rowSize;
2077          hash = 31 * hash + Arrays.hashCode(this.bits);
2078          return hash;
2079      }
2080      /**
2081       * @return string representation using "X" for set and " " for unset bits
2082       */
2083      /*@Override*/
2084      // public toString(): string {
2085      //   return toString(": "X, "  ")
2086      // }
2087      /**
2088       * @param setString representation of a set bit
2089       * @param unsetString representation of an unset bit
2090       * @return string representation of entire matrix utilizing given strings
2091       */
2092      // public toString(setString: string = "X ", unsetString: string = "  "): string {
2093      //   return this.buildToString(setString, unsetString, "\n")
2094      // }
2095      /**
2096       * @param setString representation of a set bit
2097       * @param unsetString representation of an unset bit
2098       * @param lineSeparator newline character in string representation
2099       * @return string representation of entire matrix utilizing given strings and line separator
2100       * @deprecated call {@link #toString(String,String)} only, which uses \n line separator always
2101       */
2102      // @Deprecated
2103      toString(setString = 'X ', unsetString = '  ', lineSeparator = '\n') {
2104          return this.buildToString(setString, unsetString, lineSeparator);
2105      }
2106      buildToString(setString, unsetString, lineSeparator) {
2107          let result = new StringBuilder();
2108          // result.append(lineSeparator);
2109          for (let y = 0, height = this.height; y < height; y++) {
2110              for (let x = 0, width = this.width; x < width; x++) {
2111                  result.append(this.get(x, y) ? setString : unsetString);
2112              }
2113              result.append(lineSeparator);
2114          }
2115          return result.toString();
2116      }
2117      /*@Override*/
2118      clone() {
2119          return new BitMatrix(this.width, this.height, this.rowSize, this.bits.slice());
2120      }
2121  }
2122
2123  /**
2124   * Custom Error class of type Exception.
2125   */
2126  class NotFoundException extends Exception {
2127      static getNotFoundInstance() {
2128          return new NotFoundException();
2129      }
2130  }
2131  NotFoundException.kind = 'NotFoundException';
2132
2133  /*
2134   * Copyright 2009 ZXing authors
2135   *
2136   * Licensed under the Apache License, Version 2.0 (the "License");
2137   * you may not use this file except in compliance with the License.
2138   * You may obtain a copy of the License at
2139   *
2140   *      http://www.apache.org/licenses/LICENSE-2.0
2141   *
2142   * Unless required by applicable law or agreed to in writing, software
2143   * distributed under the License is distributed on an "AS IS" BASIS,
2144   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2145   * See the License for the specific language governing permissions and
2146   * limitations under the License.
2147   */
2148  /*

2223                  localBuckets[pixel >> GlobalHistogramBinarizer.LUMINANCE_SHIFT]++;
2224              }
2225          }
2226          const blackPoint = GlobalHistogramBinarizer.estimateBlackPoint(localBuckets);
2227          // We delay reading the entire image luminance until the black point estimation succeeds.
2228          // Although we end up reading four rows twice, it is consistent with our motto of
2229          // "fail quickly" which is necessary for continuous scanning.
2230          const localLuminances = source.getMatrix();
2231          for (let y = 0; y < height; y++) {
2232              const offset = y * width;
2233              for (let x = 0; x < width; x++) {
2234                  const pixel = localLuminances[offset + x] & 0xff;
2235                  if (pixel < blackPoint) {
2236                      matrix.set(x, y);
2237                  }
2238              }
2239          }
2240          return matrix;
2241      }
2242      /*@Override*/
2243      createBinarizer(source) {
2244          return new GlobalHistogramBinarizer(source);
2245      }
2246      initArrays(luminanceSize /*int*/) {
2247          if (this.luminances.length < luminanceSize) {
2248              this.luminances = new Uint8ClampedArray(luminanceSize);
2249          }
2250          const buckets = this.buckets;
2251          for (let x = 0; x < GlobalHistogramBinarizer.LUMINANCE_BUCKETS; x++) {
2252              buckets[x] = 0;
2253          }

2253
2254      }
2255      static estimateBlackPoint(buckets) {
2256          // Find the tallest peak in the histogram.
2257          const numBuckets = buckets.length;
2258          let maxBucketCount = 0;
2259          let firstPeak = 0;
2260          let firstPeakSize = 0;
2261          for (let x = 0; x < numBuckets; x++) {
2262              if (buckets[x] > firstPeakSize) {
2263                  firstPeak = x;
2264                  firstPeakSize = buckets[x];
2265              }
2266              if (buckets[x] > maxBucketCount) {
2267                  maxBucketCount = buckets[x];
2268              }
2269          }
2270          // Find the second-tallest peak which is somewhat far from the tallest peak.
2271          let secondPeak = 0;
2272          let secondPeakScore = 0;
2273          for (let x = 0; x < numBuckets; x++) {
2274              const distanceToBiggest = x - firstPeak;
2275              // Encourage more distant second peaks by multiplying by square of distance.
2276              const score = buckets[x] * distanceToBiggest * distanceToBiggest;
2277              if (score > secondPeakScore) {
2278                  secondPeak = x;
2279                  secondPeakScore = score;
2280              }
2281          }
2282          // Make sure firstPeak corresponds to the black peak.
2283          if (firstPeak > secondPeak) {
2284              const temp = firstPeak;
2285              firstPeak = secondPeak;
2286              secondPeak = temp;
2287          }
2288          // If there is too little contrast in the image to pick a meaningful black point, throw rather
2289          // than waste time trying to decode the image, and risk false positives.
2290          if (secondPeak - firstPeak <= numBuckets / 16) {
2291              throw new NotFoundException();
2292          }
2293          // Find a valley between them that is low and closer to the white peak.
2294          let bestValley = secondPeak - 1;
2295          let bestValleyScore = -1;
2296          for (let x = secondPeak - 1; x > firstPeak; x--) {
2297              const fromFirst = x - firstPeak;
2298              const score = fromFirst * fromFirst * (secondPeak - x) * (maxBucketCount - buckets[x]);
2299              if (score > bestValleyScore) {
2300                  bestValley = x;
2301                  bestValleyScore = score;
2302              }
2303          }
2304          return bestValley << GlobalHistogramBinarizer.LUMINANCE_SHIFT;
2305      }
2306  }
2307  GlobalHistogramBinarizer.LUMINANCE_BITS = 5;
2308  GlobalHistogramBinarizer.LUMINANCE_SHIFT = 8 - GlobalHistogramBinarizer.LUMINANCE_BITS;
2309  GlobalHistogramBinarizer.LUMINANCE_BUCKETS = 1 << GlobalHistogramBinarizer.LUMINANCE_BITS;
2310  GlobalHistogramBinarizer.EMPTY = Uint8ClampedArray.from([0]);
2311
2312  /*
2313   * Copyright 2009 ZXing authors
2314   *
2315   * Licensed under the Apache License, Version 2.0 (the "License");
2316   * you may not use this file except in compliance with the License.
2317   * You may obtain a copy of the License at
2318   *
2319   *      http://www.apache.org/licenses/LICENSE-2.0
2320   *
2321   * Unless required by applicable law or agreed to in writing, software
2322   * distributed under the License is distributed on an "AS IS" BASIS,
2323   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2324   * See the License for the specific language governing permissions and
2325   * limitations under the License.
2326   */
2327  /**
2328   * This class implements a local thresholding algorithm, which while slower than the
2329   * GlobalHistogramBinarizer, is fairly efficient for what it does. It is designed for
2330   * high frequency images of barcodes with black data on white backgrounds. For this application,
2331   * it does a much better job than a global blackpoint with severe shadows and gradients.
2332   * However it tends to produce artifacts on lower frequency images and is therefore not
2333   * a good general purpose binarizer for uses outside ZXing.
2334   *
2335   * This class extends GlobalHistogramBinarizer, using the older histogram approach for 1D readers,
2336   * and the newer local approach for 2D readers. 1D decoding using a per-row histogram is already
2337   * inherently local, and only fails for horizontal gradients. We can revisit that problem later,
2338   * but for now it was not a win to use local blocks for 1D.
2339   *
2340   * This Binarizer is the default for the unit tests and the recommended class for library users.
2341   *
2342   * @author [email protected] (Daniel Switkin)
2343   */
2344  class HybridBinarizer extends GlobalHistogramBinarizer {
2345      constructor(source) {
2346          super(source);
2347          this.matrix = null;
2348      }
2349      /**
2350       * Calculates the final BitMatrix once for all requests. This could be called once from the
2351       * constructor instead, but there are some advantages to doing it lazily, such as making
2352       * profiling easier, and not doing heavy lifting when callers don't expect it.
2353       */
2354      /*@Override*/
2355      getBlackMatrix() {
2356          if (this.matrix !== null) {
2357              return this.matrix;
2358          }
2359          const source = this.getLuminanceSource();
2360          const width = source.getWidth();
2361          const height = source.getHeight();
2362          if (width >= HybridBinarizer.MINIMUM_DIMENSION && height >= HybridBinarizer.MINIMUM_DIMENSION) {
2363              const luminances = source.getMatrix();
2364              let subWidth = width >> HybridBinarizer.BLOCK_SIZE_POWER;
2365              if ((width & HybridBinarizer.BLOCK_SIZE_MASK) !== 0) {
2366                  subWidth++;
2367              }
2368              let subHeight = height >> HybridBinarizer.BLOCK_SIZE_POWER;
2369              if ((height & HybridBinarizer.BLOCK_SIZE_MASK) !== 0) {
2370                  subHeight++;
2371              }
2372              const blackPoints = HybridBinarizer.calculateBlackPoints(luminances, subWidth, subHeight, width, height);
2373              const newMatrix = new BitMatrix(width, height);
2374              HybridBinarizer.calculateThresholdForBlock(luminances, subWidth, subHeight, width, height, blackPoints, newMatrix);
2375              this.matrix = newMatrix;
2376          }
2377          else {
2378              // If the image is too small, fall back to the global histogram approach.
2379              this.matrix = super.getBlackMatrix();
2380          }
2381          return this.matrix;
2382      }
2383      /*@Override*/
2384      createBinarizer(source) {
2385          return new HybridBinarizer(source);
2386      }
2387      /**
2388       * For each block in the image, calculate the average black point using a 5x5 grid
2389       * of the blocks around it. Also handles the corner cases (fractional blocks are computed based
2390       * on the last pixels in the row/column which are also used in the previous block).
2391       */
2392      static calculateThresholdForBlock(luminances, subWidth /*int*/, subHeight /*int*/, width /*int*/, height /*int*/, blackPoints, matrix) {
2393          const maxYOffset = height - HybridBinarizer.BLOCK_SIZE;
2394          const maxXOffset = width - HybridBinarizer.BLOCK_SIZE;
2395          for (let y = 0; y < subHeight; y++) {
2396              let yoffset = y << HybridBinarizer.BLOCK_SIZE_POWER;
2397              if (yoffset > maxYOffset) {
2398                  yoffset = maxYOffset;
2399              }
2400              const top = HybridBinarizer.cap(y, 2, subHeight - 3);
2401              for (let x = 0; x < subWidth; x++) {
2402                  let xoffset = x << HybridBinarizer.BLOCK_SIZE_POWER;
2403                  if (xoffset > maxXOffset) {
2404                      xoffset = maxXOffset;
2405                  }
2406                  const left = HybridBinarizer.cap(x, 2, subWidth - 3);
2407                  let sum = 0;
2408                  for (let z = -2; z <= 2; z++) {
2409                      const blackRow = blackPoints[top + z];
2410                      sum += blackRow[left - 2] + blackRow[left - 1] + blackRow[left] + blackRow[left + 1] + blackRow[left + 2];
2411                  }
2412                  const average = sum / 25;
2413                  HybridBinarizer.thresholdBlock(luminances, xoffset, yoffset, average, width, matrix);
2414              }
2415          }
2416      }
2417      static cap(value /*int*/, min /*int*/, max /*int*/) {
2418          return value < min ? min : value > max ? max : value;
2419      }
2420      /**
2421       * Applies a single threshold to a block of pixels.
2422       */
2423      static thresholdBlock(luminances, xoffset /*int*/, yoffset /*int*/, threshold /*int*/, stride /*int*/, matrix) {
2424          for (let y = 0, offset = yoffset * stride + xoffset; y < HybridBinarizer.BLOCK_SIZE; y++, offset += stride) {
2425              for (let x = 0; x < HybridBinarizer.BLOCK_SIZE; x++) {
2426                  // Comparison needs to be <= so that black == 0 pixels are black even if the threshold is 0.
2427                  if ((luminances[offset + x] & 0xFF) <= threshold) {
2428                      matrix.set(xoffset + x, yoffset + y);
2429                  }
2430              }
2431          }
2432      }
2433      /**
2434       * Calculates a single black point for each block of pixels and saves it away.
2435       * See the following thread for a discussion of this algorithm:
2436       *  http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
2437       */
2438      static calculateBlackPoints(luminances, subWidth /*int*/, subHeight /*int*/, width /*int*/, height /*int*/) {
2439          const maxYOffset = height - HybridBinarizer.BLOCK_SIZE;
2440          const maxXOffset = width - HybridBinarizer.BLOCK_SIZE;
2441          // tslint:disable-next-line:whitespace
2442          const blackPoints = new Array(subHeight); // subWidth
2443          for (let y = 0; y < subHeight; y++) {
2444              blackPoints[y] = new Int32Array(subWidth);
2445              let yoffset = y << HybridBinarizer.BLOCK_SIZE_POWER;
2446              if (yoffset > maxYOffset) {
2447                  yoffset = maxYOffset;
2448              }
2449              for (let x = 0; x < subWidth; x++) {
2450                  let xoffset = x << HybridBinarizer.BLOCK_SIZE_POWER;
2451                  if (xoffset > maxXOffset) {
2452                      xoffset = maxXOffset;
2453                  }
2454                  let sum = 0;
2455                  let min = 0xFF;
2456                  let max = 0;
2457                  for (let yy = 0, offset = yoffset * width + xoffset; yy < HybridBinarizer.BLOCK_SIZE; yy++, offset += width) {
2458                      for (let xx = 0; xx < HybridBinarizer.BLOCK_SIZE; xx++) {
2459                          const pixel = luminances[offset + xx] & 0xFF;
2460                          sum += pixel;
2461                          // still looking for good contrast
2462                          if (pixel < min) {
2463                              min = pixel;
2464                          }
2465                          if (pixel > max) {
2466                              max = pixel;
2467                          }
2468                      }
2469                      // short-circuit min/max tests once dynamic range is met
2470                      if (max - min > HybridBinarizer.MIN_DYNAMIC_RANGE) {
2471                          // finish the rest of the rows quickly
2472                          for (yy++, offset += width; yy < HybridBinarizer.BLOCK_SIZE; yy++, offset += width) {
2473                              for (let xx = 0; xx < HybridBinarizer.BLOCK_SIZE; xx++) {
2474                                  sum += luminances[offset + xx] & 0xFF;
2475                              }
2476                          }
2477                      }
2478                  }
2479                  // The default estimate is the average of the values in the block.
2480                  let average = sum >> (HybridBinarizer.BLOCK_SIZE_POWER * 2);
2481                  if (max - min <= HybridBinarizer.MIN_DYNAMIC_RANGE) {
2482                      // If variation within the block is low, assume this is a block with only light or only
2483                      // dark pixels. In that case we do not want to use the average, as it would divide this
2484                      // low contrast area into black and white pixels, essentially creating data out of noise.
2485                      //
2486                      // The default assumption is that the block is light/background. Since no estimate for
2487                      // the level of dark pixels exists locally, use half the min for the block.
2488                      average = min / 2;
2489                      if (y > 0 && x > 0) {
2490                          // Correct the "white background" assumption for blocks that have neighbors by comparing
2491                          // the pixels in this block to the previously calculated black points. This is based on
2492                          // the fact that dark barcode symbology is always surrounded by some amount of light
2493                          // background for which reasonable black point estimates were made. The bp estimated at
2494                          // the boundaries is used for the interior.
2495                          // The (min < bp) is arbitrary but works better than other heuristics that were tried.
2496                          const averageNeighborBlackPoint = (blackPoints[y - 1][x] + (2 * blackPoints[y][x - 1]) + blackPoints[y - 1][x - 1]) / 4;
2497                          if (min < averageNeighborBlackPoint) {
2498                              average = averageNeighborBlackPoint;
2499                          }
2500                      }
2501                  }
2502                  blackPoints[y][x] = average;
2503              }
2504          }
2505          return blackPoints;
2506      }
2507  }
2508  // This class uses 5x5 blocks to compute local luminance, where each block is 8x8 pixels.
2509  // So this is the smallest dimension in each axis we can accept.
2510  HybridBinarizer.BLOCK_SIZE_POWER = 3;
2511  HybridBinarizer.BLOCK_SIZE = 1 << HybridBinarizer.BLOCK_SIZE_POWER; // ...0100...00
2512  HybridBinarizer.BLOCK_SIZE_MASK = HybridBinarizer.BLOCK_SIZE - 1; // ...0011...11
2513  HybridBinarizer.MINIMUM_DIMENSION = HybridBinarizer.BLOCK_SIZE * 5;
2514  HybridBinarizer.MIN_DYNAMIC_RANGE = 24;
2515
2516  /*
2517   * Copyright 2009 ZXing authors
2518   *
2519   * Licensed under the Apache License, Version 2.0 (the "License");
2520   * you may not use this file except in compliance with the License.
2521   * You may obtain a copy of the License at
2522   *
2523   *      http://www.apache.org/licenses/LICENSE-2.0
2524   *
2525   * Unless required by applicable law or agreed to in writing, software
2526   * distributed under the License is distributed on an "AS IS" BASIS,
2527   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2528   * See the License for the specific language governing permissions and
2529   * limitations under the License.
2530   */
2531  /*namespace com.google.zxing {*/
2532  /**
2533   * The purpose of this class hierarchy is to abstract different bitmap implementations across
2534   * platforms into a standard interface for requesting greyscale luminance values. The interface
2535   * only provides immutable methods; therefore crop and rotation create copies. This is to ensure
2536   * that one Reader does not modify the original luminance source and leave it in an unknown state
2537   * for other Readers in the chain.
2538   *
2539   * @author [email protected] (Daniel Switkin)
2540   */
2541  class LuminanceSource {
2542      constructor(width /*int*/, height /*int*/) {
2543          this.width = width;
2544          this.height = height;
2545      }
2546      /**
2547       * @return The width of the bitmap.
2548       */
2549      getWidth() {
2550          return this.width;
2551      }
2552      /**
2553       * @return The height of the bitmap.
2554       */
2555      getHeight() {
2556          return this.height;
2557      }
2558      /**
2559       * @return Whether this subclass supports cropping.
2560       */
2561      isCropSupported() {
2562          return false;
2563      }
2564      /**
2565       * Returns a new object with cropped image data. Implementations may keep a reference to the
2566       * original data rather than a copy. Only callable if isCropSupported() is true.
2567       *
2568       * @param left The left coordinate, which must be in [0,getWidth())
2569       * @param top The top coordinate, which must be in [0,getHeight())
2570       * @param width The width of the rectangle to crop.
2571       * @param height The height of the rectangle to crop.
2572       * @return A cropped version of this object.
2573       */
2574      crop(left /*int*/, top /*int*/, width /*int*/, height /*int*/) {
2575          throw new UnsupportedOperationException('This luminance source does not support cropping.');
2576      }
2577      /**
2578       * @return Whether this subclass supports counter-clockwise rotation.
2579       */
2580      isRotateSupported() {
2581          return false;
2582      }
2583      /**
2584       * Returns a new object with rotated image data by 90 degrees counterclockwise.
2585       * Only callable if {@link #isRotateSupported()} is true.
2586       *
2587       * @return A rotated version of this object.
2588       */
2589      rotateCounterClockwise() {
2590          throw new UnsupportedOperationException('This luminance source does not support rotation by 90 degrees.');
2591      }
2592      /**
2593       * Returns a new object with rotated image data by 45 degrees counterclockwise.
2594       * Only callable if {@link #isRotateSupported()} is true.
2595       *
2596       * @return A rotated version of this object.
2597       */
2598      rotateCounterClockwise45() {
2599          throw new UnsupportedOperationException('This luminance source does not support rotation by 45 degrees.');
2600      }
2601      /*@Override*/
2602      toString() {
2603          const row = new Uint8ClampedArray(this.width);
2604          let result = new StringBuilder();
2605          for (let y = 0; y < this.height; y++) {
2606              const sourceRow = this.getRow(y, row);
2607              for (let x = 0; x < this.width; x++) {
2608                  const luminance = sourceRow[x] & 0xFF;
2609                  let c;
2610                  if (luminance < 0x40) {
2611                      c = '#';
2612                  }
2613                  else if (luminance < 0x80) {
2614                      c = '+';
2615                  }
2616                  else if (luminance < 0xC0) {
2617                      c = '.';
2618                  }
2619                  else {
2620                      c = ' ';
2621                  }
2622                  result.append(c);
2623              }
2624              result.append('\n');
2625          }
2626          return result.toString();
2627      }
2628  }
2629
2630  /*
2631   * Copyright 2009 ZXing authors
2632   *
2633   * Licensed under the Apache License, Version 2.0 (the "License");
2634   * you may not use this file except in compliance with the License.
2635   * You may obtain a copy of the License at
2636   *
2637   *      http://www.apache.org/licenses/LICENSE-2.0
2638   *
2639   * Unless required by applicable law or agreed to in writing, software
2640   * distributed under the License is distributed on an "AS IS" BASIS,
2641   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2642   * See the License for the specific language governing permissions and
2643   * limitations under the License.
2644   */
2645  /*namespace com.google.zxing {*/
2646  /**
2647   * A wrapper implementation of {@link LuminanceSource} which inverts the luminances it returns -- black becomes
2648   * white and vice versa, and each value becomes (255-value).
2649   *
2650   * @author Sean Owen
2651   */
2652  class InvertedLuminanceSource extends LuminanceSource {
2653      constructor(delegate) {
2654          super(delegate.getWidth(), delegate.getHeight());
2655          this.delegate = delegate;
2656      }
2657      /*@Override*/
2658      getRow(y /*int*/, row) {
2659          const sourceRow = this.delegate.getRow(y, row);
2660          const width