@gsknnft/bigint-buffer 1.4.6 → 1.5.0

package/dist/conversion/bundle.umd.js

@@ -0,0 +1,423 @@
+(function (factory) {
+    typeof define === 'function' && define.amd ? define(factory) :
+    factory();
+})((function () { 'use strict';
+
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.toBigIntValue = exports.toHexString = exports.ZERO_FIXED_POINT = exports.FIXED_POINT_PATTERN = exports.FIXED_POINT_DECIMALS = void 0;
+    exports.toBigIntLE = toBigIntLE;
+    exports.validateBigIntBuffer = validateBigIntBuffer;
+    exports.toBigIntBE = toBigIntBE;
+    exports.toBufferLE = toBufferLE;
+    exports.toBufferBE = toBufferBE;
+    exports.parseHex = parseHex;
+    exports.bigintToBuf = bigintToBuf;
+    exports.bufToBigint = bufToBigint;
+    exports.bigintToHex = bigintToHex;
+    exports.hexToBigint = hexToBigint;
+    exports.bigintToText = bigintToText;
+    exports.textToBigint = textToBigint;
+    exports.bufToText = bufToText;
+    exports.textToBuf = textToBuf;
+    exports.bufToHex = bufToHex;
+    exports.hexToBuf = hexToBuf;
+    exports.bigintToBase64 = bigintToBase64;
+    exports.base64ToBigint = base64ToBigint;
+    exports.toFixedPoint = toFixedPoint;
+    exports.fromFixedPoint = fromFixedPoint;
+    exports.addFixedPoint = addFixedPoint;
+    exports.subtractFixedPoint = subtractFixedPoint;
+    exports.averageFixedPoint = averageFixedPoint;
+    exports.compareFixedPoint = compareFixedPoint;
+    exports.fixedPointToBigInt = fixedPointToBigInt;
+    const converter_1 = require("./converter");
+    let converter;
+    const hasRead64LE = typeof Buffer.prototype.readBigUInt64LE === "function";
+    const hasRead64BE = typeof Buffer.prototype.readBigUInt64BE === "function";
+    const hasWrite64LE = typeof Buffer.prototype.writeBigUInt64LE === "function";
+    const hasWrite64BE = typeof Buffer.prototype.writeBigUInt64BE === "function";
+    const read64LE = hasRead64LE
+        ? (buf, offset) => buf.readBigUInt64LE(offset)
+        : (buf, offset) => {
+            let out = 0n;
+            for (let i = 7; i >= 0; i--) {
+                out = (out << 8n) + BigInt(buf[offset + i]);
+            }
+            return out;
+        };
+    const read64BE = hasRead64BE
+        ? (buf, offset) => buf.readBigUInt64BE(offset)
+        : (buf, offset) => {
+            let out = 0n;
+            for (let i = 0; i < 8; i++) {
+                out = (out << 8n) + BigInt(buf[offset + i]);
+            }
+            return out;
+        };
+    const write64LE = hasWrite64LE
+        ? (buf, offset, value) => {
+            buf.writeBigUInt64LE(value, offset);
+        }
+        : (buf, offset, value) => {
+            let temp = value;
+            for (let i = 0; i < 8; i++) {
+                buf[offset + i] = Number(temp & 0xffn);
+                temp >>= 8n;
+            }
+        };
+    const write64BE = hasWrite64BE
+        ? (buf, offset, value) => {
+            buf.writeBigUInt64BE(value, offset);
+        }
+        : (buf, offset, value) => {
+            let temp = value;
+            for (let i = 7; i >= 0; i--) {
+                buf[offset + i] = Number(temp & 0xffn);
+                temp >>= 8n;
+            }
+        };
+    const bufferToBigIntLE = (buf) => {
+        let result = 0n;
+        let multiplier = 1n;
+        const len = buf.length;
+        const remainder = len & 7;
+        for (let i = 0; i < remainder; i++) {
+            result += BigInt(buf[i]) * multiplier;
+            multiplier <<= 8n;
+        }
+        for (let offset = remainder; offset < len; offset += 8) {
+            const chunk = read64LE(buf, offset);
+            result += chunk * multiplier;
+            multiplier <<= 64n;
+        }
+        return result;
+    };
+    const bufferToBigIntBE = (buf) => {
+        const len = buf.length;
+        if (len === 0)
+            return 0n;
+        let result = 0n;
+        const remainder = len & 7;
+        let offset = 0;
+        if (remainder !== 0) {
+            for (; offset < remainder; offset++) {
+                result = (result << 8n) + BigInt(buf[offset]);
+            }
+        }
+        for (; offset < len; offset += 8) {
+            const chunk = read64BE(buf, offset);
+            result = (result << 64n) + chunk;
+        }
+        return result;
+    };
+    const writeBigIntToBufferLE = (num, target) => {
+        const width = target.length;
+        let remaining = num;
+        let offset = 0;
+        const limit = width - (width % 8);
+        for (; offset < limit; offset += 8) {
+            write64LE(target, offset, remaining & 0xffffffffffffffffn);
+            remaining >>= 64n;
+        }
+        for (; offset < width; offset++) {
+            target[offset] = Number(remaining & 0xffn);
+            remaining >>= 8n;
+        }
+        return target;
+    };
+    const writeBigIntToBufferBE = (num, target) => {
+        const width = target.length;
+        let remaining = num;
+        let offset = width;
+        const limit = width & ~7;
+        while (offset > limit) {
+            offset--;
+            target[offset] = Number(remaining & 0xffn);
+            remaining >>= 8n;
+        }
+        for (; offset > 0; offset -= 8) {
+            const chunk = remaining & 0xffffffffffffffffn;
+            write64BE(target, offset - 8, chunk);
+            remaining >>= 64n;
+        }
+        return target;
+    };
+    const toBufferInput = (input) => {
+        if (Buffer.isBuffer(input))
+            return input;
+        if (input instanceof Uint8Array) {
+            return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+        }
+        return Buffer.from(input);
+    };
+    const assertWidth = (width, fnName) => {
+        if (!Number.isInteger(width) || width < 0) {
+            throw new RangeError(`${fnName} width must be a non-negative integer`);
+        }
+    };
+    if (!converter_1.IS_BROWSER) {
+        converter = (0, converter_1.loadNative)();
+    }
+    if (converter === undefined) {
+        converter = {
+            toBigInt: (buf, bigEndian = true) => bigEndian ? bufferToBigIntBE(buf) : bufferToBigIntLE(buf),
+            fromBigInt: (num, buf, bigEndian = true) => bigEndian
+                ? writeBigIntToBufferBE(num, buf)
+                : writeBigIntToBufferLE(num, buf),
+        };
+    }
+    function toBigIntLE(buf) {
+        if (converter === undefined)
+            return 0n;
+        return converter.toBigInt(toBufferInput(buf), false);
+    }
+    function validateBigIntBuffer() {
+        try {
+            const test = toBigIntLE(Buffer.from([0x01, 0x00]));
+            return test === BigInt(1);
+        }
+        catch {
+            return false;
+        }
+    }
+    function toBigIntBE(buf) {
+        if (converter === undefined)
+            return 0n;
+        return converter.toBigInt(toBufferInput(buf), true);
+    }
+    function toBufferLE(num, width) {
+        assertWidth(width, "toBufferLE");
+        if (converter === undefined)
+            return Buffer.alloc(0);
+        return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
+    }
+    function toBufferBE(num, width) {
+        assertWidth(width, "toBufferBE");
+        if (converter === undefined)
+            return Buffer.alloc(0);
+        return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
+    }
+    function parseHex(a, prefix0x = false, byteLength) {
+        const hexMatch = a.match(/^(0x)?([\da-fA-F]+)$/);
+        if (hexMatch == null) {
+            throw new RangeError("input must be a hexadecimal string, e.g. '0x124fe3a' or '0214f1b2'");
+        }
+        let hex = hexMatch[2];
+        if (byteLength !== undefined) {
+            if (byteLength < hex.length / 2) {
+                throw new RangeError(`expected byte length ${byteLength} < input hex byte length ${Math.ceil(hex.length / 2)}`);
+            }
+            hex = hex.padStart(byteLength * 2, "0");
+        }
+        return prefix0x ? "0x" + hex : hex;
+    }
+    function bigintToBuf(a, returnArrayBuffer = false) {
+        if (a < 0) {
+            throw RangeError("a should be a non-negative integer. Negative values are not supported");
+        }
+        return hexToBuf(bigintToHex(a), returnArrayBuffer);
+    }
+    function bufToBigint(buf) {
+        let bits = 8n;
+        if (ArrayBuffer.isView(buf)) {
+            bits = BigInt(buf.BYTES_PER_ELEMENT * 8);
+        }
+        else {
+            buf = new Uint8Array(buf);
+        }
+        let ret = 0n;
+        for (const i of buf.values()) {
+            const bi = BigInt(i);
+            ret = (ret << bits) + bi;
+        }
+        return ret;
+    }
+    function bigintToHex(a, prefix0x = false, byteLength) {
+        if (a < 0) {
+            throw RangeError("a should be a non-negative integer. Negative values are not supported");
+        }
+        return parseHex(a.toString(16), prefix0x, byteLength);
+    }
+    function hexToBigint(hexStr) {
+        return BigInt(parseHex(hexStr, true));
+    }
+    function bigintToText(a) {
+        if (a < 0) {
+            throw RangeError("a should be a non-negative integer. Negative values are not supported");
+        }
+        return bufToText(hexToBuf(a.toString(16)));
+    }
+    function textToBigint(text) {
+        return hexToBigint(bufToHex(textToBuf(text)));
+    }
+    function toBuffer(input) {
+        if (Buffer.isBuffer(input)) {
+            return input;
+        }
+        if (ArrayBuffer.isView(input)) {
+            return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+        }
+        if (input instanceof ArrayBuffer) {
+            return Buffer.from(new Uint8Array(input));
+        }
+        throw new TypeError("Unsupported input type for Buffer.from");
+    }
+    function bufToText(buf) {
+        const input = toBuffer(buf);
+        if (converter_1.IS_BROWSER) {
+            return new TextDecoder().decode(new Uint8Array(input));
+        }
+        else {
+            return Buffer.from(input).toString();
+        }
+    }
+    function textToBuf(str, returnArrayBuffer = false) {
+        if (!converter_1.IS_BROWSER && !returnArrayBuffer) {
+            return Buffer.from(new TextEncoder().encode(str).buffer);
+        }
+        return new TextEncoder().encode(str).buffer;
+    }
+    function bufToHex(buf, prefix0x = false, byteLength) {
+        if (converter_1.IS_BROWSER) {
+            let s = "";
+            const h = "0123456789abcdef";
+            if (ArrayBuffer.isView(buf)) {
+                buf = new Uint8Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
+            }
+            else {
+                buf = new Uint8Array(buf);
+            }
+            buf.forEach((v) => {
+                s += h[v >> 4] + h[v & 15];
+            });
+            return parseHex(s, prefix0x, byteLength);
+        }
+        else {
+            const input = toBuffer(buf);
+            if (ArrayBuffer.isView(input)) {
+                buf = new Uint8Array(input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength));
+            }
+            return parseHex(Buffer.from(toBuffer(buf)).toString("hex"), prefix0x, byteLength);
+        }
+    }
+    function hexToBuf(hexStr, returnArrayBuffer = false) {
+        let hex = parseHex(hexStr);
+        hex = parseHex(hexStr, false, Math.ceil(hex.length / 2));
+        if (converter_1.IS_BROWSER) {
+            return Uint8Array.from(hex.match(/[\da-fA-F]{2}/g).map((h) => {
+                return Number("0x" + h);
+            })).buffer;
+        }
+        else {
+            const b = Buffer.from(hex, "hex");
+            return returnArrayBuffer
+                ? b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength)
+                : b;
+        }
+    }
+    function bigintToBase64(a, urlsafe = false, padding = true) {
+        if (a < 0n) {
+            throw new RangeError("negative bigint");
+        }
+        const buf = bigintToBuf(a);
+        let base64 = Buffer.isBuffer(buf)
+            ? buf.toString("base64")
+            : Buffer.from(buf).toString("base64");
+        if (urlsafe) {
+            base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
+        }
+        if (!padding) {
+            base64 = base64.replace(/=+$/, "");
+        }
+        return base64;
+    }
+    function base64ToBigint(a) {
+        if (!a || a.trim() === "") {
+            return 0n;
+        }
+        const cleaned = a.trim();
+        if (!/^[A-Za-z0-9+/=_-]*$/.test(cleaned)) {
+            throw new RangeError("invalid base64");
+        }
+        let base64 = cleaned.replace(/-/g, "+").replace(/_/g, "/");
+        while (base64.length % 4 !== 0) {
+            base64 += "=";
+        }
+        const buf = Buffer.from(base64, "base64");
+        return bufToBigint(buf);
+    }
+    exports.FIXED_POINT_DECIMALS = 9;
+    exports.FIXED_POINT_PATTERN = /^-?0x[0-9a-f]+$/i;
+    exports.ZERO_FIXED_POINT = "0x0";
+    const normalizeHex = (value) => value.startsWith("0x") || value.startsWith("0X") ? value : `0x${value}`;
+    const toHexString = (value) => {
+        if (value === 0n) {
+            return exports.ZERO_FIXED_POINT;
+        }
+        const isNegative = value < 0n;
+        const absValue = isNegative ? -value : value;
+        const hexValue = bigintToHex(absValue);
+        return `${isNegative ? "-" : ""}0x${hexValue}`;
+    };
+    exports.toHexString = toHexString;
+    const toBigIntValue = (value) => {
+        if (!value) {
+            return 0n;
+        }
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            return 0n;
+        }
+        const isNegative = trimmed.startsWith("-");
+        const body = isNegative ? trimmed.slice(1) : trimmed;
+        const normalized = normalizeHex(body);
+        const bigValue = hexToBigint(normalized);
+        return isNegative ? -bigValue : bigValue;
+    };
+    exports.toBigIntValue = toBigIntValue;
+    function toFixedPoint(value, decimals = exports.FIXED_POINT_DECIMALS) {
+        if (!Number.isFinite(value)) {
+            return exports.ZERO_FIXED_POINT;
+        }
+        const scale = 10n ** BigInt(decimals);
+        const scaled = BigInt(Math.round(value * Number(scale)));
+        return (0, exports.toHexString)(scaled);
+    }
+    function fromFixedPoint(value, decimals = 9) {
+        if (!value)
+            return 0;
+        const trimmed = value.trim();
+        if (trimmed.length === 0)
+            return 0;
+        const isNegative = trimmed.startsWith('-');
+        const body = isNegative ? trimmed.slice(1) : trimmed;
+        const bigValue = isNegative ? -BigInt(body) : BigInt(body);
+        const scale = 10 ** decimals;
+        return Number(bigValue) / scale;
+    }
+    function addFixedPoint(a, b) {
+        return (0, exports.toHexString)((0, exports.toBigIntValue)(a) + (0, exports.toBigIntValue)(b));
+    }
+    function subtractFixedPoint(a, b) {
+        return (0, exports.toHexString)((0, exports.toBigIntValue)(a) - (0, exports.toBigIntValue)(b));
+    }
+    function averageFixedPoint(values) {
+        if (values.length === 0) {
+            return exports.ZERO_FIXED_POINT;
+        }
+        const sum = values.reduce((acc, value) => acc + (0, exports.toBigIntValue)(value), 0n);
+        return (0, exports.toHexString)(sum / BigInt(values.length));
+    }
+    function compareFixedPoint(a, b) {
+        const diff = (0, exports.toBigIntValue)(a) - (0, exports.toBigIntValue)(b);
+        if (diff === 0n) {
+            return 0;
+        }
+        return diff > 0n ? 1 : -1;
+    }
+    function fixedPointToBigInt(value) {
+        return (0, exports.toBigIntValue)(value);
+    }
+
+}));

