@mineminemine/esc-pos-encoder-ionic - npm Package Compare versions

Comparing version

2.0.3

3.0.0

+1371

dist/esc-pos-encoder.cjs

		'use strict';

		var linewrap = require('linewrap');
		var canvas = require('canvas');
		var Dither = require('canvas-dither');
		var Flatten = require('canvas-flatten');
		var CodepageEncoder = require('codepage-encoder');

		const codepageMappings = {
		epson: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'cp851': 0x0b,
		'cp853': 0x0c,
		'cp857': 0x0d,
		'cp737': 0x0e,
		'iso88597': 0x0f,
		'windows1252': 0x10,
		'cp866': 0x11,
		'cp852': 0x12,
		'cp858': 0x13,
		'cp720': 0x20,
		'cp775': 0x21,
		'cp855': 0x22,
		'cp861': 0x23,
		'cp862': 0x24,
		'cp864': 0x25,
		'cp869': 0x26,
		'iso88592': 0x27,
		'iso885915': 0x28,
		'cp1098': 0x29,
		'cp1118': 0x2a,
		'cp1119': 0x2b,
		'cp1125': 0x2c,
		'windows1250': 0x2d,
		'windows1251': 0x2e,
		'windows1253': 0x2f,
		'windows1254': 0x30,
		'windows1255': 0x31,
		'windows1256': 0x32,
		'windows1257': 0x33,
		'windows1258': 0x34,
		'rk1048': 0x35,
		},

		zjiang: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'windows1252': 0x10,
		'cp866': 0x11,
		'cp852': 0x12,
		'cp858': 0x13,
		'windows1255': 0x20,
		'cp861': 0x38,
		'cp855': 0x3c,
		'cp857': 0x3d,
		'cp862': 0x3e,
		'cp864': 0x3f,
		'cp737': 0x40,
		'cp851': 0x41,
		'cp869': 0x42,
		'cp1119': 0x44,
		'cp1118': 0x45,
		'windows1250': 0x48,
		'windows1251': 0x49,
		'cp3840': 0x4a,
		'cp3843': 0x4c,
		'cp3844': 0x4d,
		'cp3845': 0x4e,
		'cp3846': 0x4f,
		'cp3847': 0x50,
		'cp3848': 0x51,
		'cp2001': 0x53,
		'cp3001': 0x54,
		'cp3002': 0x55,
		'cp3011': 0x56,
		'cp3012': 0x57,
		'cp3021': 0x58,
		'cp3041': 0x59,
		'windows1253': 0x5a,
		'windows1254': 0x5b,
		'windows1256': 0x5c,
		'cp720': 0x5d,
		'windows1258': 0x5e,
		'cp775': 0x5f,
		},

		bixolon: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'cp851': 0x0b,
		'cp858': 0x13,
		},

		star: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'windows1252': 0x10,
		'cp866': 0x11,
		'cp852': 0x12,
		'cp858': 0x13,
		},

		citizen: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'cp852': 0x12,
		'cp866': 0x11,
		'cp857': 0x08,
		'windows1252': 0x10,
		'cp858': 0x13,
		'cp864': 0x28,
		},

		legacy: {
		'cp437': 0x00,
		'cp737': 0x40,
		'cp850': 0x02,
		'cp775': 0x5f,
		'cp852': 0x12,
		'cp855': 0x3c,
		'cp857': 0x3d,
		'cp858': 0x13,
		'cp860': 0x03,
		'cp861': 0x38,
		'cp862': 0x3e,
		'cp863': 0x04,
		'cp864': 0x1c,
		'cp865': 0x05,
		'cp866': 0x11,
		'cp869': 0x42,
		'cp936': 0xff,
		'cp949': 0xfd,
		'cp950': 0xfe,
		'cp1252': 0x10,
		'iso88596': 0x16,
		'shiftjis': 0xfc,
		'windows874': 0x1e,
		'windows1250': 0x48,
		'windows1251': 0x49,
		'windows1252': 0x47,
		'windows1253': 0x5a,
		'windows1254': 0x5b,
		'windows1255': 0x20,
		'windows1256': 0x5c,
		'windows1257': 0x19,
		'windows1258': 0x5e,
		},
		};


		/**
		* Create a byte stream based on commands for ESC/POS printers
		*/
		class EscPosEncoder {
		/**
		* Create a new object
		*
		* @param {object} options Object containing configuration options
		*/
		constructor(options) {
		this._reset(options);
		}

		/**
		* Reset the state of the object
		*
		* @param {object} options Object containing configuration options
		*/
		_reset(options) {
		this._options = Object.assign({
		width: null,
		embedded: false,
		wordWrap: true,
		imageMode: 'column',
		codepageMapping: 'epson',
		codepageCandidates: [
		'cp437', 'cp858', 'cp860', 'cp861', 'cp863', 'cp865',
		'cp852', 'cp857', 'cp855', 'cp866', 'cp869',
		],
		}, options);

		this._embedded = this._options.width && this._options.embedded;

		this._buffer = [];
		this._queued = [];
		this._cursor = 0;
		this._codepage = 'ascii';

		this._state = {
		'codepage': 0,
		'align': 'left',
		'bold': false,
		'italic': false,
		'underline': false,
		'invert': false,
		'width': 1,
		'height': 1,
		};
		}

		/**
		* Encode a string with the current code page
		*
		* @param {string} value String to encode
		* @return {object} Encoded string as a ArrayBuffer
		*
		*/
		_encode(value) {
		if (this._codepage != 'auto') {
		return CodepageEncoder.encode(value, this._codepage);
		}

		let codepages;

		if (typeof this._options.codepageMapping == 'string') {
		codepages = codepageMappings[this._options.codepageMapping];
		} else {
		codepages = this._options.codepageMapping;
		}

		const fragments = CodepageEncoder.autoEncode(value, this._options.codepageCandidates);

		let length = 0;
		for (let f = 0; f < fragments.length; f++) {
		length += 3 + fragments[f].bytes.byteLength;
		}

		const buffer = new Uint8Array(length);
		let i = 0;

		for (let f = 0; f < fragments.length; f++) {
		buffer.set([0x1b, 0x74, codepages[fragments[f].codepage]], i);
		buffer.set(fragments[f].bytes, i + 3);
		i += 3 + fragments[f].bytes.byteLength;

		this._state.codepage = codepages[fragments[f].codepage];
		}

		return buffer;
		}

		/**
		* Add commands to the queue
		*
		* @param {array} value Add array of numbers, arrays, buffers or Uint8Arrays to add to the buffer
		*
		*/
		_queue(value) {
		value.forEach((item) => this._queued.push(item));
		}

		/**
		* Flush current queue to the buffer
		*
		*/
		_flush() {
		if (this._embedded) {
		let indent = this._options.width - this._cursor;

		if (this._state.align == 'left') {
		this._queued.push((new Array(indent)).fill(0x20));
		}

		if (this._state.align == 'center') {
		const remainder = indent % 2;
		indent = indent >> 1;

		if (indent > 0) {
		this._queued.push((new Array(indent)).fill(0x20));
		}

		if (indent + remainder > 0) {
		this._queued.unshift((new Array(indent + remainder)).fill(0x20));
		}
		}

		if (this._state.align == 'right') {
		this._queued.unshift((new Array(indent)).fill(0x20));
		}
		}

		this._buffer = this._buffer.concat(this._queued);

		this._queued = [];
		this._cursor = 0;
		}

		/**
		* Wrap the text while respecting the position of the cursor
		*
		* @param {string} value String to wrap after the width of the paper has been reached
		* @param {number} position Position on which to force a wrap
		* @return {array} Array with each line
		*/
		_wrap(value, position) {
		if (position \|\| (this._options.wordWrap && this._options.width)) {
		const indent = '-'.repeat(this._cursor);
		const w = linewrap(position \|\| this._options.width, {lineBreak: '\n', whitespace: 'all'});
		const result = w(indent + value).substring(this._cursor).split('\n');

		return result;
		}

		return [value];
		}

		/**
		* Restore styles and codepages after drawing boxes or lines
		*/
		_restoreState() {
		this.bold(this._state.bold);
		this.italic(this._state.italic);
		this.underline(this._state.underline);
		this.invert(this._state.invert);

		this._queue([
		0x1b, 0x74, this._state.codepage,
		]);
		}

		/**
		* Get code page identifier for the specified code page and mapping
		*
		* @param {string} codepage Required code page
		* @return {number} Identifier for the current printer according to the specified mapping
		*/
		_getCodepageIdentifier(codepage) {
		let codepages;

		if (typeof this._options.codepageMapping == 'string') {
		codepages = codepageMappings[this._options.codepageMapping];
		} else {
		codepages = this._options.codepageMapping;
		}

		return codepages[codepage];
		}


		/**
		* Initialize the printer
		*
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		initialize() {
		this._queue([
		0x1b, 0x40,
		]);

		this._flush();

		return this;
		}

		/**
		* Change the code page
		*
		* @param {string} codepage The codepage that we set the printer to
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		codepage(codepage) {
		if (codepage === 'auto') {
		this._codepage = codepage;
		return this;
		}

		if (!CodepageEncoder.supports(codepage)) {
		throw new Error('Unknown codepage');
		}

		let codepages;

		if (typeof this._options.codepageMapping == 'string') {
		codepages = codepageMappings[this._options.codepageMapping];
		} else {
		codepages = this._options.codepageMapping;
		}

		if (typeof codepages[codepage] !== 'undefined') {
		this._codepage = codepage;
		this._state.codepage = codepages[codepage];

		this._queue([
		0x1b, 0x74, codepages[codepage],
		]);
		} else {
		throw new Error('Codepage not supported by printer');
		}

		return this;
		}

		/**
		* Print text
		*
		* @param {string} value Text that needs to be printed
		* @param {number} wrap Wrap text after this many positions
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		text(value, wrap) {
		const lines = this._wrap(value, wrap);

		for (let l = 0; l < lines.length; l++) {
		const bytes = this._encode(lines[l]);

		this._queue([
		bytes,
		]);

		this._cursor += (lines[l].length * this._state.width);

		if (this._options.width && !this._embedded) {
		this._cursor = this._cursor % this._options.width;
		}

		if (l < lines.length - 1) {
		this.newline();
		}
		}

		return this;
		}

		/**
		* Print a newline
		*
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		newline() {
		this._flush();

		this._queue([
		0x0a, 0x0d,
		]);

		if (this._embedded) {
		this._restoreState();
		}

		return this;
		}

		/**
		* Print text, followed by a newline
		*
		* @param {string} value Text that needs to be printed
		* @param {number} wrap Wrap text after this many positions
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		line(value, wrap) {
		this.text(value, wrap);
		this.newline();

		return this;
		}

		/**
		* Underline text
		*
		* @param {boolean\|number} value true to turn on underline, false to turn off, or 2 for double underline
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		underline(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.underline;
		}

		this._state.underline = value;

		this._queue([
		0x1b, 0x2d, Number(value),
		]);

		return this;
		}

		/**
		* Italic text
		*
		* @param {boolean} value true to turn on italic, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		italic(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.italic;
		}

		this._state.italic = value;

		this._queue([
		0x1b, 0x34, Number(value),
		]);

		return this;
		}

		/**
		* Bold text
		*
		* @param {boolean} value true to turn on bold, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		bold(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.bold;
		}

		this._state.bold = value;

		this._queue([
		0x1b, 0x45, Number(value),
		]);

		return this;
		}

		/**
		* Change width of text
		*
		* @param {number} width The width of the text, 1 - 8
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		width(width) {
		if (typeof width === 'undefined') {
		width = 1;
		}

		if (typeof width !== 'number') {
		throw new Error('Width must be a number');
		}

		if (width < 1 \|\| width > 8) {
		throw new Error('Width must be between 1 and 8');
		}

		this._state.width = width;

		this._queue([
		0x1d, 0x21, (this._state.height - 1) \| (this._state.width - 1) << 4,
		]);

		return this;
		}

		/**
		* Change height of text
		*
		* @param {number} height The height of the text, 1 - 8
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		height(height) {
		if (typeof height === 'undefined') {
		height = 1;
		}

		if (typeof height !== 'number') {
		throw new Error('Height must be a number');
		}

		if (height < 1 \|\| height > 8) {
		throw new Error('Height must be between 1 and 8');
		}

		this._state.height = height;

		this._queue([
		0x1d, 0x21, (this._state.height - 1) \| (this._state.width - 1) << 4,
		]);

		return this;
		}

		/**
		* Invert text
		*
		* @param {boolean} value true to turn on white text on black, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		invert(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.invert;
		}

		this._state.invert = value;

		this._queue([
		0x1d, 0x42, Number(value),
		]);

		return this;
		}

		/**
		* Change text size
		*
		* @param {string} value small or normal
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		size(value) {
		if (value === 'small') {
		value = 0x01;
		} else {
		value = 0x00;
		}

		this._queue([
		0x1b, 0x4d, value,
		]);

		return this;
		}

		/**
		* Change text alignment
		*
		* @param {string} value left, center or right
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		align(value) {
		const alignments = {
		'left': 0x00,
		'center': 0x01,
		'right': 0x02,
		};

		if (value in alignments) {
		this._state.align = value;

		if (!this._embedded) {
		this._queue([
		0x1b, 0x61, alignments[value],
		]);
		}
		} else {
		throw new Error('Unknown alignment');
		}

		return this;
		}

		/**
		* Insert a table
		*
		* @param {array} columns The column definitions
		* @param {array} data Array containing rows. Each row is an array containing cells.
		* Each cell can be a string value, or a callback function.
		* The first parameter of the callback is the encoder object on
		* which the function can call its methods.
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		table(columns, data) {
		if (this._cursor != 0) {
		this.newline();
		}

		for (let r = 0; r < data.length; r++) {
		const lines = [];
		let maxLines = 0;

		for (let c = 0; c < columns.length; c++) {
		const cell = [];

		if (typeof data[r][c] === 'string') {
		const w = linewrap(columns[c].width, {lineBreak: '\n'});
		const fragments = w(data[r][c]).split('\n');

		for (let f = 0; f < fragments.length; f++) {
		if (columns[c].align == 'right') {
		cell[f] = this._encode(fragments[f].padStart(columns[c].width));
		} else {
		cell[f] = this._encode(fragments[f].padEnd(columns[c].width));
		}
		}
		}

		if (typeof data[r][c] === 'function') {
		const columnEncoder = new EscPosEncoder(Object.assign({}, this._options, {
		width: columns[c].width,
		embedded: true,
		}));

		columnEncoder._codepage = this._codepage;
		columnEncoder.align(columns[c].align);
		data[r][c](columnEncoder);
		const encoded = columnEncoder.encode();

		let fragment = [];

		for (let e = 0; e < encoded.byteLength; e++) {
		if (e < encoded.byteLength - 1) {
		if (encoded[e] === 0x0a && encoded[e + 1] === 0x0d) {
		cell.push(fragment);
		fragment = [];

		e++;
		continue;
		}
		}

		fragment.push(encoded[e]);
		}

		if (fragment.length) {
		cell.push(fragment);
		}
		}

		maxLines = Math.max(maxLines, cell.length);
		lines[c] = cell;
		}

		for (let c = 0; c < columns.length; c++) {
		if (lines[c].length < maxLines) {
		for (let p = lines[c].length; p < maxLines; p++) {
		let verticalAlign = 'top';
		if (typeof columns[c].verticalAlign !== 'undefined') {
		verticalAlign = columns[c].verticalAlign;
		}

		if (verticalAlign == 'bottom') {
		lines[c].unshift((new Array(columns[c].width)).fill(0x20));
		} else {
		lines[c].push((new Array(columns[c].width)).fill(0x20));
		}
		}
		}
		}

		for (let l = 0; l < maxLines; l++) {
		for (let c = 0; c < columns.length; c++) {
		if (typeof columns[c].marginLeft !== 'undefined') {
		this.raw((new Array(columns[c].marginLeft)).fill(0x20));
		}

		this.raw(lines[c][l]);

		if (typeof columns[c].marginRight !== 'undefined') {
		this.raw((new Array(columns[c].marginRight)).fill(0x20));
		}
		}

		this.newline();
		}
		}

		return this;
		}

		/**
		* Insert a horizontal rule
		*
		* @param {object} options And object with the following properties:
		* - style: The style of the line, either single or double
		* - width: The width of the line, by default the width of the paper
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		rule(options) {
		options = Object.assign({
		style: 'single',
		width: this._options.width \|\| 10,
		}, options \|\| {});

		this._queue([
		0x1b, 0x74, this._getCodepageIdentifier('cp437'),
		(new Array(options.width)).fill(options.style === 'double' ? 0xcd : 0xc4),
		]);

		this._queue([
		0x1b, 0x74, this._state.codepage,
		]);

		this.newline();

		return this;
		}

		/**
		* Insert a box
		*
		* @param {object} options And object with the following properties:
		* - style: The style of the border, either single or double
		* - width: The width of the box, by default the width of the paper
		* - marginLeft: Space between the left border and the left edge
		* - marginRight: Space between the right border and the right edge
		* - paddingLeft: Space between the contents and the left border of the box
		* - paddingRight: Space between the contents and the right border of the box
		* @param {string\|function} contents A string value, or a callback function.
		* The first parameter of the callback is the encoder object on
		* which the function can call its methods.
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		box(options, contents) {
		options = Object.assign({
		style: 'single',
		width: this._options.width \|\| 30,
		marginLeft: 0,
		marginRight: 0,
		paddingLeft: 0,
		paddingRight: 0,
		}, options \|\| {});

		let elements;

		if (options.style == 'double') {
		elements = [0xc9, 0xbb, 0xc8, 0xbc, 0xcd, 0xba]; // ╔╗╚╝═║
		} else {
		elements = [0xda, 0xbf, 0xc0, 0xd9, 0xc4, 0xb3]; // ┌┐└┘─│
		}

		if (this._cursor != 0) {
		this.newline();
		}

		this._restoreState();

		this._queue([
		0x1b, 0x74, this._getCodepageIdentifier('cp437'),
		]);

		this._queue([
		new Array(options.marginLeft).fill(0x20),
		elements[0],
		new Array(options.width - 2).fill(elements[4]),
		elements[1],
		new Array(options.marginRight).fill(0x20),
		]);

		this.newline();

		const cell = [];

		if (typeof contents === 'string') {
		const w = linewrap(options.width - 2 - options.paddingLeft - options.paddingRight, {lineBreak: '\n'});
		const fragments = w(contents).split('\n');

		for (let f = 0; f < fragments.length; f++) {
		if (options.align == 'right') {
		cell[f] = this._encode(fragments[f].padStart(options.width - 2 - options.paddingLeft - options.paddingRight));
		} else {
		cell[f] = this._encode(fragments[f].padEnd(options.width - 2 - options.paddingLeft - options.paddingRight));
		}
		}
		}

		if (typeof contents === 'function') {
		const columnEncoder = new EscPosEncoder(Object.assign({}, this._options, {
		width: options.width - 2 - options.paddingLeft - options.paddingRight,
		embedded: true,
		}));

		columnEncoder._codepage = this._codepage;
		columnEncoder.align(options.align);
		contents(columnEncoder);
		const encoded = columnEncoder.encode();

		let fragment = [];

		for (let e = 0; e < encoded.byteLength; e++) {
		if (e < encoded.byteLength - 1) {
		if (encoded[e] === 0x0a && encoded[e + 1] === 0x0d) {
		cell.push(fragment);
		fragment = [];

		e++;
		continue;
		}
		}

		fragment.push(encoded[e]);
		}

		if (fragment.length) {
		cell.push(fragment);
		}
		}

		for (let c = 0; c < cell.length; c++) {
		this._queue([
		new Array(options.marginLeft).fill(0x20),
		elements[5],
		new Array(options.paddingLeft).fill(0x20),
		]);

		this._queue([
		cell[c],
		]);

		this._restoreState();

		this._queue([
		0x1b, 0x74, this._getCodepageIdentifier('cp437'),
		]);

		this._queue([
		new Array(options.paddingRight).fill(0x20),
		elements[5],
		new Array(options.marginRight).fill(0x20),
		]);

		this.newline();
		}

		this._queue([
		new Array(options.marginLeft).fill(0x20),
		elements[2],
		new Array(options.width - 2).fill(elements[4]),
		elements[3],
		new Array(options.marginRight).fill(0x20),
		]);

		this._restoreState();

		this.newline();

		return this;
		}

		/**
		* Barcode
		*
		* @param {string} value the value of the barcode
		* @param {string} symbology the type of the barcode
		* @param {number} height height of the barcode
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		barcode(value, symbology, height) {
		if (this._embedded) {
		throw new Error('Barcodes are not supported in table cells or boxes');
		}

		const symbologies = {
		'upca': 0x00,
		'upce': 0x01,
		'ean13': 0x02,
		'ean8': 0x03,
		'code39': 0x04,
		'coda39': 0x04, /* typo, leave here for backwards compatibility */
		'itf': 0x05,
		'codabar': 0x06,
		'code93': 0x48,
		'code128': 0x49,
		'gs1-128': 0x50,
		'gs1-databar-omni': 0x51,
		'gs1-databar-truncated': 0x52,
		'gs1-databar-limited': 0x53,
		'gs1-databar-expanded': 0x54,
		'code128-auto': 0x55,
		};

		if (symbology in symbologies) {
		const bytes = CodepageEncoder.encode(value, 'ascii');

		if (this._cursor != 0) {
		this.newline();
		}

		this._queue([
		0x1d, 0x68, height,
		0x1d, 0x77, symbology === 'code39' ? 0x02 : 0x03,
		]);

		if (symbology == 'code128' && bytes[0] !== 0x7b) {
		/* Not yet encodeded Code 128, assume data is Code B, which is similar to ASCII without control chars */

		this._queue([
		0x1d, 0x6b, symbologies[symbology],
		bytes.length + 2,
		0x7b, 0x42,
		bytes,
		]);
		} else if (symbologies[symbology] > 0x40) {
		/* Function B symbologies */

		this._queue([
		0x1d, 0x6b, symbologies[symbology],
		bytes.length,
		bytes,
		]);
		} else {
		/* Function A symbologies */

		this._queue([
		0x1d, 0x6b, symbologies[symbology],
		bytes,
		0x00,
		]);
		}
		} else {
		throw new Error('Symbology not supported by printer');
		}

		this._flush();

		return this;
		}

		/**
		* QR code
		*
		* @param {string} value the value of the qr code
		* @param {number} model model of the qrcode, either 1 or 2
		* @param {number} size size of the qrcode, a value between 1 and 8
		* @param {string} errorlevel the amount of error correction used, either 'l', 'm', 'q', 'h'
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		qrcode(value, model, size, errorlevel) {
		if (this._embedded) {
		throw new Error('QR codes are not supported in table cells or boxes');
		}

		/* Force printing the print buffer and moving to a new line */

		this._queue([
		0x0a,
		]);

		/* Model */

		const models = {
		1: 0x31,
		2: 0x32,
		};

		if (typeof model === 'undefined') {
		model = 2;
		}

		if (model in models) {
		this._queue([
		0x1d, 0x28, 0x6b, 0x04, 0x00, 0x31, 0x41, models[model], 0x00,
		]);
		} else {
		throw new Error('Model must be 1 or 2');
		}

		/* Size */

		if (typeof size === 'undefined') {
		size = 6;
		}

		if (typeof size !== 'number') {
		throw new Error('Size must be a number');
		}

		if (size < 1 \|\| size > 8) {
		throw new Error('Size must be between 1 and 8');
		}

		this._queue([
		0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x43, size,
		]);

		/* Error level */

		const errorlevels = {
		'l': 0x30,
		'm': 0x31,
		'q': 0x32,
		'h': 0x33,
		};

		if (typeof errorlevel === 'undefined') {
		errorlevel = 'm';
		}

		if (errorlevel in errorlevels) {
		this._queue([
		0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x45, errorlevels[errorlevel],
		]);
		} else {
		throw new Error('Error level must be l, m, q or h');
		}

		/* Data */

		const bytes = CodepageEncoder.encode(value, 'iso88591');
		const length = bytes.length + 3;

		this._queue([
		0x1d, 0x28, 0x6b, length % 0xff, length / 0xff, 0x31, 0x50, 0x30, bytes,
		]);

		/* Print QR code */

		this._queue([
		0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x51, 0x30,
		]);

		this._flush();

		return this;
		}

		/**
		* Image
		*
		* @param {object} element an element, like a canvas or image that needs to be printed
		* @param {number} width width of the image on the printer
		* @param {number} height height of the image on the printer
		* @param {string} algorithm the dithering algorithm for making the image black and white
		* @param {number} threshold threshold for the dithering algorithm
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		image(element, width, height, algorithm, threshold) {
		if (this._embedded) {
		throw new Error('Images are not supported in table cells or boxes');
		}

		if (width % 8 !== 0) {
		throw new Error('Width must be a multiple of 8');
		}

		if (height % 8 !== 0) {
		throw new Error('Height must be a multiple of 8');
		}

		if (typeof algorithm === 'undefined') {
		algorithm = 'threshold';
		}

		if (typeof threshold === 'undefined') {
		threshold = 128;
		}

		const canvas$1 = canvas.createCanvas(width, height);
		const context = canvas$1.getContext('2d');
		context.drawImage(element, 0, 0, width, height);
		let image = context.getImageData(0, 0, width, height);

		image = Flatten.flatten(image, [0xff, 0xff, 0xff]);

		switch (algorithm) {
		case 'threshold': image = Dither.threshold(image, threshold); break;
		case 'bayer': image = Dither.bayer(image, threshold); break;
		case 'floydsteinberg': image = Dither.floydsteinberg(image); break;
		case 'atkinson': image = Dither.atkinson(image); break;
		}

		const getPixel = (x, y) => x < width && y < height ? (image.data[((width * y) + x) * 4] > 0 ? 0 : 1) : 0;

		const getColumnData = (width, height) => {
		const data = [];

		for (let s = 0; s < Math.ceil(height / 24); s++) {
		const bytes = new Uint8Array(width * 3);

		for (let x = 0; x < width; x++) {
		for (let c = 0; c < 3; c++) {
		for (let b = 0; b < 8; b++) {
		bytes[(x * 3) + c] \|= getPixel(x, (s * 24) + b + (8 * c)) << (7 - b);
		}
		}
		}

		data.push(bytes);
		}

		return data;
		};

		const getRowData = (width, height) => {
		const bytes = new Uint8Array((width * height) >> 3);

		for (let y = 0; y < height; y++) {
		for (let x = 0; x < width; x = x + 8) {
		for (let b = 0; b < 8; b++) {
		bytes[(y * (width >> 3)) + (x >> 3)] \|= getPixel(x + b, y) << (7 - b);
		}
		}
		}

		return bytes;
		};


		if (this._cursor != 0) {
		this.newline();
		}

		/* Encode images with ESC * */

		if (this._options.imageMode == 'column') {
		this._queue([
		0x1b, 0x33, 0x24,
		]);

		getColumnData(width, height).forEach((bytes) => {
		this._queue([
		0x1b, 0x2a, 0x21,
		(width) & 0xff, (((width) >> 8) & 0xff),
		bytes,
		0x0a,
		]);
		});

		this._queue([
		0x1b, 0x32,
		]);
		}

		/* Encode images with GS v */

		if (this._options.imageMode == 'raster') {
		this._queue([
		0x1d, 0x76, 0x30, 0x00,
		(width >> 3) & 0xff, (((width >> 3) >> 8) & 0xff),
		height & 0xff, ((height >> 8) & 0xff),
		getRowData(width, height),
		]);
		}

		this._flush();

		return this;
		}

		/**
		* Cut paper
		*
		* @param {string} value full or partial. When not specified a full cut will be assumed
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		cut(value) {
		if (this._embedded) {
		throw new Error('Cut is not supported in table cells or boxes');
		}

		let data = 0x00;

		if (value == 'partial') {
		data = 0x01;
		}

		this._queue([
		0x1d, 0x56, data,
		]);

		return this;
		}

		/**
		* Pulse
		*
		* @param {number} device 0 or 1 for on which pin the device is connected, default of 0
		* @param {number} on Time the pulse is on in milliseconds, default of 100
		* @param {number} off Time the pulse is off in milliseconds, default of 500
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		pulse(device, on, off) {
		if (this._embedded) {
		throw new Error('Pulse is not supported in table cells or boxes');
		}

		if (typeof device === 'undefined') {
		device = 0;
		}

		if (typeof on === 'undefined') {
		on = 100;
		}

		if (typeof off === 'undefined') {
		off = 500;
		}

		on = Math.min(500, Math.round(on / 2));
		off = Math.min(500, Math.round(off / 2));

		this._queue([
		0x1b, 0x70, device ? 1 : 0, on & 0xff, off & 0xff,
		]);

		return this;
		}

		/**
		* Add raw printer commands
		*
		* @param {array} data raw bytes to be included
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		raw(data) {
		this._queue(data);

		return this;
		}

		/**
		* Encode all previous commands
		*
		* @return {Uint8Array} Return the encoded bytes
		*
		*/
		encode() {
		this._flush();

		let length = 0;

		this._buffer.forEach((item) => {
		if (typeof item === 'number') {
		length++;
		} else {
		length += item.length;
		}
		});

		const result = new Uint8Array(length);

		let index = 0;

		this._buffer.forEach((item) => {
		if (typeof item === 'number') {
		result[index] = item;
		index++;
		} else {
		result.set(item, index);
		index += item.length;
		}
		});

		this._reset();

		return result;
		}
		}

		module.exports = EscPosEncoder;

