@progress/kendo-charts 2.7.2-dev.202502101310 → 2.7.2-develop.1

package/dist/es/barcode/encodings/code128.js

@@ -3,85 +3,73 @@ import { Encoding } from './encoding';
 import deepExtend from '../../common/deep-extend';
 import inArray from '../../common/in-array';
 
-var numberRegex = /^\d+$/;
-var alphanumericRegex = /^[a-z0-9]+$/i;
-var extend = Object.assign;
+const numberRegex = /^\d+$/;
+const alphanumericRegex = /^[a-z0-9]+$/i;
+const extend = Object.assign;
 
-export var State128 = (function (Class) {
-    function State128(encoding) {
-        Class.call(this);
+export class State128 extends Class {
+    constructor(encoding) {
+        super();
         this.encoding = encoding;
         this.initProperties();
     }
 
-    if ( Class ) State128.__proto__ = Class;
-    State128.prototype = Object.create( Class && Class.prototype );
-    State128.prototype.constructor = State128;
+    initProperties() { }
 
-    State128.prototype.initProperties = function initProperties () { };
+    addStart() { }
 
-    State128.prototype.addStart = function addStart () { };
+    is() { }
 
-    State128.prototype.is = function is () { };
-
-    State128.prototype.isCode = function isCode () {
+    isCode() {
         return false;
-    };
-
-    State128.prototype.move = function move () { };
+    }
 
-    State128.prototype.pushState = function pushState () { };
+    move() { }
 
-    return State128;
-}(Class));
+    pushState() { }
+}
 
-export var State128AB = (function (State128) {
-    function State128AB(encoding, states) {
-        State128.call(this, encoding);
+export class State128AB extends State128 {
+    constructor(encoding, states) {
+        super(encoding);
         this.states = states;
         this._initMoves(states);
     }
 
-    if ( State128 ) State128AB.__proto__ = State128;
-    State128AB.prototype = Object.create( State128 && State128.prototype );
-    State128AB.prototype.constructor = State128AB;
-
-    State128AB.prototype.initProperties = function initProperties () {
-        State128.prototype.initProperties.call(this);
+    initProperties() {
+        super.initProperties();
 
         deepExtend(this, {
             FNC4: "FNC4",
             SHIFT: 98
         });
-    };
+    }
 
-    State128AB.prototype.addStart = function addStart () {
+    addStart() {
         this.encoding.addPattern(this.START);
-    };
+    }
 
-    State128AB.prototype.is = function is (value, index) {
-        var code = value.charCodeAt(index);
+    is(value, index) {
+        let code = value.charCodeAt(index);
         return this.isCode(code);
-    };
+    }
 
-    State128AB.prototype.move = function move (encodingState) {
-        var idx = 0;
+    move(encodingState) {
+        let idx = 0;
 
         while (!this._moves[idx].call(this, encodingState) && idx < this._moves.length) {
             idx++;
         }
-    };
-
-    State128AB.prototype.pushState = function pushState (encodingState) {
-        var this$1 = this;
+    }
 
-        var states = this.states,
+    pushState(encodingState) {
+        let states = this.states,
             value = encodingState.value,
             maxLength = value.length,
             code;
 
         if (inArray("C", states)) {
-            var numberMatch = value.substr(encodingState.index).match(/\d{4,}/g);
+            let numberMatch = value.substr(encodingState.index).match(/\d{4,}/g);
 
             if (numberMatch) {
                 maxLength = value.indexOf(numberMatch[0], encodingState.index);
@@ -91,12 +79,12 @@ export var State128AB = (function (State128) {
         while ((code = encodingState.value.charCodeAt(encodingState.index)) >= 0 &&
             this.isCode(code) &&
             encodingState.index < maxLength) {
-            this$1.encoding.addPattern(this$1.getValue(code));
+            this.encoding.addPattern(this.getValue(code));
             encodingState.index++;
         }
-    };
+    }
 
-    State128AB.prototype._initMoves = function _initMoves (states) {
+    _initMoves(states) {
         this._moves = [];
 
         if (inArray(this.FNC4, states)) {
@@ -108,16 +96,16 @@ export var State128AB = (function (State128) {
         }
 
         this._moves.push(this._moveState);
-    };
+    }
 
-    State128AB.prototype._moveFNC = function _moveFNC (encodingState) {
+    _moveFNC(encodingState) {
         if (encodingState.fnc) {
             encodingState.fnc = false;
             return encodingState.previousState === this.key;
         }
-    };
+    }
 
-    State128AB.prototype._shiftState = function _shiftState (encodingState) {
+    _shiftState(encodingState) {
         if (encodingState.previousState === this.shiftKey &&
             (encodingState.index + 1 >= encodingState.value.length ||
                 this.encoding[this.shiftKey].is(encodingState.value, encodingState.index + 1))) {
@@ -125,29 +113,19 @@ export var State128AB = (function (State128) {
             encodingState.shifted = true;
             return true;
         }
-    };
+    }
 
-    State128AB.prototype._moveState = function _moveState () {
+    _moveState() {
         this.encoding.addPattern(this.MOVE);
         return true;
-    };
-
-    return State128AB;
-}(State128));
-
-var states128 = {};
-
-states128.A = (function (State128AB) {
-    function State128A () {
-        State128AB.apply(this, arguments);
     }
+}
 
-    if ( State128AB ) State128A.__proto__ = State128AB;
-    State128A.prototype = Object.create( State128AB && State128AB.prototype );
-    State128A.prototype.constructor = State128A;
+const states128 = {};
 
-    State128A.prototype.initProperties = function initProperties () {
-        State128AB.prototype.initProperties.call(this);
+states128.A = class State128A extends State128AB {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             key: "A",
@@ -155,34 +133,24 @@ states128.A = (function (State128AB) {
             MOVE: 101,
             START: 103
         });
-    };
+    }
 
-    State128A.prototype.isCode = function isCode (code) {
+    isCode(code) {
         return 0 <= code && code < 96;
-    };
+    }
 
-    State128A.prototype.getValue = function getValue (code) {
+    getValue(code) {
         if (code < 32) {
             return code + 64;
         }
 
         return code - 32;
-    };
-
-    return State128A;
-}(State128AB));
-
-states128.B = (function (State128AB) {
-    function State128B () {
-        State128AB.apply(this, arguments);
     }
+};
 
-    if ( State128AB ) State128B.__proto__ = State128AB;
-    State128B.prototype = Object.create( State128AB && State128AB.prototype );
-    State128B.prototype.constructor = State128B;
-
-    State128B.prototype.initProperties = function initProperties () {
-        State128AB.prototype.initProperties.call(this);
+states128.B = class State128B extends State128AB {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             key: "B",
@@ -190,119 +158,99 @@ states128.B = (function (State128AB) {
             MOVE: 100,
             START: 104
         });
-    };
+    }
 
-    State128B.prototype.isCode = function isCode (code) {
+    isCode(code) {
         return 32 <= code && code < 128;
-    };
+    }
 
-    State128B.prototype.getValue = function getValue (code) {
+    getValue(code) {
         return code - 32;
-    };
-
-    return State128B;
-}(State128AB));
-
-states128.C = (function (State128) {
-    function State128C () {
-        State128.apply(this, arguments);
     }
+};
 
-    if ( State128 ) State128C.__proto__ = State128;
-    State128C.prototype = Object.create( State128 && State128.prototype );
-    State128C.prototype.constructor = State128C;
-
-    State128C.prototype.initProperties = function initProperties () {
-        State128.prototype.initProperties.call(this);
+states128.C = class State128C extends State128 {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             key: "C",
             MOVE: 99,
             START: 105
         });
-    };
+    }
 
-    State128C.prototype.addStart = function addStart () {
+    addStart() {
         this.encoding.addPattern(this.START);
-    };
+    }
 
-    State128C.prototype.is = function is (value, index) {
-        var next4 = getSubstring(value, index, 4);
+    is(value, index) {
+        let next4 = getSubstring(value, index, 4);
         return (index + 4 <= value.length || value.length === 2) && numberRegex.test(next4);
-    };
+    }
 
-    State128C.prototype.move = function move () {
+    move() {
         this.encoding.addPattern(this.MOVE);
-    };
-
-    State128C.prototype.pushState = function pushState (encodingState) {
-        var this$1 = this;
+    }
 
-        var code;
+    pushState(encodingState) {
+        let code;
 
         while ((code = getSubstring(encodingState.value, encodingState.index, 2)) &&
             numberRegex.test(code) && code.length === 2) {
-            this$1.encoding.addPattern(parseInt(code, 10));
+            this.encoding.addPattern(parseInt(code, 10));
             encodingState.index += 2;
         }
-    };
+    }
 
-    State128C.prototype.getValue = function getValue (code) {
+    getValue(code) {
         return code;
-    };
-
-    return State128C;
-}(State128));
+    }
+};
 
-states128.FNC4 = (function (State128) {
-    function State128FNC4(encoding, states) {
-        State128.call(this, encoding);
+states128.FNC4 = class State128FNC4 extends State128 {
+    constructor(encoding, states) {
+        super(encoding);
         this._initSubStates(states);
     }
 
-    if ( State128 ) State128FNC4.__proto__ = State128;
-    State128FNC4.prototype = Object.create( State128 && State128.prototype );
-    State128FNC4.prototype.constructor = State128FNC4;
-
-    State128FNC4.prototype.initProperties = function initProperties () {
-        State128.prototype.initProperties.call(this);
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             key: "FNC4",
             dependentStates: ["A", "B"]
         });
-    };
+    }
 
-    State128FNC4.prototype.addStart = function addStart (encodingState) {
-        var code = encodingState.value.charCodeAt(0) - 128,
+    addStart(encodingState) {
+        let code = encodingState.value.charCodeAt(0) - 128,
             subState = this._getSubState(code);
 
         this.encoding[subState].addStart();
-    };
+    }
 
-    State128FNC4.prototype.is = function is (value, index) {
-        var code = value.charCodeAt(index);
+    is(value, index) {
+        let code = value.charCodeAt(index);
         return this.isCode(code);
-    };
+    }
 
-    State128FNC4.prototype.isCode = function isCode (code) {
+    isCode(code) {
         return 128 <= code && code < 256;
-    };
-
-    State128FNC4.prototype.pushState = function pushState (encodingState) {
-        var this$1 = this;
+    }
 
-        var subState = this._initSubState(encodingState),
+    pushState(encodingState) {
+        let subState = this._initSubState(encodingState),
             encoding = this.encoding,
             length = subState.value.length;
-        var code;
+        let code;
 
         encodingState.index += length;
 
         if (length < 3) {
             for (; subState.index < length; subState.index++) {
                 code = subState.value.charCodeAt(subState.index);
-                subState.state = this$1._getSubState(code);
+                subState.state = this._getSubState(code);
 
                 if (subState.previousState !== subState.state) {
                     subState.previousState = subState.state;
@@ -327,15 +275,15 @@ states128.FNC4 = (function (State128) {
 
         encodingState.fnc = true;
         encodingState.state = subState.state;
-    };
+    }
 
-    State128FNC4.prototype._pushStart = function _pushStart (subState) {
+    _pushStart(subState) {
         this.encoding.addPattern(this.encoding[subState.state].MOVE);
         this.encoding.addPattern(this.encoding[subState.state].MOVE);
-    };
+    }
 
-    State128FNC4.prototype._initSubState = function _initSubState (encodingState) {
-        var subState = {
+    _initSubState(encodingState) {
+        const subState = {
             value: this._getAll(encodingState.value, encodingState.index),
             index: 0
         };
@@ -346,57 +294,47 @@ states128.FNC4 = (function (State128) {
             encodingState.previousState;
 
         return subState;
-    };
-
-    State128FNC4.prototype._initSubStates = function _initSubStates (states) {
-        var this$1 = this;
+    }
 
+    _initSubStates(states) {
         this.subStates = [];
 
-        for (var i = 0; i < states.length; i++) {
-            if (inArray(states[i], this$1.dependentStates)) {
-                this$1.subStates.push(states[i]);
+        for (let i = 0; i < states.length; i++) {
+            if (inArray(states[i], this.dependentStates)) {
+                this.subStates.push(states[i]);
             }
         }
-    };
-
-    State128FNC4.prototype._getSubState = function _getSubState (code) {
-        var this$1 = this;
+    }
 
-        for (var i = 0; i < this.subStates.length; i++) {
-            if (this$1.encoding[this$1.subStates[i]].isCode(code)) {
-                return this$1.subStates[i];
+    _getSubState(code) {
+        for (let i = 0; i < this.subStates.length; i++) {
+            if (this.encoding[this.subStates[i]].isCode(code)) {
+                return this.subStates[i];
             }
         }
-    };
+    }
 
-    State128FNC4.prototype._getAll = function _getAll (value, index) {
-        var code;
-        var result = "";
-        var i = index;
+    _getAll(value, index) {
+        let code;
+        let result = "";
+        let i = index;
 
         while ((code = value.charCodeAt(i++)) && this.isCode(code)) {
             result += String.fromCharCode(code - 128);
         }
 
         return result;
-    };
-
-    return State128FNC4;
-}(State128));
+    }
+};
 
-states128.FNC1 = (function (State128) {
-    function States128FNC1(encoding, states) {
-        State128.call(this, encoding);
+states128.FNC1 = class States128FNC1 extends State128 {
+    constructor(encoding, states) {
+        super(encoding);
         this.states = states;
     }
 
-    if ( State128 ) States128FNC1.__proto__ = State128;
-    States128FNC1.prototype = Object.create( State128 && State128.prototype );
-    States128FNC1.prototype.constructor = States128FNC1;
-
-    States128FNC1.prototype.initProperties = function initProperties () {
-        State128.prototype.initProperties.call(this);
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             key: "FNC1",
@@ -468,21 +406,19 @@ states128.FNC1 = (function (State128) {
             },
             START: 102
         });
-    };
+    }
 
 
-    States128FNC1.prototype.addStart = function addStart () {
+    addStart() {
         this.encoding[this.startState].addStart();
-    };
+    }
 
-    States128FNC1.prototype.is = function is () {
+    is() {
         return inArray(this.key, this.states);
-    };
-
-    States128FNC1.prototype.pushState = function pushState (encodingState) {
-        var this$1 = this;
+    }
 
-        var encoding = this.encoding,
+    pushState(encodingState) {
+        let encoding = this.encoding,
             value = encodingState.value.replace(/\s/g, ""),
             regexSeparators = new RegExp("[" + this.startAI + this.endAI + "]", "g"),
             index = encodingState.index,
@@ -495,18 +431,18 @@ states128.FNC1 = (function (State128) {
 
         encoding.addPattern(this.START);
 
-        var trueCondition = true;
+        const trueCondition = true;
 
         while (trueCondition) {
             subState.index = 0;
 
-            separatorLength = value.charAt(index) === this$1.startAI ? 2 : 0;
-            current = separatorLength > 0 ? this$1.getBySeparator(value, index) : this$1.getByLength(value, index);
+            separatorLength = value.charAt(index) === this.startAI ? 2 : 0;
+            current = separatorLength > 0 ? this.getBySeparator(value, index) : this.getByLength(value, index);
 
             if (current.ai.length) {
                 nextStart = index + separatorLength + current.id.length + current.ai.length;
             } else {
-                nextStart = value.indexOf(this$1.startAI, index + 1);
+                nextStart = value.indexOf(this.startAI, index + 1);
 
                 if (nextStart < 0) {
                     if (index + current.ai.max + current.id.length + separatorLength < value.length) {
@@ -518,8 +454,8 @@ states128.FNC1 = (function (State128) {
             }
 
             subState.value = value.substring(index, nextStart).replace(regexSeparators, "");
-            this$1.validate(current, subState.value);
-            encoding.pushData(subState, this$1.dependentStates);
+            this.validate(current, subState.value);
+            encoding.pushData(subState, this.dependentStates);
 
             if (nextStart >= value.length) {
                 break;
@@ -527,21 +463,21 @@ states128.FNC1 = (function (State128) {
 
             index = nextStart;
 
-            if (subState.state !== this$1.startState) {
-                encoding[this$1.startState].move(subState);
-                subState.state = this$1.startState;
+            if (subState.state !== this.startState) {
+                encoding[this.startState].move(subState);
+                subState.state = this.startState;
             }
 
             if (!current.ai.length) {
-                encoding.addPattern(this$1.START);
+                encoding.addPattern(this.START);
             }
         }
 
         encodingState.index = encodingState.value.length;
-    };
+    }
 
-    States128FNC1.prototype.validate = function validate (current, value) {
-        var code = value.substr(current.id.length),
+    validate(current, value) {
+        let code = value.substr(current.id.length),
             ai = current.ai;
 
         if (!ai.type && !numberRegex.test(code)) {
@@ -563,17 +499,15 @@ states128.FNC1 = (function (State128) {
         if (ai.max && ai.max < code.length) {
             throw new Error("Application identifier " + current.id + " must be at most " + ai.max + " characters long.");
         }
-    };
-
-    States128FNC1.prototype.getByLength = function getByLength (value, index) {
-        var this$1 = this;
+    }
 
-        var id;
-        var applicationIdentifier;
+    getByLength(value, index) {
+        let id;
+        let applicationIdentifier;
 
-        for (var i = 2; i <= 4; i++) {
+        for (let i = 2; i <= 4; i++) {
             id = getSubstring(value, index, i);
-            applicationIdentifier = this$1.getApplicationIdentifier(id) || this$1.getApplicationIdentifier(id.substring(0, id.length - 1));
+            applicationIdentifier = this.getApplicationIdentifier(id) || this.getApplicationIdentifier(id.substring(0, id.length - 1));
             if (applicationIdentifier) {
                 return {
                     id: id,
@@ -582,14 +516,14 @@ states128.FNC1 = (function (State128) {
             }
         }
         this.unsupportedAIError(id);
-    };
+    }
 
-    States128FNC1.prototype.unsupportedAIError = function unsupportedAIError (id) {
+    unsupportedAIError(id) {
         throw new Error("'" + id + "' is not a supported Application Identifier");
-    };
+    }
 
-    States128FNC1.prototype.getBySeparator = function getBySeparator (value, index) {
-        var start = value.indexOf(this.startAI, index),
+    getBySeparator(value, index) {
+        let start = value.indexOf(this.startAI, index),
             end = value.indexOf(this.endAI, start),
             id = value.substring(start + 1, end),
             ai = this.getApplicationIdentifier(id) || this.getApplicationIdentifier(id.substr(id.length - 1));
@@ -602,46 +536,40 @@ states128.FNC1 = (function (State128) {
             ai: ai,
             id: id
         };
-    };
+    }
 
-    States128FNC1.prototype.getApplicationIdentifier = function getApplicationIdentifier (id) {
-        var applicationIdentifier = this.applicationIdentifiers,
+    getApplicationIdentifier(id) {
+        let applicationIdentifier = this.applicationIdentifiers,
             multiKey = applicationIdentifier.multiKey;
 
         if (applicationIdentifier[id]) {
             return applicationIdentifier[id];
         }
 
-        for (var i = 0; i < multiKey.length; i++) {
+        for (let i = 0; i < multiKey.length; i++) {
             if (multiKey[i].ids && inArray(id, multiKey[i].ids)) {
                 return multiKey[i].type;
             } else if (multiKey[i].ranges) {
-                var ranges = multiKey[i].ranges;
+                let ranges = multiKey[i].ranges;
 
-                for (var j = 0; j < ranges.length; j++) {
+                for (let j = 0; j < ranges.length; j++) {
                     if (ranges[j][0] <= id && id <= ranges[j][1]) {
                         return multiKey[i].type;
                     }
                 }
             }
         }
-    };
-
-    return States128FNC1;
-}(State128));
+    }
+};
 
-export var Code128Base = (function (Encoding) {
-    function Code128Base(options) {
-        Encoding.call(this, options);
+export class Code128Base extends Encoding {
+    constructor(options) {
+        super(options);
         this._initStates();
     }
 
-    if ( Encoding ) Code128Base.__proto__ = Encoding;
-    Code128Base.prototype = Object.create( Encoding && Encoding.prototype );
-    Code128Base.prototype.constructor = Code128Base;
-
-    Code128Base.prototype.initProperties = function initProperties () {
-        Encoding.prototype.initProperties.call(this);
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             characterMap: [
@@ -659,17 +587,15 @@ export var Code128Base = (function (Encoding) {
             ],
             STOP: 106
         });
-    };
-
-    Code128Base.prototype._initStates = function _initStates () {
-        var this$1 = this;
+    }
 
-        for (var i = 0; i < this.states.length; i++) {
-            this$1[this$1.states[i]] = new states128[this$1.states[i]](this$1, this$1.states);
+    _initStates() {
+        for (let i = 0; i < this.states.length; i++) {
+            this[this.states[i]] = new states128[this.states[i]](this, this.states);
         }
-    };
+    }
 
-    Code128Base.prototype.initValue = function initValue (value, width, height) {
+    initValue(value, width, height) {
         this.pattern = [];
         this.value = value;
         this.width = width;
@@ -678,10 +604,10 @@ export var Code128Base = (function (Encoding) {
         this.totalUnits = 0;
         this.index = 0;
         this.position = 1;
-    };
+    }
 
-    Code128Base.prototype.addData = function addData () {
-        var encodingState = {
+    addData() {
+        let encodingState = {
             value: this.value,
             index: 0,
             state: ""
@@ -701,15 +627,13 @@ export var Code128Base = (function (Encoding) {
         this.addCheckSum();
         this.addStop();
         this.setBaseUnit();
-    };
-
-    Code128Base.prototype.pushData = function pushData (encodingState, states) {
-        var this$1 = this;
+    }
 
-        var trueCondition = true;
+    pushData(encodingState, states) {
+        const trueCondition = true;
 
         while (trueCondition) {
-            this$1[encodingState.state].pushState(encodingState);
+            this[encodingState.state].pushState(encodingState);
 
             if (encodingState.index >= encodingState.value.length) {
                 break;
@@ -717,168 +641,112 @@ export var Code128Base = (function (Encoding) {
 
             if (!encodingState.shifted) {
                 encodingState.previousState = encodingState.state;
-                encodingState.state = this$1.getNextState(encodingState, states);
-                this$1[encodingState.state].move(encodingState);
+                encodingState.state = this.getNextState(encodingState, states);
+                this[encodingState.state].move(encodingState);
             } else {
-                var temp = encodingState.state;
+                let temp = encodingState.state;
                 encodingState.state = encodingState.previousState;
                 encodingState.previousState = temp;
                 encodingState.shifted = false;
             }
         }
-    };
+    }
 
-    Code128Base.prototype.addStart = function addStart (encodingState) {
+    addStart(encodingState) {
         this[encodingState.state].addStart(encodingState);
         this.position = 1;
-    };
+    }
 
-    Code128Base.prototype.addCheckSum = function addCheckSum () {
+    addCheckSum() {
         this.checksum = this.checkSum % 103;
         this.addPattern(this.checksum);
-    };
+    }
 
-    Code128Base.prototype.addStop = function addStop () {
+    addStop() {
         this.addPattern(this.STOP);
-    };
+    }
 
-    Code128Base.prototype.setBaseUnit = function setBaseUnit () {
+    setBaseUnit() {
         this.baseUnit = this.width / (this.totalUnits + this.quietZoneLength);
-    };
-
-    Code128Base.prototype.addPattern = function addPattern (code) {
-        var this$1 = this;
+    }
 
-        var pattern = this.characterMap[code].toString();
-        var value;
+    addPattern(code) {
+        const pattern = this.characterMap[code].toString();
+        let value;
 
-        for (var i = 0; i < pattern.length; i++) {
+        for (let i = 0; i < pattern.length; i++) {
             value = parseInt(pattern.charAt(i), 10);
-            this$1.pattern.push(value);
-            this$1.totalUnits += value;
+            this.pattern.push(value);
+            this.totalUnits += value;
         }
         this.checkSum += code * this.position++;
-    };
-
-    Code128Base.prototype.getNextState = function getNextState (encodingState, states) {
-        var this$1 = this;
+    }
 
-        for (var i = 0; i < states.length; i++) {
-            if (this$1[states[i]].is(encodingState.value, encodingState.index)) {
+    getNextState(encodingState, states) {
+        for (let i = 0; i < states.length; i++) {
+            if (this[states[i]].is(encodingState.value, encodingState.index)) {
                 return states[i];
             }
         }
 
         this.invalidCharacterError(encodingState.value.charAt(encodingState.index));
-    };
-
-    return Code128Base;
-}(Encoding));
-
-export var Code128a = (function (Code128Base) {
-    function Code128a () {
-        Code128Base.apply(this, arguments);
     }
+}
 
-    if ( Code128Base ) Code128a.__proto__ = Code128Base;
-    Code128a.prototype = Object.create( Code128Base && Code128Base.prototype );
-    Code128a.prototype.constructor = Code128a;
-
-    Code128a.prototype.initProperties = function initProperties () {
-        Code128Base.prototype.initProperties.call(this);
+export class Code128a extends Code128Base {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             name: "Code 128 A",
             states: ["A"]
         });
-    };
-
-    return Code128a;
-}(Code128Base));
-
-export var Code128b = (function (Code128Base) {
-    function Code128b () {
-        Code128Base.apply(this, arguments);
     }
+}
 
-    if ( Code128Base ) Code128b.__proto__ = Code128Base;
-    Code128b.prototype = Object.create( Code128Base && Code128Base.prototype );
-    Code128b.prototype.constructor = Code128b;
-
-    Code128b.prototype.initProperties = function initProperties () {
-        Code128Base.prototype.initProperties.call(this);
+export class Code128b extends Code128Base {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             name: "Code 128 B",
             states: ["B"]
         });
-    };
-
-    return Code128b;
-}(Code128Base));
-
-export var Code128c = (function (Code128Base) {
-    function Code128c () {
-        Code128Base.apply(this, arguments);
     }
+}
 
-    if ( Code128Base ) Code128c.__proto__ = Code128Base;
-    Code128c.prototype = Object.create( Code128Base && Code128Base.prototype );
-    Code128c.prototype.constructor = Code128c;
-
-    Code128c.prototype.initProperties = function initProperties () {
-        Code128Base.prototype.initProperties.call(this);
+export class Code128c extends Code128Base {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             name: "Code 128 C",
             states: ["C"]
         });
-    };
-
-    return Code128c;
-}(Code128Base));
-
-export var Code128 = (function (Code128Base) {
-    function Code128 () {
-        Code128Base.apply(this, arguments);
     }
+}
 
-    if ( Code128Base ) Code128.__proto__ = Code128Base;
-    Code128.prototype = Object.create( Code128Base && Code128Base.prototype );
-    Code128.prototype.constructor = Code128;
-
-    Code128.prototype.initProperties = function initProperties () {
-        Code128Base.prototype.initProperties.call(this);
+export class Code128 extends Code128Base {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             name: "Code 128",
             states: ["C", "B", "A", "FNC4"]
         });
-    };
-
-    return Code128;
-}(Code128Base));
-
-export var CodeGS1128 = (function (Code128Base) {
-    function CodeGS1128 () {
-        Code128Base.apply(this, arguments);
     }
+}
 
-    if ( Code128Base ) CodeGS1128.__proto__ = Code128Base;
-    CodeGS1128.prototype = Object.create( Code128Base && Code128Base.prototype );
-    CodeGS1128.prototype.constructor = CodeGS1128;
-
-    CodeGS1128.prototype.initProperties = function initProperties () {
-        Code128Base.prototype.initProperties.call(this);
+export class CodeGS1128 extends Code128Base {
+    initProperties() {
+        super.initProperties();
 
         extend(this, {
             name: "Code GS1-128",
             states: ["FNC1", "C", "B"]
         });
-    };
-
-    return CodeGS1128;
-}(Code128Base));
+    }
+}
 
 function getSubstring(value, index, count) {
     return value.substring(index, index + count);