package/dist/conversion/cjs/converter.d.ts

@@ -0,0 +1,14 @@
+export type PathModule = typeof import("path");
+export type FsModule = typeof import("fs");
+export type BindingsLoader = ((name: string) => unknown) & ((options: {
+    bindings: string;
+    module_root?: string;
+}) => unknown);
+export interface ConverterInterface {
+    toBigInt: (buf: Buffer, bigEndian?: boolean) => bigint;
+    fromBigInt: (num: bigint, buf: Buffer, bigEndian?: boolean) => Buffer;
+}
+export declare let isNative: boolean;
+export declare const IS_BROWSER: boolean;
+export declare const findModuleRoot: () => string | undefined;
+export declare function loadNative(): ConverterInterface | undefined;

package/dist/conversion/cjs/index.d.ts

@@ -0,0 +1,33 @@
+type ByteInput = Buffer | Uint8Array | ArrayBuffer;
+export declare function toBigIntLE(buf: ByteInput): bigint;
+export declare function validateBigIntBuffer(): boolean;
+export declare function toBigIntBE(buf: ByteInput): bigint;
+export declare function toBufferLE(num: bigint, width: number): Buffer;
+export declare function toBufferBE(num: bigint, width: number): Buffer;
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export declare function parseHex(a: string, prefix0x?: boolean, byteLength?: number): string;
+export declare function bigintToBuf(a: bigint, returnArrayBuffer?: boolean): ArrayBuffer | Buffer;
+export declare function bufToBigint(buf: ArrayBuffer | TypedArray | Buffer): bigint;
+export declare function bigintToHex(a: bigint, prefix0x?: boolean, byteLength?: number): string;
+export declare function hexToBigint(hexStr: string): bigint;
+export declare function bigintToText(a: bigint): string;
+export declare function textToBigint(text: string): bigint;
+export declare function bufToText(buf: ArrayBuffer | TypedArray | Buffer): string;
+export declare function textToBuf(str: string, returnArrayBuffer?: boolean): ArrayBuffer | Buffer;
+export declare function bufToHex(buf: ArrayBuffer | TypedArray | Buffer, prefix0x?: boolean, byteLength?: number): string;
+export declare function hexToBuf(hexStr: string, returnArrayBuffer?: boolean): ArrayBuffer | Buffer;
+export declare function bigintToBase64(a: bigint, urlsafe?: boolean, padding?: boolean): string;
+export declare function base64ToBigint(a: string): bigint;
+export declare const FIXED_POINT_DECIMALS = 9;
+export declare const FIXED_POINT_PATTERN: RegExp;
+export declare const ZERO_FIXED_POINT: string;
+export declare const toHexString: (value: bigint) => string;
+export declare const toBigIntValue: (value?: string) => bigint;
+export declare function toFixedPoint(value: number, decimals?: number): string;
+export declare function fromFixedPoint(value?: string, decimals?: number): number;
+export declare function addFixedPoint(a: string, b: string): string;
+export declare function subtractFixedPoint(a: string, b: string): string;
+export declare function averageFixedPoint(values: string[]): string;
+export declare function compareFixedPoint(a: string, b: string): number;
+export declare function fixedPointToBigInt(value?: string): bigint;
+export {};