Preview: main.cjs
Size: 40.00 KB
/home/byroehnu/.trash/node_modules11/restructure/dist/main.cjs
function $parcel$exportWildcard(dest, source) {
Object.keys(source).forEach(function(key) {
if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
return;
}
Object.defineProperty(dest, key, {
enumerable: true,
get: function get() {
return source[key];
}
});
});
return dest;
}
function $parcel$export(e, n, v, s) {
Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
}
$parcel$export(module.exports, "EncodeStream", () => $1ed46182c1410e1d$export$9b4f661deaa36c3e);
$parcel$export(module.exports, "DecodeStream", () => $8ae20583b93e4933$export$c18b354bac7948e9);
$parcel$export(module.exports, "Array", () => $8ea28a08eae2a116$export$c4be6576ca6fe4aa);
$parcel$export(module.exports, "LazyArray", () => $444f112d3cbc7e9f$export$5576c026028d4983);
$parcel$export(module.exports, "Bitfield", () => $3def237a34a226b5$export$96b43b8a49f688ea);
$parcel$export(module.exports, "Boolean", () => $8415e91bb83faf74$export$ff887cefee4d61ec);
$parcel$export(module.exports, "Buffer", () => $08d28604119af47e$export$7d22a0eea6656474);
$parcel$export(module.exports, "Enum", () => $070ce31ea947467f$export$deb82508dd66d288);
$parcel$export(module.exports, "Optional", () => $80703542fcfb6ff0$export$7acb7b24c478f9c6);
$parcel$export(module.exports, "Reserved", () => $f4fd49878232508a$export$da9b5fe187a9aa1);
$parcel$export(module.exports, "String", () => $d8705cd4022e7dcf$export$89b8e0fa65f6a914);
$parcel$export(module.exports, "Struct", () => $aa8b66bae6abe658$export$eabc71f011df675a);
$parcel$export(module.exports, "VersionedStruct", () => $fcb208a95f6d048b$export$95a8b60f4da7dec8);
// Node back-compat.
const $8ae20583b93e4933$var$ENCODING_MAPPING = {
utf16le: "utf-16le",
ucs2: "utf-16le",
utf16be: "utf-16be"
};
class $8ae20583b93e4933$export$c18b354bac7948e9 {
constructor(buffer){
this.buffer = buffer;
this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
this.pos = 0;
this.length = this.buffer.length;
}
readString(length, encoding = "ascii") {
encoding = $8ae20583b93e4933$var$ENCODING_MAPPING[encoding] || encoding;
let buf = this.readBuffer(length);
try {
let decoder = new TextDecoder(encoding);
return decoder.decode(buf);
} catch (err) {
return buf;
}
}
readBuffer(length) {
return this.buffer.slice(this.pos, this.pos += length);
}
readUInt24BE() {
return (this.readUInt16BE() << 8) + this.readUInt8();
}
readUInt24LE() {
return this.readUInt16LE() + (this.readUInt8() << 16);
}
readInt24BE() {
return (this.readInt16BE() << 8) + this.readUInt8();
}
readInt24LE() {
return this.readUInt16LE() + (this.readInt8() << 16);
}
}
$8ae20583b93e4933$export$c18b354bac7948e9.TYPES = {
UInt8: 1,
UInt16: 2,
UInt24: 3,
UInt32: 4,
Int8: 1,
Int16: 2,
Int24: 3,
Int32: 4,
Float: 4,
Double: 8
};
for (let key of Object.getOwnPropertyNames(DataView.prototype))if (key.slice(0, 3) === "get") {
let type = key.slice(3).replace("Ui", "UI");
if (type === "Float32") type = "Float";
else if (type === "Float64") type = "Double";
let bytes = $8ae20583b93e4933$export$c18b354bac7948e9.TYPES[type];
$8ae20583b93e4933$export$c18b354bac7948e9.prototype["read" + type + (bytes === 1 ? "" : "BE")] = function() {
const ret = this.view[key](this.pos, false);
this.pos += bytes;
return ret;
};
if (bytes !== 1) $8ae20583b93e4933$export$c18b354bac7948e9.prototype["read" + type + "LE"] = function() {
const ret = this.view[key](this.pos, true);
this.pos += bytes;
return ret;
};
}
const $1ed46182c1410e1d$var$textEncoder = new TextEncoder();
const $1ed46182c1410e1d$var$isBigEndian = new Uint8Array(new Uint16Array([
0x1234
]).buffer)[0] == 0x12;
class $1ed46182c1410e1d$export$9b4f661deaa36c3e {
constructor(buffer){
this.buffer = buffer;
this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
this.pos = 0;
}
writeBuffer(buffer) {
this.buffer.set(buffer, this.pos);
this.pos += buffer.length;
}
writeString(string, encoding = "ascii") {
let buf;
switch(encoding){
case "utf16le":
case "utf16-le":
case "ucs2":
buf = $1ed46182c1410e1d$var$stringToUtf16(string, $1ed46182c1410e1d$var$isBigEndian);
break;
case "utf16be":
case "utf16-be":
buf = $1ed46182c1410e1d$var$stringToUtf16(string, !$1ed46182c1410e1d$var$isBigEndian);
break;
case "utf8":
buf = $1ed46182c1410e1d$var$textEncoder.encode(string);
break;
case "ascii":
buf = $1ed46182c1410e1d$var$stringToAscii(string);
break;
default:
throw new Error(`Unsupported encoding: ${encoding}`);
}
this.writeBuffer(buf);
}
writeUInt24BE(val) {
this.buffer[this.pos++] = val >>> 16 & 0xff;
this.buffer[this.pos++] = val >>> 8 & 0xff;
this.buffer[this.pos++] = val & 0xff;
}
writeUInt24LE(val) {
this.buffer[this.pos++] = val & 0xff;
this.buffer[this.pos++] = val >>> 8 & 0xff;
this.buffer[this.pos++] = val >>> 16 & 0xff;
}
writeInt24BE(val) {
if (val >= 0) this.writeUInt24BE(val);
else this.writeUInt24BE(val + 0xffffff + 1);
}
writeInt24LE(val) {
if (val >= 0) this.writeUInt24LE(val);
else this.writeUInt24LE(val + 0xffffff + 1);
}
fill(val, length) {
if (length < this.buffer.length) {
this.buffer.fill(val, this.pos, this.pos + length);
this.pos += length;
} else {
const buf = new Uint8Array(length);
buf.fill(val);
this.writeBuffer(buf);
}
}
}
function $1ed46182c1410e1d$var$stringToUtf16(string, swap) {
let buf = new Uint16Array(string.length);
for(let i = 0; i < string.length; i++){
let code = string.charCodeAt(i);
if (swap) code = code >> 8 | (code & 0xff) << 8;
buf[i] = code;
}
return new Uint8Array(buf.buffer);
}
function $1ed46182c1410e1d$var$stringToAscii(string) {
let buf = new Uint8Array(string.length);
for(let i = 0; i < string.length; i++)// Match node.js behavior - encoding allows 8-bit rather than 7-bit.
buf[i] = string.charCodeAt(i);
return buf;
}
for (let key of Object.getOwnPropertyNames(DataView.prototype))if (key.slice(0, 3) === "set") {
let type = key.slice(3).replace("Ui", "UI");
if (type === "Float32") type = "Float";
else if (type === "Float64") type = "Double";
let bytes = (0, $8ae20583b93e4933$export$c18b354bac7948e9).TYPES[type];
$1ed46182c1410e1d$export$9b4f661deaa36c3e.prototype["write" + type + (bytes === 1 ? "" : "BE")] = function(value) {
this.view[key](this.pos, value, false);
this.pos += bytes;
};
if (bytes !== 1) $1ed46182c1410e1d$export$9b4f661deaa36c3e.prototype["write" + type + "LE"] = function(value) {
this.view[key](this.pos, value, true);
this.pos += bytes;
};
}
class $8d21f7fa58802901$export$ef88aa0d34c34520 {
fromBuffer(buffer) {
let stream = new (0, $8ae20583b93e4933$export$c18b354bac7948e9)(buffer);
return this.decode(stream);
}
toBuffer(value) {
let size = this.size(value);
let buffer = new Uint8Array(size);
let stream = new (0, $1ed46182c1410e1d$export$9b4f661deaa36c3e)(buffer);
this.encode(stream, value);
return buffer;
}
}
var $af65abf7bf65ac42$exports = {};
$parcel$export($af65abf7bf65ac42$exports, "Number", () => $af65abf7bf65ac42$export$fffa67e515d04022);
$parcel$export($af65abf7bf65ac42$exports, "uint8", () => $af65abf7bf65ac42$export$52e103c63c4e68cf);
$parcel$export($af65abf7bf65ac42$exports, "uint16be", () => $af65abf7bf65ac42$export$60dfe43c8297a8f8);
$parcel$export($af65abf7bf65ac42$exports, "uint16", () => $af65abf7bf65ac42$export$56bd24b5a3ee8456);
$parcel$export($af65abf7bf65ac42$exports, "uint16le", () => $af65abf7bf65ac42$export$b92d76f0ca6d1789);
$parcel$export($af65abf7bf65ac42$exports, "uint24be", () => $af65abf7bf65ac42$export$255f45171f96b50c);
$parcel$export($af65abf7bf65ac42$exports, "uint24", () => $af65abf7bf65ac42$export$1925298fbd719b21);
$parcel$export($af65abf7bf65ac42$exports, "uint24le", () => $af65abf7bf65ac42$export$758e1dafc8dc7271);
$parcel$export($af65abf7bf65ac42$exports, "uint32be", () => $af65abf7bf65ac42$export$74c16dba6c885532);
$parcel$export($af65abf7bf65ac42$exports, "uint32", () => $af65abf7bf65ac42$export$de9ffb9418dd7d0d);
$parcel$export($af65abf7bf65ac42$exports, "uint32le", () => $af65abf7bf65ac42$export$5f744bb30a534bc9);
$parcel$export($af65abf7bf65ac42$exports, "int8", () => $af65abf7bf65ac42$export$5984f25eab09961f);
$parcel$export($af65abf7bf65ac42$exports, "int16be", () => $af65abf7bf65ac42$export$198ae7d10d26a900);
$parcel$export($af65abf7bf65ac42$exports, "int16", () => $af65abf7bf65ac42$export$c35c15c7caeff2b6);
$parcel$export($af65abf7bf65ac42$exports, "int16le", () => $af65abf7bf65ac42$export$399cc4b7169e5aed);
$parcel$export($af65abf7bf65ac42$exports, "int24be", () => $af65abf7bf65ac42$export$3676d1f71eca2ec0);
$parcel$export($af65abf7bf65ac42$exports, "int24", () => $af65abf7bf65ac42$export$73f695d681ac61f9);
$parcel$export($af65abf7bf65ac42$exports, "int24le", () => $af65abf7bf65ac42$export$671f8672dbd40a4);
$parcel$export($af65abf7bf65ac42$exports, "int32be", () => $af65abf7bf65ac42$export$78a2ac3d09dd42d5);
$parcel$export($af65abf7bf65ac42$exports, "int32", () => $af65abf7bf65ac42$export$1d95835383bb05a);
$parcel$export($af65abf7bf65ac42$exports, "int32le", () => $af65abf7bf65ac42$export$5ec1f146e759329a);
$parcel$export($af65abf7bf65ac42$exports, "floatbe", () => $af65abf7bf65ac42$export$92b5c14c6abb5c97);
$parcel$export($af65abf7bf65ac42$exports, "float", () => $af65abf7bf65ac42$export$6b5cd3983e3ee5ab);
$parcel$export($af65abf7bf65ac42$exports, "floatle", () => $af65abf7bf65ac42$export$6d20592bc4cb19d9);
$parcel$export($af65abf7bf65ac42$exports, "doublebe", () => $af65abf7bf65ac42$export$e50b9e97e4d43631);
$parcel$export($af65abf7bf65ac42$exports, "double", () => $af65abf7bf65ac42$export$7b3cbda67be88f5f);
$parcel$export($af65abf7bf65ac42$exports, "doublele", () => $af65abf7bf65ac42$export$6f53315aa512b751);
$parcel$export($af65abf7bf65ac42$exports, "Fixed", () => $af65abf7bf65ac42$export$13475bbd2a37a9b4);
$parcel$export($af65abf7bf65ac42$exports, "fixed16be", () => $af65abf7bf65ac42$export$f87b441e6bd90278);
$parcel$export($af65abf7bf65ac42$exports, "fixed16", () => $af65abf7bf65ac42$export$a3abada75ef55921);
$parcel$export($af65abf7bf65ac42$exports, "fixed16le", () => $af65abf7bf65ac42$export$3752a2886837dc22);
$parcel$export($af65abf7bf65ac42$exports, "fixed32be", () => $af65abf7bf65ac42$export$dd71d8d9bc792632);
$parcel$export($af65abf7bf65ac42$exports, "fixed32", () => $af65abf7bf65ac42$export$e913265d48471f2d);
$parcel$export($af65abf7bf65ac42$exports, "fixed32le", () => $af65abf7bf65ac42$export$7fc47db6a5fc8223);
class $af65abf7bf65ac42$export$fffa67e515d04022 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, endian = "BE"){
super();
this.type = type;
this.endian = endian;
this.fn = this.type;
if (this.type[this.type.length - 1] !== "8") this.fn += this.endian;
}
size() {
return (0, $8ae20583b93e4933$export$c18b354bac7948e9).TYPES[this.type];
}
decode(stream) {
return stream[`read${this.fn}`]();
}
encode(stream, val) {
return stream[`write${this.fn}`](val);
}
}
const $af65abf7bf65ac42$export$52e103c63c4e68cf = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt8");
const $af65abf7bf65ac42$export$60dfe43c8297a8f8 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt16", "BE");
const $af65abf7bf65ac42$export$56bd24b5a3ee8456 = $af65abf7bf65ac42$export$60dfe43c8297a8f8;
const $af65abf7bf65ac42$export$b92d76f0ca6d1789 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt16", "LE");
const $af65abf7bf65ac42$export$255f45171f96b50c = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt24", "BE");
const $af65abf7bf65ac42$export$1925298fbd719b21 = $af65abf7bf65ac42$export$255f45171f96b50c;
const $af65abf7bf65ac42$export$758e1dafc8dc7271 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt24", "LE");
const $af65abf7bf65ac42$export$74c16dba6c885532 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt32", "BE");
const $af65abf7bf65ac42$export$de9ffb9418dd7d0d = $af65abf7bf65ac42$export$74c16dba6c885532;
const $af65abf7bf65ac42$export$5f744bb30a534bc9 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt32", "LE");
const $af65abf7bf65ac42$export$5984f25eab09961f = new $af65abf7bf65ac42$export$fffa67e515d04022("Int8");
const $af65abf7bf65ac42$export$198ae7d10d26a900 = new $af65abf7bf65ac42$export$fffa67e515d04022("Int16", "BE");
const $af65abf7bf65ac42$export$c35c15c7caeff2b6 = $af65abf7bf65ac42$export$198ae7d10d26a900;
const $af65abf7bf65ac42$export$399cc4b7169e5aed = new $af65abf7bf65ac42$export$fffa67e515d04022("Int16", "LE");
const $af65abf7bf65ac42$export$3676d1f71eca2ec0 = new $af65abf7bf65ac42$export$fffa67e515d04022("Int24", "BE");
const $af65abf7bf65ac42$export$73f695d681ac61f9 = $af65abf7bf65ac42$export$3676d1f71eca2ec0;
const $af65abf7bf65ac42$export$671f8672dbd40a4 = new $af65abf7bf65ac42$export$fffa67e515d04022("Int24", "LE");
const $af65abf7bf65ac42$export$78a2ac3d09dd42d5 = new $af65abf7bf65ac42$export$fffa67e515d04022("Int32", "BE");
const $af65abf7bf65ac42$export$1d95835383bb05a = $af65abf7bf65ac42$export$78a2ac3d09dd42d5;
const $af65abf7bf65ac42$export$5ec1f146e759329a = new $af65abf7bf65ac42$export$fffa67e515d04022("Int32", "LE");
const $af65abf7bf65ac42$export$92b5c14c6abb5c97 = new $af65abf7bf65ac42$export$fffa67e515d04022("Float", "BE");
const $af65abf7bf65ac42$export$6b5cd3983e3ee5ab = $af65abf7bf65ac42$export$92b5c14c6abb5c97;
const $af65abf7bf65ac42$export$6d20592bc4cb19d9 = new $af65abf7bf65ac42$export$fffa67e515d04022("Float", "LE");
const $af65abf7bf65ac42$export$e50b9e97e4d43631 = new $af65abf7bf65ac42$export$fffa67e515d04022("Double", "BE");
const $af65abf7bf65ac42$export$7b3cbda67be88f5f = $af65abf7bf65ac42$export$e50b9e97e4d43631;
const $af65abf7bf65ac42$export$6f53315aa512b751 = new $af65abf7bf65ac42$export$fffa67e515d04022("Double", "LE");
class $af65abf7bf65ac42$export$13475bbd2a37a9b4 extends $af65abf7bf65ac42$export$fffa67e515d04022 {
constructor(size, endian, fracBits = size >> 1){
super(`Int${size}`, endian);
this._point = 1 << fracBits;
}
decode(stream) {
return super.decode(stream) / this._point;
}
encode(stream, val) {
return super.encode(stream, val * this._point | 0);
}
}
const $af65abf7bf65ac42$export$f87b441e6bd90278 = new $af65abf7bf65ac42$export$13475bbd2a37a9b4(16, "BE");
const $af65abf7bf65ac42$export$a3abada75ef55921 = $af65abf7bf65ac42$export$f87b441e6bd90278;
const $af65abf7bf65ac42$export$3752a2886837dc22 = new $af65abf7bf65ac42$export$13475bbd2a37a9b4(16, "LE");
const $af65abf7bf65ac42$export$dd71d8d9bc792632 = new $af65abf7bf65ac42$export$13475bbd2a37a9b4(32, "BE");
const $af65abf7bf65ac42$export$e913265d48471f2d = $af65abf7bf65ac42$export$dd71d8d9bc792632;
const $af65abf7bf65ac42$export$7fc47db6a5fc8223 = new $af65abf7bf65ac42$export$13475bbd2a37a9b4(32, "LE");
var $4559ecf940edc78d$exports = {};
$parcel$export($4559ecf940edc78d$exports, "resolveLength", () => $4559ecf940edc78d$export$83b6dc3503c1fda6);
$parcel$export($4559ecf940edc78d$exports, "PropertyDescriptor", () => $4559ecf940edc78d$export$41705b1d644e0f14);
function $4559ecf940edc78d$export$83b6dc3503c1fda6(length, stream, parent) {
let res;
if (typeof length === "number") res = length;
else if (typeof length === "function") res = length.call(parent, parent);
else if (parent && typeof length === "string") res = parent[length];
else if (stream && length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) res = length.decode(stream);
if (isNaN(res)) throw new Error("Not a fixed size");
return res;
}
class $4559ecf940edc78d$export$41705b1d644e0f14 {
constructor(opts = {}){
this.enumerable = true;
this.configurable = true;
for(let key in opts){
const val = opts[key];
this[key] = val;
}
}
}
class $8ea28a08eae2a116$export$c4be6576ca6fe4aa extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, length, lengthType = "count"){
super();
this.type = type;
this.length = length;
this.lengthType = lengthType;
}
decode(stream, parent) {
let length;
const { pos: pos } = stream;
const res = [];
let ctx = parent;
if (this.length != null) length = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, stream, parent);
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) {
// define hidden properties
Object.defineProperties(res, {
parent: {
value: parent
},
_startOffset: {
value: pos
},
_currentOffset: {
value: 0,
writable: true
},
_length: {
value: length
}
});
ctx = res;
}
if (length == null || this.lengthType === "bytes") {
const target = length != null ? stream.pos + length : (parent != null ? parent._length : undefined) ? parent._startOffset + parent._length : stream.length;
while(stream.pos < target)res.push(this.type.decode(stream, ctx));
} else for(let i = 0, end = length; i < end; i++)res.push(this.type.decode(stream, ctx));
return res;
}
size(array, ctx, includePointers = true) {
if (!array) return this.type.size(null, ctx) * $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, null, ctx);
let size = 0;
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) {
size += this.length.size();
ctx = {
parent: ctx,
pointerSize: 0
};
}
for (let item of array)size += this.type.size(item, ctx);
if (ctx && includePointers && this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) size += ctx.pointerSize;
return size;
}
encode(stream, array, parent) {
let ctx = parent;
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) {
ctx = {
pointers: [],
startOffset: stream.pos,
parent: parent
};
ctx.pointerOffset = stream.pos + this.size(array, ctx, false);
this.length.encode(stream, array.length);
}
for (let item of array)this.type.encode(stream, item, ctx);
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) {
let i = 0;
while(i < ctx.pointers.length){
const ptr = ctx.pointers[i++];
ptr.type.encode(stream, ptr.val, ptr.parent);
}
}
}
}
class $444f112d3cbc7e9f$export$5576c026028d4983 extends (0, $8ea28a08eae2a116$export$c4be6576ca6fe4aa) {
decode(stream, parent) {
const { pos: pos } = stream;
const length = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, stream, parent);
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) parent = {
parent: parent,
_startOffset: pos,
_currentOffset: 0,
_length: length
};
const res = new $444f112d3cbc7e9f$var$LazyArrayValue(this.type, length, stream, parent);
stream.pos += length * this.type.size(null, parent);
return res;
}
size(val, ctx) {
if (val instanceof $444f112d3cbc7e9f$var$LazyArrayValue) val = val.toArray();
return super.size(val, ctx);
}
encode(stream, val, ctx) {
if (val instanceof $444f112d3cbc7e9f$var$LazyArrayValue) val = val.toArray();
return super.encode(stream, val, ctx);
}
}
class $444f112d3cbc7e9f$var$LazyArrayValue {
constructor(type, length, stream, ctx){
this.type = type;
this.length = length;
this.stream = stream;
this.ctx = ctx;
this.base = this.stream.pos;
this.items = [];
}
get(index) {
if (index < 0 || index >= this.length) return undefined;
if (this.items[index] == null) {
const { pos: pos } = this.stream;
this.stream.pos = this.base + this.type.size(null, this.ctx) * index;
this.items[index] = this.type.decode(this.stream, this.ctx);
this.stream.pos = pos;
}
return this.items[index];
}
toArray() {
const result = [];
for(let i = 0, end = this.length; i < end; i++)result.push(this.get(i));
return result;
}
}
class $3def237a34a226b5$export$96b43b8a49f688ea extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, flags = []){
super();
this.type = type;
this.flags = flags;
}
decode(stream) {
const val = this.type.decode(stream);
const res = {};
for(let i = 0; i < this.flags.length; i++){
const flag = this.flags[i];
if (flag != null) res[flag] = !!(val & 1 << i);
}
return res;
}
size() {
return this.type.size();
}
encode(stream, keys) {
let val = 0;
for(let i = 0; i < this.flags.length; i++){
const flag = this.flags[i];
if (flag != null) {
if (keys[flag]) val |= 1 << i;
}
}
return this.type.encode(stream, val);
}
}
class $8415e91bb83faf74$export$ff887cefee4d61ec extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type){
super();
this.type = type;
}
decode(stream, parent) {
return !!this.type.decode(stream, parent);
}
size(val, parent) {
return this.type.size(val, parent);
}
encode(stream, val, parent) {
return this.type.encode(stream, +val, parent);
}
}
class $08d28604119af47e$export$7d22a0eea6656474 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(length){
super();
this.length = length;
}
decode(stream, parent) {
const length = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, stream, parent);
return stream.readBuffer(length);
}
size(val, parent) {
if (!val) return $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, null, parent);
let len = val.length;
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) len += this.length.size();
return len;
}
encode(stream, buf, parent) {
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) this.length.encode(stream, buf.length);
return stream.writeBuffer(buf);
}
}
class $070ce31ea947467f$export$deb82508dd66d288 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, options = []){
super();
this.type = type;
this.options = options;
}
decode(stream) {
const index = this.type.decode(stream);
return this.options[index] || index;
}
size() {
return this.type.size();
}
encode(stream, val) {
const index = this.options.indexOf(val);
if (index === -1) throw new Error(`Unknown option in enum: ${val}`);
return this.type.encode(stream, index);
}
}
class $80703542fcfb6ff0$export$7acb7b24c478f9c6 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, condition = true){
super();
this.type = type;
this.condition = condition;
}
decode(stream, parent) {
let { condition: condition } = this;
if (typeof condition === "function") condition = condition.call(parent, parent);
if (condition) return this.type.decode(stream, parent);
}
size(val, parent) {
let { condition: condition } = this;
if (typeof condition === "function") condition = condition.call(parent, parent);
if (condition) return this.type.size(val, parent);
else return 0;
}
encode(stream, val, parent) {
let { condition: condition } = this;
if (typeof condition === "function") condition = condition.call(parent, parent);
if (condition) return this.type.encode(stream, val, parent);
}
}
class $f4fd49878232508a$export$da9b5fe187a9aa1 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, count = 1){
super();
this.type = type;
this.count = count;
}
decode(stream, parent) {
stream.pos += this.size(null, parent);
return undefined;
}
size(data, parent) {
const count = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.count, null, parent);
return this.type.size() * count;
}
encode(stream, val, parent) {
return stream.fill(0, this.size(val, parent));
}
}
class $d8705cd4022e7dcf$export$89b8e0fa65f6a914 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(length, encoding = "ascii"){
super();
this.length = length;
this.encoding = encoding;
}
decode(stream, parent) {
let length, pos;
let { encoding: encoding } = this;
if (typeof encoding === "function") encoding = encoding.call(parent, parent) || "ascii";
let width = $d8705cd4022e7dcf$var$encodingWidth(encoding);
if (this.length != null) length = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, stream, parent);
else {
let buffer;
({ buffer: buffer, length: length, pos: pos } = stream);
while(pos < length - width + 1 && (buffer[pos] !== 0x00 || width === 2 && buffer[pos + 1] !== 0x00))pos += width;
length = pos - stream.pos;
}
const string = stream.readString(length, encoding);
if (this.length == null && stream.pos < stream.length) stream.pos += width;
return string;
}
size(val, parent) {
// Use the defined value if no value was given
if (val === undefined || val === null) return $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, null, parent);
let { encoding: encoding } = this;
if (typeof encoding === "function") encoding = encoding.call(parent != null ? parent.val : undefined, parent != null ? parent.val : undefined) || "ascii";
if (encoding === "utf16be") encoding = "utf16le";
let size = $d8705cd4022e7dcf$var$byteLength(val, encoding);
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) size += this.length.size();
if (this.length == null) size += $d8705cd4022e7dcf$var$encodingWidth(encoding);
return size;
}
encode(stream, val, parent) {
let { encoding: encoding } = this;
if (typeof encoding === "function") encoding = encoding.call(parent != null ? parent.val : undefined, parent != null ? parent.val : undefined) || "ascii";
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) this.length.encode(stream, $d8705cd4022e7dcf$var$byteLength(val, encoding));
stream.writeString(val, encoding);
if (this.length == null) return $d8705cd4022e7dcf$var$encodingWidth(encoding) == 2 ? stream.writeUInt16LE(0x0000) : stream.writeUInt8(0x00);
}
}
function $d8705cd4022e7dcf$var$encodingWidth(encoding) {
switch(encoding){
case "ascii":
case "utf8":
return 1;
case "utf16le":
case "utf16-le":
case "utf-16be":
case "utf-16le":
case "utf16be":
case "utf16-be":
case "ucs2":
return 2;
default:
//TODO: assume all other encodings are 1-byters
//throw new Error('Unknown encoding ' + encoding);
return 1;
}
}
function $d8705cd4022e7dcf$var$byteLength(string, encoding) {
switch(encoding){
case "ascii":
return string.length;
case "utf8":
let len = 0;
for(let i = 0; i < string.length; i++){
let c = string.charCodeAt(i);
if (c >= 0xd800 && c <= 0xdbff && i < string.length - 1) {
let c2 = string.charCodeAt(++i);
if ((c2 & 0xfc00) === 0xdc00) c = ((c & 0x3ff) << 10) + (c2 & 0x3ff) + 0x10000;
else // unmatched surrogate.
i--;
}
if ((c & 0xffffff80) === 0) len++;
else if ((c & 0xfffff800) === 0) len += 2;
else if ((c & 0xffff0000) === 0) len += 3;
else if ((c & 0xffe00000) === 0) len += 4;
}
return len;
case "utf16le":
case "utf16-le":
case "utf16be":
case "utf16-be":
case "ucs2":
return string.length * 2;
default:
throw new Error("Unknown encoding " + encoding);
}
}
class $aa8b66bae6abe658$export$eabc71f011df675a extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(fields = {}){
super();
this.fields = fields;
}
decode(stream, parent, length = 0) {
const res = this._setup(stream, parent, length);
this._parseFields(stream, res, this.fields);
if (this.process != null) this.process.call(res, stream);
return res;
}
_setup(stream, parent, length) {
const res = {};
// define hidden properties
Object.defineProperties(res, {
parent: {
value: parent
},
_startOffset: {
value: stream.pos
},
_currentOffset: {
value: 0,
writable: true
},
_length: {
value: length
}
});
return res;
}
_parseFields(stream, res, fields) {
for(let key in fields){
var val;
const type = fields[key];
if (typeof type === "function") val = type.call(res, res);
else val = type.decode(stream, res);
if (val !== undefined) {
if (val instanceof $4559ecf940edc78d$export$41705b1d644e0f14) Object.defineProperty(res, key, val);
else res[key] = val;
}
res._currentOffset = stream.pos - res._startOffset;
}
}
size(val, parent, includePointers = true) {
if (val == null) val = {};
const ctx = {
parent: parent,
val: val,
pointerSize: 0
};
if (this.preEncode != null) this.preEncode.call(val);
let size = 0;
for(let key in this.fields){
const type = this.fields[key];
if (type.size != null) size += type.size(val[key], ctx);
}
if (includePointers) size += ctx.pointerSize;
return size;
}
encode(stream, val, parent) {
let type;
if (this.preEncode != null) this.preEncode.call(val, stream);
const ctx = {
pointers: [],
startOffset: stream.pos,
parent: parent,
val: val,
pointerSize: 0
};
ctx.pointerOffset = stream.pos + this.size(val, ctx, false);
for(let key in this.fields){
type = this.fields[key];
if (type.encode != null) type.encode(stream, val[key], ctx);
}
let i = 0;
while(i < ctx.pointers.length){
const ptr = ctx.pointers[i++];
ptr.type.encode(stream, ptr.val, ptr.parent);
}
}
}
const $fcb208a95f6d048b$var$getPath = (object, pathArray)=>{
return pathArray.reduce((prevObj, key)=>prevObj && prevObj[key], object);
};
class $fcb208a95f6d048b$export$95a8b60f4da7dec8 extends (0, $aa8b66bae6abe658$export$eabc71f011df675a) {
constructor(type, versions = {}){
super();
this.type = type;
this.versions = versions;
if (typeof type === "string") this.versionPath = type.split(".");
}
decode(stream, parent, length = 0) {
const res = this._setup(stream, parent, length);
if (typeof this.type === "string") res.version = $fcb208a95f6d048b$var$getPath(parent, this.versionPath);
else res.version = this.type.decode(stream);
if (this.versions.header) this._parseFields(stream, res, this.versions.header);
const fields = this.versions[res.version];
if (fields == null) throw new Error(`Unknown version ${res.version}`);
if (fields instanceof $fcb208a95f6d048b$export$95a8b60f4da7dec8) return fields.decode(stream, parent);
this._parseFields(stream, res, fields);
if (this.process != null) this.process.call(res, stream);
return res;
}
size(val, parent, includePointers = true) {
let key, type;
if (!val) throw new Error("Not a fixed size");
if (this.preEncode != null) this.preEncode.call(val);
const ctx = {
parent: parent,
val: val,
pointerSize: 0
};
let size = 0;
if (typeof this.type !== "string") size += this.type.size(val.version, ctx);
if (this.versions.header) for(key in this.versions.header){
type = this.versions.header[key];
if (type.size != null) size += type.size(val[key], ctx);
}
const fields = this.versions[val.version];
if (fields == null) throw new Error(`Unknown version ${val.version}`);
for(key in fields){
type = fields[key];
if (type.size != null) size += type.size(val[key], ctx);
}
if (includePointers) size += ctx.pointerSize;
return size;
}
encode(stream, val, parent) {
let key, type;
if (this.preEncode != null) this.preEncode.call(val, stream);
const ctx = {
pointers: [],
startOffset: stream.pos,
parent: parent,
val: val,
pointerSize: 0
};
ctx.pointerOffset = stream.pos + this.size(val, ctx, false);
if (typeof this.type !== "string") this.type.encode(stream, val.version);
if (this.versions.header) for(key in this.versions.header){
type = this.versions.header[key];
if (type.encode != null) type.encode(stream, val[key], ctx);
}
const fields = this.versions[val.version];
for(key in fields){
type = fields[key];
if (type.encode != null) type.encode(stream, val[key], ctx);
}
let i = 0;
while(i < ctx.pointers.length){
const ptr = ctx.pointers[i++];
ptr.type.encode(stream, ptr.val, ptr.parent);
}
}
}
var $92184962f8f0d5e2$exports = {};
$parcel$export($92184962f8f0d5e2$exports, "Pointer", () => $92184962f8f0d5e2$export$b56007f12edf0c17);
$parcel$export($92184962f8f0d5e2$exports, "VoidPointer", () => $92184962f8f0d5e2$export$df5cb1f3d04f5a0f);
class $92184962f8f0d5e2$export$b56007f12edf0c17 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(offsetType, type, options = {}){
super();
this.offsetType = offsetType;
this.type = type;
this.options = options;
if (this.type === "void") this.type = null;
if (this.options.type == null) this.options.type = "local";
if (this.options.allowNull == null) this.options.allowNull = true;
if (this.options.nullValue == null) this.options.nullValue = 0;
if (this.options.lazy == null) this.options.lazy = false;
if (this.options.relativeTo) {
if (typeof this.options.relativeTo !== "function") throw new Error("relativeTo option must be a function");
this.relativeToGetter = options.relativeTo;
}
}
decode(stream, ctx) {
const offset = this.offsetType.decode(stream, ctx);
// handle NULL pointers
if (offset === this.options.nullValue && this.options.allowNull) return null;
let relative;
switch(this.options.type){
case "local":
relative = ctx._startOffset;
break;
case "immediate":
relative = stream.pos - this.offsetType.size();
break;
case "parent":
relative = ctx.parent._startOffset;
break;
default:
var c = ctx;
while(c.parent)c = c.parent;
relative = c._startOffset || 0;
}
if (this.options.relativeTo) relative += this.relativeToGetter(ctx);
const ptr = offset + relative;
if (this.type != null) {
let val = null;
const decodeValue = ()=>{
if (val != null) return val;
const { pos: pos } = stream;
stream.pos = ptr;
val = this.type.decode(stream, ctx);
stream.pos = pos;
return val;
};
// If this is a lazy pointer, define a getter to decode only when needed.
// This obviously only works when the pointer is contained by a Struct.
if (this.options.lazy) return new $4559ecf940edc78d$export$41705b1d644e0f14({
get: decodeValue
});
return decodeValue();
} else return ptr;
}
size(val, ctx) {
const parent = ctx;
switch(this.options.type){
case "local":
case "immediate":
break;
case "parent":
ctx = ctx.parent;
break;
default:
while(ctx.parent)ctx = ctx.parent;
}
let { type: type } = this;
if (type == null) {
if (!(val instanceof $92184962f8f0d5e2$export$df5cb1f3d04f5a0f)) throw new Error("Must be a VoidPointer");
({ type: type } = val);
val = val.value;
}
if (val && ctx) {
// Must be written as two separate lines rather than += in case `type.size` mutates ctx.pointerSize.
let size = type.size(val, parent);
ctx.pointerSize += size;
}
return this.offsetType.size();
}
encode(stream, val, ctx) {
let relative;
const parent = ctx;
if (val == null) {
this.offsetType.encode(stream, this.options.nullValue);
return;
}
switch(this.options.type){
case "local":
relative = ctx.startOffset;
break;
case "immediate":
relative = stream.pos + this.offsetType.size(val, parent);
break;
case "parent":
ctx = ctx.parent;
relative = ctx.startOffset;
break;
default:
relative = 0;
while(ctx.parent)ctx = ctx.parent;
}
if (this.options.relativeTo) relative += this.relativeToGetter(parent.val);
this.offsetType.encode(stream, ctx.pointerOffset - relative);
let { type: type } = this;
if (type == null) {
if (!(val instanceof $92184962f8f0d5e2$export$df5cb1f3d04f5a0f)) throw new Error("Must be a VoidPointer");
({ type: type } = val);
val = val.value;
}
ctx.pointers.push({
type: type,
val: val,
parent: parent
});
return ctx.pointerOffset += type.size(val, parent);
}
}
class $92184962f8f0d5e2$export$df5cb1f3d04f5a0f {
constructor(type, value){
this.type = type;
this.value = value;
}
}
$parcel$exportWildcard(module.exports, $4559ecf940edc78d$exports);
$parcel$exportWildcard(module.exports, $af65abf7bf65ac42$exports);
$parcel$exportWildcard(module.exports, $92184962f8f0d5e2$exports);
//# sourceMappingURL=main.cjs.map
Directory Contents
Dirs: 0 × Files: 2