pw-buffer 2.0.1 → 3.0.0

package/README.md

@@ -1,18 +1,263 @@
-# node-pw-buffer
-PW Buffer
+# Perfect World binary utils
 
-```typescript
-import { ExtendedBuffer, ExtendedBufferOptions } from 'extended-buffer';
-export interface PwBufferOptions extends ExtendedBufferOptions {
-}
-export declare class PwBuffer extends ExtendedBuffer {
-    isReadableCUInt(): boolean;
-    readCUInt(noAssert?: boolean): number;
-    _writeCUIntToBuffer(buffer: this, value: number, noAssert?: boolean): this;
-    writeCUInt(value: number, unshift?: boolean, noAssert?: boolean): this;
-    readPwString(noAssert?: boolean): string;
-    writePwString(string: string, unshift?: boolean, noAssert?: boolean): this;
-    readPwOctets(noAssert?: boolean): this;
-    writePwOctets(octets: this | Buffer, unshift?: boolean, noAssert?: boolean): this;
+A small TypeScript/Node.js library built on top of [extended-buffer](https://github.com/mvcbox/node-extended-buffer) that adds helpers commonly found in some Perfect World / PW-style binary protocols:
+
+- **CUInt** (compressed unsigned integer) encoding/decoding
+- **PW strings**: `CUInt` byte-length prefix + `utf16le` payload
+- **PW octets**: `CUInt` byte-length prefix + raw bytes
+- **MPPC** compressor/decompressor (stream-friendly) plus optional Node.js `Transform` wrappers
+
+## Install
+
+```bash
+npm i pw-buffer
+```
+
+## Quick start
+
+```ts
+import { PwBuffer } from 'pw-buffer';
+
+const b = new PwBuffer();
+
+b.writeCUInt(123);
+b.writePwString('Hello');
+b.writePwOctets(Buffer.from([1, 2, 3]));
+
+// Read back
+console.log(b.readCUInt());      // 123
+console.log(b.readPwString());   // "Hello"
+console.log(b.readPwOctets().nativeBufferView); // <Buffer 01 02 03>
+```
+
+## What is `PwBuffer`?
+
+`PwBuffer` extends `ExtendedBuffer` from the `extended-buffer` package. That means you get all of `ExtendedBuffer` features (growable buffer, internal read pointer, append/prepend writes, etc.), plus PW-specific helpers.
+
+### Append vs prepend (`unshift`)
+
+Most write methods support an optional `unshift?: boolean` flag:
+
+- `unshift = false` (default): append to the end
+- `unshift = true`: prepend to the start
+
+This is useful when you want to write a payload first and then prepend headers (length, opcode, etc.).
+
+Example: build a length-prefixed packet
+
+```ts
+import { PwBuffer } from 'pw-buffer';
+
+const pkt = new PwBuffer();
+
+pkt.writePwString('Alice');       // body
+pkt.writePwString('Bob');         //
+
+// Prepend total byte length (example protocol convention)
+pkt.writeCUInt(pkt.length, true); // length
+pkt.writeCUInt(0x1234, true);     // opcode
+
+console.log(pkt.nativeBufferView);
+```
+
+## API
+
+The package exports:
+
+```ts
+export * from './utils';
+export { PwBuffer } from './PwBuffer';
+export type { PwBufferOptions } from './PwBufferOptions';
+export { MppcCompressor, MppcDecompressor } from './mppc';
+export { MppcCompressorTransform } from './MppcCompressorTransform';
+export { MppcDecompressorTransform } from './MppcDecompressorTransform';
+```
+
+### `PwBuffer(options?: PwBufferOptions)`
+
+`PwBufferOptions` is currently the same as `ExtendedBufferOptions`:
+
+- `capacity?: number` – initial capacity (bytes)
+- `capacityStep?: number` – resize step (bytes)
+
+Example:
+
+```ts
+import { PwBuffer } from 'pw-buffer';
+
+const b = new PwBuffer({ capacity: 64 * 1024, capacityStep: 16 * 1024 });
+```
+
+### `isReadableCUInt(): boolean`
+
+Checks whether a full `CUInt` value can be read at the current read pointer without running out of data.
+
+This is handy when you parse a stream and may receive partial frames.
+
+```ts
+if (b.isReadableCUInt()) {
+  const len = b.readCUInt();
+  // ...
 }
 ```
+
+### `readCUInt(): number`
+
+Reads a **compressed unsigned integer** at the current read pointer.
+
+- Returns a JavaScript `number` in the range **0…0xFFFFFFFF**.
+- Advances the read pointer.
+
+If there are not enough readable bytes, underlying `extended-buffer` reads may throw.
+
+### `writeCUInt(value: number, unshift?: boolean): this`
+
+Writes a **compressed unsigned integer**.
+
+- `value` must be an **integer** in **0…0xFFFFFFFF**.
+- If the value is outside the allowed range, it throws an `ExtendedBufferRangeError('CUINT_VALUE_OUT_OF_RANGE')`.
+
+```ts
+b.writeCUInt(1);
+b.writeCUInt(127);
+b.writeCUInt(128);
+b.writeCUInt(0xFFFFFFFF);
+```
+
+### CUInt encoding format
+
+CUInt uses a leading-bit pattern to choose the byte width:
+
+| Range | Encoded bytes | Notes                           |
+|------:|:-------------:|---------------------------------|
+| `0x00000000 … 0x0000007F` | 1 | `0xxxxxxx`                      |
+| `0x00000080 … 0x00003FFF` | 2 | stored as `value \| 0x8000`     |
+| `0x00004000 … 0x1FFFFFFF` | 4 | stored as `value \| 0xC0000000` |
+| `0x20000000 … 0xFFFFFFFF` | 5 | marker `0xE0` + 4-byte BE value |
+
+> Implementation note: in the 5-byte case, the first byte is the marker `0xE0`, followed by the 32-bit big-endian value.
+
+### `readPwString(): string`
+
+Reads a PW string:
+
+1. Reads a `CUInt` **byte length** `N`
+2. Reads `N` bytes and decodes them as `utf16le`
+
+```ts
+const s = b.readPwString();
+```
+
+### `writePwString(value: string, unshift?: boolean): this`
+
+Writes a PW string:
+
+1. Encodes the string to bytes using `utf16le`
+2. Writes `CUInt(byteLength)`
+3. Writes the bytes
+
+```ts
+b.writePwString('Hello');
+```
+
+### `readPwOctets(): PwBuffer`
+
+Reads PW octets:
+
+1. Reads a `CUInt` **byte length** `N`
+2. Reads `N` raw bytes
+3. Returns a **new** `PwBuffer` containing only those bytes
+
+```ts
+const oct = b.readPwOctets();
+console.log(oct.length);
+console.log(oct.nativeBufferView);
+```
+
+### `writePwOctets(octets: ExtendedBuffer | Buffer, unshift?: boolean): this`
+
+Writes PW octets:
+
+1. Writes `CUInt(octets.length)`
+2. Writes raw `octets` bytes
+
+```ts
+b.writePwOctets(Buffer.from([0xde, 0xad, 0xbe, 0xef]));
+```
+
+## MPPC compression
+
+The library includes a streaming MPPC compressor and decompressor:
+
+- `MppcCompressor.update(chunk: Buffer): Buffer`
+- `MppcDecompressor.update(chunk: Buffer): Buffer`
+
+Both are **stateful**. Create a new instance per independent stream/connection.
+
+### Basic usage
+
+```ts
+import { MppcCompressor, MppcDecompressor } from 'pw-buffer';
+
+const input = Buffer.from('hello hello hello', 'utf8');
+
+const c = new MppcCompressor();
+const compressed = c.update(input);
+
+const d = new MppcDecompressor();
+const decompressed = d.update(compressed);
+
+console.log(decompressed.toString('utf8')); // "hello hello hello"
+```
+
+### Streaming usage (chunked)
+
+```ts
+import { MppcCompressor, MppcDecompressor } from 'pw-buffer';
+
+const c = new MppcCompressor();
+const d = new MppcDecompressor();
+
+const part1 = Buffer.from('hello ', 'utf8');
+const part2 = Buffer.from('world', 'utf8');
+
+const c1 = c.update(part1);
+const c2 = c.update(part2);
+
+const out1 = d.update(c1);
+const out2 = d.update(c2);
+
+console.log(Buffer.concat([out1, out2]).toString('utf8')); // "hello world"
+```
+
+## MPPC `Transform` streams
+
+If you prefer Node.js stream piping, you can use the provided transforms:
+
+- `MppcCompressorTransform`
+- `MppcDecompressorTransform`
+
+```ts
+import fs from 'node:fs';
+import { MppcCompressorTransform, MppcDecompressorTransform } from 'pw-buffer';
+
+// Compress a file
+fs.createReadStream('input.bin')
+  .pipe(new MppcCompressorTransform())
+  .pipe(fs.createWriteStream('input.bin.mppc'));
+
+// Decompress a file
+fs.createReadStream('input.bin.mppc')
+  .pipe(new MppcDecompressorTransform())
+  .pipe(fs.createWriteStream('input.bin'));
+```
+
+## Error handling tips
+
+- Before reading from a buffer fed by a socket/stream, prefer guard checks such as `isReadable(size)` (from `ExtendedBuffer`) and `isReadableCUInt()`.
+- `writeCUInt()` validates the value is an integer and within `0…0xFFFFFFFF`.
+- If you need the full set of buffer operations (pointer control, reading/writing primitives, etc.), refer to the upstream [extended-buffer](https://github.com/mvcbox/node-extended-buffer) documentation.
+
+## License
+
+MIT (see the package metadata).

package/dist/MppcCompressorTransform.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { MppcCompressor } from './mppc';
+import { Transform, TransformOptions } from 'stream';
+export declare class MppcCompressorTransform extends Transform {
+    protected readonly _mppcCompressor: MppcCompressor;
+    constructor(transformOptions?: TransformOptions);
+    _transform(chunk: Buffer | null, encoding: string, callback: Function): void;
+}

package/dist/MppcCompressorTransform.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MppcCompressorTransform = void 0;
+const mppc_1 = require("./mppc");
+const stream_1 = require("stream");
+class MppcCompressorTransform extends stream_1.Transform {
+    constructor(transformOptions) {
+        super(transformOptions);
+        this._mppcCompressor = new mppc_1.MppcCompressor();
+    }
+    _transform(chunk, encoding, callback) {
+        callback(null, chunk ? this._mppcCompressor.update(chunk) : null);
+    }
+}
+exports.MppcCompressorTransform = MppcCompressorTransform;

package/dist/MppcDecompressorTransform.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { MppcDecompressor } from './mppc';
+import { Transform, TransformOptions } from 'stream';
+export declare class MppcDecompressorTransform extends Transform {
+    protected readonly _mppcDecompressor: MppcDecompressor;
+    constructor(transformOptions?: TransformOptions);
+    _transform(chunk: Buffer | null, encoding: string, callback: Function): void;
+}

package/dist/MppcDecompressorTransform.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MppcDecompressorTransform = void 0;
+const mppc_1 = require("./mppc");
+const stream_1 = require("stream");
+class MppcDecompressorTransform extends stream_1.Transform {
+    constructor(transformOptions) {
+        super(transformOptions);
+        this._mppcDecompressor = new mppc_1.MppcDecompressor();
+    }
+    _transform(chunk, encoding, callback) {
+        callback(null, chunk ? this._mppcDecompressor.update(chunk) : null);
+    }
+}
+exports.MppcDecompressorTransform = MppcDecompressorTransform;

package/dist/PwBuffer.d.ts

@@ -1,14 +1,13 @@
 /// <reference types="node" />
-import { ExtendedBuffer, ExtendedBufferOptions } from 'extended-buffer';
-export interface PwBufferOptions extends ExtendedBufferOptions {
-}
+import { ExtendedBuffer } from 'extended-buffer';
+import type { PwBufferOptions } from './PwBufferOptions';
 export declare class PwBuffer extends ExtendedBuffer {
+    protected createInstance(options?: PwBufferOptions): this;
     isReadableCUInt(): boolean;
-    readCUInt(noAssert?: boolean): number;
-    _writeCUIntToBuffer(buffer: ExtendedBuffer, value: number, noAssert?: boolean): this;
-    writeCUInt(value: number, unshift?: boolean, noAssert?: boolean): this;
-    readPwString(noAssert?: boolean): string;
-    writePwString(string: string, unshift?: boolean, noAssert?: boolean): this;
-    readPwOctets(noAssert?: boolean): this;
-    writePwOctets(octets: ExtendedBuffer | Buffer, unshift?: boolean, noAssert?: boolean): this;
+    readCUInt(): number;
+    writeCUInt(value: number, unshift?: boolean): this;
+    readPwString(): string;
+    writePwString(string: string, unshift?: boolean): this;
+    readPwOctets(): this;
+    writePwOctets(octets: ExtendedBuffer | Buffer, unshift?: boolean): this;
 }

package/dist/PwBuffer.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const extended_buffer_1 = require("extended-buffer");
+exports.PwBuffer = void 0;
 const buffer_1 = require("buffer");
+const utils = require("./utils");
+const extended_buffer_1 = require("extended-buffer");
 class PwBuffer extends extended_buffer_1.ExtendedBuffer {
+    createInstance(options) {
+        const ThisClass = this.constructor;
+        return new ThisClass(options);
+    }
     isReadableCUInt() {
         if (!this.isReadable(1)) {
             return false;
         }
         let value = this.readUIntBE(1);
-        --this._pointer;
+        this._pointer--;
         switch (value & 0xE0) {
             case 0xE0:
                 return this.isReadable(5);
@@ -20,78 +26,55 @@ class PwBuffer extends extended_buffer_1.ExtendedBuffer {
         }
         return true;
     }
-    readCUInt(noAssert) {
-        let value = this.readUIntBE(1, noAssert);
+    readCUInt() {
+        let value = this.readUIntBE(1);
         switch (value & 0xE0) {
-            case 0xE0:
-                return this.readUIntBE(4, noAssert);
-            case 0xC0:
-                --this._pointer;
-                return this.readUIntBE(4, noAssert) & 0x1FFFFFFF;
-            case 0x80:
-            case 0xA0:
-                --this._pointer;
-                return this.readUIntBE(2, noAssert) & 0x3FFF;
-        }
-        return value;
-    }
-    _writeCUIntToBuffer(buffer, value, noAssert) {
-        let tmp;
-        if (value < 0x80) {
-            buffer.writeUIntBE(value, 1, false, noAssert);
-        }
-        else if (value < 0x4000) {
-            if ((tmp = value | 0x8000) < 0) {
-                buffer.writeIntBE(tmp, 2, false, noAssert);
-            }
-            else {
-                buffer.writeUIntBE(tmp, 2, false, noAssert);
+            case 0xE0: {
+                try {
+                    return this.readUIntBE(4);
+                }
+                catch (e) {
+                    this._pointer--;
+                }
             }
-        }
-        else if (value < 0x20000000) {
-            if ((tmp = value | 0xC0000000) < 0) {
-                buffer.writeIntBE(tmp, 4, false, noAssert);
+            case 0xC0: {
+                this._pointer--;
+                return this.readUIntBE(4) & 0x1FFFFFFF;
             }
-            else {
-                buffer.writeUIntBE(tmp, 4, false, noAssert);
+            case 0x80:
+            case 0xA0: {
+                this._pointer--;
+                return this.readUIntBE(2) & 0x3FFF;
             }
         }
-        else {
-            buffer.writeUIntBE(0xE0, 1, false, noAssert).writeUIntBE(value, 4, false, noAssert);
-        }
-        return this;
+        return value;
     }
-    writeCUInt(value, unshift, noAssert) {
-        if (unshift) {
-            const ThisClass = this.constructor;
-            let buffer = new ThisClass({
-                maxBufferLength: 5
-            });
-            buffer.allocEnd(buffer.getFreeSpace());
-            return this._writeCUIntToBuffer(buffer, value, noAssert)._writeNativeBuffer(buffer.buffer, true);
-        }
-        return this._writeCUIntToBuffer(this, value, noAssert);
+    writeCUInt(value, unshift) {
+        utils.writeCUIntToPwBuffer(this, value, unshift);
+        return this;
     }
-    readPwString(noAssert) {
-        return this.readString(this.readCUInt(noAssert), 'utf16le');
+    readPwString() {
+        return this.readString(this.readCUInt(), 'utf16le');
     }
-    writePwString(string, unshift, noAssert) {
+    writePwString(string, unshift) {
+        const bytes = buffer_1.Buffer.from(string, 'utf16le');
         if (unshift) {
-            return this.writeString(string, 'utf16le', true).writeCUInt(buffer_1.Buffer.byteLength(string, 'utf16le'), true, noAssert);
+            return this.writeNativeBuffer(bytes, true).writeCUInt(bytes.length, true);
         }
-        return this.writeCUInt(buffer_1.Buffer.byteLength(string, 'utf16le'), false, noAssert).writeString(string, 'utf16le', false);
+        return this.writeCUInt(bytes.length).writeNativeBuffer(bytes);
     }
-    readPwOctets(noAssert) {
-        let byteLength = this.readCUInt(noAssert);
+    readPwOctets() {
+        let byteLength = this.readCUInt();
         return this.readBuffer(byteLength, false, {
-            maxBufferLength: byteLength
+            capacity: byteLength,
+            capacityStep: 0
         });
     }
-    writePwOctets(octets, unshift, noAssert) {
+    writePwOctets(octets, unshift) {
         if (unshift) {
-            return this.writeBuffer(octets, true).writeCUInt(octets.length, true, noAssert);
+            return this.writeBuffer(octets, true).writeCUInt(octets.length, true);
         }
-        return this.writeCUInt(octets.length, false, noAssert).writeBuffer(octets, false);
+        return this.writeCUInt(octets.length).writeBuffer(octets);
     }
 }
 exports.PwBuffer = PwBuffer;

package/dist/PwBufferOptions.d.ts

@@ -0,0 +1,2 @@
+import { ExtendedBufferOptions } from 'extended-buffer';
+export type PwBufferOptions = ExtendedBufferOptions;

package/dist/PwBufferOptions.js

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

package/dist/index.d.ts

@@ -1 +1,6 @@
-export * from './PwBuffer';
+export * from './utils';
+export { PwBuffer } from './PwBuffer';
+export type { PwBufferOptions } from './PwBufferOptions';
+export { MppcCompressor, MppcDecompressor } from './mppc';
+export { MppcCompressorTransform } from './MppcCompressorTransform';
+export { MppcDecompressorTransform } from './MppcDecompressorTransform';

package/dist/index.js

@@ -1,6 +1,27 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./PwBuffer"));
+exports.MppcDecompressorTransform = exports.MppcCompressorTransform = exports.MppcDecompressor = exports.MppcCompressor = exports.PwBuffer = void 0;
+__exportStar(require("./utils"), exports);
+var PwBuffer_1 = require("./PwBuffer");
+Object.defineProperty(exports, "PwBuffer", { enumerable: true, get: function () { return PwBuffer_1.PwBuffer; } });
+var mppc_1 = require("./mppc");
+Object.defineProperty(exports, "MppcCompressor", { enumerable: true, get: function () { return mppc_1.MppcCompressor; } });
+Object.defineProperty(exports, "MppcDecompressor", { enumerable: true, get: function () { return mppc_1.MppcDecompressor; } });
+var MppcCompressorTransform_1 = require("./MppcCompressorTransform");
+Object.defineProperty(exports, "MppcCompressorTransform", { enumerable: true, get: function () { return MppcCompressorTransform_1.MppcCompressorTransform; } });
+var MppcDecompressorTransform_1 = require("./MppcDecompressorTransform");
+Object.defineProperty(exports, "MppcDecompressorTransform", { enumerable: true, get: function () { return MppcDecompressorTransform_1.MppcDecompressorTransform; } });

package/dist/mppc.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+export declare class MppcDecompressor {
+    private history;
+    private histPtr;
+    private bitOffset;
+    private legacy;
+    update(chunk: Buffer): Buffer;
+}
+export declare class MppcCompressor {
+    private history;
+    private histPtr;
+    private readonly bw;
+    private readonly dict;
+    private key3;
+    private addPosToDict;
+    private pushHistoryByte;
+    private writeLiteral;
+    private writeOffset;
+    private writeLength;
+    private writeFlushMarker;
+    private resetSegment;
+    update(chunk: Buffer): Buffer;
+}

package/dist/mppc.js

@@ -0,0 +1,445 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MppcCompressor = exports.MppcDecompressor = void 0;
+const buffer_1 = require("buffer");
+const extended_buffer_1 = require("extended-buffer");
+const MPPC_HIST_LEN = 8192;
+function readU32BEWithPadding(buffer, offset) {
+    const b0 = offset < buffer.length ? buffer[offset] : 0;
+    const b1 = offset + 1 < buffer.length ? buffer[offset + 1] : 0;
+    const b2 = offset + 2 < buffer.length ? buffer[offset + 2] : 0;
+    const b3 = offset + 3 < buffer.length ? buffer[offset + 3] : 0;
+    return (((b0 << 24) | (b1 << 16) | (b2 << 8) | b3) >>> 0);
+}
+class BitWriter {
+    constructor() {
+        this.out = [];
+        this.bitBuf = 0;
+        this.bitCount = 0;
+    }
+    writeBits(value, bits) {
+        if (bits <= 0) {
+            return;
+        }
+        if (bits > 31) {
+            throw new Error(`BitWriter.writeBits: bits=${bits} too large`);
+        }
+        const mask = bits === 31 ? 0x7FFFFFFF : (1 << bits) - 1;
+        const v = (value & mask) >>> 0;
+        this.bitBuf = (this.bitBuf * (Math.pow(2, bits))) + v;
+        this.bitCount += bits;
+        while (this.bitCount >= 8) {
+            const shift = this.bitCount - 8;
+            const byte = Math.floor(this.bitBuf / (Math.pow(2, shift))) & 0xFF;
+            this.out.push(byte);
+            this.bitCount -= 8;
+            if (this.bitCount === 0) {
+                this.bitBuf = 0;
+            }
+            else {
+                this.bitBuf = this.bitBuf % (Math.pow(2, this.bitCount));
+            }
+        }
+    }
+    alignToByteWithZeroPadding() {
+        const mod = this.bitCount & 7;
+        if (mod) {
+            this.writeBits(0, 8 - mod);
+        }
+    }
+    flushBytes() {
+        if (!this.out.length) {
+            return buffer_1.Buffer.alloc(0);
+        }
+        const buffer = buffer_1.Buffer.from(this.out);
+        this.out = [];
+        return buffer;
+    }
+    getPendingBitCount() {
+        return this.bitCount;
+    }
+}
+class MppcDecompressor {
+    constructor() {
+        this.history = new Uint8Array(MPPC_HIST_LEN);
+        this.histPtr = 0;
+        this.bitOffset = 0;
+        this.legacy = buffer_1.Buffer.alloc(0);
+    }
+    update(chunk) {
+        if (chunk.length) {
+            this.legacy = buffer_1.Buffer.concat([this.legacy, chunk]);
+        }
+        let rptr = 0;
+        let bitShift = this.bitOffset;
+        let consumedBits = 7;
+        const totalBits = this.legacy.length * 8 - bitShift;
+        let savedBitShift = 0;
+        let savedRptr = 0;
+        const outParts = [];
+        let histHead = this.histPtr;
+        const passBits = (n) => {
+            bitShift += n;
+            consumedBits += n;
+            if (consumedBits < totalBits) {
+                return true;
+            }
+            bitShift = savedBitShift;
+            rptr = savedRptr;
+            return false;
+        };
+        const fetch = () => {
+            rptr += bitShift >>> 3;
+            bitShift &= 7;
+            return ((readU32BEWithPadding(this.legacy, rptr) << bitShift) >>> 0);
+        };
+        while (totalBits > consumedBits) {
+            savedBitShift = bitShift;
+            savedRptr = rptr;
+            let val = fetch();
+            if (val < 0x80000000) {
+                if (!passBits(8)) {
+                    break;
+                }
+                this.history[this.histPtr++] = (val >>> 24) & 0xFF;
+                continue;
+            }
+            if (val < 0xC0000000) {
+                if (!passBits(9)) {
+                    break;
+                }
+                this.history[this.histPtr++] = (((val >>> 23) | 0x80) & 0xFF) >>> 0;
+                continue;
+            }
+            let off = 0;
+            if (val >= 0xF0000000) {
+                if (!passBits(10)) {
+                    break;
+                }
+                off = (val >>> 22) & 0x3F;
+                if (off === 0) {
+                    const advance = 8 - (bitShift & 7);
+                    if (advance < 8) {
+                        if (!passBits(advance)) {
+                            break;
+                        }
+                    }
+                    if (this.histPtr > histHead) {
+                        outParts.push(buffer_1.Buffer.from(this.history.subarray(histHead, this.histPtr)));
+                    }
+                    if (this.histPtr === MPPC_HIST_LEN) {
+                        this.histPtr = 0;
+                    }
+                    histHead = this.histPtr;
+                    continue;
+                }
+            }
+            else if (val >= 0xE0000000) {
+                if (!passBits(12)) {
+                    break;
+                }
+                off = ((val >>> 20) & 0xFF) + 64;
+            }
+            else if (val >= 0xC0000000) {
+                if (!passBits(16)) {
+                    break;
+                }
+                off = ((val >>> 16) & 0x1FFF) + 320;
+            }
+            val = fetch();
+            let len = 0;
+            if (val < 0x80000000) {
+                if (!passBits(1)) {
+                    break;
+                }
+                len = 3;
+            }
+            else if (val < 0xC0000000) {
+                if (!passBits(4)) {
+                    break;
+                }
+                len = 4 | ((val >>> 28) & 3);
+            }
+            else if (val < 0xE0000000) {
+                if (!passBits(6)) {
+                    break;
+                }
+                len = 8 | ((val >>> 26) & 7);
+            }
+            else if (val < 0xF0000000) {
+                if (!passBits(8)) {
+                    break;
+                }
+                len = 16 | ((val >>> 24) & 15);
+            }
+            else if (val < 0xF8000000) {
+                if (!passBits(10)) {
+                    break;
+                }
+                len = 32 | ((val >>> 22) & 0x1F);
+            }
+            else if (val < 0xFC000000) {
+                if (!passBits(12)) {
+                    break;
+                }
+                len = 64 | ((val >>> 20) & 0x3F);
+            }
+            else if (val < 0xFE000000) {
+                if (!passBits(14)) {
+                    break;
+                }
+                len = 128 | ((val >>> 18) & 0x7F);
+            }
+            else if (val < 0xFF000000) {
+                if (!passBits(16)) {
+                    break;
+                }
+                len = 256 | ((val >>> 16) & 0xFF);
+            }
+            else if (val < 0xFF800000) {
+                if (!passBits(18)) {
+                    break;
+                }
+                len = 0x200 | ((val >>> 14) & 0x1FF);
+            }
+            else if (val < 0xFFC00000) {
+                if (!passBits(20)) {
+                    break;
+                }
+                len = 0x400 | ((val >>> 12) & 0x3FF);
+            }
+            else if (val < 0xFFE00000) {
+                if (!passBits(22)) {
+                    break;
+                }
+                len = 0x800 | ((val >>> 10) & 0x7FF);
+            }
+            else if (val < 0xFFF00000) {
+                if (!passBits(24)) {
+                    break;
+                }
+                len = 0x1000 | ((val >>> 8) & 0xFFF);
+            }
+            else {
+                bitShift = savedBitShift;
+                rptr = savedRptr;
+                break;
+            }
+            const src = this.histPtr - off;
+            const dstEnd = this.histPtr + len;
+            if (src < 0 || dstEnd > MPPC_HIST_LEN) {
+                break;
+            }
+            for (let i = 0; i < len; i++) {
+                this.history[this.histPtr + i] = this.history[src + i];
+            }
+            this.histPtr = dstEnd;
+        }
+        if (this.histPtr > histHead) {
+            outParts.push(buffer_1.Buffer.from(this.history.subarray(histHead, this.histPtr)));
+        }
+        this.legacy = (0, extended_buffer_1.nativeBufferSubarray)(this.legacy, rptr);
+        this.bitOffset = bitShift;
+        return outParts.length ? buffer_1.Buffer.concat(outParts) : buffer_1.Buffer.alloc(0);
+    }
+}
+exports.MppcDecompressor = MppcDecompressor;
+class MppcCompressor {
+    constructor() {
+        this.history = new Uint8Array(MPPC_HIST_LEN);
+        this.histPtr = 0;
+        this.bw = new BitWriter();
+        this.dict = new Map();
+    }
+    key3(b0, b1, b2) {
+        return ((b0 & 0xFF) << 16) | ((b1 & 0xFF) << 8) | (b2 & 0xFF);
+    }
+    addPosToDict(pos) {
+        if (pos < 0 || pos + 2 >= this.histPtr) {
+            return;
+        }
+        const key = this.key3(this.history[pos], this.history[pos + 1], this.history[pos + 2]);
+        let arr = this.dict.get(key);
+        if (!arr) {
+            arr = [];
+            this.dict.set(key, arr);
+        }
+        arr.push(pos);
+        if (arr.length > 64) {
+            arr.splice(0, arr.length - 64);
+        }
+    }
+    pushHistoryByte(b) {
+        this.history[this.histPtr] = b & 0xFF;
+        this.histPtr++;
+        this.addPosToDict(this.histPtr - 3);
+    }
+    writeLiteral(b) {
+        if ((b & 0x80) === 0) {
+            this.bw.writeBits(b & 0xFF, 8);
+            return;
+        }
+        this.bw.writeBits(0x100 | (b & 0x7F), 9);
+    }
+    writeOffset(off) {
+        if (off < 0) {
+            throw new Error(`MPPC offset underflow: ${off}`);
+        }
+        if (off < 64) {
+            this.bw.writeBits((0b1111 << 6) | (off & 0x3F), 10);
+            return;
+        }
+        if (off < 320) {
+            this.bw.writeBits((0b1110 << 8) | ((off - 64) & 0xFF), 12);
+            return;
+        }
+        this.bw.writeBits((0b110 << 13) | ((off - 320) & 0x1FFF), 16);
+    }
+    writeLength(len) {
+        if (len < 3) {
+            throw new Error(`MPPC length too small: ${len}`);
+        }
+        if (len === 3) {
+            this.bw.writeBits(0, 1);
+            return;
+        }
+        if (len <= 7) {
+            this.bw.writeBits((0b10 << 2) | (len - 4), 4);
+            return;
+        }
+        if (len <= 15) {
+            this.bw.writeBits((0b110 << 3) | (len - 8), 6);
+            return;
+        }
+        if (len <= 31) {
+            this.bw.writeBits((0b1110 << 4) | (len - 16), 8);
+            return;
+        }
+        if (len <= 63) {
+            this.bw.writeBits((0b11110 << 5) | (len - 32), 10);
+            return;
+        }
+        if (len <= 127) {
+            this.bw.writeBits((0b111110 << 6) | (len - 64), 12);
+            return;
+        }
+        if (len <= 255) {
+            this.bw.writeBits((0b1111110 << 7) | (len - 128), 14);
+            return;
+        }
+        if (len <= 511) {
+            this.bw.writeBits((0b11111110 << 8) | (len - 256), 16);
+            return;
+        }
+        if (len <= 1023) {
+            this.bw.writeBits((0b111111110 << 9) | (len - 512), 18);
+            return;
+        }
+        if (len <= 2047) {
+            this.bw.writeBits((0b1111111110 << 10) | (len - 1024), 20);
+            return;
+        }
+        if (len <= 4095) {
+            this.bw.writeBits((0b11111111110 << 11) | (len - 2048), 22);
+            return;
+        }
+        if (len <= 8191) {
+            this.bw.writeBits((0b111111111110 << 12) | (len - 4096), 24);
+            return;
+        }
+        throw new Error(`MPPC length too large: ${len}`);
+    }
+    writeFlushMarker() {
+        this.writeOffset(0);
+        this.bw.alignToByteWithZeroPadding();
+    }
+    resetSegment() {
+        this.histPtr = 0;
+        this.dict.clear();
+    }
+    update(chunk) {
+        const flushBoundary = true;
+        const parts = [];
+        let i = 0;
+        while (i < chunk.length) {
+            if (this.histPtr === MPPC_HIST_LEN) {
+                this.writeFlushMarker();
+                parts.push(this.bw.flushBytes());
+                this.resetSegment();
+            }
+            const remainingHist = MPPC_HIST_LEN - this.histPtr;
+            const remainingIn = chunk.length - i;
+            const limit = remainingIn < remainingHist ? remainingIn : remainingHist;
+            if (limit <= 0) {
+                break;
+            }
+            let bestLen = 0;
+            let bestOff = 0;
+            if (limit >= 3 && this.histPtr >= 3) {
+                const key = this.key3(chunk[i], chunk[i + 1], chunk[i + 2]);
+                const candidates = this.dict.get(key);
+                if (candidates === null || candidates === void 0 ? void 0 : candidates.length) {
+                    let checked = 0;
+                    for (let c = candidates.length - 1; c >= 0; c--) {
+                        const pos = candidates[c];
+                        const off = this.histPtr - pos;
+                        if (off <= 0 || off > this.histPtr) {
+                            continue;
+                        }
+                        if (off > 0x1FFF + 320) {
+                            continue;
+                        }
+                        const maxLen = Math.min(limit, this.histPtr - pos, 8191);
+                        let l = 3;
+                        while (l < maxLen && this.history[pos + l] === chunk[i + l]) {
+                            l++;
+                        }
+                        if (l > bestLen) {
+                            bestLen = l;
+                            bestOff = off;
+                            if (bestLen === maxLen) {
+                                break;
+                            }
+                        }
+                        if (++checked >= 32) {
+                            break;
+                        }
+                    }
+                }
+            }
+            if (bestLen >= 3 && bestOff > 0) {
+                this.writeOffset(bestOff);
+                this.writeLength(bestLen);
+                for (let k = 0; k < bestLen; k++) {
+                    this.pushHistoryByte(chunk[i + k]);
+                }
+                i += bestLen;
+            }
+            else {
+                const b = chunk[i];
+                this.writeLiteral(b);
+                this.pushHistoryByte(b);
+                i++;
+            }
+            const flushed = this.bw.flushBytes();
+            if (flushed.length) {
+                parts.push(flushed);
+            }
+        }
+        if (flushBoundary) {
+            this.writeFlushMarker();
+            const flushed = this.bw.flushBytes();
+            if (flushed.length) {
+                parts.push(flushed);
+            }
+            if (this.histPtr === MPPC_HIST_LEN) {
+                this.resetSegment();
+            }
+        }
+        if (!parts.length) {
+            return buffer_1.Buffer.alloc(0);
+        }
+        return parts.length === 1 ? parts[0] : buffer_1.Buffer.concat(parts);
+    }
+}
+exports.MppcCompressor = MppcCompressor;

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export { writeCUIntToPwBuffer } from './write-cuint-to-pw-buffer';

package/dist/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCUIntToPwBuffer = void 0;
+var write_cuint_to_pw_buffer_1 = require("./write-cuint-to-pw-buffer");
+Object.defineProperty(exports, "writeCUIntToPwBuffer", { enumerable: true, get: function () { return write_cuint_to_pw_buffer_1.writeCUIntToPwBuffer; } });

package/dist/utils/write-cuint-to-pw-buffer.d.ts

@@ -0,0 +1,2 @@
+import { ExtendedBuffer } from 'extended-buffer';
+export declare function writeCUIntToPwBuffer(buffer: ExtendedBuffer, value: number, unshift?: boolean): void;

package/dist/utils/write-cuint-to-pw-buffer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCUIntToPwBuffer = void 0;
+const extended_buffer_1 = require("extended-buffer");
+function writeCUIntToPwBuffer(buffer, value, unshift) {
+    (0, extended_buffer_1.assertInteger)(value);
+    if (value < 0 || value > 0xFFFFFFFF) {
+        throw new extended_buffer_1.ExtendedBufferRangeError('CUINT_VALUE_OUT_OF_RANGE');
+    }
+    if (value < 0x80) {
+        buffer.writeUIntBE(value & 0xFF, 1, unshift);
+    }
+    else if (value < 0x4000) {
+        buffer.writeUIntBE((value | 0x8000) & 0xFFFF, 2, unshift);
+    }
+    else if (value < 0x20000000) {
+        buffer.writeUIntBE((value | 0xC0000000) >>> 0, 4, unshift);
+    }
+    else {
+        const savedPointer = buffer.getPointer();
+        try {
+            if (unshift) {
+                buffer.allocStart(5).writeUIntBE(value >>> 0, 4, true).writeUIntBE(0xE0, 1, true);
+            }
+            else {
+                buffer.allocEnd(5).writeUIntBE(0xE0, 1).writeUIntBE(value >>> 0, 4);
+            }
+        }
+        catch (e) {
+            buffer.setPointer(savedPointer);
+            throw e;
+        }
+    }
+}
+exports.writeCUIntToPwBuffer = writeCUIntToPwBuffer;

package/package.json

@@ -1,12 +1,35 @@
 {
   "name": "pw-buffer",
-  "version": "2.0.1",
-  "description": "PW Buffer, Perfect World",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "3.0.0",
+  "description": "PW Buffer, Perfect World, Beijing Perfect World",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "node ./node_modules/.bin/tsc"
+    "build": "npm run clean && node ./node_modules/.bin/tsc",
+    "clean": "node -e \"['./dist'].forEach(item => require('fs').rmSync(item, {recursive:true,force:true}));\"",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=18.0.0",
+      "onFail": "error"
+    },
+    "packageManager": {
+      "name": "npm",
+      "version": ">=8.6.0",
+      "onFail": "error"
+    }
   },
   "repository": {
     "type": "git",
@@ -18,11 +41,16 @@
     "url": "https://github.com/mvcbox/node-pw-buffer/issues"
   },
   "homepage": "https://github.com/mvcbox/node-pw-buffer#readme",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
   "dependencies": {
-    "extended-buffer": "^6.0.3"
+    "extended-buffer": "^7.0.1"
   },
   "devDependencies": {
-    "@types/node": "^4.9.3",
-    "typescript": "^3.6.2"
+    "@types/node": "^6.14.13",
+    "typescript": "^4.7.2"
   }
 }