@d2runewizard/d2s 2.0.133 → 2.0.135

package/lib/binary/bitreader.d.ts

@@ -1,23 +1,23 @@
-export declare class BitReader {
-    littleEndian: boolean;
-    bits: Uint8Array;
-    offset: number;
-    constructor(arrBuffer: ArrayBuffer);
-    ReadBit(): number;
-    ReadBitArray(count: number): Uint8Array;
-    ReadBits(bytes: Uint8Array, count: number): Uint8Array;
-    ReadBytes(bytes: number): Uint8Array;
-    ReadArray(bytes: number): Uint8Array;
-    ReadByte(bits?: number): number;
-    ReadUInt8(bits?: number): number;
-    ReadUInt16(bits?: number): number;
-    ReadUInt32(bits?: number): number;
-    ReadString(bytes: number): string;
-    ReadNullTerminatedString(): string;
-    SkipBits(number: number): BitReader;
-    SkipBytes(number: number): BitReader;
-    SeekBit(offset: number): BitReader;
-    SeekByte(offset: number): BitReader;
-    SeekSequence(sequence: string, offset?: number): BitReader;
-    Align(): BitReader;
-}
+export declare class BitReader {
+    littleEndian: boolean;
+    bits: Uint8Array;
+    offset: number;
+    constructor(arrBuffer: ArrayBuffer);
+    ReadBit(): number;
+    ReadBitArray(count: number): Uint8Array;
+    ReadBits(bytes: Uint8Array, count: number): Uint8Array;
+    ReadBytes(bytes: number): Uint8Array;
+    ReadArray(bytes: number): Uint8Array;
+    ReadByte(bits?: number): number;
+    ReadUInt8(bits?: number): number;
+    ReadUInt16(bits?: number): number;
+    ReadUInt32(bits?: number): number;
+    ReadString(bytes: number): string;
+    ReadNullTerminatedString(): string;
+    SkipBits(number: number): BitReader;
+    SkipBytes(number: number): BitReader;
+    SeekBit(offset: number): BitReader;
+    SeekByte(offset: number): BitReader;
+    SeekSequence(sequence: string, offset?: number): BitReader;
+    Align(): BitReader;
+}

package/lib/binary/bitreader.js

@@ -1,108 +1,108 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitReader = void 0;
-class BitReader {
-    constructor(arrBuffer) {
-        this.littleEndian = true;
-        this.offset = 0;
-        const typedArray = new Uint8Array(arrBuffer);
-        this.bits = new Uint8Array(typedArray.length * 8);
-        typedArray.reduce((acc, c) => {
-            const b = c
-                .toString(2)
-                .padStart(8, "0")
-                .split("")
-                .reverse()
-                .map((e) => parseInt(e, 2));
-            b.forEach((bit) => (this.bits[acc++] = bit));
-            return acc;
-        }, 0);
-    }
-    ReadBit() {
-        return this.bits[this.offset++];
-    }
-    ReadBitArray(count) {
-        const bits = new Uint8Array(count);
-        for (let i = 0; i < count; i++) {
-            bits[i] = this.bits[this.offset++];
-        }
-        return bits;
-    }
-    ReadBits(bytes, count) {
-        let byteIndex = 0;
-        let bitIndex = 0;
-        for (let i = 0; i < count; i++) {
-            if (this.bits[this.offset + i]) {
-                bytes[byteIndex] |= (1 << bitIndex) & 0xff;
-            }
-            bitIndex++;
-            if (bitIndex == 8) {
-                byteIndex++;
-                bitIndex = 0;
-            }
-        }
-        this.offset += count;
-        return bytes;
-    }
-    ReadBytes(bytes) {
-        return this.ReadBits(new Uint8Array(bytes), bytes * 8);
-    }
-    ReadArray(bytes) {
-        return this.ReadBytes(bytes);
-    }
-    ReadByte(bits = 8) {
-        const dataview = new DataView(this.ReadBits(new Uint8Array(1), bits).buffer);
-        return dataview.getUint8(0);
-    }
-    ReadUInt8(bits = 8) {
-        return this.ReadByte(bits);
-    }
-    ReadUInt16(bits = 8 * 2) {
-        const dataview = new DataView(this.ReadBits(new Uint8Array(2), bits).buffer);
-        return dataview.getUint16(0, this.littleEndian);
-    }
-    ReadUInt32(bits = 8 * 4) {
-        const dataview = new DataView(this.ReadBits(new Uint8Array(4), bits).buffer);
-        return dataview.getUint32(0, this.littleEndian);
-    }
-    ReadString(bytes) {
-        const buffer = this.ReadBytes(bytes).buffer;
-        return new TextDecoder().decode(buffer);
-    }
-    ReadNullTerminatedString() {
-        const start = this.offset;
-        while (this.ReadByte()) { }
-        const end = this.offset - 8;
-        const buffer = this.SeekBit(start).ReadBytes((end - start) / 8);
-        this.SeekBit(end + 8);
-        return new TextDecoder().decode(buffer);
-    }
-    SkipBits(number) {
-        this.offset += number;
-        return this;
-    }
-    SkipBytes(number) {
-        return this.SkipBits(number * 8);
-    }
-    SeekBit(offset) {
-        this.offset = offset;
-        return this;
-    }
-    SeekByte(offset) {
-        return this.SeekBit(offset * 8);
-    }
-    SeekSequence(sequence, offset = 0) {
-        const bitStr = this.bits.join("");
-        const idx = bitStr.indexOf(sequence, this.offset);
-        if (idx !== -1) {
-            return this.SeekBit(idx + offset);
-        }
-        return this;
-    }
-    Align() {
-        this.offset = (this.offset + 7) & ~7;
-        return this;
-    }
-}
-exports.BitReader = BitReader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitReader = void 0;
+class BitReader {
+    constructor(arrBuffer) {
+        this.littleEndian = true;
+        this.offset = 0;
+        const typedArray = new Uint8Array(arrBuffer);
+        this.bits = new Uint8Array(typedArray.length * 8);
+        typedArray.reduce((acc, c) => {
+            const b = c
+                .toString(2)
+                .padStart(8, "0")
+                .split("")
+                .reverse()
+                .map((e) => parseInt(e, 2));
+            b.forEach((bit) => (this.bits[acc++] = bit));
+            return acc;
+        }, 0);
+    }
+    ReadBit() {
+        return this.bits[this.offset++];
+    }
+    ReadBitArray(count) {
+        const bits = new Uint8Array(count);
+        for (let i = 0; i < count; i++) {
+            bits[i] = this.bits[this.offset++];
+        }
+        return bits;
+    }
+    ReadBits(bytes, count) {
+        let byteIndex = 0;
+        let bitIndex = 0;
+        for (let i = 0; i < count; i++) {
+            if (this.bits[this.offset + i]) {
+                bytes[byteIndex] |= (1 << bitIndex) & 0xff;
+            }
+            bitIndex++;
+            if (bitIndex == 8) {
+                byteIndex++;
+                bitIndex = 0;
+            }
+        }
+        this.offset += count;
+        return bytes;
+    }
+    ReadBytes(bytes) {
+        return this.ReadBits(new Uint8Array(bytes), bytes * 8);
+    }
+    ReadArray(bytes) {
+        return this.ReadBytes(bytes);
+    }
+    ReadByte(bits = 8) {
+        const dataview = new DataView(this.ReadBits(new Uint8Array(1), bits).buffer);
+        return dataview.getUint8(0);
+    }
+    ReadUInt8(bits = 8) {
+        return this.ReadByte(bits);
+    }
+    ReadUInt16(bits = 8 * 2) {
+        const dataview = new DataView(this.ReadBits(new Uint8Array(2), bits).buffer);
+        return dataview.getUint16(0, this.littleEndian);
+    }
+    ReadUInt32(bits = 8 * 4) {
+        const dataview = new DataView(this.ReadBits(new Uint8Array(4), bits).buffer);
+        return dataview.getUint32(0, this.littleEndian);
+    }
+    ReadString(bytes) {
+        const buffer = this.ReadBytes(bytes).buffer;
+        return new TextDecoder().decode(buffer);
+    }
+    ReadNullTerminatedString() {
+        const start = this.offset;
+        while (this.ReadByte()) { }
+        const end = this.offset - 8;
+        const buffer = this.SeekBit(start).ReadBytes((end - start) / 8);
+        this.SeekBit(end + 8);
+        return new TextDecoder().decode(buffer);
+    }
+    SkipBits(number) {
+        this.offset += number;
+        return this;
+    }
+    SkipBytes(number) {
+        return this.SkipBits(number * 8);
+    }
+    SeekBit(offset) {
+        this.offset = offset;
+        return this;
+    }
+    SeekByte(offset) {
+        return this.SeekBit(offset * 8);
+    }
+    SeekSequence(sequence, offset = 0) {
+        const bitStr = this.bits.join("");
+        const idx = bitStr.indexOf(sequence, this.offset);
+        if (idx !== -1) {
+            return this.SeekBit(idx + offset);
+        }
+        return this;
+    }
+    Align() {
+        this.offset = (this.offset + 7) & ~7;
+        return this;
+    }
+}
+exports.BitReader = BitReader;
 //# sourceMappingURL=bitreader.js.map

package/lib/binary/bitwriter.d.ts

@@ -1,21 +1,21 @@
-export declare class BitWriter {
-    littleEndian: boolean;
-    bits: Uint8Array;
-    offset: number;
-    length: number;
-    constructor(capacity?: number);
-    WriteBit(value: number): BitWriter;
-    WriteBits(bits: Uint8Array, numberOfBits: number): BitWriter;
-    WriteBytes(bytes: Uint8Array, numberOfBits?: number): BitWriter;
-    WriteArray(bytes: Uint8Array, numberOfBits?: number): BitWriter;
-    WriteByte(value: number, numberOfBits?: number): BitWriter;
-    WriteUInt8(value: number, numberOfBits?: number): BitWriter;
-    WriteUInt16(value: number, numberOfBits?: number): BitWriter;
-    WriteUInt32(value: number, numberOfBits?: number): BitWriter;
-    WriteString(value: string, numberOfBytes: number): BitWriter;
-    SeekBit(offset: number): BitWriter;
-    SeekByte(offset: number): BitWriter;
-    PeekBytes(count: number): Uint8Array;
-    Align(): BitWriter;
-    ToArray(): Uint8Array;
-}
+export declare class BitWriter {
+    littleEndian: boolean;
+    bits: Uint8Array;
+    offset: number;
+    length: number;
+    constructor(capacity?: number);
+    WriteBit(value: number): BitWriter;
+    WriteBits(bits: Uint8Array, numberOfBits: number): BitWriter;
+    WriteBytes(bytes: Uint8Array, numberOfBits?: number): BitWriter;
+    WriteArray(bytes: Uint8Array, numberOfBits?: number): BitWriter;
+    WriteByte(value: number, numberOfBits?: number): BitWriter;
+    WriteUInt8(value: number, numberOfBits?: number): BitWriter;
+    WriteUInt16(value: number, numberOfBits?: number): BitWriter;
+    WriteUInt32(value: number, numberOfBits?: number): BitWriter;
+    WriteString(value: string, numberOfBytes: number): BitWriter;
+    SeekBit(offset: number): BitWriter;
+    SeekByte(offset: number): BitWriter;
+    PeekBytes(count: number): Uint8Array;
+    Align(): BitWriter;
+    ToArray(): Uint8Array;
+}

package/lib/binary/bitwriter.js

@@ -1,118 +1,118 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitWriter = void 0;
-class BitWriter {
-    constructor(capacity = 8192) {
-        this.littleEndian = true;
-        this.offset = 0;
-        this.length = 0;
-        this.bits = new Uint8Array(capacity);
-    }
-    WriteBit(value) {
-        if (this.offset >= this.bits.length) {
-            const resized = new Uint8Array(this.bits.length + 8192);
-            resized.set(this.bits, 0);
-            this.bits = resized;
-        }
-        this.bits[this.offset++] = value;
-        if (this.offset > this.length)
-            this.length++;
-        return this;
-    }
-    WriteBits(bits, numberOfBits) {
-        for (let i = 0; i < numberOfBits; i++) {
-            this.WriteBit(bits[i]);
-        }
-        return this;
-    }
-    WriteBytes(bytes, numberOfBits = bytes.length * 8) {
-        const toWrite = new Uint8Array(numberOfBits);
-        bytes.reduce((acc, c) => {
-            const b = c
-                .toString(2)
-                .padStart(8, "0")
-                .split("")
-                .reverse()
-                .map((e) => parseInt(e, 2));
-            b.forEach((bit) => (toWrite[acc++] = bit));
-            return acc;
-        }, 0);
-        return this.WriteBits(toWrite, numberOfBits);
-    }
-    WriteArray(bytes, numberOfBits = bytes.length * 8) {
-        return this.WriteBytes(bytes, numberOfBits);
-    }
-    WriteByte(value, numberOfBits = 8) {
-        const buffer = new Uint8Array(1);
-        new DataView(buffer.buffer).setUint8(0, value);
-        return this.WriteBytes(buffer, numberOfBits);
-    }
-    WriteUInt8(value, numberOfBits = 8) {
-        return this.WriteByte(value, numberOfBits);
-    }
-    WriteUInt16(value, numberOfBits = 8 * 2) {
-        const buffer = new Uint8Array(2);
-        new DataView(buffer.buffer).setUint16(0, value, this.littleEndian);
-        return this.WriteBytes(buffer, numberOfBits);
-    }
-    WriteUInt32(value, numberOfBits = 8 * 4) {
-        const buffer = new Uint8Array(4);
-        new DataView(buffer.buffer).setUint32(0, value, this.littleEndian);
-        return this.WriteBytes(buffer, numberOfBits);
-    }
-    WriteString(value, numberOfBytes) {
-        const buffer = new TextEncoder().encode(value);
-        return this.WriteBytes(buffer, numberOfBytes * 8);
-    }
-    SeekBit(offset) {
-        this.offset = offset;
-        if (this.offset > this.length) {
-            this.length = this.offset;
-        }
-        return this;
-    }
-    SeekByte(offset) {
-        return this.SeekBit(offset * 8);
-    }
-    PeekBytes(count) {
-        const buffer = new Uint8Array(count);
-        let byteIndex = 0;
-        let bitIndex = 0;
-        for (let i = 0; i < count * 8; ++i) {
-            if (this.bits[this.offset + i]) {
-                buffer[byteIndex] |= (1 << bitIndex) & 0xff;
-            }
-            ++bitIndex;
-            if (bitIndex >= 8) {
-                ++byteIndex;
-                bitIndex = 0;
-            }
-        }
-        return buffer;
-    }
-    Align() {
-        this.offset = (this.offset + 7) & ~7;
-        if (this.offset > this.length) {
-            this.length = this.offset;
-        }
-        return this;
-    }
-    ToArray() {
-        const buffer = new Uint8Array((this.length - 1) / 8 + 1);
-        let byteIndex = 0;
-        let bitIndex = 0;
-        for (let i = 0; i < this.length; ++i) {
-            if (this.bits[i]) {
-                buffer[byteIndex] |= (1 << bitIndex) & 0xff;
-            }
-            ++bitIndex;
-            if (bitIndex >= 8) {
-                ++byteIndex;
-                bitIndex = 0;
-            }
-        }
-        return buffer;
-    }
-}
-exports.BitWriter = BitWriter;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitWriter = void 0;
+class BitWriter {
+    constructor(capacity = 8192) {
+        this.littleEndian = true;
+        this.offset = 0;
+        this.length = 0;
+        this.bits = new Uint8Array(capacity);
+    }
+    WriteBit(value) {
+        if (this.offset >= this.bits.length) {
+            const resized = new Uint8Array(this.bits.length + 8192);
+            resized.set(this.bits, 0);
+            this.bits = resized;
+        }
+        this.bits[this.offset++] = value;
+        if (this.offset > this.length)
+            this.length++;
+        return this;
+    }
+    WriteBits(bits, numberOfBits) {
+        for (let i = 0; i < numberOfBits; i++) {
+            this.WriteBit(bits[i]);
+        }
+        return this;
+    }
+    WriteBytes(bytes, numberOfBits = bytes.length * 8) {
+        const toWrite = new Uint8Array(numberOfBits);
+        bytes.reduce((acc, c) => {
+            const b = c
+                .toString(2)
+                .padStart(8, "0")
+                .split("")
+                .reverse()
+                .map((e) => parseInt(e, 2));
+            b.forEach((bit) => (toWrite[acc++] = bit));
+            return acc;
+        }, 0);
+        return this.WriteBits(toWrite, numberOfBits);
+    }
+    WriteArray(bytes, numberOfBits = bytes.length * 8) {
+        return this.WriteBytes(bytes, numberOfBits);
+    }
+    WriteByte(value, numberOfBits = 8) {
+        const buffer = new Uint8Array(1);
+        new DataView(buffer.buffer).setUint8(0, value);
+        return this.WriteBytes(buffer, numberOfBits);
+    }
+    WriteUInt8(value, numberOfBits = 8) {
+        return this.WriteByte(value, numberOfBits);
+    }
+    WriteUInt16(value, numberOfBits = 8 * 2) {
+        const buffer = new Uint8Array(2);
+        new DataView(buffer.buffer).setUint16(0, value, this.littleEndian);
+        return this.WriteBytes(buffer, numberOfBits);
+    }
+    WriteUInt32(value, numberOfBits = 8 * 4) {
+        const buffer = new Uint8Array(4);
+        new DataView(buffer.buffer).setUint32(0, value, this.littleEndian);
+        return this.WriteBytes(buffer, numberOfBits);
+    }
+    WriteString(value, numberOfBytes) {
+        const buffer = new TextEncoder().encode(value);
+        return this.WriteBytes(buffer, numberOfBytes * 8);
+    }
+    SeekBit(offset) {
+        this.offset = offset;
+        if (this.offset > this.length) {
+            this.length = this.offset;
+        }
+        return this;
+    }
+    SeekByte(offset) {
+        return this.SeekBit(offset * 8);
+    }
+    PeekBytes(count) {
+        const buffer = new Uint8Array(count);
+        let byteIndex = 0;
+        let bitIndex = 0;
+        for (let i = 0; i < count * 8; ++i) {
+            if (this.bits[this.offset + i]) {
+                buffer[byteIndex] |= (1 << bitIndex) & 0xff;
+            }
+            ++bitIndex;
+            if (bitIndex >= 8) {
+                ++byteIndex;
+                bitIndex = 0;
+            }
+        }
+        return buffer;
+    }
+    Align() {
+        this.offset = (this.offset + 7) & ~7;
+        if (this.offset > this.length) {
+            this.length = this.offset;
+        }
+        return this;
+    }
+    ToArray() {
+        const buffer = new Uint8Array((this.length - 1) / 8 + 1);
+        let byteIndex = 0;
+        let bitIndex = 0;
+        for (let i = 0; i < this.length; ++i) {
+            if (this.bits[i]) {
+                buffer[byteIndex] |= (1 << bitIndex) & 0xff;
+            }
+            ++bitIndex;
+            if (bitIndex >= 8) {
+                ++byteIndex;
+                bitIndex = 0;
+            }
+        }
+        return buffer;
+    }
+}
+exports.BitWriter = BitWriter;
 //# sourceMappingURL=bitwriter.js.map

package/lib/binary/constants.d.ts

@@ -1,4 +1,4 @@
-export declare enum Endianness {
-    "be" = 0,
-    "le" = 1
-}
+export declare enum Endianness {
+    "be" = 0,
+    "le" = 1
+}

package/lib/binary/constants.js

@@ -1,9 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Endianness = void 0;
-var Endianness;
-(function (Endianness) {
-    Endianness[Endianness["be"] = 0] = "be";
-    Endianness[Endianness["le"] = 1] = "le";
-})(Endianness = exports.Endianness || (exports.Endianness = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endianness = void 0;
+var Endianness;
+(function (Endianness) {
+    Endianness[Endianness["be"] = 0] = "be";
+    Endianness[Endianness["le"] = 1] = "le";
+})(Endianness = exports.Endianness || (exports.Endianness = {}));
 //# sourceMappingURL=constants.js.map

package/lib/binary/seekToSequence.d.ts

@@ -1,2 +1,2 @@
-import { BitReader } from "./bitreader";
-export declare function seekToSequence(reader: BitReader, sequence: string, offset: number): void;
+import { BitReader } from "./bitreader";
+export declare function seekToSequence(reader: BitReader, sequence: string, offset: number): void;

package/lib/binary/seekToSequence.js

@@ -1,13 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.seekToSequence = void 0;
-function seekToSequence(reader, sequence, offset) {
-    const bitStr = reader.bits.join("");
-    const searchStart = reader.offset;
-    const idx = bitStr.indexOf(sequence, searchStart);
-    if (idx !== -1) {
-        reader.SeekBit(idx + 1 + offset);
-    }
-}
-exports.seekToSequence = seekToSequence;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seekToSequence = void 0;
+function seekToSequence(reader, sequence, offset) {
+    const bitStr = reader.bits.join("");
+    const searchStart = reader.offset;
+    const idx = bitStr.indexOf(sequence, searchStart);
+    if (idx !== -1) {
+        reader.SeekBit(idx + 1 + offset);
+    }
+}
+exports.seekToSequence = seekToSequence;
 //# sourceMappingURL=seekToSequence.js.map

package/lib/d2/attribute_enhancer.d.ts

@@ -1,5 +1,5 @@
-import * as types from "./types";
-export declare function enhanceAttributes(char: types.ID2S, constants: types.IConstantData, config?: types.IConfig): Promise<void>;
-export declare function enhancePlayerAttributes(char: types.ID2S, constants: types.IConstantData, config?: types.IConfig): Promise<void>;
-export declare function enhanceItems(items: types.IItem[], constants: types.IConstantData, level?: number, config?: types.IConfig, parent?: types.IItem): Promise<void>;
-export declare function enhanceItem(item: types.IItem, constants: types.IConstantData, level?: number, config?: types.IConfig, parent?: types.IItem): void;
+import * as types from "./types";
+export declare function enhanceAttributes(char: types.ID2S, constants: types.IConstantData, config?: types.IConfig): Promise<void>;
+export declare function enhancePlayerAttributes(char: types.ID2S, constants: types.IConstantData, config?: types.IConfig): Promise<void>;
+export declare function enhanceItems(items: types.IItem[], constants: types.IConstantData, level?: number, config?: types.IConfig, parent?: types.IItem): Promise<void>;
+export declare function enhanceItem(item: types.IItem, constants: types.IConstantData, level?: number, config?: types.IConfig, parent?: types.IItem): void;