@falcon-ui/falcon-ui 1.0.0

package/esm/components/barcode/JsBarcode-C5ux6wsb.js

@@ -0,0 +1,3514 @@
+import { t as __commonJSMin } from "./chunk--em_ddB3.js";
+var require_Barcode = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _classCallCheck$30(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	exports.default = function Barcode$1(data, options) {
+		_classCallCheck$30(this, Barcode$1);
+		this.data = data;
+		this.text = options.text || data;
+		this.options = options;
+	};
+}));
+var require_CODE39 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.CODE39 = void 0;
+	var _createClass$23 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _Barcode3$12 = _interopRequireDefault$36(require_Barcode());
+	function _interopRequireDefault$36(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$29(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$25(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$25(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	var CODE39 = function(_Barcode) {
+		_inherits$25(CODE39$1, _Barcode);
+		function CODE39$1(data, options) {
+			_classCallCheck$29(this, CODE39$1);
+			data = data.toUpperCase();
+			if (options.mod43) data += getCharacter(mod43checksum(data));
+			return _possibleConstructorReturn$25(this, (CODE39$1.__proto__ || Object.getPrototypeOf(CODE39$1)).call(this, data, options));
+		}
+		_createClass$23(CODE39$1, [{
+			key: "encode",
+			value: function encode$2() {
+				var result = getEncoding("*");
+				for (var i = 0; i < this.data.length; i++) result += getEncoding(this.data[i]) + "0";
+				result += getEncoding("*");
+				return {
+					data: result,
+					text: this.text
+				};
+			}
+		}, {
+			key: "valid",
+			value: function valid() {
+				return this.data.search(/^[0-9A-Z\-\.\ \$\/\+\%]+$/) !== -1;
+			}
+		}]);
+		return CODE39$1;
+	}(_Barcode3$12.default);
+	var characters = [
+		"0",
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"A",
+		"B",
+		"C",
+		"D",
+		"E",
+		"F",
+		"G",
+		"H",
+		"I",
+		"J",
+		"K",
+		"L",
+		"M",
+		"N",
+		"O",
+		"P",
+		"Q",
+		"R",
+		"S",
+		"T",
+		"U",
+		"V",
+		"W",
+		"X",
+		"Y",
+		"Z",
+		"-",
+		".",
+		" ",
+		"$",
+		"/",
+		"+",
+		"%",
+		"*"
+	];
+	var encodings = [
+		20957,
+		29783,
+		23639,
+		30485,
+		20951,
+		29813,
+		23669,
+		20855,
+		29789,
+		23645,
+		29975,
+		23831,
+		30533,
+		22295,
+		30149,
+		24005,
+		21623,
+		29981,
+		23837,
+		22301,
+		30023,
+		23879,
+		30545,
+		22343,
+		30161,
+		24017,
+		21959,
+		30065,
+		23921,
+		22385,
+		29015,
+		18263,
+		29141,
+		17879,
+		29045,
+		18293,
+		17783,
+		29021,
+		18269,
+		17477,
+		17489,
+		17681,
+		20753,
+		35770
+	];
+	function getEncoding(character) {
+		return getBinary(characterValue(character));
+	}
+	function getBinary(characterValue$1) {
+		return encodings[characterValue$1].toString(2);
+	}
+	function getCharacter(characterValue$1) {
+		return characters[characterValue$1];
+	}
+	function characterValue(character) {
+		return characters.indexOf(character);
+	}
+	function mod43checksum(data) {
+		var checksum$5 = 0;
+		for (var i = 0; i < data.length; i++) checksum$5 += characterValue(data[i]);
+		checksum$5 = checksum$5 % 43;
+		return checksum$5;
+	}
+	exports.CODE39 = CODE39;
+}));
+var require_constants$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _SET_BY_CODE;
+	function _defineProperty(obj, key, value) {
+		if (key in obj) Object.defineProperty(obj, key, {
+			value,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+		else obj[key] = value;
+		return obj;
+	}
+	var SET_A = exports.SET_A = 0;
+	var SET_B = exports.SET_B = 1;
+	var SET_C = exports.SET_C = 2;
+	exports.SHIFT = 98;
+	var START_A = exports.START_A = 103;
+	var START_B = exports.START_B = 104;
+	var START_C = exports.START_C = 105;
+	exports.MODULO = 103;
+	exports.STOP = 106;
+	exports.FNC1 = 207;
+	exports.SET_BY_CODE = (_SET_BY_CODE = {}, _defineProperty(_SET_BY_CODE, START_A, SET_A), _defineProperty(_SET_BY_CODE, START_B, SET_B), _defineProperty(_SET_BY_CODE, START_C, SET_C), _SET_BY_CODE);
+	exports.SWAP = {
+		101: SET_A,
+		100: SET_B,
+		99: SET_C
+	};
+	exports.A_START_CHAR = String.fromCharCode(208);
+	exports.B_START_CHAR = String.fromCharCode(209);
+	exports.C_START_CHAR = String.fromCharCode(210);
+	exports.A_CHARS = "[\0-_È-Ï]";
+	exports.B_CHARS = "[ -È-Ï]";
+	exports.C_CHARS = "(Ï*[0-9]{2}Ï*)";
+	exports.BARS = [
+		11011001100,
+		11001101100,
+		11001100110,
+		10010011e3,
+		10010001100,
+		10001001100,
+		10011001e3,
+		10011000100,
+		10001100100,
+		11001001e3,
+		11001000100,
+		11000100100,
+		10110011100,
+		10011011100,
+		10011001110,
+		10111001100,
+		10011101100,
+		10011100110,
+		11001110010,
+		11001011100,
+		11001001110,
+		11011100100,
+		11001110100,
+		11101101110,
+		11101001100,
+		11100101100,
+		11100100110,
+		11101100100,
+		11100110100,
+		11100110010,
+		11011011e3,
+		11011000110,
+		11000110110,
+		10100011e3,
+		10001011e3,
+		10001000110,
+		10110001e3,
+		10001101e3,
+		10001100010,
+		11010001e3,
+		11000101e3,
+		11000100010,
+		10110111e3,
+		10110001110,
+		10001101110,
+		10111011e3,
+		10111000110,
+		10001110110,
+		11101110110,
+		11010001110,
+		11000101110,
+		11011101e3,
+		11011100010,
+		11011101110,
+		11101011e3,
+		11101000110,
+		11100010110,
+		11101101e3,
+		11101100010,
+		11100011010,
+		11101111010,
+		11001000010,
+		11110001010,
+		1010011e4,
+		10100001100,
+		1001011e4,
+		10010000110,
+		10000101100,
+		10000100110,
+		1011001e4,
+		10110000100,
+		1001101e4,
+		10011000010,
+		10000110100,
+		10000110010,
+		11000010010,
+		1100101e4,
+		11110111010,
+		11000010100,
+		10001111010,
+		10100111100,
+		10010111100,
+		10010011110,
+		10111100100,
+		10011110100,
+		10011110010,
+		11110100100,
+		11110010100,
+		11110010010,
+		11011011110,
+		11011110110,
+		11110110110,
+		10101111e3,
+		10100011110,
+		10001011110,
+		10111101e3,
+		10111100010,
+		11110101e3,
+		11110100010,
+		10111011110,
+		10111101110,
+		11101011110,
+		11110101110,
+		11010000100,
+		1101001e4,
+		11010011100,
+		1100011101011
+	];
+}));
+var require_CODE128$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$22 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _Barcode3$11 = _interopRequireDefault$35(require_Barcode());
+	var _constants$11 = require_constants$3();
+	function _interopRequireDefault$35(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$28(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$24(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$24(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_Barcode) {
+		_inherits$24(CODE128$1, _Barcode);
+		function CODE128$1(data, options) {
+			_classCallCheck$28(this, CODE128$1);
+			var _this = _possibleConstructorReturn$24(this, (CODE128$1.__proto__ || Object.getPrototypeOf(CODE128$1)).call(this, data.substring(1), options));
+			_this.bytes = data.split("").map(function(char) {
+				return char.charCodeAt(0);
+			});
+			return _this;
+		}
+		_createClass$22(CODE128$1, [
+			{
+				key: "valid",
+				value: function valid() {
+					return /^[\x00-\x7F\xC8-\xD3]+$/.test(this.data);
+				}
+			},
+			{
+				key: "encode",
+				value: function encode$2() {
+					var bytes = this.bytes;
+					var startIndex = bytes.shift() - 105;
+					var startSet = _constants$11.SET_BY_CODE[startIndex];
+					if (startSet === void 0) throw new RangeError("The encoding does not start with a start character.");
+					if (this.shouldEncodeAsEan128() === true) bytes.unshift(_constants$11.FNC1);
+					var encodingResult = CODE128$1.next(bytes, 1, startSet);
+					return {
+						text: this.text === this.data ? this.text.replace(/[^\x20-\x7E]/g, "") : this.text,
+						data: CODE128$1.getBar(startIndex) + encodingResult.result + CODE128$1.getBar((encodingResult.checksum + startIndex) % _constants$11.MODULO) + CODE128$1.getBar(_constants$11.STOP)
+					};
+				}
+			},
+			{
+				key: "shouldEncodeAsEan128",
+				value: function shouldEncodeAsEan128() {
+					var isEAN128 = this.options.ean128 || false;
+					if (typeof isEAN128 === "string") isEAN128 = isEAN128.toLowerCase() === "true";
+					return isEAN128;
+				}
+			}
+		], [
+			{
+				key: "getBar",
+				value: function getBar(index) {
+					return _constants$11.BARS[index] ? _constants$11.BARS[index].toString() : "";
+				}
+			},
+			{
+				key: "correctIndex",
+				value: function correctIndex(bytes, set) {
+					if (set === _constants$11.SET_A) {
+						var charCode = bytes.shift();
+						return charCode < 32 ? charCode + 64 : charCode - 32;
+					} else if (set === _constants$11.SET_B) return bytes.shift() - 32;
+					else return (bytes.shift() - 48) * 10 + bytes.shift() - 48;
+				}
+			},
+			{
+				key: "next",
+				value: function next(bytes, pos, set) {
+					if (!bytes.length) return {
+						result: "",
+						checksum: 0
+					};
+					var nextCode = void 0, index = void 0;
+					if (bytes[0] >= 200) {
+						index = bytes.shift() - 105;
+						var nextSet = _constants$11.SWAP[index];
+						if (nextSet !== void 0) nextCode = CODE128$1.next(bytes, pos + 1, nextSet);
+						else {
+							if ((set === _constants$11.SET_A || set === _constants$11.SET_B) && index === _constants$11.SHIFT) bytes[0] = set === _constants$11.SET_A ? bytes[0] > 95 ? bytes[0] - 96 : bytes[0] : bytes[0] < 32 ? bytes[0] + 96 : bytes[0];
+							nextCode = CODE128$1.next(bytes, pos + 1, set);
+						}
+					} else {
+						index = CODE128$1.correctIndex(bytes, set);
+						nextCode = CODE128$1.next(bytes, pos + 1, set);
+					}
+					var enc = CODE128$1.getBar(index);
+					var weight = index * pos;
+					return {
+						result: enc + nextCode.result,
+						checksum: weight + nextCode.checksum
+					};
+				}
+			}
+		]);
+		return CODE128$1;
+	}(_Barcode3$11.default);
+}));
+var require_auto = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _constants$10 = require_constants$3();
+	var matchSetALength = function matchSetALength$1(string) {
+		return string.match(/* @__PURE__ */ new RegExp("^" + _constants$10.A_CHARS + "*"))[0].length;
+	};
+	var matchSetBLength = function matchSetBLength$1(string) {
+		return string.match(/* @__PURE__ */ new RegExp("^" + _constants$10.B_CHARS + "*"))[0].length;
+	};
+	var matchSetC = function matchSetC$1(string) {
+		return string.match(/* @__PURE__ */ new RegExp("^" + _constants$10.C_CHARS + "*"))[0];
+	};
+	function autoSelectFromAB(string, isA) {
+		var ranges = isA ? _constants$10.A_CHARS : _constants$10.B_CHARS;
+		var untilC = string.match(/* @__PURE__ */ new RegExp("^(" + ranges + "+?)(([0-9]{2}){2,})([^0-9]|$)"));
+		if (untilC) return untilC[1] + String.fromCharCode(204) + autoSelectFromC(string.substring(untilC[1].length));
+		var chars = string.match(/* @__PURE__ */ new RegExp("^" + ranges + "+"))[0];
+		if (chars.length === string.length) return string;
+		return chars + String.fromCharCode(isA ? 205 : 206) + autoSelectFromAB(string.substring(chars.length), !isA);
+	}
+	function autoSelectFromC(string) {
+		var cMatch = matchSetC(string);
+		var length = cMatch.length;
+		if (length === string.length) return string;
+		string = string.substring(length);
+		var isA = matchSetALength(string) >= matchSetBLength(string);
+		return cMatch + String.fromCharCode(isA ? 206 : 205) + autoSelectFromAB(string, isA);
+	}
+	exports.default = function(string) {
+		var newString = void 0;
+		if (matchSetC(string).length >= 2) newString = _constants$10.C_START_CHAR + autoSelectFromC(string);
+		else {
+			var isA = matchSetALength(string) > matchSetBLength(string);
+			newString = (isA ? _constants$10.A_START_CHAR : _constants$10.B_START_CHAR) + autoSelectFromAB(string, isA);
+		}
+		return newString.replace(/[\xCD\xCE]([^])[\xCD\xCE]/, function(match, char) {
+			return String.fromCharCode(203) + char;
+		});
+	};
+}));
+var require_CODE128_AUTO = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _CODE3$5 = _interopRequireDefault$34(require_CODE128$1());
+	var _auto2 = _interopRequireDefault$34(require_auto());
+	function _interopRequireDefault$34(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$27(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$23(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$23(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_CODE$1) {
+		_inherits$23(CODE128AUTO$1, _CODE$1);
+		function CODE128AUTO$1(data, options) {
+			_classCallCheck$27(this, CODE128AUTO$1);
+			if (/^[\x00-\x7F\xC8-\xD3]+$/.test(data)) var _this = _possibleConstructorReturn$23(this, (CODE128AUTO$1.__proto__ || Object.getPrototypeOf(CODE128AUTO$1)).call(this, (0, _auto2.default)(data), options));
+			else var _this = _possibleConstructorReturn$23(this, (CODE128AUTO$1.__proto__ || Object.getPrototypeOf(CODE128AUTO$1)).call(this, data, options));
+			return _possibleConstructorReturn$23(_this);
+		}
+		return CODE128AUTO$1;
+	}(_CODE3$5.default);
+}));
+var require_CODE128A = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$21 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _CODE3$4 = _interopRequireDefault$33(require_CODE128$1());
+	var _constants$9 = require_constants$3();
+	function _interopRequireDefault$33(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$26(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$22(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$22(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_CODE$1) {
+		_inherits$22(CODE128A$1, _CODE$1);
+		function CODE128A$1(string, options) {
+			_classCallCheck$26(this, CODE128A$1);
+			return _possibleConstructorReturn$22(this, (CODE128A$1.__proto__ || Object.getPrototypeOf(CODE128A$1)).call(this, _constants$9.A_START_CHAR + string, options));
+		}
+		_createClass$21(CODE128A$1, [{
+			key: "valid",
+			value: function valid() {
+				return (/* @__PURE__ */ new RegExp("^" + _constants$9.A_CHARS + "+$")).test(this.data);
+			}
+		}]);
+		return CODE128A$1;
+	}(_CODE3$4.default);
+}));
+var require_CODE128B = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$20 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _CODE3$3 = _interopRequireDefault$32(require_CODE128$1());
+	var _constants$8 = require_constants$3();
+	function _interopRequireDefault$32(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$25(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$21(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$21(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_CODE$1) {
+		_inherits$21(CODE128B$1, _CODE$1);
+		function CODE128B$1(string, options) {
+			_classCallCheck$25(this, CODE128B$1);
+			return _possibleConstructorReturn$21(this, (CODE128B$1.__proto__ || Object.getPrototypeOf(CODE128B$1)).call(this, _constants$8.B_START_CHAR + string, options));
+		}
+		_createClass$20(CODE128B$1, [{
+			key: "valid",
+			value: function valid() {
+				return (/* @__PURE__ */ new RegExp("^" + _constants$8.B_CHARS + "+$")).test(this.data);
+			}
+		}]);
+		return CODE128B$1;
+	}(_CODE3$3.default);
+}));
+var require_CODE128C = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$19 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _CODE3$2 = _interopRequireDefault$31(require_CODE128$1());
+	var _constants$7 = require_constants$3();
+	function _interopRequireDefault$31(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$24(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$20(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$20(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_CODE$1) {
+		_inherits$20(CODE128C$1, _CODE$1);
+		function CODE128C$1(string, options) {
+			_classCallCheck$24(this, CODE128C$1);
+			return _possibleConstructorReturn$20(this, (CODE128C$1.__proto__ || Object.getPrototypeOf(CODE128C$1)).call(this, _constants$7.C_START_CHAR + string, options));
+		}
+		_createClass$19(CODE128C$1, [{
+			key: "valid",
+			value: function valid() {
+				return (/* @__PURE__ */ new RegExp("^" + _constants$7.C_CHARS + "+$")).test(this.data);
+			}
+		}]);
+		return CODE128C$1;
+	}(_CODE3$2.default);
+}));
+var require_CODE128 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.CODE128C = exports.CODE128B = exports.CODE128A = exports.CODE128 = void 0;
+	var _CODE128_AUTO2 = _interopRequireDefault$30(require_CODE128_AUTO());
+	var _CODE128A2 = _interopRequireDefault$30(require_CODE128A());
+	var _CODE128B2 = _interopRequireDefault$30(require_CODE128B());
+	var _CODE128C2 = _interopRequireDefault$30(require_CODE128C());
+	function _interopRequireDefault$30(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	exports.CODE128 = _CODE128_AUTO2.default;
+	exports.CODE128A = _CODE128A2.default;
+	exports.CODE128B = _CODE128B2.default;
+	exports.CODE128C = _CODE128C2.default;
+}));
+var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.SIDE_BIN = "101";
+	exports.MIDDLE_BIN = "01010";
+	exports.BINARIES = {
+		"L": [
+			"0001101",
+			"0011001",
+			"0010011",
+			"0111101",
+			"0100011",
+			"0110001",
+			"0101111",
+			"0111011",
+			"0110111",
+			"0001011"
+		],
+		"G": [
+			"0100111",
+			"0110011",
+			"0011011",
+			"0100001",
+			"0011101",
+			"0111001",
+			"0000101",
+			"0010001",
+			"0001001",
+			"0010111"
+		],
+		"R": [
+			"1110010",
+			"1100110",
+			"1101100",
+			"1000010",
+			"1011100",
+			"1001110",
+			"1010000",
+			"1000100",
+			"1001000",
+			"1110100"
+		],
+		"O": [
+			"0001101",
+			"0011001",
+			"0010011",
+			"0111101",
+			"0100011",
+			"0110001",
+			"0101111",
+			"0111011",
+			"0110111",
+			"0001011"
+		],
+		"E": [
+			"0100111",
+			"0110011",
+			"0011011",
+			"0100001",
+			"0011101",
+			"0111001",
+			"0000101",
+			"0010001",
+			"0001001",
+			"0010111"
+		]
+	};
+	exports.EAN2_STRUCTURE = [
+		"LL",
+		"LG",
+		"GL",
+		"GG"
+	];
+	exports.EAN5_STRUCTURE = [
+		"GGLLL",
+		"GLGLL",
+		"GLLGL",
+		"GLLLG",
+		"LGGLL",
+		"LLGGL",
+		"LLLGG",
+		"LGLGL",
+		"LGLLG",
+		"LLGLG"
+	];
+	exports.EAN13_STRUCTURE = [
+		"LLLLLL",
+		"LLGLGG",
+		"LLGGLG",
+		"LLGGGL",
+		"LGLLGG",
+		"LGGLLG",
+		"LGGGLL",
+		"LGLGLG",
+		"LGLGGL",
+		"LGGLGL"
+	];
+}));
+var require_encoder = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _constants$6 = require_constants$2();
+	exports.default = function encode$2(data, structure, separator) {
+		var encoded = data.split("").map(function(val, idx) {
+			return _constants$6.BINARIES[structure[idx]];
+		}).map(function(val, idx) {
+			return val ? val[data[idx]] : "";
+		});
+		if (separator) {
+			var last = data.length - 1;
+			encoded = encoded.map(function(val, idx) {
+				return idx < last ? val + separator : val;
+			});
+		}
+		return encoded.join("");
+	};
+}));
+var require_EAN = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$18 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _constants$5 = require_constants$2();
+	var _encoder2$4 = _interopRequireDefault$29(require_encoder());
+	var _Barcode3$10 = _interopRequireDefault$29(require_Barcode());
+	function _interopRequireDefault$29(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$23(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$19(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$19(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_Barcode) {
+		_inherits$19(EAN$1, _Barcode);
+		function EAN$1(data, options) {
+			_classCallCheck$23(this, EAN$1);
+			var _this = _possibleConstructorReturn$19(this, (EAN$1.__proto__ || Object.getPrototypeOf(EAN$1)).call(this, data, options));
+			_this.fontSize = !options.flat && options.fontSize > options.width * 10 ? options.width * 10 : options.fontSize;
+			_this.guardHeight = options.height + _this.fontSize / 2 + options.textMargin;
+			return _this;
+		}
+		_createClass$18(EAN$1, [
+			{
+				key: "encode",
+				value: function encode$2() {
+					return this.options.flat ? this.encodeFlat() : this.encodeGuarded();
+				}
+			},
+			{
+				key: "leftText",
+				value: function leftText(from, to) {
+					return this.text.substr(from, to);
+				}
+			},
+			{
+				key: "leftEncode",
+				value: function leftEncode(data, structure) {
+					return (0, _encoder2$4.default)(data, structure);
+				}
+			},
+			{
+				key: "rightText",
+				value: function rightText(from, to) {
+					return this.text.substr(from, to);
+				}
+			},
+			{
+				key: "rightEncode",
+				value: function rightEncode(data, structure) {
+					return (0, _encoder2$4.default)(data, structure);
+				}
+			},
+			{
+				key: "encodeGuarded",
+				value: function encodeGuarded() {
+					var textOptions = { fontSize: this.fontSize };
+					var guardOptions = { height: this.guardHeight };
+					return [
+						{
+							data: _constants$5.SIDE_BIN,
+							options: guardOptions
+						},
+						{
+							data: this.leftEncode(),
+							text: this.leftText(),
+							options: textOptions
+						},
+						{
+							data: _constants$5.MIDDLE_BIN,
+							options: guardOptions
+						},
+						{
+							data: this.rightEncode(),
+							text: this.rightText(),
+							options: textOptions
+						},
+						{
+							data: _constants$5.SIDE_BIN,
+							options: guardOptions
+						}
+					];
+				}
+			},
+			{
+				key: "encodeFlat",
+				value: function encodeFlat() {
+					return {
+						data: [
+							_constants$5.SIDE_BIN,
+							this.leftEncode(),
+							_constants$5.MIDDLE_BIN,
+							this.rightEncode(),
+							_constants$5.SIDE_BIN
+						].join(""),
+						text: this.text
+					};
+				}
+			}
+		]);
+		return EAN$1;
+	}(_Barcode3$10.default);
+}));
+var require_EAN13 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$17 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _get$1 = function get(object, property, receiver) {
+		if (object === null) object = Function.prototype;
+		var desc = Object.getOwnPropertyDescriptor(object, property);
+		if (desc === void 0) {
+			var parent = Object.getPrototypeOf(object);
+			if (parent === null) return;
+			else return get(parent, property, receiver);
+		} else if ("value" in desc) return desc.value;
+		else {
+			var getter = desc.get;
+			if (getter === void 0) return;
+			return getter.call(receiver);
+		}
+	};
+	var _constants$4 = require_constants$2();
+	var _EAN3$1 = _interopRequireDefault$28(require_EAN());
+	function _interopRequireDefault$28(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$22(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$18(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$18(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	var checksum$4 = function checksum$5(number) {
+		return (10 - number.substr(0, 12).split("").map(function(n) {
+			return +n;
+		}).reduce(function(sum, a, idx) {
+			return idx % 2 ? sum + a * 3 : sum + a;
+		}, 0) % 10) % 10;
+	};
+	exports.default = function(_EAN) {
+		_inherits$18(EAN13$1, _EAN);
+		function EAN13$1(data, options) {
+			_classCallCheck$22(this, EAN13$1);
+			if (data.search(/^[0-9]{12}$/) !== -1) data += checksum$4(data);
+			var _this = _possibleConstructorReturn$18(this, (EAN13$1.__proto__ || Object.getPrototypeOf(EAN13$1)).call(this, data, options));
+			_this.lastChar = options.lastChar;
+			return _this;
+		}
+		_createClass$17(EAN13$1, [
+			{
+				key: "valid",
+				value: function valid() {
+					return this.data.search(/^[0-9]{13}$/) !== -1 && +this.data[12] === checksum$4(this.data);
+				}
+			},
+			{
+				key: "leftText",
+				value: function leftText() {
+					return _get$1(EAN13$1.prototype.__proto__ || Object.getPrototypeOf(EAN13$1.prototype), "leftText", this).call(this, 1, 6);
+				}
+			},
+			{
+				key: "leftEncode",
+				value: function leftEncode() {
+					var data = this.data.substr(1, 6);
+					var structure = _constants$4.EAN13_STRUCTURE[this.data[0]];
+					return _get$1(EAN13$1.prototype.__proto__ || Object.getPrototypeOf(EAN13$1.prototype), "leftEncode", this).call(this, data, structure);
+				}
+			},
+			{
+				key: "rightText",
+				value: function rightText() {
+					return _get$1(EAN13$1.prototype.__proto__ || Object.getPrototypeOf(EAN13$1.prototype), "rightText", this).call(this, 7, 6);
+				}
+			},
+			{
+				key: "rightEncode",
+				value: function rightEncode() {
+					var data = this.data.substr(7, 6);
+					return _get$1(EAN13$1.prototype.__proto__ || Object.getPrototypeOf(EAN13$1.prototype), "rightEncode", this).call(this, data, "RRRRRR");
+				}
+			},
+			{
+				key: "encodeGuarded",
+				value: function encodeGuarded() {
+					var data = _get$1(EAN13$1.prototype.__proto__ || Object.getPrototypeOf(EAN13$1.prototype), "encodeGuarded", this).call(this);
+					if (this.options.displayValue) {
+						data.unshift({
+							data: "000000000000",
+							text: this.text.substr(0, 1),
+							options: {
+								textAlign: "left",
+								fontSize: this.fontSize
+							}
+						});
+						if (this.options.lastChar) {
+							data.push({ data: "00" });
+							data.push({
+								data: "00000",
+								text: this.options.lastChar,
+								options: { fontSize: this.fontSize }
+							});
+						}
+					}
+					return data;
+				}
+			}
+		]);
+		return EAN13$1;
+	}(_EAN3$1.default);
+}));
+var require_EAN8 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$16 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _get = function get(object, property, receiver) {
+		if (object === null) object = Function.prototype;
+		var desc = Object.getOwnPropertyDescriptor(object, property);
+		if (desc === void 0) {
+			var parent = Object.getPrototypeOf(object);
+			if (parent === null) return;
+			else return get(parent, property, receiver);
+		} else if ("value" in desc) return desc.value;
+		else {
+			var getter = desc.get;
+			if (getter === void 0) return;
+			return getter.call(receiver);
+		}
+	};
+	var _EAN3 = _interopRequireDefault$27(require_EAN());
+	function _interopRequireDefault$27(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$21(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$17(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$17(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	var checksum$3 = function checksum$5(number) {
+		return (10 - number.substr(0, 7).split("").map(function(n) {
+			return +n;
+		}).reduce(function(sum, a, idx) {
+			return idx % 2 ? sum + a : sum + a * 3;
+		}, 0) % 10) % 10;
+	};
+	exports.default = function(_EAN) {
+		_inherits$17(EAN8$1, _EAN);
+		function EAN8$1(data, options) {
+			_classCallCheck$21(this, EAN8$1);
+			if (data.search(/^[0-9]{7}$/) !== -1) data += checksum$3(data);
+			return _possibleConstructorReturn$17(this, (EAN8$1.__proto__ || Object.getPrototypeOf(EAN8$1)).call(this, data, options));
+		}
+		_createClass$16(EAN8$1, [
+			{
+				key: "valid",
+				value: function valid() {
+					return this.data.search(/^[0-9]{8}$/) !== -1 && +this.data[7] === checksum$3(this.data);
+				}
+			},
+			{
+				key: "leftText",
+				value: function leftText() {
+					return _get(EAN8$1.prototype.__proto__ || Object.getPrototypeOf(EAN8$1.prototype), "leftText", this).call(this, 0, 4);
+				}
+			},
+			{
+				key: "leftEncode",
+				value: function leftEncode() {
+					var data = this.data.substr(0, 4);
+					return _get(EAN8$1.prototype.__proto__ || Object.getPrototypeOf(EAN8$1.prototype), "leftEncode", this).call(this, data, "LLLL");
+				}
+			},
+			{
+				key: "rightText",
+				value: function rightText() {
+					return _get(EAN8$1.prototype.__proto__ || Object.getPrototypeOf(EAN8$1.prototype), "rightText", this).call(this, 4, 4);
+				}
+			},
+			{
+				key: "rightEncode",
+				value: function rightEncode() {
+					var data = this.data.substr(4, 4);
+					return _get(EAN8$1.prototype.__proto__ || Object.getPrototypeOf(EAN8$1.prototype), "rightEncode", this).call(this, data, "RRRR");
+				}
+			}
+		]);
+		return EAN8$1;
+	}(_EAN3.default);
+}));
+var require_EAN5 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$15 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _constants$3 = require_constants$2();
+	var _encoder2$3 = _interopRequireDefault$26(require_encoder());
+	var _Barcode3$9 = _interopRequireDefault$26(require_Barcode());
+	function _interopRequireDefault$26(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$20(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$16(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$16(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	var checksum$2 = function checksum$5(data) {
+		return data.split("").map(function(n) {
+			return +n;
+		}).reduce(function(sum, a, idx) {
+			return idx % 2 ? sum + a * 9 : sum + a * 3;
+		}, 0) % 10;
+	};
+	exports.default = function(_Barcode) {
+		_inherits$16(EAN5$1, _Barcode);
+		function EAN5$1(data, options) {
+			_classCallCheck$20(this, EAN5$1);
+			return _possibleConstructorReturn$16(this, (EAN5$1.__proto__ || Object.getPrototypeOf(EAN5$1)).call(this, data, options));
+		}
+		_createClass$15(EAN5$1, [{
+			key: "valid",
+			value: function valid() {
+				return this.data.search(/^[0-9]{5}$/) !== -1;
+			}
+		}, {
+			key: "encode",
+			value: function encode$2() {
+				var structure = _constants$3.EAN5_STRUCTURE[checksum$2(this.data)];
+				return {
+					data: "1011" + (0, _encoder2$3.default)(this.data, structure, "01"),
+					text: this.text
+				};
+			}
+		}]);
+		return EAN5$1;
+	}(_Barcode3$9.default);
+}));
+var require_EAN2 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$14 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _constants$2 = require_constants$2();
+	var _encoder2$2 = _interopRequireDefault$25(require_encoder());
+	var _Barcode3$8 = _interopRequireDefault$25(require_Barcode());
+	function _interopRequireDefault$25(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$19(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$15(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$15(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_Barcode) {
+		_inherits$15(EAN2$1, _Barcode);
+		function EAN2$1(data, options) {
+			_classCallCheck$19(this, EAN2$1);
+			return _possibleConstructorReturn$15(this, (EAN2$1.__proto__ || Object.getPrototypeOf(EAN2$1)).call(this, data, options));
+		}
+		_createClass$14(EAN2$1, [{
+			key: "valid",
+			value: function valid() {
+				return this.data.search(/^[0-9]{2}$/) !== -1;
+			}
+		}, {
+			key: "encode",
+			value: function encode$2() {
+				var structure = _constants$2.EAN2_STRUCTURE[parseInt(this.data) % 4];
+				return {
+					data: "1011" + (0, _encoder2$2.default)(this.data, structure, "01"),
+					text: this.text
+				};
+			}
+		}]);
+		return EAN2$1;
+	}(_Barcode3$8.default);
+}));
+var require_UPC = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$13 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	exports.checksum = checksum$1;
+	var _encoder2$1 = _interopRequireDefault$24(require_encoder());
+	var _Barcode3$7 = _interopRequireDefault$24(require_Barcode());
+	function _interopRequireDefault$24(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$18(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$14(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$14(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	var UPC = function(_Barcode) {
+		_inherits$14(UPC$1, _Barcode);
+		function UPC$1(data, options) {
+			_classCallCheck$18(this, UPC$1);
+			if (data.search(/^[0-9]{11}$/) !== -1) data += checksum$1(data);
+			var _this = _possibleConstructorReturn$14(this, (UPC$1.__proto__ || Object.getPrototypeOf(UPC$1)).call(this, data, options));
+			_this.displayValue = options.displayValue;
+			if (options.fontSize > options.width * 10) _this.fontSize = options.width * 10;
+			else _this.fontSize = options.fontSize;
+			_this.guardHeight = options.height + _this.fontSize / 2 + options.textMargin;
+			return _this;
+		}
+		_createClass$13(UPC$1, [
+			{
+				key: "valid",
+				value: function valid() {
+					return this.data.search(/^[0-9]{12}$/) !== -1 && this.data[11] == checksum$1(this.data);
+				}
+			},
+			{
+				key: "encode",
+				value: function encode$2() {
+					if (this.options.flat) return this.flatEncoding();
+					else return this.guardedEncoding();
+				}
+			},
+			{
+				key: "flatEncoding",
+				value: function flatEncoding() {
+					var result = "";
+					result += "101";
+					result += (0, _encoder2$1.default)(this.data.substr(0, 6), "LLLLLL");
+					result += "01010";
+					result += (0, _encoder2$1.default)(this.data.substr(6, 6), "RRRRRR");
+					result += "101";
+					return {
+						data: result,
+						text: this.text
+					};
+				}
+			},
+			{
+				key: "guardedEncoding",
+				value: function guardedEncoding() {
+					var result = [];
+					if (this.displayValue) result.push({
+						data: "00000000",
+						text: this.text.substr(0, 1),
+						options: {
+							textAlign: "left",
+							fontSize: this.fontSize
+						}
+					});
+					result.push({
+						data: "101" + (0, _encoder2$1.default)(this.data[0], "L"),
+						options: { height: this.guardHeight }
+					});
+					result.push({
+						data: (0, _encoder2$1.default)(this.data.substr(1, 5), "LLLLL"),
+						text: this.text.substr(1, 5),
+						options: { fontSize: this.fontSize }
+					});
+					result.push({
+						data: "01010",
+						options: { height: this.guardHeight }
+					});
+					result.push({
+						data: (0, _encoder2$1.default)(this.data.substr(6, 5), "RRRRR"),
+						text: this.text.substr(6, 5),
+						options: { fontSize: this.fontSize }
+					});
+					result.push({
+						data: (0, _encoder2$1.default)(this.data[11], "R") + "101",
+						options: { height: this.guardHeight }
+					});
+					if (this.displayValue) result.push({
+						data: "00000000",
+						text: this.text.substr(11, 1),
+						options: {
+							textAlign: "right",
+							fontSize: this.fontSize
+						}
+					});
+					return result;
+				}
+			}
+		]);
+		return UPC$1;
+	}(_Barcode3$7.default);
+	function checksum$1(number) {
+		var result = 0;
+		var i;
+		for (i = 1; i < 11; i += 2) result += parseInt(number[i]);
+		for (i = 0; i < 11; i += 2) result += parseInt(number[i]) * 3;
+		return (10 - result % 10) % 10;
+	}
+	exports.default = UPC;
+}));
+var require_UPCE = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$12 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _encoder2 = _interopRequireDefault$23(require_encoder());
+	var _Barcode3$6 = _interopRequireDefault$23(require_Barcode());
+	var _UPC = require_UPC();
+	function _interopRequireDefault$23(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$17(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$13(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$13(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	var EXPANSIONS = [
+		"XX00000XXX",
+		"XX10000XXX",
+		"XX20000XXX",
+		"XXX00000XX",
+		"XXXX00000X",
+		"XXXXX00005",
+		"XXXXX00006",
+		"XXXXX00007",
+		"XXXXX00008",
+		"XXXXX00009"
+	];
+	var PARITIES = [
+		["EEEOOO", "OOOEEE"],
+		["EEOEOO", "OOEOEE"],
+		["EEOOEO", "OOEEOE"],
+		["EEOOOE", "OOEEEO"],
+		["EOEEOO", "OEOOEE"],
+		["EOOEEO", "OEEOOE"],
+		["EOOOEE", "OEEEOO"],
+		["EOEOEO", "OEOEOE"],
+		["EOEOOE", "OEOEEO"],
+		["EOOEOE", "OEEOEO"]
+	];
+	var UPCE = function(_Barcode) {
+		_inherits$13(UPCE$1, _Barcode);
+		function UPCE$1(data, options) {
+			_classCallCheck$17(this, UPCE$1);
+			var _this = _possibleConstructorReturn$13(this, (UPCE$1.__proto__ || Object.getPrototypeOf(UPCE$1)).call(this, data, options));
+			_this.isValid = false;
+			if (data.search(/^[0-9]{6}$/) !== -1) {
+				_this.middleDigits = data;
+				_this.upcA = expandToUPCA(data, "0");
+				_this.text = options.text || "" + _this.upcA[0] + data + _this.upcA[_this.upcA.length - 1];
+				_this.isValid = true;
+			} else if (data.search(/^[01][0-9]{7}$/) !== -1) {
+				_this.middleDigits = data.substring(1, data.length - 1);
+				_this.upcA = expandToUPCA(_this.middleDigits, data[0]);
+				if (_this.upcA[_this.upcA.length - 1] === data[data.length - 1]) _this.isValid = true;
+				else return _possibleConstructorReturn$13(_this);
+			} else return _possibleConstructorReturn$13(_this);
+			_this.displayValue = options.displayValue;
+			if (options.fontSize > options.width * 10) _this.fontSize = options.width * 10;
+			else _this.fontSize = options.fontSize;
+			_this.guardHeight = options.height + _this.fontSize / 2 + options.textMargin;
+			return _this;
+		}
+		_createClass$12(UPCE$1, [
+			{
+				key: "valid",
+				value: function valid() {
+					return this.isValid;
+				}
+			},
+			{
+				key: "encode",
+				value: function encode$2() {
+					if (this.options.flat) return this.flatEncoding();
+					else return this.guardedEncoding();
+				}
+			},
+			{
+				key: "flatEncoding",
+				value: function flatEncoding() {
+					var result = "";
+					result += "101";
+					result += this.encodeMiddleDigits();
+					result += "010101";
+					return {
+						data: result,
+						text: this.text
+					};
+				}
+			},
+			{
+				key: "guardedEncoding",
+				value: function guardedEncoding() {
+					var result = [];
+					if (this.displayValue) result.push({
+						data: "00000000",
+						text: this.text[0],
+						options: {
+							textAlign: "left",
+							fontSize: this.fontSize
+						}
+					});
+					result.push({
+						data: "101",
+						options: { height: this.guardHeight }
+					});
+					result.push({
+						data: this.encodeMiddleDigits(),
+						text: this.text.substring(1, 7),
+						options: { fontSize: this.fontSize }
+					});
+					result.push({
+						data: "010101",
+						options: { height: this.guardHeight }
+					});
+					if (this.displayValue) result.push({
+						data: "00000000",
+						text: this.text[7],
+						options: {
+							textAlign: "right",
+							fontSize: this.fontSize
+						}
+					});
+					return result;
+				}
+			},
+			{
+				key: "encodeMiddleDigits",
+				value: function encodeMiddleDigits() {
+					var numberSystem = this.upcA[0];
+					var checkDigit = this.upcA[this.upcA.length - 1];
+					var parity = PARITIES[parseInt(checkDigit)][parseInt(numberSystem)];
+					return (0, _encoder2.default)(this.middleDigits, parity);
+				}
+			}
+		]);
+		return UPCE$1;
+	}(_Barcode3$6.default);
+	function expandToUPCA(middleDigits, numberSystem) {
+		var expansion = EXPANSIONS[parseInt(middleDigits[middleDigits.length - 1])];
+		var result = "";
+		var digitIndex = 0;
+		for (var i = 0; i < expansion.length; i++) {
+			var c = expansion[i];
+			if (c === "X") result += middleDigits[digitIndex++];
+			else result += c;
+		}
+		result = "" + numberSystem + result;
+		return "" + result + (0, _UPC.checksum)(result);
+	}
+	exports.default = UPCE;
+}));
+var require_EAN_UPC = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.UPCE = exports.UPC = exports.EAN2 = exports.EAN5 = exports.EAN8 = exports.EAN13 = void 0;
+	var _EAN2 = _interopRequireDefault$22(require_EAN13());
+	var _EAN4 = _interopRequireDefault$22(require_EAN8());
+	var _EAN6 = _interopRequireDefault$22(require_EAN5());
+	var _EAN8 = _interopRequireDefault$22(require_EAN2());
+	var _UPC2 = _interopRequireDefault$22(require_UPC());
+	var _UPCE2 = _interopRequireDefault$22(require_UPCE());
+	function _interopRequireDefault$22(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	exports.EAN13 = _EAN2.default;
+	exports.EAN8 = _EAN4.default;
+	exports.EAN5 = _EAN6.default;
+	exports.EAN2 = _EAN8.default;
+	exports.UPC = _UPC2.default;
+	exports.UPCE = _UPCE2.default;
+}));
+var require_constants$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.START_BIN = "1010";
+	exports.END_BIN = "11101";
+	exports.BINARIES = [
+		"00110",
+		"10001",
+		"01001",
+		"11000",
+		"00101",
+		"10100",
+		"01100",
+		"00011",
+		"10010",
+		"01010"
+	];
+}));
+var require_ITF$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$11 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _constants$1 = require_constants$1();
+	var _Barcode3$5 = _interopRequireDefault$21(require_Barcode());
+	function _interopRequireDefault$21(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$16(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$12(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$12(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_Barcode) {
+		_inherits$12(ITF$1, _Barcode);
+		function ITF$1() {
+			_classCallCheck$16(this, ITF$1);
+			return _possibleConstructorReturn$12(this, (ITF$1.__proto__ || Object.getPrototypeOf(ITF$1)).apply(this, arguments));
+		}
+		_createClass$11(ITF$1, [
+			{
+				key: "valid",
+				value: function valid() {
+					return this.data.search(/^([0-9]{2})+$/) !== -1;
+				}
+			},
+			{
+				key: "encode",
+				value: function encode$2() {
+					var _this2 = this;
+					var encoded = this.data.match(/.{2}/g).map(function(pair) {
+						return _this2.encodePair(pair);
+					}).join("");
+					return {
+						data: _constants$1.START_BIN + encoded + _constants$1.END_BIN,
+						text: this.text
+					};
+				}
+			},
+			{
+				key: "encodePair",
+				value: function encodePair(pair) {
+					var second = _constants$1.BINARIES[pair[1]];
+					return _constants$1.BINARIES[pair[0]].split("").map(function(first, idx) {
+						return (first === "1" ? "111" : "1") + (second[idx] === "1" ? "000" : "0");
+					}).join("");
+				}
+			}
+		]);
+		return ITF$1;
+	}(_Barcode3$5.default);
+}));
+var require_ITF14 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$10 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _ITF3 = _interopRequireDefault$20(require_ITF$1());
+	function _interopRequireDefault$20(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$15(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$11(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$11(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	var checksum = function checksum$5(data) {
+		var res = data.substr(0, 13).split("").map(function(num) {
+			return parseInt(num, 10);
+		}).reduce(function(sum, n, idx) {
+			return sum + n * (3 - idx % 2 * 2);
+		}, 0);
+		return Math.ceil(res / 10) * 10 - res;
+	};
+	exports.default = function(_ITF$1) {
+		_inherits$11(ITF14$1, _ITF$1);
+		function ITF14$1(data, options) {
+			_classCallCheck$15(this, ITF14$1);
+			if (data.search(/^[0-9]{13}$/) !== -1) data += checksum(data);
+			return _possibleConstructorReturn$11(this, (ITF14$1.__proto__ || Object.getPrototypeOf(ITF14$1)).call(this, data, options));
+		}
+		_createClass$10(ITF14$1, [{
+			key: "valid",
+			value: function valid() {
+				return this.data.search(/^[0-9]{14}$/) !== -1 && +this.data[13] === checksum(this.data);
+			}
+		}]);
+		return ITF14$1;
+	}(_ITF3.default);
+}));
+var require_ITF = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ITF14 = exports.ITF = void 0;
+	var _ITF2 = _interopRequireDefault$19(require_ITF$1());
+	var _ITF4 = _interopRequireDefault$19(require_ITF14());
+	function _interopRequireDefault$19(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	exports.ITF = _ITF2.default;
+	exports.ITF14 = _ITF4.default;
+}));
+var require_MSI$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$9 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _Barcode3$4 = _interopRequireDefault$18(require_Barcode());
+	function _interopRequireDefault$18(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$14(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$10(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$10(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	var MSI = function(_Barcode) {
+		_inherits$10(MSI$1, _Barcode);
+		function MSI$1(data, options) {
+			_classCallCheck$14(this, MSI$1);
+			return _possibleConstructorReturn$10(this, (MSI$1.__proto__ || Object.getPrototypeOf(MSI$1)).call(this, data, options));
+		}
+		_createClass$9(MSI$1, [{
+			key: "encode",
+			value: function encode$2() {
+				var ret = "110";
+				for (var i = 0; i < this.data.length; i++) {
+					var bin = parseInt(this.data[i]).toString(2);
+					bin = addZeroes(bin, 4 - bin.length);
+					for (var b = 0; b < bin.length; b++) ret += bin[b] == "0" ? "100" : "110";
+				}
+				ret += "1001";
+				return {
+					data: ret,
+					text: this.text
+				};
+			}
+		}, {
+			key: "valid",
+			value: function valid() {
+				return this.data.search(/^[0-9]+$/) !== -1;
+			}
+		}]);
+		return MSI$1;
+	}(_Barcode3$4.default);
+	function addZeroes(number, n) {
+		for (var i = 0; i < n; i++) number = "0" + number;
+		return number;
+	}
+	exports.default = MSI;
+}));
+var require_checksums = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.mod10 = mod10;
+	exports.mod11 = mod11;
+	function mod10(number) {
+		var sum = 0;
+		for (var i = 0; i < number.length; i++) {
+			var n = parseInt(number[i]);
+			if ((i + number.length) % 2 === 0) sum += n;
+			else sum += n * 2 % 10 + Math.floor(n * 2 / 10);
+		}
+		return (10 - sum % 10) % 10;
+	}
+	function mod11(number) {
+		var sum = 0;
+		var weights = [
+			2,
+			3,
+			4,
+			5,
+			6,
+			7
+		];
+		for (var i = 0; i < number.length; i++) {
+			var n = parseInt(number[number.length - 1 - i]);
+			sum += weights[i % weights.length] * n;
+		}
+		return (11 - sum % 11) % 11;
+	}
+}));
+var require_MSI10 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _MSI3$3 = _interopRequireDefault$17(require_MSI$1());
+	var _checksums$3 = require_checksums();
+	function _interopRequireDefault$17(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$13(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$9(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$9(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_MSI$1) {
+		_inherits$9(MSI10$1, _MSI$1);
+		function MSI10$1(data, options) {
+			_classCallCheck$13(this, MSI10$1);
+			return _possibleConstructorReturn$9(this, (MSI10$1.__proto__ || Object.getPrototypeOf(MSI10$1)).call(this, data + (0, _checksums$3.mod10)(data), options));
+		}
+		return MSI10$1;
+	}(_MSI3$3.default);
+}));
+var require_MSI11 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _MSI3$2 = _interopRequireDefault$16(require_MSI$1());
+	var _checksums$2 = require_checksums();
+	function _interopRequireDefault$16(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$12(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$8(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$8(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_MSI$1) {
+		_inherits$8(MSI11$1, _MSI$1);
+		function MSI11$1(data, options) {
+			_classCallCheck$12(this, MSI11$1);
+			return _possibleConstructorReturn$8(this, (MSI11$1.__proto__ || Object.getPrototypeOf(MSI11$1)).call(this, data + (0, _checksums$2.mod11)(data), options));
+		}
+		return MSI11$1;
+	}(_MSI3$2.default);
+}));
+var require_MSI1010 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _MSI3$1 = _interopRequireDefault$15(require_MSI$1());
+	var _checksums$1 = require_checksums();
+	function _interopRequireDefault$15(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$11(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$7(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$7(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_MSI$1) {
+		_inherits$7(MSI1010$1, _MSI$1);
+		function MSI1010$1(data, options) {
+			_classCallCheck$11(this, MSI1010$1);
+			data += (0, _checksums$1.mod10)(data);
+			data += (0, _checksums$1.mod10)(data);
+			return _possibleConstructorReturn$7(this, (MSI1010$1.__proto__ || Object.getPrototypeOf(MSI1010$1)).call(this, data, options));
+		}
+		return MSI1010$1;
+	}(_MSI3$1.default);
+}));
+var require_MSI1110 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _MSI3 = _interopRequireDefault$14(require_MSI$1());
+	var _checksums = require_checksums();
+	function _interopRequireDefault$14(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$10(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$6(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$6(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_MSI$1) {
+		_inherits$6(MSI1110$1, _MSI$1);
+		function MSI1110$1(data, options) {
+			_classCallCheck$10(this, MSI1110$1);
+			data += (0, _checksums.mod11)(data);
+			data += (0, _checksums.mod10)(data);
+			return _possibleConstructorReturn$6(this, (MSI1110$1.__proto__ || Object.getPrototypeOf(MSI1110$1)).call(this, data, options));
+		}
+		return MSI1110$1;
+	}(_MSI3.default);
+}));
+var require_MSI = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.MSI1110 = exports.MSI1010 = exports.MSI11 = exports.MSI10 = exports.MSI = void 0;
+	var _MSI2 = _interopRequireDefault$13(require_MSI$1());
+	var _MSI4 = _interopRequireDefault$13(require_MSI10());
+	var _MSI6 = _interopRequireDefault$13(require_MSI11());
+	var _MSI8 = _interopRequireDefault$13(require_MSI1010());
+	var _MSI10 = _interopRequireDefault$13(require_MSI1110());
+	function _interopRequireDefault$13(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	exports.MSI = _MSI2.default;
+	exports.MSI10 = _MSI4.default;
+	exports.MSI11 = _MSI6.default;
+	exports.MSI1010 = _MSI8.default;
+	exports.MSI1110 = _MSI10.default;
+}));
+var require_pharmacode = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.pharmacode = void 0;
+	var _createClass$8 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _Barcode3$3 = _interopRequireDefault$12(require_Barcode());
+	function _interopRequireDefault$12(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$9(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$5(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$5(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.pharmacode = function(_Barcode) {
+		_inherits$5(pharmacode$1, _Barcode);
+		function pharmacode$1(data, options) {
+			_classCallCheck$9(this, pharmacode$1);
+			var _this = _possibleConstructorReturn$5(this, (pharmacode$1.__proto__ || Object.getPrototypeOf(pharmacode$1)).call(this, data, options));
+			_this.number = parseInt(data, 10);
+			return _this;
+		}
+		_createClass$8(pharmacode$1, [{
+			key: "encode",
+			value: function encode$2() {
+				var z = this.number;
+				var result = "";
+				while (!isNaN(z) && z != 0) if (z % 2 === 0) {
+					result = "11100" + result;
+					z = (z - 2) / 2;
+				} else {
+					result = "100" + result;
+					z = (z - 1) / 2;
+				}
+				result = result.slice(0, -2);
+				return {
+					data: result,
+					text: this.text
+				};
+			}
+		}, {
+			key: "valid",
+			value: function valid() {
+				return this.number >= 3 && this.number <= 131070;
+			}
+		}]);
+		return pharmacode$1;
+	}(_Barcode3$3.default);
+}));
+var require_codabar = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.codabar = void 0;
+	var _createClass$7 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _Barcode3$2 = _interopRequireDefault$11(require_Barcode());
+	function _interopRequireDefault$11(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$8(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$4(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$4(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.codabar = function(_Barcode) {
+		_inherits$4(codabar$1, _Barcode);
+		function codabar$1(data, options) {
+			_classCallCheck$8(this, codabar$1);
+			if (data.search(/^[0-9\-\$\:\.\+\/]+$/) === 0) data = "A" + data + "A";
+			var _this = _possibleConstructorReturn$4(this, (codabar$1.__proto__ || Object.getPrototypeOf(codabar$1)).call(this, data.toUpperCase(), options));
+			_this.text = _this.options.text || _this.text.replace(/[A-D]/g, "");
+			return _this;
+		}
+		_createClass$7(codabar$1, [
+			{
+				key: "valid",
+				value: function valid() {
+					return this.data.search(/^[A-D][0-9\-\$\:\.\+\/]+[A-D]$/) !== -1;
+				}
+			},
+			{
+				key: "encode",
+				value: function encode$2() {
+					var result = [];
+					var encodings$1 = this.getEncodings();
+					for (var i = 0; i < this.data.length; i++) {
+						result.push(encodings$1[this.data.charAt(i)]);
+						if (i !== this.data.length - 1) result.push("0");
+					}
+					return {
+						text: this.text,
+						data: result.join("")
+					};
+				}
+			},
+			{
+				key: "getEncodings",
+				value: function getEncodings() {
+					return {
+						"0": "101010011",
+						"1": "101011001",
+						"2": "101001011",
+						"3": "110010101",
+						"4": "101101001",
+						"5": "110101001",
+						"6": "100101011",
+						"7": "100101101",
+						"8": "100110101",
+						"9": "110100101",
+						"-": "101001101",
+						"$": "101100101",
+						":": "1101011011",
+						"/": "1101101011",
+						".": "1101101101",
+						"+": "1011011011",
+						"A": "1011001001",
+						"B": "1001001011",
+						"C": "1010010011",
+						"D": "1010011001"
+					};
+				}
+			}
+		]);
+		return codabar$1;
+	}(_Barcode3$2.default);
+}));
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.SYMBOLS = [
+		"0",
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"A",
+		"B",
+		"C",
+		"D",
+		"E",
+		"F",
+		"G",
+		"H",
+		"I",
+		"J",
+		"K",
+		"L",
+		"M",
+		"N",
+		"O",
+		"P",
+		"Q",
+		"R",
+		"S",
+		"T",
+		"U",
+		"V",
+		"W",
+		"X",
+		"Y",
+		"Z",
+		"-",
+		".",
+		" ",
+		"$",
+		"/",
+		"+",
+		"%",
+		"($)",
+		"(%)",
+		"(/)",
+		"(+)",
+		"ÿ"
+	];
+	exports.BINARIES = [
+		"100010100",
+		"101001000",
+		"101000100",
+		"101000010",
+		"100101000",
+		"100100100",
+		"100100010",
+		"101010000",
+		"100010010",
+		"100001010",
+		"110101000",
+		"110100100",
+		"110100010",
+		"110010100",
+		"110010010",
+		"110001010",
+		"101101000",
+		"101100100",
+		"101100010",
+		"100110100",
+		"100011010",
+		"101011000",
+		"101001100",
+		"101000110",
+		"100101100",
+		"100010110",
+		"110110100",
+		"110110010",
+		"110101100",
+		"110100110",
+		"110010110",
+		"110011010",
+		"101101100",
+		"101100110",
+		"100110110",
+		"100111010",
+		"100101110",
+		"111010100",
+		"111010010",
+		"111001010",
+		"101101110",
+		"101110110",
+		"110101110",
+		"100100110",
+		"111011010",
+		"111010110",
+		"100110010",
+		"101011110"
+	];
+	exports.MULTI_SYMBOLS = {
+		"\0": ["(%)", "U"],
+		"
": ["($)", "A"],
+		"": ["($)", "B"],
+		"": ["($)", "C"],
+		"": ["($)", "D"],
+		"": ["($)", "E"],
+		"": ["($)", "F"],
+		"\x07": ["($)", "G"],
+		"\b": ["($)", "H"],
+		"	": ["($)", "I"],
+		"\n": ["($)", "J"],
+		"\v": ["($)", "K"],
+		"\f": ["($)", "L"],
+		"\r": ["($)", "M"],
+		"": ["($)", "N"],
+		"": ["($)", "O"],
+		"": ["($)", "P"],
+		"": ["($)", "Q"],
+		"": ["($)", "R"],
+		"": ["($)", "S"],
+		"": ["($)", "T"],
+		"": ["($)", "U"],
+		"": ["($)", "V"],
+		"": ["($)", "W"],
+		"": ["($)", "X"],
+		"": ["($)", "Y"],
+		"": ["($)", "Z"],
+		"\x1B": ["(%)", "A"],
+		"": ["(%)", "B"],
+		"": ["(%)", "C"],
+		"": ["(%)", "D"],
+		"": ["(%)", "E"],
+		"!": ["(/)", "A"],
+		"\"": ["(/)", "B"],
+		"#": ["(/)", "C"],
+		"&": ["(/)", "F"],
+		"'": ["(/)", "G"],
+		"(": ["(/)", "H"],
+		")": ["(/)", "I"],
+		"*": ["(/)", "J"],
+		",": ["(/)", "L"],
+		":": ["(/)", "Z"],
+		";": ["(%)", "F"],
+		"<": ["(%)", "G"],
+		"=": ["(%)", "H"],
+		">": ["(%)", "I"],
+		"?": ["(%)", "J"],
+		"@": ["(%)", "V"],
+		"[": ["(%)", "K"],
+		"\\": ["(%)", "L"],
+		"]": ["(%)", "M"],
+		"^": ["(%)", "N"],
+		"_": ["(%)", "O"],
+		"`": ["(%)", "W"],
+		"a": ["(+)", "A"],
+		"b": ["(+)", "B"],
+		"c": ["(+)", "C"],
+		"d": ["(+)", "D"],
+		"e": ["(+)", "E"],
+		"f": ["(+)", "F"],
+		"g": ["(+)", "G"],
+		"h": ["(+)", "H"],
+		"i": ["(+)", "I"],
+		"j": ["(+)", "J"],
+		"k": ["(+)", "K"],
+		"l": ["(+)", "L"],
+		"m": ["(+)", "M"],
+		"n": ["(+)", "N"],
+		"o": ["(+)", "O"],
+		"p": ["(+)", "P"],
+		"q": ["(+)", "Q"],
+		"r": ["(+)", "R"],
+		"s": ["(+)", "S"],
+		"t": ["(+)", "T"],
+		"u": ["(+)", "U"],
+		"v": ["(+)", "V"],
+		"w": ["(+)", "W"],
+		"x": ["(+)", "X"],
+		"y": ["(+)", "Y"],
+		"z": ["(+)", "Z"],
+		"{": ["(%)", "P"],
+		"|": ["(%)", "Q"],
+		"}": ["(%)", "R"],
+		"~": ["(%)", "S"],
+		"": ["(%)", "T"]
+	};
+}));
+var require_CODE93$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$6 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _constants = require_constants();
+	var _Barcode3$1 = _interopRequireDefault$10(require_Barcode());
+	function _interopRequireDefault$10(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$7(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$3(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$3(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_Barcode) {
+		_inherits$3(CODE93$1, _Barcode);
+		function CODE93$1(data, options) {
+			_classCallCheck$7(this, CODE93$1);
+			return _possibleConstructorReturn$3(this, (CODE93$1.__proto__ || Object.getPrototypeOf(CODE93$1)).call(this, data, options));
+		}
+		_createClass$6(CODE93$1, [{
+			key: "valid",
+			value: function valid() {
+				return /^[0-9A-Z\-. $/+%]+$/.test(this.data);
+			}
+		}, {
+			key: "encode",
+			value: function encode$2() {
+				var symbols = this.data.split("").flatMap(function(c) {
+					return _constants.MULTI_SYMBOLS[c] || c;
+				});
+				var encoded = symbols.map(function(s) {
+					return CODE93$1.getEncoding(s);
+				}).join("");
+				var csumC = CODE93$1.checksum(symbols, 20);
+				var csumK = CODE93$1.checksum(symbols.concat(csumC), 15);
+				return {
+					text: this.text,
+					data: CODE93$1.getEncoding("ÿ") + encoded + CODE93$1.getEncoding(csumC) + CODE93$1.getEncoding(csumK) + CODE93$1.getEncoding("ÿ") + "1"
+				};
+			}
+		}], [
+			{
+				key: "getEncoding",
+				value: function getEncoding$1(symbol) {
+					return _constants.BINARIES[CODE93$1.symbolValue(symbol)];
+				}
+			},
+			{
+				key: "getSymbol",
+				value: function getSymbol(symbolValue) {
+					return _constants.SYMBOLS[symbolValue];
+				}
+			},
+			{
+				key: "symbolValue",
+				value: function symbolValue(symbol) {
+					return _constants.SYMBOLS.indexOf(symbol);
+				}
+			},
+			{
+				key: "checksum",
+				value: function checksum$5(symbols, maxWeight) {
+					var csum = symbols.slice().reverse().reduce(function(sum, symbol, idx) {
+						var weight = idx % maxWeight + 1;
+						return sum + CODE93$1.symbolValue(symbol) * weight;
+					}, 0);
+					return CODE93$1.getSymbol(csum % 47);
+				}
+			}
+		]);
+		return CODE93$1;
+	}(_Barcode3$1.default);
+}));
+var require_CODE93FullASCII = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$5 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _CODE3$1 = _interopRequireDefault$9(require_CODE93$1());
+	function _interopRequireDefault$9(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$6(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$2(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$2(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.default = function(_CODE$1) {
+		_inherits$2(CODE93FullASCII$1, _CODE$1);
+		function CODE93FullASCII$1(data, options) {
+			_classCallCheck$6(this, CODE93FullASCII$1);
+			return _possibleConstructorReturn$2(this, (CODE93FullASCII$1.__proto__ || Object.getPrototypeOf(CODE93FullASCII$1)).call(this, data, options));
+		}
+		_createClass$5(CODE93FullASCII$1, [{
+			key: "valid",
+			value: function valid() {
+				return /^[\x00-\x7f]+$/.test(this.data);
+			}
+		}]);
+		return CODE93FullASCII$1;
+	}(_CODE3$1.default);
+}));
+var require_CODE93 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.CODE93FullASCII = exports.CODE93 = void 0;
+	var _CODE2$1 = _interopRequireDefault$8(require_CODE93$1());
+	var _CODE93FullASCII2 = _interopRequireDefault$8(require_CODE93FullASCII());
+	function _interopRequireDefault$8(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	exports.CODE93 = _CODE2$1.default;
+	exports.CODE93FullASCII = _CODE93FullASCII2.default;
+}));
+var require_GenericBarcode = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.GenericBarcode = void 0;
+	var _createClass$4 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _Barcode3 = _interopRequireDefault$7(require_Barcode());
+	function _interopRequireDefault$7(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$5(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn$1(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits$1(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	exports.GenericBarcode = function(_Barcode) {
+		_inherits$1(GenericBarcode$1, _Barcode);
+		function GenericBarcode$1(data, options) {
+			_classCallCheck$5(this, GenericBarcode$1);
+			return _possibleConstructorReturn$1(this, (GenericBarcode$1.__proto__ || Object.getPrototypeOf(GenericBarcode$1)).call(this, data, options));
+		}
+		_createClass$4(GenericBarcode$1, [{
+			key: "encode",
+			value: function encode$2() {
+				return {
+					data: "10101010101010101010101010101010101010101",
+					text: this.text
+				};
+			}
+		}, {
+			key: "valid",
+			value: function valid() {
+				return true;
+			}
+		}]);
+		return GenericBarcode$1;
+	}(_Barcode3.default);
+}));
+var require_barcodes = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _CODE = require_CODE39();
+	var _CODE2 = require_CODE128();
+	var _EAN_UPC = require_EAN_UPC();
+	var _ITF = require_ITF();
+	var _MSI = require_MSI();
+	var _pharmacode = require_pharmacode();
+	var _codabar = require_codabar();
+	var _CODE3 = require_CODE93();
+	var _GenericBarcode = require_GenericBarcode();
+	exports.default = {
+		CODE39: _CODE.CODE39,
+		CODE128: _CODE2.CODE128,
+		CODE128A: _CODE2.CODE128A,
+		CODE128B: _CODE2.CODE128B,
+		CODE128C: _CODE2.CODE128C,
+		EAN13: _EAN_UPC.EAN13,
+		EAN8: _EAN_UPC.EAN8,
+		EAN5: _EAN_UPC.EAN5,
+		EAN2: _EAN_UPC.EAN2,
+		UPC: _EAN_UPC.UPC,
+		UPCE: _EAN_UPC.UPCE,
+		ITF14: _ITF.ITF14,
+		ITF: _ITF.ITF,
+		MSI: _MSI.MSI,
+		MSI10: _MSI.MSI10,
+		MSI11: _MSI.MSI11,
+		MSI1010: _MSI.MSI1010,
+		MSI1110: _MSI.MSI1110,
+		pharmacode: _pharmacode.pharmacode,
+		codabar: _codabar.codabar,
+		CODE93: _CODE3.CODE93,
+		CODE93FullASCII: _CODE3.CODE93FullASCII,
+		GenericBarcode: _GenericBarcode.GenericBarcode
+	};
+}));
+var require_merge = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _extends = Object.assign || function(target) {
+		for (var i = 1; i < arguments.length; i++) {
+			var source = arguments[i];
+			for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+		}
+		return target;
+	};
+	exports.default = function(old, replaceObj) {
+		return _extends({}, old, replaceObj);
+	};
+}));
+var require_linearizeEncodings = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = linearizeEncodings;
+	function linearizeEncodings(encodings$1) {
+		var linearEncodings = [];
+		function nextLevel(encoded) {
+			if (Array.isArray(encoded)) for (var i = 0; i < encoded.length; i++) nextLevel(encoded[i]);
+			else {
+				encoded.text = encoded.text || "";
+				encoded.data = encoded.data || "";
+				linearEncodings.push(encoded);
+			}
+		}
+		nextLevel(encodings$1);
+		return linearEncodings;
+	}
+}));
+var require_fixOptions = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = fixOptions;
+	function fixOptions(options) {
+		options.marginTop = options.marginTop || options.margin;
+		options.marginBottom = options.marginBottom || options.margin;
+		options.marginRight = options.marginRight || options.margin;
+		options.marginLeft = options.marginLeft || options.margin;
+		return options;
+	}
+}));
+var require_optionsFromStrings = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = optionsFromStrings;
+	function optionsFromStrings(options) {
+		var intOptions = [
+			"width",
+			"height",
+			"textMargin",
+			"fontSize",
+			"margin",
+			"marginTop",
+			"marginBottom",
+			"marginLeft",
+			"marginRight"
+		];
+		for (var intOption in intOptions) if (intOptions.hasOwnProperty(intOption)) {
+			intOption = intOptions[intOption];
+			if (typeof options[intOption] === "string") options[intOption] = parseInt(options[intOption], 10);
+		}
+		if (typeof options["displayValue"] === "string") options["displayValue"] = options["displayValue"] != "false";
+		return options;
+	}
+}));
+var require_defaults = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = {
+		width: 2,
+		height: 100,
+		format: "auto",
+		displayValue: true,
+		fontOptions: "",
+		font: "monospace",
+		text: void 0,
+		textAlign: "center",
+		textPosition: "bottom",
+		textMargin: 2,
+		fontSize: 20,
+		background: "#ffffff",
+		lineColor: "#000000",
+		margin: 10,
+		marginTop: void 0,
+		marginBottom: void 0,
+		marginLeft: void 0,
+		marginRight: void 0,
+		valid: function valid() {}
+	};
+}));
+var require_getOptionsFromElement = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _optionsFromStrings2$1 = _interopRequireDefault$6(require_optionsFromStrings());
+	var _defaults2$1 = _interopRequireDefault$6(require_defaults());
+	function _interopRequireDefault$6(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function getOptionsFromElement(element) {
+		var options = {};
+		for (var property in _defaults2$1.default) if (_defaults2$1.default.hasOwnProperty(property)) {
+			if (element.hasAttribute("jsbarcode-" + property.toLowerCase())) options[property] = element.getAttribute("jsbarcode-" + property.toLowerCase());
+			if (element.hasAttribute("data-" + property.toLowerCase())) options[property] = element.getAttribute("data-" + property.toLowerCase());
+		}
+		options["value"] = element.getAttribute("jsbarcode-value") || element.getAttribute("data-value");
+		options = (0, _optionsFromStrings2$1.default)(options);
+		return options;
+	}
+	exports.default = getOptionsFromElement;
+}));
+var require_shared = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getTotalWidthOfEncodings = exports.calculateEncodingAttributes = exports.getBarcodePadding = exports.getEncodingHeight = exports.getMaximumHeightOfEncodings = void 0;
+	var _merge2$3 = _interopRequireDefault$5(require_merge());
+	function _interopRequireDefault$5(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function getEncodingHeight(encoding, options) {
+		return options.height + (options.displayValue && encoding.text.length > 0 ? options.fontSize + options.textMargin : 0) + options.marginTop + options.marginBottom;
+	}
+	function getBarcodePadding(textWidth, barcodeWidth, options) {
+		if (options.displayValue && barcodeWidth < textWidth) {
+			if (options.textAlign == "center") return Math.floor((textWidth - barcodeWidth) / 2);
+			else if (options.textAlign == "left") return 0;
+			else if (options.textAlign == "right") return Math.floor(textWidth - barcodeWidth);
+		}
+		return 0;
+	}
+	function calculateEncodingAttributes(encodings$1, barcodeOptions, context) {
+		for (var i = 0; i < encodings$1.length; i++) {
+			var encoding = encodings$1[i];
+			var options = (0, _merge2$3.default)(barcodeOptions, encoding.options);
+			var textWidth;
+			if (options.displayValue) textWidth = messureText(encoding.text, options, context);
+			else textWidth = 0;
+			var barcodeWidth = encoding.data.length * options.width;
+			encoding.width = Math.ceil(Math.max(textWidth, barcodeWidth));
+			encoding.height = getEncodingHeight(encoding, options);
+			encoding.barcodePadding = getBarcodePadding(textWidth, barcodeWidth, options);
+		}
+	}
+	function getTotalWidthOfEncodings(encodings$1) {
+		var totalWidth = 0;
+		for (var i = 0; i < encodings$1.length; i++) totalWidth += encodings$1[i].width;
+		return totalWidth;
+	}
+	function getMaximumHeightOfEncodings(encodings$1) {
+		var maxHeight = 0;
+		for (var i = 0; i < encodings$1.length; i++) if (encodings$1[i].height > maxHeight) maxHeight = encodings$1[i].height;
+		return maxHeight;
+	}
+	function messureText(string, options, context) {
+		var ctx;
+		if (context) ctx = context;
+		else if (typeof document !== "undefined") ctx = document.createElement("canvas").getContext("2d");
+		else return 0;
+		ctx.font = options.fontOptions + " " + options.fontSize + "px " + options.font;
+		var measureTextResult = ctx.measureText(string);
+		if (!measureTextResult) return 0;
+		return measureTextResult.width;
+	}
+	exports.getMaximumHeightOfEncodings = getMaximumHeightOfEncodings;
+	exports.getEncodingHeight = getEncodingHeight;
+	exports.getBarcodePadding = getBarcodePadding;
+	exports.calculateEncodingAttributes = calculateEncodingAttributes;
+	exports.getTotalWidthOfEncodings = getTotalWidthOfEncodings;
+}));
+var require_canvas = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$3 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _merge2$2 = _interopRequireDefault$4(require_merge());
+	var _shared$1 = require_shared();
+	function _interopRequireDefault$4(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$4(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	exports.default = function() {
+		function CanvasRenderer$1(canvas, encodings$1, options) {
+			_classCallCheck$4(this, CanvasRenderer$1);
+			this.canvas = canvas;
+			this.encodings = encodings$1;
+			this.options = options;
+		}
+		_createClass$3(CanvasRenderer$1, [
+			{
+				key: "render",
+				value: function render$1() {
+					if (!this.canvas.getContext) throw new Error("The browser does not support canvas.");
+					this.prepareCanvas();
+					for (var i = 0; i < this.encodings.length; i++) {
+						var encodingOptions = (0, _merge2$2.default)(this.options, this.encodings[i].options);
+						this.drawCanvasBarcode(encodingOptions, this.encodings[i]);
+						this.drawCanvasText(encodingOptions, this.encodings[i]);
+						this.moveCanvasDrawing(this.encodings[i]);
+					}
+					this.restoreCanvas();
+				}
+			},
+			{
+				key: "prepareCanvas",
+				value: function prepareCanvas() {
+					var ctx = this.canvas.getContext("2d");
+					ctx.save();
+					(0, _shared$1.calculateEncodingAttributes)(this.encodings, this.options, ctx);
+					var totalWidth = (0, _shared$1.getTotalWidthOfEncodings)(this.encodings);
+					var maxHeight = (0, _shared$1.getMaximumHeightOfEncodings)(this.encodings);
+					this.canvas.width = totalWidth + this.options.marginLeft + this.options.marginRight;
+					this.canvas.height = maxHeight;
+					ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+					if (this.options.background) {
+						ctx.fillStyle = this.options.background;
+						ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+					}
+					ctx.translate(this.options.marginLeft, 0);
+				}
+			},
+			{
+				key: "drawCanvasBarcode",
+				value: function drawCanvasBarcode(options, encoding) {
+					var ctx = this.canvas.getContext("2d");
+					var binary = encoding.data;
+					var yFrom;
+					if (options.textPosition == "top") yFrom = options.marginTop + options.fontSize + options.textMargin;
+					else yFrom = options.marginTop;
+					ctx.fillStyle = options.lineColor;
+					for (var b = 0; b < binary.length; b++) {
+						var x = b * options.width + encoding.barcodePadding;
+						if (binary[b] === "1") ctx.fillRect(x, yFrom, options.width, options.height);
+						else if (binary[b]) ctx.fillRect(x, yFrom, options.width, options.height * binary[b]);
+					}
+				}
+			},
+			{
+				key: "drawCanvasText",
+				value: function drawCanvasText(options, encoding) {
+					var ctx = this.canvas.getContext("2d");
+					var font = options.fontOptions + " " + options.fontSize + "px " + options.font;
+					if (options.displayValue) {
+						var x, y;
+						if (options.textPosition == "top") y = options.marginTop + options.fontSize - options.textMargin;
+						else y = options.height + options.textMargin + options.marginTop + options.fontSize;
+						ctx.font = font;
+						if (options.textAlign == "left" || encoding.barcodePadding > 0) {
+							x = 0;
+							ctx.textAlign = "left";
+						} else if (options.textAlign == "right") {
+							x = encoding.width - 1;
+							ctx.textAlign = "right";
+						} else {
+							x = encoding.width / 2;
+							ctx.textAlign = "center";
+						}
+						ctx.fillText(encoding.text, x, y);
+					}
+				}
+			},
+			{
+				key: "moveCanvasDrawing",
+				value: function moveCanvasDrawing(encoding) {
+					this.canvas.getContext("2d").translate(encoding.width, 0);
+				}
+			},
+			{
+				key: "restoreCanvas",
+				value: function restoreCanvas() {
+					this.canvas.getContext("2d").restore();
+				}
+			}
+		]);
+		return CanvasRenderer$1;
+	}();
+}));
+var require_svg = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$2 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	var _merge2$1 = _interopRequireDefault$3(require_merge());
+	var _shared = require_shared();
+	function _interopRequireDefault$3(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function _classCallCheck$3(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	var svgns = "http://www.w3.org/2000/svg";
+	exports.default = function() {
+		function SVGRenderer$1(svg, encodings$1, options) {
+			_classCallCheck$3(this, SVGRenderer$1);
+			this.svg = svg;
+			this.encodings = encodings$1;
+			this.options = options;
+			this.document = options.xmlDocument || document;
+		}
+		_createClass$2(SVGRenderer$1, [
+			{
+				key: "render",
+				value: function render$1() {
+					var currentX = this.options.marginLeft;
+					this.prepareSVG();
+					for (var i = 0; i < this.encodings.length; i++) {
+						var encoding = this.encodings[i];
+						var encodingOptions = (0, _merge2$1.default)(this.options, encoding.options);
+						var group = this.createGroup(currentX, encodingOptions.marginTop, this.svg);
+						this.setGroupOptions(group, encodingOptions);
+						this.drawSvgBarcode(group, encodingOptions, encoding);
+						this.drawSVGText(group, encodingOptions, encoding);
+						currentX += encoding.width;
+					}
+				}
+			},
+			{
+				key: "prepareSVG",
+				value: function prepareSVG() {
+					while (this.svg.firstChild) this.svg.removeChild(this.svg.firstChild);
+					(0, _shared.calculateEncodingAttributes)(this.encodings, this.options);
+					var totalWidth = (0, _shared.getTotalWidthOfEncodings)(this.encodings);
+					var maxHeight = (0, _shared.getMaximumHeightOfEncodings)(this.encodings);
+					var width = totalWidth + this.options.marginLeft + this.options.marginRight;
+					this.setSvgAttributes(width, maxHeight);
+					if (this.options.background) this.drawRect(0, 0, width, maxHeight, this.svg).setAttribute("fill", this.options.background);
+				}
+			},
+			{
+				key: "drawSvgBarcode",
+				value: function drawSvgBarcode(parent, options, encoding) {
+					var binary = encoding.data;
+					var yFrom;
+					if (options.textPosition == "top") yFrom = options.fontSize + options.textMargin;
+					else yFrom = 0;
+					var barWidth = 0;
+					var x = 0;
+					for (var b = 0; b < binary.length; b++) {
+						x = b * options.width + encoding.barcodePadding;
+						if (binary[b] === "1") barWidth++;
+						else if (barWidth > 0) {
+							this.drawRect(x - options.width * barWidth, yFrom, options.width * barWidth, options.height, parent);
+							barWidth = 0;
+						}
+					}
+					if (barWidth > 0) this.drawRect(x - options.width * (barWidth - 1), yFrom, options.width * barWidth, options.height, parent);
+				}
+			},
+			{
+				key: "drawSVGText",
+				value: function drawSVGText(parent, options, encoding) {
+					var textElem = this.document.createElementNS(svgns, "text");
+					if (options.displayValue) {
+						var x, y;
+						textElem.setAttribute("font-family", options.font);
+						textElem.setAttribute("font-size", options.fontSize);
+						if (options.fontOptions.includes("bold")) textElem.setAttribute("font-weight", "bold");
+						if (options.fontOptions.includes("italic")) textElem.setAttribute("font-style", "italic");
+						if (options.textPosition == "top") y = options.fontSize - options.textMargin;
+						else y = options.height + options.textMargin + options.fontSize;
+						if (options.textAlign == "left" || encoding.barcodePadding > 0) {
+							x = 0;
+							textElem.setAttribute("text-anchor", "start");
+						} else if (options.textAlign == "right") {
+							x = encoding.width - 1;
+							textElem.setAttribute("text-anchor", "end");
+						} else {
+							x = encoding.width / 2;
+							textElem.setAttribute("text-anchor", "middle");
+						}
+						textElem.setAttribute("x", x);
+						textElem.setAttribute("y", y);
+						textElem.appendChild(this.document.createTextNode(encoding.text));
+						parent.appendChild(textElem);
+					}
+				}
+			},
+			{
+				key: "setSvgAttributes",
+				value: function setSvgAttributes(width, height) {
+					var svg = this.svg;
+					svg.setAttribute("width", width + "px");
+					svg.setAttribute("height", height + "px");
+					svg.setAttribute("x", "0px");
+					svg.setAttribute("y", "0px");
+					svg.setAttribute("viewBox", "0 0 " + width + " " + height);
+					svg.setAttribute("xmlns", svgns);
+					svg.setAttribute("version", "1.1");
+				}
+			},
+			{
+				key: "createGroup",
+				value: function createGroup(x, y, parent) {
+					var group = this.document.createElementNS(svgns, "g");
+					group.setAttribute("transform", "translate(" + x + ", " + y + ")");
+					parent.appendChild(group);
+					return group;
+				}
+			},
+			{
+				key: "setGroupOptions",
+				value: function setGroupOptions(group, options) {
+					group.setAttribute("fill", options.lineColor);
+				}
+			},
+			{
+				key: "drawRect",
+				value: function drawRect(x, y, width, height, parent) {
+					var rect = this.document.createElementNS(svgns, "rect");
+					rect.setAttribute("x", x);
+					rect.setAttribute("y", y);
+					rect.setAttribute("width", width);
+					rect.setAttribute("height", height);
+					parent.appendChild(rect);
+					return rect;
+				}
+			}
+		]);
+		return SVGRenderer$1;
+	}();
+}));
+var require_object = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass$1 = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	function _classCallCheck$2(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	exports.default = function() {
+		function ObjectRenderer$1(object, encodings$1, options) {
+			_classCallCheck$2(this, ObjectRenderer$1);
+			this.object = object;
+			this.encodings = encodings$1;
+			this.options = options;
+		}
+		_createClass$1(ObjectRenderer$1, [{
+			key: "render",
+			value: function render$1() {
+				this.object.encodings = this.encodings;
+			}
+		}]);
+		return ObjectRenderer$1;
+	}();
+}));
+var require_renderers = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _canvas2 = _interopRequireDefault$2(require_canvas());
+	var _svg2 = _interopRequireDefault$2(require_svg());
+	var _object2 = _interopRequireDefault$2(require_object());
+	function _interopRequireDefault$2(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	exports.default = {
+		CanvasRenderer: _canvas2.default,
+		SVGRenderer: _svg2.default,
+		ObjectRenderer: _object2.default
+	};
+}));
+var require_exceptions = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _classCallCheck$1(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn(self, call) {
+		if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return call && (typeof call === "object" || typeof call === "function") ? call : self;
+	}
+	function _inherits(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+	}
+	var InvalidInputException = function(_Error) {
+		_inherits(InvalidInputException$1, _Error);
+		function InvalidInputException$1(symbology, input) {
+			_classCallCheck$1(this, InvalidInputException$1);
+			var _this = _possibleConstructorReturn(this, (InvalidInputException$1.__proto__ || Object.getPrototypeOf(InvalidInputException$1)).call(this));
+			_this.name = "InvalidInputException";
+			_this.symbology = symbology;
+			_this.input = input;
+			_this.message = "\"" + _this.input + "\" is not a valid input for " + _this.symbology;
+			return _this;
+		}
+		return InvalidInputException$1;
+	}(Error);
+	var InvalidElementException = function(_Error2) {
+		_inherits(InvalidElementException$1, _Error2);
+		function InvalidElementException$1() {
+			_classCallCheck$1(this, InvalidElementException$1);
+			var _this2 = _possibleConstructorReturn(this, (InvalidElementException$1.__proto__ || Object.getPrototypeOf(InvalidElementException$1)).call(this));
+			_this2.name = "InvalidElementException";
+			_this2.message = "Not supported type to render on";
+			return _this2;
+		}
+		return InvalidElementException$1;
+	}(Error);
+	var NoElementException = function(_Error3) {
+		_inherits(NoElementException$1, _Error3);
+		function NoElementException$1() {
+			_classCallCheck$1(this, NoElementException$1);
+			var _this3 = _possibleConstructorReturn(this, (NoElementException$1.__proto__ || Object.getPrototypeOf(NoElementException$1)).call(this));
+			_this3.name = "NoElementException";
+			_this3.message = "No element to render on.";
+			return _this3;
+		}
+		return NoElementException$1;
+	}(Error);
+	exports.InvalidInputException = InvalidInputException;
+	exports.InvalidElementException = InvalidElementException;
+	exports.NoElementException = NoElementException;
+}));
+var require_getRenderProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
+		return typeof obj;
+	} : function(obj) {
+		return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+	};
+	var _getOptionsFromElement2 = _interopRequireDefault$1(require_getOptionsFromElement());
+	var _renderers2 = _interopRequireDefault$1(require_renderers());
+	var _exceptions$1 = require_exceptions();
+	function _interopRequireDefault$1(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function getRenderProperties(element) {
+		if (typeof element === "string") return querySelectedRenderProperties(element);
+		else if (Array.isArray(element)) {
+			var returnArray = [];
+			for (var i = 0; i < element.length; i++) returnArray.push(getRenderProperties(element[i]));
+			return returnArray;
+		} else if (typeof HTMLCanvasElement !== "undefined" && element instanceof HTMLImageElement) return newCanvasRenderProperties(element);
+		else if (element && element.nodeName && element.nodeName.toLowerCase() === "svg" || typeof SVGElement !== "undefined" && element instanceof SVGElement) return {
+			element,
+			options: (0, _getOptionsFromElement2.default)(element),
+			renderer: _renderers2.default.SVGRenderer
+		};
+		else if (typeof HTMLCanvasElement !== "undefined" && element instanceof HTMLCanvasElement) return {
+			element,
+			options: (0, _getOptionsFromElement2.default)(element),
+			renderer: _renderers2.default.CanvasRenderer
+		};
+		else if (element && element.getContext) return {
+			element,
+			renderer: _renderers2.default.CanvasRenderer
+		};
+		else if (element && (typeof element === "undefined" ? "undefined" : _typeof(element)) === "object" && !element.nodeName) return {
+			element,
+			renderer: _renderers2.default.ObjectRenderer
+		};
+		else throw new _exceptions$1.InvalidElementException();
+	}
+	function querySelectedRenderProperties(string) {
+		var selector = document.querySelectorAll(string);
+		if (selector.length === 0) return;
+		else {
+			var returnArray = [];
+			for (var i = 0; i < selector.length; i++) returnArray.push(getRenderProperties(selector[i]));
+			return returnArray;
+		}
+	}
+	function newCanvasRenderProperties(imgElement) {
+		var canvas = document.createElement("canvas");
+		return {
+			element: canvas,
+			options: (0, _getOptionsFromElement2.default)(imgElement),
+			renderer: _renderers2.default.CanvasRenderer,
+			afterRender: function afterRender() {
+				imgElement.setAttribute("src", canvas.toDataURL());
+			}
+		};
+	}
+	exports.default = getRenderProperties;
+}));
+var require_ErrorHandler = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var _createClass = function() {
+		function defineProperties(target, props) {
+			for (var i = 0; i < props.length; i++) {
+				var descriptor = props[i];
+				descriptor.enumerable = descriptor.enumerable || false;
+				descriptor.configurable = true;
+				if ("value" in descriptor) descriptor.writable = true;
+				Object.defineProperty(target, descriptor.key, descriptor);
+			}
+		}
+		return function(Constructor, protoProps, staticProps) {
+			if (protoProps) defineProperties(Constructor.prototype, protoProps);
+			if (staticProps) defineProperties(Constructor, staticProps);
+			return Constructor;
+		};
+	}();
+	function _classCallCheck(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	exports.default = function() {
+		function ErrorHandler$1(api) {
+			_classCallCheck(this, ErrorHandler$1);
+			this.api = api;
+		}
+		_createClass(ErrorHandler$1, [{
+			key: "handleCatch",
+			value: function handleCatch(e) {
+				if (e.name === "InvalidInputException") if (this.api._options.valid !== this.api._defaults.valid) this.api._options.valid(false);
+				else throw e.message;
+				else throw e;
+				this.api.render = function() {};
+			}
+		}, {
+			key: "wrapBarcodeCall",
+			value: function wrapBarcodeCall(func) {
+				try {
+					var result = func.apply(void 0, arguments);
+					this.api._options.valid(true);
+					return result;
+				} catch (e) {
+					this.handleCatch(e);
+					return this.api;
+				}
+			}
+		}]);
+		return ErrorHandler$1;
+	}();
+}));
+var require_JsBarcode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var _barcodes2 = _interopRequireDefault(require_barcodes());
+	var _merge2 = _interopRequireDefault(require_merge());
+	var _linearizeEncodings2 = _interopRequireDefault(require_linearizeEncodings());
+	var _fixOptions2 = _interopRequireDefault(require_fixOptions());
+	var _getRenderProperties2 = _interopRequireDefault(require_getRenderProperties());
+	var _optionsFromStrings2 = _interopRequireDefault(require_optionsFromStrings());
+	var _ErrorHandler2 = _interopRequireDefault(require_ErrorHandler());
+	var _exceptions = require_exceptions();
+	var _defaults2 = _interopRequireDefault(require_defaults());
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	var API = function API$1() {};
+	var JsBarcode = function JsBarcode$1(element, text, options) {
+		var api = new API();
+		if (typeof element === "undefined") throw Error("No element to render on was provided.");
+		api._renderProperties = (0, _getRenderProperties2.default)(element);
+		api._encodings = [];
+		api._options = _defaults2.default;
+		api._errorHandler = new _ErrorHandler2.default(api);
+		if (typeof text !== "undefined") {
+			options = options || {};
+			if (!options.format) options.format = autoSelectBarcode();
+			api.options(options)[options.format](text, options).render();
+		}
+		return api;
+	};
+	JsBarcode.getModule = function(name$1) {
+		return _barcodes2.default[name$1];
+	};
+	for (var name in _barcodes2.default) if (_barcodes2.default.hasOwnProperty(name)) registerBarcode(_barcodes2.default, name);
+	function registerBarcode(barcodes, name$1) {
+		API.prototype[name$1] = API.prototype[name$1.toUpperCase()] = API.prototype[name$1.toLowerCase()] = function(text, options) {
+			var api = this;
+			return api._errorHandler.wrapBarcodeCall(function() {
+				options.text = typeof options.text === "undefined" ? void 0 : "" + options.text;
+				var newOptions = (0, _merge2.default)(api._options, options);
+				newOptions = (0, _optionsFromStrings2.default)(newOptions);
+				var Encoder = barcodes[name$1];
+				var encoded = encode(text, Encoder, newOptions);
+				api._encodings.push(encoded);
+				return api;
+			});
+		};
+	}
+	function encode(text, Encoder, options) {
+		text = "" + text;
+		var encoder = new Encoder(text, options);
+		if (!encoder.valid()) throw new _exceptions.InvalidInputException(encoder.constructor.name, text);
+		var encoded = encoder.encode();
+		encoded = (0, _linearizeEncodings2.default)(encoded);
+		for (var i = 0; i < encoded.length; i++) encoded[i].options = (0, _merge2.default)(options, encoded[i].options);
+		return encoded;
+	}
+	function autoSelectBarcode() {
+		if (_barcodes2.default["CODE128"]) return "CODE128";
+		return Object.keys(_barcodes2.default)[0];
+	}
+	API.prototype.options = function(options) {
+		this._options = (0, _merge2.default)(this._options, options);
+		return this;
+	};
+	API.prototype.blank = function(size) {
+		var zeroes = new Array(size + 1).join("0");
+		this._encodings.push({ data: zeroes });
+		return this;
+	};
+	API.prototype.init = function() {
+		if (!this._renderProperties) return;
+		if (!Array.isArray(this._renderProperties)) this._renderProperties = [this._renderProperties];
+		var renderProperty;
+		for (var i in this._renderProperties) {
+			renderProperty = this._renderProperties[i];
+			var options = (0, _merge2.default)(this._options, renderProperty.options);
+			if (options.format == "auto") options.format = autoSelectBarcode();
+			this._errorHandler.wrapBarcodeCall(function() {
+				var text = options.value;
+				var Encoder = _barcodes2.default[options.format.toUpperCase()];
+				var encoded = encode(text, Encoder, options);
+				render(renderProperty, encoded, options);
+			});
+		}
+	};
+	API.prototype.render = function() {
+		if (!this._renderProperties) throw new _exceptions.NoElementException();
+		if (Array.isArray(this._renderProperties)) for (var i = 0; i < this._renderProperties.length; i++) render(this._renderProperties[i], this._encodings, this._options);
+		else render(this._renderProperties, this._encodings, this._options);
+		return this;
+	};
+	API.prototype._defaults = _defaults2.default;
+	function render(renderProperties, encodings$1, options) {
+		encodings$1 = (0, _linearizeEncodings2.default)(encodings$1);
+		for (var i = 0; i < encodings$1.length; i++) {
+			encodings$1[i].options = (0, _merge2.default)(options, encodings$1[i].options);
+			(0, _fixOptions2.default)(encodings$1[i].options);
+		}
+		(0, _fixOptions2.default)(options);
+		var Renderer = renderProperties.renderer;
+		new Renderer(renderProperties.element, encodings$1, options).render();
+		if (renderProperties.afterRender) renderProperties.afterRender();
+	}
+	if (typeof window !== "undefined") window.JsBarcode = JsBarcode;
+	if (typeof jQuery !== "undefined") jQuery.fn.JsBarcode = function(content, options) {
+		var elementArray = [];
+		jQuery(this).each(function() {
+			elementArray.push(this);
+		});
+		return JsBarcode(elementArray, content, options);
+	};
+	module.exports = JsBarcode;
+}));
+export default require_JsBarcode();
+
+//# sourceMappingURL=JsBarcode-C5ux6wsb.js.map