@babylonjs/loaders 9.11.0 → 9.12.1

package/FBX/parsers/fbxBinaryParser.js

@@ -0,0 +1,255 @@
+import { inflateZlib } from "./zlibInflate.js";
+const FBX_MAGIC = "Kaydara FBX Binary  \0";
+const HEADER_SIZE = 27; // 21 magic + 2 padding + 4 version uint32
+/**
+ * Parse a binary FBX file into an FBXDocument.
+ * Supports FBX versions 7.0–7.7 (v7.5+ uses 64-bit node headers).
+ */
+export function parseBinaryFBX(buffer) {
+    const view = new DataView(buffer);
+    const bytes = new Uint8Array(buffer);
+    // Validate magic
+    const magic = decodeASCII(bytes, 0, 21);
+    if (magic !== FBX_MAGIC) {
+        throw new Error("Not a valid binary FBX file");
+    }
+    if (buffer.byteLength < HEADER_SIZE) {
+        throw new Error("Truncated binary FBX header");
+    }
+    const version = view.getUint32(23, true);
+    // v7.5+ uses 64-bit offsets in node records
+    const is64Bit = version >= 7500;
+    const nodes = [];
+    let offset = HEADER_SIZE;
+    while (offset < buffer.byteLength) {
+        const result = parseNode(view, bytes, offset, is64Bit, buffer.byteLength);
+        if (result === null) {
+            break; // null sentinel node
+        }
+        nodes.push(result.node);
+        offset = result.endOffset;
+    }
+    return { version, nodes };
+}
+function parseNode(view, bytes, offset, is64Bit, limit) {
+    // Read node header
+    let endOffset;
+    let numProperties;
+    let propertyListLen;
+    let headerSize;
+    if (is64Bit) {
+        ensureRange(bytes, offset, 25, limit, "FBX node header");
+        endOffset = readUint64AsNumber(view, offset);
+        numProperties = readUint64AsNumber(view, offset + 8);
+        propertyListLen = readUint64AsNumber(view, offset + 16);
+        headerSize = 25; // 8+8+8+1 (nameLen byte)
+    }
+    else {
+        ensureRange(bytes, offset, 13, limit, "FBX node header");
+        endOffset = view.getUint32(offset, true);
+        numProperties = view.getUint32(offset + 4, true);
+        propertyListLen = view.getUint32(offset + 8, true);
+        headerSize = 13; // 4+4+4+1 (nameLen byte)
+    }
+    // Null sentinel: all header fields are zero
+    if (endOffset === 0) {
+        return null;
+    }
+    if (endOffset <= offset || endOffset > limit) {
+        throw new Error(`Invalid FBX node end offset ${endOffset} at offset ${offset}`);
+    }
+    const nameLen = bytes[offset + headerSize - 1];
+    ensureRange(bytes, offset + headerSize, nameLen, endOffset, "FBX node name");
+    const name = decodeASCII(bytes, offset + headerSize, nameLen);
+    let cursor = offset + headerSize + nameLen;
+    const propertiesStart = cursor;
+    const propertiesEnd = propertiesStart + propertyListLen;
+    if (propertiesEnd > endOffset) {
+        throw new Error(`Invalid FBX property list length for node '${name}' at offset ${offset}`);
+    }
+    // Parse properties
+    const properties = [];
+    for (let i = 0; i < numProperties; i++) {
+        const result = parseProperty(view, bytes, cursor, propertiesEnd);
+        properties.push(result.property);
+        cursor = result.nextOffset;
+    }
+    if (cursor !== propertiesEnd) {
+        throw new Error(`Invalid FBX property list length for node '${name}' at offset ${offset}`);
+    }
+    // Parse nested child nodes (between end of properties and endOffset)
+    const children = [];
+    if (cursor < endOffset) {
+        while (cursor < endOffset) {
+            const child = parseNode(view, bytes, cursor, is64Bit, endOffset);
+            if (child === null) {
+                break;
+            }
+            if (child.endOffset <= cursor || child.endOffset > endOffset) {
+                throw new Error(`Invalid FBX child node end offset ${child.endOffset} at offset ${cursor}`);
+            }
+            children.push(child.node);
+            cursor = child.endOffset;
+        }
+    }
+    return {
+        node: { name, properties, children },
+        endOffset,
+    };
+}
+function parseProperty(view, bytes, offset, limit) {
+    ensureRange(bytes, offset, 1, limit, "FBX property type");
+    const typeCode = String.fromCharCode(bytes[offset]);
+    offset += 1;
+    switch (typeCode) {
+        case "C": {
+            // Boolean (1 byte)
+            ensureRange(bytes, offset, 1, limit, "FBX boolean property");
+            const value = bytes[offset] !== 0;
+            return { property: { type: "boolean", value }, nextOffset: offset + 1 };
+        }
+        case "Y": {
+            // Int16
+            ensureRange(bytes, offset, 2, limit, "FBX int16 property");
+            const value = view.getInt16(offset, true);
+            return { property: { type: "int16", value }, nextOffset: offset + 2 };
+        }
+        case "I": {
+            // Int32
+            ensureRange(bytes, offset, 4, limit, "FBX int32 property");
+            const value = view.getInt32(offset, true);
+            return { property: { type: "int32", value }, nextOffset: offset + 4 };
+        }
+        case "F": {
+            // Float32
+            ensureRange(bytes, offset, 4, limit, "FBX float32 property");
+            const value = view.getFloat32(offset, true);
+            return { property: { type: "float32", value }, nextOffset: offset + 4 };
+        }
+        case "D": {
+            // Float64
+            ensureRange(bytes, offset, 8, limit, "FBX float64 property");
+            const value = view.getFloat64(offset, true);
+            return { property: { type: "float64", value }, nextOffset: offset + 8 };
+        }
+        case "L": {
+            // Int64
+            ensureRange(bytes, offset, 8, limit, "FBX int64 property");
+            const value = readInt64AsNumber(view, offset);
+            return { property: { type: "int64", value }, nextOffset: offset + 8 };
+        }
+        case "S": {
+            // String (uint32 length + data)
+            ensureRange(bytes, offset, 4, limit, "FBX string property length");
+            const len = view.getUint32(offset, true);
+            ensureRange(bytes, offset + 4, len, limit, "FBX string property data");
+            const value = decodeUTF8(bytes, offset + 4, len);
+            return { property: { type: "string", value }, nextOffset: offset + 4 + len };
+        }
+        case "R": {
+            // Raw binary data (uint32 length + data)
+            ensureRange(bytes, offset, 4, limit, "FBX raw property length");
+            const len = view.getUint32(offset, true);
+            ensureRange(bytes, offset + 4, len, limit, "FBX raw property data");
+            const value = bytes.slice(offset + 4, offset + 4 + len);
+            return { property: { type: "raw", value }, nextOffset: offset + 4 + len };
+        }
+        // Array types
+        case "f":
+            return parseArrayProperty(view, bytes, offset, "float32[]", 4, limit);
+        case "d":
+            return parseArrayProperty(view, bytes, offset, "float64[]", 8, limit);
+        case "i":
+            return parseArrayProperty(view, bytes, offset, "int32[]", 4, limit);
+        case "l":
+            return parseArrayProperty(view, bytes, offset, "int64[]", 8, limit);
+        case "b":
+            return parseArrayProperty(view, bytes, offset, "boolean[]", 1, limit);
+        default:
+            throw new Error(`Unknown FBX property type: '${typeCode}' at offset ${offset - 1}`);
+    }
+}
+function parseArrayProperty(view, bytes, offset, type, elementSize, limit) {
+    ensureRange(bytes, offset, 12, limit, `FBX array property header for ${type}`);
+    const arrayLength = view.getUint32(offset, true);
+    const encoding = view.getUint32(offset + 4, true); // 0=raw, 1=zlib
+    const compressedLength = view.getUint32(offset + 8, true);
+    offset += 12;
+    const expectedByteLength = arrayLength * elementSize;
+    ensureRange(bytes, offset, compressedLength, limit, `FBX array property data for ${type}`);
+    let arrayData;
+    if (encoding === 1) {
+        // zlib compressed
+        const compressed = bytes.subarray(offset, offset + compressedLength);
+        arrayData = inflateZlib(compressed, expectedByteLength);
+    }
+    else {
+        if (encoding !== 0) {
+            throw new Error(`Unsupported FBX array encoding: ${encoding}`);
+        }
+        if (compressedLength !== expectedByteLength) {
+            throw new Error(`Invalid FBX array byte length for ${type}`);
+        }
+        arrayData = bytes.slice(offset, offset + compressedLength);
+    }
+    const arrayBuffer = arrayData.buffer.slice(arrayData.byteOffset, arrayData.byteOffset + arrayData.byteLength);
+    let value;
+    switch (type) {
+        case "float32[]":
+            value = new Float32Array(arrayBuffer);
+            break;
+        case "float64[]":
+            value = new Float64Array(arrayBuffer);
+            break;
+        case "int32[]":
+            value = new Int32Array(arrayBuffer);
+            break;
+        case "boolean[]":
+            value = arrayData;
+            break;
+        case "int64[]":
+            value = readInt64ArrayData(arrayData);
+            break;
+        default:
+            throw new Error(`Unexpected array type: ${type}`);
+    }
+    return {
+        property: { type, value },
+        nextOffset: offset + compressedLength,
+    };
+}
+function ensureRange(bytes, offset, byteLength, limit, context) {
+    if (offset < 0 || byteLength < 0 || offset + byteLength > limit || offset + byteLength > bytes.byteLength) {
+        throw new Error(`${context}: unexpected end of input`);
+    }
+}
+function readUint64AsNumber(view, offset) {
+    const low = view.getUint32(offset, true);
+    const high = view.getUint32(offset + 4, true);
+    return high * 0x100000000 + low;
+}
+function readInt64AsNumber(view, offset) {
+    const low = view.getUint32(offset, true);
+    const high = view.getInt32(offset + 4, true);
+    return high * 0x100000000 + low;
+}
+function readInt64ArrayData(arrayData) {
+    const view = new DataView(arrayData.buffer, arrayData.byteOffset, arrayData.byteLength);
+    const values = new Float64Array(arrayData.byteLength / 8);
+    for (let i = 0; i < values.length; i++) {
+        values[i] = readInt64AsNumber(view, i * 8);
+    }
+    return values;
+}
+function decodeASCII(bytes, offset, length) {
+    let result = "";
+    for (let i = 0; i < length; i++) {
+        result += String.fromCharCode(bytes[offset + i]);
+    }
+    return result;
+}
+function decodeUTF8(bytes, offset, length) {
+    const decoder = new TextDecoder("utf-8");
+    return decoder.decode(bytes.subarray(offset, offset + length));
+}
+//# sourceMappingURL=fbxBinaryParser.js.map

