@gsknnft/bigint-buffer 1.4.6 → 1.5.0

package/dist/conversion/esm/index.js

@@ -0,0 +1,416 @@
+"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/esm/index.node.js

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { default } from './index.js';

package/dist/conversion/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/conversion/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const v=require("buffer"),l=require("path"),H=require("fs");let w=!1,B,h;const u=typeof globalThis<"u"&&typeof globalThis.document<"u",y=[l.resolve(__dirname,"../"),l.resolve(__dirname,"../.."),l.resolve(__dirname,"../../../")],_=()=>{for(const t of y){const e=l.join(t,"build","Release","bigint_buffer.node");if(H.existsSync(e))return t}return y[0]};function W(){try{const t=require("bindings"),e=_();return t({bindings:"bigint_buffer",module_root:e})}catch(t){h=t;return}}u||(B=W(),w=B!==void 0,!w&&h!==void 0&&process.env?.BIGINT_BUFFER_SILENT_NATIVE_FAIL!=="1"&&console.warn("bigint-buffer: Failed to load native bindings; using pure JS fallback. Run npm run rebuild to restore native.",h));B===void 0&&(B={toBigInt:(t,e=!0)=>{const n=v.Buffer.from(t);e||n.reverse();const r=n.toString("hex");return r.length===0?0n:BigInt(`0x${r}`)},fromBigInt:(t,e,n=!0)=>{const r=t.toString(16),i=e.length,o=r.padStart(i*2,"0").slice(0,i*2),c=v.Buffer.from(o,"hex");return n||c.reverse(),c.copy(e),e}});const x=9,d="0x0",q=t=>t.startsWith("0x")||t.startsWith("0X")?t:`0x${t}`,b=t=>{if(t===0n)return d;const e=t<0n,n=e?-t:t,r=E(n);return`${e?"-":""}0x${r}`},s=t=>{if(!t)return 0n;const e=t.trim();if(e.length===0)return 0n;const n=e.startsWith("-"),r=n?e.slice(1):e,i=q(r),o=T(i);return n?-o:o};function j(t,e=x){if(!Number.isFinite(t))return d;const n=Math.pow(10,e),r=BigInt(Math.round(t*n));return b(r)}function k(t,e=x){const n=s(t);if(n===0n)return 0;const r=Math.pow(10,e);return Number(n)/r}function z(t,e){return b(s(t)+s(e))}function D(t,e){return b(s(t)-s(e))}function C(t){if(t.length===0)return d;const e=t.reduce((n,r)=>n+s(r),0n);return b(e/BigInt(t.length))}function J(t,e){const n=s(t)-s(e);return n===0n?0:n>0n?1:-1}function X(t){return s(t)}let f,I;function Z(){try{const t=require("bindings"),e=_();return t({bindings:"bigint_buffer",module_root:e})}catch(t){I=t;return}}let S=!1;u||(f=Z(),S=f!==void 0,!S&&I!==void 0&&process.env?.BIGINT_BUFFER_SILENT_NATIVE_FAIL!=="1"&&console.warn("bigint-buffer: Failed to load native bindings; using pure JS fallback. Run npm run rebuild to restore native.",I));f===void 0&&(f={toBigInt:(t,e=!0)=>{const n=Buffer.from(t);e||n.reverse();const r=n.toString("hex");return r.length===0?0n:BigInt(`0x${r}`)},fromBigInt:(t,e,n=!0)=>{const r=t.toString(16),i=e.length,o=r.padStart(i*2,"0").slice(0,i*2),c=Buffer.from(o,"hex");return n||c.reverse(),c.copy(e),e}});function $(t){if(u||f===void 0){const e=Buffer.from(t);e.reverse();const n=e.toString("hex");return n.length===0?BigInt(0):BigInt(`0x${n}`)}return f.toBigInt(t,!1)}function G(){try{return $(Buffer.from([1,0]))===BigInt(1)}catch{return!1}}function Y(t){if(u||f===void 0){const e=t.toString("hex");return e.length===0?BigInt(0):BigInt(`0x${e}`)}return f.toBigInt(t,!0)}function K(t,e){if(u||f===void 0){const n=t.toString(16),r=Buffer.from(n.padStart(e*2,"0").slice(0,e*2),"hex");return r.reverse(),r}return f.fromBigInt(t,Buffer.allocUnsafe(e),!1)}function Q(t,e){if(u||f===void 0){const n=t.toString(16);return Buffer.from(n.padStart(e*2,"0").slice(0,e*2),"hex")}return f.fromBigInt(t,Buffer.allocUnsafe(e),!0)}function a(t,e=!1,n){const r=t.match(/^(0x)?([\da-fA-F]+)$/);if(r==null)throw new RangeError("input must be a hexadecimal string, e.g. '0x124fe3a' or '0214f1b2'");let i=r[2];if(n!==void 0){if(n<i.length/2)throw new RangeError(`expected byte length ${n} < input hex byte length ${Math.ceil(i.length/2)}`);i=i.padStart(n*2,"0")}return e?"0x"+i:i}function L(t,e=!1){if(t<0)throw RangeError("a should be a non-negative integer. Negative values are not supported");return p(E(t),e)}function N(t){let e=8n;ArrayBuffer.isView(t)?e=BigInt(t.BYTES_PER_ELEMENT*8):t=new Uint8Array(t);let n=0n;for(const r of t.values()){const i=BigInt(r);n=(n<<e)+i}return n}function E(t,e=!1,n){if(t<0)throw RangeError("a should be a non-negative integer. Negative values are not supported");return a(t.toString(16),e,n)}function T(t){return BigInt(a(t,!0))}function tt(t){if(t<0)throw RangeError("a should be a non-negative integer. Negative values are not supported");return R(p(t.toString(16)))}function et(t){return T(A(U(t)))}function m(t){if(Buffer.isBuffer(t))return t;if(ArrayBuffer.isView(t))return Buffer.from(t.buffer,t.byteOffset,t.byteLength);if(t instanceof ArrayBuffer)return Buffer.from(new Uint8Array(t));throw new TypeError("Unsupported input type for Buffer.from")}function R(t){const e=m(t);return u?new TextDecoder().decode(new Uint8Array(e)):Buffer.from(e).toString()}function U(t,e=!1){return!u&&!e?Buffer.from(new TextEncoder().encode(t).buffer):new TextEncoder().encode(t).buffer}function A(t,e=!1,n){if(u){let r="";const i="0123456789abcdef";return ArrayBuffer.isView(t)?t=new Uint8Array(t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength)):t=new Uint8Array(t),t.forEach(o=>{r+=i[o>>4]+i[o&15]}),a(r,e,n)}else{const r=m(t);return ArrayBuffer.isView(r)&&(t=new Uint8Array(r.buffer.slice(r.byteOffset,r.byteOffset+r.byteLength))),a(Buffer.from(m(t)).toString("hex"),e,n)}}function p(t,e=!1){let n=a(t);if(n=a(t,!1,Math.ceil(n.length/2)),u)return Uint8Array.from(n.match(/[\da-fA-F]{2}/g).map(r=>+("0x"+r))).buffer;{const r=Buffer.from(n,"hex");return e?r.buffer.slice(r.byteOffset,r.byteOffset+r.byteLength):r}}function nt(t,e=!1,n=!0){if(t<0n)throw new RangeError("negative bigint");const r=L(t);let i=Buffer.isBuffer(r)?r.toString("base64"):Buffer.from(r).toString("base64");return e&&(i=i.replace(/\+/g,"-").replace(/\//g,"_")),n||(i=i.replace(/=+$/,"")),i}function rt(t){if(!t||t.trim()==="")return 0n;const e=t.trim();if(!/^[A-Za-z0-9+/=_-]*$/.test(e))throw new RangeError("invalid base64");let n=e.replace(/-/g,"+").replace(/_/g,"/");for(;n.length%4!==0;)n+="=";const r=Buffer.from(n,"base64");return N(r)}const it=Object.freeze(Object.defineProperty({__proto__:null,FIXED_POINT_DECIMALS:x,ZERO_FIXED_POINT:d,addFixedPoint:z,averageFixedPoint:C,base64ToBigint:rt,bigintToBase64:nt,bigintToBuf:L,bigintToHex:E,bigintToText:tt,bufToBigint:N,bufToHex:A,bufToText:R,compareFixedPoint:J,fixedPointToBigInt:X,fromFixedPoint:k,hexToBigint:T,hexToBuf:p,parseHex:a,subtractFixedPoint:D,textToBigint:et,textToBuf:U,toBigIntBE:Y,toBigIntLE:$,toBigIntValue:s,toBufferBE:Q,toBufferLE:K,toFixedPoint:j,validateBigIntBuffer:G},Symbol.toStringTag,{value:"Module"})),ot=typeof Buffer.prototype.readBigUInt64LE=="function",ft=typeof Buffer.prototype.readBigUInt64BE=="function",st=typeof Buffer.prototype.writeBigUInt64LE=="function",ut=typeof Buffer.prototype.writeBigUInt64BE=="function",ct=ot?(t,e)=>t.readBigUInt64LE(e):(t,e)=>{let n=0n;for(let r=7;r>=0;r--)n=(n<<8n)+BigInt(t[e+r]);return n},at=ft?(t,e)=>t.readBigUInt64BE(e):(t,e)=>{let n=0n;for(let r=0;r<8;r++)n=(n<<8n)+BigInt(t[e+r]);return n},gt=st?(t,e,n)=>{t.writeBigUInt64LE(n,e)}:(t,e,n)=>{let r=n;for(let i=0;i<8;i++)t[e+i]=Number(r&0xffn),r>>=8n},lt=ut?(t,e,n)=>{t.writeBigUInt64BE(n,e)}:(t,e,n)=>{let r=n;for(let i=7;i>=0;i--)t[e+i]=Number(r&0xffn),r>>=8n},Bt=t=>{let e=0n,n=1n;const r=t.length,i=r&7;for(let o=0;o<i;o++)e+=BigInt(t[o])*n,n<<=8n;for(let o=i;o<r;o+=8){const c=ct(t,o);e+=c*n,n<<=64n}return e},dt=t=>{const e=t.length;if(e===0)return 0n;let n=0n;const r=e&7;let i=0;if(r!==0)for(;i<r;i++)n=(n<<8n)+BigInt(t[i]);for(;i<e;i+=8){const o=at(t,i);n=(n<<64n)+o}return n},bt=(t,e)=>{const n=e.length;let r=t,i=0;const o=n-n%8;for(;i<o;i+=8)gt(e,i,r&0xffffffffffffffffn),r>>=64n;for(;i<n;i++)e[i]=Number(r&0xffn),r>>=8n;return e},ht=(t,e)=>{const n=e.length;let r=t,i=n;const o=n&-8;for(;i>o;)i--,e[i]=Number(r&0xffn),r>>=8n;for(;i>0;i-=8){const c=r&0xffffffffffffffffn;lt(e,i-8,c),r>>=64n}return e},It=t=>{if(t===0n)return 1;let e=t,n=0;for(;e>0n;)n++,e>>=8n;return n},mt={toBigInt:(t,e=!0)=>e?dt(t):Bt(t),fromBigInt:(t,e,n=!0)=>n?ht(t,e):bt(t,e)};let g=mt;exports.isNative=!1;if(typeof window>"u")try{const t=require("bindings")("bigint_buffer");t!==void 0&&(g=t,exports.isNative=!0)}catch(t){console.warn("bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)",t)}function F(t){return g.toBigInt(t,!1)}function xt(){try{return F(Buffer.from([1,0]))===BigInt(1)}catch{return!1}}function O(t){return g.toBigInt(t,!0)}function Et(t,e){if(e<0)throw new RangeError("toBufferLE width must be non-negative");const n=e===0?Buffer.alloc(0):Buffer.allocUnsafe(e);return g.fromBigInt(t,n,!1)}function P(t,e){if(e<0)throw new RangeError("toBufferBE width must be non-negative");const n=e===0?Buffer.alloc(0):Buffer.allocUnsafe(e);return g.fromBigInt(t,n,!0)}function M(t){if(t<BigInt(0))throw new Error("bigintToBuf: negative bigint values are not supported");const e=It(t);return P(t,e)}function V(t){return O(t)}function Tt(t){if(t<BigInt(0))throw new Error("bigintToHex: negative bigint values are not supported");const e=t.toString(16);return e.length%2===0?e:"0"+e}function pt(t){const e=t.startsWith("0x")?t.slice(2):t;return e.length===0?BigInt(0):BigInt(`0x${e}`)}function vt(t){return t.toString(10)}function wt(t){if(!t?.trim())throw new Error("textToBigint: input string cannot be empty");try{return BigInt(t)}catch(e){throw new Error(`textToBigint: invalid decimal string "${t}" ${e instanceof Error?e.message:String(e)}`)}}function yt(t){if(t<BigInt(0))throw new Error("bigintToBase64: negative bigint values are not supported");return M(t).toString("base64")}function St(t){if(!t?.trim())throw new Error("base64ToBigint: input string cannot be empty");const e=t.trim();if(!/^[A-Za-z0-9+/]+=*$/.test(e))throw new Error("base64ToBigint: invalid base64 string format");const n=Buffer.from(e,"base64");return V(n)}exports.base64ToBigint=St;exports.bigintToBase64=yt;exports.bigintToBuf=M;exports.bigintToHex=Tt;exports.bigintToText=vt;exports.bufToBigint=V;exports.conversionUtils=it;exports.hexToBigint=pt;exports.textToBigint=wt;exports.toBigIntBE=O;exports.toBigIntLE=F;exports.toBufferBE=P;exports.toBufferLE=Et;exports.validateBigIntBuffer=xt;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});let g;const l=typeof globalThis<"u"&&typeof globalThis.document<"u";let f,c;typeof process<"u"&&process.versions?.node&&!l&&(f=require("path"),c=require("fs"));const b=()=>{if(!f||!c)return;let t=__dirname;for(;;){const o=f.join(t,"node_modules","@gsknnft","bigint-buffer","package.json");if(c.existsSync(o))return f.dirname(o);const s=f.dirname(t);if(s===t)break;t=s}const n=typeof require=="function"&&typeof require.resolve=="function",e=o=>{if(n)try{return require.resolve(o)}catch{return}},r=e("@gsknnft/bigint-buffer")??e("@gsknnft/bigint-buffer/dist/index.cjs")??e("@gsknnft/bigint-buffer/dist/index.js");let i=r?f.dirname(r):__dirname;for(;;){const o=f.join(i,"package.json");if(c.existsSync(o))return i;const s=f.dirname(i);if(s===i)break;i=s}},w=()=>{if(!f)return[];const t=new Set,n=o=>{if(!o)return;const s=f.resolve(o);t.has(s)||t.add(s)},e=b(),r=typeof process<"u"&&process.resourcesPath;n(process.env?.BIGINT_BUFFER_NATIVE_PATH),n(e),n(e?f.join(e,"dist"):void 0),n(r?f.join(r,"app.asar.unpacked","node_modules","@gsknnft","bigint-buffer"):void 0),n(f.resolve(__dirname,"..")),n(f.resolve(__dirname,"../..")),n(f.resolve(__dirname,"../../..")),n(f.resolve(__dirname,"../../../..")),n(f.resolve(__dirname,"../../../../.."));const i=Array.from(t);return process.env.BIGINT_BUFFER_DEBUG&&console.log("bigint-buffer: candidateRoots:",i),i},F=()=>{if(!(!f||!c)){for(const t of w()){const n=f.join(t,"build","Release","bigint_buffer.node");if(process.env.BIGINT_BUFFER_DEBUG&&console.log("bigint-buffer: checking for native at",n),c.existsSync(n))return process.env.BIGINT_BUFFER_DEBUG&&console.log("bigint-buffer: found native at",n),t;const e=f.join(t,"dist","build","Release","bigint_buffer.node");if(process.env.BIGINT_BUFFER_DEBUG&&console.log("bigint-buffer: checking for native at",e),c.existsSync(e))return process.env.BIGINT_BUFFER_DEBUG&&console.log("bigint-buffer: found native at",e),f.join(t,"dist")}process.env.BIGINT_BUFFER_DEBUG&&console.warn("bigint-buffer: native binary not found in any candidate root")}},N=t=>{if(typeof t=="function")return t;if(t&&typeof t=="object"){const n=t.default;if(typeof n=="function")return n;if(n&&typeof n=="object"&&typeof n.default=="function")return n.default}throw new TypeError("bindings is not a function")},R=()=>{if(f)try{const t=require("node-gyp-build"),n=b();return n?t(n):void 0}catch(t){g=t;return}};function I(){g=void 0;const t=R();if(t)return t;try{const n=require("bindings"),e=N(n),r=b(),i=F()??r;return e(i?{bindings:"bigint_buffer",module_root:i}:"bigint_buffer")}catch(n){g=n,process.env?.BIGINT_BUFFER_SILENT_NATIVE_FAIL!=="1"&&console.warn("bigint-buffer: Failed to load native bindings; using pure JS fallback. Run npm run rebuild to restore native.",g)}}Buffer.prototype.readBigUInt64LE;Buffer.prototype.readBigUInt64BE;Buffer.prototype.writeBigUInt64LE;Buffer.prototype.writeBigUInt64BE;l||I();function p(t,n=!1,e){const r=t.match(/^(0x)?([\da-fA-F]+)$/);if(r==null)throw new RangeError("input must be a hexadecimal string, e.g. '0x124fe3a' or '0214f1b2'");let i=r[2];return n?"0x"+i:i}function U(t,n=!1,e){if(t<0)throw RangeError("a should be a non-negative integer. Negative values are not supported");return p(t.toString(16),n)}function P(t){return BigInt(p(t,!0))}const E=9,L=/^-?0x[0-9a-f]+$/i,B="0x0",k=t=>t.startsWith("0x")||t.startsWith("0X")?t:`0x${t}`,d=t=>{if(t===0n)return B;const n=t<0n,e=n?-t:t,r=U(e);return`${n?"-":""}0x${r}`},u=t=>{if(!t)return 0n;const n=t.trim();if(n.length===0)return 0n;const e=n.startsWith("-"),r=e?n.slice(1):n,i=k(r),o=P(i);return e?-o:o};function S(t,n=E){if(!Number.isFinite(t))return B;const e=10n**BigInt(n),r=BigInt(Math.round(t*Number(e)));return d(r)}function D(t,n=9){if(!t)return 0;const e=t.trim();if(e.length===0)return 0;const r=e.startsWith("-"),i=r?e.slice(1):e,o=r?-BigInt(i):BigInt(i),s=10**n;return Number(o)/s}function G(t,n){return d(u(t)+u(n))}function j(t,n){return d(u(t)-u(n))}function A(t){if(t.length===0)return B;const n=t.reduce((e,r)=>e+u(r),0n);return d(n/BigInt(t.length))}function $(t,n){const e=u(t)-u(n);return e===0n?0:e>0n?1:-1}function O(t){return u(t)}const W=typeof Buffer.prototype.readBigUInt64LE=="function",H=typeof Buffer.prototype.readBigUInt64BE=="function",V=typeof Buffer.prototype.writeBigUInt64LE=="function",q=typeof Buffer.prototype.writeBigUInt64BE=="function",X=W?(t,n)=>t.readBigUInt64LE(n):(t,n)=>{let e=0n;for(let r=7;r>=0;r--)e=(e<<8n)+BigInt(t[n+r]);return e},C=H?(t,n)=>t.readBigUInt64BE(n):(t,n)=>{let e=0n;for(let r=0;r<8;r++)e=(e<<8n)+BigInt(t[n+r]);return e},M=V?(t,n,e)=>{t.writeBigUInt64LE(e,n)}:(t,n,e)=>{let r=e;for(let i=0;i<8;i++)t[n+i]=Number(r&0xffn),r>>=8n},z=q?(t,n,e)=>{t.writeBigUInt64BE(e,n)}:(t,n,e)=>{let r=e;for(let i=7;i>=0;i--)t[n+i]=Number(r&0xffn),r>>=8n},Z=t=>{let n=0n,e=1n;const r=t.length,i=r&7;for(let o=0;o<i;o++)n+=BigInt(t[o])*e,e<<=8n;for(let o=i;o<r;o+=8){const s=X(t,o);n+=s*e,e<<=64n}return n},J=t=>{const n=t.length;if(n===0)return 0n;let e=0n;const r=n&7;let i=0;if(r!==0)for(;i<r;i++)e=(e<<8n)+BigInt(t[i]);for(;i<n;i+=8){const o=C(t,i);e=(e<<64n)+o}return e},K=(t,n)=>{const e=n.length;let r=t,i=0;const o=e-e%8;for(;i<o;i+=8)M(n,i,r&0xffffffffffffffffn),r>>=64n;for(;i<e;i++)n[i]=Number(r&0xffn),r>>=8n;return n},Q=(t,n)=>{const e=n.length;let r=t,i=e;const o=e&-8;for(;i>o;)i--,n[i]=Number(r&0xffn),r>>=8n;for(;i>0;i-=8){const s=r&0xffffffffffffffffn;z(n,i-8,s),r>>=64n}return n},Y=t=>{if(t===0n)return 1;let n=t,e=0;for(;n>0n;)e++,n>>=8n;return e},m=(t,n)=>{if(!Number.isInteger(t)||t<0)throw new RangeError(`${n} width must be a non-negative integer`)},h=t=>Buffer.isBuffer(t)?t:t instanceof Uint8Array?Buffer.from(t.buffer,t.byteOffset,t.byteLength):Buffer.from(t),tt={toBigInt:(t,n=!0)=>n?J(t):Z(t),fromBigInt:(t,n,e=!0)=>e?Q(t,n):K(t,n)};let a=tt;exports.isNative=!1;if(!l){const t=I();t!==void 0&&(a=t,exports.isNative=!0)}function T(t){return a.toBigInt(h(t),!1)}function nt(){try{return T(Buffer.from([1,0]))===BigInt(1)}catch{return!1}}function y(t){return a.toBigInt(h(t),!0)}function et(t,n){m(n,"toBufferLE");const e=n===0?Buffer.alloc(0):Buffer.allocUnsafe(n);return a.fromBigInt(t,e,!1)}function v(t,n){m(n,"toBufferBE");const e=n===0?Buffer.alloc(0):Buffer.allocUnsafe(n);return a.fromBigInt(t,e,!0)}function _(t){if(t<BigInt(0))throw new Error("bigintToBuf: negative bigint values are not supported");const n=Y(t);return v(t,n)}function x(t){return y(t)}function rt(t){if(t<BigInt(0))throw new Error("bigintToHex: negative bigint values are not supported");const n=t.toString(16);return n.length%2===0?n:"0"+n}function it(t){const n=t.startsWith("0x")?t.slice(2):t;return n.length===0?BigInt(0):BigInt(`0x${n}`)}function ot(t){return t.toString(10)}function ft(t){if(!t?.trim())throw new Error("textToBigint: input string cannot be empty");try{return BigInt(t)}catch(n){throw new Error(`textToBigint: invalid decimal string "${t}" ${n instanceof Error?n.message:String(n)}`)}}function st(t){if(t<BigInt(0))throw new Error("bigintToBase64: negative bigint values are not supported");return _(t).toString("base64")}function ut(t){if(!t?.trim())throw new Error("base64ToBigint: input string cannot be empty");const n=t.trim();if(!/^[A-Za-z0-9+/=_-]+$/.test(n))throw new Error("base64ToBigint: invalid base64 string format");let e=n.replace(/-/g,"+").replace(/_/g,"/");for(;e.length%4!==0;)e+="=";const r=Buffer.from(e,"base64");return x(r)}exports.FIXED_POINT_DECIMALS=E;exports.FIXED_POINT_PATTERN=L;exports.ZERO_FIXED_POINT=B;exports.addFixedPoint=G;exports.averageFixedPoint=A;exports.base64ToBigint=ut;exports.bigintToBase64=st;exports.bigintToBuf=_;exports.bigintToHex=rt;exports.bigintToText=ot;exports.bufToBigint=x;exports.compareFixedPoint=$;exports.fixedPointToBigInt=O;exports.fromFixedPoint=D;exports.hexToBigint=it;exports.subtractFixedPoint=j;exports.textToBigint=ft;exports.toBigIntBE=y;exports.toBigIntLE=T;exports.toBigIntValue=u;exports.toBufferBE=v;exports.toBufferLE=et;exports.toFixedPoint=S;exports.validateBigIntBuffer=nt;

package/dist/{types/dist/dist/index.d.ts → index.d.ts}

@@ -1,19 +1,19 @@
-import * as conversionUtils from "./conversion/src/ts/index";
-export { conversionUtils };
+export { FIXED_POINT_DECIMALS, FIXED_POINT_PATTERN, ZERO_FIXED_POINT, toFixedPoint, fromFixedPoint, addFixedPoint, subtractFixedPoint, averageFixedPoint, compareFixedPoint, fixedPointToBigInt, toBigIntValue, } from "./conversion/src/ts/index";
+type ByteInput = Buffer | Uint8Array | ArrayBuffer;
 export declare let isNative: boolean;
 /**
  * Convert a little-endian buffer into a BigInt.
  * @param buf The little-endian buffer to convert
  * @returns A BigInt with the little-endian representation of buf.
  */
-export declare function toBigIntLE(buf: Buffer): bigint;
+export declare function toBigIntLE(buf: ByteInput): bigint;
 export declare function validateBigIntBuffer(): boolean;
 /**
  * Convert a big-endian buffer into a BigInt
  * @param buf The big-endian buffer to convert.
  * @returns A BigInt with the big-endian representation of buf.
  */
-export declare function toBigIntBE(buf: Buffer): bigint;
+export declare function toBigIntBE(buf: ByteInput): bigint;
 /**
  * Convert a BigInt to a little-endian buffer.
  * @param num   The BigInt to convert.
@@ -41,7 +41,7 @@ export declare function bigintToBuf(num: bigint): Buffer;
  * @param buf The buffer to convert
  * @returns A bigint representation of the buffer
  */
-export declare function bufToBigint(buf: Buffer): bigint;
+export declare function bufToBigint(buf: ByteInput): bigint;
 /**
  * Convert a bigint to a hexadecimal string.
  * @param num The bigint to convert