yh-hiprint 2.3.6 → 2.4.1

package/libs/jsbarcode/barcodes/CODE128/CODE128.js

@@ -1,167 +1,127 @@
-'use strict';
-
-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; }; }();
-
-var _Barcode2 = require('../Barcode.js');
-
-var _Barcode3 = _interopRequireDefault(_Barcode2);
-
-var _constants = require('./constants');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(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; }
+import Barcode from "../Barcode.js";
+import { SHIFT, SET_A, SET_B, MODULO, STOP, FNC1, SET_BY_CODE, SWAP, BARS } from './constants';
 
 // This is the master class,
 // it does require the start code to be included in the string
-var CODE128 = function (_Barcode) {
-	_inherits(CODE128, _Barcode);
-
-	function CODE128(data, options) {
-		_classCallCheck(this, CODE128);
+class CODE128 extends Barcode {
+	constructor(data, options) {
+		super(data.substring(1), options);
 
 		// Get array of ascii codes from data
-		var _this = _possibleConstructorReturn(this, (CODE128.__proto__ || Object.getPrototypeOf(CODE128)).call(this, data.substring(1), options));
-
-		_this.bytes = data.split('').map(function (char) {
-			return char.charCodeAt(0);
-		});
-		return _this;
+		this.bytes = data.split('')
+			.map(char => char.charCodeAt(0));
 	}
 
-	_createClass(CODE128, [{
-		key: 'valid',
-		value: function valid() {
-			// ASCII value ranges 0-127, 200-211
-			return (/^[\x00-\x7F\xC8-\xD3]+$/.test(this.data)
-			);
-		}
-
-		// The public encoding function
+	valid() {
+		// ASCII value ranges 0-127, 200-211
+		return /^[\x00-\x7F\xC8-\xD3]+$/.test(this.data);
+	}
 
-	}, {
-		key: 'encode',
-		value: function encode() {
-			var bytes = this.bytes;
-			// Remove the start code from the bytes and set its index
-			var startIndex = bytes.shift() - 105;
-			// Get start set by index
-			var startSet = _constants.SET_BY_CODE[startIndex];
+	// The public encoding function
+	encode() {
+		const bytes = this.bytes;
+		// Remove the start code from the bytes and set its index
+		const startIndex = bytes.shift() - 105;
+		// Get start set by index
+		const startSet = SET_BY_CODE[startIndex];
 
-			if (startSet === undefined) {
-				throw new RangeError('The encoding does not start with a start character.');
-			}
+		if (startSet === undefined) {
+			throw new RangeError('The encoding does not start with a start character.');
+		}
 
-			if (this.shouldEncodeAsEan128() === true) {
-				bytes.unshift(_constants.FNC1);
-			}
+		if (this.shouldEncodeAsEan128() === true) {
+			bytes.unshift(FNC1);
+		}
 
-			// Start encode with the right type
-			var encodingResult = CODE128.next(bytes, 1, startSet);
+		// Start encode with the right type
+		const encodingResult = CODE128.next(bytes, 1, startSet);
 
-			return {
-				text: this.text === this.data ? this.text.replace(/[^\x20-\x7E]/g, '') : this.text,
-				data:
+		return {
+			text:
+				this.text === this.data
+					? this.text.replace(/[^\x20-\x7E]/g, '')
+					: this.text,
+			data:
 				// Add the start bits
 				CODE128.getBar(startIndex) +
 				// Add the encoded bits
 				encodingResult.result +
 				// Add the checksum
-				CODE128.getBar((encodingResult.checksum + startIndex) % _constants.MODULO) +
+				CODE128.getBar((encodingResult.checksum + startIndex) % MODULO) +
 				// Add the end bits
-				CODE128.getBar(_constants.STOP)
-			};
-		}
-
-		// GS1-128/EAN-128
+				CODE128.getBar(STOP)
+		};
+	}
 
-	}, {
-		key: 'shouldEncodeAsEan128',
-		value: function shouldEncodeAsEan128() {
-			var isEAN128 = this.options.ean128 || false;
-			if (typeof isEAN128 === 'string') {
-				isEAN128 = isEAN128.toLowerCase() === 'true';
-			}
-			return isEAN128;
+	// GS1-128/EAN-128
+	shouldEncodeAsEan128() {
+		let isEAN128 = this.options.ean128 || false;
+		if (typeof isEAN128 === 'string') {
+			isEAN128 = isEAN128.toLowerCase() === 'true';
 		}
+		return isEAN128;
+	}
 
-		// Get a bar symbol by index
+	// Get a bar symbol by index
+	static getBar(index) {
+		return BARS[index] ? BARS[index].toString() : '';
+	}
 
-	}], [{
-		key: 'getBar',
-		value: function getBar(index) {
-			return _constants.BARS[index] ? _constants.BARS[index].toString() : '';
+	// Correct an index by a set and shift it from the bytes array
+	static correctIndex(bytes, set) {
+		if (set === SET_A) {
+			const charCode = bytes.shift();
+			return charCode < 32 ? charCode + 64 : charCode - 32;
+		} else if (set === SET_B) {
+			return bytes.shift() - 32;
+		} else {
+			return (bytes.shift() - 48) * 10 + bytes.shift() - 48;
 		}
+	}
 
-		// Correct an index by a set and shift it from the bytes array
-
-	}, {
-		key: 'correctIndex',
-		value: function correctIndex(bytes, set) {
-			if (set === _constants.SET_A) {
-				var charCode = bytes.shift();
-				return charCode < 32 ? charCode + 64 : charCode - 32;
-			} else if (set === _constants.SET_B) {
-				return bytes.shift() - 32;
-			} else {
-				return (bytes.shift() - 48) * 10 + bytes.shift() - 48;
-			}
+	static next(bytes, pos, set) {
+		if (!bytes.length) {
+			return { result: '', checksum: 0 };
 		}
-	}, {
-		key: 'next',
-		value: function next(bytes, pos, set) {
-			if (!bytes.length) {
-				return { result: '', checksum: 0 };
-			}
 
-			var nextCode = void 0,
-			    index = void 0;
+		let nextCode, index;
 
-			// Special characters
-			if (bytes[0] >= 200) {
-				index = bytes.shift() - 105;
-				var nextSet = _constants.SWAP[index];
+		// Special characters
+		if (bytes[0] >= 200){
+			index = bytes.shift() - 105;
+			const nextSet = SWAP[index];
 
-				// Swap to other set
-				if (nextSet !== undefined) {
-					nextCode = CODE128.next(bytes, pos + 1, nextSet);
-				}
-				// Continue on current set but encode a special character
-				else {
-						// Shift
-						if ((set === _constants.SET_A || set === _constants.SET_B) && index === _constants.SHIFT) {
-							// Convert the next character so that is encoded correctly
-							bytes[0] = set === _constants.SET_A ? bytes[0] > 95 ? bytes[0] - 96 : bytes[0] : bytes[0] < 32 ? bytes[0] + 96 : bytes[0];
-						}
-						nextCode = CODE128.next(bytes, pos + 1, set);
-					}
+			// Swap to other set
+			if (nextSet !== undefined) {
+				nextCode = CODE128.next(bytes, pos + 1, nextSet);
 			}
-			// Continue encoding
+			// Continue on current set but encode a special character
 			else {
-					index = CODE128.correctIndex(bytes, set);
-					nextCode = CODE128.next(bytes, pos + 1, set);
+				// Shift
+				if ((set === SET_A || set === SET_B) && index === SHIFT) {
+					// Convert the next character so that is encoded correctly
+					bytes[0] = (set === SET_A)
+						? bytes[0] > 95 ? bytes[0] - 96 : bytes[0]
+						: bytes[0] < 32 ? bytes[0] + 96 : bytes[0];
 				}
-
-			// Get the correct binary encoding and calculate the weight
-			var enc = CODE128.getBar(index);
-			var weight = index * pos;
-
-			return {
-				result: enc + nextCode.result,
-				checksum: weight + nextCode.checksum
-			};
+				nextCode = CODE128.next(bytes, pos + 1, set);
+			}
+		}
+		// Continue encoding
+		else {
+			index = CODE128.correctIndex(bytes, set);
+			nextCode = CODE128.next(bytes, pos + 1, set);
 		}
-	}]);
 
-	return CODE128;
-}(_Barcode3.default);
+		// Get the correct binary encoding and calculate the weight
+		const enc = CODE128.getBar(index);
+		const weight = index * pos;
+
+		return {
+			result: enc + nextCode.result,
+			checksum: weight + nextCode.checksum
+		};
+	}
+}
 
-exports.default = CODE128;
+export default CODE128;

package/libs/jsbarcode/barcodes/CODE128/CODE128A.js

@@ -1,42 +1,14 @@
-'use strict';
+import CODE128 from './CODE128.js';
+import { A_START_CHAR, A_CHARS } from './constants';
 
-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; }; }();
-
-var _CODE2 = require('./CODE128.js');
-
-var _CODE3 = _interopRequireDefault(_CODE2);
-
-var _constants = require('./constants');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(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 CODE128A = function (_CODE) {
-	_inherits(CODE128A, _CODE);
-
-	function CODE128A(string, options) {
-		_classCallCheck(this, CODE128A);
-
-		return _possibleConstructorReturn(this, (CODE128A.__proto__ || Object.getPrototypeOf(CODE128A)).call(this, _constants.A_START_CHAR + string, options));
+class CODE128A extends CODE128 {
+	constructor(string, options) {
+		super(A_START_CHAR + string, options);
 	}
 
-	_createClass(CODE128A, [{
-		key: 'valid',
-		value: function valid() {
-			return new RegExp('^' + _constants.A_CHARS + '+$').test(this.data);
-		}
-	}]);
-
-	return CODE128A;
-}(_CODE3.default);
+	valid() {
+		return (new RegExp(`^${A_CHARS}+$`)).test(this.data);
+	}
+}
 
-exports.default = CODE128A;
+export default CODE128A;

package/libs/jsbarcode/barcodes/CODE128/CODE128B.js

@@ -1,42 +1,14 @@
-'use strict';
+import CODE128 from './CODE128.js';
+import { B_START_CHAR, B_CHARS } from './constants';
 
-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; }; }();
-
-var _CODE2 = require('./CODE128.js');
-
-var _CODE3 = _interopRequireDefault(_CODE2);
-
-var _constants = require('./constants');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(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 CODE128B = function (_CODE) {
-	_inherits(CODE128B, _CODE);
-
-	function CODE128B(string, options) {
-		_classCallCheck(this, CODE128B);
-
-		return _possibleConstructorReturn(this, (CODE128B.__proto__ || Object.getPrototypeOf(CODE128B)).call(this, _constants.B_START_CHAR + string, options));
+class CODE128B extends CODE128 {
+	constructor(string, options) {
+		super(B_START_CHAR + string, options);
 	}
 
-	_createClass(CODE128B, [{
-		key: 'valid',
-		value: function valid() {
-			return new RegExp('^' + _constants.B_CHARS + '+$').test(this.data);
-		}
-	}]);
-
-	return CODE128B;
-}(_CODE3.default);
+	valid() {
+		return (new RegExp(`^${B_CHARS}+$`)).test(this.data);
+	}
+}
 
-exports.default = CODE128B;
+export default CODE128B;

package/libs/jsbarcode/barcodes/CODE128/CODE128C.js

@@ -1,42 +1,14 @@
-'use strict';
+import CODE128 from './CODE128.js';
+import { C_START_CHAR, C_CHARS } from './constants';
 
-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; }; }();
-
-var _CODE2 = require('./CODE128.js');
-
-var _CODE3 = _interopRequireDefault(_CODE2);
-
-var _constants = require('./constants');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(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 CODE128C = function (_CODE) {
-	_inherits(CODE128C, _CODE);
-
-	function CODE128C(string, options) {
-		_classCallCheck(this, CODE128C);
-
-		return _possibleConstructorReturn(this, (CODE128C.__proto__ || Object.getPrototypeOf(CODE128C)).call(this, _constants.C_START_CHAR + string, options));
+class CODE128C extends CODE128 {
+	constructor(string, options) {
+		super(C_START_CHAR + string, options);
 	}
 
-	_createClass(CODE128C, [{
-		key: 'valid',
-		value: function valid() {
-			return new RegExp('^' + _constants.C_CHARS + '+$').test(this.data);
-		}
-	}]);
-
-	return CODE128C;
-}(_CODE3.default);
+	valid() {
+		return (new RegExp(`^${C_CHARS}+$`)).test(this.data);
+	}
+}
 
-exports.default = CODE128C;
+export default CODE128C;

package/libs/jsbarcode/barcodes/CODE128/CODE128_AUTO.js

@@ -1,41 +1,15 @@
-'use strict';
+import CODE128 from './CODE128';
+import autoSelectModes from './auto';
 
-Object.defineProperty(exports, "__esModule", {
-	value: true
-});
-
-var _CODE2 = require('./CODE128');
-
-var _CODE3 = _interopRequireDefault(_CODE2);
-
-var _auto = require('./auto');
-
-var _auto2 = _interopRequireDefault(_auto);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(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 CODE128AUTO = function (_CODE) {
-	_inherits(CODE128AUTO, _CODE);
-
-	function CODE128AUTO(data, options) {
-		_classCallCheck(this, CODE128AUTO);
-
-		// ASCII value ranges 0-127, 200-211
+class CODE128AUTO extends CODE128{
+	constructor(data, options){
+    // ASCII value ranges 0-127, 200-211
 		if (/^[\x00-\x7F\xC8-\xD3]+$/.test(data)) {
-			var _this = _possibleConstructorReturn(this, (CODE128AUTO.__proto__ || Object.getPrototypeOf(CODE128AUTO)).call(this, (0, _auto2.default)(data), options));
-		} else {
-			var _this = _possibleConstructorReturn(this, (CODE128AUTO.__proto__ || Object.getPrototypeOf(CODE128AUTO)).call(this, data, options));
+			super(autoSelectModes(data), options);
+		} else{
+			super(data, options);
 		}
-		return _possibleConstructorReturn(_this);
 	}
+}
 
-	return CODE128AUTO;
-}(_CODE3.default);
-
-exports.default = CODE128AUTO;
+export default CODE128AUTO;

package/libs/jsbarcode/barcodes/CODE128/auto.js

@@ -1,44 +1,40 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-	value: true
-});
-
-var _constants = require('./constants');
+import { A_START_CHAR, B_START_CHAR, C_START_CHAR, A_CHARS, B_CHARS, C_CHARS } from './constants';
 
 // Match Set functions
-var matchSetALength = function matchSetALength(string) {
-	return string.match(new RegExp('^' + _constants.A_CHARS + '*'))[0].length;
-};
-var matchSetBLength = function matchSetBLength(string) {
-	return string.match(new RegExp('^' + _constants.B_CHARS + '*'))[0].length;
-};
-var matchSetC = function matchSetC(string) {
-	return string.match(new RegExp('^' + _constants.C_CHARS + '*'))[0];
-};
+const matchSetALength = (string) => string.match(new RegExp(`^${A_CHARS}*`))[0].length;
+const matchSetBLength = (string) => string.match(new RegExp(`^${B_CHARS}*`))[0].length;
+const matchSetC = (string) => string.match(new RegExp(`^${C_CHARS}*`))[0];
 
 // CODE128A or CODE128B
-function autoSelectFromAB(string, isA) {
-	var ranges = isA ? _constants.A_CHARS : _constants.B_CHARS;
-	var untilC = string.match(new RegExp('^(' + ranges + '+?)(([0-9]{2}){2,})([^0-9]|$)'));
+function autoSelectFromAB(string, isA){
+	const ranges = isA ? A_CHARS : B_CHARS;
+	const untilC = string.match(new RegExp(`^(${ranges}+?)(([0-9]{2}){2,})([^0-9]|$)`));
 
 	if (untilC) {
-		return untilC[1] + String.fromCharCode(204) + autoSelectFromC(string.substring(untilC[1].length));
+		return (
+			untilC[1] +
+			String.fromCharCode(204) +
+			autoSelectFromC(string.substring(untilC[1].length))
+		);
 	}
 
-	var chars = string.match(new RegExp('^' + ranges + '+'))[0];
+	const chars = string.match(new RegExp(`^${ranges}+`))[0];
 
 	if (chars.length === string.length) {
 		return string;
 	}
 
-	return chars + String.fromCharCode(isA ? 205 : 206) + autoSelectFromAB(string.substring(chars.length), !isA);
+	return (
+		chars +
+		String.fromCharCode(isA ? 205 : 206) +
+		autoSelectFromAB(string.substring(chars.length), !isA)
+	);
 }
 
 // CODE128C
 function autoSelectFromC(string) {
-	var cMatch = matchSetC(string);
-	var length = cMatch.length;
+	const cMatch = matchSetC(string);
+	const length = cMatch.length;
 
 	if (length === string.length) {
 		return string;
@@ -47,27 +43,26 @@ function autoSelectFromC(string) {
 	string = string.substring(length);
 
 	// Select A/B depending on the longest match
-	var isA = matchSetALength(string) >= matchSetBLength(string);
+	const isA = matchSetALength(string) >= matchSetBLength(string);
 	return cMatch + String.fromCharCode(isA ? 206 : 205) + autoSelectFromAB(string, isA);
 }
 
 // Detect Code Set (A, B or C) and format the string
-
-exports.default = function (string) {
-	var newString = void 0;
-	var cLength = matchSetC(string).length;
+export default (string) => {
+	let newString;
+	const cLength = matchSetC(string).length;
 
 	// Select 128C if the string start with enough digits
 	if (cLength >= 2) {
-		newString = _constants.C_START_CHAR + autoSelectFromC(string);
+		newString = C_START_CHAR + autoSelectFromC(string);
 	} else {
 		// Select A/B depending on the longest match
-		var isA = matchSetALength(string) > matchSetBLength(string);
-		newString = (isA ? _constants.A_START_CHAR : _constants.B_START_CHAR) + autoSelectFromAB(string, isA);
+		const isA = matchSetALength(string) > matchSetBLength(string);
+		newString = (isA ? A_START_CHAR : B_START_CHAR) + autoSelectFromAB(string, isA);
 	}
 
-	return newString.replace(/[\xCD\xCE]([^])[\xCD\xCE]/, // Any sequence between 205 and 206 characters
-	function (match, char) {
-		return String.fromCharCode(203) + char;
-	});
-};
+	return newString.replace(
+		/[\xCD\xCE]([^])[\xCD\xCE]/, // Any sequence between 205 and 206 characters
+		(match, char) => String.fromCharCode(203) + char
+	);
+};