package/FBX/parsers/fbxBinaryParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fbxBinaryParser.js","sourceRoot":"","sources":["../../../../../dev/loaders/src/FBX/parsers/fbxBinaryParser.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention, jsdoc/require-param, jsdoc/require-returns */\r\nimport { type FBXDocument, type FBXNode, type FBXProperty, type FBXPropertyType } from \"../types/fbxTypes\";\r\nimport { inflateZlib } from \"./zlibInflate\";\r\n\r\nconst FBX_MAGIC = \"Kaydara FBX Binary  \\0\";\r\nconst HEADER_SIZE = 27; // 21 magic + 2 padding + 4 version uint32\r\n\r\n/**\r\n * Parse a binary FBX file into an FBXDocument.\r\n * Supports FBX versions 7.0–7.7 (v7.5+ uses 64-bit node headers).\r\n */\r\nexport function parseBinaryFBX(buffer: ArrayBuffer): FBXDocument {\r\n    const view = new DataView(buffer);\r\n    const bytes = new Uint8Array(buffer);\r\n\r\n    // Validate magic\r\n    const magic = decodeASCII(bytes, 0, 21);\r\n    if (magic !== FBX_MAGIC) {\r\n        throw new Error(\"Not a valid binary FBX file\");\r\n    }\r\n    if (buffer.byteLength < HEADER_SIZE) {\r\n        throw new Error(\"Truncated binary FBX header\");\r\n    }\r\n\r\n    const version = view.getUint32(23, true);\r\n    // v7.5+ uses 64-bit offsets in node records\r\n    const is64Bit = version >= 7500;\r\n\r\n    const nodes: FBXNode[] = [];\r\n    let offset = HEADER_SIZE;\r\n\r\n    while (offset < buffer.byteLength) {\r\n        const result = parseNode(view, bytes, offset, is64Bit, buffer.byteLength);\r\n        if (result === null) {\r\n            break; // null sentinel node\r\n        }\r\n        nodes.push(result.node);\r\n        offset = result.endOffset;\r\n    }\r\n\r\n    return { version, nodes };\r\n}\r\n\r\ninterface ParsedNode {\r\n    node: FBXNode;\r\n    endOffset: number;\r\n}\r\n\r\nfunction parseNode(view: DataView, bytes: Uint8Array, offset: number, is64Bit: boolean, limit: number): ParsedNode | null {\r\n    // Read node header\r\n    let endOffset: number;\r\n    let numProperties: number;\r\n    let propertyListLen: number;\r\n    let headerSize: number;\r\n\r\n    if (is64Bit) {\r\n        ensureRange(bytes, offset, 25, limit, \"FBX node header\");\r\n        endOffset = readUint64AsNumber(view, offset);\r\n        numProperties = readUint64AsNumber(view, offset + 8);\r\n        propertyListLen = readUint64AsNumber(view, offset + 16);\r\n        headerSize = 25; // 8+8+8+1 (nameLen byte)\r\n    } else {\r\n        ensureRange(bytes, offset, 13, limit, \"FBX node header\");\r\n        endOffset = view.getUint32(offset, true);\r\n        numProperties = view.getUint32(offset + 4, true);\r\n        propertyListLen = view.getUint32(offset + 8, true);\r\n        headerSize = 13; // 4+4+4+1 (nameLen byte)\r\n    }\r\n\r\n    // Null sentinel: all header fields are zero\r\n    if (endOffset === 0) {\r\n        return null;\r\n    }\r\n    if (endOffset <= offset || endOffset > limit) {\r\n        throw new Error(`Invalid FBX node end offset ${endOffset} at offset ${offset}`);\r\n    }\r\n\r\n    const nameLen = bytes[offset + headerSize - 1];\r\n    ensureRange(bytes, offset + headerSize, nameLen, endOffset, \"FBX node name\");\r\n    const name = decodeASCII(bytes, offset + headerSize, nameLen);\r\n\r\n    let cursor = offset + headerSize + nameLen;\r\n    const propertiesStart = cursor;\r\n    const propertiesEnd = propertiesStart + propertyListLen;\r\n    if (propertiesEnd > endOffset) {\r\n        throw new Error(`Invalid FBX property list length for node '${name}' at offset ${offset}`);\r\n    }\r\n\r\n    // Parse properties\r\n    const properties: FBXProperty[] = [];\r\n    for (let i = 0; i < numProperties; i++) {\r\n        const result = parseProperty(view, bytes, cursor, propertiesEnd);\r\n        properties.push(result.property);\r\n        cursor = result.nextOffset;\r\n    }\r\n    if (cursor !== propertiesEnd) {\r\n        throw new Error(`Invalid FBX property list length for node '${name}' at offset ${offset}`);\r\n    }\r\n\r\n    // Parse nested child nodes (between end of properties and endOffset)\r\n    const children: FBXNode[] = [];\r\n    if (cursor < endOffset) {\r\n        while (cursor < endOffset) {\r\n            const child = parseNode(view, bytes, cursor, is64Bit, endOffset);\r\n            if (child === null) {\r\n                break;\r\n            }\r\n            if (child.endOffset <= cursor || child.endOffset > endOffset) {\r\n                throw new Error(`Invalid FBX child node end offset ${child.endOffset} at offset ${cursor}`);\r\n            }\r\n            children.push(child.node);\r\n            cursor = child.endOffset;\r\n        }\r\n    }\r\n\r\n    return {\r\n        node: { name, properties, children },\r\n        endOffset,\r\n    };\r\n}\r\n\r\ninterface ParsedProperty {\r\n    property: FBXProperty;\r\n    nextOffset: number;\r\n}\r\n\r\nfunction parseProperty(view: DataView, bytes: Uint8Array, offset: number, limit: number): ParsedProperty {\r\n    ensureRange(bytes, offset, 1, limit, \"FBX property type\");\r\n    const typeCode = String.fromCharCode(bytes[offset]);\r\n    offset += 1;\r\n\r\n    switch (typeCode) {\r\n        case \"C\": {\r\n            // Boolean (1 byte)\r\n            ensureRange(bytes, offset, 1, limit, \"FBX boolean property\");\r\n            const value = bytes[offset] !== 0;\r\n            return { property: { type: \"boolean\", value }, nextOffset: offset + 1 };\r\n        }\r\n        case \"Y\": {\r\n            // Int16\r\n            ensureRange(bytes, offset, 2, limit, \"FBX int16 property\");\r\n            const value = view.getInt16(offset, true);\r\n            return { property: { type: \"int16\", value }, nextOffset: offset + 2 };\r\n        }\r\n        case \"I\": {\r\n            // Int32\r\n            ensureRange(bytes, offset, 4, limit, \"FBX int32 property\");\r\n            const value = view.getInt32(offset, true);\r\n            return { property: { type: \"int32\", value }, nextOffset: offset + 4 };\r\n        }\r\n        case \"F\": {\r\n            // Float32\r\n            ensureRange(bytes, offset, 4, limit, \"FBX float32 property\");\r\n            const value = view.getFloat32(offset, true);\r\n            return { property: { type: \"float32\", value }, nextOffset: offset + 4 };\r\n        }\r\n        case \"D\": {\r\n            // Float64\r\n            ensureRange(bytes, offset, 8, limit, \"FBX float64 property\");\r\n            const value = view.getFloat64(offset, true);\r\n            return { property: { type: \"float64\", value }, nextOffset: offset + 8 };\r\n        }\r\n        case \"L\": {\r\n            // Int64\r\n            ensureRange(bytes, offset, 8, limit, \"FBX int64 property\");\r\n            const value = readInt64AsNumber(view, offset);\r\n            return { property: { type: \"int64\", value }, nextOffset: offset + 8 };\r\n        }\r\n        case \"S\": {\r\n            // String (uint32 length + data)\r\n            ensureRange(bytes, offset, 4, limit, \"FBX string property length\");\r\n            const len = view.getUint32(offset, true);\r\n            ensureRange(bytes, offset + 4, len, limit, \"FBX string property data\");\r\n            const value = decodeUTF8(bytes, offset + 4, len);\r\n            return { property: { type: \"string\", value }, nextOffset: offset + 4 + len };\r\n        }\r\n        case \"R\": {\r\n            // Raw binary data (uint32 length + data)\r\n            ensureRange(bytes, offset, 4, limit, \"FBX raw property length\");\r\n            const len = view.getUint32(offset, true);\r\n            ensureRange(bytes, offset + 4, len, limit, \"FBX raw property data\");\r\n            const value = bytes.slice(offset + 4, offset + 4 + len);\r\n            return { property: { type: \"raw\", value }, nextOffset: offset + 4 + len };\r\n        }\r\n        // Array types\r\n        case \"f\":\r\n            return parseArrayProperty(view, bytes, offset, \"float32[]\", 4, limit);\r\n        case \"d\":\r\n            return parseArrayProperty(view, bytes, offset, \"float64[]\", 8, limit);\r\n        case \"i\":\r\n            return parseArrayProperty(view, bytes, offset, \"int32[]\", 4, limit);\r\n        case \"l\":\r\n            return parseArrayProperty(view, bytes, offset, \"int64[]\", 8, limit);\r\n        case \"b\":\r\n            return parseArrayProperty(view, bytes, offset, \"boolean[]\", 1, limit);\r\n        default:\r\n            throw new Error(`Unknown FBX property type: '${typeCode}' at offset ${offset - 1}`);\r\n    }\r\n}\r\n\r\nfunction parseArrayProperty(view: DataView, bytes: Uint8Array, offset: number, type: FBXPropertyType, elementSize: number, limit: number): ParsedProperty {\r\n    ensureRange(bytes, offset, 12, limit, `FBX array property header for ${type}`);\r\n    const arrayLength = view.getUint32(offset, true);\r\n    const encoding = view.getUint32(offset + 4, true); // 0=raw, 1=zlib\r\n    const compressedLength = view.getUint32(offset + 8, true);\r\n    offset += 12;\r\n    const expectedByteLength = arrayLength * elementSize;\r\n    ensureRange(bytes, offset, compressedLength, limit, `FBX array property data for ${type}`);\r\n\r\n    let arrayData: Uint8Array;\r\n    if (encoding === 1) {\r\n        // zlib compressed\r\n        const compressed = bytes.subarray(offset, offset + compressedLength);\r\n        arrayData = inflateZlib(compressed, expectedByteLength);\r\n    } else {\r\n        if (encoding !== 0) {\r\n            throw new Error(`Unsupported FBX array encoding: ${encoding}`);\r\n        }\r\n        if (compressedLength !== expectedByteLength) {\r\n            throw new Error(`Invalid FBX array byte length for ${type}`);\r\n        }\r\n        arrayData = bytes.slice(offset, offset + compressedLength);\r\n    }\r\n\r\n    const arrayBuffer = arrayData.buffer.slice(arrayData.byteOffset, arrayData.byteOffset + arrayData.byteLength);\r\n\r\n    let value: Float32Array | Float64Array | Int32Array | Uint8Array;\r\n    switch (type) {\r\n        case \"float32[]\":\r\n            value = new Float32Array(arrayBuffer);\r\n            break;\r\n        case \"float64[]\":\r\n            value = new Float64Array(arrayBuffer);\r\n            break;\r\n        case \"int32[]\":\r\n            value = new Int32Array(arrayBuffer);\r\n            break;\r\n        case \"boolean[]\":\r\n            value = arrayData;\r\n            break;\r\n        case \"int64[]\":\r\n            value = readInt64ArrayData(arrayData);\r\n            break;\r\n        default:\r\n            throw new Error(`Unexpected array type: ${type}`);\r\n    }\r\n\r\n    return {\r\n        property: { type, value },\r\n        nextOffset: offset + compressedLength,\r\n    };\r\n}\r\n\r\nfunction ensureRange(bytes: Uint8Array, offset: number, byteLength: number, limit: number, context: string): void {\r\n    if (offset < 0 || byteLength < 0 || offset + byteLength > limit || offset + byteLength > bytes.byteLength) {\r\n        throw new Error(`${context}: unexpected end of input`);\r\n    }\r\n}\r\n\r\nfunction readUint64AsNumber(view: DataView, offset: number): number {\r\n    const low = view.getUint32(offset, true);\r\n    const high = view.getUint32(offset + 4, true);\r\n    return high * 0x100000000 + low;\r\n}\r\n\r\nfunction readInt64AsNumber(view: DataView, offset: number): number {\r\n    const low = view.getUint32(offset, true);\r\n    const high = view.getInt32(offset + 4, true);\r\n    return high * 0x100000000 + low;\r\n}\r\n\r\nfunction readInt64ArrayData(arrayData: Uint8Array): Float64Array {\r\n    const view = new DataView(arrayData.buffer, arrayData.byteOffset, arrayData.byteLength);\r\n    const values = new Float64Array(arrayData.byteLength / 8);\r\n    for (let i = 0; i < values.length; i++) {\r\n        values[i] = readInt64AsNumber(view, i * 8);\r\n    }\r\n    return values;\r\n}\r\n\r\nfunction decodeASCII(bytes: Uint8Array, offset: number, length: number): string {\r\n    let result = \"\";\r\n    for (let i = 0; i < length; i++) {\r\n        result += String.fromCharCode(bytes[offset + i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nfunction decodeUTF8(bytes: Uint8Array, offset: number, length: number): string {\r\n    const decoder = new TextDecoder(\"utf-8\");\r\n    return decoder.decode(bytes.subarray(offset, offset + length));\r\n}\r\n"]}