+1

dist/esc-pos-encoder.esm.js

+1369

dist/esc-pos-encoder.mjs

		import linewrap from 'linewrap';
		import { createCanvas } from 'canvas';
		import Dither from 'canvas-dither';
		import Flatten from 'canvas-flatten';
		import CodepageEncoder from 'codepage-encoder';

		const codepageMappings = {
		epson: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'cp851': 0x0b,
		'cp853': 0x0c,
		'cp857': 0x0d,
		'cp737': 0x0e,
		'iso88597': 0x0f,
		'windows1252': 0x10,
		'cp866': 0x11,
		'cp852': 0x12,
		'cp858': 0x13,
		'cp720': 0x20,
		'cp775': 0x21,
		'cp855': 0x22,
		'cp861': 0x23,
		'cp862': 0x24,
		'cp864': 0x25,
		'cp869': 0x26,
		'iso88592': 0x27,
		'iso885915': 0x28,
		'cp1098': 0x29,
		'cp1118': 0x2a,
		'cp1119': 0x2b,
		'cp1125': 0x2c,
		'windows1250': 0x2d,
		'windows1251': 0x2e,
		'windows1253': 0x2f,
		'windows1254': 0x30,
		'windows1255': 0x31,
		'windows1256': 0x32,
		'windows1257': 0x33,
		'windows1258': 0x34,
		'rk1048': 0x35,
		},

		zjiang: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'windows1252': 0x10,
		'cp866': 0x11,
		'cp852': 0x12,
		'cp858': 0x13,
		'windows1255': 0x20,
		'cp861': 0x38,
		'cp855': 0x3c,
		'cp857': 0x3d,
		'cp862': 0x3e,
		'cp864': 0x3f,
		'cp737': 0x40,
		'cp851': 0x41,
		'cp869': 0x42,
		'cp1119': 0x44,
		'cp1118': 0x45,
		'windows1250': 0x48,
		'windows1251': 0x49,
		'cp3840': 0x4a,
		'cp3843': 0x4c,
		'cp3844': 0x4d,
		'cp3845': 0x4e,
		'cp3846': 0x4f,
		'cp3847': 0x50,
		'cp3848': 0x51,
		'cp2001': 0x53,
		'cp3001': 0x54,
		'cp3002': 0x55,
		'cp3011': 0x56,
		'cp3012': 0x57,
		'cp3021': 0x58,
		'cp3041': 0x59,
		'windows1253': 0x5a,
		'windows1254': 0x5b,
		'windows1256': 0x5c,
		'cp720': 0x5d,
		'windows1258': 0x5e,
		'cp775': 0x5f,
		},

		bixolon: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'cp851': 0x0b,
		'cp858': 0x13,
		},

		star: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'windows1252': 0x10,
		'cp866': 0x11,
		'cp852': 0x12,
		'cp858': 0x13,
		},

		citizen: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'cp852': 0x12,
		'cp866': 0x11,
		'cp857': 0x08,
		'windows1252': 0x10,
		'cp858': 0x13,
		'cp864': 0x28,
		},

		legacy: {
		'cp437': 0x00,
		'cp737': 0x40,
		'cp850': 0x02,
		'cp775': 0x5f,
		'cp852': 0x12,
		'cp855': 0x3c,
		'cp857': 0x3d,
		'cp858': 0x13,
		'cp860': 0x03,
		'cp861': 0x38,
		'cp862': 0x3e,
		'cp863': 0x04,
		'cp864': 0x1c,
		'cp865': 0x05,
		'cp866': 0x11,
		'cp869': 0x42,
		'cp936': 0xff,
		'cp949': 0xfd,
		'cp950': 0xfe,
		'cp1252': 0x10,
		'iso88596': 0x16,
		'shiftjis': 0xfc,
		'windows874': 0x1e,
		'windows1250': 0x48,
		'windows1251': 0x49,
		'windows1252': 0x47,
		'windows1253': 0x5a,
		'windows1254': 0x5b,
		'windows1255': 0x20,
		'windows1256': 0x5c,
		'windows1257': 0x19,
		'windows1258': 0x5e,
		},
		};


		/**
		* Create a byte stream based on commands for ESC/POS printers
		*/
		class EscPosEncoder {
		/**
		* Create a new object
		*
		* @param {object} options Object containing configuration options
		*/
		constructor(options) {
		this._reset(options);
		}

		/**
		* Reset the state of the object
		*
		* @param {object} options Object containing configuration options
		*/
		_reset(options) {
		this._options = Object.assign({
		width: null,
		embedded: false,
		wordWrap: true,
		imageMode: 'column',
		codepageMapping: 'epson',
		codepageCandidates: [
		'cp437', 'cp858', 'cp860', 'cp861', 'cp863', 'cp865',
		'cp852', 'cp857', 'cp855', 'cp866', 'cp869',
		],
		}, options);

		this._embedded = this._options.width && this._options.embedded;

		this._buffer = [];
		this._queued = [];
		this._cursor = 0;
		this._codepage = 'ascii';

		this._state = {
		'codepage': 0,
		'align': 'left',
		'bold': false,
		'italic': false,
		'underline': false,
		'invert': false,
		'width': 1,
		'height': 1,
		};
		}

		/**
		* Encode a string with the current code page
		*
		* @param {string} value String to encode
		* @return {object} Encoded string as a ArrayBuffer
		*
		*/
		_encode(value) {
		if (this._codepage != 'auto') {
		return CodepageEncoder.encode(value, this._codepage);
		}

		let codepages;

		if (typeof this._options.codepageMapping == 'string') {
		codepages = codepageMappings[this._options.codepageMapping];
		} else {
		codepages = this._options.codepageMapping;
		}

		const fragments = CodepageEncoder.autoEncode(value, this._options.codepageCandidates);

		let length = 0;
		for (let f = 0; f < fragments.length; f++) {
		length += 3 + fragments[f].bytes.byteLength;
		}

		const buffer = new Uint8Array(length);
		let i = 0;

		for (let f = 0; f < fragments.length; f++) {
		buffer.set([0x1b, 0x74, codepages[fragments[f].codepage]], i);
		buffer.set(fragments[f].bytes, i + 3);
		i += 3 + fragments[f].bytes.byteLength;

		this._state.codepage = codepages[fragments[f].codepage];
		}

		return buffer;
		}

		/**
		* Add commands to the queue
		*
		* @param {array} value Add array of numbers, arrays, buffers or Uint8Arrays to add to the buffer
		*
		*/
		_queue(value) {
		value.forEach((item) => this._queued.push(item));
		}

		/**
		* Flush current queue to the buffer
		*
		*/
		_flush() {
		if (this._embedded) {
		let indent = this._options.width - this._cursor;

		if (this._state.align == 'left') {
		this._queued.push((new Array(indent)).fill(0x20));
		}

		if (this._state.align == 'center') {
		const remainder = indent % 2;
		indent = indent >> 1;

		if (indent > 0) {
		this._queued.push((new Array(indent)).fill(0x20));
		}

		if (indent + remainder > 0) {
		this._queued.unshift((new Array(indent + remainder)).fill(0x20));
		}
		}

		if (this._state.align == 'right') {
		this._queued.unshift((new Array(indent)).fill(0x20));
		}
		}

		this._buffer = this._buffer.concat(this._queued);

		this._queued = [];
		this._cursor = 0;
		}

		/**
		* Wrap the text while respecting the position of the cursor
		*
		* @param {string} value String to wrap after the width of the paper has been reached
		* @param {number} position Position on which to force a wrap
		* @return {array} Array with each line
		*/
		_wrap(value, position) {
		if (position \|\| (this._options.wordWrap && this._options.width)) {
		const indent = '-'.repeat(this._cursor);
		const w = linewrap(position \|\| this._options.width, {lineBreak: '\n', whitespace: 'all'});
		const result = w(indent + value).substring(this._cursor).split('\n');

		return result;
		}

		return [value];
		}

		/**
		* Restore styles and codepages after drawing boxes or lines
		*/
		_restoreState() {
		this.bold(this._state.bold);
		this.italic(this._state.italic);
		this.underline(this._state.underline);
		this.invert(this._state.invert);

		this._queue([
		0x1b, 0x74, this._state.codepage,
		]);
		}

		/**
		* Get code page identifier for the specified code page and mapping
		*
		* @param {string} codepage Required code page
		* @return {number} Identifier for the current printer according to the specified mapping
		*/
		_getCodepageIdentifier(codepage) {
		let codepages;

		if (typeof this._options.codepageMapping == 'string') {
		codepages = codepageMappings[this._options.codepageMapping];
		} else {
		codepages = this._options.codepageMapping;
		}

		return codepages[codepage];
		}


		/**
		* Initialize the printer
		*
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		initialize() {
		this._queue([
		0x1b, 0x40,
		]);

		this._flush();

		return this;
		}

		/**
		* Change the code page
		*
		* @param {string} codepage The codepage that we set the printer to
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		codepage(codepage) {
		if (codepage === 'auto') {
		this._codepage = codepage;
		return this;
		}

		if (!CodepageEncoder.supports(codepage)) {
		throw new Error('Unknown codepage');
		}

		let codepages;

		if (typeof this._options.codepageMapping == 'string') {
		codepages = codepageMappings[this._options.codepageMapping];
		} else {
		codepages = this._options.codepageMapping;
		}

		if (typeof codepages[codepage] !== 'undefined') {
		this._codepage = codepage;
		this._state.codepage = codepages[codepage];

		this._queue([
		0x1b, 0x74, codepages[codepage],
		]);
		} else {
		throw new Error('Codepage not supported by printer');
		}

		return this;
		}

		/**
		* Print text
		*
		* @param {string} value Text that needs to be printed
		* @param {number} wrap Wrap text after this many positions
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		text(value, wrap) {
		const lines = this._wrap(value, wrap);

		for (let l = 0; l < lines.length; l++) {
		const bytes = this._encode(lines[l]);

		this._queue([
		bytes,
		]);

		this._cursor += (lines[l].length * this._state.width);

		if (this._options.width && !this._embedded) {
		this._cursor = this._cursor % this._options.width;
		}

		if (l < lines.length - 1) {
		this.newline();
		}
		}

		return this;
		}

		/**
		* Print a newline
		*
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		newline() {
		this._flush();

		this._queue([
		0x0a, 0x0d,
		]);

		if (this._embedded) {
		this._restoreState();
		}

		return this;
		}

		/**
		* Print text, followed by a newline
		*
		* @param {string} value Text that needs to be printed
		* @param {number} wrap Wrap text after this many positions
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		line(value, wrap) {
		this.text(value, wrap);
		this.newline();

		return this;
		}

		/**
		* Underline text
		*
		* @param {boolean\|number} value true to turn on underline, false to turn off, or 2 for double underline
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		underline(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.underline;
		}

		this._state.underline = value;

		this._queue([
		0x1b, 0x2d, Number(value),
		]);

		return this;
		}

		/**
		* Italic text
		*
		* @param {boolean} value true to turn on italic, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		italic(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.italic;
		}

		this._state.italic = value;

		this._queue([
		0x1b, 0x34, Number(value),
		]);

		return this;
		}

		/**
		* Bold text
		*
		* @param {boolean} value true to turn on bold, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		bold(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.bold;
		}

		this._state.bold = value;

		this._queue([
		0x1b, 0x45, Number(value),
		]);

		return this;
		}

		/**
		* Change width of text
		*
		* @param {number} width The width of the text, 1 - 8
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		width(width) {
		if (typeof width === 'undefined') {
		width = 1;
		}

		if (typeof width !== 'number') {
		throw new Error('Width must be a number');
		}

		if (width < 1 \|\| width > 8) {
		throw new Error('Width must be between 1 and 8');
		}

		this._state.width = width;

		this._queue([
		0x1d, 0x21, (this._state.height - 1) \| (this._state.width - 1) << 4,
		]);

		return this;
		}

		/**
		* Change height of text
		*
		* @param {number} height The height of the text, 1 - 8
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		height(height) {
		if (typeof height === 'undefined') {
		height = 1;
		}

		if (typeof height !== 'number') {
		throw new Error('Height must be a number');
		}

		if (height < 1 \|\| height > 8) {
		throw new Error('Height must be between 1 and 8');
		}

		this._state.height = height;

		this._queue([
		0x1d, 0x21, (this._state.height - 1) \| (this._state.width - 1) << 4,
		]);

		return this;
		}

		/**
		* Invert text
		*
		* @param {boolean} value true to turn on white text on black, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		invert(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.invert;
		}

		this._state.invert = value;

		this._queue([
		0x1d, 0x42, Number(value),
		]);

		return this;
		}

		/**
		* Change text size
		*
		* @param {string} value small or normal
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		size(value) {
		if (value === 'small') {
		value = 0x01;
		} else {
		value = 0x00;
		}

		this._queue([
		0x1b, 0x4d, value,
		]);

		return this;
		}

		/**
		* Change text alignment
		*
		* @param {string} value left, center or right
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		align(value) {
		const alignments = {
		'left': 0x00,
		'center': 0x01,
		'right': 0x02,
		};

		if (value in alignments) {
		this._state.align = value;

		if (!this._embedded) {
		this._queue([
		0x1b, 0x61, alignments[value],
		]);
		}
		} else {
		throw new Error('Unknown alignment');
		}

		return this;
		}

		/**
		* Insert a table
		*
		* @param {array} columns The column definitions
		* @param {array} data Array containing rows. Each row is an array containing cells.
		* Each cell can be a string value, or a callback function.
		* The first parameter of the callback is the encoder object on
		* which the function can call its methods.
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		table(columns, data) {
		if (this._cursor != 0) {
		this.newline();
		}

		for (let r = 0; r < data.length; r++) {
		const lines = [];
		let maxLines = 0;

		for (let c = 0; c < columns.length; c++) {
		const cell = [];

		if (typeof data[r][c] === 'string') {
		const w = linewrap(columns[c].width, {lineBreak: '\n'});
		const fragments = w(data[r][c]).split('\n');

		for (let f = 0; f < fragments.length; f++) {
		if (columns[c].align == 'right') {
		cell[f] = this._encode(fragments[f].padStart(columns[c].width));
		} else {
		cell[f] = this._encode(fragments[f].padEnd(columns[c].width));
		}
		}
		}

		if (typeof data[r][c] === 'function') {
		const columnEncoder = new EscPosEncoder(Object.assign({}, this._options, {
		width: columns[c].width,
		embedded: true,
		}));

		columnEncoder._codepage = this._codepage;
		columnEncoder.align(columns[c].align);
		data[r][c](columnEncoder);
		const encoded = columnEncoder.encode();

		let fragment = [];

		for (let e = 0; e < encoded.byteLength; e++) {
		if (e < encoded.byteLength - 1) {
		if (encoded[e] === 0x0a && encoded[e + 1] === 0x0d) {
		cell.push(fragment);
		fragment = [];

		e++;
		continue;
		}
		}

		fragment.push(encoded[e]);
		}

		if (fragment.length) {
		cell.push(fragment);
		}
		}

		maxLines = Math.max(maxLines, cell.length);
		lines[c] = cell;
		}

		for (let c = 0; c < columns.length; c++) {
		if (lines[c].length < maxLines) {
		for (let p = lines[c].length; p < maxLines; p++) {
		let verticalAlign = 'top';
		if (typeof columns[c].verticalAlign !== 'undefined') {
		verticalAlign = columns[c].verticalAlign;
		}

		if (verticalAlign == 'bottom') {
		lines[c].unshift((new Array(columns[c].width)).fill(0x20));
		} else {
		lines[c].push((new Array(columns[c].width)).fill(0x20));
		}
		}
		}
		}

		for (let l = 0; l < maxLines; l++) {
		for (let c = 0; c < columns.length; c++) {
		if (typeof columns[c].marginLeft !== 'undefined') {
		this.raw((new Array(columns[c].marginLeft)).fill(0x20));
		}

		this.raw(lines[c][l]);

		if (typeof columns[c].marginRight !== 'undefined') {
		this.raw((new Array(columns[c].marginRight)).fill(0x20));
		}
		}

		this.newline();
		}
		}

		return this;
		}

		/**
		* Insert a horizontal rule
		*
		* @param {object} options And object with the following properties:
		* - style: The style of the line, either single or double
		* - width: The width of the line, by default the width of the paper
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		rule(options) {
		options = Object.assign({
		style: 'single',
		width: this._options.width \|\| 10,
		}, options \|\| {});

		this._queue([
		0x1b, 0x74, this._getCodepageIdentifier('cp437'),
		(new Array(options.width)).fill(options.style === 'double' ? 0xcd : 0xc4),
		]);

		this._queue([
		0x1b, 0x74, this._state.codepage,
		]);

		this.newline();

		return this;
		}

		/**
		* Insert a box
		*
		* @param {object} options And object with the following properties:
		* - style: The style of the border, either single or double
		* - width: The width of the box, by default the width of the paper
		* - marginLeft: Space between the left border and the left edge
		* - marginRight: Space between the right border and the right edge
		* - paddingLeft: Space between the contents and the left border of the box
		* - paddingRight: Space between the contents and the right border of the box
		* @param {string\|function} contents A string value, or a callback function.
		* The first parameter of the callback is the encoder object on
		* which the function can call its methods.
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		box(options, contents) {
		options = Object.assign({
		style: 'single',
		width: this._options.width \|\| 30,
		marginLeft: 0,
		marginRight: 0,
		paddingLeft: 0,
		paddingRight: 0,
		}, options \|\| {});

		let elements;

		if (options.style == 'double') {
		elements = [0xc9, 0xbb, 0xc8, 0xbc, 0xcd, 0xba]; // ╔╗╚╝═║
		} else {
		elements = [0xda, 0xbf, 0xc0, 0xd9, 0xc4, 0xb3]; // ┌┐└┘─│
		}

		if (this._cursor != 0) {
		this.newline();
		}

		this._restoreState();

		this._queue([
		0x1b, 0x74, this._getCodepageIdentifier('cp437'),
		]);

		this._queue([
		new Array(options.marginLeft).fill(0x20),
		elements[0],
		new Array(options.width - 2).fill(elements[4]),
		elements[1],
		new Array(options.marginRight).fill(0x20),
		]);

		this.newline();

		const cell = [];

		if (typeof contents === 'string') {
		const w = linewrap(options.width - 2 - options.paddingLeft - options.paddingRight, {lineBreak: '\n'});
		const fragments = w(contents).split('\n');

		for (let f = 0; f < fragments.length; f++) {
		if (options.align == 'right') {
		cell[f] = this._encode(fragments[f].padStart(options.width - 2 - options.paddingLeft - options.paddingRight));
		} else {
		cell[f] = this._encode(fragments[f].padEnd(options.width - 2 - options.paddingLeft - options.paddingRight));
		}
		}
		}

		if (typeof contents === 'function') {
		const columnEncoder = new EscPosEncoder(Object.assign({}, this._options, {
		width: options.width - 2 - options.paddingLeft - options.paddingRight,
		embedded: true,
		}));

		columnEncoder._codepage = this._codepage;
		columnEncoder.align(options.align);
		contents(columnEncoder);
		const encoded = columnEncoder.encode();

		let fragment = [];

		for (let e = 0; e < encoded.byteLength; e++) {
		if (e < encoded.byteLength - 1) {
		if (encoded[e] === 0x0a && encoded[e + 1] === 0x0d) {
		cell.push(fragment);
		fragment = [];

		e++;
		continue;
		}
		}

		fragment.push(encoded[e]);
		}

		if (fragment.length) {
		cell.push(fragment);
		}
		}

		for (let c = 0; c < cell.length; c++) {
		this._queue([
		new Array(options.marginLeft).fill(0x20),
		elements[5],
		new Array(options.paddingLeft).fill(0x20),
		]);

		this._queue([
		cell[c],
		]);

		this._restoreState();

		this._queue([
		0x1b, 0x74, this._getCodepageIdentifier('cp437'),
		]);

		this._queue([
		new Array(options.paddingRight).fill(0x20),
		elements[5],
		new Array(options.marginRight).fill(0x20),
		]);

		this.newline();
		}

		this._queue([
		new Array(options.marginLeft).fill(0x20),
		elements[2],
		new Array(options.width - 2).fill(elements[4]),
		elements[3],
		new Array(options.marginRight).fill(0x20),
		]);

		this._restoreState();

		this.newline();

		return this;
		}

		/**
		* Barcode
		*
		* @param {string} value the value of the barcode
		* @param {string} symbology the type of the barcode
		* @param {number} height height of the barcode
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		barcode(value, symbology, height) {
		if (this._embedded) {
		throw new Error('Barcodes are not supported in table cells or boxes');
		}

		const symbologies = {
		'upca': 0x00,
		'upce': 0x01,
		'ean13': 0x02,
		'ean8': 0x03,
		'code39': 0x04,
		'coda39': 0x04, /* typo, leave here for backwards compatibility */
		'itf': 0x05,
		'codabar': 0x06,
		'code93': 0x48,
		'code128': 0x49,
		'gs1-128': 0x50,
		'gs1-databar-omni': 0x51,
		'gs1-databar-truncated': 0x52,
		'gs1-databar-limited': 0x53,
		'gs1-databar-expanded': 0x54,
		'code128-auto': 0x55,
		};

		if (symbology in symbologies) {
		const bytes = CodepageEncoder.encode(value, 'ascii');

		if (this._cursor != 0) {
		this.newline();
		}

		this._queue([
		0x1d, 0x68, height,
		0x1d, 0x77, symbology === 'code39' ? 0x02 : 0x03,
		]);

		if (symbology == 'code128' && bytes[0] !== 0x7b) {
		/* Not yet encodeded Code 128, assume data is Code B, which is similar to ASCII without control chars */

		this._queue([
		0x1d, 0x6b, symbologies[symbology],
		bytes.length + 2,
		0x7b, 0x42,
		bytes,
		]);
		} else if (symbologies[symbology] > 0x40) {
		/* Function B symbologies */

		this._queue([
		0x1d, 0x6b, symbologies[symbology],
		bytes.length,
		bytes,
		]);
		} else {
		/* Function A symbologies */

		this._queue([
		0x1d, 0x6b, symbologies[symbology],
		bytes,
		0x00,
		]);
		}
		} else {
		throw new Error('Symbology not supported by printer');
		}

		this._flush();

		return this;
		}

		/**
		* QR code
		*
		* @param {string} value the value of the qr code
		* @param {number} model model of the qrcode, either 1 or 2
		* @param {number} size size of the qrcode, a value between 1 and 8
		* @param {string} errorlevel the amount of error correction used, either 'l', 'm', 'q', 'h'
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		qrcode(value, model, size, errorlevel) {
		if (this._embedded) {
		throw new Error('QR codes are not supported in table cells or boxes');
		}

		/* Force printing the print buffer and moving to a new line */

		this._queue([
		0x0a,
		]);

		/* Model */

		const models = {
		1: 0x31,
		2: 0x32,
		};

		if (typeof model === 'undefined') {
		model = 2;
		}

		if (model in models) {
		this._queue([
		0x1d, 0x28, 0x6b, 0x04, 0x00, 0x31, 0x41, models[model], 0x00,
		]);
		} else {
		throw new Error('Model must be 1 or 2');
		}

		/* Size */

		if (typeof size === 'undefined') {
		size = 6;
		}

		if (typeof size !== 'number') {
		throw new Error('Size must be a number');
		}

		if (size < 1 \|\| size > 8) {
		throw new Error('Size must be between 1 and 8');
		}

		this._queue([
		0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x43, size,
		]);

		/* Error level */

		const errorlevels = {
		'l': 0x30,
		'm': 0x31,
		'q': 0x32,
		'h': 0x33,
		};

		if (typeof errorlevel === 'undefined') {
		errorlevel = 'm';
		}

		if (errorlevel in errorlevels) {
		this._queue([
		0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x45, errorlevels[errorlevel],
		]);
		} else {
		throw new Error('Error level must be l, m, q or h');
		}

		/* Data */

		const bytes = CodepageEncoder.encode(value, 'iso88591');
		const length = bytes.length + 3;

		this._queue([
		0x1d, 0x28, 0x6b, length % 0xff, length / 0xff, 0x31, 0x50, 0x30, bytes,
		]);

		/* Print QR code */

		this._queue([
		0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x51, 0x30,
		]);

		this._flush();

		return this;
		}

		/**
		* Image
		*
		* @param {object} element an element, like a canvas or image that needs to be printed
		* @param {number} width width of the image on the printer
		* @param {number} height height of the image on the printer
		* @param {string} algorithm the dithering algorithm for making the image black and white
		* @param {number} threshold threshold for the dithering algorithm
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		image(element, width, height, algorithm, threshold) {
		if (this._embedded) {
		throw new Error('Images are not supported in table cells or boxes');
		}

		if (width % 8 !== 0) {
		throw new Error('Width must be a multiple of 8');
		}

		if (height % 8 !== 0) {
		throw new Error('Height must be a multiple of 8');
		}

		if (typeof algorithm === 'undefined') {
		algorithm = 'threshold';
		}

		if (typeof threshold === 'undefined') {
		threshold = 128;
		}

		const canvas = createCanvas(width, height);
		const context = canvas.getContext('2d');
		context.drawImage(element, 0, 0, width, height);
		let image = context.getImageData(0, 0, width, height);

		image = Flatten.flatten(image, [0xff, 0xff, 0xff]);

		switch (algorithm) {
		case 'threshold': image = Dither.threshold(image, threshold); break;
		case 'bayer': image = Dither.bayer(image, threshold); break;
		case 'floydsteinberg': image = Dither.floydsteinberg(image); break;
		case 'atkinson': image = Dither.atkinson(image); break;
		}

		const getPixel = (x, y) => x < width && y < height ? (image.data[((width * y) + x) * 4] > 0 ? 0 : 1) : 0;

		const getColumnData = (width, height) => {
		const data = [];

		for (let s = 0; s < Math.ceil(height / 24); s++) {
		const bytes = new Uint8Array(width * 3);

		for (let x = 0; x < width; x++) {
		for (let c = 0; c < 3; c++) {
		for (let b = 0; b < 8; b++) {
		bytes[(x * 3) + c] \|= getPixel(x, (s * 24) + b + (8 * c)) << (7 - b);
		}
		}
		}

		data.push(bytes);
		}

		return data;
		};

		const getRowData = (width, height) => {
		const bytes = new Uint8Array((width * height) >> 3);

		for (let y = 0; y < height; y++) {
		for (let x = 0; x < width; x = x + 8) {
		for (let b = 0; b < 8; b++) {
		bytes[(y * (width >> 3)) + (x >> 3)] \|= getPixel(x + b, y) << (7 - b);
		}
		}
		}

		return bytes;
		};


		if (this._cursor != 0) {
		this.newline();
		}

		/* Encode images with ESC * */

		if (this._options.imageMode == 'column') {
		this._queue([
		0x1b, 0x33, 0x24,
		]);

		getColumnData(width, height).forEach((bytes) => {
		this._queue([
		0x1b, 0x2a, 0x21,
		(width) & 0xff, (((width) >> 8) & 0xff),
		bytes,
		0x0a,
		]);
		});

		this._queue([
		0x1b, 0x32,
		]);
		}

		/* Encode images with GS v */

		if (this._options.imageMode == 'raster') {
		this._queue([
		0x1d, 0x76, 0x30, 0x00,
		(width >> 3) & 0xff, (((width >> 3) >> 8) & 0xff),
		height & 0xff, ((height >> 8) & 0xff),
		getRowData(width, height),
		]);
		}

		this._flush();

		return this;
		}

		/**
		* Cut paper
		*
		* @param {string} value full or partial. When not specified a full cut will be assumed
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		cut(value) {
		if (this._embedded) {
		throw new Error('Cut is not supported in table cells or boxes');
		}

		let data = 0x00;

		if (value == 'partial') {
		data = 0x01;
		}

		this._queue([
		0x1d, 0x56, data,
		]);

		return this;
		}

		/**
		* Pulse
		*
		* @param {number} device 0 or 1 for on which pin the device is connected, default of 0
		* @param {number} on Time the pulse is on in milliseconds, default of 100
		* @param {number} off Time the pulse is off in milliseconds, default of 500
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		pulse(device, on, off) {
		if (this._embedded) {
		throw new Error('Pulse is not supported in table cells or boxes');
		}

		if (typeof device === 'undefined') {
		device = 0;
		}

		if (typeof on === 'undefined') {
		on = 100;
		}

		if (typeof off === 'undefined') {
		off = 500;
		}

		on = Math.min(500, Math.round(on / 2));
		off = Math.min(500, Math.round(off / 2));

		this._queue([
		0x1b, 0x70, device ? 1 : 0, on & 0xff, off & 0xff,
		]);

		return this;
		}

		/**
		* Add raw printer commands
		*
		* @param {array} data raw bytes to be included
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		raw(data) {
		this._queue(data);

		return this;
		}

		/**
		* Encode all previous commands
		*
		* @return {Uint8Array} Return the encoded bytes
		*
		*/
		encode() {
		this._flush();

		let length = 0;

		this._buffer.forEach((item) => {
		if (typeof item === 'number') {
		length++;
		} else {
		length += item.length;
		}
		});

		const result = new Uint8Array(length);

		let index = 0;

		this._buffer.forEach((item) => {
		if (typeof item === 'number') {
		result[index] = item;
		index++;
		} else {
		result.set(item, index);
		index += item.length;
		}
		});

		this._reset();

		return result;
		}
		}

		export { EscPosEncoder as default };

