node-insim
Version:
An InSim library for NodeJS with TypeScript support
441 lines (440 loc) • 14.1 kB
JavaScript
;
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.unpack = exports.pack = exports.determineLength = void 0;
exports.copyBuffer = copyBuffer;
var parse_lfs_message_1 = __importDefault(require("parse-lfs-message"));
var unicode_to_lfs_1 = __importDefault(require("unicode-to-lfs"));
var magic = {
// byte array
A: {
length: 1,
pack: function (dv, value, offset, c) {
if (Array.isArray(value)) {
for (var i = 0; i < c; i++) {
dv.setInt8(offset + i, value[0][i]);
}
}
else {
for (var i = 0; i < c; i++) {
dv.setInt8(offset + i, [value][i]);
}
}
},
unpack: function (dv, offset, c) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getInt8(offset + i));
}
return [r];
},
},
// padding byte
x: {
length: 1,
pack: function (dv, value, offset, c) {
for (var i = 0; i < c; i++) {
dv.setUint8(0, offset + i);
}
},
unpack: function (dv, offset, c) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(0);
}
return r;
},
},
// char
c: {
length: 1,
pack: function (dv, value, offset, c) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setUint8(offset + i, value[i].charCodeAt(0));
}
},
unpack: function (dv, offset, c) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(String.fromCharCode(dv.getUint8(offset + i)));
}
return r;
},
},
// LFS car name string
C: {
length: 4,
pack: function (dv, value, offset) {
if (!Array.isArray(value))
value = [value];
var carName = value[0];
if (isAlphaNumeric(carName[0]) &&
isAlphaNumeric(carName[1]) &&
isAlphaNumeric(carName[2]) &&
carName.length === 3) {
for (var i = 0; i < 3; i++) {
dv.setUint8(offset + i, carName[i].charCodeAt(0));
}
}
else {
dv.setUint8(offset + 2, parseInt("".concat(carName[0]).concat(carName[1]), 16));
dv.setUint8(offset + 1, parseInt("".concat(carName[2]).concat(carName[3]), 16));
dv.setUint8(offset, parseInt("".concat(carName[4]).concat(carName[5]), 16));
}
},
unpack: function (dv, offset) {
var r = [];
for (var i = 0; i < 4; i++)
r.push(String.fromCharCode(dv.getUint8(offset + i)));
if (isAlphaNumeric(r[0]) &&
isAlphaNumeric(r[1]) &&
isAlphaNumeric(r[2]) &&
r[3] === '\x00') {
return [r.slice(0, -1).join('')];
}
return [
__spreadArray([], __read(new Uint8Array(dv.buffer.slice(offset, offset + 3))), false).reverse()
.map(function (x) { return x.toString(16).toUpperCase().padStart(2, '0'); })
.join(''),
];
},
},
// signed char
b: {
length: 1,
pack: function (dv, value, offset, c) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setInt8(offset + i, value[i]);
}
},
unpack: function (dv, offset, c) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getInt8(offset + i));
}
return r;
},
},
// unsigned char
B: {
length: 1,
pack: function (dv, value, offset, c) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setUint8(offset + i, value[i]);
}
},
unpack: function (dv, offset, c) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getUint8(offset + i));
}
return r;
},
},
// signed short
h: {
length: 2,
pack: function (dv, value, offset, c, littleendian) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setInt16(offset + i, value[i], littleendian);
}
},
unpack: function (dv, offset, c, littleendian) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getInt16(offset + i, littleendian));
}
return r;
},
},
// unsigned short
H: {
length: 2,
pack: function (dv, value, offset, c, littleendian) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setUint16(offset + i, value[i], littleendian);
}
},
unpack: function (dv, offset, c, littleendian) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getUint16(offset + i, littleendian));
}
return r;
},
},
// signed long
i: {
length: 4,
pack: function (dv, value, offset, c, littleendian) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setInt32(offset + i, value[i], littleendian);
}
},
unpack: function (dv, offset, c, littleendian) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getInt32(offset + i, littleendian));
}
return r;
},
},
// unsigned long
I: {
length: 4,
pack: function (dv, value, offset, c, littleendian) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setUint32(offset + i, value[i], littleendian);
}
},
unpack: function (dv, offset, c, littleendian) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getUint32(offset + i, littleendian));
}
return r;
},
},
l: {
length: 4,
pack: function (dv, value, offset, c, littleendian) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setInt32(offset + i, value[i], littleendian);
}
},
unpack: function (dv, offset, c, littleendian) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getInt32(offset + i, littleendian));
}
return r;
},
},
// unsigned long
L: {
length: 4,
pack: function (dv, value, offset, c, littleendian) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setUint32(offset + i, value[i], littleendian);
}
},
unpack: function (dv, offset, c, littleendian) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getUint32(offset + i, littleendian));
}
return r;
},
},
// char[]
s: {
length: 1,
pack: function (dv, value, offset, c) {
var val = (0, unicode_to_lfs_1.default)(value[0], {
isNullTerminated: false,
length: c,
});
for (var i = 0; i < c; i++) {
var code = 0;
if (i < val.length)
code = val.charCodeAt(i);
dv.setUint8(offset + i, code);
}
},
unpack: function (dv, offset, c) {
var chars = [];
var bytes = [];
for (var i = 0; i < c; i++) {
chars.push(String.fromCharCode(dv.getUint8(offset + i)));
bytes.push(dv.getUint8(offset + i));
}
return [[chars.join(''), (0, parse_lfs_message_1.default)(new Uint8Array(bytes))]];
},
},
// char[] - null-terminated
S: {
length: 1,
pack: function (dv, value, offset, c) {
var val = (0, unicode_to_lfs_1.default)(value[0], {
isNullTerminated: true,
length: c,
});
for (var i = 0; i < c; i++) {
var code = 0;
if (i < val.length)
code = val.charCodeAt(i);
dv.setUint8(offset + i, code);
}
},
unpack: function (dv, offset, c) {
var chars = [];
var bytes = [];
for (var i = 0; i < c; i++) {
chars.push(String.fromCharCode(dv.getUint8(offset + i)));
bytes.push(dv.getUint8(offset + i));
}
return [[chars.join(''), (0, parse_lfs_message_1.default)(new Uint8Array(bytes))]];
},
},
// float
f: {
length: 4,
pack: function (dv, value, offset, c, littleendian) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setFloat32(offset + i, value[i], littleendian);
}
},
unpack: function (dv, offset, c, littleendian) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getFloat32(offset + i, littleendian));
}
return r;
},
},
// double
d: {
length: 8,
pack: function (dv, value, offset, c, littleendian) {
if (!Array.isArray(value))
value = [value];
for (var i = 0; i < c; i++) {
dv.setFloat64(offset + i, value[i], littleendian);
}
},
unpack: function (dv, offset, c, littleendian) {
var r = [];
for (var i = 0; i < c; i++) {
r.push(dv.getFloat64(offset + i, littleendian));
}
return r;
},
},
};
// pattern of stuff we're looking for
var pattern = '(\\d+)?([AxcCbBhHsSfdiIlL])';
/**
* Determine the size of arraybuffer we'd need
* @internal
*/
var determineLength = function (fmt) {
var re = new RegExp(pattern, 'g');
var m, sum = 0;
while ((m = re.exec(fmt)))
sum +=
(m[1] == undefined || m[1] == '' ? 1 : parseInt(m[1])) *
magic[m[2]].length;
return sum;
};
exports.determineLength = determineLength;
/**
* Pack a set of values, starting at offset, based on format
* @internal
*/
var pack = function (fmt, values, offset) {
if (offset === void 0) { offset = 0; }
var littleendian = fmt.charAt(0) == '<';
offset = offset ? offset : 0;
var ab = new ArrayBuffer(determineLength(fmt)), dv = new DataView(ab), re = new RegExp(pattern, 'g');
var m, c, l, i = 0;
while ((m = re.exec(fmt))) {
if (magic[m[2]] == undefined)
throw new Error('Unknown format type');
c = m[1] == undefined || m[1] == '' ? 1 : parseInt(m[1]);
l = magic[m[2]].length;
if (offset + c * l > ab.byteLength)
return null;
var value = values.slice(i, i + 1);
magic[m[2]].pack(dv, value, offset, c, littleendian);
offset += c * l;
i += 1;
}
return new Uint8Array(dv.buffer);
};
exports.pack = pack;
/**
* Unpack an arraybuffer, starting at offset, based on format
* @internal
*/
var unpack = function (fmt, ab, offset) {
if (offset === void 0) { offset = 0; }
var littleendian = fmt.charAt(0) == '<';
var re = new RegExp(pattern, 'g');
var results = [], m, c, l;
while ((m = re.exec(fmt))) {
if (magic[m[2]] == undefined)
throw new Error('Unknown format type');
c = m[1] == undefined || m[1] == '' ? 1 : parseInt(m[1]);
l = magic[m[2]].length;
if (offset + c * l > ab.byteLength)
return null;
results = results.concat(magic[m[2]].unpack(new DataView(ab), offset, c, littleendian));
offset += c * l;
}
return results;
};
exports.unpack = unpack;
/** @internal */
function isAlphaNumeric(b) {
if (b >= '0' && b <= '9')
return true;
if (b >= 'A' && b <= 'Z')
return true;
if (b >= 'a' && b <= 'z')
return true;
return false;
}
/** @internal */
function copyBuffer(buffer) {
var dest = new ArrayBuffer(buffer.byteLength);
var newBuffer = new Uint8Array(dest);
newBuffer.set(buffer);
return newBuffer;
}