package/FBX/parsers/zlibInflate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Inflate a zlib-wrapped deflate stream.
+ *
+ * This implementation is intentionally scoped to FBX binary array payloads: one-shot,
+ * synchronous zlib streams with the exact uncompressed length known up front.
+ */
+export declare function inflateZlib(input: Uint8Array, expectedLength: number): Uint8Array;

package/FBX/parsers/zlibInflate.js

@@ -0,0 +1,350 @@
+/* eslint-disable @typescript-eslint/naming-convention, jsdoc/require-param, jsdoc/require-returns */
+const ADLER_MOD = 65521;
+const MAX_BITS = 15;
+const LENGTH_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+const LENGTH_EXTRA_BITS = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+const DISTANCE_BASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+const DISTANCE_EXTRA_BITS = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+const CODE_LENGTH_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+/**
+ * Inflate a zlib-wrapped deflate stream.
+ *
+ * This implementation is intentionally scoped to FBX binary array payloads: one-shot,
+ * synchronous zlib streams with the exact uncompressed length known up front.
+ */
+export function inflateZlib(input, expectedLength) {
+    if (!Number.isInteger(expectedLength) || expectedLength < 0) {
+        throw new Error("zlib: invalid expected length");
+    }
+    if (input.byteLength < 6) {
+        throw new Error("zlib: unexpected end of input");
+    }
+    const cmf = input[0];
+    const flg = input[1];
+    if ((cmf & 0x0f) !== 8 || cmf >> 4 > 7 || ((cmf << 8) + flg) % 31 !== 0) {
+        throw new Error("zlib: invalid header");
+    }
+    if ((flg & 0x20) !== 0) {
+        throw new Error("zlib: preset dictionary not supported");
+    }
+    const reader = new BitReader(input, 2, input.byteLength - 4);
+    const output = new OutputWriter(expectedLength);
+    let isFinalBlock = false;
+    while (!isFinalBlock) {
+        isFinalBlock = reader.readBits(1) === 1;
+        const blockType = reader.readBits(2);
+        switch (blockType) {
+            case 0:
+                inflateStoredBlock(reader, output);
+                break;
+            case 1:
+                inflateCompressedBlock(reader, output, getFixedLiteralLengthTree(), getFixedDistanceTree());
+                break;
+            case 2: {
+                const { literalLengthTree, distanceTree } = readDynamicTrees(reader);
+                inflateCompressedBlock(reader, output, literalLengthTree, distanceTree);
+                break;
+            }
+            default:
+                throw new Error("deflate: invalid block type");
+        }
+    }
+    if (reader.byteOffset < input.byteLength - 4) {
+        throw new Error("zlib: trailing deflate data");
+    }
+    output.finish();
+    const expectedAdler = ((input[input.byteLength - 4] << 24) | (input[input.byteLength - 3] << 16) | (input[input.byteLength - 2] << 8) | input[input.byteLength - 1]) >>> 0;
+    if (output.adler32() !== expectedAdler) {
+        throw new Error("zlib: adler32 mismatch");
+    }
+    return output.bytes;
+}
+class BitReader {
+    constructor(input, byteOffset, endOffset) {
+        this.input = input;
+        this.byteOffset = byteOffset;
+        this.endOffset = endOffset;
+        this.bitBuffer = 0;
+        this.bitCount = 0;
+    }
+    readBits(count) {
+        this.ensureBits(count);
+        const value = this.bitBuffer & ((1 << count) - 1);
+        this.bitBuffer >>>= count;
+        this.bitCount -= count;
+        return value;
+    }
+    readBit() {
+        if (this.bitCount === 0) {
+            if (this.byteOffset >= this.endOffset) {
+                throw new Error("zlib: unexpected end of input");
+            }
+            this.bitBuffer = this.input[this.byteOffset++];
+            this.bitCount = 8;
+        }
+        const bit = this.bitBuffer & 1;
+        this.bitBuffer >>>= 1;
+        this.bitCount--;
+        return bit;
+    }
+    alignToByte() {
+        this.bitBuffer = 0;
+        this.bitCount = 0;
+    }
+    readUint16LE() {
+        this.ensureByteAligned();
+        if (this.byteOffset + 2 > this.endOffset) {
+            throw new Error("zlib: unexpected end of input");
+        }
+        const value = this.input[this.byteOffset] | (this.input[this.byteOffset + 1] << 8);
+        this.byteOffset += 2;
+        return value;
+    }
+    readByte() {
+        this.ensureByteAligned();
+        if (this.byteOffset >= this.endOffset) {
+            throw new Error("zlib: unexpected end of input");
+        }
+        return this.input[this.byteOffset++];
+    }
+    ensureByteAligned() {
+        if (this.bitCount !== 0) {
+            throw new Error("deflate: expected byte alignment");
+        }
+    }
+    ensureBits(count) {
+        while (this.bitCount < count) {
+            if (this.byteOffset >= this.endOffset) {
+                throw new Error("zlib: unexpected end of input");
+            }
+            this.bitBuffer |= this.input[this.byteOffset++] << this.bitCount;
+            this.bitCount += 8;
+        }
+    }
+}
+class OutputWriter {
+    constructor(expectedLength) {
+        this.offset = 0;
+        this.adlerA = 1;
+        this.adlerB = 0;
+        this.bytes = new Uint8Array(expectedLength);
+    }
+    writeByte(value) {
+        if (this.offset >= this.bytes.byteLength) {
+            throw new Error("zlib: output length mismatch");
+        }
+        const byte = value & 0xff;
+        this.bytes[this.offset++] = byte;
+        this.adlerA += byte;
+        this.adlerB += this.adlerA;
+        this.adlerA %= ADLER_MOD;
+        this.adlerB %= ADLER_MOD;
+    }
+    copy(distance, length) {
+        if (distance <= 0 || distance > this.offset) {
+            throw new Error("deflate: distance out of range");
+        }
+        for (let i = 0; i < length; i++) {
+            this.writeByte(this.bytes[this.offset - distance]);
+        }
+    }
+    finish() {
+        if (this.offset !== this.bytes.byteLength) {
+            throw new Error("zlib: output length mismatch");
+        }
+    }
+    adler32() {
+        return ((this.adlerB << 16) | this.adlerA) >>> 0;
+    }
+}
+class HuffmanTree {
+    constructor(codeLengths, options = {}) {
+        const counts = new Array(MAX_BITS + 1).fill(0);
+        let nonZeroCount = 0;
+        let maxCodeLength = 0;
+        for (const length of codeLengths) {
+            if (!Number.isInteger(length) || length < 0 || length > MAX_BITS) {
+                throw new Error("deflate: invalid huffman code lengths");
+            }
+            if (length > 0) {
+                counts[length]++;
+                nonZeroCount++;
+                maxCodeLength = Math.max(maxCodeLength, length);
+            }
+        }
+        if (nonZeroCount === 0) {
+            if (options.allowEmpty) {
+                this.symbolsByLength = [];
+                this.maxCodeLength = 0;
+                return;
+            }
+            throw new Error("deflate: invalid huffman code lengths");
+        }
+        let remaining = 1;
+        for (let bits = 1; bits <= MAX_BITS; bits++) {
+            remaining = (remaining << 1) - counts[bits];
+            if (remaining < 0) {
+                throw new Error("deflate: invalid huffman code lengths");
+            }
+        }
+        if (remaining !== 0 && nonZeroCount !== 1) {
+            throw new Error("deflate: invalid huffman code lengths");
+        }
+        const nextCode = new Array(MAX_BITS + 1).fill(0);
+        let code = 0;
+        for (let bits = 1; bits <= MAX_BITS; bits++) {
+            code = (code + counts[bits - 1]) << 1;
+            nextCode[bits] = code;
+        }
+        this.symbolsByLength = Array.from({ length: MAX_BITS + 1 }, (_, length) => {
+            if (counts[length] === 0) {
+                return undefined;
+            }
+            const symbols = new Int16Array(1 << length);
+            symbols.fill(-1);
+            return symbols;
+        });
+        for (let symbol = 0; symbol < codeLengths.length; symbol++) {
+            const length = codeLengths[symbol];
+            if (length === 0) {
+                continue;
+            }
+            this.symbolsByLength[length][nextCode[length]++] = symbol;
+        }
+        this.maxCodeLength = maxCodeLength;
+    }
+    decode(reader) {
+        if (this.maxCodeLength === 0) {
+            throw new Error("deflate: invalid huffman code");
+        }
+        let code = 0;
+        for (let length = 1; length <= this.maxCodeLength; length++) {
+            code = (code << 1) | reader.readBit();
+            const symbol = this.symbolsByLength[length]?.[code] ?? -1;
+            if (symbol >= 0) {
+                return symbol;
+            }
+        }
+        throw new Error("deflate: invalid huffman code");
+    }
+}
+let fixedLiteralLengthTree;
+let fixedDistanceTree;
+function getFixedLiteralLengthTree() {
+    if (!fixedLiteralLengthTree) {
+        const lengths = new Array(288);
+        for (let symbol = 0; symbol <= 143; symbol++) {
+            lengths[symbol] = 8;
+        }
+        for (let symbol = 144; symbol <= 255; symbol++) {
+            lengths[symbol] = 9;
+        }
+        for (let symbol = 256; symbol <= 279; symbol++) {
+            lengths[symbol] = 7;
+        }
+        for (let symbol = 280; symbol <= 287; symbol++) {
+            lengths[symbol] = 8;
+        }
+        fixedLiteralLengthTree = new HuffmanTree(lengths);
+    }
+    return fixedLiteralLengthTree;
+}
+function getFixedDistanceTree() {
+    if (!fixedDistanceTree) {
+        fixedDistanceTree = new HuffmanTree(new Array(32).fill(5));
+    }
+    return fixedDistanceTree;
+}
+function inflateStoredBlock(reader, output) {
+    reader.alignToByte();
+    const length = reader.readUint16LE();
+    const inverseLength = reader.readUint16LE();
+    if (((length ^ inverseLength) & 0xffff) !== 0xffff) {
+        throw new Error("deflate: invalid stored block length");
+    }
+    for (let i = 0; i < length; i++) {
+        output.writeByte(reader.readByte());
+    }
+}
+function inflateCompressedBlock(reader, output, literalLengthTree, distanceTree) {
+    while (true) {
+        const symbol = literalLengthTree.decode(reader);
+        if (symbol < 256) {
+            output.writeByte(symbol);
+            continue;
+        }
+        if (symbol === 256) {
+            return;
+        }
+        if (symbol > 285) {
+            throw new Error("deflate: invalid literal/length symbol");
+        }
+        const lengthIndex = symbol - 257;
+        const length = LENGTH_BASE[lengthIndex] + reader.readBits(LENGTH_EXTRA_BITS[lengthIndex]);
+        const distanceSymbol = distanceTree.decode(reader);
+        if (distanceSymbol > 29) {
+            throw new Error("deflate: invalid distance symbol");
+        }
+        const distance = DISTANCE_BASE[distanceSymbol] + reader.readBits(DISTANCE_EXTRA_BITS[distanceSymbol]);
+        output.copy(distance, length);
+    }
+}
+function readDynamicTrees(reader) {
+    const literalLengthCount = reader.readBits(5) + 257;
+    const distanceCount = reader.readBits(5) + 1;
+    const codeLengthCount = reader.readBits(4) + 4;
+    const codeLengthLengths = new Array(19).fill(0);
+    for (let i = 0; i < codeLengthCount; i++) {
+        codeLengthLengths[CODE_LENGTH_ORDER[i]] = reader.readBits(3);
+    }
+    const codeLengthTree = new HuffmanTree(codeLengthLengths);
+    const lengths = readCodeLengths(reader, codeLengthTree, literalLengthCount + distanceCount);
+    const literalLengthLengths = lengths.slice(0, literalLengthCount);
+    const distanceLengths = lengths.slice(literalLengthCount);
+    if (literalLengthLengths[256] === 0) {
+        throw new Error("deflate: missing end-of-block code");
+    }
+    return {
+        literalLengthTree: new HuffmanTree(literalLengthLengths),
+        distanceTree: new HuffmanTree(distanceLengths, { allowEmpty: true }),
+    };
+}
+function readCodeLengths(reader, codeLengthTree, count) {
+    const lengths = [];
+    while (lengths.length < count) {
+        const symbol = codeLengthTree.decode(reader);
+        if (symbol <= 15) {
+            lengths.push(symbol);
+            continue;
+        }
+        let repeatLength;
+        let repeatedValue;
+        switch (symbol) {
+            case 16:
+                if (lengths.length === 0) {
+                    throw new Error("deflate: invalid code length repeat");
+                }
+                repeatedValue = lengths[lengths.length - 1];
+                repeatLength = reader.readBits(2) + 3;
+                break;
+            case 17:
+                repeatedValue = 0;
+                repeatLength = reader.readBits(3) + 3;
+                break;
+            case 18:
+                repeatedValue = 0;
+                repeatLength = reader.readBits(7) + 11;
+                break;
+            default:
+                throw new Error("deflate: invalid code length symbol");
+        }
+        if (lengths.length + repeatLength > count) {
+            throw new Error("deflate: invalid code length repeat");
+        }
+        for (let i = 0; i < repeatLength; i++) {
+            lengths.push(repeatedValue);
+        }
+    }
+    return lengths;
+}
+//# sourceMappingURL=zlibInflate.js.map