+1

dist/esc-pos-encoder.umd.js

+1

-1

LICENSE

		MIT License

		Copyright (c) 2019 Anson Tio
		Copyright (c) 2024 Ryan Huxley

		@@ -5,0 +5,0 @@ Permission is hereby granted, free of charge, to any person obtaining a copy

+28

-18

package.json

		{
		"name": "@mineminemine/esc-pos-encoder-ionic",
		"version": "2.0.3",
		"version": "3.0.0",
		"description": "Create a set of commands that can be send to any receipt printer that supports ESC/POS",
		"main": "src/esc-pos-encoder.js",
		"type": "module",
		"exports": {
		"browser": {
		"import": "./dist/esc-pos-encoder.esm.js",
		"require": "./dist/esc-pos-encoder.umd.js",
		"script": "./dist/esc-pos-encoder.umd.js"
		},
		"import": "./dist/esc-pos-encoder.mjs",
		"require": "./dist/esc-pos-encoder.cjs"
		},
		"main": "dist/esc-pos-encoder.cjs",
		"module": "dist/esc-pos-encoder.mjs",
		"scripts": {
		"bundle": "browserify src/esc-pos-encoder.js --standalone EscPosEncoder -o dist/esc-pos-encoder.js",
		"uglify": "uglifyjs dist/esc-pos-encoder.js -cm --overwrite -o dist/esc-pos-encoder.js",
		"build": "npm run bundle && npm run uglify",
		"build": "rollup -c",
		"lint": "eslint --fix src/esc-pos-encoder.js",
		@@ -26,3 +35,4 @@ "mocha": "mocha test/",
		"ionic5",
		"ionic6"
		"ionic6",
		"ionic7"
		],
		@@ -36,21 +46,21 @@ "author": "Ryan Huxley",
		"devDependencies": {
		"browserify": "^17.0.0",
		"buffer-to-uint8array": "^1.1.0",
		"chai": "^4.3.4",
		"eslint": "^7.31.0",
		"@rollup/plugin-commonjs": "^24.1.0",
		"@rollup/plugin-node-resolve": "^15.0.2",
		"@rollup/plugin-terser": "^0.4.1",
		"chai": "^4.3.7",
		"eslint": "^8.39.0",
		"eslint-config-google": "^0.14.0",
		"iconv-lite": "^0.6.3",
		"mocha": "^9.0.2",
		"uglify-es": "^3.3.9"
		"mocha": "^10.2.0",
		"rollup": "^3.20.7"
		},
		"dependencies": {
		"canvas": "^2.8.0",
		"canvas": "^2.11.2",
		"canvas-dither": "^1.0.1",
		"canvas-flatten": "^1.0.1",
		"codepage-encoder": "^1.0.0",
		"codepage-encoder": "^2.0.4",
		"linewrap": "^0.2.1"
		},
		"directories": {
		"test": "test"
		}
		"files": [
		"dist"
		]
		}

