@gsknnft/bigint-buffer 1.4.6 → 1.5.0

package/dist/conversion/esm/bundle.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/bundle.min.js

@@ -0,0 +1 @@
+Object.defineProperty(exports,"__esModule",{value:!0}),exports.toBigIntValue=exports.toHexString=exports.ZERO_FIXED_POINT=exports.FIXED_POINT_PATTERN=exports.FIXED_POINT_DECIMALS=void 0,exports.toBigIntLE=x,exports.validateBigIntBuffer=function(){try{return x(Buffer.from([1,0]))===BigInt(1)}catch{return!1}},exports.toBigIntBE=function(t){return void 0===e?0n:e.toBigInt(g(t),!0)},exports.toBufferLE=function(t,r){return B(r,"toBufferLE"),void 0===e?Buffer.alloc(0):e.fromBigInt(t,Buffer.allocUnsafe(r),!1)},exports.toBufferBE=function(t,r){return B(r,"toBufferBE"),void 0===e?Buffer.alloc(0):e.fromBigInt(t,Buffer.allocUnsafe(r),!0)},exports.parseHex=c,exports.bigintToBuf=p,exports.bufToBigint=l,exports.bigintToHex=I,exports.hexToBigint=E,exports.bigintToText=function(t){if(t<0)throw RangeError("a should be a non-negative integer. Negative values are not supported");return h(m(t.toString(16)))},exports.textToBigint=function(t){return E(y(d(t)))},exports.bufToText=h,exports.textToBuf=d,exports.bufToHex=y,exports.hexToBuf=m,exports.bigintToBase64=function(t,e=!1,r=!0){if(t<0n)throw new RangeError("negative bigint");const n=p(t);let o=Buffer.isBuffer(n)?n.toString("base64"):Buffer.from(n).toString("base64");e&&(o=o.replace(/\+/g,"-").replace(/\//g,"_"));r||(o=o.replace(/=+$/,""));return o},exports.base64ToBigint=function(t){if(!t||""===t.trim())return 0n;const e=t.trim();if(!/^[A-Za-z0-9+/=_-]*$/.test(e))throw new RangeError("invalid base64");let r=e.replace(/-/g,"+").replace(/_/g,"/");for(;r.length%4!=0;)r+="=";return l(Buffer.from(r,"base64"))},exports.toFixedPoint=function(t,e=exports.FIXED_POINT_DECIMALS){if(!Number.isFinite(t))return exports.ZERO_FIXED_POINT;const r=10n**BigInt(e),n=BigInt(Math.round(t*Number(r)));return(0,exports.toHexString)(n)},exports.fromFixedPoint=function(t,e=9){if(!t)return 0;const r=t.trim();if(0===r.length)return 0;const n=r.startsWith("-"),o=n?r.slice(1):r,f=n?-BigInt(o):BigInt(o),i=10**e;return Number(f)/i},exports.addFixedPoint=function(t,e){return(0,exports.toHexString)((0,exports.toBigIntValue)(t)+(0,exports.toBigIntValue)(e))},exports.subtractFixedPoint=function(t,e){return(0,exports.toHexString)((0,exports.toBigIntValue)(t)-(0,exports.toBigIntValue)(e))},exports.averageFixedPoint=function(t){if(0===t.length)return exports.ZERO_FIXED_POINT;const e=t.reduce((t,e)=>t+(0,exports.toBigIntValue)(e),0n);return(0,exports.toHexString)(e/BigInt(t.length))},exports.compareFixedPoint=function(t,e){const r=(0,exports.toBigIntValue)(t)-(0,exports.toBigIntValue)(e);if(0n===r)return 0;return r>0n?1:-1},exports.fixedPointToBigInt=function(t){return(0,exports.toBigIntValue)(t)};const t=require("./converter");let e;const r="function"==typeof Buffer.prototype.readBigUInt64LE,n="function"==typeof Buffer.prototype.readBigUInt64BE,o="function"==typeof Buffer.prototype.writeBigUInt64LE,f="function"==typeof Buffer.prototype.writeBigUInt64BE,i=r?(t,e)=>t.readBigUInt64LE(e):(t,e)=>{let r=0n;for(let n=7;n>=0;n--)r=(r<<8n)+BigInt(t[e+n]);return r},u=n?(t,e)=>t.readBigUInt64BE(e):(t,e)=>{let r=0n;for(let n=0;n<8;n++)r=(r<<8n)+BigInt(t[e+n]);return r},s=o?(t,e,r)=>{t.writeBigUInt64LE(r,e)}:(t,e,r)=>{let n=r;for(let r=0;r<8;r++)t[e+r]=Number(0xffn&n),n>>=8n},a=f?(t,e,r)=>{t.writeBigUInt64BE(r,e)}:(t,e,r)=>{let n=r;for(let r=7;r>=0;r--)t[e+r]=Number(0xffn&n),n>>=8n},g=t=>Buffer.isBuffer(t)?t:t instanceof Uint8Array?Buffer.from(t.buffer,t.byteOffset,t.byteLength):Buffer.from(t),B=(t,e)=>{if(!Number.isInteger(t)||t<0)throw new RangeError(`${e} width must be a non-negative integer`)};function x(t){return void 0===e?0n:e.toBigInt(g(t),!1)}function c(t,e=!1,r){const n=t.match(/^(0x)?([\da-fA-F]+)$/);if(null==n)throw new RangeError("input must be a hexadecimal string, e.g. '0x124fe3a' or '0214f1b2'");let o=n[2];if(void 0!==r){if(r<o.length/2)throw new RangeError(`expected byte length ${r} < input hex byte length ${Math.ceil(o.length/2)}`);o=o.padStart(2*r,"0")}return e?"0x"+o:o}function p(t,e=!1){if(t<0)throw RangeError("a should be a non-negative integer. Negative values are not supported");return m(I(t),e)}function l(t){let e=8n;ArrayBuffer.isView(t)?e=BigInt(8*t.BYTES_PER_ELEMENT):t=new Uint8Array(t);let r=0n;for(const n of t.values()){r=(r<<e)+BigInt(n)}return r}function I(t,e=!1,r){if(t<0)throw RangeError("a should be a non-negative integer. Negative values are not supported");return c(t.toString(16),e,r)}function E(t){return BigInt(c(t,!0))}function b(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 h(e){const r=b(e);return t.IS_BROWSER?(new TextDecoder).decode(new Uint8Array(r)):Buffer.from(r).toString()}function d(e,r=!1){return t.IS_BROWSER||r?(new TextEncoder).encode(e).buffer:Buffer.from((new TextEncoder).encode(e).buffer)}function y(e,r=!1,n){if(t.IS_BROWSER){let t="";const o="0123456789abcdef";return(e=ArrayBuffer.isView(e)?new Uint8Array(e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength)):new Uint8Array(e)).forEach(e=>{t+=o[e>>4]+o[15&e]}),c(t,r,n)}{const t=b(e);return ArrayBuffer.isView(t)&&(e=new Uint8Array(t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength))),c(Buffer.from(b(e)).toString("hex"),r,n)}}function m(e,r=!1){let n=c(e);if(n=c(e,!1,Math.ceil(n.length/2)),t.IS_BROWSER)return Uint8Array.from(n.match(/[\da-fA-F]{2}/g).map(t=>Number("0x"+t))).buffer;{const t=Buffer.from(n,"hex");return r?t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength):t}}t.IS_BROWSER||(e=(0,t.loadNative)()),void 0===e&&(e={toBigInt:(t,e=!0)=>e?(t=>{const e=t.length;if(0===e)return 0n;let r=0n;const n=7&e;let o=0;if(0!==n)for(;o<n;o++)r=(r<<8n)+BigInt(t[o]);for(;o<e;o+=8)r=(r<<64n)+u(t,o);return r})(t):(t=>{let e=0n,r=1n;const n=t.length,o=7&n;for(let n=0;n<o;n++)e+=BigInt(t[n])*r,r<<=8n;for(let f=o;f<n;f+=8)e+=i(t,f)*r,r<<=64n;return e})(t),fromBigInt:(t,e,r=!0)=>r?((t,e)=>{const r=e.length;let n=t,o=r;const f=-8&r;for(;o>f;)o--,e[o]=Number(0xffn&n),n>>=8n;for(;o>0;o-=8)a(e,o-8,0xffffffffffffffffn&n),n>>=64n;return e})(t,e):((t,e)=>{const r=e.length;let n=t,o=0;const f=r-r%8;for(;o<f;o+=8)s(e,o,0xffffffffffffffffn&n),n>>=64n;for(;o<r;o++)e[o]=Number(0xffn&n),n>>=8n;return e})(t,e)}),exports.FIXED_POINT_DECIMALS=9,exports.FIXED_POINT_PATTERN=/^-?0x[0-9a-f]+$/i,exports.ZERO_FIXED_POINT="0x0";exports.toHexString=t=>{if(0n===t)return exports.ZERO_FIXED_POINT;const e=t<0n;return`${e?"-":""}0x${I(e?-t:t)}`};exports.toBigIntValue=t=>{if(!t)return 0n;const e=t.trim();if(0===e.length)return 0n;const r=e.startsWith("-"),n=(t=>t.startsWith("0x")||t.startsWith("0X")?t:`0x${t}`)(r?e.slice(1):e),o=E(n);return r?-o:o};

package/dist/conversion/esm/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;