Barcode Generation

node_modules/jsbarcode/test/node/CODE128.test.js

@@ -0,0 +1,109 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var Canvas = require("canvas");
+
+
+describe('CODE128', function() {
+  it('should be able to include the encoder(s)', function () {
+    CODE128 = JsBarcode.getModule("CODE128");
+    CODE128A = JsBarcode.getModule("CODE128A");
+    CODE128B = JsBarcode.getModule("CODE128B");
+    CODE128C = JsBarcode.getModule("CODE128C");
+  });
+
+  it('should encode CODE128A', function () {
+    var enc = new CODE128A("ABC" + String.fromCharCode(25), {});
+    assert.equal("1101000010010100011000100010110001000100011011011011110100011101101100011101011"
+      , enc.encode().data);
+  });
+
+  it('should encode CODE128B', function () {
+    var enc = new CODE128B("a@B=1", {});
+    assert.equal("110100100001001011000011000110110100010110001110011001010011100110110111001001100011101011"
+      , enc.encode().data);
+  });
+
+  it('should encode CODE128C', function () {
+    var enc = new CODE128C("123456", {});
+    assert.equal("11010011100101100111001000101100011100010110100011011101100011101011"
+      , enc.encode().data);
+  });
+
+  it('should encode CODE128 as GS1-128/EAN-128', function () {
+    var enc = new CODE128C("12345678", { ean128: true });
+    assert.equal("110100111001111010111010110011100100010110001110001011011000010100110010011101100011101011",
+      enc.encode().data);
+  });
+
+  it('should remove unprintable characters', function () {
+    var enc = new CODE128C("A\n\x00B \x04\x10\x1FC", {});
+    assert.equal("AB C", enc.encode().text);
+  });
+
+  it('should encode CODE128 (auto)', function () {
+    var enc = new CODE128("12345Hejsan123456\tA", {});
+    assert.equal("110100111001011001110010001011000101111011101101110010011000101000101100100001000011001010111100100100101100001100001010010111011110101100111001000101100011100010110111010111101000011010010100011000111011110101100011101011",
+      enc.encode().data);
+
+    var enc = new CODE128("Hi\n12345", {});
+    assert.equal("110100100001100010100010000110100111010111101000011001010011100110101110111101110110111010111011000111001100101100011101011"
+      , enc.encode().data);
+
+    var enc = new CODE128("HI\nHi", {});
+    assert.equal("11010000100110001010001100010001010000110010110001010001011110111010000110100110110011001100011101011"
+      , enc.encode().data);
+
+    var enc = new CODE128("HI\n" + String.fromCharCode(201) + "Hi" + String.fromCharCode(202) + "123456" + String.fromCharCode(207), {});
+    assert.equal("1101000010011000101000110001000101000011001010111100010110001010001011110111010000110100111101010001011101111010110011100100010110001110001011011110101110110011100101100011101011"
+      , enc.encode().data);
+
+    var enc = new CODE128(String.fromCharCode(207) + "42184020500", {});
+    assert.equal("110100111001111010111010110111000110011100101100010100011001001110110001011101110101111010011101100101011110001100011101011"
+      , enc.encode().data);
+
+    var enc = new CODE128("Should\nshift", {});
+    assert.equal("1101001000011011101000100110000101000111101010011110010110010100001000010011011110100010100001100101011110010010011000010100001101001011000010010011110100100011010001100011101011"
+      , enc.encode().data);
+
+    var enc = new CODE128("\tHi\nHI", {});
+    assert.equal("1101000010010000110100110001010001111010001010000110100100001100101100010100011000100010111101101101100011101011"
+      , enc.encode().data);
+
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new CODE128("ABC" + String.fromCharCode(500), {});
+    assert.equal(false, enc.valid(), {});
+
+    var enc = new CODE128A("Abc", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new CODE128B("Abc\t123", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new CODE128C("1234ab56", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new CODE128C("12345", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should pass valid text', function () {
+    var enc = new CODE128("ABC" + String.fromCharCode(207), {});
+    assert.equal(true, enc.valid());
+
+    var enc = new CODE128A("ABC\t\n123", {});
+    assert.equal(true, enc.valid());
+
+    var enc = new CODE128B("Abc123" + String.fromCharCode(202), {});
+    assert.equal(true, enc.valid());
+
+    var enc = new CODE128C("123456", {});
+    assert.equal(true, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new CODE128("AB12", {text: "THISISTEXT"});
+    assert.equal("THISISTEXT", enc.encode().text);
+  });
+});

node_modules/jsbarcode/test/node/CODE39.test.js

@@ -0,0 +1,37 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var Canvas = require("canvas");
+
+
+describe('CODE39', function() {
+  it('should be able to include the encoder(s)', function () {
+    CODE39 = JsBarcode.getModule("CODE39");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new CODE39("AB12", {});
+    assert.equal("100010111011101011101010001011101011101000101110111010001010111010111000101011101000101110111010"
+      , enc.encode().data);
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new CODE39("AB!12", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should make lowercase to uppercase', function () {
+    var enc = new CODE39("abc123ABC", {});
+    assert.equal("ABC123ABC", enc.encode().text);
+  });
+
+  it('should calculate correct checksums', function () {
+    var enc = new CODE39("ABCDEFG", {mod43: true});
+    assert.equal("1000101110111010111010100010111010111010001011101110111010001010101011100010111011101011100010101011101110001010101010001110111011101000111010101000101110111010"
+      , enc.encode().data);
+  });
+
+  it('should work with text option', function () {
+    var enc = new CODE39("AB12", {text: "THISISTEXT"});
+    assert.equal("THISISTEXT", enc.encode().text);
+  });
+});

node_modules/jsbarcode/test/node/EAN-UPC.test.js

@@ -0,0 +1,220 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var Canvas = require("canvas");
+var help = require("./help/help");
+var clone = help.clone;
+
+var options = {height: 100, displayValue: true, fontSize: 20, textMargin: 2, width: 2};
+
+describe('UPC-A', function() {
+  it('should be able to include the encoder(s)', function () {
+    UPC = JsBarcode.getModule("UPC");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new UPC("123456789999", clone(options));
+    assert.equal("10100110010010011011110101000110110001010111101010100010010010001110100111010011101001110100101"
+      , help.fixBin(enc.encode()));
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new UPC("12345", clone(options));
+    assert.equal(false, enc.valid());
+  });
+
+  it('should auto include the checksum if missing', function () {
+    var enc = new UPC("12345678999", clone(options));
+    assert.equal("123456789999", help.fixText(enc.encode()));
+  });
+
+  it('should work with text option', function () {
+    var enc = new UPC("12345678999", help.merge(options, {text: "THISISTEXT"}));
+    assert.equal("THISISTEXT", help.fixText(enc.encode()));
+  });
+
+  it('should work with flat option', function () {
+    var enc = new UPC("123456789999", help.merge(options, {flat: true}));
+    assert.equal("10100110010010011011110101000110110001010111101010100010010010001110100111010011101001110100101"
+      , enc.encode().data);
+    assert.equal("123456789999", enc.encode().text);
+  });
+});
+
+const UPCE_BINARY = "101011001100100110011101011100101110110011001010101";
+describe('UPC-E', function() {
+  it('should be able to include the encoder(s)', function () {
+    UPCE = JsBarcode.getModule("UPCE");
+  });
+
+  it('should be able to encode 8-digit codes', function () {
+    var enc = new UPCE("01245714", clone(options));
+    assert.equal(UPCE_BINARY, help.fixBin(enc.encode()));
+  });
+
+  it('should be able to encode 6-digit codes by assuming a 0 number system', function () {
+    var enc = new UPCE("124571", clone(options));
+    assert.equal(UPCE_BINARY, help.fixBin(enc.encode()));
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new UPCE("01245715", clone(options));
+    assert.equal(false, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new UPCE("124571", help.merge(options, {text: "SOMETEXT"}));
+    assert.equal("SOMETEXT", help.fixText(enc.encode()));
+  });
+
+  it('should work with flat option', function () {
+    var enc = new UPCE("01245714", help.merge(options, {flat: true}));
+    assert.equal(UPCE_BINARY, enc.encode().data);
+    assert.equal("01245714", enc.encode().text);
+  });
+});
+
+describe('EAN', function() {
+  it('should be able to include the encoder(s)', function () {
+    EAN = JsBarcode.getModule("EAN13");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new EAN("5901234123457", clone(options));
+    assert.equal(true, enc.valid());
+    assert.equal("10100010110100111011001100100110111101001110101010110011011011001000010101110010011101000100101"
+      , help.fixBin(enc.encode()));
+    assert.equal("5901234123457", help.fixText(enc.encode()));
+  });
+
+  it('should be able to encode normal text with flat option', function () {
+    var enc = new EAN("5901234123457", help.merge(options, {flat: true}));
+    assert.equal(true, enc.valid());
+    assert.equal("10100010110100111011001100100110111101001110101010110011011011001000010101110010011101000100101"
+      , enc.encode().data);
+    assert.equal("5901234123457", help.fixText(enc.encode()));
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new EAN("12345", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new EAN("5901234123456  ", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should auto include the checksum if missing', function () {
+    var enc = new EAN("590123412345", clone(options));
+    assert.equal("5901234123457", help.fixText(enc.encode()));
+  });
+
+  it('should work with text option', function () {
+    var enc = new EAN("12345678999", help.merge(options, {text: "THISISTEXT"}));
+    assert.equal("THISISTEXT", help.fixText(enc.encode()));
+  });
+});
+
+describe('EAN-8', function() {
+  it('should be able to include the encoder(s)', function () {
+    EAN8 = JsBarcode.getModule("EAN8");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new EAN8("96385074", {});
+    assert.equal(true, enc.valid());
+    assert.equal("1010001011010111101111010110111010101001110111001010001001011100101"
+      , help.fixBin(enc.encode()));
+    assert.equal("96385074", help.fixText(enc.encode()));
+  });
+
+  it('should be able to encode normal text with flat option', function () {
+    var enc = new EAN8("96385074", help.merge(options, {flat: true}));
+    assert.equal(true, enc.valid());
+    assert.equal("1010001011010111101111010110111010101001110111001010001001011100101"
+      , enc.encode().data);
+    assert.equal("96385074", help.fixText(enc.encode()));
+  });
+
+  it('should auto include the checksum if missing', function () {
+    var enc = new EAN8("9638507", {});
+
+    assert.equal(true, enc.valid());
+    assert.equal("96385074", help.fixText(enc.encode()));
+    assert.equal("1010001011010111101111010110111010101001110111001010001001011100101"
+      , help.fixBin(enc.encode()));
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new EAN8("12345", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new EAN8("96385073", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new EAN8("96385074", help.merge(options, {text: "THISISTEXT", flat: true}));
+    assert.equal("THISISTEXT", help.fixText(enc.encode()));
+  });
+});
+
+describe('EAN-5', function() {
+  it('should be able to include the encoder(s)', function () {
+    EAN5 = JsBarcode.getModule("EAN5");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new EAN5("54495", {});
+    assert.equal(true, enc.valid());
+    assert.equal("10110110001010100011010011101010001011010111001"
+      , enc.encode().data);
+
+    var enc = new EAN5("12345", {});
+    assert.equal(true, enc.valid());
+    assert.equal("10110110011010010011010100001010100011010110001"
+      , enc.encode().data);
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new EAN5("1234", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new EAN5("123a5", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new EAN5("12345", help.merge(options, {text: "THISISTEXT"}));
+    assert.equal("THISISTEXT", help.fixText(enc.encode()));
+  });
+});
+
+describe('EAN-2', function() {
+  it('should be able to include the encoder(s)', function () {
+    EAN2 = JsBarcode.getModule("EAN2");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new EAN2("53", {});
+    assert.equal(true, enc.valid());
+    assert.equal("10110110001010100001"
+      , enc.encode().data);
+
+    var enc = new EAN2("12", {});
+    assert.equal(true, enc.valid());
+    assert.equal("10110011001010010011"
+      , enc.encode().data);
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new EAN2("1", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new EAN2("a2", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new EAN2("12", help.merge(options, {text: "THISISTEXT"}));
+    assert.equal("THISISTEXT", help.fixText(enc.encode()));
+  });
+});

node_modules/jsbarcode/test/node/ITF-14.test.js

@@ -0,0 +1,68 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var Canvas = require("canvas");
+
+
+describe('ITF-14', function() {
+  it('should be able to include the encoder(s)', function () {
+    ITF14 = JsBarcode.getModule("ITF14");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new ITF14("98765432109213", {});
+    assert.equal("101010001110101110001010100010001110111011101011100010100011101110001010100011101010001000111010111000101110100011100010001010111011101"
+      , enc.encode().data);
+  });
+
+  it('should be able to add checksum if needed', function () {
+    var enc = new ITF14("9876543210921", {});
+    assert.equal("101010001110101110001010100010001110111011101011100010100011101110001010100011101010001000111010111000101110100011100010001010111011101"
+      , enc.encode().data);
+  });
+
+  it('should return text correct', function () {
+    var enc = new ITF14("9876543210921", {});
+    assert.equal("98765432109213", enc.encode().text);
+
+    var enc = new ITF14("98765432109213", {});
+    assert.equal("98765432109213", enc.encode().text);
+  });
+
+  it('should warn with invalid text and not when valid', function () {
+    var enc = new ITF14("987654321092", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new ITF14("98765432109212", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new ITF14("98765432109213", {});
+    assert.equal(true, enc.valid());
+
+    var enc = new ITF14("9876543210921", {});
+    assert.equal(true, enc.valid());
+
+    // Edge cases for check digit of zero
+    var enc = new ITF14("00847280031740", {});
+    assert.equal(true, enc.valid());
+
+    var enc = new ITF14("00847280031900", {});
+    assert.equal(true, enc.valid());
+
+    var enc = new ITF14("00847280032020", {});
+    assert.equal(true, enc.valid());
+
+    var enc = new ITF14("00847280031870", {});
+    assert.equal(true, enc.valid());
+
+    var enc = new ITF14("00847280031450", {});
+    assert.equal(true, enc.valid());
+
+    var enc = new ITF14("00847280031320", {});
+    assert.equal(true, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new ITF14("00847280031450", {text: "THISISTEXT"});
+    assert.equal("THISISTEXT", enc.encode().text);
+  });
+});

node_modules/jsbarcode/test/node/ITF.test.js

@@ -0,0 +1,34 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var Canvas = require("canvas");
+
+
+describe('ITF', function() {
+  it('should be able to include the encoder(s)', function () {
+    ITF = JsBarcode.getModule("ITF");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new ITF("123456", {});
+    assert.equal("101011101000101011100011101110100010100011101000111000101011101"
+      , enc.encode().data);
+  });
+
+  it('should return getText correct', function () {
+    var enc = new ITF("123456", {});
+    assert.equal("123456", enc.encode().text);
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new ITF("12345", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new ITF("1234AB", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new ITF("123456", {text: "THISISTEXT"});
+    assert.equal("THISISTEXT", enc.encode().text);
+  });
+});

node_modules/jsbarcode/test/node/JsBarcode.test.js

@@ -0,0 +1,132 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var { createCanvas } = require("canvas");
+
+describe('Encoders', function() {
+  it('should be able to include the encoders needed', function () {
+    CODE128 = JsBarcode.getModule("CODE128");
+    GENERIC = JsBarcode.getModule("GenericBarcode");
+  });
+});
+
+describe('node-canvas generation', function() {
+  it('should generate normal canvas', function () {
+    var canvas = createCanvas();
+    JsBarcode(canvas, "Hello");
+  });
+
+  it('checking width', function () {
+    var canvas1 = createCanvas();
+    var canvas2 = createCanvas();
+
+    JsBarcode(canvas1, "Hello", {format: "CODE128"});
+    JsBarcode(canvas2, "Hello", {format: "CODE39"});
+
+    assert.notEqual(canvas1.width, canvas2.width);
+  });
+
+  it('should throws errors when suppose to', function () {
+    var canvas = createCanvas();
+    assert.throws(function(){JsBarcode(canvas, "Hello", {format: "EAN8"});});
+    assert.throws(function(){JsBarcode("Hello", "Hello", {format: "DOESNOTEXIST"});});
+    assert.throws(function(){JsBarcode(123, "Hello", {format: "DOESNOTEXIST"});});
+  });
+
+  it('should use the valid callback correct', function (done) {
+    var canvas = createCanvas();
+
+    JsBarcode(canvas, "Hello", {
+      format: "CODE128",
+      valid: function(valid){
+        if(valid){
+          done();
+        }
+      }
+    });
+  });
+
+  it('should use false valid callback correct', function (done) {
+    var canvas = createCanvas();
+
+    JsBarcode(canvas, "Hello", {
+      format: "pharmacode",
+      valid: function(valid){
+        if(!valid){
+          done();
+        }
+      }
+    });
+  });
+
+  it('should create output with same input', function () {
+    var canvas1 = createCanvas();
+    var canvas2 = createCanvas();
+
+    JsBarcode(canvas1, "Hello", {format: "CODE128"});
+    JsBarcode(canvas2, "Hello", {format: "CODE128"});
+
+    assert.equal(canvas1.toDataURL(), canvas2.toDataURL());
+  });
+
+  it('should set background', function () {
+    var canvas = createCanvas();
+    var ctx = canvas.getContext("2d");
+    JsBarcode(canvas, "Hello", {format: "CODE128", background: "#f00"});
+
+    var topLeft = ctx.getImageData(0,0,1,1);
+    assert.equal(255, topLeft.data[0]);
+    assert.equal(0, topLeft.data[1]);
+    assert.equal(0, topLeft.data[2]);
+  });
+});
+
+describe('Text printing', function() {
+  it('should produce different output when displaying value', function () {
+    var canvas1 = createCanvas();
+    var canvas2 = createCanvas();
+
+    JsBarcode(canvas1, "Hello", {format: "CODE128", displayValue: false});
+    JsBarcode(canvas2, "Hello", {format: "CODE128"});
+
+    assert.notEqual(canvas1.toDataURL(), canvas2.toDataURL());
+  });
+
+  it('should produce different output when having different textAlign', function () {
+    var canvas1 = createCanvas();
+    var canvas2 = createCanvas();
+    var canvas3 = createCanvas();
+
+    JsBarcode(canvas1, "Hello", {format: "CODE128", displayValue: true, textAlign: "center"});
+    JsBarcode(canvas2, "Hello", {format: "CODE128", displayValue: true, textAlign: "left"});
+    JsBarcode(canvas3, "Hello", {format: "CODE128", displayValue: true, textAlign: "right"});
+
+    assert.notEqual(canvas1.toDataURL(), canvas2.toDataURL());
+    assert.notEqual(canvas2.toDataURL(), canvas3.toDataURL());
+    assert.notEqual(canvas1.toDataURL(), canvas3.toDataURL());
+  });
+
+  it('should allow numbers as input', function () {
+    var canvas = createCanvas();
+
+    JsBarcode(canvas, 1234567890128, {format: "EAN13"});
+  });
+});
+
+describe('Extended Arrays', function() {
+  it('should work with extended arrays', function () {
+    Array.prototype.test = function(){};
+    Array.prototype._test = "test";
+
+    var canvas = createCanvas();
+    JsBarcode(canvas, "Hello");
+    JsBarcode(canvas, "HI", {format: "CODE39"});
+  });
+});
+
+describe('Generic barcode', function() {
+  it('should not fail generic barcode', function () {
+    var enc = new GENERIC("1234", {});
+    assert.equal(enc.valid(), true);
+    assert.equal(enc.encode().text, "1234");
+  });
+});

node_modules/jsbarcode/test/node/MSI.test.js

@@ -0,0 +1,77 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var Canvas = require("canvas");
+
+
+describe('MSI', function() {
+  it('should be able to include the encoder(s)', function () {
+    MSI = JsBarcode.getModule("MSI");
+    MSI10 = JsBarcode.getModule("MSI10");
+    MSI11 = JsBarcode.getModule("MSI11");
+    MSI1010 = JsBarcode.getModule("MSI1010");
+    MSI1110 = JsBarcode.getModule("MSI1110");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new MSI10("1234567", {});
+    assert.equal(true, enc.valid());
+    assert.equal("12345674", enc.encode().text);
+    assert.equal("1101001001001101001001101001001001101101001101001001001101001101001101101001001101101101001101001001001"
+      , enc.encode().data);
+
+    var enc = new MSI("12345674", {});
+    assert.equal("1101001001001101001001101001001001101101001101001001001101001101001101101001001101101101001101001001001"
+      , enc.encode().data);
+
+    var enc = new MSI10("17345", {});
+    assert.equal(true, enc.valid());
+    assert.equal("173450", enc.encode().text);
+
+    var enc = new MSI10("1234", {});
+    assert.equal(true, enc.valid());
+    assert.equal("12344", enc.encode().text);
+  });
+
+  it('should encode MSI11', function () {
+    var enc = new MSI11("123456", {});
+    assert.equal("1234560", enc.encode().text);
+
+    var enc = new MSI11("12345678", {});
+    assert.equal("123456785", enc.encode().text);
+
+    var enc = new MSI11("1234567891011", {});
+    assert.equal("12345678910115", enc.encode().text);
+
+    var enc = new MSI11("1134567", {});
+    assert.equal("11345670", enc.encode().text);
+  });
+
+  it('should encode MSI1010', function () {
+    var enc = new MSI1010("1234567", {});
+    assert.equal("123456741", enc.encode().text);
+
+    var enc = new MSI1010("1337", {});
+    assert.equal("133751", enc.encode().text);
+  });
+
+  it('should encode MSI1110', function () {
+    var enc = new MSI1110("12345678", {});
+    assert.equal("1234567855", enc.encode().text);
+
+    var enc = new MSI1110("1337", {});
+    assert.equal("133744", enc.encode().text);
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new MSI("12345ABC", {});
+    assert.equal(false, enc.valid());
+
+    var enc = new MSI("12345AB675", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new MSI("12345674", {text: "THISISTEXT"});
+    assert.equal("THISISTEXT", enc.encode().text);
+  });
+});

node_modules/jsbarcode/test/node/Object-Render.test.js

@@ -0,0 +1,41 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var Canvas = require("canvas");
+
+describe('Object', function() {
+	it('should handle default options', function () {
+		var data = {};
+		JsBarcode(data, '12345678');
+		assert.equal(typeof data.encodings, 'object');
+	});
+
+	it('should catch null', function() {
+		assert.throws(
+			() => {
+				JsBarcode(null, '12345678');
+			},
+			/InvalidElementException/
+		);
+	});
+
+  it('should ignore dom elements', function() {
+    var fakeElement = {
+      nodeName: 'Some Dom Element'
+    }
+    assert.throws(
+      () => {
+        JsBarcode(fakeElement, '2345678');
+      },
+      /InvalidElementException/
+    );
+  });
+	
+	it('should work for different types', function () {
+		var data = {};
+		JsBarcode(data, '550000000000', {
+			format: 'upc'
+		});
+		assert.equal(data.encodings.length, 7);
+		assert.ok(data.encodings.every((val) => val.options.format === 'upc'));
+	});
+});

node_modules/jsbarcode/test/node/codabar.test.js

@@ -0,0 +1,73 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var Canvas = require("canvas");
+
+describe('Codabar', function() {
+  it('should be able to include the encoder(s)', function () {
+    Codabar = JsBarcode.getModule("codabar");
+  });
+
+  it('should encode a string with start and stop characters', function() {
+    var enc = new Codabar("A12345B", {});
+    assert.equal("10110010010101011001010100101101100101010101101001011010100101001001011"
+      , enc.encode().data);
+  });
+
+  it('should add start and stop characters to a string without them', function() {
+    var enc = new Codabar("12345", {});
+    // should encode to "A12345A"
+    assert.equal("10110010010101011001010100101101100101010101101001011010100101011001001"
+      , enc.encode().data);
+  });
+
+  it('should return text string without start/stop characters', function() {
+    var enc = new Codabar("A12345B", {});
+    assert.equal("12345", enc.encode().text)
+  });
+
+  it('should warn with invalid start/stop characters', function () {
+    var enc = new Codabar("X12345Y", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should warn with only a start character', function () {
+    var enc = new Codabar("A12345", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should warn with only an invalid start character', function () {
+    var enc = new Codabar("X12345", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should warn with only a stop character', function () {
+    var enc = new Codabar("12345A", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should warn with only an invalid stop character', function () {
+    var enc = new Codabar("12345X", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should warn with only start and stop characters', function() {
+    var enc = new Codabar("AA", {})
+    assert.equal(false, enc.valid());
+  });
+
+  it('should warn with an empty string', function() {
+    var enc = new Codabar("", {})
+    assert.equal(false, enc.valid());
+  });
+
+  it('should warn with invalid input', function () {
+    var enc = new Codabar("A1234OOPS56A", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new Codabar("A1234OOPS56A", {text: "THISISATEXT"});
+    assert.equal("THISISATEXT", enc.encode().text);
+  });
+
+});

node_modules/jsbarcode/test/node/help/help.js

@@ -0,0 +1,72 @@
+module.exports.toBin = mergeToBin;
+module.exports.stripZero = stripZero;
+module.exports.fixText = mergeToText;
+module.exports.merge = merge;
+module.exports.clone = clone;
+
+module.exports.fixBin = function(a){
+  return stripZero(mergeToBin(a));
+}
+
+function mergeToText(encodeData){
+  if(Array.isArray(encodeData)){
+    var ret = "";
+    for(var i = 0; i < encodeData.length; i++){
+      ret += mergeToText(encodeData[i]);
+    }
+    return ret;
+  }
+  else{
+    return encodeData.text || "";
+  }
+}
+
+function mergeToBin(encodeData){
+  if(Array.isArray(encodeData)){
+    var ret = "";
+    for(var i = 0; i < encodeData.length; i++){
+      ret += toBin(encodeData[i].data);
+    }
+    return ret;
+  }
+  else{
+    return toBin(encodeData);
+  }
+}
+
+function toBin(res){
+  var ret = "";
+  for(var i=0;i<res.length;i++){
+    if(res[i] > 0){
+      ret += "1";
+    }
+    else{
+      ret += "0";
+    }
+  }
+  return ret;
+}
+
+function stripZero(string){
+  return string.match(/^0*(.+?)0*$/)[1];
+}
+
+function merge(old, replaceObj) {
+	var newMerge = {};
+	var k;
+	for (k in old) {
+		if (old.hasOwnProperty(k)) {
+			newMerge[k] = old[k];
+		}
+	}
+	for (k in replaceObj) {
+		if(replaceObj.hasOwnProperty(k) && typeof replaceObj[k] !== "undefined"){
+			newMerge[k] = replaceObj[k];
+		}
+	}
+	return newMerge;
+}
+
+function clone(obj){
+  return merge({}, obj)
+}

node_modules/jsbarcode/test/node/nodesvg.test.js

@@ -0,0 +1,20 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var xmldom  = require('xmldom');
+var DOMImplementation = xmldom.DOMImplementation;
+var XMLSerializer = xmldom.XMLSerializer;
+var xmlSerializer = new XMLSerializer();
+var document = new DOMImplementation().createDocument('http://www.w3.org/1999/xhtml', 'html', null);
+
+describe('SVG', function() {
+  it('should work with external SVG implementation', function () {
+    var svgNode = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+
+    JsBarcode(svgNode, 'test', {
+      xmlDocument: document
+    });
+
+    var xml = xmlSerializer.serializeToString(svgNode);
+    assert(xml.length > 200);
+  });
+});

node_modules/jsbarcode/test/node/pharmacode.test.js

@@ -0,0 +1,37 @@
+var assert = require('assert');
+var JsBarcode = require('../../bin/JsBarcode.js');
+var Canvas = require("canvas");
+
+describe('Pharmacode', function() {
+  it('should be able to include the encoder(s)', function () {
+    Pharmacode = JsBarcode.getModule("pharmacode");
+  });
+
+  it('should be able to encode normal text', function () {
+    var enc = new Pharmacode("1234", {});
+    assert.equal("10010011100111001001110010010011100111"
+      , enc.encode().data);
+
+    var enc = new Pharmacode("4567", {});
+    assert.equal("10010010011100111001110010011100111001001001"
+      , enc.encode().data);
+
+    var enc = new Pharmacode("12", {});
+    assert.equal("11100100111", enc.encode().data);
+  });
+
+  it('should return getText correct', function () {
+    var enc = new Pharmacode("1234", {});
+    assert.equal("1234", enc.encode().text);
+  });
+
+  it('should warn with invalid text', function () {
+    var enc = new Pharmacode("12345678", {});
+    assert.equal(false, enc.valid());
+  });
+
+  it('should work with text option', function () {
+    var enc = new Pharmacode("12345678", {text: "THISISTEXT"});
+    assert.equal("THISISTEXT", enc.encode().text);
+  });
+});