react-native-nitro-buffer 0.0.1

package/lib/Buffer.js

@@ -0,0 +1,642 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Buffer = void 0;
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+// Lazily load the native module
+let _native;
+function getNative() {
+    if (!_native) {
+        _native = react_native_nitro_modules_1.NitroModules.createHybridObject('NitroBuffer');
+    }
+    return _native;
+}
+class Buffer extends Uint8Array {
+    constructor(arg, encodingOrOffset, length) {
+        // Handling different constructor arguments roughly
+        if (typeof arg === 'number') {
+            super(arg);
+        }
+        else if (typeof arg === 'string') {
+            const encoding = encodingOrOffset || 'utf8';
+            const len = getNative().byteLength(arg, encoding);
+            super(len);
+            getNative().write(this.buffer, arg, 0, len, encoding);
+        }
+        else if (arg instanceof Uint8Array) {
+            super(arg);
+        }
+        else if (arg instanceof ArrayBuffer) {
+            super(arg, encodingOrOffset, length);
+        }
+        else if (Object.prototype.toString.call(arg) === '[object ArrayBuffer]') {
+            super(arg, encodingOrOffset, length);
+        }
+        else if (typeof arg === 'object' && arg !== null && arg.type === 'Buffer' && Array.isArray(arg.data)) {
+            // Buffer.from({ type: 'Buffer', data: [...] })
+            super(arg.data);
+        }
+        else {
+            super(arg);
+        }
+    }
+    get parent() {
+        return this.buffer;
+    }
+    static from(value, encodingOrOffset, length) {
+        if (typeof value === 'string') {
+            return new Buffer(value, encodingOrOffset);
+        }
+        if (value instanceof Uint8Array) {
+            // Copy
+            const buf = new Buffer(value.length);
+            buf.set(value);
+            return buf;
+        }
+        if (value instanceof ArrayBuffer) {
+            return new Buffer(value, encodingOrOffset, length);
+        }
+        if (Array.isArray(value)) {
+            return new Buffer(new Uint8Array(value).buffer);
+        }
+        throw new TypeError('Unsupported type for Buffer.from');
+    }
+    static alloc(size, fill, encoding) {
+        // Fast path: use Uint8Array directly to avoid Buffer constructor overhead
+        const buf = new Uint8Array(size);
+        Object.setPrototypeOf(buf, Buffer.prototype);
+        if (fill !== undefined) {
+            buf.fill(fill, encoding);
+        }
+        return buf;
+    }
+    static allocUnsafe(size) {
+        // In JS, memory is always zeroed for security, so allocUnsafe is same as alloc usually.
+        // Unless we recycled buffers (not implemented).
+        // Using native allocUnsafe might give uninitialized memory, but bridge overhead (~0.05ms) 
+        // might outweight the zeroing cost (~0.02ms). 
+        // So we stick to JS native alloc for now.
+        const buf = new Uint8Array(size);
+        Object.setPrototypeOf(buf, Buffer.prototype);
+        return buf;
+    }
+    static allocUnsafeSlow(size) {
+        return Buffer.allocUnsafe(size);
+    }
+    static byteLength(string, encoding = 'utf8') {
+        return getNative().byteLength(string, encoding);
+    }
+    static isBuffer(obj) {
+        return obj instanceof Buffer;
+    }
+    static compare(buf1, buf2) {
+        return getNative().compare(buf1.buffer, buf1.byteOffset, buf1.byteLength, buf2.buffer, buf2.byteOffset, buf2.byteLength);
+    }
+    static copyBytesFrom(view, offset, length) {
+        if (offset === undefined)
+            offset = 0;
+        if (length === undefined)
+            length = view.byteLength - offset;
+        if (offset < 0 || length < 0 || offset + length > view.byteLength) {
+            throw new RangeError('offset or length out of bounds');
+        }
+        const buf = Buffer.allocUnsafe(length);
+        const src = new Uint8Array(view.buffer, view.byteOffset + offset, length);
+        buf.set(src);
+        return buf;
+    }
+    static concat(list, totalLength) {
+        if (totalLength === undefined) {
+            totalLength = list.reduce((acc, curr) => acc + curr.length, 0);
+        }
+        const buf = Buffer.allocUnsafe(totalLength);
+        let offset = 0;
+        for (const item of list) {
+            buf.set(item, offset);
+            offset += item.length;
+        }
+        return buf;
+    }
+    write(string, offset, length, encoding) {
+        // Argument handling
+        if (offset === undefined) {
+            offset = 0;
+            length = this.length;
+            encoding = 'utf8';
+        }
+        else if (length === undefined && typeof offset === 'string') {
+            encoding = offset;
+            offset = 0;
+            length = this.length;
+        }
+        else if (length === undefined) {
+            length = this.length - offset;
+            encoding = 'utf8';
+        }
+        else if (encoding === undefined) {
+            encoding = 'utf8';
+        }
+        return getNative().write(this.buffer, string, this.byteOffset + offset, length, encoding);
+    }
+    toString(encoding, start, end) {
+        if (encoding === undefined)
+            encoding = 'utf8';
+        if (start === undefined)
+            start = 0;
+        if (end === undefined)
+            end = this.length;
+        if (start < 0)
+            start = 0;
+        if (end > this.length)
+            end = this.length;
+        if (start >= end)
+            return '';
+        return getNative().decode(this.buffer, this.byteOffset + start, end - start, encoding);
+    }
+    indexOf(value, byteOffset, encoding) {
+        if (typeof value === 'string') {
+            const needle = Buffer.from(value, encoding);
+            return getNative().indexOfBuffer(this.buffer, needle.buffer, byteOffset || 0, this.length);
+        }
+        if (value instanceof Uint8Array) {
+            return getNative().indexOfBuffer(this.buffer, value.buffer, byteOffset || 0, this.length);
+        }
+        if (typeof value === 'number') {
+            return getNative().indexOf(this.buffer, value, byteOffset || 0, this.length);
+        }
+        throw new TypeError('"value" argument must be string, number or Buffer');
+    }
+    lastIndexOf(value, byteOffset, encoding) {
+        // Node.js defaults byteOffset to buf.length - 1
+        // If byteOffset is provided, it is the index to start searching backwards from.
+        // We implement this by defining a window [0, limit] where limit is calculated.
+        if (byteOffset === undefined || byteOffset > this.length) {
+            byteOffset = this.length;
+        }
+        if (typeof value === 'string') {
+            const needle = Buffer.from(value, encoding);
+            if (needle.length === 0)
+                return -1;
+            // We search in [0, byteOffset + needle.length]. 
+            // The match must start at <= byteOffset.
+            // So the match must be fully contained in [0, byteOffset + needle.length].
+            return getNative().lastIndexOfBuffer(this.buffer, needle.buffer, 0, byteOffset + needle.length);
+        }
+        if (value instanceof Uint8Array) {
+            if (value.length === 0)
+                return -1;
+            return getNative().lastIndexOfBuffer(this.buffer, value.buffer, 0, byteOffset + value.length);
+        }
+        if (typeof value === 'number') {
+            // Search in [0, byteOffset + 1]. The last byte checked is at byteOffset.
+            return getNative().lastIndexOfByte(this.buffer, value, 0, byteOffset + 1);
+        }
+        throw new TypeError('"value" argument must be string, number or Buffer');
+    }
+    includes(value, byteOffset, encoding) {
+        return this.indexOf(value, byteOffset, encoding) !== -1;
+    }
+    fill(value, offset, end, encoding) {
+        // Handle argument shifting
+        if (typeof offset === 'string') {
+            encoding = offset;
+            offset = 0;
+            end = this.length;
+        }
+        else if (typeof end === 'string') {
+            encoding = end;
+            end = this.length;
+        }
+        if (offset === undefined)
+            offset = 0;
+        if (end === undefined)
+            end = this.length;
+        const len = end - offset;
+        if (len <= 0)
+            return this;
+        if (typeof value === 'number') {
+            getNative().fill(this.buffer, value, this.byteOffset + offset, len);
+            return this;
+        }
+        let valBuf;
+        if (typeof value === 'string') {
+            valBuf = Buffer.from(value, encoding);
+        }
+        else if (value instanceof Uint8Array) {
+            valBuf = value;
+        }
+        else {
+            throw new TypeError('"value" argument must be string, number or Buffer');
+        }
+        if (valBuf.length === 0)
+            return this;
+        // Native fillBuffer takes ArrayBuffer, assumes generic fill logic
+        getNative().fillBuffer(this.buffer, valBuf.buffer, this.byteOffset + offset, len);
+        return this;
+    }
+    compare(target, targetStart, targetEnd, sourceStart, sourceEnd) {
+        if (targetStart === undefined)
+            targetStart = 0;
+        if (targetEnd === undefined)
+            targetEnd = target.length;
+        if (sourceStart === undefined)
+            sourceStart = 0;
+        if (sourceEnd === undefined)
+            sourceEnd = this.length;
+        return getNative().compare(this.buffer, this.byteOffset + sourceStart, sourceEnd - sourceStart, target.buffer, target.byteOffset + targetStart, targetEnd - targetStart);
+    }
+    slice(start, end) {
+        // Uint8Array.prototype.slice returns a copy (new buffer).
+        // Buffer.prototype.slice (legacy) returned a view.
+        // Buffer.prototype.subarray returns a view.
+        // In Node.js Buffer.slice is deprecated and acts like subarray? No, Buffer.slice returns a view (unlike Uint8Array.slice which returns copy).
+        // Wait, Node Buffer.slice returns a NEW Buffer that references the SAME memory.
+        // But Uint8Array.prototype.slice returns a COPY.
+        // So we should override slice to return a view (subarray behavior) but wrapped in Buffer?
+        // Actually Node documentation says: "The Buffer.prototype.slice() method is deprecated... use subarray() instead."
+        // BUT for compatibility, often libs expect slice to duplicate memory? No, Buffer.slice(start, end) shares memory. 
+        // Uint8Array.prototype.slice(start, end) copies memory.
+        // So we should override slice to be compatible with Node behavior (view), OR standard Uint8Array behavior (copy).
+        // Node's `slice` shares memory. `Uint8Array`'s `slice` copies. This is a conflict.
+        // Let's implement `subarray` which returns a Buffer view.
+        const sub = this.subarray(start, end);
+        // sub is Uint8Array. We need to cast it to Buffer.
+        // We can use Object.setPrototypeOf or just new Buffer via constructor that takes Uint8Array 
+        // but that constructor usually copies?
+        // `new Buffer(uint8Array)` copies.
+        // We need `new Buffer(arrayBuffer, byteOffset, length)`.
+        return new Buffer(sub.buffer, sub.byteOffset, sub.byteLength);
+    }
+    subarray(begin, end) {
+        const sub = super.subarray(begin, end);
+        // Ensure we return a Buffer, not just a Uint8Array
+        if (sub instanceof Buffer)
+            return sub;
+        // Wrap the Uint8Array's memory view into a new Buffer
+        // Note: new Buffer(arrayBuffer, byteOffset, length) creates a view
+        return new Buffer(sub.buffer, sub.byteOffset, sub.byteLength);
+    }
+    // ================== Read Methods ==================
+    readInt8(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt8(offset);
+    }
+    readUInt8(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint8(offset);
+    }
+    readInt16LE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt16(offset, true);
+    }
+    readInt16BE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt16(offset, false);
+    }
+    readUInt16LE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint16(offset, true);
+    }
+    readUInt16BE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint16(offset, false);
+    }
+    readInt32LE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt32(offset, true);
+    }
+    readInt32BE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt32(offset, false);
+    }
+    readUInt32LE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint32(offset, true);
+    }
+    readUInt32BE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint32(offset, false);
+    }
+    readBigInt64LE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getBigInt64(offset, true);
+    }
+    readBigInt64BE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getBigInt64(offset, false);
+    }
+    readBigUInt64LE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getBigUint64(offset, true);
+    }
+    readBigUInt64BE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getBigUint64(offset, false);
+    }
+    readFloatLE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getFloat32(offset, true);
+    }
+    readFloatBE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getFloat32(offset, false);
+    }
+    readDoubleLE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getFloat64(offset, true);
+    }
+    readDoubleBE(offset = 0) {
+        return new DataView(this.buffer, this.byteOffset, this.byteLength).getFloat64(offset, false);
+    }
+    readIntLE(offset, byteLength) {
+        if (offset === undefined)
+            throw new TypeError('"offset" is invalid');
+        if (byteLength > 6 || byteLength < 0)
+            throw new RangeError('"byteLength" out of range');
+        offset = offset >>> 0;
+        byteLength = byteLength >>> 0;
+        let val = this[offset];
+        let mul = 1;
+        let i = 0;
+        while (++i < byteLength && (mul *= 0x100)) {
+            val += this[offset + i] * mul;
+        }
+        mul *= 0x80;
+        if (val >= mul)
+            val -= Math.pow(2, 8 * byteLength);
+        return val;
+    }
+    readIntBE(offset, byteLength) {
+        if (offset === undefined)
+            throw new TypeError('"offset" is invalid');
+        if (byteLength > 6 || byteLength < 0)
+            throw new RangeError('"byteLength" out of range');
+        offset = offset >>> 0;
+        byteLength = byteLength >>> 0;
+        let i = byteLength;
+        let mul = 1;
+        let val = this[offset + --i];
+        while (i > 0 && (mul *= 0x100)) {
+            val += this[offset + --i] * mul;
+        }
+        mul *= 0x80;
+        if (val >= mul)
+            val -= Math.pow(2, 8 * byteLength);
+        return val;
+    }
+    readUIntLE(offset, byteLength) {
+        if (offset === undefined)
+            throw new TypeError('"offset" is invalid');
+        if (byteLength > 6 || byteLength < 0)
+            throw new RangeError('"byteLength" out of range');
+        offset = offset >>> 0;
+        byteLength = byteLength >>> 0;
+        let val = this[offset];
+        let mul = 1;
+        let i = 0;
+        while (++i < byteLength && (mul *= 0x100)) {
+            val += this[offset + i] * mul;
+        }
+        return val;
+    }
+    readUIntBE(offset, byteLength) {
+        if (offset === undefined)
+            throw new TypeError('"offset" is invalid');
+        if (byteLength > 6 || byteLength < 0)
+            throw new RangeError('"byteLength" out of range');
+        offset = offset >>> 0;
+        byteLength = byteLength >>> 0;
+        let i = byteLength;
+        let mul = 1;
+        let val = this[offset + --i];
+        while (i > 0 && (mul *= 0x100)) {
+            val += this[offset + --i] * mul;
+        }
+        return val;
+    }
+    // ================== Write Methods ==================
+    writeInt8(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setInt8(offset, value);
+        return offset + 1;
+    }
+    writeUInt8(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setUint8(offset, value);
+        return offset + 1;
+    }
+    writeInt16LE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setInt16(offset, value, true);
+        return offset + 2;
+    }
+    writeInt16BE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setInt16(offset, value, false);
+        return offset + 2;
+    }
+    writeUInt16LE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setUint16(offset, value, true);
+        return offset + 2;
+    }
+    writeUInt16BE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setUint16(offset, value, false);
+        return offset + 2;
+    }
+    writeInt32LE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setInt32(offset, value, true);
+        return offset + 4;
+    }
+    writeInt32BE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setInt32(offset, value, false);
+        return offset + 4;
+    }
+    writeUInt32LE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setUint32(offset, value, true);
+        return offset + 4;
+    }
+    writeUInt32BE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setUint32(offset, value, false);
+        return offset + 4;
+    }
+    writeBigInt64LE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setBigInt64(offset, value, true);
+        return offset + 8;
+    }
+    writeBigInt64BE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setBigInt64(offset, value, false);
+        return offset + 8;
+    }
+    writeBigUInt64LE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setBigUint64(offset, value, true);
+        return offset + 8;
+    }
+    writeBigUInt64BE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setBigUint64(offset, value, false);
+        return offset + 8;
+    }
+    writeFloatLE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setFloat32(offset, value, true);
+        return offset + 4;
+    }
+    writeFloatBE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setFloat32(offset, value, false);
+        return offset + 4;
+    }
+    writeDoubleLE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setFloat64(offset, value, true);
+        return offset + 8;
+    }
+    writeDoubleBE(value, offset = 0) {
+        new DataView(this.buffer, this.byteOffset, this.byteLength).setFloat64(offset, value, false);
+        return offset + 8;
+    }
+    writeIntLE(value, offset, byteLength) {
+        if (offset === undefined)
+            throw new TypeError('"offset" is invalid');
+        if (byteLength > 6 || byteLength < 0)
+            throw new RangeError('"byteLength" out of range');
+        offset = offset >>> 0;
+        byteLength = byteLength >>> 0;
+        let i = 0;
+        let mul = 1;
+        let sub = 0;
+        this[offset] = value & 0xFF;
+        while (++i < byteLength && (mul *= 0x100)) {
+            if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+                sub = 1;
+            }
+            this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
+        }
+        return offset + byteLength;
+    }
+    writeIntBE(value, offset, byteLength) {
+        if (offset === undefined)
+            throw new TypeError('"offset" is invalid');
+        if (byteLength > 6 || byteLength < 0)
+            throw new RangeError('"byteLength" out of range');
+        offset = offset >>> 0;
+        byteLength = byteLength >>> 0;
+        let i = byteLength - 1;
+        let mul = 1;
+        let sub = 0;
+        this[offset + i] = value & 0xFF;
+        while (--i >= 0 && (mul *= 0x100)) {
+            if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+                sub = 1;
+            }
+            this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
+        }
+        return offset + byteLength;
+    }
+    writeUIntLE(value, offset, byteLength) {
+        if (offset === undefined)
+            throw new TypeError('"offset" is invalid');
+        if (byteLength > 6 || byteLength < 0)
+            throw new RangeError('"byteLength" out of range');
+        offset = offset >>> 0;
+        byteLength = byteLength >>> 0;
+        let i = 0;
+        let mul = 1;
+        this[offset] = value & 0xFF;
+        while (++i < byteLength && (mul *= 0x100)) {
+            this[offset + i] = (value / mul) & 0xFF;
+        }
+        return offset + byteLength;
+    }
+    writeUIntBE(value, offset, byteLength) {
+        if (offset === undefined)
+            throw new TypeError('"offset" is invalid');
+        if (byteLength > 6 || byteLength < 0)
+            throw new RangeError('"byteLength" out of range');
+        offset = offset >>> 0;
+        byteLength = byteLength >>> 0;
+        let i = byteLength - 1;
+        let mul = 1;
+        this[offset + i] = value & 0xFF;
+        while (--i >= 0 && (mul *= 0x100)) {
+            this[offset + i] = (value / mul) & 0xFF;
+        }
+        return offset + byteLength;
+    }
+    // ================== Utils ==================
+    toJSON() {
+        return {
+            type: 'Buffer',
+            data: Array.from(this)
+        };
+    }
+    static isEncoding(encoding) {
+        switch (encoding.toLowerCase()) {
+            case 'utf8':
+            case 'utf-8':
+            case 'hex':
+            case 'base64':
+            case 'binary':
+            case 'latin1':
+            case 'ascii':
+            case 'utf16le':
+            case 'ucs2':
+                return true;
+            default:
+                return false;
+        }
+    }
+    swap16() {
+        const len = this.length;
+        if (len % 2 !== 0)
+            throw new RangeError('Buffer size must be a multiple of 16-bits');
+        for (let i = 0; i < len; i += 2) {
+            const v = this[i];
+            this[i] = this[i + 1];
+            this[i + 1] = v;
+        }
+        return this;
+    }
+    swap32() {
+        const len = this.length;
+        if (len % 4 !== 0)
+            throw new RangeError('Buffer size must be a multiple of 32-bits');
+        for (let i = 0; i < len; i += 4) {
+            const v0 = this[i];
+            const v1 = this[i + 1];
+            const v2 = this[i + 2];
+            const v3 = this[i + 3];
+            this[i] = v3;
+            this[i + 1] = v2;
+            this[i + 2] = v1;
+            this[i + 3] = v0;
+        }
+        return this;
+    }
+    swap64() {
+        const len = this.length;
+        if (len % 8 !== 0)
+            throw new RangeError('Buffer size must be a multiple of 64-bits');
+        for (let i = 0; i < len; i += 8) {
+            const v0 = this[i];
+            const v1 = this[i + 1];
+            const v2 = this[i + 2];
+            const v3 = this[i + 3];
+            const v4 = this[i + 4];
+            const v5 = this[i + 5];
+            const v6 = this[i + 6];
+            const v7 = this[i + 7];
+            this[i] = v7;
+            this[i + 1] = v6;
+            this[i + 2] = v5;
+            this[i + 3] = v4;
+            this[i + 4] = v3;
+            this[i + 5] = v2;
+            this[i + 6] = v1;
+            this[i + 7] = v0;
+        }
+        return this;
+    }
+    copy(target, targetStart, sourceStart, sourceEnd) {
+        if (!target)
+            throw new TypeError('argument must be a Buffer');
+        if (targetStart === undefined)
+            targetStart = 0;
+        if (sourceStart === undefined)
+            sourceStart = 0;
+        if (sourceEnd === undefined)
+            sourceEnd = this.length;
+        if (targetStart >= target.length)
+            return 0;
+        if (sourceStart >= sourceEnd)
+            return 0;
+        if (sourceStart < 0)
+            sourceStart = 0;
+        if (sourceEnd > this.length)
+            sourceEnd = this.length;
+        if (targetStart < 0)
+            targetStart = 0;
+        let len = sourceEnd - sourceStart;
+        if (target.length - targetStart < len) {
+            len = target.length - targetStart;
+        }
+        target.set(this.subarray(sourceStart, sourceStart + len), targetStart);
+        return len;
+    }
+}
+exports.Buffer = Buffer;
+Buffer.poolSize = 8192;

