@cloudbase/framework-plugin-low-code 0.4.44 → 0.4.45

package/template/node_modules/@zxing/library/cjs/core/util/Arrays.js

@@ -0,0 +1,191 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var System_1 = require("./System");
+var IllegalArgumentException_1 = require("../IllegalArgumentException");
+var ArrayIndexOutOfBoundsException_1 = require("../ArrayIndexOutOfBoundsException");
+var Arrays = /** @class */ (function () {
+    function Arrays() {
+    }
+    /**
+     * Assigns the specified int value to each element of the specified array
+     * of ints.
+     *
+     * @param a the array to be filled
+     * @param val the value to be stored in all elements of the array
+     */
+    Arrays.fill = function (a, val) {
+        for (var i = 0, len = a.length; i < len; i++)
+            a[i] = val;
+    };
+    /**
+     * Assigns the specified int value to each element of the specified
+     * range of the specified array of ints.  The range to be filled
+     * extends from index {@code fromIndex}, inclusive, to index
+     * {@code toIndex}, exclusive.  (If {@code fromIndex==toIndex}, the
+     * range to be filled is empty.)
+     *
+     * @param a the array to be filled
+     * @param fromIndex the index of the first element (inclusive) to be
+     *        filled with the specified value
+     * @param toIndex the index of the last element (exclusive) to be
+     *        filled with the specified value
+     * @param val the value to be stored in all elements of the array
+     * @throws IllegalArgumentException if {@code fromIndex > toIndex}
+     * @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
+     *         {@code toIndex > a.length}
+     */
+    Arrays.fillWithin = function (a, fromIndex, toIndex, val) {
+        Arrays.rangeCheck(a.length, fromIndex, toIndex);
+        for (var i = fromIndex; i < toIndex; i++)
+            a[i] = val;
+    };
+    /**
+     * Checks that {@code fromIndex} and {@code toIndex} are in
+     * the range and throws an exception if they aren't.
+     */
+    Arrays.rangeCheck = function (arrayLength, fromIndex, toIndex) {
+        if (fromIndex > toIndex) {
+            throw new IllegalArgumentException_1.default('fromIndex(' + fromIndex + ') > toIndex(' + toIndex + ')');
+        }
+        if (fromIndex < 0) {
+            throw new ArrayIndexOutOfBoundsException_1.default(fromIndex);
+        }
+        if (toIndex > arrayLength) {
+            throw new ArrayIndexOutOfBoundsException_1.default(toIndex);
+        }
+    };
+    Arrays.asList = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return args;
+    };
+    Arrays.create = function (rows, cols, value) {
+        var arr = Array.from({ length: rows });
+        return arr.map(function (x) { return Array.from({ length: cols }).fill(value); });
+    };
+    Arrays.createInt32Array = function (rows, cols, value) {
+        var arr = Array.from({ length: rows });
+        return arr.map(function (x) { return Int32Array.from({ length: cols }).fill(value); });
+    };
+    Arrays.equals = function (first, second) {
+        if (!first) {
+            return false;
+        }
+        if (!second) {
+            return false;
+        }
+        if (!first.length) {
+            return false;
+        }
+        if (!second.length) {
+            return false;
+        }
+        if (first.length !== second.length) {
+            return false;
+        }
+        for (var i = 0, length_1 = first.length; i < length_1; i++) {
+            if (first[i] !== second[i]) {
+                return false;
+            }
+        }
+        return true;
+    };
+    Arrays.hashCode = function (a) {
+        var e_1, _a;
+        if (a === null) {
+            return 0;
+        }
+        var result = 1;
+        try {
+            for (var a_1 = __values(a), a_1_1 = a_1.next(); !a_1_1.done; a_1_1 = a_1.next()) {
+                var element = a_1_1.value;
+                result = 31 * result + element;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (a_1_1 && !a_1_1.done && (_a = a_1.return)) _a.call(a_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return result;
+    };
+    Arrays.fillUint8Array = function (a, value) {
+        for (var i = 0; i !== a.length; i++) {
+            a[i] = value;
+        }
+    };
+    Arrays.copyOf = function (original, newLength) {
+        return original.slice(0, newLength);
+    };
+    Arrays.copyOfUint8Array = function (original, newLength) {
+        if (original.length <= newLength) {
+            var newArray = new Uint8Array(newLength);
+            newArray.set(original);
+            return newArray;
+        }
+        return original.slice(0, newLength);
+    };
+    Arrays.copyOfRange = function (original, from, to) {
+        var newLength = to - from;
+        var copy = new Int32Array(newLength);
+        System_1.default.arraycopy(original, from, copy, 0, newLength);
+        return copy;
+    };
+    /*
+    * Returns the index of of the element in a sorted array or (-n-1) where n is the insertion point
+    * for the new element.
+    * Parameters:
+    *     ar - A sorted array
+    *     el - An element to search for
+    *     comparator - A comparator function. The function takes two arguments: (a, b) and returns:
+    *        a negative number  if a is less than b;
+    *        0 if a is equal to b;
+    *        a positive number of a is greater than b.
+    * The array may contain duplicate elements. If there are more than one equal elements in the array,
+    * the returned value can be the index of any one of the equal elements.
+    *
+    * http://jsfiddle.net/aryzhov/pkfst550/
+    */
+    Arrays.binarySearch = function (ar, el, comparator) {
+        if (undefined === comparator) {
+            comparator = Arrays.numberComparator;
+        }
+        var m = 0;
+        var n = ar.length - 1;
+        while (m <= n) {
+            var k = (n + m) >> 1;
+            var cmp = comparator(el, ar[k]);
+            if (cmp > 0) {
+                m = k + 1;
+            }
+            else if (cmp < 0) {
+                n = k - 1;
+            }
+            else {
+                return k;
+            }
+        }
+        return -m - 1;
+    };
+    Arrays.numberComparator = function (a, b) {
+        return a - b;
+    };
+    return Arrays;
+}());
+exports.default = Arrays;
+//# sourceMappingURL=Arrays.js.map

package/template/node_modules/@zxing/library/cjs/core/util/Arrays.js.map

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

package/template/node_modules/@zxing/library/cjs/core/util/ByteArrayOutputStream.d.ts

@@ -0,0 +1,174 @@
+import OutputStream from './OutputStream';
+import { int } from '../../customTypings';
+/**
+ * This class implements an output stream in which the data is
+ * written into a byte array. The buffer automatically grows as data
+ * is written to it.
+ * The data can be retrieved using <code>toByteArray()</code> and
+ * <code>toString()</code>.
+ * <p>
+ * Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
+ * this class can be called after the stream has been closed without
+ * generating an <tt>IOException</tt>.
+ *
+ * @author  Arthur van Hoff
+ * @since   JDK1.0
+ */
+export default class ByteArrayOutputStream extends OutputStream {
+    /**
+     * The buffer where data is stored.
+     */
+    protected buf: Uint8Array;
+    /**
+     * The number of valid bytes in the buffer.
+     */
+    protected count: int;
+    /**
+     * Creates a new byte array output stream. The buffer capacity is
+     * initially 32 bytes, though its size increases if necessary.
+     */
+    /**
+     * Creates a new byte array output stream, with a buffer capacity of
+     * the specified size, in bytes.
+     *
+     * @param   size   the initial size.
+     * @exception  IllegalArgumentException if size is negative.
+     */
+    constructor(size?: int);
+    /**
+     * Increases the capacity if necessary to ensure that it can hold
+     * at least the number of elements specified by the minimum
+     * capacity argument.
+     *
+     * @param minCapacity the desired minimum capacity
+     * @throws OutOfMemoryError if {@code minCapacity < 0}.  This is
+     * interpreted as a request for the unsatisfiably large capacity
+     * {@code (long) Integer.MAX_VALUE + (minCapacity - Integer.MAX_VALUE)}.
+     */
+    private ensureCapacity;
+    /**
+     * Increases the capacity to ensure that it can hold at least the
+     * number of elements specified by the minimum capacity argument.
+     *
+     * @param minCapacity the desired minimum capacity
+     */
+    private grow;
+    /**
+     * Writes the specified byte to this byte array output stream.
+     *
+     * @param   b   the byte to be written.
+     */
+    write(b: int): void;
+    /**
+     * Writes <code>len</code> bytes from the specified byte array
+     * starting at offset <code>off</code> to this byte array output stream.
+     *
+     * @param   b     the data.
+     * @param   off   the start offset in the data.
+     * @param   len   the number of bytes to write.
+     */
+    writeBytesOffset(b: Uint8Array, off: int, len: int): void;
+    /**
+     * Writes the complete contents of this byte array output stream to
+     * the specified output stream argument, as if by calling the output
+     * stream's write method using <code>out.write(buf, 0, count)</code>.
+     *
+     * @param      out   the output stream to which to write the data.
+     * @exception  IOException  if an I/O error occurs.
+     */
+    writeTo(out: OutputStream): void;
+    /**
+     * Resets the <code>count</code> field of this byte array output
+     * stream to zero, so that all currently accumulated output in the
+     * output stream is discarded. The output stream can be used again,
+     * reusing the already allocated buffer space.
+     *
+     * @see     java.io.ByteArrayInputStream#count
+     */
+    reset(): void;
+    /**
+     * Creates a newly allocated byte array. Its size is the current
+     * size of this output stream and the valid contents of the buffer
+     * have been copied into it.
+     *
+     * @return  the current contents of this output stream, as a byte array.
+     * @see     java.io.ByteArrayOutputStream#size()
+     */
+    toByteArray(): Uint8Array;
+    /**
+     * Returns the current size of the buffer.
+     *
+     * @return  the value of the <code>count</code> field, which is the number
+     *          of valid bytes in this output stream.
+     * @see     java.io.ByteArrayOutputStream#count
+     */
+    size(): int;
+    toString(param?: number | string): string;
+    /**
+     * Converts the buffer's contents into a string decoding bytes using the
+     * platform's default character set. The length of the new <tt>String</tt>
+     * is a function of the character set, and hence may not be equal to the
+     * size of the buffer.
+     *
+     * <p> This method always replaces malformed-input and unmappable-character
+     * sequences with the default replacement string for the platform's
+     * default character set. The {@linkplain java.nio.charset.CharsetDecoder}
+     * class should be used when more control over the decoding process is
+     * required.
+     *
+     * @return String decoded from the buffer's contents.
+     * @since  JDK1.1
+     */
+    toString_void(): string;
+    /**
+     * Converts the buffer's contents into a string by decoding the bytes using
+     * the specified {@link java.nio.charset.Charset charsetName}. The length of
+     * the new <tt>String</tt> is a function of the charset, and hence may not be
+     * equal to the length of the byte array.
+     *
+     * <p> This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement string. The {@link
+     * java.nio.charset.CharsetDecoder} class should be used when more control
+     * over the decoding process is required.
+     *
+     * @param  charsetName  the name of a supported
+     *              {@linkplain java.nio.charset.Charset </code>charset<code>}
+     * @return String decoded from the buffer's contents.
+     * @exception  UnsupportedEncodingException
+     *             If the named charset is not supported
+     * @since   JDK1.1
+     */
+    toString_string(charsetName: string): string;
+    /**
+     * Creates a newly allocated string. Its size is the current size of
+     * the output stream and the valid contents of the buffer have been
+     * copied into it. Each character <i>c</i> in the resulting string is
+     * constructed from the corresponding element <i>b</i> in the byte
+     * array such that:
+     * <blockquote><pre>
+     *     c == (char)(((hibyte &amp; 0xff) &lt;&lt; 8) | (b &amp; 0xff))
+     * </pre></blockquote>
+     *
+     * @deprecated This method does not properly convert bytes into characters.
+     * As of JDK&nbsp;1.1, the preferred way to do this is via the
+     * <code>toString(String enc)</code> method, which takes an encoding-name
+     * argument, or the <code>toString()</code> method, which uses the
+     * platform's default character encoding.
+     *
+     * @param      hibyte    the high byte of each resulting Unicode character.
+     * @return     the current contents of the output stream, as a string.
+     * @see        java.io.ByteArrayOutputStream#size()
+     * @see        java.io.ByteArrayOutputStream#toString(String)
+     * @see        java.io.ByteArrayOutputStream#toString()
+     */
+    toString_number(hibyte: int): string;
+    /**
+     * Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
+     * this class can be called after the stream has been closed without
+     * generating an <tt>IOException</tt>.
+     * <p>
+     *
+     * @throws IOException
+     */
+    close(): void;
+}

package/template/node_modules/@zxing/library/cjs/core/util/ByteArrayOutputStream.js

@@ -0,0 +1,284 @@
+"use strict";
+/*
+ * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// package java.io;
+// import java.util.Arrays;
+var Arrays_1 = require("./Arrays");
+var OutputStream_1 = require("./OutputStream");
+var Integer_1 = require("./Integer");
+var IllegalArgumentException_1 = require("../IllegalArgumentException");
+var OutOfMemoryError_1 = require("../OutOfMemoryError");
+var System_1 = require("./System");
+var IndexOutOfBoundsException_1 = require("../IndexOutOfBoundsException");
+/**
+ * This class implements an output stream in which the data is
+ * written into a byte array. The buffer automatically grows as data
+ * is written to it.
+ * The data can be retrieved using <code>toByteArray()</code> and
+ * <code>toString()</code>.
+ * <p>
+ * Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
+ * this class can be called after the stream has been closed without
+ * generating an <tt>IOException</tt>.
+ *
+ * @author  Arthur van Hoff
+ * @since   JDK1.0
+ */
+var ByteArrayOutputStream = /** @class */ (function (_super) {
+    __extends(ByteArrayOutputStream, _super);
+    /**
+     * Creates a new byte array output stream. The buffer capacity is
+     * initially 32 bytes, though its size increases if necessary.
+     */
+    // public constructor() {
+    //     this(32);
+    // }
+    /**
+     * Creates a new byte array output stream, with a buffer capacity of
+     * the specified size, in bytes.
+     *
+     * @param   size   the initial size.
+     * @exception  IllegalArgumentException if size is negative.
+     */
+    function ByteArrayOutputStream(size) {
+        if (size === void 0) { size = 32; }
+        var _this = _super.call(this) || this;
+        /**
+         * The number of valid bytes in the buffer.
+         */
+        _this.count = 0;
+        if (size < 0) {
+            throw new IllegalArgumentException_1.default('Negative initial size: '
+                + size);
+        }
+        _this.buf = new Uint8Array(size);
+        return _this;
+    }
+    /**
+     * Increases the capacity if necessary to ensure that it can hold
+     * at least the number of elements specified by the minimum
+     * capacity argument.
+     *
+     * @param minCapacity the desired minimum capacity
+     * @throws OutOfMemoryError if {@code minCapacity < 0}.  This is
+     * interpreted as a request for the unsatisfiably large capacity
+     * {@code (long) Integer.MAX_VALUE + (minCapacity - Integer.MAX_VALUE)}.
+     */
+    ByteArrayOutputStream.prototype.ensureCapacity = function (minCapacity) {
+        // overflow-conscious code
+        if (minCapacity - this.buf.length > 0)
+            this.grow(minCapacity);
+    };
+    /**
+     * Increases the capacity to ensure that it can hold at least the
+     * number of elements specified by the minimum capacity argument.
+     *
+     * @param minCapacity the desired minimum capacity
+     */
+    ByteArrayOutputStream.prototype.grow = function (minCapacity) {
+        // overflow-conscious code
+        var oldCapacity = this.buf.length;
+        var newCapacity = oldCapacity << 1;
+        if (newCapacity - minCapacity < 0)
+            newCapacity = minCapacity;
+        if (newCapacity < 0) {
+            if (minCapacity < 0) // overflow
+                throw new OutOfMemoryError_1.default();
+            newCapacity = Integer_1.default.MAX_VALUE;
+        }
+        this.buf = Arrays_1.default.copyOfUint8Array(this.buf, newCapacity);
+    };
+    /**
+     * Writes the specified byte to this byte array output stream.
+     *
+     * @param   b   the byte to be written.
+     */
+    ByteArrayOutputStream.prototype.write = function (b) {
+        this.ensureCapacity(this.count + 1);
+        this.buf[this.count] = /*(byte)*/ b;
+        this.count += 1;
+    };
+    /**
+     * Writes <code>len</code> bytes from the specified byte array
+     * starting at offset <code>off</code> to this byte array output stream.
+     *
+     * @param   b     the data.
+     * @param   off   the start offset in the data.
+     * @param   len   the number of bytes to write.
+     */
+    ByteArrayOutputStream.prototype.writeBytesOffset = function (b, off, len) {
+        if ((off < 0) || (off > b.length) || (len < 0) ||
+            ((off + len) - b.length > 0)) {
+            throw new IndexOutOfBoundsException_1.default();
+        }
+        this.ensureCapacity(this.count + len);
+        System_1.default.arraycopy(b, off, this.buf, this.count, len);
+        this.count += len;
+    };
+    /**
+     * Writes the complete contents of this byte array output stream to
+     * the specified output stream argument, as if by calling the output
+     * stream's write method using <code>out.write(buf, 0, count)</code>.
+     *
+     * @param      out   the output stream to which to write the data.
+     * @exception  IOException  if an I/O error occurs.
+     */
+    ByteArrayOutputStream.prototype.writeTo = function (out) {
+        out.writeBytesOffset(this.buf, 0, this.count);
+    };
+    /**
+     * Resets the <code>count</code> field of this byte array output
+     * stream to zero, so that all currently accumulated output in the
+     * output stream is discarded. The output stream can be used again,
+     * reusing the already allocated buffer space.
+     *
+     * @see     java.io.ByteArrayInputStream#count
+     */
+    ByteArrayOutputStream.prototype.reset = function () {
+        this.count = 0;
+    };
+    /**
+     * Creates a newly allocated byte array. Its size is the current
+     * size of this output stream and the valid contents of the buffer
+     * have been copied into it.
+     *
+     * @return  the current contents of this output stream, as a byte array.
+     * @see     java.io.ByteArrayOutputStream#size()
+     */
+    ByteArrayOutputStream.prototype.toByteArray = function () {
+        return Arrays_1.default.copyOfUint8Array(this.buf, this.count);
+    };
+    /**
+     * Returns the current size of the buffer.
+     *
+     * @return  the value of the <code>count</code> field, which is the number
+     *          of valid bytes in this output stream.
+     * @see     java.io.ByteArrayOutputStream#count
+     */
+    ByteArrayOutputStream.prototype.size = function () {
+        return this.count;
+    };
+    ByteArrayOutputStream.prototype.toString = function (param) {
+        if (!param) {
+            return this.toString_void();
+        }
+        if (typeof param === 'string') {
+            return this.toString_string(param);
+        }
+        return this.toString_number(param);
+    };
+    /**
+     * Converts the buffer's contents into a string decoding bytes using the
+     * platform's default character set. The length of the new <tt>String</tt>
+     * is a function of the character set, and hence may not be equal to the
+     * size of the buffer.
+     *
+     * <p> This method always replaces malformed-input and unmappable-character
+     * sequences with the default replacement string for the platform's
+     * default character set. The {@linkplain java.nio.charset.CharsetDecoder}
+     * class should be used when more control over the decoding process is
+     * required.
+     *
+     * @return String decoded from the buffer's contents.
+     * @since  JDK1.1
+     */
+    ByteArrayOutputStream.prototype.toString_void = function () {
+        return new String(this.buf /*, 0, this.count*/).toString();
+    };
+    /**
+     * Converts the buffer's contents into a string by decoding the bytes using
+     * the specified {@link java.nio.charset.Charset charsetName}. The length of
+     * the new <tt>String</tt> is a function of the charset, and hence may not be
+     * equal to the length of the byte array.
+     *
+     * <p> This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement string. The {@link
+     * java.nio.charset.CharsetDecoder} class should be used when more control
+     * over the decoding process is required.
+     *
+     * @param  charsetName  the name of a supported
+     *              {@linkplain java.nio.charset.Charset </code>charset<code>}
+     * @return String decoded from the buffer's contents.
+     * @exception  UnsupportedEncodingException
+     *             If the named charset is not supported
+     * @since   JDK1.1
+     */
+    ByteArrayOutputStream.prototype.toString_string = function (charsetName) {
+        return new String(this.buf /*, 0, this.count, charsetName*/).toString();
+    };
+    /**
+     * Creates a newly allocated string. Its size is the current size of
+     * the output stream and the valid contents of the buffer have been
+     * copied into it. Each character <i>c</i> in the resulting string is
+     * constructed from the corresponding element <i>b</i> in the byte
+     * array such that:
+     * <blockquote><pre>
+     *     c == (char)(((hibyte &amp; 0xff) &lt;&lt; 8) | (b &amp; 0xff))
+     * </pre></blockquote>
+     *
+     * @deprecated This method does not properly convert bytes into characters.
+     * As of JDK&nbsp;1.1, the preferred way to do this is via the
+     * <code>toString(String enc)</code> method, which takes an encoding-name
+     * argument, or the <code>toString()</code> method, which uses the
+     * platform's default character encoding.
+     *
+     * @param      hibyte    the high byte of each resulting Unicode character.
+     * @return     the current contents of the output stream, as a string.
+     * @see        java.io.ByteArrayOutputStream#size()
+     * @see        java.io.ByteArrayOutputStream#toString(String)
+     * @see        java.io.ByteArrayOutputStream#toString()
+     */
+    // @Deprecated
+    ByteArrayOutputStream.prototype.toString_number = function (hibyte) {
+        return new String(this.buf /*, hibyte, 0, this.count*/).toString();
+    };
+    /**
+     * Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
+     * this class can be called after the stream has been closed without
+     * generating an <tt>IOException</tt>.
+     * <p>
+     *
+     * @throws IOException
+     */
+    ByteArrayOutputStream.prototype.close = function () {
+    };
+    return ByteArrayOutputStream;
+}(OutputStream_1.default));
+exports.default = ByteArrayOutputStream;
+//# sourceMappingURL=ByteArrayOutputStream.js.map

package/template/node_modules/@zxing/library/cjs/core/util/ByteArrayOutputStream.js.map

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

package/template/node_modules/@zxing/library/cjs/core/util/Charset.d.ts

@@ -0,0 +1,7 @@
+import CharacterSetECI from '../common/CharacterSetECI';
+/**
+ * Just to make a shortcut between Java code and TS code.
+ */
+export default class Charset extends CharacterSetECI {
+    static forName(name: string): Charset;
+}