rbx-reader-ts 1.5.4 → 1.5.6

package/dist/ByteReader.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+function bufferToString(buffer) {
+    if (buffer instanceof ArrayBuffer) {
+        buffer = new Uint8Array(buffer);
+    }
+    var result = [];
+    if (buffer instanceof Uint8Array) {
+        for (var i = 0; i < buffer.length; i += 0x8000) {
+            result.push(String.fromCharCode.apply(undefined, buffer.subarray(i, i + 0x8000)));
+        }
+    }
+    return result.join('');
+}
+class ByteReader extends Uint8Array {
+    static ParseFloat(long) {
+        const exp = (long >>> 23) & 255;
+        if (exp === 0) {
+            return 0;
+        }
+        const float = 2 ** (exp - 127) * (1 + (long & 0x7FFFFF) / 0x7FFFFF);
+        return long > 0x7FFFFFFF ? -float : float;
+    }
+    static ParseRBXFloat(long) {
+        const exp = long >>> 24;
+        if (exp === 0) {
+            return 0;
+        }
+        const float = 2 ** (exp - 127) * (1 + ((long >>> 1) & 0x7FFFFF) / 0x7FFFFF);
+        return long & 1 ? -float : float;
+    }
+    static ParseDouble(long0, long1) {
+        const exp = (long0 >>> 20) & 0x7FF;
+        const frac = (((long0 & 1048575) * 4294967296) + long1) / 4503599627370496;
+        const neg = long0 & 2147483648;
+        if (exp === 0) {
+            if (frac === 0) {
+                return -0;
+            }
+            const double = 2 ** (exp - 1023) * frac;
+            return neg ? -double : double;
+        }
+        else if (exp === 2047) {
+            return frac === 0 ? Infinity : NaN;
+        }
+        const double = 2 ** (exp - 1023) * (1 + frac);
+        return neg ? -double : double;
+    }
+    constructor(...args) {
+        if (args[0] instanceof Uint8Array) {
+            args[1] = args[0].byteOffset;
+            args[2] = args[0].byteLength;
+            args[0] = args[0].buffer;
+        }
+        (0, assert_1.default)(args[0] instanceof ArrayBuffer, 'buffer is not an ArrayBuffer');
+        super(args[0], args[1], args[2]);
+        this.chunkBuffer = new Uint8Array();
+        this.index = 0;
+    }
+    SetIndex(n) { this.index = n; }
+    GetIndex() { return this.index; }
+    GetRemaining() { return this.length - this.index; }
+    GetLength() { return this.length; }
+    Jump(n) { this.index += n; }
+    Array(n) {
+        const result = new Uint8Array(this.buffer, this.index, n);
+        this.index += n;
+        return result;
+    }
+    Match(arr) {
+        const begin = this.index;
+        this.index += arr.length;
+        for (var i = 0; i < arr.length; i++) {
+            if (arr[i] !== this[begin + i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    Byte() { return this[this.index++]; }
+    UInt8() { return this[this.index++]; }
+    UInt16LE() { return this[this.index++] + (this[this.index++] * 256); }
+    UInt16BE() { return (this[this.index++] * 256) + this[this.index++]; }
+    UInt32LE() { return this[this.index++] + (this[this.index++] * 256) + (this[this.index++] * 65536) + (this[this.index++] * 16777216); }
+    UInt32BE() { return (this[this.index++] * 16777216) + (this[this.index++] * 65536) + (this[this.index++] * 256) + this[this.index++]; }
+    Int8() { return (this[this.index++]) << 24 >> 24; }
+    Int16LE() { return (this[this.index++] + (this[this.index++] * 256)) << 16 >> 16; }
+    Int16BE() { return ((this[this.index++] * 256) + this[this.index++]) << 16 >> 16; }
+    Int32LE() { return (this[this.index++] + (this[this.index++] * 256) + (this[this.index++] * 65536) + (this[this.index++] * 16777216)) >> 0; }
+    Int32BE() { return ((this[this.index++] * 16777216) + (this[this.index++] * 65536) + (this[this.index++] * 256) + this[this.index++]) >> 0; }
+    FloatLE() { return ByteReader.ParseFloat(this.UInt32LE()); }
+    FloatBE() { return ByteReader.ParseFloat(this.UInt32BE()); }
+    DoubleLE() {
+        const byte = this.UInt32LE();
+        return ByteReader.ParseDouble(this.UInt32LE(), byte);
+    }
+    DoubleBE() { return ByteReader.ParseDouble(this.UInt32BE(), this.UInt32BE()); }
+    String(n) {
+        return bufferToString(this.Array(n));
+    }
+    // Custom stuff
+    LZ4(buffer) {
+        const comLength = this.UInt32LE();
+        const decomLength = this.UInt32LE();
+        this.Jump(4);
+        if (comLength === 0) { // TOOD: This path is actually not supported by Roblox, may have to take a look at some point?
+            (0, assert_1.default)(this.GetRemaining() >= decomLength, '[ByteReader.LZ4] unexpected eof');
+            return this.Array(decomLength);
+        }
+        (0, assert_1.default)(this.GetRemaining() >= comLength, '[ByteReader.LZ4] unexpected eof');
+        if (!buffer || buffer.length < decomLength) {
+            buffer = new Uint8Array(decomLength);
+        }
+        const start = this.index;
+        const end = start + comLength;
+        const data = buffer.length === decomLength ? buffer : buffer.subarray(0, decomLength);
+        var index = 0;
+        while (this.index < end) {
+            const token = this.Byte();
+            var litLen = token >>> 4;
+            if (litLen === 0xF) {
+                while (true) {
+                    const lenByte = this.Byte();
+                    litLen += lenByte;
+                    if (lenByte !== 0xFF) {
+                        break;
+                    }
+                }
+            }
+            (0, assert_1.default)(this.index + litLen <= end, '[ByteReader.LZ4] unexpected eof');
+            for (var i = 0; i < litLen; i++) {
+                data[index++] = this.Byte();
+            }
+            if (this.index < end) {
+                const offset = this.UInt16LE();
+                const begin = index - offset;
+                var len = token & 0xF;
+                if (len === 0xF) {
+                    while (true) {
+                        const lenByte = this.Byte();
+                        len += lenByte;
+                        if (lenByte !== 0xFF) {
+                            break;
+                        }
+                    }
+                }
+                len += 4;
+                for (var i = 0; i < len; i++) {
+                    data[index++] = data[begin + i];
+                }
+            }
+        }
+        (0, assert_1.default)(this.index === end, '[ByteReader.LZ4] input size mismatch');
+        (0, assert_1.default)(index === decomLength, '[ByteReader.LZ4] output size mismatch');
+        return data;
+    }
+    // RBX
+    RBXFloatLE() { return ByteReader.ParseRBXFloat(this.UInt32LE()); }
+    RBXFloatBE() { return ByteReader.ParseRBXFloat(this.UInt32BE()); }
+    RBXInterleavedUint32(count, result) {
+        for (var i = 0; i < count; i++) {
+            result[i] = (this[this.index + i] << 24)
+                + (this[this.index + i + count] << 16)
+                + (this[this.index + i + count * 2] << 8)
+                + (this[this.index + i + count * 3]);
+        }
+        this.Jump(count * 4);
+        return result;
+    }
+    RBXInterleavedInt32(count, result) {
+        this.RBXInterleavedUint32(count, result);
+        for (var i = 0; i < count; i++) {
+            result[i] = (result[i] % 2 === 1 ? -(result[i] + 1) / 2 : result[i] / 2);
+        }
+        return result;
+    }
+    RBXInterleavedFloat(count, result) {
+        this.RBXInterleavedUint32(count, result);
+        for (var i = 0; i < count; i++) {
+            result[i] = ByteReader.ParseRBXFloat(result[i]);
+        }
+        return result;
+    }
+}
+{
+    const peekMethods = [
+        'Byte', 'UInt8', 'UInt16LE', 'UInt16BE', 'UInt32LE', 'UInt32BE',
+        'FloatLE', 'FloatBE', 'DoubleLE', 'DoubleBE', 'String'
+    ];
+    peekMethods.forEach((key) => {
+        const fn = ByteReader.prototype[key];
+        ByteReader.prototype[`Peek${key}`] = function (...args) {
+            const index = this.GetIndex();
+            const result = fn.apply(this, args);
+            this.SetIndex(index);
+            return result;
+        };
+    });
+}
+exports.default = ByteReader;

package/dist/Instance.d.ts

@@ -0,0 +1,150 @@
+declare class InstanceRoot extends Array<Instance> {
+    getChildren(): Instance[];
+    getDescendants(): Instance[];
+    findFirstChild(name: string, recursive?: boolean): Instance | undefined;
+    findFirstChildOfClass(className: string, recursive?: boolean): Instance | undefined;
+}
+interface BoolAttr {
+    Bool: boolean;
+}
+interface BinaryStringAttr {
+    BinaryString: string;
+}
+interface NumberSequenceKeypointAttr {
+    time: number;
+    value: number;
+    envelope: number;
+}
+interface NumberSequenceAttr {
+    NumberSequence: {
+        keypoints: NumberSequenceKeypointAttr[];
+    };
+}
+interface RectAttr {
+    Rect: number[][];
+}
+interface CFrameAttr {
+    CFrame: {
+        position: number[];
+        orientation: number[][];
+    };
+}
+interface NumberRangeAttr {
+    NumberRange: number[];
+}
+interface ColorSequenceKeypointAttr {
+    time: number;
+    color: number[];
+}
+interface ColorSequenceAttr {
+    ColorSequence: {
+        keypoints: ColorSequenceKeypointAttr[];
+    };
+}
+interface Vector3Attr {
+    Vector3: number[];
+}
+interface UDim2Attr {
+    UDim2: number[][];
+}
+interface Vector2Attr {
+    Vector2: number[];
+}
+interface Color3Attr {
+    Color3: number[];
+}
+interface BrickColorAttr {
+    BrickColor: number;
+}
+interface Float64Attr {
+    Float64: number;
+}
+interface UDimAttr {
+    UDim: number[];
+}
+export type AttributeValue = Partial<BoolAttr | BinaryStringAttr | NumberSequenceAttr | RectAttr | CFrameAttr | NumberRangeAttr | ColorSequenceAttr | Vector3Attr | UDim2Attr | Vector2Attr | Color3Attr | BrickColorAttr | Float64Attr | UDimAttr>;
+declare function isBoolAttr(obj: any): obj is BoolAttr;
+declare function isStringAttr(obj: any): obj is BinaryStringAttr;
+declare function isNumberSequenceAttr(obj: any): obj is NumberSequenceAttr;
+declare function isRectAttr(obj: any): obj is RectAttr;
+declare function isCFrameAttr(obj: any): obj is CFrameAttr;
+declare function isNumberRangeAttr(obj: any): obj is NumberRangeAttr;
+declare function isColorSequenceAttr(obj: any): obj is ColorSequenceAttr;
+declare function isVector3Attr(obj: any): obj is Vector3Attr;
+declare function isUDim2Attr(obj: any): obj is UDim2Attr;
+declare function isVector2Attr(obj: any): obj is Vector2Attr;
+declare function isColor3Attr(obj: any): obj is Color3Attr;
+declare function isBrickColorAttr(obj: any): obj is BrickColorAttr;
+declare function isNumberAttr(obj: any): obj is Float64Attr;
+declare function isUDimAttr(obj: any): obj is UDimAttr;
+export declare const AttrAssertions: {
+    isBoolAttr: typeof isBoolAttr;
+    isStringAttr: typeof isStringAttr;
+    isNumberSequenceAttr: typeof isNumberSequenceAttr;
+    isRectAttr: typeof isRectAttr;
+    isCFrameAttr: typeof isCFrameAttr;
+    isNumberRangeAttr: typeof isNumberRangeAttr;
+    isColorSequenceAttr: typeof isColorSequenceAttr;
+    isVector3Attr: typeof isVector3Attr;
+    isUDim2Attr: typeof isUDim2Attr;
+    isVector2Attr: typeof isVector2Attr;
+    isColor3Attr: typeof isColor3Attr;
+    isBrickColorAttr: typeof isBrickColorAttr;
+    isNumberAttr: typeof isNumberAttr;
+    isUDimAttr: typeof isUDimAttr;
+    isFloat64Attr: typeof isNumberAttr;
+};
+type AttributeJSValue = boolean | string | number | NumberSequenceKeypointAttr[] | number[][] | {
+    position: number[];
+    orientation: number[][];
+} | {
+    lower: number;
+    upper: number;
+} | ColorSequenceKeypointAttr[] | {
+    x: number;
+    y: number;
+    z: number;
+} | {
+    x: {
+        scale: number;
+        offset: number;
+    };
+    y: {
+        scale: number;
+        offset: number;
+    };
+} | {
+    x: number;
+    y: number;
+} | {
+    r: number;
+    g: number;
+    b: number;
+} | {
+    scale: number;
+    offset: number;
+} | {
+    BrickColor: number;
+};
+declare class Instance {
+    readonly Children: Instance[];
+    readonly Properties: object;
+    Attributes: {
+        [key: string]: AttributeJSValue;
+    };
+    get ClassName(): string;
+    get Name(): string;
+    get Parent(): Instance | InstanceRoot | undefined;
+    getFullName(): string;
+    static new(className: string): Instance;
+    constructor(className: string);
+    setProperty(name: string, value: any, type: any): void;
+    getProperty(name: string, caseInsensitive?: boolean): any;
+    getChildren(): Instance[];
+    getDescendants(): Instance[];
+    hasProperty(name: string, caseInsensitive?: boolean): boolean;
+    findFirstChild(name: string, recursive?: boolean): Instance | undefined;
+    findFirstChildOfClass(className: string, recursive?: boolean): Instance | undefined;
+    getAttribute(name: string): AttributeJSValue | undefined;
+}
+export { Instance, InstanceRoot };

package/dist/Instance.js

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceRoot = exports.Instance = exports.AttrAssertions = void 0;
+const assert_1 = __importDefault(require("assert"));
+const InstanceUtils = {
+    findFirstChild(target, name, recursive = false) {
+        const children = target instanceof Instance ? target.Children : target;
+        for (const child of children) {
+            if (child.getProperty('Name') === name) {
+                return child;
+            }
+        }
+        if (recursive) {
+            const arrays = [children];
+            while (arrays.length) {
+                for (const desc of arrays.shift()) {
+                    if (desc.getProperty('Name') === name) {
+                        return desc;
+                    }
+                    if (desc.Children.length) {
+                        arrays.push(desc.Children);
+                    }
+                }
+            }
+        }
+        return undefined;
+    },
+    findFirstChildOfClass(target, className, recursive = false) {
+        const children = target instanceof Instance ? target.Children : target;
+        for (const child of children) {
+            if (child.getProperty('ClassName') === className) {
+                return child;
+            }
+        }
+        if (recursive) {
+            const arrays = [children];
+            while (arrays.length > 0) {
+                for (const desc of arrays.shift()) {
+                    if (desc.getProperty('ClassName') === className) {
+                        return desc;
+                    }
+                    if (desc.Children.length) {
+                        arrays.push(desc.Children);
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+};
+class InstanceRoot extends Array {
+    getChildren() {
+        return this;
+    }
+    getDescendants() {
+        const l = this.getChildren();
+        l.forEach(v => l.push(...v.getDescendants()));
+        return l;
+    }
+    findFirstChild(name, recursive = false) { return InstanceUtils.findFirstChild(this, name, recursive); }
+    findFirstChildOfClass(className, recursive = false) { return InstanceUtils.findFirstChildOfClass(this, className, recursive); }
+}
+exports.InstanceRoot = InstanceRoot;
+function isBoolAttr(obj) {
+    return typeof obj == 'object' && typeof obj.Bool == 'boolean';
+}
+function isStringAttr(obj) {
+    return typeof obj == 'object' && typeof obj.BinaryString == 'string';
+}
+function isNumSequenceKeyPtAttr(obj) {
+    return typeof obj == 'object' && typeof obj.time == 'number' && typeof obj.value == 'number' && typeof obj.envelope == 'number';
+}
+function isNumberSequenceAttr(obj) {
+    return typeof obj == 'object' && typeof obj.NumberSequence == 'object' &&
+        Array.isArray(obj.NumberSequence.keypoints) && obj.NumberSequence.keypoints.every(isNumSequenceKeyPtAttr);
+}
+function isRectAttr(obj) {
+    return typeof obj == 'object' && Array.isArray(obj.Rect) && obj.Rect.length == 2 &&
+        obj.Rect.every((v) => Array.isArray(v) && v.length == 2);
+}
+function isCFrameAttr(obj) {
+    return typeof obj == 'object' && typeof obj.CFrame == 'object' && Array.isArray(obj.CFrame.position) &&
+        obj.CFrame.position.length == 3 && obj.CFrame.position.every((v) => typeof v == 'number') &&
+        Array.isArray(obj.CFrame.orientation) && obj.CFrame.orientation.length == 3 &&
+        obj.CFrame.orientation.every((v) => Array.isArray(v) &&
+            v.length == 3 && v.every((v2) => typeof v2 == 'number'));
+}
+function isNumberRangeAttr(obj) {
+    return typeof obj == 'object' && Array.isArray(obj.NumberRange) &&
+        obj.NumberRange.every((v) => typeof v == 'number') && obj.NumberRange.length == 2;
+}
+function isColorSequenceKeyPtAttr(obj) {
+    return typeof obj == 'object' && typeof obj.time == 'number' && Array.isArray(obj.color)
+        && obj.color.every((v) => typeof v == 'number') && obj.color.length == 3;
+}
+function isColorSequenceAttr(obj) {
+    return typeof obj == 'object' && typeof obj.ColorSequence == 'object' &&
+        Array.isArray(obj.ColorSequence.keypoints) && obj.ColorSequence.keypoints.every(isColorSequenceKeyPtAttr);
+}
+function isVector3Attr(obj) {
+    return typeof obj == 'object' && Array.isArray(obj.Vector3) &&
+        obj.Vector3.every((v) => typeof v == 'number') && obj.Vector3.length == 3;
+}
+function isUDim2Attr(obj) {
+    return typeof obj == 'object' && Array.isArray(obj.UDim2) && obj.UDim2.length == 2 &&
+        obj.UDim2.every((v) => Array.isArray(v) && v.every((v2) => typeof v2 == 'number') &&
+            v.length == 2);
+}
+function isVector2Attr(obj) {
+    return typeof obj == 'object' && Array.isArray(obj.Vector2) &&
+        obj.Vector2.every((v) => typeof v == 'number') && obj.Vector2.length == 2;
+}
+function isColor3Attr(obj) {
+    return typeof obj == 'object' && Array.isArray(obj.Color3) &&
+        obj.Color3.every((v) => typeof v == 'number') && obj.Color3.length == 3;
+}
+function isBrickColorAttr(obj) {
+    return typeof obj == 'object' && typeof obj.BrickColor == 'number';
+}
+function isNumberAttr(obj) {
+    return typeof obj == 'object' && typeof obj.Float64 == 'number';
+}
+function isUDimAttr(obj) {
+    return typeof obj == 'object' && Array.isArray(obj.UDim) && obj.UDim.length == 2 &&
+        obj.UDim.every((v) => typeof v == 'number');
+}
+exports.AttrAssertions = {
+    isBoolAttr,
+    isStringAttr,
+    isNumberSequenceAttr,
+    isRectAttr,
+    isCFrameAttr,
+    isNumberRangeAttr,
+    isColorSequenceAttr,
+    isVector3Attr,
+    isUDim2Attr,
+    isVector2Attr,
+    isColor3Attr,
+    isBrickColorAttr,
+    isNumberAttr,
+    isUDimAttr,
+    isFloat64Attr: isNumberAttr
+};
+class Instance {
+    get ClassName() {
+        return this.Properties['ClassName'].value;
+    }
+    get Name() {
+        return this.Properties['Name'].value;
+    }
+    get Parent() {
+        return this.Properties['Parent'].value;
+    }
+    getFullName() {
+        if (this.Parent && !(this.Parent instanceof InstanceRoot)) {
+            return `${this.Parent.getFullName()}.${this.Name}`;
+        }
+        else {
+            return `${this.Name}`;
+        }
+    }
+    static new(className) {
+        (0, assert_1.default)(typeof className === 'string', 'className is not a string');
+        return new Instance(className);
+    }
+    constructor(className) {
+        this.Children = [];
+        this.Properties = {};
+        this.Attributes = {};
+        (0, assert_1.default)(typeof className === 'string', 'className is not a string');
+        this.Children = [];
+        this.setProperty('ClassName', className, 'string');
+        this.setProperty('Name', 'Instance', 'string');
+        this.setProperty('Parent', undefined, 'Instance');
+    }
+    setProperty(name, value, type) {
+        if (!type) {
+            if (typeof value === 'boolean') {
+                type = 'bool';
+            }
+            else if (value instanceof Instance) {
+                type = 'Instance';
+            }
+            else {
+                throw new TypeError('You need to specify property type since it cannot be inferred');
+            }
+        }
+        var descriptor = this.Properties[name];
+        if (descriptor) {
+            (0, assert_1.default)(descriptor.type === type, `Property type mismatch: ${type} !== ${descriptor.type}`);
+            if (name === 'Parent' && descriptor.value instanceof Instance) {
+                const index = descriptor.value.Children.indexOf(this);
+                if (index !== -1)
+                    descriptor.value.Children.splice(index, 1);
+            }
+            descriptor.value = value;
+        }
+        else
+            descriptor = this.Properties[name] = { type, value };
+        if (name === 'Parent' && descriptor.value instanceof Instance)
+            descriptor.value.Children.push(this);
+        if (name !== 'Children' && name !== 'Properties' && !(name in Object.getPrototypeOf(this)))
+            this[name] = value;
+    }
+    getProperty(name, caseInsensitive = false) {
+        const descriptor = this.Properties[name] || caseInsensitive && Object.entries(this.Properties).find(x => x[0].toLowerCase() === name.toLowerCase())?.[1];
+        return descriptor ? descriptor.value : undefined;
+    }
+    getChildren() {
+        return this.Children;
+    }
+    getDescendants() {
+        const desc = this.Children;
+        desc.forEach(inst => {
+            desc.push(...inst.getDescendants());
+        });
+        return desc;
+    }
+    hasProperty(name, caseInsensitive = false) {
+        return name in this.Properties || caseInsensitive && !Object.entries(this.Properties).find(x => x[0].toLowerCase() === name.toLowerCase());
+    }
+    findFirstChild(name, recursive = false) { return InstanceUtils.findFirstChild(this, name, recursive); }
+    findFirstChildOfClass(className, recursive = false) { return InstanceUtils.findFirstChildOfClass(this, className, recursive); }
+    getAttribute(name) {
+        return this.Attributes[name];
+    }
+}
+exports.Instance = Instance;

package/dist/XmlParser.d.ts

@@ -0,0 +1,23 @@
+import { Instance, InstanceRoot } from './Instance';
+interface XmlParser {
+    result: InstanceRoot;
+    refs: object;
+    refWait: any[];
+    sharedStrings: object;
+}
+declare const XmlParser: {
+    Transforms: {
+        CFrame: string[];
+        Vector3: string[];
+        Vector2: string[];
+    };
+    escapeXml(value: string): string;
+    unescapeXml(value: string): string;
+    parse(buffer: ArrayBuffer | Uint8Array): {
+        result: InstanceRoot;
+        instances: Instance[];
+    };
+    parseItem(parser: XmlParser, node: Element): Instance;
+    parseProperties(parser: XmlParser, inst: Instance, targetNode: Element): void;
+};
+export default XmlParser;