package/lib/NitroBuffer.nitro.d.ts

@@ -0,0 +1,18 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+export interface NitroBuffer extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    alloc(size: number): ArrayBuffer;
+    allocUnsafe(size: number): ArrayBuffer;
+    byteLength(string: string, encoding: string): number;
+    write(buffer: ArrayBuffer, string: string, offset: number, length: number, encoding: string): number;
+    decode(buffer: ArrayBuffer, offset: number, length: number, encoding: string): string;
+    compare(a: ArrayBuffer, aOffset: number, aLength: number, b: ArrayBuffer, bOffset: number, bLength: number): number;
+    fill(buffer: ArrayBuffer, value: number, offset: number, length: number): void;
+    indexOf(buffer: ArrayBuffer, value: number, offset: number, length: number): number;
+    indexOfBuffer(buffer: ArrayBuffer, needle: ArrayBuffer, offset: number, length: number): number;
+    lastIndexOfByte(buffer: ArrayBuffer, value: number, offset: number, length: number): number;
+    lastIndexOfBuffer(buffer: ArrayBuffer, needle: ArrayBuffer, offset: number, length: number): number;
+    fillBuffer(buffer: ArrayBuffer, value: ArrayBuffer, offset: number, length: number): void;
+}

package/lib/NitroBuffer.nitro.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+export { Buffer } from './Buffer';
+export * from './utils';
+export declare const INSPECT_MAX_BYTES = 50;
+export declare const kMaxLength = 2147483647;
+export declare const kStringMaxLength = 536870888;
+export declare const constants: {
+    MAX_LENGTH: number;
+    MAX_STRING_LENGTH: number;
+};
+export declare class SlowBuffer extends Uint8Array {
+    constructor(size: number);
+}