+137

-69

README.md

		# esc-pos-encoder-ionic

		This is a fork of [EscPosEncoder](https://github.com/Ans0n-Ti0/EscPosEncoder) by Anson Tio that is intended to work with Ionic. I have only updated his fork to match the latest [EscPosEncoder](https://github.com/NielsLeenheer/EscPosEncoder) by NielsLeenheer.

		Create a set of commands that can be send to any receipt printer that supports ESC/POS.
		This is ionic friendly, which mean you can use this for your ionic project too!

		Before you use this library, you should also consider [ThermalPrinterEncoder](https://github.com/NielsLeenheer/ThermalPrinterEncoder), which is based on [EscPosEncoder](https://github.com/NielsLeenheer/EscPosEncoder), but also adds support for the StarPRNT language by using [StarPrntEncoder](https://github.com/NielsLeenheer/StarPrntEncoder). The API of ThermalPrinter is identical to this one and you should just be able to swap it out without any further changes.

		## Usage
		@@ -12,5 +15,5 @@

		Then, require the package and use it like so:
		If you prefer ES6 modules, then import `EscPosEncoder` from `esc-pos-encoder` and use it like so:

		let EscPosEncoder = require('esc-pos-encoder');
		import EscPosEncoder from '@mineminemine/esc-pos-encoder-ionic';

		@@ -26,19 +29,39 @@ let encoder = new EscPosEncoder();

		## Commands
		Alternatively you could use the CommonJS way of doing things and require the package:

		You can reuse the instantiated `EscPosEncoder` class to generate multiple commands or sets of commands for the same printer. It will remember settings like code page, so you don't have to specify that on subsequent use. That does rely on that previous commands were actually send to the printer.
		let EscPosEncoder = require('@mineminemine/esc-pos-encoder-ionic');

		All commands can be chained, except for `encode()` which will return the result as an Uint8Array which contains all the bytes that need to be send to the printer.
		let encoder = new EscPosEncoder();

		## Options

		## Usage (Ionic)
		When you create the `EscPosEncoder` object you can specify a number of options to help with the library with generating receipts.

		On the page that you want to have the encoder, type this
		### Width

		import EscPosEncoder from '@mineminemine/esc-pos-encoder-ionic';

		Then inside the class method, you can access it by using:
		To set the width of the paper you can use the `width` property. This is option, as text automatically wraps to a new line if the edge of the paper is reached, but if you want to use word wrap, you need to specify this.

		const encoder = new EscPosEncoder();

		let encoder = new EscPosEncoder({
		width: 42
		});

		If you use 57mm wide paper, it allows you to print up to 32 or 35 characters horizontally, depending on the resolution of the printer.

		If you use 80mm wide paper, it allows you to print up to 42 or 48 characters horizontally, depending on the resolution of the printer.

		## Word wrap

		If you want text to automatically word wrap at the edge of the paper you can turn on `wordWrap`. If you use this option you also must specify a paper width using the `width` property.

		let encoder = new EscPosEncoder({
		width: 48,
		wordWrap: true
		});

		## Commands

		You can reuse the instantiated `EscPosEncoder` class to generate multiple commands or sets of commands for the same printer. It will remember settings like code page, so you don't have to specify that on subsequent use. That does rely on that previous commands were actually send to the printer.

		All commands can be chained, except for `encode()` which will return the result as an Uint8Array which contains all the bytes that need to be send to the printer.

		The following commands are available:
		@@ -56,5 +79,5 @@

		Set the code page of the printer. Receipt printers don't support UTF-8 or any other unicode encoding, instead the rely on legacy code pages.
		Set the code page of the printer. Receipt printers don't support UTF-8 or any other unicode encoding, instead the rely on legacy code pages.

		If you specify the code page, it will send a command to the printer to enable that particular code page and from then on it will automatically encode all text string to that code page.
		If you specify the code page, it will send a command to the printer to enable that particular code page and from then on it will automatically encode all text string to that code page.

		@@ -74,5 +97,5 @@ If you don't specify a code page, it will assume you want to print only ASCII characters and strip out any others.

		Support for one specific code pages is not only dependant on this library, even more important is that the printer understands it. And support for code pages depend on manufacturer and model. Some only support a few, some support most of these. There are probably no printers that support all of them.
		Support for one specific code pages is not only dependant on this library, even more important is that the printer understands it. And support for code pages depend on manufacturer and model. Some only support a few, some support most of these. There are probably no printers that support all of them.

		Before choosing a code page, check the technical manual of your printer which codepages are supported. If your printer does not support a code page that you need, you are out of luck and nothing this library does can help you solve this problem.
		Before choosing a code page, check the technical manual of your printer which codepages are supported. If your printer does not support a code page that you need, you are out of luck and nothing this library does can help you solve this problem.

		@@ -90,4 +113,4 @@ #### Advanced text compositing

		let encoder = new EscPosEncoder({
		codepageMapping: 'bixolon'
		let encoder = new EscPosEncoder({
		codepageMapping: 'bixolon'
		});
		@@ -97,3 +120,3 @@

		let encoder = new EscPosEncoder({
		let encoder = new EscPosEncoder({
		codepageMapping: {
		@@ -107,11 +130,10 @@ 'cp437': 0x00,
		'cp858': 0x13,
		}
		}
		});

		Each property name must be one of the code pages supported by this library and the value is the number which is used for that code page on your printer.
		Each property name must be one of the code pages supported by this library and the value is the number which is used for that code page on your printer.


		#### Auto encoding

		It is also possible to enable auto encoding of code pages. The library will then automatically switch between code pages depending on the text that you want to print.
		It is also possible to enable auto encoding of code pages. The library will then automatically switch between code pages depending on the text that you want to print.

		@@ -134,3 +156,3 @@ let result = encoder

		let encoder = new EscPosEncoder({
		let encoder = new EscPosEncoder({
		codepageCandidates: [
		@@ -142,3 +164,2 @@ 'cp437', 'cp858', 'cp860', 'cp861', 'cp863', 'cp865',


		### Text
		@@ -192,3 +213,3 @@

		Change the text style to underline.
		Change the text style to underline.

		@@ -213,3 +234,3 @@ let result = encoder

		Change the text style to bold.
		Change the text style to bold.

		@@ -234,3 +255,3 @@ let result = encoder

		Change the text style to italic.
		Change the text style to italic.

		@@ -253,7 +274,7 @@ let result = encoder

		Note: this text style is not supported by most receipt printers.
		Note: this text style is not supported by most receipt printers.

		### Invert

		Change the style to white text on a black background.
		Change the style to white text on a black background.

		@@ -334,9 +355,8 @@ let result = encoder
		.width(2)
		.width(2)
		.height(2)
		.line('This text is twice as large as normal text')
		.width(1)
		.height(1)
		.height(1)
		.encode()


		### Table
		@@ -351,3 +371,3 @@
		{ width: 10, align: 'right' }
		],
		],
		[
		@@ -362,13 +382,59 @@ [ 'Item 1', '€ 10,00' ],
		]
		)
		)
		.encode()

		The table function takes two parameters.

		The first parameter is an array of column definitions. Each column can have the folowing properties:

		- `width`: determines the width of the column.
		- `marginLeft` and `marginRight`: set a margin to the left and right of the column.
		- `align`: sets the horizontal alignment of the text in the column and can either be `left` or `right`.
		- `verticalAlign`: sets the vertical alignment of the text in the column and can either be `top` or `bottom`.

		The second parameter contains the data and is an array that contains each row. There can be as many rows as you would like.

		Each row is an array with a value for each cell. The number of cells in each row should be equal to the number of columns you defined previously.

		[
		/* Row one, with two columns */
		[ 'Cell one', 'Cell two' ],

		/* Row two, with two columns */
		[ 'Cell three', 'Cell four' ]
		]

		The value can either be a string or a callback function.

		If you want to style text inside of a cell, can use the callback function instead. The first parameter of the called function contains the encoder object which you can use to chain additional commands.

		[
		/* Row one, with two columns */
		[
		'Cell one',
		(encoder) => encoder.bold().text('Cell two').bold()
		],
		]

		### Box

		Insert a bordered box. The content of the box can be a string, or a callback function.
		Insert a bordered box.

		The first parameter is an object with additional configuration options.

		- `style`: The style of the border, either `single` or `double`
		- `width`: The width of the box, by default the width of the paper
		- `marginLeft`: Space between the left border and the left edge
		- `marginRight`: Space between the right border and the right edge
		- `paddingLeft`: Space between the contents and the left border of the box
		- `paddingRight`: Space between the contents and the right border of the box
		- `align`: The alignment of the text within the box, can be `left` or `right`.

		The second parameter is the content of the box and it can be a string, or a callback function.

		For example:

		let result = encoder
		.box(
		{ width: 30, align: 'right', style: 'double', marginLeft: 10 },
		{ width: 30, align: 'right', style: 'double', marginLeft: 10 },
		'The quick brown fox jumps over the lazy dog
		@@ -378,3 +444,2 @@ )


		### Rule
		@@ -384,7 +449,13 @@

		The first parameters is an object with additional styling options:

		- `style`: The style of the line, either `single` or `double`
		- `width`: The width of the line, by default the width of the paper

		For example:

		let result = encoder
		.rule({ style: 'double' })
		.rule({ style: 'double' })
		.encode()


		### Barcode
		@@ -398,3 +469,3 @@

		In general the printer will automatically calculate the checksum if one is not provided. If one is provided in the data, it will not check the checksum. If you provide the checksum yourself and it is not correctly calculated, the behaviour is not defined. It may calculate the correct checksum use that instead or print an invalid barcode.
		In general the printer will automatically calculate the checksum if one is not provided. If one is provided in the data, it will not check the checksum. If you provide the checksum yourself and it is not correctly calculated, the behaviour is not defined. It may calculate the correct checksum use that instead or print an invalid barcode.

		@@ -417,18 +488,18 @@ For example with the checksum provided in the data:

		\| Symbology \| Length \| Characters \|
		\|-\|-\|-\|
		\| upca \| 11 - 12 \| 0 - 9 \|
		\| ean8 \| 7 - 8 \| 0 - 9 \|
		\| ean13 \| 12 - 13 \| 0 - 9 \|
		\| code39 \| >= 1 \| 0 - 9, A - Z, space, or $ % * + - . / \|
		\| itf \| >= 2 (even) \| 0 - 9 \|
		\| codabar \| >= 2 \| 0 - 9, A - D, a - d, or $ + − . / : \|
		\| code93 \| 1 - 255 \| ASCII character (0 - 127) \|
		\| code128 \| 1 - 253 \| ASCII character (32 - 127) \|
		\| Symbology \| Length \| Characters \|
		\| --------- \| ----------- \| -------------------------------------- \|
		\| upca \| 11 - 12 \| 0 - 9 \|
		\| ean8 \| 7 - 8 \| 0 - 9 \|
		\| ean13 \| 12 - 13 \| 0 - 9 \|
		\| code39 \| >= 1 \| 0 - 9, A - Z, space, or $ % \* + - . / \|
		\| itf \| >= 2 (even) \| 0 - 9 \|
		\| codabar \| >= 2 \| 0 - 9, A - D, a - d, or $ + − . / : \|
		\| code93 \| 1 - 255 \| ASCII character (0 - 127) \|
		\| code128 \| 1 - 253 \| ASCII character (32 - 127) \|

		The Code 128 symbology specifies three different code sets which contain different characters. For example: CODE A contains ASCII control characters, special characters, digits and uppercase letters. CODE B contains special characters, digits, uppercase letters and lowercase letters. CODE C prints 2 digits numbers that correspond to the ASCII value of the letter.
		The Code 128 symbology specifies three different code sets which contain different characters. For example: CODE A contains ASCII control characters, special characters, digits and uppercase letters. CODE B contains special characters, digits, uppercase letters and lowercase letters. CODE C prints 2 digits numbers that correspond to the ASCII value of the letter.

		By default Code 128 uses CODE B. It is possible to use a different code set, by using the code set selector character { followed by the uppercase letter of the character set.

		For example with the default CODE B set:
		For example with the default CODE B set:

		@@ -457,4 +528,2 @@ let result = encoder



		### Qrcode
		@@ -470,5 +539,5 @@

		- model - a number that can be 1 for Model 1 and 2 for Model 2
		- size - a number that can be between 1 and 8 for determining the size of the QR code
		- errorlevel - a string that can be either 'l', 'm', 'q' or 'h'.
		- _model_ - a number that can be 1 for Model 1 and 2 for Model 2
		- _size_ - a number that can be between 1 and 8 for determining the size of the QR code
		- _errorlevel_ - a string that can be either 'l', 'm', 'q' or 'h'.

		@@ -481,3 +550,2 @@ For example:


		### Image
		@@ -487,3 +555,3 @@

		The first parameter is the image itself. When running in the browser it can be any element that can be drawn onto a canvas, like an img, svg, canvas and video elements. When on Node it can be a Canvas provided by the `canvas` package.
		The first parameter is the image itself. When running in the browser it can be any element that can be drawn onto a canvas, like an img, svg, canvas and video elements. When on Node it can be a Canvas provided by the `canvas` package.

		@@ -500,3 +568,3 @@ The second parameter is the width of the image on the paper receipt in pixels. It must be a multiple of 8.
		img.src = 'https://...';


		img.onload = function() {
		@@ -514,4 +582,4 @@ let result = encoder

		let encoder = new EscPosEncoder({
		imageMode: 'raster'
		let encoder = new EscPosEncoder({
		imageMode: 'raster'
		});
		@@ -523,3 +591,3 @@

		Cut the paper. Optionally a parameter can be specified which can be either be "partial" or "full". If not specified, a full cut will be used.
		Cut the paper. Optionally a parameter can be specified which can be either be "partial" or "full". If not specified, a full cut will be used.

		@@ -530,7 +598,7 @@ let result = encoder

		Note: Not all printer models support cutting paper. And even if they do, they might not support both types of cuts.
		_Note: Not all printer models support cutting paper. And even if they do, they might not support both types of cuts._

		### Pulse

		Send a pulse to an external device, such as a beeper or cash drawer.
		Send a pulse to an external device, such as a beeper or cash drawer.

		@@ -558,6 +626,6 @@ let result = encoder
		.encode()



		## License

		MIT
		MIT

-19

.eslintrc.json

		{
		"parserOptions": {
		"ecmaVersion": 6
		},
		"env": {
		"node": true,
		"es6": true
		},
		"extends": [
		"eslint:recommended",
		"google"
		],
		"rules": {
		"max-len": [
		1,
		120
		]
		}
		}

-1

dist/esc-pos-encoder.js

-239

index.d.ts

		export default class EscPosEncoder {
		/**
		* Initialize the printer
		*
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		initialize(): EscPosEncoder;

		/**
		* Change the code page
		*
		* @param {string} codepage The codepage that we set the printer to
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		codepage(codepage: string): EscPosEncoder;

		/**
		* Print text
		*
		* @param {string} value Text that needs to be printed
		* @param {number} wrap Wrap text after this many positions
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		text(value: string, wrap?: number): EscPosEncoder;

		/**
		* Print a newline
		*
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		newline(): EscPosEncoder;

		/**
		* Print text, followed by a newline
		*
		* @param {string} value Text that needs to be printed
		* @param {number} wrap Wrap text after this many positions
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		line(value: string, wrap?: number): EscPosEncoder;

		/**
		* Underline text
		*
		* @param {boolean\|number} value true to turn on underline, false to turn off, or 2 for double underline
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		underline(value?: boolean \| number): EscPosEncoder;

		/**
		* Italic text
		*
		* @param {boolean} value true to turn on italic, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		italic(value?: boolean): EscPosEncoder;

		/**
		* Bold text
		*
		* @param {boolean} value true to turn on bold, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		bold(value?: boolean): EscPosEncoder;

		/**
		* Change width of text
		*
		* @param {number} width The width of the text, 1 - 8
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		width(width: number): EscPosEncoder;

		/**
		* Change height of text
		*
		* @param {number} height The height of the text, 1 - 8
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		height(height: number): EscPosEncoder;

		/**
		* Invert text
		*
		* @param {boolean} value true to turn on white text on black, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		invert(value: boolean): EscPosEncoder;

		/**
		* Change text size
		*
		* @param {string} value small or normal
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		size(value: string): EscPosEncoder;

		/**
		* Change text alignment
		*
		* @param {string} value left, center or right
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		align(value: string): EscPosEncoder;

		/**
		* Insert a table
		*
		* @param {array} columns The column definitions
		* @param {array} data Array containing rows. Each row is an array containing cells.
		* Each cell can be a string value, or a callback function.
		* The first parameter of the callback is the encoder object on
		* which the function can call its methods.
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		table(columns: any[], data: any[]): EscPosEncoder;

		/**
		* Insert a horizontal rule
		*
		* @param {object} options And object with the following properties:
		* - style: The style of the line, either single or double
		* - width: The width of the line, by default the width of the paper
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		rule(options: Object): EscPosEncoder;

		/**
		* Insert a horizontal rule
		*
		* @param {object} options And object with the following properties:
		* - style: The style of the border, either single or double
		* - width: The width of the box, by default the width of the paper, if specified
		* - marginLeft: Space between the left border and the left side of the paper
		* - marginRight: Space between the right border and the right side of the paper
		* - paddingLeft: Space between the contents and the left border of the box
		* - paddingRight: Space between the contents and the right border of the box
		* @param {string\|function} contents A string value, or a callback function.
		* The first parameter of the callback is the encoder object on
		* which the function can call its methods.
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		box(options: Object, contents: string \| Function): EscPosEncoder;

		/**
		* Barcode
		*
		* @param {string} value the value of the barcode
		* @param {string} symbology the type of the barcode
		* @param {number} height height of the barcode
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		barcode(value: string, symbology: string, height: number): EscPosEncoder;

		/**
		* QR code
		*
		* @param {string} value the value of the qr code
		* @param {number} model model of the qrcode, either 1 or 2
		* @param {number} size size of the qrcode, a value between 1 and 8
		* @param {string} errorlevel the amount of error correction used, either 'l', 'm', 'q', 'h'
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		qrcode(value: string, model?: number, size?: number, errorlevel?: string): EscPosEncoder;

		/**
		* Image
		*
		* @param {object} element an element, like a canvas or image that needs to be printed
		* @param {number} width width of the image on the printer
		* @param {number} height height of the image on the printer
		* @param {string} algorithm the dithering algorithm for making the image black and white
		* @param {number} threshold threshold for the dithering algorithm
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		image(
		element: Object,
		width: number,
		height: number,
		algorithm: string,
		threshold: number
		): EscPosEncoder;

		/**
		* Cut paper
		*
		* @param {string} value full or partial. When not specified a full cut will be assumed
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		cut(value?: string): EscPosEncoder;

		/**
		* Pulse
		*
		* @param {number} device 0 or 1 for on which pin the device is connected, default of 0
		* @param {number} on Time the pulse is on in milliseconds, default of 100
		* @param {number} off Time the pulse is off in milliseconds, default of 500
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		pulse(device?: number, on?: number, off?: number): EscPosEncoder;

		/**
		* Add raw printer commands
		*
		* @param {array} data raw bytes to be included
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		raw(data: any[]): EscPosEncoder;

		/**
		* Encode all previous commands
		*
		* @return {Uint8Array} Return the encoded bytes
		*
		*/
		encode(): Uint8Array;
		}

-1357

src/esc-pos-encoder.js

		const linewrap = require('linewrap');
		const {createCanvas} = require('canvas');
		const Dither = require('canvas-dither');
		const Flatten = require('canvas-flatten');
		const CodepageEncoder = require('codepage-encoder');


		const codepageMappings = {
		epson: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'cp851': 0x0b,
		'cp853': 0x0c,
		'cp857': 0x0d,
		'cp737': 0x0e,
		'iso88597': 0x0f,
		'windows1252': 0x10,
		'cp866': 0x11,
		'cp852': 0x12,
		'cp858': 0x13,
		'cp720': 0x20,
		'cp775': 0x21,
		'cp855': 0x22,
		'cp861': 0x23,
		'cp862': 0x24,
		'cp864': 0x25,
		'cp869': 0x26,
		'iso88592': 0x27,
		'iso885915': 0x28,
		'cp1098': 0x29,
		'cp1118': 0x2a,
		'cp1119': 0x2b,
		'cp1125': 0x2c,
		'windows1250': 0x2d,
		'windows1251': 0x2e,
		'windows1253': 0x2f,
		'windows1254': 0x30,
		'windows1255': 0x31,
		'windows1256': 0x32,
		'windows1257': 0x33,
		'windows1258': 0x34,
		'rk1048': 0x35,
		},

		zjiang: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'windows1252': 0x10,
		'cp866': 0x11,
		'cp852': 0x12,
		'cp858': 0x13,
		'windows1255': 0x20,
		'cp861': 0x38,
		'cp855': 0x3c,
		'cp857': 0x3d,
		'cp862': 0x3e,
		'cp864': 0x3f,
		'cp737': 0x40,
		'cp851': 0x41,
		'cp869': 0x42,
		'cp1119': 0x44,
		'cp1118': 0x45,
		'windows1250': 0x48,
		'windows1251': 0x49,
		'cp3840': 0x4a,
		'cp3843': 0x4c,
		'cp3844': 0x4d,
		'cp3845': 0x4e,
		'cp3846': 0x4f,
		'cp3847': 0x50,
		'cp3848': 0x51,
		'cp2001': 0x53,
		'cp3001': 0x54,
		'cp3002': 0x55,
		'cp3011': 0x56,
		'cp3012': 0x57,
		'cp3021': 0x58,
		'cp3041': 0x59,
		'windows1253': 0x5a,
		'windows1254': 0x5b,
		'windows1256': 0x5c,
		'cp720': 0x5d,
		'windows1258': 0x5e,
		'cp775': 0x5f,
		},

		bixolon: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'cp851': 0x0b,
		'cp858': 0x13,
		},

		star: {
		'cp437': 0x00,
		'shiftjis': 0x01,
		'cp850': 0x02,
		'cp860': 0x03,
		'cp863': 0x04,
		'cp865': 0x05,
		'windows1252': 0x10,
		'cp866': 0x11,
		'cp852': 0x12,
		'cp858': 0x13,
		},

		legacy: {
		'cp437': 0x00,
		'cp737': 0x40,
		'cp850': 0x02,
		'cp775': 0x5f,
		'cp852': 0x12,
		'cp855': 0x3c,
		'cp857': 0x3d,
		'cp858': 0x13,
		'cp860': 0x03,
		'cp861': 0x38,
		'cp862': 0x3e,
		'cp863': 0x04,
		'cp864': 0x1c,
		'cp865': 0x05,
		'cp866': 0x11,
		'cp869': 0x42,
		'cp936': 0xff,
		'cp949': 0xfd,
		'cp950': 0xfe,
		'cp1252': 0x10,
		'iso88596': 0x16,
		'shiftjis': 0xfc,
		'windows874': 0x1e,
		'windows1250': 0x48,
		'windows1251': 0x49,
		'windows1252': 0x47,
		'windows1253': 0x5a,
		'windows1254': 0x5b,
		'windows1255': 0x20,
		'windows1256': 0x5c,
		'windows1257': 0x19,
		'windows1258': 0x5e,
		},
		};


		/**
		* Create a byte stream based on commands for ESC/POS printers
		*/
		class EscPosEncoder {
		/**
		* Create a new object
		*
		* @param {object} options Object containing configuration options
		*/
		constructor(options) {
		this._reset(options);
		}

		/**
		* Reset the state of the object
		*
		* @param {object} options Object containing configuration options
		*/
		_reset(options) {
		this._options = Object.assign({
		width: null,
		embedded: false,
		wordWrap: true,
		imageMode: 'column',
		codepageMapping: 'epson',
		codepageCandidates: [
		'cp437', 'cp858', 'cp860', 'cp861', 'cp863', 'cp865',
		'cp852', 'cp857', 'cp855', 'cp866', 'cp869',
		],
		}, options);

		this._embedded = this._options.width && this._options.embedded;

		this._buffer = [];
		this._queued = [];
		this._cursor = 0;
		this._codepage = 'ascii';

		this._state = {
		'codepage': 0,
		'align': 'left',
		'bold': false,
		'italic': false,
		'underline': false,
		'invert': false,
		'width': 1,
		'height': 1,
		};
		}

		/**
		* Encode a string with the current code page
		*
		* @param {string} value String to encode
		* @return {object} Encoded string as a ArrayBuffer
		*
		*/
		_encode(value) {
		if (this._codepage != 'auto') {
		return CodepageEncoder.encode(this._codepage, value);
		}

		let codepages;

		if (typeof this._options.codepageMapping == 'string') {
		codepages = codepageMappings[this._options.codepageMapping];
		} else {
		codepages = this._options.codepageMapping;
		}

		const fragments = CodepageEncoder.autoEncode(value, this._options.codepageCandidates);

		let length = 0;
		for (let f = 0; f < fragments.length; f++) {
		length += 3 + fragments[f].bytes.byteLength;
		}

		const buffer = new Uint8Array(length);
		let i = 0;

		for (let f = 0; f < fragments.length; f++) {
		buffer.set([0x1b, 0x74, codepages[fragments[f].codepage]], i);
		buffer.set(fragments[f].bytes, i + 3);
		i += 3 + fragments[f].bytes.byteLength;

		this._state.codepage = codepages[fragments[f].codepage];
		}

		return buffer;
		}

		/**
		* Add commands to the queue
		*
		* @param {array} value Add array of numbers, arrays, buffers or Uint8Arrays to add to the buffer
		*
		*/
		_queue(value) {
		value.forEach((item) => this._queued.push(item));
		}

		/**
		* Flush current queue to the buffer
		*
		*/
		_flush() {
		if (this._embedded) {
		let indent = this._options.width - this._cursor;

		if (this._state.align == 'left') {
		this._queued.push((new Array(indent)).fill(0x20));
		}

		if (this._state.align == 'center') {
		const remainder = indent % 2;
		indent = indent >> 1;

		if (indent > 0) {
		this._queued.push((new Array(indent)).fill(0x20));
		}

		if (indent + remainder > 0) {
		this._queued.unshift((new Array(indent + remainder)).fill(0x20));
		}
		}

		if (this._state.align == 'right') {
		this._queued.unshift((new Array(indent)).fill(0x20));
		}
		}

		this._buffer = this._buffer.concat(this._queued);

		this._queued = [];
		this._cursor = 0;
		}

		/**
		* Wrap the text while respecting the position of the cursor
		*
		* @param {string} value String to wrap after the width of the paper has been reached
		* @param {number} position Position on which to force a wrap
		* @return {array} Array with each line
		*/
		_wrap(value, position) {
		if (position \|\| (this._options.wordWrap && this._options.width)) {
		const indent = '-'.repeat(this._cursor);
		const w = linewrap(position \|\| this._options.width, {lineBreak: '\n', whitespace: 'all'});
		const result = w(indent + value).substring(this._cursor).split('\n');

		return result;
		}

		return [value];
		}

		/**
		* Restore styles and codepages after drawing boxes or lines
		*/
		_restoreState() {
		this.bold(this._state.bold);
		this.italic(this._state.italic);
		this.underline(this._state.underline);
		this.invert(this._state.invert);

		this._queue([
		0x1b, 0x74, this._state.codepage,
		]);
		}

		/**
		* Get code page identifier for the specified code page and mapping
		*
		* @param {string} codepage Required code page
		* @return {number} Identifier for the current printer according to the specified mapping
		*/
		_getCodepageIdentifier(codepage) {
		let codepages;

		if (typeof this._options.codepageMapping == 'string') {
		codepages = codepageMappings[this._options.codepageMapping];
		} else {
		codepages = this._options.codepageMapping;
		}

		return codepages[codepage];
		}




		/**
		* Initialize the printer
		*
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		initialize() {
		this._queue([
		0x1b, 0x40,
		]);

		this._flush();

		return this;
		}

		/**
		* Change the code page
		*
		* @param {string} codepage The codepage that we set the printer to
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		codepage(codepage) {
		if (codepage === 'auto') {
		this._codepage = codepage;
		return this;
		}

		if (!CodepageEncoder.supports(codepage)) {
		throw new Error('Unknown codepage');
		}

		let codepages;

		if (typeof this._options.codepageMapping == 'string') {
		codepages = codepageMappings[this._options.codepageMapping];
		} else {
		codepages = this._options.codepageMapping;
		}

		if (typeof codepages[codepage] !== 'undefined') {
		this._codepage = codepage;
		this._state.codepage = codepages[codepage];

		this._queue([
		0x1b, 0x74, codepages[codepage],
		]);
		} else {
		throw new Error('Codepage not supported by printer');
		}

		return this;
		}

		/**
		* Print text
		*
		* @param {string} value Text that needs to be printed
		* @param {number} wrap Wrap text after this many positions
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		text(value, wrap) {
		const lines = this._wrap(value, wrap);

		for (let l = 0; l < lines.length; l++) {
		const bytes = this._encode(lines[l]);

		this._queue([
		bytes,
		]);

		this._cursor += (lines[l].length * this._state.width);

		if (this._options.width && !this._embedded) {
		this._cursor = this._cursor % this._options.width;
		}

		if (l < lines.length - 1) {
		this.newline();
		}
		}

		return this;
		}

		/**
		* Print a newline
		*
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		newline() {
		this._flush();

		this._queue([
		0x0a, 0x0d,
		]);

		if (this._embedded) {
		this._restoreState();
		}

		return this;
		}

		/**
		* Print text, followed by a newline
		*
		* @param {string} value Text that needs to be printed
		* @param {number} wrap Wrap text after this many positions
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		line(value, wrap) {
		this.text(value, wrap);
		this.newline();

		return this;
		}

		/**
		* Underline text
		*
		* @param {boolean\|number} value true to turn on underline, false to turn off, or 2 for double underline
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		underline(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.underline;
		}

		this._state.underline = value;

		this._queue([
		0x1b, 0x2d, Number(value),
		]);

		return this;
		}

		/**
		* Italic text
		*
		* @param {boolean} value true to turn on italic, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		italic(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.italic;
		}

		this._state.italic = value;

		this._queue([
		0x1b, 0x34, Number(value),
		]);

		return this;
		}

		/**
		* Bold text
		*
		* @param {boolean} value true to turn on bold, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		bold(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.bold;
		}

		this._state.bold = value;

		this._queue([
		0x1b, 0x45, Number(value),
		]);

		return this;
		}

		/**
		* Change width of text
		*
		* @param {number} width The width of the text, 1 - 8
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		width(width) {
		if (typeof width === 'undefined') {
		width = 1;
		}

		if (typeof width !== 'number') {
		throw new Error('Width must be a number');
		}

		if (width < 1 \|\| width > 8) {
		throw new Error('Width must be between 1 and 8');
		}

		this._state.width = width;

		this._queue([
		0x1d, 0x21, (this._state.height - 1) \| (this._state.width - 1) << 4,
		]);

		return this;
		}

		/**
		* Change height of text
		*
		* @param {number} height The height of the text, 1 - 8
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		height(height) {
		if (typeof height === 'undefined') {
		height = 1;
		}

		if (typeof height !== 'number') {
		throw new Error('Height must be a number');
		}

		if (height < 1 \|\| height > 8) {
		throw new Error('Height must be between 1 and 8');
		}

		this._state.height = height;

		this._queue([
		0x1d, 0x21, (this._state.height - 1) \| (this._state.width - 1) << 4,
		]);

		return this;
		}

		/**
		* Invert text
		*
		* @param {boolean} value true to turn on white text on black, false to turn off
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		invert(value) {
		if (typeof value === 'undefined') {
		value = ! this._state.invert;
		}

		this._state.invert = value;

		this._queue([
		0x1d, 0x42, Number(value),
		]);

		return this;
		}

		/**
		* Change text size
		*
		* @param {string} value small or normal
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		size(value) {
		if (value === 'small') {
		value = 0x01;
		} else {
		value = 0x00;
		}

		this._queue([
		0x1b, 0x4d, value,
		]);

		return this;
		}

		/**
		* Change text alignment
		*
		* @param {string} value left, center or right
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		align(value) {
		const alignments = {
		'left': 0x00,
		'center': 0x01,
		'right': 0x02,
		};

		if (value in alignments) {
		this._state.align = value;

		if (!this._embedded) {
		this._queue([
		0x1b, 0x61, alignments[value],
		]);
		}
		} else {
		throw new Error('Unknown alignment');
		}

		return this;
		}

		/**
		* Insert a table
		*
		* @param {array} columns The column definitions
		* @param {array} data Array containing rows. Each row is an array containing cells.
		* Each cell can be a string value, or a callback function.
		* The first parameter of the callback is the encoder object on
		* which the function can call its methods.
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		table(columns, data) {
		if (this._cursor != 0) {
		this.newline();
		}

		for (let r = 0; r < data.length; r++) {
		const lines = [];
		let maxLines = 0;

		for (let c = 0; c < columns.length; c++) {
		const cell = [];

		if (typeof data[r][c] === 'string') {
		const w = linewrap(columns[c].width, {lineBreak: '\n'});
		const fragments = w(data[r][c]).split('\n');

		for (let f = 0; f < fragments.length; f++) {
		if (columns[c].align == 'right') {
		cell[f] = this._encode(fragments[f].padStart(columns[c].width));
		} else {
		cell[f] = this._encode(fragments[f].padEnd(columns[c].width));
		}
		}
		}

		if (typeof data[r][c] === 'function') {
		const columnEncoder = new EscPosEncoder(Object.assign({}, this._options, {
		width: columns[c].width,
		embedded: true,
		}));

		columnEncoder._codepage = this._codepage;
		columnEncoder.align(columns[c].align);
		data[r][c](columnEncoder);
		const encoded = columnEncoder.encode();

		let fragment = [];

		for (let e = 0; e < encoded.byteLength; e++) {
		if (e < encoded.byteLength - 1) {
		if (encoded[e] === 0x0a && encoded[e + 1] === 0x0d) {
		cell.push(fragment);
		fragment = [];

		e++;
		continue;
		}
		}

		fragment.push(encoded[e]);
		}

		if (fragment.length) {
		cell.push(fragment);
		}
		}

		maxLines = Math.max(maxLines, cell.length);
		lines[c] = cell;
		}

		for (let c = 0; c < columns.length; c++) {
		if (lines[c].length < maxLines) {
		for (let p = lines[c].length; p < maxLines; p++) {
		let verticalAlign = 'top';
		if (typeof columns[c].verticalAlign !== 'undefined') {
		verticalAlign = columns[c].verticalAlign;
		}

		if (verticalAlign == 'bottom') {
		lines[c].unshift((new Array(columns[c].width)).fill(0x20));
		} else {
		lines[c].push((new Array(columns[c].width)).fill(0x20));
		}
		}
		}
		}

		for (let l = 0; l < maxLines; l++) {
		for (let c = 0; c < columns.length; c++) {
		if (typeof columns[c].marginLeft !== 'undefined') {
		this.raw((new Array(columns[c].marginLeft)).fill(0x20));
		}

		this.raw(lines[c][l]);

		if (typeof columns[c].marginRight !== 'undefined') {
		this.raw((new Array(columns[c].marginRight)).fill(0x20));
		}
		}

		this.newline();
		}
		}

		return this;
		}

		/**
		* Insert a horizontal rule
		*
		* @param {object} options And object with the following properties:
		* - style: The style of the line, either single or double
		* - width: The width of the line, by default the width of the paper
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		rule(options) {
		options = Object.assign({
		style: 'single',
		width: this._options.width \|\| 10,
		}, options \|\| {});

		this._queue([
		0x1b, 0x74, this._getCodepageIdentifier('cp437'),
		(new Array(options.width)).fill(options.style === 'double' ? 0xcd : 0xc4),
		]);

		this._queue([
		0x1b, 0x74, this._state.codepage,
		]);

		this.newline();

		return this;
		}

		/**
		* Insert a horizontal rule
		*
		* @param {object} options And object with the following properties:
		* - style: The style of the border, either single or double
		* - width: The width of the box, by default the width of the paper, if specified
		* - marginLeft: Space between the left border and the left side of the paper
		* - marginRight: Space between the right border and the right side of the paper
		* - paddingLeft: Space between the contents and the left border of the box
		* - paddingRight: Space between the contents and the right border of the box
		* @param {string\|function} contents A string value, or a callback function.
		* The first parameter of the callback is the encoder object on
		* which the function can call its methods.
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		box(options, contents) {
		options = Object.assign({
		style: 'single',
		width: this._options.width \|\| 30,
		marginLeft: 0,
		marginRight: 0,
		paddingLeft: 0,
		paddingRight: 0,
		}, options \|\| {});

		let elements;

		if (options.style == 'double') {
		elements = [0xc9, 0xbb, 0xc8, 0xbc, 0xcd, 0xba]; // ╔╗╚╝═║
		} else {
		elements = [0xda, 0xbf, 0xc0, 0xd9, 0xc4, 0xb3]; // ┌┐└┘─│
		}

		if (this._cursor != 0) {
		this.newline();
		}

		this._restoreState();

		this._queue([
		0x1b, 0x74, this._getCodepageIdentifier('cp437'),
		]);

		this._queue([
		new Array(options.marginLeft).fill(0x20),
		elements[0],
		new Array(options.width - 2).fill(elements[4]),
		elements[1],
		new Array(options.marginRight).fill(0x20),
		]);

		this.newline();

		const cell = [];

		if (typeof contents === 'string') {
		const w = linewrap(options.width - 2 - options.paddingLeft - options.paddingRight, {lineBreak: '\n'});
		const fragments = w(contents).split('\n');

		for (let f = 0; f < fragments.length; f++) {
		if (options.align == 'right') {
		cell[f] = this._encode(fragments[f].padStart(options.width - 2 - options.paddingLeft - options.paddingRight));
		} else {
		cell[f] = this._encode(fragments[f].padEnd(options.width - 2 - options.paddingLeft - options.paddingRight));
		}
		}
		}

		if (typeof contents === 'function') {
		const columnEncoder = new EscPosEncoder(Object.assign({}, this._options, {
		width: options.width - 2 - options.paddingLeft - options.paddingRight,
		embedded: true,
		}));

		columnEncoder._codepage = this._codepage;
		columnEncoder.align(options.align);
		contents(columnEncoder);
		const encoded = columnEncoder.encode();

		let fragment = [];

		for (let e = 0; e < encoded.byteLength; e++) {
		if (e < encoded.byteLength - 1) {
		if (encoded[e] === 0x0a && encoded[e + 1] === 0x0d) {
		cell.push(fragment);
		fragment = [];

		e++;
		continue;
		}
		}

		fragment.push(encoded[e]);
		}

		if (fragment.length) {
		cell.push(fragment);
		}
		}

		for (let c = 0; c < cell.length; c++) {
		this._queue([
		new Array(options.marginLeft).fill(0x20),
		elements[5],
		new Array(options.paddingLeft).fill(0x20),
		]);

		this._queue([
		cell[c],
		]);

		this._restoreState();

		this._queue([
		0x1b, 0x74, this._getCodepageIdentifier('cp437'),
		]);

		this._queue([
		new Array(options.paddingRight).fill(0x20),
		elements[5],
		new Array(options.marginRight).fill(0x20),
		]);

		this.newline();
		}

		this._queue([
		new Array(options.marginLeft).fill(0x20),
		elements[2],
		new Array(options.width - 2).fill(elements[4]),
		elements[3],
		new Array(options.marginRight).fill(0x20),
		]);

		this._restoreState();

		this.newline();

		return this;
		}

		/**
		* Barcode
		*
		* @param {string} value the value of the barcode
		* @param {string} symbology the type of the barcode
		* @param {number} height height of the barcode
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		barcode(value, symbology, height) {
		if (this._embedded) {
		throw new Error('Barcodes are not supported in table cells or boxes');
		}

		const symbologies = {
		'upca': 0x00,
		'upce': 0x01,
		'ean13': 0x02,
		'ean8': 0x03,
		'code39': 0x04,
		'coda39': 0x04, /* typo, leave here for backwards compatibility */
		'itf': 0x05,
		'codabar': 0x06,
		'code93': 0x48,
		'code128': 0x49,
		'gs1-128': 0x50,
		'gs1-databar-omni': 0x51,
		'gs1-databar-truncated': 0x52,
		'gs1-databar-limited': 0x53,
		'gs1-databar-expanded': 0x54,
		'code128-auto': 0x55,
		};

		if (symbology in symbologies) {
		const bytes = CodepageEncoder.encode('ascii', value);

		if (this._cursor != 0) {
		this.newline();
		}

		this._queue([
		0x1d, 0x68, height,
		0x1d, 0x77, symbology === 'code39' ? 0x02 : 0x03,
		]);

		if (symbology == 'code128' && bytes[0] !== 0x7b) {
		/* Not yet encodeded Code 128, assume data is Code B, which is similar to ASCII without control chars */

		this._queue([
		0x1d, 0x6b, symbologies[symbology],
		bytes.length + 2,
		0x7b, 0x42,
		bytes,
		]);
		} else if (symbologies[symbology] > 0x40) {
		/* Function B symbologies */

		this._queue([
		0x1d, 0x6b, symbologies[symbology],
		bytes.length,
		bytes,
		]);
		} else {
		/* Function A symbologies */

		this._queue([
		0x1d, 0x6b, symbologies[symbology],
		bytes,
		0x00,
		]);
		}
		} else {
		throw new Error('Symbology not supported by printer');
		}

		this._flush();

		return this;
		}

		/**
		* QR code
		*
		* @param {string} value the value of the qr code
		* @param {number} model model of the qrcode, either 1 or 2
		* @param {number} size size of the qrcode, a value between 1 and 8
		* @param {string} errorlevel the amount of error correction used, either 'l', 'm', 'q', 'h'
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		qrcode(value, model, size, errorlevel) {
		if (this._embedded) {
		throw new Error('QR codes are not supported in table cells or boxes');
		}

		/* Force printing the print buffer and moving to a new line */

		this._queue([
		0x0a,
		]);

		/* Model */

		const models = {
		1: 0x31,
		2: 0x32,
		};

		if (typeof model === 'undefined') {
		model = 2;
		}

		if (model in models) {
		this._queue([
		0x1d, 0x28, 0x6b, 0x04, 0x00, 0x31, 0x41, models[model], 0x00,
		]);
		} else {
		throw new Error('Model must be 1 or 2');
		}

		/* Size */

		if (typeof size === 'undefined') {
		size = 6;
		}

		if (typeof size !== 'number') {
		throw new Error('Size must be a number');
		}

		if (size < 1 \|\| size > 8) {
		throw new Error('Size must be between 1 and 8');
		}

		this._queue([
		0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x43, size,
		]);

		/* Error level */

		const errorlevels = {
		'l': 0x30,
		'm': 0x31,
		'q': 0x32,
		'h': 0x33,
		};

		if (typeof errorlevel === 'undefined') {
		errorlevel = 'm';
		}

		if (errorlevel in errorlevels) {
		this._queue([
		0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x45, errorlevels[errorlevel],
		]);
		} else {
		throw new Error('Error level must be l, m, q or h');
		}

		/* Data */

		const bytes = CodepageEncoder.encode('iso88591', value);
		const length = bytes.length + 3;

		this._queue([
		0x1d, 0x28, 0x6b, length % 0xff, length / 0xff, 0x31, 0x50, 0x30, bytes,
		]);

		/* Print QR code */

		this._queue([
		0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x51, 0x30,
		]);

		this._flush();

		return this;
		}

		/**
		* Image
		*
		* @param {object} element an element, like a canvas or image that needs to be printed
		* @param {number} width width of the image on the printer
		* @param {number} height height of the image on the printer
		* @param {string} algorithm the dithering algorithm for making the image black and white
		* @param {number} threshold threshold for the dithering algorithm
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		image(element, width, height, algorithm, threshold) {
		if (this._embedded) {
		throw new Error('Images are not supported in table cells or boxes');
		}

		if (width % 8 !== 0) {
		throw new Error('Width must be a multiple of 8');
		}

		if (height % 8 !== 0) {
		throw new Error('Height must be a multiple of 8');
		}

		if (typeof algorithm === 'undefined') {
		algorithm = 'threshold';
		}

		if (typeof threshold === 'undefined') {
		threshold = 128;
		}

		const canvas = createCanvas(width, height);
		const context = canvas.getContext('2d');
		context.drawImage(element, 0, 0, width, height);
		let image = context.getImageData(0, 0, width, height);

		image = Flatten.flatten(image, [0xff, 0xff, 0xff]);

		switch (algorithm) {
		case 'threshold': image = Dither.threshold(image, threshold); break;
		case 'bayer': image = Dither.bayer(image, threshold); break;
		case 'floydsteinberg': image = Dither.floydsteinberg(image); break;
		case 'atkinson': image = Dither.atkinson(image); break;
		}

		const getPixel = (x, y) => x < width && y < height ? (image.data[((width * y) + x) * 4] > 0 ? 0 : 1) : 0;

		const getColumnData = (width, height) => {
		const data = [];

		for (let s = 0; s < Math.ceil(height / 24); s++) {
		const bytes = new Uint8Array(width * 3);

		for (let x = 0; x < width; x++) {
		for (let c = 0; c < 3; c++) {
		for (let b = 0; b < 8; b++) {
		bytes[(x * 3) + c] \|= getPixel(x, (s * 24) + b + (8 * c)) << (7 - b);
		}
		}
		}

		data.push(bytes);
		}

		return data;
		};

		const getRowData = (width, height) => {
		const bytes = new Uint8Array((width * height) >> 3);

		for (let y = 0; y < height; y++) {
		for (let x = 0; x < width; x = x + 8) {
		for (let b = 0; b < 8; b++) {
		bytes[(y * (width >> 3)) + (x >> 3)] \|= getPixel(x + b, y) << (7 - b);
		}
		}
		}

		return bytes;
		};


		if (this._cursor != 0) {
		this.newline();
		}

		/* Encode images with ESC * */

		if (this._options.imageMode == 'column') {
		this._queue([
		0x1b, 0x33, 0x24,
		]);

		getColumnData(width, height).forEach((bytes) => {
		this._queue([
		0x1b, 0x2a, 0x21,
		(width) & 0xff, (((width) >> 8) & 0xff),
		bytes,
		0x0a,
		]);
		});

		this._queue([
		0x1b, 0x32,
		]);
		}

		/* Encode images with GS v */

		if (this._options.imageMode == 'raster') {
		this._queue([
		0x1d, 0x76, 0x30, 0x00,
		(width >> 3) & 0xff, (((width >> 3) >> 8) & 0xff),
		height & 0xff, ((height >> 8) & 0xff),
		getRowData(width, height),
		]);
		}

		this._flush();

		return this;
		}

		/**
		* Cut paper
		*
		* @param {string} value full or partial. When not specified a full cut will be assumed
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		cut(value) {
		if (this._embedded) {
		throw new Error('Cut is not supported in table cells or boxes');
		}

		let data = 0x00;

		if (value == 'partial') {
		data = 0x01;
		}

		this._queue([
		0x1d, 0x56, data,
		]);

		return this;
		}

		/**
		* Pulse
		*
		* @param {number} device 0 or 1 for on which pin the device is connected, default of 0
		* @param {number} on Time the pulse is on in milliseconds, default of 100
		* @param {number} off Time the pulse is off in milliseconds, default of 500
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		pulse(device, on, off) {
		if (this._embedded) {
		throw new Error('Pulse is not supported in table cells or boxes');
		}

		if (typeof device === 'undefined') {
		device = 0;
		}

		if (typeof on === 'undefined') {
		on = 100;
		}

		if (typeof off === 'undefined') {
		off = 500;
		}

		on = Math.min(500, Math.round(on / 2));
		off = Math.min(500, Math.round(off / 2));

		this._queue([
		0x1b, 0x70, device ? 1 : 0, on & 0xff, off & 0xff,
		]);

		return this;
		}

		/**
		* Add raw printer commands
		*
		* @param {array} data raw bytes to be included
		* @return {object} Return the object, for easy chaining commands
		*
		*/
		raw(data) {
		this._queue(data);

		return this;
		}

		/**
		* Encode all previous commands
		*
		* @return {Uint8Array} Return the encoded bytes
		*
		*/
		encode() {
		this._flush();

		let length = 0;

		this._buffer.forEach((item) => {
		if (typeof item === 'number') {
		length++;
		} else {
		length += item.length;
		}
		});

		const result = new Uint8Array(length);

		let index = 0;

		this._buffer.forEach((item) => {
		if (typeof item === 'number') {
		result[index] = item;
		index++;
		} else {
		result.set(item, index);
		index += item.length;
		}
		});

		this._reset();

		return result;
		}
		}

		module.exports = EscPosEncoder;

-295

test/esc-pos-encoder.js

		const EscPosEncoder = require ('../src/esc-pos-encoder');
		const { createCanvas } = require('canvas');

		const chai = require('chai');
		const assert = chai.assert;
		const expect = chai.expect;
		const should = chai.should();


		describe('EscPosEncoder', function() {
		let encoder = new EscPosEncoder();
		let rasterEncoder = new EscPosEncoder({ imageMode: 'raster' });

		describe('text(hello)', function () {
		let result = encoder.text('hello').encode();

		it('should be [ 104, 101, 108, 108, 111 ]', function () {
		assert.deepEqual(new Uint8Array([ 104, 101, 108, 108, 111 ]), result);
		});
		});

		describe('text(hello).newline()', function () {
		let result = encoder.text('hello').newline().encode();

		it('should be [ 104, 101, 108, 108, 111, 10, 13 ]', function () {
		assert.deepEqual(new Uint8Array([ 104, 101, 108, 108, 111, 10, 13 ]), result);
		});
		});

		describe('line(hello)', function () {
		let result = encoder.line('hello').encode();

		it('should be [ 104, 101, 108, 108, 111, 10, 13 ]', function () {
		assert.deepEqual(new Uint8Array([ 104, 101, 108, 108, 111, 10, 13 ]), result);
		});
		});

		describe('text(héllo) - é -> ?', function () {
		let result = encoder.text('héllo').encode();

		it('should be [ 104, 63, 108, 108, 111 ]', function () {
		assert.deepEqual(new Uint8Array([ 104, 63, 108, 108, 111 ]), result);
		});
		});

		describe('codepage(cp437).text(héllo) - é -> 130', function () {
		let result = encoder.codepage('cp437').text('héllo').encode();

		it('should be [ 27, 116, 0, 104, 130, 108, 108, 111 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 116, 0, 104, 130, 108, 108, 111 ]), result);
		});
		});

		describe('codepage(windows1252).text(héllo) - é -> 233', function () {
		let result = encoder.codepage('windows1252').text('héllo').encode();

		it('should be [ 27, 116, 16, 104, 233, 108, 108, 111 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 116, 16, 104, 233, 108, 108, 111 ]), result);
		});
		});

		describe('codepage(unknown).text(héllo)', function () {
		it('should throw an "Unknown codepage" error', function () {
		expect(function(){
		let result = encoder.codepage('unknown').text('héllo').encode();
		}).to.throw('Unknown codepage');
		});
		});

		describe('bold(true).text(hello).bold(false)', function () {
		let result = encoder.bold(true).text('hello').bold(false).encode();

		it('should be [ 27, 69, 1, ..., 27, 69, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 69, 1, 104, 101, 108, 108, 111, 27, 69, 0 ]), result);
		});
		});

		describe('bold().text(hello).bold()', function () {
		let result = encoder.bold().text('hello').bold().encode();

		it('should be [ 27, 69, 1, ..., 27, 69, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 69, 1, 104, 101, 108, 108, 111, 27, 69, 0 ]), result);
		});
		});

		describe('italic().text(hello).italic()', function () {
		let result = encoder.italic().text('hello').italic().encode();

		it('should be [ 27, 69, 1, ..., 27, 69, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 52, 1, 104, 101, 108, 108, 111, 27, 52, 0 ]), result);
		});
		});

		describe('underline(true).text(hello).underline(false)', function () {
		let result = encoder.underline(true).text('hello').underline(false).encode();

		it('should be [ 27, 45, 1, ..., 27, 45, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 45, 1, 104, 101, 108, 108, 111, 27, 45, 0 ]), result);
		});
		});

		describe('underline().text(hello).underline()', function () {
		let result = encoder.underline().text('hello').underline().encode();

		it('should be [ 27, 45, 1, ..., 27, 45, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 45, 1, 104, 101, 108, 108, 111, 27, 45, 0 ]), result);
		});
		});

		describe('invert().text(hello).invert()', function () {
		let result = encoder.invert().text('hello').invert().encode();

		it('should be [ 29, 66, 1, ..., 29, 66, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 66, 1, 104, 101, 108, 108, 111, 29, 66, 0 ]), result);
		});
		});

		describe('width(2).text(hello).width(1)', function () {
		let result = encoder.width(2).text('hello').width(1).encode();

		it('should be [ 29, 33, 16, ..., 29, 33, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 33, 16, 104, 101, 108, 108, 111, 29, 33, 0 ]), result);
		});
		});

		describe('height(2).text(hello).height(1)', function () {
		let result = encoder.height(2).text('hello').height(1).encode();

		it('should be [ 29, 33, 1, ..., 29, 33, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 33, 1, 104, 101, 108, 108, 111, 29, 33, 0 ]), result);
		});
		});

		describe('width(2).height(2).text(hello).width(1).height(1)', function () {
		let result = encoder.width(2).height(2).text('hello').width(1).height(1).encode();

		it('should be [ 29, 33, 16, 29, 33, 17, ..., 29, 33, 1, 29, 33, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 33, 16, 29, 33, 17, 104, 101, 108, 108, 111, 29, 33, 1, 29, 33, 0 ]), result);
		});
		});

		describe('align(left).line(hello)', function () {
		let result = encoder.align('left').line('hello').encode();

		it('should be [ 27, 97, 0, ..., 10, 13 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 97, 0, 104, 101, 108, 108, 111, 10, 13 ]), result);
		});
		});

		describe('align(center).line(hello)', function () {
		let result = encoder.align('center').line('hello').encode();

		it('should be [ 27, 97, 1, ..., 10, 13 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 97, 1, 104, 101, 108, 108, 111, 10, 13 ]), result);
		});
		});

		describe('align(right).line(hello)', function () {
		let result = encoder.align('right').line('hello').encode();

		it('should be [ 27, 97, 2, ..., 10, 13 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 97, 2, 104, 101, 108, 108, 111, 10, 13 ]), result);
		});
		});

		describe('qrcode(https://nielsleenheer.com)', function () {
		let result = encoder.qrcode('https://nielsleenheer.com').encode();

		it('should be [ 10, 29, 40, 107, 4, 0, 49, 65, 50, 0, 29, 40, 107, 3, 0, ... ]', function () {
		assert.deepEqual(new Uint8Array([ 10, 29, 40, 107, 4, 0, 49, 65, 50, 0, 29, 40, 107, 3, 0, 49, 67, 6, 29, 40, 107, 3, 0, 49, 69, 49, 29, 40, 107, 28, 0, 49, 80, 48, 104, 116, 116, 112, 115, 58, 47, 47, 110, 105, 101, 108, 115, 108, 101, 101, 110, 104, 101, 101, 114, 46, 99, 111, 109, 29, 40, 107, 3, 0, 49, 81, 48 ]), result);
		});
		});

		describe('qrcode(https://nielsleenheer.com, 1, 8, h)', function () {
		let result = encoder.qrcode('https://nielsleenheer.com', 1, 8, 'h').encode();

		it('should be [ 10, 29, 40, 107, 4, 0, 49, 65, 49, 0, 29, 40, 107, 3, 0, ... ]', function () {
		assert.deepEqual(new Uint8Array([ 10, 29, 40, 107, 4, 0, 49, 65, 49, 0, 29, 40, 107, 3, 0, 49, 67, 8, 29, 40, 107, 3, 0, 49, 69, 51, 29, 40, 107, 28, 0, 49, 80, 48, 104, 116, 116, 112, 115, 58, 47, 47, 110, 105, 101, 108, 115, 108, 101, 101, 110, 104, 101, 101, 114, 46, 99, 111, 109, 29, 40, 107, 3, 0, 49, 81, 48 ]), result);
		});
		});

		describe('barcode(3130630574613, ean13, 60)', function () {
		let result = encoder.barcode('3130630574613', 'ean13', 60).encode();

		it('should be [ 29, 104, 60, 29, 119, 3, 29, 107, 2, ... ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 104, 60, 29, 119, 3, 29, 107, 2, 51, 49, 51, 48, 54, 51, 48, 53, 55, 52, 54, 49, 51, 0 ]), result);
		});
		});

		describe('barcode(CODE128, code128, 60)', function () {
		let result = encoder.barcode('CODE128', 'code128', 60).encode();

		it('should be [ 29, 104, 60, 29, 119, 3, 29, 107, 73, ... ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 104, 60, 29, 119, 3, 29, 107, 73, 9, 123, 66, 67, 79, 68, 69, 49, 50, 56 ]), result);
		});
		});

		describe('barcode({ACODE128, code128, 60)', function () {
		let result = encoder.barcode('{ACODE128', 'code128', 60).encode();

		it('should be [ 29, 104, 60, 29, 119, 3, 29, 107, 73, ... ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 104, 60, 29, 119, 3, 29, 107, 73, 9, 123, 65, 67, 79, 68, 69, 49, 50, 56 ]), result);
		});
		});

		describe('barcode({BCODE128, code128, 60)', function () {
		let result = encoder.barcode('{BCODE128', 'code128', 60).encode();

		it('should be [ 29, 104, 60, 29, 119, 3, 29, 107, 73, ... ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 104, 60, 29, 119, 3, 29, 107, 73, 9, 123, 66, 67, 79, 68, 69, 49, 50, 56 ]), result);
		});
		});

		describe('barcode({C2Uc#, code128, 60)', function () {
		let result = encoder.barcode('{C2Uc#', 'code128', 60).encode();

		it('should be [ 29, 104, 60, 29, 119, 3, 29, 107, 73, ... ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 104, 60, 29, 119, 3, 29, 107, 73, 6, 123, 67, 50, 85, 99, 35 ]), result);
		});
		});

		describe('image(canvas, 8, 8) - with a black pixel at 0,0 (legacy)', function () {
		let canvas = createCanvas(8, 8);
		let context = canvas.getContext('2d');
		context.fillStyle = 'rgba(0, 0, 0, 1)';
		context.fillRect( 0, 0, 1, 1 );

		let result = rasterEncoder.image(canvas, 8, 8).encode();

		it('should be [ 29, 118, 48, 0, 1, 0, 8, 0, 128, 0, 0, 0, 0, 0, 0, 0 ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 118, 48, 0, 1, 0, 8, 0, 128, 0, 0, 0, 0, 0, 0, 0 ]), result);
		});
		});

		describe('image(canvas, 8, 8) - with a black pixel at 0,0', function () {
		let canvas = createCanvas(8, 8);
		let context = canvas.getContext('2d');
		context.fillStyle = 'rgba(0, 0, 0, 1)';
		context.fillRect( 0, 0, 1, 1 );

		let result = encoder.image(canvas, 8, 8).encode();

		it('should be [ 27, 51, 36, 27, 42, 33, 8, 0, 128, 0, 0, 0, 0, ... ]', function () {
		assert.deepEqual(new Uint8Array([27, 51, 36, 27, 42, 33, 8, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 27, 50]), result);
		});
		});

		describe('pulse()', function () {
		let result = encoder.pulse().encode();

		it('should be [ 27, 112, 0, 50, 250 ]', function () {
		assert.deepEqual(new Uint8Array([ 27, 112, 0, 50, 250 ]), result);
		});
		});

		describe('cut()', function () {
		let result = encoder.cut().encode();

		it('should be [ 29, 86, 00 ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 86, 00 ]), result);
		});
		});

		describe('cut(full)', function () {
		let result = encoder.cut('full').encode();

		it('should be [ 29, 86, 00 ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 86, 00 ]), result);
		});
		});

		describe('cut(partial)', function () {
		let result = encoder.cut('partial').encode();

		it('should be [ 29, 86, 01 ]', function () {
		assert.deepEqual(new Uint8Array([ 29, 86, 01 ]), result);
		});
		});

		describe('raw([ 0x1c, 0x2e ])', function () {
		let result = encoder.raw([ 0x1c, 0x2e ]).encode();

		it('should be [ 28, 46 ]', function () {
		assert.deepEqual(new Uint8Array([ 28, 46 ]), result);
		});
		});

		describe('codepage(auto).text(héψжł)', function () {
		let result = encoder.codepage('auto').text('héψжł').encode();

		it('should be [27, 116, 0, 104, 130, 27, 116, 38, 246, 27, 116, 34, 233, 27, 116, 18, 136]', function () {
		assert.deepEqual(new Uint8Array([27, 116, 0, 104, 130, 27, 116, 38, 246, 27, 116, 34, 233, 27, 116, 18, 136]), result);
		});
		});
		});

@mineminemine/esc-pos-encoder-ionic - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes