rbx-reader-ts 1.5.4 → 1.5.6

package/dist/XmlParser.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsdom_1 = require("jsdom");
+const Instance_1 = require("./Instance");
+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('');
+}
+const XmlParser = {
+    Transforms: {
+        CFrame: ['X', 'Y', 'Z', 'R00', 'R01', 'R02', 'R10', 'R11', 'R12', 'R20', 'R21', 'R22'],
+        Vector3: ['X', 'Y', 'Z'],
+        Vector2: ['X', 'Y']
+    },
+    escapeXml(value) {
+        return value
+            .replace(/&amp;/g, '&amp;&amp;')
+            .replace(/&#((?!0?0?38;)\d{1,4}|(?!0?0?26;)x[0-9a-fA-F]{1,4});/g, '&amp;#$1;');
+    },
+    unescapeXml(value) {
+        if (value.startsWith('<![CDATA[')) {
+            // https://github.com/niklasvh/base64-arraybuffer/blob/master/src/index.ts
+            const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+            const lookup = new Uint8Array(256);
+            for (var i = 0; i < chars.length; i++) {
+                lookup[chars.charCodeAt(i)] = i;
+            }
+            const decodeBase64 = (base64, startIndex, endIndex) => {
+                var bufferLength = base64.length * 0.75;
+                var len = endIndex - startIndex;
+                var i = startIndex;
+                var p = 0;
+                var encoded1;
+                var encoded2;
+                var encoded3;
+                var encoded4;
+                if (base64[base64.length - 1] === '=') {
+                    bufferLength--;
+                    if (base64[base64.length - 2] === '=') {
+                        bufferLength--;
+                    }
+                }
+                const bytes = new Uint8Array(bufferLength);
+                for (; i < len; i += 4) {
+                    encoded1 = lookup[base64.charCodeAt(i)];
+                    encoded2 = lookup[base64.charCodeAt(i + 1)];
+                    encoded3 = lookup[base64.charCodeAt(i + 2)];
+                    encoded4 = lookup[base64.charCodeAt(i + 3)];
+                    bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+                    bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+                    bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+                }
+                return bytes;
+            };
+            return bufferToString(decodeBase64(value, 9, -3));
+        }
+        return value
+            .replace(/(?<!&)((?:&{2})*)&#(\d{1,4}|x[0-9a-fA-F]{1,4});/g, (_, prefix, inner) => {
+            const byte = inner[0] === 'x' ? parseInt(inner.slice(1), 16) : parseInt(inner, 10);
+            return `${prefix}${String.fromCharCode(byte)}`;
+        })
+            .replace(/&&/g, '&');
+    },
+    parse(buffer) {
+        // const xml = new DOMParser().parseFromString(this.escapeXml(bufferToString(buffer)), 'text/xml').documentElement
+        const window = new jsdom_1.JSDOM(this.escapeXml(bufferToString(buffer)), {
+            contentType: 'text/xml'
+        }).window;
+        const xml = window.document.documentElement;
+        const parser = {
+            result: new Instance_1.InstanceRoot(),
+            refs: {},
+            refWait: [],
+            sharedStrings: {}
+        };
+        const sharedStrings = xml.querySelector(':scope > SharedStrings');
+        if (sharedStrings) {
+            for (const child of Object.values(sharedStrings.children)) {
+                if (child.nodeName !== 'SharedString') {
+                    continue;
+                }
+                const md5 = child.getAttribute('md5');
+                var value;
+                try {
+                    value = window.atob(child.textContent?.trim() || '');
+                }
+                catch (ex) {
+                    console.error(ex);
+                }
+                if (typeof md5 === 'string' && typeof value === 'string') {
+                    parser.sharedStrings[md5] = { md5, value };
+                }
+            }
+        }
+        for (const child of Object.values(xml.children)) {
+            if (child.nodeName === 'Item') {
+                parser.result.push(this.parseItem(parser, child));
+            }
+        }
+        return {
+            result: parser.result,
+            instances: parser.result.getDescendants()
+        };
+    },
+    parseItem(parser, node) {
+        const inst = Instance_1.Instance.new(node.className);
+        const referent = node.getAttribute('referent');
+        if (referent) {
+            parser.refs[referent] = inst;
+            for (const wait of parser.refWait) {
+                if (wait.id === referent) {
+                    parser.refWait.splice(parser.refWait.indexOf(wait), 1);
+                    wait.inst.setProperty(wait.name, inst, 'Instance');
+                }
+            }
+        }
+        for (const childNode of Object.values(node.children)) {
+            switch (childNode.nodeName) {
+                case 'Item': {
+                    const child = this.parseItem(parser, childNode);
+                    child.setProperty('Parent', inst, 'Instance');
+                    break;
+                }
+                case 'Properties':
+                    try {
+                        this.parseProperties(parser, inst, childNode);
+                    }
+                    catch (err) {
+                        console.log(err);
+                        throw 'owch';
+                    }
+                    break;
+            }
+        }
+        return inst;
+    },
+    parseProperties(parser, inst, targetNode) {
+        for (var propNode of Object.values(targetNode.children)) {
+            const name = propNode.attributes['name'].value;
+            const value = propNode.textContent;
+            switch (propNode.nodeName.toLowerCase()) {
+                case 'content':
+                case 'string':
+                case 'protectedstring':
+                case 'binarystring': {
+                    inst.setProperty(name, this.unescapeXml(value.trim()), 'string');
+                    break;
+                }
+                case 'double': {
+                    inst.setProperty(name, +value, 'double');
+                    break;
+                }
+                case 'float': {
+                    inst.setProperty(name, +value, 'float');
+                    break;
+                }
+                case 'int': {
+                    inst.setProperty(name, +value, 'int');
+                    break;
+                }
+                case 'int64': {
+                    inst.setProperty(name, value, 'int64');
+                    break;
+                }
+                case 'bool': {
+                    inst.setProperty(name, value.toLowerCase() === 'true', 'bool');
+                    break;
+                }
+                case 'token': {
+                    inst.setProperty(name, +value, 'Enum');
+                    break;
+                }
+                case 'color3':
+                case 'color3uint8': {
+                    inst.setProperty(name, [(+value >>> 16 & 255) / 255, (+value >>> 8 & 255) / 255, (+value & 255) / 255], 'Color3');
+                    break;
+                }
+                case 'optionalcoordinateframe':
+                    const cframeNode = Object.values(propNode.children).find(x => x.nodeName.toLowerCase() === 'cframe');
+                    if (!cframeNode) {
+                        break;
+                    }
+                    propNode = cframeNode;
+                // break omitted
+                case 'coordinateframe': {
+                    const cframe = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1];
+                    for (const x of Object.values(propNode.children)) {
+                        const index = this.Transforms.CFrame.indexOf(x.nodeName.toUpperCase());
+                        if (index !== -1) {
+                            cframe[index] = +x.textContent;
+                        }
+                    }
+                    inst.setProperty(name, cframe, 'CFrame');
+                    break;
+                }
+                case 'vector2': {
+                    const vector2 = [0, 0];
+                    for (const x of Object.values(propNode.children)) {
+                        const index = this.Transforms.Vector2.indexOf(x.nodeName.toUpperCase());
+                        if (index !== -1) {
+                            vector2[index] = +x.textContent;
+                        }
+                    }
+                    inst.setProperty(name, vector2, 'Vector2');
+                    break;
+                }
+                case 'vector3': {
+                    const vector3 = [0, 0, 0];
+                    for (const x of Object.values(propNode.children)) {
+                        const index = this.Transforms.Vector3.indexOf(x.nodeName.toUpperCase());
+                        if (index !== -1) {
+                            vector3[index] = +x.textContent;
+                        }
+                    }
+                    inst.setProperty(name, vector3, 'Vector3');
+                    break;
+                }
+                case 'udim2': {
+                    const udim2 = [
+                        [0, 0],
+                        [0, 0]
+                    ];
+                    for (const x of Object.values(propNode.children)) {
+                        const nodeName = x.nodeName.toUpperCase();
+                        if (nodeName === 'XS') {
+                            udim2[0][0] = +x.textContent;
+                        }
+                        else if (nodeName === 'XO') {
+                            udim2[0][1] = +x.textContent;
+                        }
+                        else if (nodeName === 'YS') {
+                            udim2[1][0] = +x.textContent;
+                        }
+                        else if (nodeName === 'YO') {
+                            udim2[0][1] = +x.textContent;
+                        }
+                    }
+                    inst.setProperty(name, udim2, 'UDim2');
+                    break;
+                }
+                case 'physicalproperties': {
+                    const props = { CustomPhysics: false, Density: null, Friction: null, Elasticity: null, FrictionWeight: null, ElasticityWeight: null };
+                    for (const x of Object.values(propNode.children)) {
+                        if (x.nodeName in props) {
+                            props[x.nodeName] = x.nodeName === 'CustomPhysics' ? x.textContent.toLowerCase() === 'true' : +x.textContent;
+                        }
+                    }
+                    inst.setProperty(name, props, 'PhysicalProperties');
+                    break;
+                }
+                case 'ref': {
+                    const target = parser.refs[value] || null;
+                    if (!target && value.toLowerCase() !== 'null') {
+                        parser.refWait.push({
+                            inst, name,
+                            id: value
+                        });
+                    }
+                    inst.setProperty(name, target, 'Instance');
+                    break;
+                }
+                case 'sharedstring': {
+                    const md5 = value.trim();
+                    const sharedString = parser.sharedStrings[md5].value;
+                    inst.setProperty(name, sharedString, 'SharedString');
+                    break;
+                }
+                case 'uniqueid': {
+                    inst.setProperty(name, value.trim(), 'UniqueId');
+                    break;
+                }
+                case 'colorsequence':
+                case 'numberrange':
+                case 'numbersequence':
+                    break;
+                default:
+                    console.warn(`[ParseRBXXml] Unknown dataType ${propNode.nodeName} for ${inst.ClassName}.${name}`, propNode.innerHTML, ' is the RBXLX/RBXMX invalid?');
+            }
+        }
+    }
+};
+exports.default = XmlParser;

package/dist/attributes-parser/attributes_parser.d.ts

@@ -0,0 +1,7 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+* @param {Uint8Array} buf
+* @returns {any}
+*/
+export function parse_attrs(buf: Uint8Array): any;

package/dist/attributes-parser/attributes_parser.js

@@ -0,0 +1,291 @@
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+let wasm;
+const { TextDecoder, TextEncoder } = require(`util`);
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+* @param {Uint8Array} buf
+* @returns {any}
+*/
+module.exports.parse_attrs = function(buf) {
+    const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parse_attrs(ptr0, len0);
+    return takeObject(ret);
+};
+
+module.exports.__wbindgen_object_drop_ref = function(arg0) {
+    takeObject(arg0);
+};
+
+module.exports.__wbindgen_as_number = function(arg0) {
+    const ret = +getObject(arg0);
+    return ret;
+};
+
+module.exports.__wbindgen_object_clone_ref = function(arg0) {
+    const ret = getObject(arg0);
+    return addHeapObject(ret);
+};
+
+module.exports.__wbindgen_error_new = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+module.exports.__wbindgen_is_string = function(arg0) {
+    const ret = typeof(getObject(arg0)) === 'string';
+    return ret;
+};
+
+module.exports.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+module.exports.__wbindgen_number_new = function(arg0) {
+    const ret = arg0;
+    return addHeapObject(ret);
+};
+
+module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
+    const ret = arg0;
+    return addHeapObject(ret);
+};
+
+module.exports.__wbindgen_bigint_from_u64 = function(arg0) {
+    const ret = BigInt.asUintN(64, arg0);
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_set_f975102236d3c502 = function(arg0, arg1, arg2) {
+    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+};
+
+module.exports.__wbg_new_16b304a2cfa7ff4a = function() {
+    const ret = new Array();
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_new_d9bc3a0147634640 = function() {
+    const ret = new Map();
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_new_72fb9a18b5ae2624 = function() {
+    const ret = new Object();
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
+    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+};
+
+module.exports.__wbg_set_8417257aaedc936b = function(arg0, arg1, arg2) {
+    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+};
+
+module.exports.__wbindgen_debug_string = function(arg0, arg1) {
+    const ret = debugString(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+const path = require('path').join(__dirname, 'attributes_parser_bg.wasm');
+const bytes = require('fs').readFileSync(path);
+
+const wasmModule = new WebAssembly.Module(bytes);
+const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+wasm = wasmInstance.exports;
+module.exports.__wasm = wasm;
+

package/dist/attributes-parser/attributes_parser_bg.wasm.d.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export function parse_attrs(a: number, b: number): number;
+export function __wbindgen_malloc(a: number, b: number): number;
+export function __wbindgen_realloc(a: number, b: number, c: number, d: number): number;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { ParserResult } from './BinaryParser';
+import { PathOrFileDescriptor } from 'node:fs';
+import { AttributeValue } from './Instance';
+export type Result = Omit<ParserResult, 'reader' | 'arrays' | 'arrayIndex' | 'sharedStrings' | 'groups' | 'meta'>;
+export declare function parseBuffer(buffer: ArrayBuffer): Result;
+export declare function readFile(file: PathOrFileDescriptor): Result;
+export declare function parseAttributes(attributesSerializeBuf: ArrayBufferLike): {
+    [key: string]: AttributeValue;
+};