@tgsnake/bytesio 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tgsnake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# BytesIO 🚀
+
+A simple Buffer implementation inspired by Python's `BytesIO`.  
+This project was originally based on the source code from [`@tgsnake/core`](https://github.com/tgsnake/core). 🐍
+
+## Features ✨
+
+- In-memory byte stream operations 💾
+- Read and write bytes efficiently ⚡
+- Python-like API for ease of use 🐍
+
+## Installation 📦
+
+```bash
+# Example installation command
+npm install @tgsnake/bytesio
+```
+
+## Usage 🛠️
+
+```ts
+import { BytesIO } from '@tgsnake/bytesio';
+
+const stream = new BytesIO();
+stream.write(Buffer.from([1, 2, 3]));
+stream.seek(0);
+console.log(stream.read(3)); // Output: <Buffer 01 02 03>
+```

package/dist/BytesIO.d.ts

@@ -0,0 +1,33 @@
+import { Buffer } from 'node:buffer';
+export declare class BytesIO {
+    private _buffer;
+    private _post;
+    constructor(buffer?: Buffer);
+    seek(offset: number, whence?: number): number;
+    slice(...args: Array<any>): BytesIO;
+    toJSON(): {
+        type: "Buffer";
+        data: number[];
+    };
+    toString(...args: Array<any>): string;
+    read(length?: number): Buffer;
+    readInt32LE(size?: number): number;
+    readInt32BE(size?: number): number;
+    readUInt32LE(size?: number): number;
+    readUInt32BE(size?: number): number;
+    readBigInt64LE(size?: number): bigint;
+    readBigInt64BE(size?: number): bigint;
+    readBigUInt64LE(size?: number): bigint;
+    readBigUInt64BE(size?: number): bigint;
+    readDoubleLE(size?: number): number;
+    readDoubleBE(size?: number): number;
+    readFloatLE(size?: number): number;
+    readFloatBE(size?: number): number;
+    write(data: Buffer): BytesIO;
+    static alloc(size: number): BytesIO;
+    static from(input: any, encode?: any): BytesIO;
+    static concat(data: Array<Buffer>): BytesIO;
+    get length(): number;
+    get buffer(): Buffer;
+    get post(): number;
+}

package/dist/BytesIO.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytesIO = void 0;
+const node_buffer_1 = require("node:buffer");
+class BytesIO {
+    _buffer;
+    _post;
+    constructor(buffer = node_buffer_1.Buffer.alloc(0)) {
+        this._post = 0;
+        this._buffer = buffer;
+        return this;
+    }
+    seek(offset, whence = 0) {
+        if (whence === 0) {
+            if (offset < 0) {
+                throw new Error(`offset of BytesIO.seek must be zero or positive value when whence is 0`);
+            }
+            this._post = whence;
+        }
+        else if (whence === 1) {
+            this._post += offset;
+        }
+        else if (whence === 2) {
+            if (offset >= 0) {
+                throw new Error(`offset of BytesIO.seek must be less than zero or negative value when whence is 2`);
+            }
+            if (node_buffer_1.Buffer.byteLength(this._buffer) + offset < 0) {
+                throw new Error(`offset out of range, offset ${offset} is less than the available buffer length.`);
+            }
+            this._post = node_buffer_1.Buffer.byteLength(this._buffer) + offset;
+        }
+        else {
+            throw new Error(`whence must be 0 or 1 or 2, but receive ${whence}`);
+        }
+        return this._post;
+    }
+    slice(...args) {
+        return new BytesIO(this._buffer.subarray(...args));
+    }
+    toJSON() {
+        return this._buffer.toJSON();
+    }
+    toString(...args) {
+        return this._buffer.toString(...args);
+    }
+    read(length) {
+        if (length === undefined) {
+            const results = this._buffer.subarray(this._post);
+            this.seek(node_buffer_1.Buffer.byteLength(results), 1);
+            return results;
+        }
+        if (length >= 1 && this._post <= node_buffer_1.Buffer.byteLength(this._buffer)) {
+            const results = this._buffer.subarray(this._post, this._post + length);
+            this.seek(length, 1);
+            return results;
+        }
+        return node_buffer_1.Buffer.alloc(0);
+    }
+    readInt32LE(size = 4) {
+        const results = this._buffer.readInt32LE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readInt32BE(size = 4) {
+        const results = this._buffer.readInt32BE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readUInt32LE(size = 4) {
+        const results = this._buffer.readUInt32LE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readUInt32BE(size = 4) {
+        const results = this._buffer.readInt32BE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readBigInt64LE(size = 8) {
+        const results = this._buffer.readBigInt64LE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readBigInt64BE(size = 8) {
+        const results = this._buffer.readBigInt64BE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readBigUInt64LE(size = 8) {
+        const results = this._buffer.readBigUInt64LE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readBigUInt64BE(size = 8) {
+        const results = this._buffer.readBigUInt64BE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readDoubleLE(size = 8) {
+        const results = this._buffer.readDoubleLE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readDoubleBE(size = 8) {
+        const results = this._buffer.readDoubleBE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readFloatLE(size = 4) {
+        const results = this._buffer.readFloatLE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    readFloatBE(size = 4) {
+        const results = this._buffer.readFloatBE(this._post);
+        this.seek(size, 1);
+        return results;
+    }
+    write(data) {
+        this._buffer = node_buffer_1.Buffer.concat([
+            this._buffer,
+            data,
+        ]);
+        return this;
+    }
+    static alloc(size) {
+        return new BytesIO(node_buffer_1.Buffer.alloc(size));
+    }
+    static from(input, encode) {
+        return new BytesIO(node_buffer_1.Buffer.from(input, encode));
+    }
+    static concat(data) {
+        return new BytesIO(node_buffer_1.Buffer.concat(data));
+    }
+    get length() {
+        return node_buffer_1.Buffer.byteLength(this._buffer);
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    get post() {
+        return this._post;
+    }
+}
+exports.BytesIO = BytesIO;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.BytesIO = void 0;
+var BytesIO_js_1 = require("./BytesIO.js");
+Object.defineProperty(exports, "BytesIO", { enumerable: true, get: function () { return BytesIO_js_1.BytesIO; } });
+var BytesIO_js_2 = require("./BytesIO.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return BytesIO_js_2.BytesIO; } });

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@tgsnake/bytesio",
+  "packageManager": "yarn@4.9.2",
+  "version": "1.0.0",
+  "description": "A simple BytesIO implementation for Typescript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepare": "yarn build",
+    "prettier": "NODE_OPTIONS=--max_old_space_size=4096 prettier -w .",
+    "docs": "typedoc --out docs src/BytesIO.ts --excludePrivate --excludeProtected --excludeInternal --theme default --readme none"
+  },
+  "homepage": "https://tgsnake.js.org",
+  "keywords": [
+    "tgsnake",
+    "BytesIO",
+    "Buffer"
+  ],
+  "bugs": "https://github.com/tgsnake/bytesio/issues",
+  "repository": "https://github.com/tgsnake/bytesio",
+  "author": "butthx",
+  "files": [
+    "dist/**/**"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "^1.2.18",
+    "@types/node": "^24.0.13",
+    "prettier": "^3.6.2",
+    "typedoc": "^0.28.7",
+    "typescript": "^5.8.3"
+  }
+}