1338 lines
44 KiB
JavaScript
1338 lines
44 KiB
JavaScript
var __bare_os_bundle_exports__ = (() => {
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// ../../node_modules/b4a/index.js
|
|
var require_b4a = __commonJS({
|
|
"../../node_modules/b4a/index.js"(exports, module) {
|
|
function isBuffer(value) {
|
|
return Buffer.isBuffer(value) || value instanceof Uint8Array;
|
|
}
|
|
function isEncoding(encoding) {
|
|
return Buffer.isEncoding(encoding);
|
|
}
|
|
function alloc(size, fill2, encoding) {
|
|
return Buffer.alloc(size, fill2, encoding);
|
|
}
|
|
function allocUnsafe(size) {
|
|
return Buffer.allocUnsafe(size);
|
|
}
|
|
function allocUnsafeSlow(size) {
|
|
return Buffer.allocUnsafeSlow(size);
|
|
}
|
|
function byteLength(string, encoding) {
|
|
return Buffer.byteLength(string, encoding);
|
|
}
|
|
function compare(a, b) {
|
|
return Buffer.compare(a, b);
|
|
}
|
|
function concat(buffers, totalLength) {
|
|
return Buffer.concat(buffers, totalLength);
|
|
}
|
|
function copy(source, target, targetStart, start, end) {
|
|
return toBuffer(source).copy(target, targetStart, start, end);
|
|
}
|
|
function equals(a, b) {
|
|
return toBuffer(a).equals(b);
|
|
}
|
|
function fill(buffer, value, offset, end, encoding) {
|
|
return toBuffer(buffer).fill(value, offset, end, encoding);
|
|
}
|
|
function from(value, encodingOrOffset, length) {
|
|
return Buffer.from(value, encodingOrOffset, length);
|
|
}
|
|
function includes(buffer, value, byteOffset, encoding) {
|
|
return toBuffer(buffer).includes(value, byteOffset, encoding);
|
|
}
|
|
function indexOf(buffer, value, byfeOffset, encoding) {
|
|
return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
|
|
}
|
|
function lastIndexOf(buffer, value, byteOffset, encoding) {
|
|
return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
|
|
}
|
|
function swap16(buffer) {
|
|
return toBuffer(buffer).swap16();
|
|
}
|
|
function swap32(buffer) {
|
|
return toBuffer(buffer).swap32();
|
|
}
|
|
function swap64(buffer) {
|
|
return toBuffer(buffer).swap64();
|
|
}
|
|
function toBuffer(buffer) {
|
|
if (Buffer.isBuffer(buffer)) return buffer;
|
|
return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
}
|
|
function toString(buffer, encoding, start, end) {
|
|
return toBuffer(buffer).toString(encoding, start, end);
|
|
}
|
|
function write(buffer, string, offset, length, encoding) {
|
|
return toBuffer(buffer).write(string, offset, length, encoding);
|
|
}
|
|
function readDoubleBE(buffer, offset) {
|
|
return toBuffer(buffer).readDoubleBE(offset);
|
|
}
|
|
function readDoubleLE(buffer, offset) {
|
|
return toBuffer(buffer).readDoubleLE(offset);
|
|
}
|
|
function readFloatBE(buffer, offset) {
|
|
return toBuffer(buffer).readFloatBE(offset);
|
|
}
|
|
function readFloatLE(buffer, offset) {
|
|
return toBuffer(buffer).readFloatLE(offset);
|
|
}
|
|
function readInt32BE(buffer, offset) {
|
|
return toBuffer(buffer).readInt32BE(offset);
|
|
}
|
|
function readInt32LE(buffer, offset) {
|
|
return toBuffer(buffer).readInt32LE(offset);
|
|
}
|
|
function readUInt32BE(buffer, offset) {
|
|
return toBuffer(buffer).readUInt32BE(offset);
|
|
}
|
|
function readUInt32LE(buffer, offset) {
|
|
return toBuffer(buffer).readUInt32LE(offset);
|
|
}
|
|
function writeDoubleBE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeDoubleBE(value, offset);
|
|
}
|
|
function writeDoubleLE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeDoubleLE(value, offset);
|
|
}
|
|
function writeFloatBE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeFloatBE(value, offset);
|
|
}
|
|
function writeFloatLE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeFloatLE(value, offset);
|
|
}
|
|
function writeInt32BE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeInt32BE(value, offset);
|
|
}
|
|
function writeInt32LE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeInt32LE(value, offset);
|
|
}
|
|
function writeUInt32BE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeUInt32BE(value, offset);
|
|
}
|
|
function writeUInt32LE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeUInt32LE(value, offset);
|
|
}
|
|
module.exports = {
|
|
isBuffer,
|
|
isEncoding,
|
|
alloc,
|
|
allocUnsafe,
|
|
allocUnsafeSlow,
|
|
byteLength,
|
|
compare,
|
|
concat,
|
|
copy,
|
|
equals,
|
|
fill,
|
|
from,
|
|
includes,
|
|
indexOf,
|
|
lastIndexOf,
|
|
swap16,
|
|
swap32,
|
|
swap64,
|
|
toBuffer,
|
|
toString,
|
|
write,
|
|
readDoubleBE,
|
|
readDoubleLE,
|
|
readFloatBE,
|
|
readFloatLE,
|
|
readInt32BE,
|
|
readInt32LE,
|
|
readUInt32BE,
|
|
readUInt32LE,
|
|
writeDoubleBE,
|
|
writeDoubleLE,
|
|
writeFloatBE,
|
|
writeFloatLE,
|
|
writeInt32BE,
|
|
writeInt32LE,
|
|
writeUInt32BE,
|
|
writeUInt32LE
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/compact-encoding/endian.js
|
|
var require_endian = __commonJS({
|
|
"../../node_modules/compact-encoding/endian.js"(exports) {
|
|
var LE = exports.LE = new Uint8Array(new Uint16Array([255]).buffer)[0] === 255;
|
|
exports.BE = !LE;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/compact-encoding/raw.js
|
|
var require_raw = __commonJS({
|
|
"../../node_modules/compact-encoding/raw.js"(exports, module) {
|
|
var b4a = require_b4a();
|
|
var { BE } = require_endian();
|
|
exports = module.exports = {
|
|
preencode(state, b) {
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
state.buffer.set(b, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
const b = state.buffer.subarray(state.start, state.end);
|
|
state.start = state.end;
|
|
return b;
|
|
}
|
|
};
|
|
var buffer = exports.buffer = {
|
|
preencode(state, b) {
|
|
if (b) uint8array.preencode(state, b);
|
|
else state.end++;
|
|
},
|
|
encode(state, b) {
|
|
if (b) uint8array.encode(state, b);
|
|
else state.buffer[state.start++] = 0;
|
|
},
|
|
decode(state) {
|
|
const b = state.buffer.subarray(state.start);
|
|
if (b.byteLength === 0) return null;
|
|
state.start = state.end;
|
|
return b;
|
|
}
|
|
};
|
|
exports.binary = {
|
|
...buffer,
|
|
preencode(state, b) {
|
|
if (typeof b === "string") utf8.preencode(state, b);
|
|
else buffer.preencode(state, b);
|
|
},
|
|
encode(state, b) {
|
|
if (typeof b === "string") utf8.encode(state, b);
|
|
else buffer.encode(state, b);
|
|
}
|
|
};
|
|
exports.arraybuffer = {
|
|
preencode(state, b) {
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
const view = new Uint8Array(b);
|
|
state.buffer.set(view, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
const b = new ArrayBuffer(state.end - state.start);
|
|
const view = new Uint8Array(b);
|
|
view.set(state.buffer.subarray(state.start));
|
|
state.start = state.end;
|
|
return b;
|
|
}
|
|
};
|
|
function typedarray(TypedArray, swap) {
|
|
const n = TypedArray.BYTES_PER_ELEMENT;
|
|
return {
|
|
preencode(state, b) {
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
|
|
if (BE && swap) swap(view);
|
|
state.buffer.set(view, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
let b = state.buffer.subarray(state.start);
|
|
if (b.byteOffset % n !== 0) b = new Uint8Array(b);
|
|
if (BE && swap) swap(b);
|
|
state.start = state.end;
|
|
return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n);
|
|
}
|
|
};
|
|
}
|
|
var uint8array = exports.uint8array = typedarray(Uint8Array);
|
|
exports.uint16array = typedarray(Uint16Array, b4a.swap16);
|
|
exports.uint32array = typedarray(Uint32Array, b4a.swap32);
|
|
exports.int8array = typedarray(Int8Array);
|
|
exports.int16array = typedarray(Int16Array, b4a.swap16);
|
|
exports.int32array = typedarray(Int32Array, b4a.swap32);
|
|
exports.biguint64array = typedarray(BigUint64Array, b4a.swap64);
|
|
exports.bigint64array = typedarray(BigInt64Array, b4a.swap64);
|
|
exports.float32array = typedarray(Float32Array, b4a.swap32);
|
|
exports.float64array = typedarray(Float64Array, b4a.swap64);
|
|
function string(encoding) {
|
|
return {
|
|
preencode(state, s) {
|
|
state.end += b4a.byteLength(s, encoding);
|
|
},
|
|
encode(state, s) {
|
|
state.start += b4a.write(state.buffer, s, state.start, encoding);
|
|
},
|
|
decode(state) {
|
|
const s = b4a.toString(state.buffer, encoding, state.start);
|
|
state.start = state.end;
|
|
return s;
|
|
}
|
|
};
|
|
}
|
|
var utf8 = exports.string = exports.utf8 = string("utf-8");
|
|
exports.ascii = string("ascii");
|
|
exports.hex = string("hex");
|
|
exports.base64 = string("base64");
|
|
exports.ucs2 = exports.utf16le = string("utf16le");
|
|
exports.array = function array(enc) {
|
|
return {
|
|
preencode(state, list) {
|
|
for (const value of list) enc.preencode(state, value);
|
|
},
|
|
encode(state, list) {
|
|
for (const value of list) enc.encode(state, value);
|
|
},
|
|
decode(state) {
|
|
const arr = [];
|
|
while (state.start < state.end) arr.push(enc.decode(state));
|
|
return arr;
|
|
}
|
|
};
|
|
};
|
|
exports.json = {
|
|
preencode(state, v) {
|
|
utf8.preencode(state, JSON.stringify(v));
|
|
},
|
|
encode(state, v) {
|
|
utf8.encode(state, JSON.stringify(v));
|
|
},
|
|
decode(state) {
|
|
return JSON.parse(utf8.decode(state));
|
|
}
|
|
};
|
|
exports.ndjson = {
|
|
preencode(state, v) {
|
|
utf8.preencode(state, JSON.stringify(v) + "\n");
|
|
},
|
|
encode(state, v) {
|
|
utf8.encode(state, JSON.stringify(v) + "\n");
|
|
},
|
|
decode(state) {
|
|
return JSON.parse(utf8.decode(state));
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/compact-encoding/lexint.js
|
|
var require_lexint = __commonJS({
|
|
"../../node_modules/compact-encoding/lexint.js"(exports, module) {
|
|
module.exports = {
|
|
preencode,
|
|
encode,
|
|
decode
|
|
};
|
|
function preencode(state, num) {
|
|
if (num < 251) {
|
|
state.end++;
|
|
} else if (num < 256) {
|
|
state.end += 2;
|
|
} else if (num < 65536) {
|
|
state.end += 3;
|
|
} else if (num < 16777216) {
|
|
state.end += 4;
|
|
} else if (num < 4294967296) {
|
|
state.end += 5;
|
|
} else {
|
|
state.end++;
|
|
const exp = Math.floor(Math.log(num) / Math.log(2)) - 32;
|
|
preencode(state, exp);
|
|
state.end += 6;
|
|
}
|
|
}
|
|
function encode(state, num) {
|
|
const max = 251;
|
|
const x = num - max;
|
|
if (num < max) {
|
|
state.buffer[state.start++] = num;
|
|
} else if (num < 256) {
|
|
state.buffer[state.start++] = max;
|
|
state.buffer[state.start++] = x;
|
|
} else if (num < 65536) {
|
|
state.buffer[state.start++] = max + 1;
|
|
state.buffer[state.start++] = x >> 8 & 255;
|
|
state.buffer[state.start++] = x & 255;
|
|
} else if (num < 16777216) {
|
|
state.buffer[state.start++] = max + 2;
|
|
state.buffer[state.start++] = x >> 16;
|
|
state.buffer[state.start++] = x >> 8 & 255;
|
|
state.buffer[state.start++] = x & 255;
|
|
} else if (num < 4294967296) {
|
|
state.buffer[state.start++] = max + 3;
|
|
state.buffer[state.start++] = x >> 24;
|
|
state.buffer[state.start++] = x >> 16 & 255;
|
|
state.buffer[state.start++] = x >> 8 & 255;
|
|
state.buffer[state.start++] = x & 255;
|
|
} else {
|
|
const exp = Math.floor(Math.log(x) / Math.log(2)) - 32;
|
|
state.buffer[state.start++] = 255;
|
|
encode(state, exp);
|
|
const rem = x / Math.pow(2, exp - 11);
|
|
for (let i = 5; i >= 0; i--) {
|
|
state.buffer[state.start++] = rem / Math.pow(2, 8 * i) & 255;
|
|
}
|
|
}
|
|
}
|
|
function decode(state) {
|
|
const max = 251;
|
|
if (state.end - state.start < 1) throw new Error("Out of bounds");
|
|
const flag = state.buffer[state.start++];
|
|
if (flag < max) return flag;
|
|
if (state.end - state.start < flag - max + 1) {
|
|
throw new Error("Out of bounds.");
|
|
}
|
|
if (flag < 252) {
|
|
return state.buffer[state.start++] + max;
|
|
}
|
|
if (flag < 253) {
|
|
return (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
|
|
}
|
|
if (flag < 254) {
|
|
return (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
|
|
}
|
|
if (flag < 255) {
|
|
return state.buffer[state.start++] * 16777216 + (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
|
|
}
|
|
const exp = decode(state);
|
|
if (state.end - state.start < 6) throw new Error("Out of bounds");
|
|
let rem = 0;
|
|
for (let i = 5; i >= 0; i--) {
|
|
rem += state.buffer[state.start++] * Math.pow(2, 8 * i);
|
|
}
|
|
return rem * Math.pow(2, exp - 11) + max;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/compact-encoding/index.js
|
|
var require_compact_encoding = __commonJS({
|
|
"../../node_modules/compact-encoding/index.js"(exports) {
|
|
var b4a = require_b4a();
|
|
var { BE } = require_endian();
|
|
exports.state = function(start = 0, end = 0, buffer2 = null) {
|
|
return { start, end, buffer: buffer2 };
|
|
};
|
|
var raw = exports.raw = require_raw();
|
|
var uint = exports.uint = {
|
|
preencode(state, n) {
|
|
state.end += n <= 252 ? 1 : n <= 65535 ? 3 : n <= 4294967295 ? 5 : 9;
|
|
},
|
|
encode(state, n) {
|
|
if (n <= 252) uint8.encode(state, n);
|
|
else if (n <= 65535) {
|
|
state.buffer[state.start++] = 253;
|
|
uint16.encode(state, n);
|
|
} else if (n <= 4294967295) {
|
|
state.buffer[state.start++] = 254;
|
|
uint32.encode(state, n);
|
|
} else {
|
|
state.buffer[state.start++] = 255;
|
|
uint64.encode(state, n);
|
|
}
|
|
},
|
|
decode(state) {
|
|
const a = uint8.decode(state);
|
|
if (a <= 252) return a;
|
|
if (a === 253) return uint16.decode(state);
|
|
if (a === 254) return uint32.decode(state);
|
|
return uint64.decode(state);
|
|
}
|
|
};
|
|
var uint8 = exports.uint8 = {
|
|
preencode(state, n) {
|
|
state.end += 1;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
state.buffer[state.start++] = n;
|
|
},
|
|
decode(state) {
|
|
if (state.start >= state.end) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++];
|
|
}
|
|
};
|
|
var uint16 = exports.uint16 = {
|
|
preencode(state, n) {
|
|
state.end += 2;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
state.buffer[state.start++] = n;
|
|
state.buffer[state.start++] = n >>> 8;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 2) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++] + state.buffer[state.start++] * 256;
|
|
}
|
|
};
|
|
var uint24 = exports.uint24 = {
|
|
preencode(state, n) {
|
|
state.end += 3;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
state.buffer[state.start++] = n;
|
|
state.buffer[state.start++] = n >>> 8;
|
|
state.buffer[state.start++] = n >>> 16;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 3) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++] + state.buffer[state.start++] * 256 + state.buffer[state.start++] * 65536;
|
|
}
|
|
};
|
|
var uint32 = exports.uint32 = {
|
|
preencode(state, n) {
|
|
state.end += 4;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
state.buffer[state.start++] = n;
|
|
state.buffer[state.start++] = n >>> 8;
|
|
state.buffer[state.start++] = n >>> 16;
|
|
state.buffer[state.start++] = n >>> 24;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 4) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++] + state.buffer[state.start++] * 256 + state.buffer[state.start++] * 65536 + state.buffer[state.start++] * 16777216;
|
|
}
|
|
};
|
|
var uint40 = exports.uint40 = {
|
|
preencode(state, n) {
|
|
state.end += 5;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
const r = Math.floor(n / 256);
|
|
uint8.encode(state, n);
|
|
uint32.encode(state, r);
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 5) throw new Error("Out of bounds");
|
|
return uint8.decode(state) + 256 * uint32.decode(state);
|
|
}
|
|
};
|
|
var uint48 = exports.uint48 = {
|
|
preencode(state, n) {
|
|
state.end += 6;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
const r = Math.floor(n / 65536);
|
|
uint16.encode(state, n);
|
|
uint32.encode(state, r);
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 6) throw new Error("Out of bounds");
|
|
return uint16.decode(state) + 65536 * uint32.decode(state);
|
|
}
|
|
};
|
|
var uint56 = exports.uint56 = {
|
|
preencode(state, n) {
|
|
state.end += 7;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
const r = Math.floor(n / 16777216);
|
|
uint24.encode(state, n);
|
|
uint32.encode(state, r);
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 7) throw new Error("Out of bounds");
|
|
return uint24.decode(state) + 16777216 * uint32.decode(state);
|
|
}
|
|
};
|
|
var uint64 = exports.uint64 = {
|
|
preencode(state, n) {
|
|
state.end += 8;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
const r = Math.floor(n / 4294967296);
|
|
uint32.encode(state, n);
|
|
uint32.encode(state, r);
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 8) throw new Error("Out of bounds");
|
|
return uint32.decode(state) + 4294967296 * uint32.decode(state);
|
|
}
|
|
};
|
|
var int = exports.int = zigZagInt(uint);
|
|
exports.int8 = zigZagInt(uint8);
|
|
exports.int16 = zigZagInt(uint16);
|
|
exports.int24 = zigZagInt(uint24);
|
|
exports.int32 = zigZagInt(uint32);
|
|
exports.int40 = zigZagInt(uint40);
|
|
exports.int48 = zigZagInt(uint48);
|
|
exports.int56 = zigZagInt(uint56);
|
|
exports.int64 = zigZagInt(uint64);
|
|
var biguint64 = exports.biguint64 = {
|
|
preencode(state, n) {
|
|
state.end += 8;
|
|
},
|
|
encode(state, n) {
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8
|
|
);
|
|
view.setBigUint64(0, n, true);
|
|
state.start += 8;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 8) throw new Error("Out of bounds");
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8
|
|
);
|
|
const n = view.getBigUint64(0, true);
|
|
state.start += 8;
|
|
return n;
|
|
}
|
|
};
|
|
exports.bigint64 = zigZagBigInt(biguint64);
|
|
var biguint = exports.biguint = {
|
|
preencode(state, n) {
|
|
let len = 0;
|
|
for (let m = n; m; m = m >> 64n) len++;
|
|
uint.preencode(state, len);
|
|
state.end += 8 * len;
|
|
},
|
|
encode(state, n) {
|
|
let len = 0;
|
|
for (let m = n; m; m = m >> 64n) len++;
|
|
uint.encode(state, len);
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8 * len
|
|
);
|
|
for (let m = n, i = 0; m; m = m >> 64n, i += 8) {
|
|
view.setBigUint64(i, BigInt.asUintN(64, m), true);
|
|
}
|
|
state.start += 8 * len;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
if (state.end - state.start < 8 * len) throw new Error("Out of bounds");
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8 * len
|
|
);
|
|
let n = 0n;
|
|
for (let i = len - 1; i >= 0; i--)
|
|
n = (n << 64n) + view.getBigUint64(i * 8, true);
|
|
state.start += 8 * len;
|
|
return n;
|
|
}
|
|
};
|
|
exports.bigint = zigZagBigInt(biguint);
|
|
exports.lexint = require_lexint();
|
|
exports.float32 = {
|
|
preencode(state, n) {
|
|
state.end += 4;
|
|
},
|
|
encode(state, n) {
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
4
|
|
);
|
|
view.setFloat32(0, n, true);
|
|
state.start += 4;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 4) throw new Error("Out of bounds");
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
4
|
|
);
|
|
const float = view.getFloat32(0, true);
|
|
state.start += 4;
|
|
return float;
|
|
}
|
|
};
|
|
exports.float64 = {
|
|
preencode(state, n) {
|
|
state.end += 8;
|
|
},
|
|
encode(state, n) {
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8
|
|
);
|
|
view.setFloat64(0, n, true);
|
|
state.start += 8;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 8) throw new Error("Out of bounds");
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8
|
|
);
|
|
const float = view.getFloat64(0, true);
|
|
state.start += 8;
|
|
return float;
|
|
}
|
|
};
|
|
var buffer = exports.buffer = {
|
|
preencode(state, b) {
|
|
if (b) uint8array.preencode(state, b);
|
|
else state.end++;
|
|
},
|
|
encode(state, b) {
|
|
if (b) uint8array.encode(state, b);
|
|
else state.buffer[state.start++] = 0;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
if (len === 0) return null;
|
|
if (state.end - state.start < len) throw new Error("Out of bounds");
|
|
return state.buffer.subarray(state.start, state.start += len);
|
|
}
|
|
};
|
|
exports.binary = {
|
|
...buffer,
|
|
preencode(state, b) {
|
|
if (typeof b === "string") utf8.preencode(state, b);
|
|
else buffer.preencode(state, b);
|
|
},
|
|
encode(state, b) {
|
|
if (typeof b === "string") utf8.encode(state, b);
|
|
else buffer.encode(state, b);
|
|
}
|
|
};
|
|
exports.arraybuffer = {
|
|
preencode(state, b) {
|
|
uint.preencode(state, b.byteLength);
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
uint.encode(state, b.byteLength);
|
|
const view = new Uint8Array(b);
|
|
state.buffer.set(view, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
const b = new ArrayBuffer(len);
|
|
const view = new Uint8Array(b);
|
|
view.set(state.buffer.subarray(state.start, state.start += len));
|
|
return b;
|
|
}
|
|
};
|
|
function typedarray(TypedArray, swap) {
|
|
const n = TypedArray.BYTES_PER_ELEMENT;
|
|
return {
|
|
preencode(state, b) {
|
|
uint.preencode(state, b.length);
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
uint.encode(state, b.length);
|
|
const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
|
|
if (BE && swap) swap(view);
|
|
state.buffer.set(view, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
let b = state.buffer.subarray(state.start, state.start += len * n);
|
|
if (b.byteLength !== len * n) throw new Error("Out of bounds");
|
|
if (b.byteOffset % n !== 0) b = new Uint8Array(b);
|
|
if (BE && swap) swap(b);
|
|
return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n);
|
|
}
|
|
};
|
|
}
|
|
var uint8array = exports.uint8array = typedarray(Uint8Array);
|
|
exports.uint16array = typedarray(Uint16Array, b4a.swap16);
|
|
exports.uint32array = typedarray(Uint32Array, b4a.swap32);
|
|
exports.int8array = typedarray(Int8Array);
|
|
exports.int16array = typedarray(Int16Array, b4a.swap16);
|
|
exports.int32array = typedarray(Int32Array, b4a.swap32);
|
|
exports.biguint64array = typedarray(BigUint64Array, b4a.swap64);
|
|
exports.bigint64array = typedarray(BigInt64Array, b4a.swap64);
|
|
exports.float32array = typedarray(Float32Array, b4a.swap32);
|
|
exports.float64array = typedarray(Float64Array, b4a.swap64);
|
|
function string(encoding) {
|
|
return {
|
|
preencode(state, s) {
|
|
const len = b4a.byteLength(s, encoding);
|
|
uint.preencode(state, len);
|
|
state.end += len;
|
|
},
|
|
encode(state, s) {
|
|
const len = b4a.byteLength(s, encoding);
|
|
uint.encode(state, len);
|
|
b4a.write(state.buffer, s, state.start, encoding);
|
|
state.start += len;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
if (state.end - state.start < len) throw new Error("Out of bounds");
|
|
return b4a.toString(
|
|
state.buffer,
|
|
encoding,
|
|
state.start,
|
|
state.start += len
|
|
);
|
|
},
|
|
fixed(n) {
|
|
return {
|
|
preencode(state) {
|
|
state.end += n;
|
|
},
|
|
encode(state, s) {
|
|
b4a.write(state.buffer, s, state.start, n, encoding);
|
|
state.start += n;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < n) throw new Error("Out of bounds");
|
|
return b4a.toString(
|
|
state.buffer,
|
|
encoding,
|
|
state.start,
|
|
state.start += n
|
|
);
|
|
}
|
|
};
|
|
}
|
|
};
|
|
}
|
|
var utf8 = exports.string = exports.utf8 = string("utf-8");
|
|
exports.ascii = string("ascii");
|
|
exports.hex = string("hex");
|
|
exports.base64 = string("base64");
|
|
exports.ucs2 = exports.utf16le = string("utf16le");
|
|
exports.bool = {
|
|
preencode(state, b) {
|
|
state.end++;
|
|
},
|
|
encode(state, b) {
|
|
state.buffer[state.start++] = b ? 1 : 0;
|
|
},
|
|
decode(state) {
|
|
if (state.start >= state.end) throw Error("Out of bounds");
|
|
return state.buffer[state.start++] === 1;
|
|
}
|
|
};
|
|
var fixed = exports.fixed = function fixed2(n) {
|
|
return {
|
|
preencode(state, s) {
|
|
if (s.byteLength !== n) throw new Error("Incorrect buffer size");
|
|
state.end += n;
|
|
},
|
|
encode(state, s) {
|
|
state.buffer.set(s, state.start);
|
|
state.start += n;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < n) throw new Error("Out of bounds");
|
|
return state.buffer.subarray(state.start, state.start += n);
|
|
}
|
|
};
|
|
};
|
|
exports.fixed32 = fixed(32);
|
|
exports.fixed64 = fixed(64);
|
|
exports.array = function array(enc) {
|
|
return {
|
|
preencode(state, list) {
|
|
uint.preencode(state, list.length);
|
|
for (let i = 0; i < list.length; i++) enc.preencode(state, list[i]);
|
|
},
|
|
encode(state, list) {
|
|
uint.encode(state, list.length);
|
|
for (let i = 0; i < list.length; i++) enc.encode(state, list[i]);
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
if (len > 1048576) throw new Error("Array is too big");
|
|
const arr = new Array(len);
|
|
for (let i = 0; i < len; i++) arr[i] = enc.decode(state);
|
|
return arr;
|
|
}
|
|
};
|
|
};
|
|
exports.frame = function frame(enc) {
|
|
const dummy = exports.state();
|
|
return {
|
|
preencode(state, m) {
|
|
const end = state.end;
|
|
enc.preencode(state, m);
|
|
uint.preencode(state, state.end - end);
|
|
},
|
|
encode(state, m) {
|
|
dummy.end = 0;
|
|
enc.preencode(dummy, m);
|
|
uint.encode(state, dummy.end);
|
|
enc.encode(state, m);
|
|
},
|
|
decode(state) {
|
|
const end = state.end;
|
|
const len = uint.decode(state);
|
|
state.end = state.start + len;
|
|
const m = enc.decode(state);
|
|
state.start = state.end;
|
|
state.end = end;
|
|
return m;
|
|
}
|
|
};
|
|
};
|
|
exports.date = {
|
|
preencode(state, d) {
|
|
int.preencode(state, d.getTime());
|
|
},
|
|
encode(state, d) {
|
|
int.encode(state, d.getTime());
|
|
},
|
|
decode(state, d) {
|
|
return new Date(int.decode(state));
|
|
}
|
|
};
|
|
exports.json = {
|
|
preencode(state, v) {
|
|
utf8.preencode(state, JSON.stringify(v));
|
|
},
|
|
encode(state, v) {
|
|
utf8.encode(state, JSON.stringify(v));
|
|
},
|
|
decode(state) {
|
|
return JSON.parse(utf8.decode(state));
|
|
}
|
|
};
|
|
exports.ndjson = {
|
|
preencode(state, v) {
|
|
utf8.preencode(state, JSON.stringify(v) + "\n");
|
|
},
|
|
encode(state, v) {
|
|
utf8.encode(state, JSON.stringify(v) + "\n");
|
|
},
|
|
decode(state) {
|
|
return JSON.parse(utf8.decode(state));
|
|
}
|
|
};
|
|
exports.none = {
|
|
preencode(state, n) {
|
|
},
|
|
encode(state, n) {
|
|
},
|
|
decode(state) {
|
|
return null;
|
|
}
|
|
};
|
|
var anyArray = {
|
|
preencode(state, arr) {
|
|
uint.preencode(state, arr.length);
|
|
for (let i = 0; i < arr.length; i++) {
|
|
any.preencode(state, arr[i]);
|
|
}
|
|
},
|
|
encode(state, arr) {
|
|
uint.encode(state, arr.length);
|
|
for (let i = 0; i < arr.length; i++) {
|
|
any.encode(state, arr[i]);
|
|
}
|
|
},
|
|
decode(state) {
|
|
const arr = [];
|
|
let len = uint.decode(state);
|
|
while (len-- > 0) {
|
|
arr.push(any.decode(state));
|
|
}
|
|
return arr;
|
|
}
|
|
};
|
|
var anyObject = {
|
|
preencode(state, o) {
|
|
const keys = Object.keys(o);
|
|
uint.preencode(state, keys.length);
|
|
for (const key of keys) {
|
|
utf8.preencode(state, key);
|
|
any.preencode(state, o[key]);
|
|
}
|
|
},
|
|
encode(state, o) {
|
|
const keys = Object.keys(o);
|
|
uint.encode(state, keys.length);
|
|
for (const key of keys) {
|
|
utf8.encode(state, key);
|
|
any.encode(state, o[key]);
|
|
}
|
|
},
|
|
decode(state) {
|
|
let len = uint.decode(state);
|
|
const o = {};
|
|
while (len-- > 0) {
|
|
const key = utf8.decode(state);
|
|
o[key] = any.decode(state);
|
|
}
|
|
return o;
|
|
}
|
|
};
|
|
var anyTypes = [
|
|
exports.none,
|
|
exports.bool,
|
|
exports.string,
|
|
exports.buffer,
|
|
exports.uint,
|
|
exports.int,
|
|
exports.float64,
|
|
anyArray,
|
|
anyObject,
|
|
exports.date
|
|
];
|
|
var any = exports.any = {
|
|
preencode(state, o) {
|
|
const t = getType(o);
|
|
uint.preencode(state, t);
|
|
anyTypes[t].preencode(state, o);
|
|
},
|
|
encode(state, o) {
|
|
const t = getType(o);
|
|
uint.encode(state, t);
|
|
anyTypes[t].encode(state, o);
|
|
},
|
|
decode(state) {
|
|
const t = uint.decode(state);
|
|
if (t >= anyTypes.length) throw new Error("Unknown type: " + t);
|
|
return anyTypes[t].decode(state);
|
|
}
|
|
};
|
|
var port = exports.port = uint16;
|
|
var address = (host, family) => {
|
|
return {
|
|
preencode(state, m) {
|
|
host.preencode(state, m.host);
|
|
port.preencode(state, m.port);
|
|
},
|
|
encode(state, m) {
|
|
host.encode(state, m.host);
|
|
port.encode(state, m.port);
|
|
},
|
|
decode(state) {
|
|
return {
|
|
host: host.decode(state),
|
|
family,
|
|
port: port.decode(state)
|
|
};
|
|
}
|
|
};
|
|
};
|
|
var ipv4 = exports.ipv4 = {
|
|
preencode(state) {
|
|
state.end += 4;
|
|
},
|
|
encode(state, string2) {
|
|
const start = state.start;
|
|
const end = start + 4;
|
|
let i = 0;
|
|
while (i < string2.length) {
|
|
let n = 0;
|
|
let c;
|
|
while (i < string2.length && (c = string2.charCodeAt(i++)) !== /* . */
|
|
46) {
|
|
n = n * 10 + (c - /* 0 */
|
|
48);
|
|
}
|
|
state.buffer[state.start++] = n;
|
|
}
|
|
state.start = end;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 4) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++];
|
|
}
|
|
};
|
|
exports.ipv4Address = address(ipv4, 4);
|
|
var ipv6 = exports.ipv6 = {
|
|
preencode(state) {
|
|
state.end += 16;
|
|
},
|
|
encode(state, string2) {
|
|
const start = state.start;
|
|
const end = start + 16;
|
|
let i = 0;
|
|
let split = null;
|
|
while (i < string2.length) {
|
|
let n = 0;
|
|
let c;
|
|
while (i < string2.length && (c = string2.charCodeAt(i++)) !== /* : */
|
|
58) {
|
|
if (c >= 48 && c <= 57) n = n * 16 + (c - /* 0 */
|
|
48);
|
|
else if (c >= 65 && c <= 70) n = n * 16 + (c - /* A */
|
|
65 + 10);
|
|
else if (c >= 97 && c <= 102) n = n * 16 + (c - /* a */
|
|
97 + 10);
|
|
}
|
|
state.buffer[state.start++] = n >>> 8;
|
|
state.buffer[state.start++] = n;
|
|
if (i < string2.length && string2.charCodeAt(i) === /* : */
|
|
58) {
|
|
i++;
|
|
split = state.start;
|
|
}
|
|
}
|
|
if (split !== null) {
|
|
const offset = end - state.start;
|
|
state.buffer.copyWithin(split + offset, split).fill(0, split, split + offset);
|
|
}
|
|
state.start = end;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 16) throw new Error("Out of bounds");
|
|
return (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16);
|
|
}
|
|
};
|
|
exports.ipv6Address = address(ipv6, 6);
|
|
var ip = exports.ip = {
|
|
preencode(state, string2) {
|
|
const family = string2.includes(":") ? 6 : 4;
|
|
uint8.preencode(state, family);
|
|
if (family === 4) ipv4.preencode(state);
|
|
else ipv6.preencode(state);
|
|
},
|
|
encode(state, string2) {
|
|
const family = string2.includes(":") ? 6 : 4;
|
|
uint8.encode(state, family);
|
|
if (family === 4) ipv4.encode(state, string2);
|
|
else ipv6.encode(state, string2);
|
|
},
|
|
decode(state) {
|
|
const family = uint8.decode(state);
|
|
if (family === 4) return ipv4.decode(state);
|
|
else return ipv6.decode(state);
|
|
}
|
|
};
|
|
exports.ipAddress = {
|
|
preencode(state, m) {
|
|
ip.preencode(state, m.host);
|
|
port.preencode(state, m.port);
|
|
},
|
|
encode(state, m) {
|
|
ip.encode(state, m.host);
|
|
port.encode(state, m.port);
|
|
},
|
|
decode(state) {
|
|
const family = uint8.decode(state);
|
|
return {
|
|
host: family === 4 ? ipv4.decode(state) : ipv6.decode(state),
|
|
family,
|
|
port: port.decode(state)
|
|
};
|
|
}
|
|
};
|
|
var record = exports.record = function(keyEncoding, valueEncoding) {
|
|
return {
|
|
preencode(state, v) {
|
|
const keys = Object.keys(v);
|
|
uint.preencode(state, keys.length);
|
|
for (const k of keys) {
|
|
keyEncoding.preencode(state, k);
|
|
valueEncoding.preencode(state, v[k]);
|
|
}
|
|
},
|
|
encode(state, v) {
|
|
const keys = Object.keys(v);
|
|
uint.encode(state, keys.length);
|
|
for (const k of keys) {
|
|
keyEncoding.encode(state, k);
|
|
valueEncoding.encode(state, v[k]);
|
|
}
|
|
},
|
|
decode(state) {
|
|
const out = /* @__PURE__ */ Object.create(null);
|
|
const keys = uint.decode(state);
|
|
for (let i = 0; i < keys; i++) {
|
|
out[keyEncoding.decode(state)] = valueEncoding.decode(state);
|
|
}
|
|
return out;
|
|
}
|
|
};
|
|
};
|
|
exports.stringRecord = record(utf8, utf8);
|
|
function getType(o) {
|
|
if (o === null || o === void 0) return 0;
|
|
if (typeof o === "boolean") return 1;
|
|
if (typeof o === "string") return 2;
|
|
if (b4a.isBuffer(o)) return 3;
|
|
if (typeof o === "number") {
|
|
if (Number.isInteger(o)) return o >= 0 ? 4 : 5;
|
|
return 6;
|
|
}
|
|
if (Array.isArray(o)) return 7;
|
|
if (o instanceof Date) return 9;
|
|
if (typeof o === "object") return 8;
|
|
throw new Error("Unsupported type for " + o);
|
|
}
|
|
exports.from = function from(enc) {
|
|
if (typeof enc === "string") return fromNamed(enc);
|
|
if (enc.preencode) return enc;
|
|
if (enc.encodingLength) return fromAbstractEncoder(enc);
|
|
return fromCodec(enc);
|
|
};
|
|
function fromNamed(enc) {
|
|
switch (enc) {
|
|
case "ascii":
|
|
return raw.ascii;
|
|
case "utf-8":
|
|
case "utf8":
|
|
return raw.utf8;
|
|
case "hex":
|
|
return raw.hex;
|
|
case "base64":
|
|
return raw.base64;
|
|
case "utf16-le":
|
|
case "utf16le":
|
|
case "ucs-2":
|
|
case "ucs2":
|
|
return raw.ucs2;
|
|
case "ndjson":
|
|
return raw.ndjson;
|
|
case "json":
|
|
return raw.json;
|
|
case "binary":
|
|
default:
|
|
return raw.binary;
|
|
}
|
|
}
|
|
function fromCodec(enc) {
|
|
let tmpM = null;
|
|
let tmpBuf = null;
|
|
return {
|
|
preencode(state, m) {
|
|
tmpM = m;
|
|
tmpBuf = enc.encode(m);
|
|
state.end += tmpBuf.byteLength;
|
|
},
|
|
encode(state, m) {
|
|
raw.encode(state, m === tmpM ? tmpBuf : enc.encode(m));
|
|
tmpM = tmpBuf = null;
|
|
},
|
|
decode(state) {
|
|
return enc.decode(raw.decode(state));
|
|
}
|
|
};
|
|
}
|
|
function fromAbstractEncoder(enc) {
|
|
return {
|
|
preencode(state, m) {
|
|
state.end += enc.encodingLength(m);
|
|
},
|
|
encode(state, m) {
|
|
enc.encode(m, state.buffer, state.start);
|
|
state.start += enc.encode.bytes;
|
|
},
|
|
decode(state) {
|
|
const m = enc.decode(state.buffer, state.start, state.end);
|
|
state.start += enc.decode.bytes;
|
|
return m;
|
|
}
|
|
};
|
|
}
|
|
exports.encode = function encode(enc, m) {
|
|
const state = exports.state();
|
|
enc.preencode(state, m);
|
|
state.buffer = b4a.allocUnsafe(state.end);
|
|
enc.encode(state, m);
|
|
return state.buffer;
|
|
};
|
|
exports.decode = function decode(enc, buffer2) {
|
|
return enc.decode(exports.state(0, buffer2.byteLength, buffer2));
|
|
};
|
|
function zigZagInt(enc) {
|
|
return {
|
|
preencode(state, n) {
|
|
enc.preencode(state, zigZagEncodeInt(n));
|
|
},
|
|
encode(state, n) {
|
|
enc.encode(state, zigZagEncodeInt(n));
|
|
},
|
|
decode(state) {
|
|
return zigZagDecodeInt(enc.decode(state));
|
|
}
|
|
};
|
|
}
|
|
function zigZagDecodeInt(n) {
|
|
return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2;
|
|
}
|
|
function zigZagEncodeInt(n) {
|
|
return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n;
|
|
}
|
|
function zigZagBigInt(enc) {
|
|
return {
|
|
preencode(state, n) {
|
|
enc.preencode(state, zigZagEncodeBigInt(n));
|
|
},
|
|
encode(state, n) {
|
|
enc.encode(state, zigZagEncodeBigInt(n));
|
|
},
|
|
decode(state) {
|
|
return zigZagDecodeBigInt(enc.decode(state));
|
|
}
|
|
};
|
|
}
|
|
function zigZagDecodeBigInt(n) {
|
|
return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n;
|
|
}
|
|
function zigZagEncodeBigInt(n) {
|
|
return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n;
|
|
}
|
|
function validateUint(n) {
|
|
if (n >= 0 === false)
|
|
throw new Error("uint must be positive");
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../bare-lib-entry-compactEncoding.js
|
|
var bare_lib_entry_compactEncoding_exports = {};
|
|
__export(bare_lib_entry_compactEncoding_exports, {
|
|
default: () => bare_lib_entry_compactEncoding_default
|
|
});
|
|
var import_compact_encoding = __toESM(require_compact_encoding());
|
|
var bare_lib_entry_compactEncoding_default = import_compact_encoding.default;
|
|
return __toCommonJS(bare_lib_entry_compactEncoding_exports);
|
|
})();
|
|
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["compactEncoding"]=v;})();
|