@threenative/raw-unreal 0.1.1

package/dist/index.js

@@ -0,0 +1,2329 @@
+import { BufferGeometry, BufferAttribute, Mesh, Loader, FileLoader, MeshStandardMaterial } from 'three';
+
+// src/errors.ts
+var UAssetError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "UAssetError";
+    this.code = code;
+    this.details = details;
+  }
+};
+function assertUAsset(condition, code, message, details = {}) {
+  if (!condition) throw new UAssetError(code, message, details);
+}
+
+// src/binary.ts
+var utf8 = new TextDecoder("utf-8");
+var utf16 = new TextDecoder("utf-16le");
+var BinaryReader = class {
+  bytes;
+  view;
+  pos = 0;
+  constructor(input, offset = 0, length = input.byteLength - offset) {
+    if (offset < 0 || length < 0 || offset + length > input.byteLength) {
+      throw new UAssetError("TRUNCATED_PACKAGE", "Invalid binary reader range", {
+        offset,
+        length,
+        byteLength: input.byteLength
+      });
+    }
+    this.bytes = input.subarray(offset, offset + length);
+    this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+  }
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  get remaining() {
+    return this.byteLength - this.pos;
+  }
+  ensure(size, context) {
+    if (!Number.isInteger(size) || size < 0 || this.pos + size > this.byteLength) {
+      throw new UAssetError("TRUNCATED_PACKAGE", `Unexpected end of ${context}`, {
+        offset: this.pos,
+        requested: size,
+        remaining: this.remaining
+      });
+    }
+  }
+  seek(offset) {
+    if (!Number.isInteger(offset) || offset < 0 || offset > this.byteLength) {
+      throw new UAssetError("TRUNCATED_PACKAGE", "Invalid binary seek", {
+        offset,
+        byteLength: this.byteLength
+      });
+    }
+    this.pos = offset;
+  }
+  skip(size, context) {
+    this.ensure(size, context);
+    this.pos += size;
+  }
+  uint8(context) {
+    this.ensure(1, context);
+    return this.view.getUint8(this.pos++);
+  }
+  int32(context) {
+    this.ensure(4, context);
+    const value = this.view.getInt32(this.pos, true);
+    this.pos += 4;
+    return value;
+  }
+  uint32(context) {
+    this.ensure(4, context);
+    const value = this.view.getUint32(this.pos, true);
+    this.pos += 4;
+    return value;
+  }
+  uint32BE(context) {
+    this.ensure(4, context);
+    const value = this.view.getUint32(this.pos, false);
+    this.pos += 4;
+    return value;
+  }
+  uint64BE(context) {
+    this.ensure(8, context);
+    const value = this.view.getBigUint64(this.pos, false);
+    this.pos += 8;
+    return value;
+  }
+  float32(context) {
+    this.ensure(4, context);
+    const value = this.view.getFloat32(this.pos, true);
+    this.pos += 4;
+    return value;
+  }
+  raw(size, context) {
+    this.ensure(size, context);
+    const value = this.bytes.subarray(this.pos, this.pos + size);
+    this.pos += size;
+    return value;
+  }
+  /** An FString: positive length is UTF-8 bytes, negative is UTF-16 code units, zero is empty. */
+  fstring(context) {
+    const start = this.pos;
+    const length = this.int32(`${context} length`);
+    if (length === 0) return "";
+    if (Math.abs(length) > 16777216) {
+      throw new UAssetError("TRUNCATED_PACKAGE", `Unreasonable ${context} length`, {
+        offset: start,
+        length
+      });
+    }
+    if (length > 0) {
+      const data2 = this.raw(length, context);
+      const end = data2.length > 0 && data2[data2.length - 1] === 0 ? data2.length - 1 : data2.length;
+      return utf8.decode(data2.subarray(0, end));
+    }
+    const charCount = -length;
+    const data = this.raw(charCount * 2, context);
+    const hasNull = data.length >= 2 && data[data.length - 1] === 0 && data[data.length - 2] === 0;
+    return utf16.decode(data.subarray(0, hasNull ? data.length - 2 : data.length));
+  }
+};
+
+// src/package-summary.ts
+var PACKAGE_FILE_TAG = 2653586369;
+var EDITOR_OBJECT_VERSION_GUID_BYTES = Uint8Array.from([
+  237,
+  104,
+  176,
+  228,
+  // E4B068ED
+  233,
+  66,
+  148,
+  244,
+  // F49442E9
+  11,
+  218,
+  49,
+  162,
+  // A231DA0B
+  65,
+  187,
+  70,
+  46
+  // 2E46BB41
+]);
+var SUMMARY_SCAN_BYTES = 4096;
+function findEditorObjectVersion(bytes, from) {
+  const limit = Math.min(bytes.byteLength - 20, from + SUMMARY_SCAN_BYTES);
+  for (let position = from; position >= 0 && position < limit; position += 1) {
+    let matched = true;
+    for (let index = 0; index < 16; index += 1) {
+      if (bytes[position + index] !== EDITOR_OBJECT_VERSION_GUID_BYTES[index]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) {
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      return view.getInt32(position + 16, true);
+    }
+  }
+  return void 0;
+}
+function readPackageSummary(bytes) {
+  if (bytes.byteLength < 4) {
+    throw new UAssetError("TRUNCATED_PACKAGE", "Unreal package is too small", {
+      byteLength: bytes.byteLength
+    });
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const packageTag = view.getUint32(0, true);
+  if (packageTag !== PACKAGE_FILE_TAG) {
+    throw new UAssetError(
+      "INVALID_PACKAGE_TAG",
+      "Input is not a legacy Unreal package (.uasset/.umap)",
+      {
+        tag: `0x${packageTag.toString(16)}`
+      }
+    );
+  }
+  if (bytes.byteLength < 16) {
+    throw new UAssetError("TRUNCATED_PACKAGE", "Unreal package summary is truncated", {
+      byteLength: bytes.byteLength
+    });
+  }
+  const legacyFileVersion = view.getInt32(4, true);
+  const legacyUE3Version = view.getInt32(8, true);
+  const fileVersionUE4 = view.getInt32(12, true);
+  const fileVersionUE5 = legacyFileVersion <= -8 ? view.getInt32(16, true) : void 0;
+  const licenseeOffset = legacyFileVersion <= -8 ? 20 : 16;
+  const licenseeVersion = view.getInt32(licenseeOffset, true);
+  const afterLicensee = licenseeOffset + 4;
+  const editorObjectVersion = findEditorObjectVersion(bytes, afterLicensee);
+  return {
+    packageTag,
+    legacyFileVersion,
+    legacyUE3Version,
+    fileVersionUE4,
+    ...fileVersionUE5 === void 0 ? {} : { fileVersionUE5 },
+    ...licenseeVersion === void 0 ? {} : { licenseeVersion },
+    ...editorObjectVersion === void 0 ? {} : { editorObjectVersion }
+  };
+}
+var VER_WORLD_LEVEL_INFO = 224;
+var VER_CHUNKID_ARRAY = 326;
+var VER_ENGINE_VERSION_OBJECT = 336;
+var VER_STRING_ASSET_REFERENCES_MAP = 384;
+var VER_COMPATIBLE_ENGINE_VERSION = 444;
+var VER_SERIALIZE_TEXT_IN_PACKAGES = 459;
+var VER_PRELOAD_DEPENDENCIES = 507;
+var VER_ADDED_SEARCHABLE_NAMES = 510;
+var VER_PACKAGE_SUMMARY_LOCALIZATION_ID = 516;
+var VER_ADDED_PACKAGE_OWNER = 518;
+var VER_REMOVE_LINKER_PACKAGE_OWNER = 520;
+var UE5_NAMES_REFERENCED_FROM_EXPORT_DATA = 1001;
+var UE5_PAYLOAD_TOC = 1002;
+var UE5_ADD_SOFTOBJECTPATH_LIST = 1008;
+var UE5_DATA_RESOURCES = 1009;
+var OLDEST_MODELLED_LEGACY_VERSION = -8;
+function readEngineVersion(reader) {
+  reader.skip(2 + 2 + 2 + 4, "FEngineVersion");
+  reader.fstring("FEngineVersion branch");
+}
+function walkSummary(bytes, summary) {
+  const reader = new BinaryReader(bytes);
+  const { legacyFileVersion, fileVersionUE4 = 0, fileVersionUE5 } = summary;
+  reader.seek(legacyFileVersion <= -8 ? 24 : 20);
+  if (legacyFileVersion <= -2) {
+    const customVersionCount = reader.int32("custom-version count");
+    assertUAsset(
+      customVersionCount >= 0 && customVersionCount <= 512,
+      "INVALID_PACKAGE_SUMMARY",
+      "Invalid custom-version count",
+      { customVersionCount }
+    );
+    reader.skip(customVersionCount * 20, "custom-version list");
+  }
+  const totalHeaderSize = reader.int32("TotalHeaderSize");
+  reader.fstring("FolderName");
+  reader.skip(4, "PackageFlags");
+  const nameCount = reader.int32("NameCount");
+  const nameOffset = reader.int32("NameOffset");
+  if (fileVersionUE5 !== void 0 && fileVersionUE5 >= UE5_ADD_SOFTOBJECTPATH_LIST) {
+    reader.skip(8, "SoftObjectPaths");
+  }
+  if (fileVersionUE4 >= VER_PACKAGE_SUMMARY_LOCALIZATION_ID) reader.fstring("LocalizationId");
+  if (fileVersionUE4 >= VER_SERIALIZE_TEXT_IN_PACKAGES) reader.skip(8, "GatherableTextData");
+  const exportCount = reader.int32("ExportCount");
+  const exportOffset = reader.int32("ExportOffset");
+  reader.skip(8, "ImportCount and ImportOffset");
+  reader.skip(4, "DependsOffset");
+  if (fileVersionUE4 >= VER_STRING_ASSET_REFERENCES_MAP) reader.skip(8, "SoftPackageReferences");
+  if (fileVersionUE4 >= VER_ADDED_SEARCHABLE_NAMES) reader.skip(4, "SearchableNamesOffset");
+  reader.skip(4, "ThumbnailTableOffset");
+  reader.skip(16, "package Guid");
+  if (fileVersionUE4 >= VER_ADDED_PACKAGE_OWNER) {
+    reader.skip(16, "PersistentGuid");
+    if (fileVersionUE4 < VER_REMOVE_LINKER_PACKAGE_OWNER) reader.skip(16, "OwnerPersistentGuid");
+  }
+  const generationCount = reader.int32("GenerationCount");
+  assertUAsset(
+    generationCount >= 0 && generationCount <= 4096,
+    "INVALID_PACKAGE_SUMMARY",
+    "Invalid generation count",
+    { generationCount }
+  );
+  reader.skip(generationCount * 8, "generation list");
+  if (fileVersionUE4 >= VER_ENGINE_VERSION_OBJECT) readEngineVersion(reader);
+  else reader.skip(4, "EngineChangelist");
+  if (fileVersionUE4 >= VER_COMPATIBLE_ENGINE_VERSION) readEngineVersion(reader);
+  reader.skip(4, "CompressionFlags");
+  const compressedChunkCount = reader.int32("CompressedChunkCount");
+  assertUAsset(
+    compressedChunkCount >= 0 && compressedChunkCount <= 65536,
+    "INVALID_PACKAGE_SUMMARY",
+    "Invalid compressed-chunk count",
+    { compressedChunkCount }
+  );
+  reader.skip(compressedChunkCount * 16, "compressed-chunk list");
+  reader.skip(4, "PackageSource");
+  const additionalPackagesToCook = reader.int32("AdditionalPackagesToCook count");
+  assertUAsset(
+    additionalPackagesToCook >= 0 && additionalPackagesToCook <= 65536,
+    "INVALID_PACKAGE_SUMMARY",
+    "Invalid additional-packages-to-cook count",
+    { additionalPackagesToCook }
+  );
+  for (let index = 0; index < additionalPackagesToCook; index += 1) {
+    reader.fstring("AdditionalPackagesToCook entry");
+  }
+  if (legacyFileVersion > -7) reader.skip(4, "NumTextureAllocations");
+  reader.skip(4, "AssetRegistryDataOffset");
+  const bulkDataStartOffset = Number(
+    new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getBigInt64(reader.pos, true)
+  );
+  reader.skip(8, "BulkDataStartOffset");
+  if (fileVersionUE4 >= VER_WORLD_LEVEL_INFO) reader.skip(4, "WorldTileInfoDataOffset");
+  if (fileVersionUE4 >= VER_CHUNKID_ARRAY) {
+    const chunkIdCount = reader.int32("ChunkID count");
+    assertUAsset(
+      chunkIdCount >= 0 && chunkIdCount <= 65536,
+      "INVALID_PACKAGE_SUMMARY",
+      "Invalid chunk-id count",
+      { chunkIdCount }
+    );
+    reader.skip(chunkIdCount * 4, "ChunkID list");
+  }
+  if (fileVersionUE4 >= VER_PRELOAD_DEPENDENCIES) reader.skip(8, "PreloadDependencies");
+  if (fileVersionUE5 !== void 0) {
+    if (fileVersionUE5 >= UE5_NAMES_REFERENCED_FROM_EXPORT_DATA) {
+      reader.skip(4, "NamesReferencedFromExportDataCount");
+    }
+    if (fileVersionUE5 >= UE5_PAYLOAD_TOC) reader.skip(8, "PayloadTocOffset");
+    if (fileVersionUE5 >= UE5_DATA_RESOURCES) reader.skip(4, "DataResourceOffset");
+  }
+  assertUAsset(
+    reader.pos === nameOffset,
+    "INVALID_PACKAGE_SUMMARY",
+    "Package summary does not end where its name table begins",
+    { summaryEnd: reader.pos, nameOffset, fileVersionUE4, fileVersionUE5, legacyFileVersion }
+  );
+  assertUAsset(
+    totalHeaderSize > 0 && totalHeaderSize <= bytes.byteLength && bulkDataStartOffset >= totalHeaderSize && bulkDataStartOffset <= bytes.byteLength,
+    "INVALID_PACKAGE_SUMMARY",
+    "Package header and bulk-data offsets do not bracket the package",
+    { totalHeaderSize, bulkDataStartOffset, byteLength: bytes.byteLength }
+  );
+  return {
+    ...summary,
+    totalHeaderSize,
+    bulkDataStartOffset,
+    nameCount,
+    nameOffset,
+    exportCount,
+    exportOffset
+  };
+}
+function readPackageLayout(bytes) {
+  let summary;
+  try {
+    summary = readPackageSummary(bytes);
+  } catch {
+    return void 0;
+  }
+  if (summary.legacyFileVersion < OLDEST_MODELLED_LEGACY_VERSION) return void 0;
+  try {
+    return walkSummary(bytes, summary);
+  } catch (error) {
+    if (error instanceof UAssetError) return void 0;
+    throw error;
+  }
+}
+
+// src/bulk-data.ts
+var BULK_DATA_FLAG = Object.freeze({
+  PAYLOAD_AT_END_OF_FILE: 1,
+  SERIALIZE_COMPRESSED_ZLIB: 2,
+  FORCE_INLINE_PAYLOAD: 64,
+  PAYLOAD_IN_SEPARATE_FILE: 256,
+  OPTIONAL_PAYLOAD: 2048,
+  MEMORY_MAPPED_PAYLOAD: 4096,
+  SIZE_64_BIT: 8192,
+  NO_OFFSET_FIX_UP: 65536
+});
+var MIN_PAYLOAD_BYTES = 16;
+var MAX_COMPRESSION_CHUNK_BYTES = 64 * 1024 * 1024;
+function bulkError(message, details) {
+  return new UAssetError("INVALID_BULK_DATA", message, details);
+}
+function storageOf(flags) {
+  const named = [
+    BULK_DATA_FLAG.PAYLOAD_IN_SEPARATE_FILE,
+    BULK_DATA_FLAG.FORCE_INLINE_PAYLOAD,
+    BULK_DATA_FLAG.PAYLOAD_AT_END_OF_FILE
+  ].filter((bit) => (flags & bit) !== 0);
+  if (named.length !== 1) return void 0;
+  if (named[0] === BULK_DATA_FLAG.PAYLOAD_IN_SEPARATE_FILE) return "separate-file";
+  if (named[0] === BULK_DATA_FLAG.FORCE_INLINE_PAYLOAD) return "inline";
+  return "end-of-file";
+}
+function fileOf(flags, storage) {
+  if (storage !== "separate-file") return "uasset";
+  return (flags & BULK_DATA_FLAG.OPTIONAL_PAYLOAD) !== 0 ? "uptnl" : "ubulk";
+}
+function parseBulkDataHeader(bytes, offset, layout) {
+  const reader = new BinaryReader(bytes, offset);
+  const flags = reader.uint32("BulkDataFlags");
+  if ((flags & -131072) !== 0) {
+    throw bulkError("BulkDataFlags carries bits Unreal does not define", { offset, flags });
+  }
+  const storage = storageOf(flags);
+  if (storage === void 0) {
+    throw bulkError("BulkDataFlags names no payload storage", { offset, flags });
+  }
+  const wide = (flags & BULK_DATA_FLAG.SIZE_64_BIT) !== 0;
+  const elementCount = wide ? readInt64(reader, "ElementCount") : reader.int32("ElementCount");
+  const sizeOnDisk = wide ? readInt64(reader, "BulkDataSizeOnDisk") : reader.int32("BulkDataSizeOnDisk");
+  const offsetInFile = readInt64(reader, "BulkDataOffsetInFile");
+  const headerEnd = offset + reader.pos;
+  if (elementCount <= 0 || sizeOnDisk < MIN_PAYLOAD_BYTES || offsetInFile < 0) {
+    throw bulkError("Bulk-data header describes no readable payload", {
+      offset,
+      flags,
+      elementCount,
+      sizeOnDisk,
+      offsetInFile
+    });
+  }
+  const compression = (flags & BULK_DATA_FLAG.SERIALIZE_COMPRESSED_ZLIB) !== 0 ? "zlib" : "none";
+  if (compression === "none" && elementCount !== sizeOnDisk) {
+    throw bulkError("Uncompressed bulk data does not occupy one byte per element", {
+      offset,
+      flags,
+      elementCount,
+      sizeOnDisk
+    });
+  }
+  const fixUp = storage === "end-of-file" && (flags & BULK_DATA_FLAG.NO_OFFSET_FIX_UP) === 0 ? layout.bulkDataStartOffset : 0;
+  const payloadOffset = storage === "inline" ? headerEnd : offsetInFile + fixUp;
+  return {
+    headerOffset: offset,
+    headerEnd,
+    flags,
+    storage,
+    file: fileOf(flags, storage),
+    compression,
+    elementCount,
+    sizeOnDisk,
+    offsetInFile,
+    payloadOffset
+  };
+}
+function readInt64(reader, context) {
+  reader.ensure(8, context);
+  const value = reader.view.getBigInt64(reader.pos, true);
+  reader.pos += 8;
+  if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) {
+    throw bulkError(`${context} exceeds the safe integer range`, { value: value.toString() });
+  }
+  return Number(value);
+}
+function findBulkDataHeaders(bytes, layout, files = {}) {
+  const headers = [];
+  const scanEnd = Math.min(layout.bulkDataStartOffset, bytes.byteLength);
+  for (let offset = layout.totalHeaderSize; offset + 20 <= scanEnd; offset += 1) {
+    let header;
+    try {
+      header = parseBulkDataHeader(bytes, offset, layout);
+    } catch (error) {
+      if (!(error instanceof UAssetError)) throw error;
+      continue;
+    }
+    if (!payloadFits(header, bytes, files, layout)) continue;
+    headers.push(header);
+  }
+  return headers;
+}
+function payloadFits(header, bytes, files, layout) {
+  if (header.storage === "separate-file") {
+    const sibling = siblingBytes(files, header.file);
+    if (sibling === void 0) return false;
+    return header.payloadOffset + header.sizeOnDisk <= sibling.byteLength;
+  }
+  if (header.storage === "inline") {
+    return header.payloadOffset + header.sizeOnDisk <= layout.bulkDataStartOffset;
+  }
+  return header.payloadOffset >= layout.bulkDataStartOffset && header.payloadOffset + header.sizeOnDisk <= bytes.byteLength;
+}
+function siblingBytes(files, file) {
+  const input = file === "uasset" ? void 0 : files[file];
+  if (input === void 0) return void 0;
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+}
+function decompressBulkData(container, codecs) {
+  const reader = new BinaryReader(container);
+  const tag = readInt64(reader, "compressed-chunk tag");
+  assertUAsset(
+    tag === PACKAGE_FILE_TAG,
+    "INVALID_BULK_DATA",
+    "Compressed bulk data does not start with the package tag",
+    { tag: `0x${tag.toString(16)}` }
+  );
+  const chunkSize = readInt64(reader, "loading compression chunk size");
+  const totalCompressed = readInt64(reader, "total compressed size");
+  const totalRaw = readInt64(reader, "total uncompressed size");
+  assertUAsset(
+    chunkSize > 0 && chunkSize <= MAX_COMPRESSION_CHUNK_BYTES && totalCompressed > 0 && totalRaw > 0,
+    "INVALID_BULK_DATA",
+    "Compressed bulk-data totals are not readable sizes",
+    { chunkSize, totalCompressed, totalRaw }
+  );
+  const chunkCount = Math.ceil(totalRaw / chunkSize);
+  const chunks = [];
+  let compressedSum = 0;
+  let rawSum = 0;
+  for (let index = 0; index < chunkCount; index += 1) {
+    const compressed = readInt64(reader, `chunk ${index} compressed size`);
+    const raw = readInt64(reader, `chunk ${index} uncompressed size`);
+    assertUAsset(
+      compressed > 0 && raw > 0 && raw <= chunkSize,
+      "INVALID_BULK_DATA",
+      `Compressed bulk-data chunk ${index} has an unreadable size`,
+      { index, compressed, raw, chunkSize }
+    );
+    compressedSum += compressed;
+    rawSum += raw;
+    chunks.push({ compressed, raw });
+  }
+  assertUAsset(
+    compressedSum === totalCompressed && rawSum === totalRaw,
+    "INVALID_BULK_DATA",
+    "Compressed bulk-data chunk sizes disagree with the container totals",
+    { compressedSum, totalCompressed, rawSum, totalRaw }
+  );
+  if (codecs.zlib === void 0) {
+    throw new UAssetError(
+      "MISSING_CODEC",
+      "This bulk-data payload is zlib-compressed and no `zlib` codec was supplied",
+      { compression: "zlib", totalCompressed, totalRaw }
+    );
+  }
+  const out = new Uint8Array(totalRaw);
+  let written = 0;
+  for (const [index, chunk] of chunks.entries()) {
+    const block = reader.raw(chunk.compressed, `chunk ${index} data`);
+    const inflated = codecs.zlib(block, chunk.raw);
+    assertUAsset(
+      inflated.byteLength === chunk.raw,
+      "CODEC_SIZE_MISMATCH",
+      `zlib codec returned ${inflated.byteLength} bytes for chunk ${index}, expected ${chunk.raw}`,
+      { index, expected: chunk.raw, actual: inflated.byteLength }
+    );
+    out.set(inflated, written);
+    written += inflated.byteLength;
+  }
+  assertUAsset(
+    written === totalRaw,
+    "INCOMPLETE_DECOMPRESSION",
+    "Compressed bulk data did not decompress to its declared size",
+    { written, totalRaw }
+  );
+  return out;
+}
+function resolveBulkDataPayload(bytes, header, options = {}) {
+  const files = options.files ?? {};
+  let source = bytes;
+  if (header.storage === "separate-file") {
+    const sibling = siblingBytes(files, header.file);
+    if (sibling === void 0) {
+      throw new UAssetError(
+        "MISSING_BULK_DATA_FILE",
+        `This package's bulk payload was written to its sibling .${header.file} file, whose bytes were not supplied`,
+        {
+          file: header.file,
+          flags: header.flags,
+          sizeOnDisk: header.sizeOnDisk,
+          offsetInFile: header.offsetInFile
+        }
+      );
+    }
+    source = sibling;
+  }
+  const end = header.payloadOffset + header.sizeOnDisk;
+  assertUAsset(
+    header.payloadOffset >= 0 && end <= source.byteLength,
+    "INVALID_BULK_DATA",
+    "Bulk-data payload runs past the file it was read from",
+    {
+      file: header.file,
+      payloadOffset: header.payloadOffset,
+      sizeOnDisk: header.sizeOnDisk,
+      byteLength: source.byteLength
+    }
+  );
+  const stored = source.subarray(header.payloadOffset, end);
+  if (header.compression === "none") return stored;
+  return decompressBulkData(stored, { zlib: options.zlib });
+}
+
+// src/geometry.ts
+function convertVector(x, y, z, convertCoordinates) {
+  return convertCoordinates ? [x, z, -y] : [x, y, z];
+}
+function computeBounds(positions) {
+  const min = [
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY
+  ];
+  const max = [
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY
+  ];
+  for (let index = 0; index + 2 < positions.length; index += 3) {
+    for (let component = 0; component < 3; component += 1) {
+      const value = positions[index + component];
+      if (value === void 0) {
+        throw new UAssetError(
+          "INVALID_MESH_REFERENCE",
+          "Position data ended before its declared count",
+          { index }
+        );
+      }
+      min[component] = Math.min(min[component] ?? value, value);
+      max[component] = Math.max(max[component] ?? value, value);
+    }
+  }
+  return { min, max };
+}
+function assembleGeometry(positions, normals, uvs, trianglesByGroup, materialNameFor, sourceStats) {
+  const indexCount = [...trianglesByGroup.values()].reduce((sum, group) => sum + group.length, 0);
+  const indices = positions.length / 3 > 65535 ? new Uint32Array(indexCount) : new Uint16Array(indexCount);
+  const sections = [];
+  let cursor = 0;
+  for (const [group, groupIndices] of trianglesByGroup) {
+    indices.set(groupIndices, cursor);
+    sections.push({
+      materialIndex: sections.length,
+      sectionIndex: group,
+      materialName: materialNameFor(group),
+      start: cursor,
+      count: groupIndices.length
+    });
+    cursor += groupIndices.length;
+  }
+  return { positions, normals, uvs, indices, sections, sourceStats };
+}
+
+// src/mesh-attributes-ue4.ts
+var MAX_MESH_ELEMENTS = 1e7;
+var MAX_ATTRIBUTE_VALUES = 1e8;
+function readInt32Array(reader, count, what) {
+  const values = new Int32Array(count);
+  for (let index = 0; index < count; index += 1) values[index] = reader.int32(what);
+  return values;
+}
+function meshError(message, details) {
+  return new UAssetError("INVALID_MESH_DESCRIPTION", message, details);
+}
+var ATTRIBUTE_TYPES = Object.freeze([
+  { name: "FVector4f", components: 4, byteSize: 16, kind: "float" },
+  { name: "FVector3f", components: 3, byteSize: 12, kind: "float" },
+  { name: "FVector2f", components: 2, byteSize: 8, kind: "float" },
+  { name: "float", components: 1, byteSize: 4, kind: "float" },
+  { name: "int32", components: 1, byteSize: 4, kind: "int" },
+  { name: "bool", components: 1, byteSize: 1, kind: "bool" },
+  { name: "FName", components: 1, byteSize: void 0, kind: "name" }
+]);
+function readAttributeEntry(reader, rawName) {
+  const name = rawName.trimEnd();
+  const typeIndex = reader.uint32(`${name} type`);
+  const type = ATTRIBUTE_TYPES[typeIndex];
+  assertUAsset(type !== void 0, "INVALID_MESH_DESCRIPTION", "Unknown attribute type", {
+    attribute: name,
+    typeIndex
+  });
+  const numElements = reader.int32(`${name} element count`);
+  const numChannels = reader.int32(`${name} channel count`);
+  if (numElements < 0 || numElements > MAX_MESH_ELEMENTS || numChannels < 0 || numChannels > 128) {
+    throw meshError(`Invalid attribute shape for ${name}`, { name, numElements, numChannels });
+  }
+  let values = new Float32Array(0);
+  for (let channel = 0; channel < numChannels; channel += 1) {
+    const channelValues2 = readAttributeChannel(reader, type, name, numElements);
+    if (channel === 0) values = channelValues2;
+  }
+  readDefaultValue(reader, type);
+  reader.uint32(`${name} flags`);
+  return { name, type: type.name, components: type.components, numElements, values };
+}
+function readAttributeChannel(reader, type, name, numElements) {
+  if (type.kind === "name") {
+    const count2 = reader.int32(`${name} FName count`);
+    if (count2 < 0 || count2 > MAX_ATTRIBUTE_VALUES) {
+      throw meshError(`Invalid FName count for ${name}`, { name, count: count2 });
+    }
+    assertUAsset(
+      count2 === numElements,
+      "INVALID_MESH_DESCRIPTION",
+      `Serialized value count mismatch for ${name}`,
+      { name, expected: numElements, actual: count2 }
+    );
+    const names = new Array(count2);
+    for (let index = 0; index < count2; index += 1)
+      names[index] = reader.fstring(`${name}[${index}]`);
+    return names;
+  }
+  const elementSize = reader.int32(`${name} bulk element size`);
+  const count = reader.int32(`${name} bulk element count`);
+  assertUAsset(
+    type.byteSize !== void 0 && elementSize === type.byteSize,
+    "INVALID_MESH_DESCRIPTION",
+    `${name} has an unexpected element size`,
+    { name, expected: type.byteSize, actual: elementSize }
+  );
+  assertUAsset(
+    count === numElements,
+    "INVALID_MESH_DESCRIPTION",
+    `Serialized value count mismatch for ${name}`,
+    { name, expected: numElements, actual: count }
+  );
+  const requiredBytes = count * elementSize;
+  assertUAsset(
+    Number.isSafeInteger(requiredBytes) && requiredBytes <= reader.remaining,
+    "INVALID_MESH_DESCRIPTION",
+    `${name} exceeds the remaining MeshDescription payload`,
+    { name, requiredBytes, remaining: reader.remaining }
+  );
+  if (type.kind === "float") {
+    const values2 = new Float32Array(count * type.components);
+    for (let index = 0; index < values2.length; index += 1) values2[index] = reader.float32(name);
+    return values2;
+  }
+  if (type.kind === "int") return readInt32Array(reader, count, name);
+  const values = new Uint8Array(count);
+  values.set(reader.raw(count, name));
+  return values;
+}
+function readDefaultValue(reader, type) {
+  switch (type.kind) {
+    case "float":
+      for (let index = 0; index < type.components; index += 1) reader.float32(type.name);
+      return;
+    case "int":
+    case "bool":
+      reader.int32(type.name);
+      return;
+    case "name":
+      reader.fstring(type.name);
+      return;
+  }
+}
+function readAttributeSet(reader, what, expectedElements) {
+  const numElements = reader.int32(`${what} attribute-set element count`);
+  const attributeCount = reader.int32(`${what} attribute count`);
+  if (numElements < 0 || numElements > MAX_MESH_ELEMENTS || attributeCount < 0 || attributeCount > 1024) {
+    throw meshError(`Invalid ${what} attribute set`, { what, numElements, attributeCount });
+  }
+  assertUAsset(
+    numElements === expectedElements,
+    "INVALID_MESH_DESCRIPTION",
+    `${what} attribute set disagrees with its element container`,
+    { what, numElements, expectedElements }
+  );
+  const attributes = /* @__PURE__ */ new Map();
+  for (let index = 0; index < attributeCount; index += 1) {
+    const rawName = reader.fstring(`${what} attribute name ${index}`);
+    const entry = readAttributeEntry(reader, rawName);
+    assertUAsset(
+      entry.numElements === numElements,
+      "INVALID_MESH_DESCRIPTION",
+      `${what} attribute "${entry.name}" disagrees with its set`,
+      { what, attribute: entry.name, numElements: entry.numElements, expected: numElements }
+    );
+    attributes.set(entry.name, entry);
+  }
+  return attributes;
+}
+
+// src/mesh-description-ue4.ts
+var MAX_MESH_ELEMENTS2 = 1e7;
+function meshError2(message, details) {
+  return new UAssetError("INVALID_MESH_DESCRIPTION", message, details);
+}
+function readBitArray(reader, what) {
+  const offset = reader.pos;
+  const numBits = reader.int32(`${what} TBitArray NumBits`);
+  if (numBits < 0 || numBits > MAX_MESH_ELEMENTS2) {
+    throw meshError2(`Invalid ${what} allocation length`, { offset, numBits });
+  }
+  const wordCount = Math.ceil(numBits / 32);
+  const words = new Uint32Array(wordCount);
+  for (let index = 0; index < wordCount; index += 1) {
+    words[index] = reader.uint32(`${what} TBitArray word`);
+  }
+  const validIds = [];
+  for (let id = 0; id < numBits; id += 1) {
+    const word = words[id >>> 5];
+    if (word !== void 0 && (word & 1 << (id & 31)) !== 0) validIds.push(id);
+  }
+  return { numBits, validIds };
+}
+function parseMeshDescriptionUe4(input, offset = 0) {
+  const reader = new BinaryReader(input, offset);
+  const vertices = readBitArray(reader, "VertexArray");
+  const vertexInstances = readBitArray(reader, "VertexInstanceArray");
+  const vertexInstanceVertices = new Int32Array(vertexInstances.numBits).fill(-1);
+  for (const instanceId of vertexInstances.validIds) {
+    vertexInstanceVertices[instanceId] = reader.int32("FMeshVertexInstance.VertexID");
+  }
+  const edges = readBitArray(reader, "EdgeArray");
+  reader.skip(edges.validIds.length * 8, "FMeshEdge.VertexIDs");
+  const polygons = readBitArray(reader, "PolygonArray");
+  const polygonGroups = new Int32Array(polygons.numBits).fill(-1);
+  for (const polygonId of polygons.validIds) {
+    const triangleCount = reader.int32("FMeshPolygon.TriangleIDs count");
+    if (triangleCount < 0 || triangleCount > MAX_MESH_ELEMENTS2) {
+      throw meshError2("Invalid polygon triangulation count", { polygonId, triangleCount });
+    }
+    reader.skip(triangleCount * 4, "FMeshPolygon.TriangleIDs");
+    polygonGroups[polygonId] = reader.int32("FMeshPolygon.PolygonGroupID");
+  }
+  const polygonGroupArray = readBitArray(reader, "PolygonGroupArray");
+  const vertexAttributes = readAttributeSet(reader, "Vertex", vertices.numBits);
+  const vertexInstanceAttributes = readAttributeSet(
+    reader,
+    "VertexInstance",
+    vertexInstances.numBits
+  );
+  readAttributeSet(reader, "Edge", edges.numBits);
+  readAttributeSet(reader, "Polygon", polygons.numBits);
+  const polygonGroupAttributes = readAttributeSet(
+    reader,
+    "PolygonGroup",
+    polygonGroupArray.numBits
+  );
+  const triangles = readBitArray(reader, "TriangleArray");
+  const triangleVertexInstances = new Int32Array(triangles.numBits * 3).fill(-1);
+  const trianglePolygons = new Int32Array(triangles.numBits).fill(-1);
+  for (const triangleId of triangles.validIds) {
+    for (let corner = 0; corner < 3; corner += 1) {
+      triangleVertexInstances[triangleId * 3 + corner] = reader.int32(
+        "FMeshTriangle.VertexInstanceIDs"
+      );
+    }
+    trianglePolygons[triangleId] = reader.int32("FMeshTriangle.PolygonID");
+  }
+  readAttributeSet(reader, "Triangle", triangles.numBits);
+  validateReferences({
+    vertices,
+    vertexInstances,
+    polygons,
+    polygonGroupCount: polygonGroupArray.numBits,
+    triangles,
+    vertexInstanceVertices,
+    polygonGroups,
+    triangleVertexInstances,
+    trianglePolygons
+  });
+  assertUAsset(
+    reader.remaining === 0,
+    "INVALID_MESH_DESCRIPTION",
+    "UE4 MeshDescription walk did not consume its payload exactly",
+    { consumed: reader.pos, byteLength: reader.byteLength, trailing: reader.remaining }
+  );
+  return {
+    byteLength: reader.pos,
+    vertexCount: vertices.validIds.length,
+    vertexSlots: vertices.numBits,
+    validVertexIds: vertices.validIds,
+    validVertexInstanceIds: vertexInstances.validIds,
+    vertexInstanceVertices,
+    polygonGroups,
+    polygonGroupCount: polygonGroupArray.numBits,
+    validTriangleIds: triangles.validIds,
+    triangleVertexInstances,
+    trianglePolygons,
+    vertexAttributes,
+    vertexInstanceAttributes,
+    polygonGroupAttributes
+  };
+}
+function validateReferences(inputs) {
+  assertUAsset(
+    inputs.vertices.validIds.length > 0 && inputs.vertexInstances.validIds.length > 0 && inputs.triangles.validIds.length > 0,
+    "INVALID_MESH_DESCRIPTION",
+    "UE4 MeshDescription contains no renderable geometry",
+    {
+      vertices: inputs.vertices.validIds.length,
+      vertexInstances: inputs.vertexInstances.validIds.length,
+      triangles: inputs.triangles.validIds.length
+    }
+  );
+  const allocatedVertices = new Set(inputs.vertices.validIds);
+  const allocatedInstances = new Set(inputs.vertexInstances.validIds);
+  const allocatedPolygons = new Set(inputs.polygons.validIds);
+  for (const instanceId of inputs.vertexInstances.validIds) {
+    const vertexId = inputs.vertexInstanceVertices[instanceId];
+    if (vertexId === void 0 || !allocatedVertices.has(vertexId)) {
+      throw meshError2("Vertex instance references a vertex the file did not allocate", {
+        instanceId,
+        vertexId
+      });
+    }
+  }
+  for (const polygonId of inputs.polygons.validIds) {
+    const groupId = inputs.polygonGroups[polygonId];
+    if (groupId === void 0 || groupId < 0 || groupId >= inputs.polygonGroupCount) {
+      throw meshError2("Polygon references an invalid polygon group", {
+        polygonId,
+        groupId,
+        polygonGroupCount: inputs.polygonGroupCount
+      });
+    }
+  }
+  for (const triangleId of inputs.triangles.validIds) {
+    for (let corner = 0; corner < 3; corner += 1) {
+      const instanceId = inputs.triangleVertexInstances[triangleId * 3 + corner];
+      if (instanceId === void 0 || !allocatedInstances.has(instanceId)) {
+        throw meshError2("Triangle references a vertex instance the file did not allocate", {
+          triangleId,
+          corner,
+          instanceId
+        });
+      }
+    }
+    const polygonId = inputs.trianglePolygons[triangleId];
+    if (polygonId === void 0 || !allocatedPolygons.has(polygonId)) {
+      throw meshError2("Triangle references a polygon the file did not allocate", {
+        triangleId,
+        polygonId
+      });
+    }
+  }
+}
+function looksLikeMeshDescriptionUe4(bytes, offset = 0) {
+  if (offset < 0 || offset + 12 > bytes.byteLength) return false;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const vertexBits = view.getInt32(offset, true);
+  if (vertexBits <= 0 || vertexBits > MAX_MESH_ELEMENTS2) return false;
+  const instanceOffset = offset + 4 + Math.ceil(vertexBits / 32) * 4;
+  if (instanceOffset + 4 > bytes.byteLength) return false;
+  const instanceBits = view.getInt32(instanceOffset, true);
+  return instanceBits >= vertexBits && instanceBits <= MAX_MESH_ELEMENTS2;
+}
+
+// src/raw-mesh-geometry.ts
+function rawFloat(values, index, what) {
+  const value = values[index];
+  if (typeof value !== "number") {
+    throw new UAssetError("INVALID_RAW_MESH", `${what} ended before its declared element count`, {
+      index
+    });
+  }
+  return value;
+}
+function rawWedge(values, index) {
+  const value = values[index];
+  if (typeof value !== "number") {
+    throw new UAssetError(
+      "INVALID_RAW_MESH",
+      "FRawMesh wedge table ended before its declared count",
+      { index }
+    );
+  }
+  return value;
+}
+function rawInt(values, index, what) {
+  const value = values[index];
+  if (typeof value !== "number") {
+    throw new UAssetError("INVALID_RAW_MESH", `${what} ended before its declared element count`, {
+      index
+    });
+  }
+  return value;
+}
+function buildGeometryFromRawMesh(mesh, options) {
+  const {
+    vertexCount,
+    vertexPositions,
+    wedgeIndices,
+    wedgeNormals,
+    wedgeUvs,
+    faceMaterialIndices
+  } = mesh;
+  const wedgeCount = wedgeIndices.length;
+  const uvSet = wedgeUvs[0];
+  assertUAsset(uvSet !== void 0, "INVALID_RAW_MESH", "FRawMesh has no texture coordinates");
+  const positions = new Float32Array(wedgeCount * 3);
+  const normals = wedgeNormals ? new Float32Array(wedgeCount * 3) : void 0;
+  const uvs = new Float32Array(wedgeCount * 2);
+  for (let wedge = 0; wedge < wedgeCount; wedge += 1) {
+    const vertexId = rawWedge(wedgeIndices, wedge);
+    const [x, y, z] = convertVector(
+      rawFloat(vertexPositions, vertexId * 3, "VertexPositions"),
+      rawFloat(vertexPositions, vertexId * 3 + 1, "VertexPositions"),
+      rawFloat(vertexPositions, vertexId * 3 + 2, "VertexPositions"),
+      options.convertCoordinates
+    );
+    positions[wedge * 3] = x;
+    positions[wedge * 3 + 1] = y;
+    positions[wedge * 3 + 2] = z;
+    if (normals && wedgeNormals) {
+      const [nx, ny, nz] = convertVector(
+        rawFloat(wedgeNormals, wedge * 3, "WedgeTangentZ"),
+        rawFloat(wedgeNormals, wedge * 3 + 1, "WedgeTangentZ"),
+        rawFloat(wedgeNormals, wedge * 3 + 2, "WedgeTangentZ"),
+        options.convertCoordinates
+      );
+      normals[wedge * 3] = nx;
+      normals[wedge * 3 + 1] = ny;
+      normals[wedge * 3 + 2] = nz;
+    }
+    uvs[wedge * 2] = rawFloat(uvSet, wedge * 2, "WedgeTexCoords");
+    const v = rawFloat(uvSet, wedge * 2 + 1, "WedgeTexCoords");
+    uvs[wedge * 2 + 1] = options.flipV ? 1 - v : v;
+  }
+  const trianglesByGroup = /* @__PURE__ */ new Map();
+  for (let face = 0; face < faceMaterialIndices.length; face += 1) {
+    const base = face * 3;
+    const a = base;
+    const b = options.flipWinding ? base + 2 : base + 1;
+    const c = options.flipWinding ? base + 1 : base + 2;
+    const materialIndex = rawInt(faceMaterialIndices, face, "FaceMaterialIndices");
+    const group = materialIndex >= 0 ? materialIndex : 0;
+    const groupTriangles = trianglesByGroup.get(group) ?? [];
+    groupTriangles.push(a, b, c);
+    trianglesByGroup.set(group, groupTriangles);
+  }
+  return assembleGeometry(positions, normals, uvs, trianglesByGroup, (group) => String(group), {
+    vertices: vertexCount,
+    vertexInstances: wedgeCount,
+    triangles: faceMaterialIndices.length
+  });
+}
+
+// src/raw-mesh.ts
+var RAW_MESH_VER_INITIAL = 0;
+var RAW_MESH_VER_REMOVE_ZERO_TRIANGLE_SECTIONS = 1;
+var MAX_MESH_TEXTURE_COORDS = 8;
+var MAX_ARRAY_ELEMENTS = 2e8;
+function parseRawMesh(bytes, offset = 0) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let pos = offset;
+  function array(elementSize, label) {
+    if (pos + 4 > bytes.byteLength) {
+      throw rawMeshError(`${label} count is truncated`, { offset, position: pos });
+    }
+    const count = view.getInt32(pos, true);
+    pos += 4;
+    if (count < 0 || count > MAX_ARRAY_ELEMENTS) {
+      throw rawMeshError(`${label} has an invalid element count`, { offset, count });
+    }
+    const start = pos;
+    const end = pos + count * elementSize;
+    if (end > bytes.byteLength) {
+      throw rawMeshError(`${label} runs past the payload`, {
+        offset,
+        count,
+        end,
+        byteLength: bytes.byteLength
+      });
+    }
+    pos = end;
+    return { count, start };
+  }
+  const version = view.getInt32(pos, true);
+  pos += 4;
+  if (version !== RAW_MESH_VER_INITIAL && version !== RAW_MESH_VER_REMOVE_ZERO_TRIANGLE_SECTIONS) {
+    throw rawMeshError("Unsupported FRawMesh version", { offset, version });
+  }
+  const licenseeVersion = view.getInt32(pos, true);
+  pos += 4;
+  if (licenseeVersion !== 0) {
+    throw rawMeshError("FRawMesh licensee version is not the stock layout", {
+      offset,
+      licenseeVersion
+    });
+  }
+  const faces = array(4, "FaceMaterialIndices");
+  const smoothing = array(4, "FaceSmoothingMasks");
+  const vertices = array(12, "VertexPositions");
+  const wedges = array(4, "WedgeIndices");
+  array(12, "WedgeTangentX");
+  array(12, "WedgeTangentY");
+  const normals = array(12, "WedgeTangentZ");
+  const uvChannels = [];
+  for (let channel = 0; channel < MAX_MESH_TEXTURE_COORDS; channel += 1) {
+    uvChannels.push(array(8, `WedgeTexCoords[${channel}]`));
+  }
+  array(4, "WedgeColors");
+  if (version >= RAW_MESH_VER_REMOVE_ZERO_TRIANGLE_SECTIONS) {
+    array(4, "ImportedMaterialNames");
+  }
+  const byteLength = pos - offset;
+  const faceCount = faces.count;
+  const wedgeCount = wedges.count;
+  const vertexCount = vertices.count;
+  validateRawMeshCounts(offset, {
+    faceCount,
+    wedgeCount,
+    vertexCount,
+    smoothingCount: smoothing.count,
+    normalCount: normals.count,
+    uvChannels
+  });
+  const nonEmptyUvChannels = uvChannels.filter((channel) => channel.count > 0);
+  for (let wedge = 0; wedge < wedgeCount; wedge += 1) {
+    if (view.getUint32(wedges.start + wedge * 4, true) >= vertexCount) {
+      throw rawMeshError("FRawMesh wedge index is out of range for the vertex count", {
+        offset,
+        wedge,
+        vertexCount
+      });
+    }
+  }
+  const faceMaterialIndices = new Int32Array(faceCount);
+  for (let face = 0; face < faceCount; face += 1) {
+    faceMaterialIndices[face] = view.getInt32(faces.start + face * 4, true);
+  }
+  const vertexPositions = new Float32Array(vertexCount * 3);
+  for (let index = 0; index < vertexCount * 3; index += 1) {
+    vertexPositions[index] = view.getFloat32(vertices.start + index * 4, true);
+  }
+  const wedgeIndices = new Uint32Array(wedgeCount);
+  for (let wedge = 0; wedge < wedgeCount; wedge += 1) {
+    wedgeIndices[wedge] = view.getUint32(wedges.start + wedge * 4, true);
+  }
+  const wedgeNormals = normals.count > 0 ? copyFloats(view, normals.start, normals.count * 3) : void 0;
+  const wedgeUvs = nonEmptyUvChannels.map(
+    (channel) => copyFloats(view, channel.start, channel.count * 2)
+  );
+  return {
+    offset,
+    byteLength,
+    mesh: {
+      version,
+      faceMaterialIndices,
+      vertexPositions,
+      vertexCount,
+      wedgeIndices,
+      wedgeNormals,
+      wedgeUvs
+    }
+  };
+}
+function validateRawMeshCounts(offset, counts) {
+  const { faceCount, wedgeCount, vertexCount, smoothingCount, normalCount, uvChannels } = counts;
+  if (wedgeCount !== faceCount * 3) {
+    throw rawMeshError("FRawMesh wedge count does not match three per face", {
+      offset,
+      wedgeCount,
+      faceCount
+    });
+  }
+  if (smoothingCount !== 0 && smoothingCount !== faceCount) {
+    throw rawMeshError("FRawMesh smoothing-mask count does not match the face count", {
+      offset,
+      smoothingCount,
+      faceCount
+    });
+  }
+  if (normalCount !== 0 && normalCount !== wedgeCount) {
+    throw rawMeshError("FRawMesh normal count does not match the wedge count", {
+      offset,
+      normalCount,
+      wedgeCount
+    });
+  }
+  if (!uvChannels.some((channel) => channel.count > 0)) {
+    throw rawMeshError("FRawMesh has no texture coordinates", { offset });
+  }
+  for (const channel of uvChannels) {
+    if (channel.count !== 0 && channel.count !== wedgeCount) {
+      throw rawMeshError("FRawMesh UV channel does not match the wedge count", {
+        offset,
+        uvCount: channel.count,
+        wedgeCount
+      });
+    }
+  }
+  if (wedgeCount === 0 || vertexCount === 0) {
+    throw rawMeshError("FRawMesh has no renderable geometry", { offset });
+  }
+}
+function copyFloats(view, start, count) {
+  const values = new Float32Array(count);
+  for (let index = 0; index < count; index += 1) {
+    values[index] = view.getFloat32(start + index * 4, true);
+  }
+  return values;
+}
+function rawMeshError(message, details) {
+  return new UAssetError("INVALID_RAW_MESH", message, details);
+}
+function findRawMeshBlobs(bytes) {
+  const blobs = [];
+  for (let offset = 0; offset + 20 <= bytes.byteLength; offset += 1) {
+    try {
+      const blob = parseRawMesh(bytes, offset);
+      blobs.push(blob);
+      offset += blob.byteLength - 1;
+    } catch (error) {
+      if (!(error instanceof UAssetError)) throw error;
+    }
+  }
+  return blobs;
+}
+
+// src/bulk-source-model.ts
+function attributeValues(set, name, required) {
+  const entry = set.get(name);
+  if (entry) return entry.values;
+  if (required) {
+    throw new UAssetError("MISSING_MESH_ATTRIBUTE", `UE4 MeshDescription is missing ${name}`, {
+      attribute: name,
+      available: [...set.keys()]
+    });
+  }
+  return void 0;
+}
+function floatAt(values, index, what) {
+  const value = values[index];
+  if (typeof value !== "number") {
+    throw new UAssetError("INVALID_MESH_REFERENCE", `${what} ended before its declared count`, {
+      index,
+      what
+    });
+  }
+  return value;
+}
+function intAt(values, index, what) {
+  const value = values[index];
+  if (typeof value !== "number") {
+    throw new UAssetError("INVALID_MESH_REFERENCE", `${what} ended before its declared count`, {
+      index,
+      what
+    });
+  }
+  return value;
+}
+function expandUe4Instances(description, options) {
+  const positionsByVertex = attributeValues(
+    description.vertexAttributes,
+    "Position",
+    true
+  );
+  const uvsByInstance = attributeValues(
+    description.vertexInstanceAttributes,
+    "TextureCoordinate",
+    true
+  );
+  const normalsByInstance = attributeValues(
+    description.vertexInstanceAttributes,
+    "Normal",
+    false
+  );
+  const instanceIds = description.validVertexInstanceIds;
+  const positions = new Float32Array(instanceIds.length * 3);
+  const uvs = new Float32Array(instanceIds.length * 2);
+  const normals = normalsByInstance ? new Float32Array(instanceIds.length * 3) : void 0;
+  const instanceToOutput = /* @__PURE__ */ new Map();
+  for (let output = 0; output < instanceIds.length; output += 1) {
+    const instanceId = instanceIds[output] ?? -1;
+    instanceToOutput.set(instanceId, output);
+    const vertexId = intAt(
+      description.vertexInstanceVertices,
+      instanceId,
+      "FMeshVertexInstance.VertexID"
+    );
+    const [x, y, z] = convertVector(
+      floatAt(positionsByVertex, vertexId * 3, "Position"),
+      floatAt(positionsByVertex, vertexId * 3 + 1, "Position"),
+      floatAt(positionsByVertex, vertexId * 3 + 2, "Position"),
+      options.convertCoordinates
+    );
+    positions[output * 3] = x;
+    positions[output * 3 + 1] = y;
+    positions[output * 3 + 2] = z;
+    uvs[output * 2] = floatAt(uvsByInstance, instanceId * 2, "TextureCoordinate");
+    const v = floatAt(uvsByInstance, instanceId * 2 + 1, "TextureCoordinate");
+    uvs[output * 2 + 1] = options.flipV ? 1 - v : v;
+    if (normals && normalsByInstance) {
+      const [nx, ny, nz] = convertVector(
+        floatAt(normalsByInstance, instanceId * 3, "Normal"),
+        floatAt(normalsByInstance, instanceId * 3 + 1, "Normal"),
+        floatAt(normalsByInstance, instanceId * 3 + 2, "Normal"),
+        options.convertCoordinates
+      );
+      normals[output * 3] = nx;
+      normals[output * 3 + 1] = ny;
+      normals[output * 3 + 2] = nz;
+    }
+  }
+  return { positions, normals, uvs, instanceToOutput };
+}
+function buildGeometryFromUe4MeshDescription(description, options) {
+  const expanded = expandUe4Instances(description, options);
+  const triangleIds = description.validTriangleIds;
+  assertUAsset(
+    triangleIds.length > 0,
+    "UNSUPPORTED_STATIC_MESH_LAYOUT",
+    "UE4 MeshDescription contains no triangles"
+  );
+  const trianglesByGroup = /* @__PURE__ */ new Map();
+  for (const triangleId of triangleIds) {
+    const corners = [0, 0, 0];
+    for (let corner = 0; corner < 3; corner += 1) {
+      const instanceId = intAt(
+        description.triangleVertexInstances,
+        triangleId * 3 + corner,
+        "FMeshTriangle.VertexInstanceIDs"
+      );
+      const output = expanded.instanceToOutput.get(instanceId);
+      if (output === void 0) {
+        throw new UAssetError(
+          "INVALID_MESH_REFERENCE",
+          "Triangle references a vertex instance with no output slot",
+          { triangleId, corner, instanceId }
+        );
+      }
+      corners[corner] = output;
+    }
+    if (options.flipWinding) {
+      const second = corners[1];
+      corners[1] = corners[2];
+      corners[2] = second;
+    }
+    const polygonId = intAt(description.trianglePolygons, triangleId, "FMeshTriangle.PolygonID");
+    const group = intAt(description.polygonGroups, polygonId, "FMeshPolygon.PolygonGroupID");
+    const groupTriangles = trianglesByGroup.get(group) ?? [];
+    groupTriangles.push(corners[0], corners[1], corners[2]);
+    trianglesByGroup.set(group, groupTriangles);
+  }
+  const slotNames = attributeValues(
+    description.polygonGroupAttributes,
+    "ImportedMaterialSlotName",
+    false
+  );
+  return assembleGeometry(
+    expanded.positions,
+    expanded.normals,
+    expanded.uvs,
+    trianglesByGroup,
+    (group) => slotNames?.[group] ?? String(group),
+    {
+      vertices: description.vertexCount,
+      vertexInstances: description.validVertexInstanceIds.length,
+      triangles: triangleIds.length
+    }
+  );
+}
+function bulkInfo(header) {
+  return {
+    headerOffset: header.headerOffset,
+    flags: header.flags,
+    storage: header.storage,
+    file: header.file,
+    compression: header.compression,
+    elementCount: header.elementCount,
+    sizeOnDisk: header.sizeOnDisk,
+    offsetInFile: header.offsetInFile,
+    payloadOffset: header.payloadOffset
+  };
+}
+function decodeSourceModel(payload, options) {
+  if (looksLikeMeshDescriptionUe4(payload)) {
+    try {
+      const description = parseMeshDescriptionUe4(payload);
+      return {
+        layout: "mesh-description-ue4",
+        build: buildGeometryFromUe4MeshDescription(description, options),
+        byteLength: description.byteLength
+      };
+    } catch (error) {
+      if (!(error instanceof UAssetError)) throw error;
+    }
+  }
+  try {
+    const blob = parseRawMesh(payload, 0);
+    return {
+      layout: "raw-mesh",
+      build: buildGeometryFromRawMesh(blob.mesh, options),
+      byteLength: blob.byteLength
+    };
+  } catch (error) {
+    if (!(error instanceof UAssetError)) throw error;
+  }
+  return void 0;
+}
+function selectBulkSourceModel(bytes, layout, parseOptions, options) {
+  let blockingError;
+  for (const header of findBulkDataHeaders(bytes, layout, parseOptions.bulkDataFiles)) {
+    let payload;
+    try {
+      payload = resolveBulkDataPayload(bytes, header, {
+        ...parseOptions.bulkDataFiles === void 0 ? {} : { files: parseOptions.bulkDataFiles },
+        ...parseOptions.zlib === void 0 ? {} : { zlib: parseOptions.zlib }
+      });
+    } catch (error) {
+      if (!(error instanceof UAssetError)) throw error;
+      if (error.code === "MISSING_CODEC" || error.code === "MISSING_BULK_DATA_FILE") {
+        blockingError ??= error;
+      }
+      continue;
+    }
+    const decoded = decodeSourceModel(payload, options);
+    if (decoded === void 0) continue;
+    return {
+      selection: {
+        layout: decoded.layout,
+        build: decoded.build,
+        bulkData: bulkInfo(header),
+        payloadByteLength: decoded.byteLength
+      }
+    };
+  }
+  return blockingError === void 0 ? {} : { blockingError };
+}
+
+// src/compressed-buffer.ts
+var COMPRESSED_BUFFER_MAGIC = 3077923682;
+var COMPRESSION_METHOD = Object.freeze({
+  NONE: 0,
+  OODLE: 3,
+  LZ4: 4
+});
+function findCompressedBufferOffsets(bytes) {
+  const offsets = [];
+  for (let offset = 0; offset + 4 <= bytes.byteLength; offset += 1) {
+    if (bytes[offset] === 183 && bytes[offset + 1] === 117 && bytes[offset + 2] === 99 && bytes[offset + 3] === 98) {
+      offsets.push(offset);
+    }
+  }
+  return offsets;
+}
+function parseCompressedBuffer(bytes, offset = 0) {
+  const reader = new BinaryReader(bytes, offset);
+  const magic = reader.uint32BE("FCompressedBuffer magic");
+  assertUAsset(
+    magic === COMPRESSED_BUFFER_MAGIC,
+    "INVALID_COMPRESSED_BUFFER",
+    "Invalid FCompressedBuffer magic",
+    {
+      offset,
+      magic: `0x${magic.toString(16)}`
+    }
+  );
+  const crc32 = reader.uint32BE("FCompressedBuffer CRC32");
+  const method = reader.uint8("compression method");
+  const compressor = reader.uint8("compressor");
+  const compressionLevel = reader.uint8("compression level");
+  const blockSizeExponent = reader.uint8("block size exponent");
+  const blockCount = reader.uint32BE("block count");
+  const totalRawSize = safeNumber(reader.uint64BE("total raw size"), "Total raw size", offset);
+  const totalCompressedSize = safeNumber(
+    reader.uint64BE("total compressed size"),
+    "Total compressed size",
+    offset
+  );
+  const rawHash = reader.raw(32, "raw BLAKE3 hash");
+  assertUAsset(
+    blockCount <= 1e6,
+    "INVALID_COMPRESSED_BUFFER",
+    "Invalid compressed block count",
+    {
+      offset,
+      blockCount
+    }
+  );
+  assertUAsset(
+    totalCompressedSize >= 64,
+    "INVALID_COMPRESSED_BUFFER",
+    "Compressed buffer is smaller than its header",
+    { offset, totalCompressedSize }
+  );
+  assertUAsset(
+    totalCompressedSize <= Number.MAX_SAFE_INTEGER && offset + totalCompressedSize <= bytes.byteLength,
+    "TRUNCATED_PACKAGE",
+    "Compressed buffer extends past the package",
+    { offset, totalCompressedSize, packageSize: bytes.byteLength }
+  );
+  assertUAsset(
+    method === COMPRESSION_METHOD.NONE || method === COMPRESSION_METHOD.OODLE || method === COMPRESSION_METHOD.LZ4,
+    "UNSUPPORTED_COMPRESSION_METHOD",
+    `Unsupported Unreal compressed-buffer method ${method}`,
+    { offset, method }
+  );
+  assertUAsset(
+    method === COMPRESSION_METHOD.NONE || blockCount > 0 || totalRawSize === 0,
+    "INVALID_COMPRESSED_BUFFER",
+    "Compressed Unreal payload declares no blocks",
+    { offset, method, blockCount, totalRawSize }
+  );
+  const blockSizes = [];
+  if (method === COMPRESSION_METHOD.OODLE || method === COMPRESSION_METHOD.LZ4) {
+    for (let index = 0; index < blockCount; index += 1) {
+      blockSizes.push(reader.uint32BE(`compressed block ${index} size`));
+    }
+  }
+  const dataOffset = offset + reader.pos;
+  const payloadSize = method === COMPRESSION_METHOD.NONE ? totalRawSize : blockSizes.reduce((sum, size) => sum + size, 0);
+  assertUAsset(
+    reader.pos + payloadSize <= totalCompressedSize,
+    "INVALID_COMPRESSED_BUFFER",
+    "Compressed payload exceeds its declared buffer size",
+    { offset, headerAndTableSize: reader.pos, payloadSize, totalCompressedSize }
+  );
+  assertUAsset(
+    dataOffset + payloadSize <= bytes.byteLength,
+    "TRUNCATED_PACKAGE",
+    "Compressed payload bytes are truncated",
+    { offset, dataOffset, payloadSize, packageSize: bytes.byteLength }
+  );
+  return {
+    offset,
+    crc32,
+    method,
+    compressor,
+    compressionLevel,
+    blockSizeExponent,
+    blockCount,
+    totalRawSize,
+    totalCompressedSize,
+    rawHash: Uint8Array.from(rawHash),
+    blockSizes,
+    payloadBytes: bytes.subarray(dataOffset, dataOffset + payloadSize)
+  };
+}
+function safeNumber(value, label, offset) {
+  const number = Number(value);
+  assertUAsset(Number.isSafeInteger(number), "INVALID_COMPRESSED_BUFFER", `${label} is too large`, {
+    offset,
+    value: value.toString()
+  });
+  return number;
+}
+function decompressCompressedBuffer(buffer, codecs) {
+  if (buffer.method === COMPRESSION_METHOD.NONE) {
+    return Uint8Array.from(buffer.payloadBytes.subarray(0, buffer.totalRawSize));
+  }
+  const isOodle = buffer.method === COMPRESSION_METHOD.OODLE;
+  const codec = isOodle ? codecs.oodle : codecs.lz4;
+  const codecName = isOodle ? "Oodle" : "LZ4";
+  if (typeof codec !== "function") {
+    throw new UAssetError(
+      "MISSING_CODEC",
+      `${codecName} decompression is required for this Unreal payload`,
+      {
+        method: buffer.method,
+        offset: buffer.offset
+      }
+    );
+  }
+  const output = new Uint8Array(buffer.totalRawSize);
+  const maximumBlockSize = buffer.blockSizeExponent > 0 && buffer.blockSizeExponent < 31 ? 2 ** buffer.blockSizeExponent : buffer.totalRawSize;
+  let sourceOffset = 0;
+  let targetOffset = 0;
+  for (let index = 0; index < buffer.blockSizes.length; index += 1) {
+    const compressedSize = buffer.blockSizes[index];
+    if (compressedSize === void 0) {
+      throw new UAssetError("INVALID_COMPRESSED_BUFFER", "Compressed block table ended early", {
+        block: index
+      });
+    }
+    const rawBlockSize = Math.min(maximumBlockSize, buffer.totalRawSize - targetOffset);
+    const compressed = buffer.payloadBytes.subarray(sourceOffset, sourceOffset + compressedSize);
+    const decompressed = codec(compressed, rawBlockSize);
+    assertUAsset(
+      decompressed.byteLength === rawBlockSize,
+      "CODEC_SIZE_MISMATCH",
+      `${codecName} returned the wrong size`,
+      { block: index, expected: rawBlockSize, actual: decompressed.byteLength }
+    );
+    output.set(decompressed, targetOffset);
+    sourceOffset += compressedSize;
+    targetOffset += rawBlockSize;
+  }
+  assertUAsset(
+    targetOffset === buffer.totalRawSize,
+    "INCOMPLETE_DECOMPRESSION",
+    "Compressed payload did not produce the declared raw size",
+    { expected: buffer.totalRawSize, actual: targetOffset }
+  );
+  return output;
+}
+
+// src/mesh-description.ts
+var MAX_MESH_ELEMENTS3 = 1e7;
+var MAX_ATTRIBUTE_VALUES2 = 1e8;
+var ATTRIBUTE_TYPES2 = Object.freeze([
+  { name: "FVector4f", components: 4, byteSize: 16, kind: "float" },
+  { name: "FVector3f", components: 3, byteSize: 12, kind: "float" },
+  { name: "FVector2f", components: 2, byteSize: 8, kind: "float" },
+  { name: "float", components: 1, byteSize: 4, kind: "float" },
+  { name: "int32", components: 1, byteSize: 4, kind: "int" },
+  { name: "bool", components: 1, byteSize: 1, kind: "bool" },
+  { name: "FName", components: 1, byteSize: void 0, kind: "name" }
+]);
+function readBitArray2(reader) {
+  const numBits = reader.int32("TBitArray NumBits");
+  assertUAsset(
+    numBits >= 0 && numBits <= MAX_MESH_ELEMENTS3,
+    "INVALID_MESH_DESCRIPTION",
+    "Invalid Unreal bit-array length",
+    { offset: reader.pos - 4, numBits }
+  );
+  const wordCount = Math.ceil(numBits / 32);
+  const words = new Uint32Array(wordCount);
+  for (let index = 0; index < wordCount; index += 1) {
+    words[index] = reader.uint32("TBitArray word");
+  }
+  const validIds = [];
+  for (let id = 0; id < numBits; id += 1) {
+    const word = words[id >>> 5];
+    if (word !== void 0 && (word & 1 << (id & 31)) !== 0) validIds.push(id);
+  }
+  return { numBits, validIds };
+}
+function readBulkValues(reader, type, context) {
+  const serializedElementSize = reader.int32(`${context} bulk element size`);
+  const serializedCount = reader.int32(`${context} bulk element count`);
+  assertUAsset(
+    type.byteSize !== void 0 && serializedElementSize === type.byteSize,
+    "INVALID_MESH_DESCRIPTION",
+    `${context} has an unexpected element size`,
+    { expected: type.byteSize, actual: serializedElementSize, type: type.name }
+  );
+  assertUAsset(
+    serializedCount >= 0 && serializedCount <= MAX_ATTRIBUTE_VALUES2,
+    "INVALID_MESH_DESCRIPTION",
+    `${context} has an invalid value count`,
+    { count: serializedCount }
+  );
+  const requiredBytes = serializedCount * serializedElementSize;
+  assertUAsset(
+    Number.isSafeInteger(requiredBytes) && requiredBytes <= reader.remaining,
+    "INVALID_MESH_DESCRIPTION",
+    `${context} exceeds the remaining MeshDescription payload`,
+    { requiredBytes, remaining: reader.remaining, serializedCount, serializedElementSize }
+  );
+  if (type.kind === "float") {
+    const values2 = new Float32Array(serializedCount * type.components);
+    for (let index = 0; index < values2.length; index += 1) {
+      values2[index] = reader.float32(context);
+    }
+    return { values: values2, serializedCount };
+  }
+  if (type.kind === "int") {
+    const values2 = new Int32Array(serializedCount);
+    for (let index = 0; index < values2.length; index += 1) {
+      values2[index] = reader.int32(context);
+    }
+    return { values: values2, serializedCount };
+  }
+  const values = new Uint8Array(serializedCount);
+  values.set(reader.raw(serializedCount, context));
+  return { values, serializedCount };
+}
+function readAttributeEntry2(reader, rawName) {
+  const name = rawName.trimEnd();
+  const typeIndex = reader.uint32(`${name} type`);
+  const type = ATTRIBUTE_TYPES2[typeIndex];
+  assertUAsset(
+    type !== void 0,
+    "INVALID_MESH_DESCRIPTION",
+    "Unknown MeshDescription attribute type",
+    {
+      attribute: name,
+      typeIndex
+    }
+  );
+  const extent = reader.uint32(`${name} extent`);
+  assertUAsset(
+    extent >= 1 && extent <= 64,
+    "INVALID_MESH_DESCRIPTION",
+    `Invalid extent for ${name}`,
+    {
+      extent
+    }
+  );
+  const numElements = reader.int32(`${name} number of elements`);
+  const numChannels = reader.int32(`${name} channel count`);
+  assertUAsset(
+    numElements >= 0 && numElements <= MAX_MESH_ELEMENTS3,
+    "INVALID_MESH_DESCRIPTION",
+    `Invalid element count for ${name}`,
+    { numElements }
+  );
+  assertUAsset(
+    numChannels >= 0 && numChannels <= 128,
+    "INVALID_MESH_DESCRIPTION",
+    `Invalid channel count for ${name}`,
+    { numChannels }
+  );
+  const channels = [];
+  for (let channelIndex = 0; channelIndex < numChannels; channelIndex += 1) {
+    const channelExtent = reader.uint32(`${name} channel extent`);
+    assertUAsset(
+      channelExtent === extent,
+      "INVALID_MESH_DESCRIPTION",
+      `Channel extent mismatch for ${name}`,
+      { extent, channelExtent }
+    );
+    let channel;
+    if (type.kind === "name") {
+      const count = reader.int32(`${name} FName count`);
+      assertUAsset(
+        count >= 0 && count <= MAX_ATTRIBUTE_VALUES2,
+        "INVALID_MESH_DESCRIPTION",
+        `Invalid FName count for ${name}`,
+        { count }
+      );
+      const values = new Array(count);
+      for (let index = 0; index < count; index += 1) {
+        values[index] = reader.fstring(`${name}[${index}]`);
+      }
+      channel = { extent: channelExtent, values, serializedCount: count };
+    } else {
+      channel = {
+        extent: channelExtent,
+        ...readBulkValues(reader, type, `${name}[${channelIndex}]`)
+      };
+    }
+    const expectedCount = numElements * extent;
+    assertUAsset(
+      channel.serializedCount === expectedCount,
+      "INVALID_MESH_DESCRIPTION",
+      `Serialized value count mismatch for ${name}`,
+      {
+        channelIndex,
+        expected: expectedCount,
+        actual: channel.serializedCount,
+        numElements,
+        extent
+      }
+    );
+    channels.push(channel);
+  }
+  readDefaultValue2(reader, type);
+  reader.uint32(`${name} flags`);
+  return {
+    name,
+    type: type.name,
+    components: type.components,
+    extent,
+    numElements,
+    channels
+  };
+}
+function readDefaultValue2(reader, type) {
+  switch (type.kind) {
+    case "float": {
+      const values = [];
+      for (let index = 0; index < type.components; index += 1) {
+        values.push(reader.float32(type.name));
+      }
+      return type.components === 1 ? values[0] ?? 0 : values;
+    }
+    case "int":
+      return reader.int32(type.name);
+    case "bool":
+      return reader.uint32(type.name) !== 0;
+    case "name":
+      return reader.fstring(type.name);
+  }
+}
+function readAttributesSet(reader) {
+  const numElements = reader.int32("attribute-set number of elements");
+  const attributeCount = reader.int32("attribute map count");
+  assertUAsset(
+    numElements >= 0 && numElements <= MAX_MESH_ELEMENTS3 && attributeCount >= 0 && attributeCount <= 1024,
+    "INVALID_MESH_DESCRIPTION",
+    "Invalid attribute-set size",
+    { numElements, attributeCount }
+  );
+  const attributes = /* @__PURE__ */ new Map();
+  for (let index = 0; index < attributeCount; index += 1) {
+    const rawName = reader.fstring(`attribute name ${index}`);
+    const entry = readAttributeEntry2(reader, rawName);
+    attributes.set(entry.name, entry);
+  }
+  return { numElements, attributes };
+}
+function readElementContainer(reader, elementName, channelIndex) {
+  const allocation = readBitArray2(reader);
+  const numHoles = reader.int32(`${elementName} NumHoles`);
+  const attributeSet = readAttributesSet(reader);
+  assertUAsset(
+    attributeSet.numElements === allocation.numBits,
+    "INVALID_MESH_DESCRIPTION",
+    `Allocation and attribute count disagree for ${elementName}`,
+    {
+      channelIndex,
+      allocatedSlots: allocation.numBits,
+      attributeElements: attributeSet.numElements
+    }
+  );
+  assertUAsset(
+    numHoles >= 0 && numHoles <= allocation.numBits,
+    "INVALID_MESH_DESCRIPTION",
+    `Invalid hole count for ${elementName}`,
+    { channelIndex, numHoles, numBits: allocation.numBits }
+  );
+  assertUAsset(
+    allocation.validIds.length === allocation.numBits - numHoles,
+    "INVALID_MESH_DESCRIPTION",
+    `Bit array and hole count disagree for ${elementName}`,
+    { validIds: allocation.validIds.length, numBits: allocation.numBits, numHoles }
+  );
+  return { allocation, attributeSet };
+}
+function parseMeshDescription(input, offset = 0) {
+  const reader = new BinaryReader(input, offset);
+  const start = reader.pos;
+  const elementTypeCount = reader.int32("MeshDescription element type count");
+  assertUAsset(
+    elementTypeCount >= 1 && elementTypeCount <= 32,
+    "INVALID_MESH_DESCRIPTION",
+    "Invalid MeshDescription element-type count",
+    { offset, elementTypeCount }
+  );
+  const elements = /* @__PURE__ */ new Map();
+  for (let elementIndex = 0; elementIndex < elementTypeCount; elementIndex += 1) {
+    const name = reader.fstring(`element type ${elementIndex}`);
+    assertUAsset(
+      name.length > 0 && name.length < 128,
+      "INVALID_MESH_DESCRIPTION",
+      "Invalid MeshDescription element name",
+      { elementIndex, name }
+    );
+    const channelCount = reader.int32(`${name} channel count`);
+    assertUAsset(
+      channelCount >= 1 && channelCount <= 128,
+      "INVALID_MESH_DESCRIPTION",
+      `Invalid channel count for ${name}`,
+      { channelCount }
+    );
+    const channels = [];
+    for (let channelIndex = 0; channelIndex < channelCount; channelIndex += 1) {
+      channels.push(readElementContainer(reader, name, channelIndex));
+    }
+    elements.set(name, { name, channels });
+  }
+  return {
+    byteLength: reader.pos - start,
+    trailingBytes: reader.remaining,
+    elements
+  };
+}
+function looksLikeMeshDescription(bytes, offset = 0) {
+  if (offset < 0 || offset + 17 > bytes.byteLength) return false;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const count = view.getInt32(offset, true);
+  const stringLength = view.getInt32(offset + 4, true);
+  if (count < 1 || count > 32 || stringLength !== 9) return false;
+  const expected = "Vertices";
+  for (let index = 0; index < expected.length; index += 1) {
+    if (bytes[offset + 8 + index] !== expected.charCodeAt(index)) return false;
+  }
+  return bytes[offset + 16] === 0;
+}
+function findMeshDescriptionOffsets(bytes) {
+  const offsets = [];
+  for (let offset = 0; offset + 17 <= bytes.byteLength; offset += 1) {
+    if (looksLikeMeshDescription(bytes, offset)) offsets.push(offset);
+  }
+  return offsets;
+}
+
+// src/static-mesh.ts
+var latin1 = new TextDecoder("latin1");
+var METADATA_SCAN_BYTES = 262144;
+function asBytes(input) {
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  throw new TypeError("Expected an ArrayBuffer or ArrayBufferView");
+}
+function scanMetadata(bytes) {
+  const text = latin1.decode(bytes.subarray(0, Math.min(bytes.byteLength, METADATA_SCAN_BYTES)));
+  const branch = /\+\+UE[45]\+Release-[0-9.]+/.exec(text)?.[0] ?? "unknown";
+  const gamePaths = [...text.matchAll(/\/Game\/[A-Za-z0-9_./-]+/g)].map((match) => match[0]);
+  const objectPath = gamePaths.find((path) => /\/StaticMeshes\//.test(path)) ?? gamePaths[0] ?? "unknown";
+  return { engineVersion: branch, objectPath };
+}
+function attribute(description, elementName, attributeName, required) {
+  const entry = description.elements.get(elementName)?.channels[0]?.attributeSet.attributes.get(attributeName);
+  if (entry) return entry;
+  if (required) {
+    throw new UAssetError("MISSING_MESH_ATTRIBUTE", `MeshDescription is missing ${attributeName}`, {
+      element: elementName,
+      attribute: attributeName
+    });
+  }
+  return void 0;
+}
+function channelValues(entry) {
+  const channel = entry.channels[0];
+  assertUAsset(
+    channel !== void 0,
+    "MISSING_MESH_ATTRIBUTE",
+    `${entry.name} has no data channel`,
+    {
+      attribute: entry.name
+    }
+  );
+  return channel.values;
+}
+function componentAt(values, elementId, extent, component) {
+  const value = values[elementId * extent + component];
+  if (typeof value !== "number") {
+    throw new UAssetError(
+      "INVALID_MESH_REFERENCE",
+      "Attribute data ended before its declared element count",
+      {
+        elementId,
+        extent,
+        component
+      }
+    );
+  }
+  return value;
+}
+function groupTrianglesByInstance(inputs) {
+  const trianglesByGroup = /* @__PURE__ */ new Map();
+  for (const triangleId of inputs.validTriangleIds) {
+    const source = triangleId * inputs.triangleExtent;
+    const corners = [0, 0, 0];
+    for (let corner = 0; corner < 3; corner += 1) {
+      const instanceId = inputs.triangleVertexInstances[source + corner];
+      const outputIndex = inputs.instanceToOutput.get(instanceId ?? -1);
+      if (outputIndex === void 0) {
+        throw new UAssetError(
+          "INVALID_MESH_REFERENCE",
+          "Triangle references an invalid vertex instance",
+          {
+            triangleId,
+            instanceId
+          }
+        );
+      }
+      corners[corner] = outputIndex;
+    }
+    if (inputs.flipWinding) {
+      const second = corners[1];
+      corners[1] = corners[2];
+      corners[2] = second;
+    }
+    const rawGroupId = inputs.triangleGroups ? componentAt(inputs.triangleGroups, triangleId, inputs.triangleGroupExtent, 0) : 0;
+    const groupId = rawGroupId >= 0 ? rawGroupId : 0;
+    const groupTriangles = trianglesByGroup.get(groupId) ?? [];
+    groupTriangles.push(corners[0], corners[1], corners[2]);
+    trianglesByGroup.set(groupId, groupTriangles);
+  }
+  return trianglesByGroup;
+}
+function expandVertexInstances(inputs) {
+  const instanceToOutput = /* @__PURE__ */ new Map();
+  const positions = new Float32Array(inputs.validInstanceIds.length * 3);
+  const uvs = new Float32Array(inputs.validInstanceIds.length * 2);
+  const normals = inputs.normalsByInstance ? new Float32Array(inputs.validInstanceIds.length * 3) : void 0;
+  for (let outputIndex = 0; outputIndex < inputs.validInstanceIds.length; outputIndex += 1) {
+    const instanceId = inputs.validInstanceIds[outputIndex];
+    if (instanceId === void 0) {
+      throw new UAssetError("INVALID_MESH_REFERENCE", "Vertex instance allocation ended early", {
+        outputIndex
+      });
+    }
+    instanceToOutput.set(instanceId, outputIndex);
+    const vertexId = inputs.vertexIndices[instanceId * inputs.vertexExtent];
+    if (typeof vertexId !== "number" || !inputs.validVertexIds.has(vertexId)) {
+      throw new UAssetError(
+        "INVALID_MESH_REFERENCE",
+        "Vertex instance references an invalid vertex",
+        {
+          instanceId,
+          vertexId
+        }
+      );
+    }
+    const [x, y, z] = convertVector(
+      componentAt(inputs.positionsByVertex, vertexId, inputs.positionExtent, 0),
+      componentAt(inputs.positionsByVertex, vertexId, inputs.positionExtent, 1),
+      componentAt(inputs.positionsByVertex, vertexId, inputs.positionExtent, 2),
+      inputs.options.convertCoordinates
+    );
+    positions[outputIndex * 3] = x;
+    positions[outputIndex * 3 + 1] = y;
+    positions[outputIndex * 3 + 2] = z;
+    uvs[outputIndex * 2] = componentAt(inputs.uvsByInstance, instanceId, inputs.uvExtent, 0);
+    const v = componentAt(inputs.uvsByInstance, instanceId, inputs.uvExtent, 1);
+    uvs[outputIndex * 2 + 1] = inputs.options.flipV ? 1 - v : v;
+    if (normals && inputs.normalsByInstance) {
+      const [nx, ny, nz] = convertVector(
+        componentAt(inputs.normalsByInstance, instanceId, inputs.normalExtent, 0),
+        componentAt(inputs.normalsByInstance, instanceId, inputs.normalExtent, 1),
+        componentAt(inputs.normalsByInstance, instanceId, inputs.normalExtent, 2),
+        inputs.options.convertCoordinates
+      );
+      normals[outputIndex * 3] = nx;
+      normals[outputIndex * 3 + 1] = ny;
+      normals[outputIndex * 3 + 2] = nz;
+    }
+  }
+  return { positions, normals, uvs, instanceToOutput };
+}
+function buildGeometryFromMeshDescription(description, options) {
+  const vertices = description.elements.get("Vertices");
+  const vertexInstances = description.elements.get("VertexInstances");
+  const triangles = description.elements.get("Triangles");
+  assertUAsset(
+    vertices !== void 0 && vertexInstances !== void 0 && triangles !== void 0,
+    "INVALID_MESH_DESCRIPTION",
+    "MeshDescription lacks required static-mesh element containers",
+    { available: [...description.elements.keys()] }
+  );
+  const positionAttribute = attribute(description, "Vertices", "Position", true);
+  const vertexIndexAttribute = attribute(description, "VertexInstances", "VertexIndex", true);
+  const uvAttribute = attribute(description, "VertexInstances", "TextureCoordinate", true);
+  const normalAttribute = attribute(description, "VertexInstances", "Normal", false);
+  const triangleIndexAttribute = attribute(description, "Triangles", "VertexInstanceIndex", true);
+  const triangleGroupAttribute = attribute(description, "Triangles", "PolygonGroupIndex", false);
+  const materialSlotAttribute = description.elements.get("PolygonGroups")?.channels[0]?.attributeSet.attributes.get("ImportedMaterialSlotName");
+  const positionsByVertex = channelValues(positionAttribute);
+  const vertexIndices = channelValues(vertexIndexAttribute);
+  const uvsByInstance = channelValues(uvAttribute);
+  const normalsByInstance = normalAttribute ? channelValues(normalAttribute) : void 0;
+  const triangleVertexInstances = channelValues(triangleIndexAttribute);
+  const triangleGroups = triangleGroupAttribute ? channelValues(triangleGroupAttribute) : void 0;
+  const materialSlotNames = materialSlotAttribute ? channelValues(materialSlotAttribute) : void 0;
+  const verticesChannel = vertices.channels[0];
+  const instancesChannel = vertexInstances.channels[0];
+  const trianglesChannel = triangles.channels[0];
+  if (verticesChannel === void 0 || instancesChannel === void 0 || trianglesChannel === void 0) {
+    throw new UAssetError(
+      "INVALID_MESH_DESCRIPTION",
+      "MeshDescription element container has no channels"
+    );
+  }
+  const validVertexIds = new Set(verticesChannel.allocation.validIds);
+  const validInstanceIds = instancesChannel.allocation.validIds;
+  assertUAsset(
+    validVertexIds.size > 0 && validInstanceIds.length > 0,
+    "UNSUPPORTED_STATIC_MESH_LAYOUT",
+    "Static mesh contains no renderable vertices"
+  );
+  const expanded = expandVertexInstances({
+    validInstanceIds,
+    validVertexIds,
+    vertexIndices,
+    vertexExtent: vertexIndexAttribute.extent,
+    positionsByVertex,
+    positionExtent: positionAttribute.extent,
+    uvsByInstance,
+    uvExtent: uvAttribute.extent,
+    normalsByInstance,
+    normalExtent: normalAttribute?.extent ?? 1,
+    options
+  });
+  const instanceToOutput = expanded.instanceToOutput;
+  const validTriangleIds = trianglesChannel.allocation.validIds;
+  assertUAsset(
+    validTriangleIds.length > 0,
+    "UNSUPPORTED_STATIC_MESH_LAYOUT",
+    "Static mesh contains no triangles"
+  );
+  const trianglesByGroup = groupTrianglesByInstance({
+    validTriangleIds,
+    triangleExtent: triangleIndexAttribute.extent,
+    triangleVertexInstances,
+    instanceToOutput,
+    triangleGroups,
+    triangleGroupExtent: triangleGroupAttribute?.extent ?? 1,
+    flipWinding: options.flipWinding
+  });
+  const slotNameStride = materialSlotAttribute?.extent ?? 1;
+  return assembleGeometry(
+    expanded.positions,
+    expanded.normals,
+    expanded.uvs,
+    trianglesByGroup,
+    (groupId) => materialSlotNames?.[groupId * slotNameStride] ?? String(groupId),
+    {
+      vertices: verticesChannel.allocation.validIds.length,
+      vertexInstances: validInstanceIds.length,
+      triangles: validTriangleIds.length
+    }
+  );
+}
+function tryMeshDescriptionPayload(payload, options) {
+  for (const offset of findMeshDescriptionOffsets(payload)) {
+    try {
+      const description = parseMeshDescription(payload, offset);
+      if (description.elements.has("Vertices") && description.elements.has("VertexInstances") && description.elements.has("Triangles")) {
+        return {
+          description,
+          offset,
+          build: buildGeometryFromMeshDescription(description, options)
+        };
+      }
+    } catch (error) {
+      if (!(error instanceof UAssetError)) throw error;
+    }
+  }
+  return void 0;
+}
+function probeCompressedBuffer(buffer, codecs, options) {
+  try {
+    const payload = decompressCompressedBuffer(buffer, codecs);
+    const found = tryMeshDescriptionPayload(payload, options);
+    if (found) {
+      return {
+        selection: {
+          layout: "mesh-description",
+          payload: {
+            frame: "decompressed",
+            offset: found.offset,
+            byteLength: found.description.byteLength
+          },
+          build: found.build,
+          compressedBuffer: buffer
+        }
+      };
+    }
+    return {};
+  } catch (error) {
+    if (!(error instanceof UAssetError)) throw error;
+    return { missingCodecError: error.code === "MISSING_CODEC" ? error : void 0 };
+  }
+}
+function selectCompressedMeshDescription(bytes, codecs, options) {
+  let missingCodecError;
+  for (const offset of findCompressedBufferOffsets(bytes)) {
+    let buffer;
+    try {
+      buffer = parseCompressedBuffer(bytes, offset);
+    } catch (error) {
+      if (!(error instanceof UAssetError)) throw error;
+      continue;
+    }
+    if (buffer === void 0) continue;
+    const probed = probeCompressedBuffer(buffer, codecs, options);
+    if (probed.selection) return probed;
+    missingCodecError ??= probed.missingCodecError;
+  }
+  return { missingCodecError };
+}
+function selectRawMesh(bytes, options) {
+  const blob = findRawMeshBlobs(bytes)[0];
+  if (blob === void 0) return void 0;
+  return {
+    layout: "raw-mesh",
+    payload: { frame: "package", offset: blob.offset, byteLength: blob.byteLength },
+    build: buildGeometryFromRawMesh(blob.mesh, options)
+  };
+}
+function selectBulkData(bytes, parseOptions, options) {
+  const layout = readPackageLayout(bytes);
+  if (layout === void 0) return {};
+  const found = selectBulkSourceModel(bytes, layout, parseOptions, options);
+  if (found.selection === void 0) {
+    return found.blockingError === void 0 ? {} : { blockingError: found.blockingError };
+  }
+  return { selection: toPayloadSelection(found.selection) };
+}
+function toPayloadSelection(model) {
+  return {
+    layout: model.layout,
+    payload: { frame: "bulk-data", offset: 0, byteLength: model.payloadByteLength },
+    build: model.build,
+    bulkData: model.bulkData
+  };
+}
+function buildUnrealInfo(summary, selected) {
+  const compressedInfo = selected.compressedBuffer;
+  return {
+    packageTag: summary.packageTag,
+    legacyFileVersion: summary.legacyFileVersion,
+    ...summary.fileVersionUE4 === void 0 ? {} : { fileVersionUE4: summary.fileVersionUE4 },
+    ...summary.fileVersionUE5 === void 0 ? {} : { fileVersionUE5: summary.fileVersionUE5 },
+    ...summary.licenseeVersion === void 0 ? {} : { licenseeVersion: summary.licenseeVersion },
+    ...summary.editorObjectVersion === void 0 ? {} : { editorObjectVersion: summary.editorObjectVersion },
+    layout: selected.layout,
+    payload: selected.payload,
+    ...compressedInfo === void 0 ? {} : {
+      compressedBuffer: {
+        offset: compressedInfo.offset,
+        method: compressedInfo.method,
+        compressor: compressedInfo.compressor,
+        compressionLevel: compressedInfo.compressionLevel,
+        rawSize: compressedInfo.totalRawSize,
+        compressedSize: compressedInfo.totalCompressedSize,
+        blockCount: compressedInfo.blockCount
+      }
+    },
+    ...selected.bulkData === void 0 ? {} : { bulkData: selected.bulkData }
+  };
+}
+function parseUAssetStaticMesh(input, options = {}) {
+  const bytes = asBytes(input);
+  const resolved = {
+    convertCoordinates: options.convertCoordinates ?? true,
+    flipWinding: options.flipWinding ?? true,
+    flipV: options.flipV ?? false
+  };
+  const summary = readPackageSummary(bytes);
+  const metadataScan = scanMetadata(bytes);
+  const compressed = selectCompressedMeshDescription(
+    bytes,
+    { oodle: options.oodle, lz4: options.lz4 },
+    resolved
+  );
+  let selected = compressed.selection;
+  if (selected === void 0) {
+    const inlineFound = tryMeshDescriptionPayload(bytes, resolved);
+    if (inlineFound) {
+      selected = {
+        layout: "mesh-description",
+        payload: {
+          frame: "package",
+          offset: inlineFound.offset,
+          byteLength: inlineFound.description.byteLength
+        },
+        build: inlineFound.build
+      };
+    }
+  }
+  let bulk = {};
+  if (selected === void 0) {
+    bulk = selectBulkData(bytes, options, resolved);
+    selected = bulk.selection;
+  }
+  selected ??= selectRawMesh(bytes, resolved);
+  if (selected === void 0) {
+    if (bulk.blockingError) throw bulk.blockingError;
+    if (compressed.missingCodecError) throw compressed.missingCodecError;
+    throw new UAssetError(
+      "UNSUPPORTED_STATIC_MESH_LAYOUT",
+      "No supported static-mesh payload was found in this package",
+      {
+        fileVersionUE4: summary.fileVersionUE4,
+        editorObjectVersion: summary.editorObjectVersion,
+        // What was looked for, rather than a version range. A real UE4.27 pack reached here and
+        // was told the parser covers "UE4.26–5.x editor static meshes with serialized
+        // FMeshDescription data" — a claim that describes the file in front of it, so the only
+        // conclusion left to the caller was that the asset is corrupt. Naming the three probes
+        // that ran and matched nothing says the true thing: this is a coverage gap in the
+        // payload forms, not a broken package.
+        probed: "compressed-buffer, inline mesh-description, bulk-data, raw-mesh \u2014 none matched",
+        supported: "UE4.26\u20135.x editor static meshes whose FMeshDescription is serialized inline or in a compressed buffer (UE5 compressed payloads need an `oodle` codec); UE4.2x editor packages whose FMeshDescription or FRawMesh source model is kept in FByteBulkData, inline, at the end of the package, or in a sibling .ubulk/.uptnl file whose bytes the caller supplies through `bulkDataFiles` (zlib-compressed payloads need a `zlib` codec); and UE4.18-era packages with inline uncompressed FRawMesh source models. IoStore containers, PAK archives, cooked render buffers, Nanite clusters and skeletal meshes are not read."
+      }
+    );
+  }
+  return {
+    positions: selected.build.positions,
+    normals: selected.build.normals,
+    uvs: selected.build.uvs,
+    indices: selected.build.indices,
+    sections: selected.build.sections,
+    bounds: computeBounds(selected.build.positions),
+    metadata: {
+      assetClass: "StaticMesh",
+      engineVersion: metadataScan.engineVersion,
+      objectPath: metadataScan.objectPath,
+      packageByteLength: bytes.byteLength
+    },
+    unreal: buildUnrealInfo(summary, selected),
+    sourceStats: selected.build.sourceStats
+  };
+}
+function fallbackMaterial() {
+  return new MeshStandardMaterial({ color: 12110047, metalness: 0.08, roughness: 0.42 });
+}
+function createThreeGeometry(decoded) {
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", new BufferAttribute(decoded.positions, 3));
+  geometry.setAttribute("uv", new BufferAttribute(decoded.uvs, 2));
+  if (decoded.normals) {
+    geometry.setAttribute("normal", new BufferAttribute(decoded.normals, 3));
+  } else {
+    geometry.computeVertexNormals();
+  }
+  geometry.setIndex(new BufferAttribute(decoded.indices, 1));
+  for (const section of decoded.sections) {
+    geometry.addGroup(section.start, section.count, section.materialIndex);
+  }
+  geometry.computeBoundingBox();
+  geometry.computeBoundingSphere();
+  return geometry;
+}
+function createThreeObject(decoded, options = {}) {
+  const geometry = createThreeGeometry(decoded);
+  const chosen = options.materialFactory ? options.materialFactory(decoded) : decoded.sections.length > 1 ? decoded.sections.map(() => fallbackMaterial()) : fallbackMaterial();
+  const material = Array.isArray(chosen) ? [...chosen] : chosen;
+  const mesh = new Mesh(geometry, material);
+  mesh.name = decoded.metadata.objectPath.split("/").at(-1) || "UnrealStaticMesh";
+  mesh.userData.unreal = {
+    ...decoded.metadata,
+    ...decoded.unreal,
+    sections: decoded.sections,
+    sourceStats: decoded.sourceStats,
+    directUasset: true
+  };
+  return mesh;
+}
+var UAssetLoader = class extends Loader {
+  options;
+  constructor(manager, options = {}) {
+    super(manager);
+    this.options = options;
+  }
+  parse(data) {
+    return createThreeObject(parseUAssetStaticMesh(data, this.options.parse), this.options.three);
+  }
+  load(url, onLoad, onProgress, onError) {
+    const fileLoader = new FileLoader(this.manager);
+    fileLoader.setPath(this.path);
+    fileLoader.setRequestHeader(this.requestHeader);
+    fileLoader.setWithCredentials(this.withCredentials);
+    fileLoader.setResponseType("arraybuffer");
+    fileLoader.load(
+      url,
+      (data) => {
+        try {
+          if (!(data instanceof ArrayBuffer)) {
+            throw new TypeError("Expected FileLoader to return an ArrayBuffer");
+          }
+          onLoad(this.parse(data));
+        } catch (error) {
+          onError?.(error);
+        }
+      },
+      onProgress,
+      onError
+    );
+    return this;
+  }
+};
+
+export { BULK_DATA_FLAG, COMPRESSED_BUFFER_MAGIC, COMPRESSION_METHOD, PACKAGE_FILE_TAG, UAssetError, UAssetLoader, createThreeGeometry, createThreeObject, decompressBulkData, decompressCompressedBuffer, findBulkDataHeaders, findCompressedBufferOffsets, findMeshDescriptionOffsets, findRawMeshBlobs, looksLikeMeshDescription, looksLikeMeshDescriptionUe4, parseBulkDataHeader, parseCompressedBuffer, parseMeshDescription, parseMeshDescriptionUe4, parseRawMesh, parseUAssetStaticMesh, readPackageLayout, readPackageSummary, resolveBulkDataPayload };