minidraco 0.6.0 → 0.7.0

package/dist/index.js

@@ -1,35 +1,20 @@
 // src/decoder/core/DracoTypes.ts
-var DataType = {
-  INVALID: 0,
-  INT8: 1,
-  UINT8: 2,
-  INT16: 3,
-  UINT16: 4,
-  INT32: 5,
-  UINT32: 6,
-  INT64: 7,
-  UINT64: 8,
-  FLOAT32: 9,
-  FLOAT64: 10,
-  BOOL: 11,
-  TYPES_COUNT: 12
-};
 function dataTypeLength(dt) {
   switch (dt) {
-    case DataType.INT8:
-    case DataType.UINT8:
-    case DataType.BOOL:
+    case 1 /* INT8 */:
+    case 2 /* UINT8 */:
+    case 11 /* BOOL */:
       return 1;
-    case DataType.INT16:
-    case DataType.UINT16:
+    case 3 /* INT16 */:
+    case 4 /* UINT16 */:
       return 2;
-    case DataType.INT32:
-    case DataType.UINT32:
-    case DataType.FLOAT32:
+    case 5 /* INT32 */:
+    case 6 /* UINT32 */:
+    case 9 /* FLOAT32 */:
       return 4;
-    case DataType.INT64:
-    case DataType.UINT64:
-    case DataType.FLOAT64:
+    case 7 /* INT64 */:
+    case 8 /* UINT64 */:
+    case 10 /* FLOAT64 */:
       return 8;
     default:
       return -1;
@@ -47,73 +32,73 @@ var Type = {
   NAMED_ATTRIBUTES_COUNT: 5
 };
 var GeometryAttribute = class {
-  d = null;
-  A = 1;
-  T = DataType.FLOAT32;
-  Ga = false;
-  K = 0;
-  L = 0;
-  ta = Type.INVALID;
-  ua = 0;
+  c = null;
+  w = 1;
+  L = 9 /* FLOAT32 */;
+  Qa = false;
+  M = 0;
+  N = 0;
+  Aa = Type.INVALID;
+  Ba = 0;
   init(attributeType, buffer, numComponents, dataType, normalized, byteStride, byteOffset) {
-    this.d = buffer;
-    this.A = numComponents;
-    this.T = dataType;
-    this.Ga = normalized;
-    this.K = byteStride;
-    this.L = byteOffset;
-    this.ta = attributeType;
+    this.c = buffer;
+    this.w = numComponents;
+    this.L = dataType;
+    this.Qa = normalized;
+    this.M = byteStride;
+    this.N = byteOffset;
+    this.Aa = attributeType;
   }
   resetBuffer(buffer, byteStride, byteOffset) {
-    this.d = buffer;
-    this.K = byteStride;
-    this.L = byteOffset;
+    this.c = buffer;
+    this.M = byteStride;
+    this.N = byteOffset;
   }
   get attributeType() {
-    return this.ta;
+    return this.Aa;
   }
   get dataType() {
-    return this.T;
+    return this.L;
   }
   get numComponents() {
-    return this.A;
+    return this.w;
   }
   get buffer() {
-    return this.d;
+    return this.c;
   }
   get byteStride() {
-    return this.K;
+    return this.M;
   }
   get byteOffset() {
-    return this.L;
+    return this.N;
   }
   get uniqueId() {
-    return this.ua;
+    return this.Ba;
   }
   set uniqueId(id) {
-    this.ua = id;
+    this.Ba = id;
   }
 };
 
 // src/decoder/point_cloud/PointCloud.ts
 var NAMED_ATTRIBUTES_COUNT = 8;
 var PointCloud = class {
-  num_points_ = 0;
+  kb = 0;
   attributes_ = [];
   // named_attribute_index_[type] = [att_id, ...], one list per named type.
-  named_attribute_index_ = [[], [], [], [], [], [], [], []];
+  Ra = [[], [], [], [], [], [], [], []];
   numNamedAttributes(type) {
     if (type < 0 || type >= NAMED_ATTRIBUTES_COUNT) {
       return 0;
     }
-    return this.named_attribute_index_[type].length;
+    return this.Ra[type].length;
   }
   getNamedAttributeId(type, i) {
     if (i === void 0) i = 0;
     if (this.numNamedAttributes(type) <= i) {
       return -1;
     }
-    return this.named_attribute_index_[type][i];
+    return this.Ra[type][i];
   }
   getNamedAttribute(type, i) {
     if (i === void 0) i = 0;
@@ -153,31 +138,26 @@ var PointCloud = class {
       this.attributes_.push(null);
     }
     if (pa.attributeType < NAMED_ATTRIBUTES_COUNT) {
-      this.named_attribute_index_[pa.attributeType].push(attId);
+      this.Ra[pa.attributeType].push(attId);
     }
     pa.uniqueId = attId;
     this.attributes_[attId] = pa;
   }
   numPoints() {
-    return this.num_points_;
+    return this.kb;
   }
   setNumPoints(num) {
-    this.num_points_ = num;
+    this.kb = num;
   }
 };
 
 // src/decoder/mesh/Mesh.ts
-var MeshAttributeElementType = {
-  MESH_VERTEX_ATTRIBUTE: 0,
-  MESH_CORNER_ATTRIBUTE: 1,
-  MESH_FACE_ATTRIBUTE: 2
-};
 var Mesh = class extends PointCloud {
   // Flat Int32Array, 3 point indices per face, for cache locality and to avoid
   // a per-face allocation. faces_[3*f + c] is corner c of face f; corner index
   // ci maps directly to faces_[ci].
   faces_ = new Int32Array(0);
-  numFaces_ = 0;
+  lb = 0;
   // Sizes faces_ to hold numFaces faces. Called once per decode, before any
   // face index is written (edgebreaker: _assignPointsToCorners; sequential:
   // decodeConnectivity), so the buffer is allocated exactly here — the
@@ -189,10 +169,42 @@ var Mesh = class extends PointCloud {
       grown.set(this.faces_);
       this.faces_ = grown;
     }
-    this.numFaces_ = numFaces;
+    this.lb = numFaces;
   }
   numFaces() {
-    return this.numFaces_;
+    return this.lb;
+  }
+};
+
+// src/decoder/core/DataBuffer.ts
+var DataBuffer = class {
+  n = new Uint8Array(0);
+  // Resizes to `size` bytes (contents preserved); when `data` is given, grows
+  // as needed and copies its first `size` bytes in.
+  update(data, size) {
+    if (data === null) {
+      this.mb(size);
+      return;
+    }
+    if (size > this.n.length) {
+      this.mb(size);
+    }
+    this.n.set(data.length === size ? data : data.subarray(0, size));
+  }
+  // The caller passes a Uint8Array of exactly dataSize bytes in the common
+  // case; avoid allocating a wrapper view per value (dominates storage time /
+  // GC pressure).
+  write(bytePos, inArray, dataSize) {
+    this.n.set(inArray.length === dataSize ? inArray : inArray.subarray(0, dataSize), bytePos);
+  }
+  get data() {
+    return this.n;
+  }
+  mb(newSize) {
+    if (newSize === this.n.length) return;
+    const newData = new Uint8Array(newSize);
+    newData.set(this.n.subarray(0, Math.min(this.n.length, newSize)));
+    this.n = newData;
   }
 };
 
@@ -277,155 +289,140 @@ var releaseScratch = () => {
   borrowedUint8.length = 0;
 };
 
-// src/decoder/core/DataBuffer.ts
-var DataBuffer = class {
-  l = new Uint8Array(0);
-  // Resizes to `size` bytes (contents preserved); when `data` is given, grows
-  // as needed and copies its first `size` bytes in.
-  update(data, size) {
-    if (data === null) {
-      this.$a(size);
-      return;
-    }
-    if (size > this.l.length) {
-      this.$a(size);
-    }
-    this.l.set(data.length === size ? data : data.subarray(0, size));
-  }
-  // Replaces the contents with a decode-scoped scratch buffer of exactly
-  // `size` bytes; the previous contents are dropped and the new ones are
-  // arbitrary, so every byte must be written before it is read. Only for
-  // buffers that never outlive the decode (see ScratchArena) — the portable
-  // attributes the integer decoders build and discard per attribute are the
-  // one caller, and their per-primitive allocation showed up in profiles.
-  adoptScratch(size) {
-    this.l = scratchUint8(size);
-  }
-  // The caller passes a Uint8Array of exactly dataSize bytes in the common
-  // case; avoid allocating a wrapper view per value (dominates storage time /
-  // GC pressure).
-  write(bytePos, inArray, dataSize) {
-    this.l.set(inArray.length === dataSize ? inArray : inArray.subarray(0, dataSize), bytePos);
-  }
-  get data() {
-    return this.l;
-  }
-  $a(newSize) {
-    if (newSize === this.l.length) return;
-    const newData = new Uint8Array(newSize);
-    newData.set(this.l.subarray(0, Math.min(this.l.length, newSize)));
-    this.l = newData;
-  }
-};
-
 // src/decoder/attributes/PointAttribute.ts
 function viewCtorFor(dt) {
   switch (dt) {
-    case DataType.INT8:
+    case 1 /* INT8 */:
       return Int8Array;
-    case DataType.UINT8:
+    case 2 /* UINT8 */:
       return Uint8Array;
-    case DataType.INT16:
+    case 3 /* INT16 */:
       return Int16Array;
-    case DataType.UINT16:
+    case 4 /* UINT16 */:
       return Uint16Array;
-    case DataType.INT32:
+    case 5 /* INT32 */:
       return Int32Array;
-    case DataType.UINT32:
+    case 6 /* UINT32 */:
       return Uint32Array;
-    case DataType.FLOAT32:
+    case 9 /* FLOAT32 */:
       return Float32Array;
-    case DataType.FLOAT64:
+    case 10 /* FLOAT64 */:
       return Float64Array;
     default:
       return null;
   }
 }
+var LAZY_NONE = 0;
+var LAZY_INTEGER = 1;
+var LAZY_QUANTIZED = 2;
+var LAZY_OCTAHEDRON = 3;
 var PointAttribute = class extends GeometryAttribute {
-  G = false;
-  Ha = 0;
-  H = [];
-  v = null;
-  zb = null;
+  A = false;
+  Sa = 0;
+  B = [];
+  W = null;
   // Lazily-created cached typed-array view over the attribute buffer, keyed
   // on (constructor, underlying ArrayBuffer). An attribute only ever reads
   // through the one view type its data type dictates.
-  ab = null;
-  bb = null;
-  cb = null;
+  nb = null;
+  ob = null;
+  pb = null;
+  // Deferred inverse transform. The integer attribute decoders leave their
+  // decoded values here as int32 -- quantized floats, octahedral normals or
+  // plain integers -- with the transform's parameters, and extractTo applies
+  // the transform while gathering the values into point order: one pass over
+  // the points instead of an inverse-transform pass into a per-value buffer
+  // followed by a gather from it, and no such buffer at all.
+  Ca = LAZY_NONE;
+  X = null;
+  qb = [];
+  Da = 0;
   constructor(geometryAttribute) {
     super();
     if (geometryAttribute instanceof GeometryAttribute) {
-      this.d = geometryAttribute.d;
-      this.A = geometryAttribute.A;
-      this.T = geometryAttribute.T;
-      this.Ga = geometryAttribute.Ga;
-      this.K = geometryAttribute.K;
+      this.c = geometryAttribute.c;
+      this.w = geometryAttribute.w;
       this.L = geometryAttribute.L;
-      this.ta = geometryAttribute.ta;
-      this.ua = geometryAttribute.ua;
+      this.Qa = geometryAttribute.Qa;
+      this.M = geometryAttribute.M;
+      this.N = geometryAttribute.N;
+      this.Aa = geometryAttribute.Aa;
+      this.Ba = geometryAttribute.Ba;
     }
   }
   // Intentionally shadows GeometryAttribute.init with a different signature (matches draco.js / C++ source).
   // @ts-expect-error -- signature intentionally differs from the base class, as in the source.
   init(attributeType, numComponents, dataType, normalized, numAttributeValues) {
-    this.v = new DataBuffer();
+    this.W = new DataBuffer();
     const byteStride = dataTypeLength(dataType) * numComponents;
-    super.init(attributeType, this.v, numComponents, dataType, normalized, byteStride, 0);
+    super.init(attributeType, this.W, numComponents, dataType, normalized, byteStride, 0);
     this.reset(numAttributeValues);
     this.setIdentityMapping();
   }
   reset(numAttributeValues) {
-    if (this.v === null) {
-      this.v = new DataBuffer();
+    if (this.W === null) {
+      this.W = new DataBuffer();
     }
     const entrySize = dataTypeLength(this.dataType) * this.numComponents;
-    this.v.update(null, numAttributeValues * entrySize);
-    this.resetBuffer(this.v, entrySize, 0);
-    this.Ha = numAttributeValues;
+    this.W.update(null, numAttributeValues * entrySize);
+    this.resetBuffer(this.W, entrySize, 0);
+    this.Sa = numAttributeValues;
     return true;
   }
-  // Like reset(), but backs the attribute with decode-scoped scratch memory.
-  // Only valid for attributes that never escape the decode and whose every
-  // byte is written before it is read (see DataBuffer.adoptScratch).
-  resetScratch(numAttributeValues) {
-    if (this.v === null) {
-      this.v = new DataBuffer();
-    }
-    const entrySize = dataTypeLength(this.dataType) * this.numComponents;
-    this.v.adoptScratch(numAttributeValues * entrySize);
-    this.resetBuffer(this.v, entrySize, 0);
-    this.Ha = numAttributeValues;
-    return true;
+  // Sizes the attribute without allocating storage, for the deferred
+  // transforms below (the values live in the decoder's portable attribute).
+  resetLazy(numAttributeValues) {
+    this.Sa = numAttributeValues;
+  }
+  // numValues decoded integers of the attribute's own integer type, stored as
+  // int32; extractTo converts them to the requested output type.
+  setLazyInteger(values) {
+    this.Ca = LAZY_INTEGER;
+    this.X = values;
+  }
+  // Quantized float values: value * delta + min per component (float32
+  // arithmetic, see _extractQuantized), as the C++ Dequantizer computes them.
+  setLazyQuantized(values, minValues, delta) {
+    this.Ca = LAZY_QUANTIZED;
+    this.X = values;
+    this.qb = minValues;
+    this.Da = delta;
+  }
+  // Octahedral normals: two quantized coordinates per value, dequantized by
+  // `scale` and turned into unit vectors (see _extractOctahedron).
+  setLazyOctahedron(values, scale) {
+    this.Ca = LAZY_OCTAHEDRON;
+    this.X = values;
+    this.Da = scale;
   }
   get size() {
-    return this.Ha;
+    return this.Sa;
   }
   mappedIndex(pointIndex) {
-    if (this.G) {
+    if (this.A) {
       return pointIndex;
     }
-    return this.H[pointIndex];
+    return this.B[pointIndex];
   }
   get isMappingIdentity() {
-    return this.G;
+    return this.A;
   }
   get indicesMapSize() {
-    if (this.G) {
+    if (this.A) {
       return 0;
     }
-    return this.H.length;
+    return this.B.length;
   }
   // Direct access to the explicit point->value index map (a Uint32Array after
   // any of the setExplicitMapping* calls). Lets hot mapping loops write
   // entries without a per-entry dispatch.
   get indicesMap() {
-    return this.H;
+    return this.B;
   }
   // Implicit mapping: point index equals attribute entry index.
   setIdentityMapping() {
-    this.G = true;
-    this.H = [];
+    this.A = true;
+    this.B = [];
   }
   // Explicit mapping without an invalid-index fill. Only for callers that
   // provably write every entry right away (the fill was ~4% of decode time on
@@ -435,80 +432,76 @@ var PointAttribute = class extends GeometryAttribute {
   // and avoids boxed-number storage; it is read once per point per attribute.
   // Must be UNSIGNED so the 0xFFFFFFFF invalid sentinel round-trips intact.
   setExplicitMappingUnfilled(numPoints) {
-    this.G = false;
-    this.H = new Uint32Array(numPoints);
+    this.A = false;
+    this.B = new Uint32Array(numPoints);
   }
   // Adopts an already-computed map, shared with other attributes of the same
   // mesh. The map must be treated as read-only from here on (reads go through
   // mappedIndex/extractTo).
   setExplicitMappingShared(map) {
-    this.G = false;
-    this.H = map;
+    this.A = false;
+    this.B = map;
   }
   // Like setExplicitMappingUnfilled, but from decode-scoped scratch. Only for
   // attributes that never escape the decode (see ScratchArena) -- the portable
   // attributes the sequential decoders build and discard.
   setExplicitMappingScratch(numPoints) {
-    this.G = false;
-    this.H = scratchUint32(numPoints);
-  }
-  setAttributeTransformData(transformData) {
-    this.zb = transformData;
+    this.A = false;
+    this.B = scratchUint32(numPoints);
   }
   // Cached typed-array view of the given type over the attribute buffer.
-  Ia(Ctor, bufData) {
-    if (this.ab !== Ctor || this.bb !== bufData.buffer) {
-      this.ab = Ctor;
-      this.bb = bufData.buffer;
-      this.cb = new Ctor(bufData.buffer);
-    }
-    return this.cb;
-  }
-  // Mirrors C++ PointAttribute::ConvertValue<T>(). Attribute buffers start at
-  // byteOffset 0 and entries are naturally aligned, so every type reads
-  // through a typed-array view instead of a per-component DataView dispatch.
+  rb(Ctor, bufData) {
+    if (this.nb !== Ctor || this.ob !== bufData.buffer) {
+      this.nb = Ctor;
+      this.ob = bufData.buffer;
+      this.pb = new Ctor(bufData.buffer);
+    }
+    return this.pb;
+  }
+  // Mirrors C++ PointAttribute::ConvertValue<T>() for buffer-backed
+  // attributes. Attribute buffers start at byteOffset 0 and entries are
+  // naturally aligned, so every type reads through a typed-array view instead
+  // of a per-component DataView dispatch.
   convertValue(attIndex, outVal) {
-    const bytePos = this.L + this.K * attIndex;
-    const bufData = this.d.data;
-    const dt = this.T;
-    const nc = this.A;
-    if (dt === DataType.INT32) {
-      const view2 = this.Ia(Int32Array, bufData);
-      const baseIndex2 = bufData.byteOffset + bytePos >> 2;
-      for (let i = 0; i < nc; ++i) {
-        outVal[i] = view2[baseIndex2 + i];
-      }
-      return;
-    }
-    const Ctor = viewCtorFor(dt);
+    const bufData = this.c.data;
+    const nc = this.w;
+    const Ctor = viewCtorFor(this.L);
     if (Ctor === null) {
-      for (let i = 0; i < nc; ++i) {
-        outVal[i] = 0;
-      }
+      for (let i = 0; i < nc; ++i) outVal[i] = 0;
       return;
     }
-    const view = this.Ia(Ctor, bufData);
-    const baseIndex = (bufData.byteOffset + bytePos) / Ctor.BYTES_PER_ELEMENT;
-    for (let i = 0; i < nc; ++i) {
-      outVal[i] = view[baseIndex + i];
-    }
+    const view = this.rb(Ctor, bufData);
+    const baseIndex = (bufData.byteOffset + this.N + this.M * attIndex) / Ctor.BYTES_PER_ELEMENT;
+    for (let i = 0; i < nc; ++i) outVal[i] = view[baseIndex + i];
   }
-  // Flat-array extraction of all values into one output typed array (avoids the
-  // per-point temp-array copy via cached typed-array views over the buffer).
+  // Flat-array extraction of all values into one output typed array, in point
+  // order (applying the deferred transform, if any, on the way).
   extractTo(OutputTypedArray, numPoints) {
-    const numComponents = this.A;
+    const numComponents = this.w;
     const array = new OutputTypedArray(numPoints * numComponents);
-    const Ctor = viewCtorFor(this.T);
-    if (this.d === null || numPoints === 0 || Ctor === null) {
+    if (numPoints === 0) {
+      return array;
+    }
+    const kind = this.Ca;
+    if (kind !== LAZY_NONE) {
+      if (this.X !== null) {
+        if (kind === LAZY_QUANTIZED) this.Sb(array, numPoints);
+        else if (kind === LAZY_OCTAHEDRON) this.Tb(array, numPoints);
+        else this.Ub(array, numPoints);
+      }
+      return array;
+    }
+    const Ctor = viewCtorFor(this.L);
+    if (this.c === null || Ctor === null) {
       return array;
     }
-    const bufData = this.d.data;
-    const isIdentity = this.G;
-    const indicesMap = this.H;
-    const srcView = this.Ia(Ctor, bufData);
+    const bufData = this.c.data;
+    const isIdentity = this.A;
+    const indicesMap = this.B;
+    const srcView = this.rb(Ctor, bufData);
     const shift = 31 - Math.clz32(Ctor.BYTES_PER_ELEMENT);
-    const srcStart = bufData.byteOffset + this.L >> shift;
-    const strideElements = this.K >> shift;
+    const srcStart = bufData.byteOffset + this.N >> shift;
+    const strideElements = this.M >> shift;
     if (isIdentity && strideElements === numComponents) {
       const srcEnd = srcStart + numPoints * numComponents;
       if (srcView.constructor === OutputTypedArray) {
@@ -516,59 +509,130 @@ var PointAttribute = class extends GeometryAttribute {
         return array;
       }
     }
-    if (isIdentity) {
-      let dst = 0;
-      for (let i = 0; i < numPoints; i++) {
-        const srcOffset = srcStart + i * strideElements;
-        for (let j = 0; j < numComponents; j++) {
-          array[dst + j] = srcView[srcOffset + j];
-        }
-        dst += numComponents;
-      }
-    } else if (numComponents === 3) {
-      let dst = 0;
-      for (let i = 0; i < numPoints; i++) {
-        const srcOffset = srcStart + indicesMap[i] * strideElements;
-        array[dst] = srcView[srcOffset];
-        array[dst + 1] = srcView[srcOffset + 1];
-        array[dst + 2] = srcView[srcOffset + 2];
-        dst += 3;
-      }
-    } else if (numComponents === 2) {
-      let dst = 0;
-      for (let i = 0; i < numPoints; i++) {
-        const srcOffset = srcStart + indicesMap[i] * strideElements;
-        array[dst] = srcView[srcOffset];
-        array[dst + 1] = srcView[srcOffset + 1];
-        dst += 2;
-      }
-    } else if (numComponents === 4) {
-      let dst = 0;
-      for (let i = 0; i < numPoints; i++) {
-        const srcOffset = srcStart + indicesMap[i] * strideElements;
-        array[dst] = srcView[srcOffset];
-        array[dst + 1] = srcView[srcOffset + 1];
-        array[dst + 2] = srcView[srcOffset + 2];
-        array[dst + 3] = srcView[srcOffset + 3];
-        dst += 4;
-      }
-    } else if (numComponents === 1) {
-      let dst = 0;
-      for (let i = 0; i < numPoints; i++) {
-        array[dst++] = srcView[srcStart + indicesMap[i] * strideElements];
-      }
-    } else {
-      let dst = 0;
-      for (let i = 0; i < numPoints; i++) {
-        const srcOffset = srcStart + indicesMap[i] * strideElements;
-        for (let j = 0; j < numComponents; j++) {
-          array[dst + j] = srcView[srcOffset + j];
-        }
-        dst += numComponents;
+    let dst = 0;
+    for (let i = 0; i < numPoints; i++) {
+      const srcOffset = srcStart + (isIdentity ? i : indicesMap[i]) * strideElements;
+      for (let j = 0; j < numComponents; j++) {
+        array[dst + j] = srcView[srcOffset + j];
       }
+      dst += numComponents;
     }
     return array;
   }
+  // The deferred transforms, each fused with the point-order gather. One
+  // function per transform so the engine tiers each up on its own complete
+  // type feedback (a single body for all three deoptimized once per newly
+  // seen kind, which made the first decodes of a session measurably slower).
+  // Every float step is rounded to float32 exactly where the C++ decoder's
+  // float arithmetic rounds (Dequantizer, OctahedronToolBox), so the values
+  // are bit-identical to the reference decoder whatever the output array type.
+  // Point -> value index; the identity mapping (sequential meshes) gets a
+  // plain iota so the loops carry no per-point branch.
+  Ta(numPoints) {
+    if (!this.A) return this.B;
+    const map = new Uint32Array(numPoints);
+    for (let p = 0; p < numPoints; ++p) map[p] = p;
+    return map;
+  }
+  // The C++ starts from static_cast<float>(value). An integer below 2^24 is
+  // exact as a float32 and its product with a float32 is exact as a double,
+  // so for such values `fround(value * scale)` is that float32 product
+  // without the (measurably costly) int-to-float32-to-double round trip per
+  // component. Larger values (quantization above 24 bits, never seen in
+  // practice) are rounded in place once here, after which the same holds.
+  sb() {
+    const values = this.X;
+    for (let i = 0; i < values.length; ++i) {
+      if (values[i] >= 16777216 || values[i] <= -16777216) {
+        for (let j = 0; j < values.length; ++j) values[j] = Math.fround(values[j]);
+        break;
+      }
+    }
+    return values;
+  }
+  // C++ Dequantizer: float(value) * delta + min, all in float32.
+  Sb(out, numPoints) {
+    const values = this.sb();
+    const map = this.Ta(numPoints);
+    const numComponents = this.w;
+    const fround = Math.fround;
+    const delta = this.Da;
+    const min = this.qb;
+    if (numComponents === 3) {
+      const m0 = min[0];
+      const m1 = min[1];
+      const m2 = min[2];
+      for (let p = 0, d = 0; p < numPoints; ++p, d += 3) {
+        const s = map[p] * 3;
+        out[d] = fround(fround(values[s] * delta) + m0);
+        out[d + 1] = fround(fround(values[s + 1] * delta) + m1);
+        out[d + 2] = fround(fround(values[s + 2] * delta) + m2);
+      }
+      return;
+    }
+    if (numComponents === 2) {
+      const m0 = min[0];
+      const m1 = min[1];
+      for (let p = 0, d = 0; p < numPoints; ++p, d += 2) {
+        const s = map[p] * 2;
+        out[d] = fround(fround(values[s] * delta) + m0);
+        out[d + 1] = fround(fround(values[s + 1] * delta) + m1);
+      }
+      return;
+    }
+    for (let p = 0, d = 0; p < numPoints; ++p) {
+      const s = map[p] * numComponents;
+      for (let c = 0; c < numComponents; ++c) {
+        out[d++] = fround(fround(values[s + c] * delta) + min[c]);
+      }
+    }
+  }
+  // OctahedronToolBox.QuantizedOctahedralCoordsToUnitVector, two quantized
+  // coordinates per value to one unit vector per point.
+  Tb(out, numPoints) {
+    const values = this.sb();
+    const map = this.Ta(numPoints);
+    const fround = Math.fround;
+    const scale = this.Da;
+    for (let p = 0, d = 0; p < numPoints; ++p, d += 3) {
+      const s = map[p] * 2;
+      let y = fround(fround(values[s] * scale) - 1);
+      let z = fround(fround(values[s + 1] * scale) - 1);
+      const x = fround(fround(1 - Math.abs(y)) - Math.abs(z));
+      let xOffset = -x;
+      if (xOffset < 0) xOffset = 0;
+      y = fround(y + (y < 0 ? xOffset : -xOffset));
+      z = fround(z + (z < 0 ? xOffset : -xOffset));
+      const normSquared = fround(fround(fround(x * x) + fround(y * y)) + fround(z * z));
+      if (normSquared < 1e-6) {
+        out[d] = 0;
+        out[d + 1] = 0;
+        out[d + 2] = 0;
+      } else {
+        const k = fround(1 / fround(Math.sqrt(normSquared)));
+        out[d] = fround(x * k);
+        out[d + 1] = fround(y * k);
+        out[d + 2] = fround(z * k);
+      }
+    }
+  }
+  // The int32 values wrap to the attribute's own integer type (as storing
+  // them into it would) before the output store converts them.
+  Ub(out, numPoints) {
+    const values = this.X;
+    const map = this.Ta(numPoints);
+    const numComponents = this.w;
+    const dt = this.L;
+    const shift = 32 - 8 * dataTypeLength(dt);
+    const signed = dt === 1 /* INT8 */ || dt === 3 /* INT16 */ || dt === 5 /* INT32 */;
+    for (let p = 0, d = 0; p < numPoints; ++p) {
+      const s = map[p] * numComponents;
+      for (let c = 0; c < numComponents; ++c) {
+        const v = values[s + c] << shift;
+        out[d++] = signed ? v >> shift : v >>> shift;
+      }
+    }
+  }
 };
 
 // src/decoder/core/VarintDecoding.ts
@@ -590,21 +654,21 @@ function decodeVarint(buffer) {
 
 // src/decoder/core/DecoderBuffer.ts
 var BitDecoder = class {
-  va = null;
+  Ea = null;
   o = 0;
-  da = 0;
+  ka = 0;
   reset(uint8Array, byteLength) {
-    this.va = uint8Array;
-    this.da = byteLength;
+    this.Ea = uint8Array;
+    this.ka = byteLength;
     this.o = 0;
   }
   getBits(nbits) {
     if (nbits > 32) return void 0;
-    const buf = this.va;
+    const buf = this.Ea;
     let off = this.o;
     const byteOffset = off >> 3;
     const bitShift = off & 7;
-    if (byteOffset + 4 < this.da) {
+    if (byteOffset + 4 < this.ka) {
       const val = (buf[byteOffset] | buf[byteOffset + 1] << 8 | buf[byteOffset + 2] << 16 | buf[byteOffset + 3] << 24) >>> 0;
       let result;
       if (nbits > 32 - bitShift) {
@@ -623,7 +687,7 @@ var BitDecoder = class {
     let currOff = off;
     while (bitsRead < nbits) {
       const bOff = currOff >> 3;
-      if (bOff >= this.da) return void 0;
+      if (bOff >= this.ka) return void 0;
       const bShift = currOff & 7;
       const bitsAvail = 8 - bShift;
       const bitsNeeded = nbits - bitsRead;
@@ -638,61 +702,49 @@ var BitDecoder = class {
   }
 };
 var DecoderBuffer = class {
-  l = null;
-  ea = null;
-  w = 0;
-  c = 0;
-  fa = new BitDecoder();
-  wa = false;
+  n = null;
+  Fa = null;
+  I = 0;
+  d = 0;
+  la = new BitDecoder();
+  Ga = false;
   init(data, dataSize = data.length) {
-    this.l = data;
-    this.ea = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    this.w = dataSize;
-    this.c = 0;
+    this.n = data;
+    this.Fa = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    this.I = dataSize;
+    this.d = 0;
   }
   // Typed little-endian reads.
   decodeUint8() {
-    if (this.c + 1 > this.w) return void 0;
-    const val = this.l[this.c];
-    this.c += 1;
-    return val;
-  }
-  decodeInt8() {
-    if (this.c + 1 > this.w) return void 0;
-    const val = this.ea.getInt8(this.c);
-    this.c += 1;
+    if (this.d + 1 > this.I) return void 0;
+    const val = this.n[this.d];
+    this.d += 1;
     return val;
   }
   decodeUint16() {
-    if (this.c + 2 > this.w) return void 0;
-    const val = this.ea.getUint16(this.c, true);
-    this.c += 2;
+    if (this.d + 2 > this.I) return void 0;
+    const val = this.Fa.getUint16(this.d, true);
+    this.d += 2;
     return val;
   }
   decodeInt32() {
-    if (this.c + 4 > this.w) return void 0;
-    const val = this.ea.getInt32(this.c, true);
-    this.c += 4;
+    if (this.d + 4 > this.I) return void 0;
+    const val = this.Fa.getInt32(this.d, true);
+    this.d += 4;
     return val;
   }
   decodeFloat32() {
-    if (this.c + 4 > this.w) return void 0;
-    const val = this.ea.getFloat32(this.c, true);
-    this.c += 4;
+    if (this.d + 4 > this.I) return void 0;
+    const val = this.Fa.getFloat32(this.d, true);
+    this.d += 4;
     return val;
   }
-  decodeBytes(size) {
-    if (this.c + size > this.w) return void 0;
-    const result = this.l.slice(this.c, this.c + size);
-    this.c += size;
-    return result;
-  }
-  // Zero-copy variant of decodeBytes: a view into the stream, only valid until
-  // the caller's next chance to mutate the buffer — copy out before keeping it.
+  // A view into the stream (no copy), only valid until the caller's next
+  // chance to mutate the buffer — copy out before keeping it.
   decodeBytesView(size) {
-    if (this.c + size > this.w) return void 0;
-    const result = this.l.subarray(this.c, this.c + size);
-    this.c += size;
+    if (this.d + size > this.I) return void 0;
+    const result = this.n.subarray(this.d, this.d + size);
+    this.d += size;
     return result;
   }
   // Only the 2.2+ layout (varint size prefix): older bitstreams are rejected
@@ -704,80 +756,39 @@ var DecoderBuffer = class {
       if (size === void 0) return void 0;
       outSize = size;
     }
-    this.wa = true;
-    this.fa.reset(this.l.subarray(this.c), this.w - this.c);
+    this.Ga = true;
+    this.la.reset(this.n.subarray(this.d), this.I - this.d);
     return outSize;
   }
   endBitDecoding() {
-    this.wa = false;
-    this.c += Math.ceil(this.fa.o / 8);
+    this.Ga = false;
+    this.d += Math.ceil(this.la.o / 8);
   }
   decodeLeastSignificantBits32(nbits) {
-    if (!this.wa) return void 0;
-    return this.fa.getBits(nbits);
+    if (!this.Ga) return void 0;
+    return this.la.getBits(nbits);
   }
   advance(bytes) {
-    this.c += bytes;
+    this.d += bytes;
   }
   get data() {
-    return this.l;
+    return this.n;
   }
   get dataHead() {
-    return this.l.subarray(this.c);
+    return this.n.subarray(this.d);
   }
   get remainingSize() {
-    return this.w - this.c;
+    return this.I - this.d;
   }
   get decodedSize() {
-    return this.c;
+    return this.d;
   }
   get bitDecoderActive() {
-    return this.wa;
+    return this.Ga;
   }
 };
 
 // src/decoder/compression/config/CompressionShared.ts
-var EncodedGeometryType = {
-  POINT_CLOUD: 0,
-  TRIANGULAR_MESH: 1
-};
-var MeshEncoderMethod = {
-  MESH_SEQUENTIAL_ENCODING: 0,
-  MESH_EDGEBREAKER_ENCODING: 1
-};
-var SequentialAttributeEncoderType = {
-  SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC: 0,
-  SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER: 1,
-  SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION: 2,
-  SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS: 3
-};
-var PredictionSchemeMethod = {
-  PREDICTION_NONE: -2,
-  MESH_PREDICTION_PARALLELOGRAM: 1,
-  MESH_PREDICTION_MULTI_PARALLELOGRAM: 2,
-  MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM: 4,
-  MESH_PREDICTION_TEX_COORDS_PORTABLE: 5,
-  MESH_PREDICTION_GEOMETRIC_NORMAL: 6,
-  NUM_PREDICTION_SCHEMES: 7
-};
-var PredictionSchemeTransformType = {
-  PREDICTION_TRANSFORM_NONE: -1,
-  PREDICTION_TRANSFORM_WRAP: 1,
-  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON: 2,
-  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED: 3,
-  NUM_PREDICTION_SCHEME_TRANSFORM_TYPES: 4
-};
-var MeshTraversalMethod = {
-  MESH_TRAVERSAL_DEPTH_FIRST: 0,
-  MESH_TRAVERSAL_PREDICTION_DEGREE: 1,
-  NUM_TRAVERSAL_METHODS: 2
-};
-var MeshEdgebreakerConnectivityEncodingMethod = {
-  MESH_EDGEBREAKER_STANDARD_ENCODING: 0,
-  MESH_EDGEBREAKER_PREDICTIVE_ENCODING: 1,
-  // Deprecated.
-  MESH_EDGEBREAKER_VALENCE_ENCODING: 2
-};
 var DracoHeader = class {
   versionMajor = 0;
   versionMinor = 0;
@@ -785,76 +796,72 @@ var DracoHeader = class {
   encoderMethod = 0;
   flags = 0;
 };
-var SymbolCodingMethod = {
-  SYMBOL_CODING_TAGGED: 0,
-  SYMBOL_CODING_RAW: 1
-};
 var METADATA_FLAG_MASK = 32768;
 
 // src/decoder/metadata/MetadataDecoder.ts
 var kMaxSubmetadataLevel = 1e3;
 var MetadataDecoder = class {
   constructor(buffer_) {
-    this.buffer_ = buffer_;
+    this.C = buffer_;
   }
   buffer_;
   // Skips per-attribute metadata followed by the geometry-level metadata.
   skipGeometryMetadata() {
-    const numAttMetadata = decodeVarint(this.buffer_);
+    const numAttMetadata = decodeVarint(this.C);
     if (numAttMetadata === void 0) {
       return false;
     }
     for (let i = 0; i < numAttMetadata; ++i) {
-      if (decodeVarint(this.buffer_) === void 0) {
+      if (decodeVarint(this.C) === void 0) {
         return false;
       }
-      if (!this.Ja(0)) {
+      if (!this.Ua(0)) {
         return false;
       }
     }
-    return this.Ja(0);
+    return this.Ua(0);
   }
   // Discards one metadata block (key-value entries plus nested sub-metadata).
   // Sub-blocks read depth-first in stream order, matching the C++ stack traversal.
-  Ja(level) {
+  Ua(level) {
     if (level > kMaxSubmetadataLevel) {
       return false;
     }
-    const numEntries = decodeVarint(this.buffer_);
+    const numEntries = decodeVarint(this.C);
     if (numEntries === void 0) {
       return false;
     }
     for (let i = 0; i < numEntries; ++i) {
-      const nameSkipped = this.db();
-      const dataSize = nameSkipped ? decodeVarint(this.buffer_) : void 0;
-      if (dataSize === void 0 || dataSize === 0 || !this.eb(dataSize)) {
+      const nameSkipped = this.tb();
+      const dataSize = nameSkipped ? decodeVarint(this.C) : void 0;
+      if (dataSize === void 0 || dataSize === 0 || !this.ub(dataSize)) {
         return false;
       }
     }
-    const numSubMetadata = decodeVarint(this.buffer_);
-    if (numSubMetadata === void 0 || numSubMetadata > this.buffer_.remainingSize) {
+    const numSubMetadata = decodeVarint(this.C);
+    if (numSubMetadata === void 0 || numSubMetadata > this.C.remainingSize) {
       return false;
     }
     for (let i = 0; i < numSubMetadata; ++i) {
-      if (!this.db() || !this.Ja(level + 1)) {
+      if (!this.tb() || !this.Ua(level + 1)) {
         return false;
       }
     }
     return true;
   }
   // Skips a name (uint8 length prefix followed by that many bytes).
-  db() {
-    const nameLen = this.buffer_.decodeUint8();
+  tb() {
+    const nameLen = this.C.decodeUint8();
     if (nameLen === void 0) {
       return false;
     }
-    return this.eb(nameLen);
+    return this.ub(nameLen);
   }
-  eb(size) {
-    if (size > this.buffer_.remainingSize) {
+  ub(size) {
+    if (size > this.C.remainingSize) {
       return false;
     }
-    this.buffer_.advance(size);
+    this.C.advance(size);
     return true;
   }
 };
@@ -924,12 +931,13 @@ var RAnsDecoder = class {
   // flat
   cumProbTable = null;
   // flat
-  // Short-stream mode (see ransBuildLookUpTable): no full-precision lut; a
+  // Coarse mode (see ransBuildLookUpTable): no full-precision lut; a
   // 256-entry bucket table narrows each lookup to a symbol range that a short
   // cumProb scan finishes. cumProbTable then carries one extra trailing entry
   // (== ransPrecision) so the scan needs no bounds check.
   coarse = false;
   bucketShift = 0;
+  // Uint16 unless the alphabet needs wider ids, so real streams keep one table type.
   bucketTable = null;
   // Stream state inlined (not a nested AnsDecoder) so the ransRead() hot loop
   // touches own props; initialized by ansReadInit.
@@ -989,47 +997,14 @@ var RAnsDecoder = class {
   }
   // Batch ransRead() into out[0..count): all fields hoisted to locals, state
   // written back once. Removes per-symbol property reads and call indirection.
-  // lutTable's element type varies per decoder (Uint8/16/32 by symbol count),
-  // which would make the hot lutTable[rem] access site polymorphic — dispatch
-  // once here so each loop body stays monomorphic on its concrete type. The
-  // three bodies are intentionally identical copies.
   decodeSymbols(out, count) {
     if (this.coarse) {
-      this.Ab(out, count);
+      this.Vb(out, count);
       return;
     }
-    const lutTable = this.lutTable;
-    if (lutTable instanceof Uint8Array) {
-      this.Bb(out, count, lutTable);
-    } else if (lutTable instanceof Uint16Array) {
-      this.Cb(out, count, lutTable);
-    } else {
-      this.Db(out, count, lutTable);
-    }
-  }
-  Bb(out, count, lutTable) {
-    const buf = this.buf;
-    const lRansBase = this.lRansBase;
-    const ransPrecisionBits = this.ransPrecisionBits;
-    const ransPrecisionMask = this.ransPrecisionMask;
-    const probTable = this.probTable;
-    const cumProbTable = this.cumProbTable;
-    let state = this.state;
-    let bufOffset = this.bufOffset;
-    const bufStart = this.bufStart;
-    for (let i = 0; i < count; ++i) {
-      while (state < lRansBase && bufOffset > bufStart) {
-        state = state << 8 | buf[--bufOffset];
-      }
-      const rem = state & ransPrecisionMask;
-      const symbol = lutTable[rem];
-      out[i] = symbol;
-      state = (state >>> ransPrecisionBits) * probTable[symbol] + rem - cumProbTable[symbol];
-    }
-    this.state = state;
-    this.bufOffset = bufOffset;
+    this.Wb(out, count, this.lutTable);
   }
-  Cb(out, count, lutTable) {
+  Wb(out, count, lutTable) {
     const buf = this.buf;
     const lRansBase = this.lRansBase;
     const ransPrecisionBits = this.ransPrecisionBits;
@@ -1053,7 +1028,7 @@ var RAnsDecoder = class {
   }
   // Short-stream loop: bucket table + cumProb scan instead of the full lut.
   // Same state arithmetic as the lut loops, so the output is identical.
-  Ab(out, count) {
+  Vb(out, count) {
     const buf = this.buf;
     const lRansBase = this.lRansBase;
     const ransPrecisionBits = this.ransPrecisionBits;
@@ -1078,28 +1053,6 @@ var RAnsDecoder = class {
     this.state = state;
     this.bufOffset = bufOffset;
   }
-  Db(out, count, lutTable) {
-    const buf = this.buf;
-    const lRansBase = this.lRansBase;
-    const ransPrecisionBits = this.ransPrecisionBits;
-    const ransPrecisionMask = this.ransPrecisionMask;
-    const probTable = this.probTable;
-    const cumProbTable = this.cumProbTable;
-    let state = this.state;
-    let bufOffset = this.bufOffset;
-    const bufStart = this.bufStart;
-    for (let i = 0; i < count; ++i) {
-      while (state < lRansBase && bufOffset > bufStart) {
-        state = state << 8 | buf[--bufOffset];
-      }
-      const rem = state & ransPrecisionMask;
-      const symbol = lutTable[rem];
-      out[i] = symbol;
-      state = (state >>> ransPrecisionBits) * probTable[symbol] + rem - cumProbTable[symbol];
-    }
-    this.state = state;
-    this.bufOffset = bufOffset;
-  }
   // Builds the decoding tables. Returns false on bad input data.
   //
   // expectedCount is how many symbols the caller will decode from this stream.
@@ -1109,10 +1062,13 @@ var RAnsDecoder = class {
   // get a coarse 256-entry bucket table (symbol at the start of each
   // precision/256-wide bucket) and finish each lookup with a scan of the
   // cumulative probabilities; long streams keep the exact lut, whose per-symbol
-  // cost is lower.
+  // cost is lower. The coarse tables also serve an alphabet wider than a
+  // Uint16 lut entry (raw symbol coding allows 2^18 symbols; no real file
+  // has been seen past 2^14), rather than keeping a Uint32 copy of every
+  // lut loop for it.
   ransBuildLookUpTable(tokenProbs, numSymbols, expectedCount = 2147483647) {
     const ransPrecision = this.ransPrecision;
-    const coarse = numSymbols <= 65535 && expectedCount * COARSE_STREAM_FACTOR < ransPrecision;
+    const coarse = numSymbols > 65536 || expectedCount * COARSE_STREAM_FACTOR < ransPrecision;
     this.coarse = coarse;
     const probTable = acquirePooled(Uint32Array, numSymbols);
     const cumProbTable = acquirePooled(Uint32Array, numSymbols + 1);
@@ -1135,7 +1091,7 @@ var RAnsDecoder = class {
       }
       cumProbTable[numSymbols] = ransPrecision;
       const bucketShift = this.ransPrecisionBits - COARSE_BUCKET_BITS;
-      const bucketTable = acquirePooled(Uint16Array, 1 << COARSE_BUCKET_BITS);
+      const bucketTable = numSymbols > 65536 ? acquirePooled(Uint32Array, 1 << COARSE_BUCKET_BITS) : acquirePooled(Uint16Array, 1 << COARSE_BUCKET_BITS);
       this.bucketShift = bucketShift;
       this.bucketTable = bucketTable;
       let symbol = 0;
@@ -1146,8 +1102,7 @@ var RAnsDecoder = class {
       }
       return true;
     }
-    const LutArray = numSymbols <= 256 ? Uint8Array : numSymbols <= 65536 ? Uint16Array : Uint32Array;
-    const lutTable = acquirePooled(LutArray, ransPrecision);
+    const lutTable = acquirePooled(Uint16Array, ransPrecision);
     this.lutTable = lutTable;
     let actProb = 0;
     for (let i = 0; i < numSymbols; ++i) {
@@ -1174,66 +1129,9 @@ var RAnsDecoder = class {
     return true;
   }
 };
-function ransDecodeSymbolsPairU8(a, outA, countA, b, outB, countB) {
-  const lutA = a.lutTable;
-  const lutB = b.lutTable;
-  const bufA = a.buf;
-  const bufB = b.buf;
-  const probA = a.probTable;
-  const probB = b.probTable;
-  const cumA = a.cumProbTable;
-  const cumB = b.cumProbTable;
-  const lBaseA = a.lRansBase;
-  const lBaseB = b.lRansBase;
-  const bitsA = a.ransPrecisionBits;
-  const bitsB = b.ransPrecisionBits;
-  const maskA = a.ransPrecisionMask;
-  const maskB = b.ransPrecisionMask;
-  const startA = a.bufStart;
-  const startB = b.bufStart;
-  let stateA = a.state;
-  let stateB = b.state;
-  let offA = a.bufOffset;
-  let offB = b.bufOffset;
-  const shared = countA < countB ? countA : countB;
-  for (let i = 0; i < shared; ++i) {
-    while (stateA < lBaseA && offA > startA) {
-      stateA = stateA << 8 | bufA[--offA];
-    }
-    while (stateB < lBaseB && offB > startB) {
-      stateB = stateB << 8 | bufB[--offB];
-    }
-    const remA = stateA & maskA;
-    const remB = stateB & maskB;
-    const symA = lutA[remA];
-    const symB = lutB[remB];
-    outA[i] = symA;
-    outB[i] = symB;
-    stateA = (stateA >>> bitsA) * probA[symA] + remA - cumA[symA];
-    stateB = (stateB >>> bitsB) * probB[symB] + remB - cumB[symB];
-  }
-  a.state = stateA;
-  a.bufOffset = offA;
-  b.state = stateB;
-  b.bufOffset = offB;
-  if (shared < countA) {
-    a.decodeSymbols(outA.subarray(shared), countA - shared);
-  }
-  if (shared < countB) {
-    b.decodeSymbols(outB.subarray(shared), countB - shared);
-  }
-}
 function ransDecodeSymbolsPair(a, outA, countA, b, outB, countB) {
-  const lutA = a.lutTable;
-  const lutB = b.lutTable;
-  if (lutA instanceof Uint8Array && lutB instanceof Uint8Array) {
-    ransDecodeSymbolsPairU8(a, outA, countA, b, outB, countB);
-  } else if (lutA instanceof Uint16Array && lutB instanceof Uint16Array) {
+  if (!a.coarse && !b.coarse) {
     ransDecodeSymbolsPairU16(a, outA, countA, b, outB, countB);
-  } else if (lutA instanceof Uint8Array && lutB instanceof Uint16Array) {
-    ransDecodeSymbolsPairU8U16(a, outA, countA, b, outB, countB);
-  } else if (lutA instanceof Uint16Array && lutB instanceof Uint8Array) {
-    ransDecodeSymbolsPairU8U16(b, outB, countB, a, outA, countA);
   } else {
     a.decodeSymbols(outA, countA);
     b.decodeSymbols(outB, countB);
@@ -1288,56 +1186,7 @@ function ransDecodeSymbolsPairU16(a, outA, countA, b, outB, countB) {
     b.decodeSymbols(outB.subarray(shared), countB - shared);
   }
 }
-function ransDecodeSymbolsPairU8U16(a, outA, countA, b, outB, countB) {
-  const lutA = a.lutTable;
-  const lutB = b.lutTable;
-  const bufA = a.buf;
-  const bufB = b.buf;
-  const probA = a.probTable;
-  const probB = b.probTable;
-  const cumA = a.cumProbTable;
-  const cumB = b.cumProbTable;
-  const lBaseA = a.lRansBase;
-  const lBaseB = b.lRansBase;
-  const bitsA = a.ransPrecisionBits;
-  const bitsB = b.ransPrecisionBits;
-  const maskA = a.ransPrecisionMask;
-  const maskB = b.ransPrecisionMask;
-  const startA = a.bufStart;
-  const startB = b.bufStart;
-  let stateA = a.state;
-  let stateB = b.state;
-  let offA = a.bufOffset;
-  let offB = b.bufOffset;
-  const shared = countA < countB ? countA : countB;
-  for (let i = 0; i < shared; ++i) {
-    while (stateA < lBaseA && offA > startA) {
-      stateA = stateA << 8 | bufA[--offA];
-    }
-    while (stateB < lBaseB && offB > startB) {
-      stateB = stateB << 8 | bufB[--offB];
-    }
-    const remA = stateA & maskA;
-    const remB = stateB & maskB;
-    const symA = lutA[remA];
-    const symB = lutB[remB];
-    outA[i] = symA;
-    outB[i] = symB;
-    stateA = (stateA >>> bitsA) * probA[symA] + remA - cumA[symA];
-    stateB = (stateB >>> bitsB) * probB[symB] + remB - cumB[symB];
-  }
-  a.state = stateA;
-  a.bufOffset = offA;
-  b.state = stateB;
-  b.bufOffset = offB;
-  if (shared < countA) {
-    a.decodeSymbols(outA.subarray(shared), countA - shared);
-  }
-  if (shared < countB) {
-    b.decodeSymbols(outB.subarray(shared), countB - shared);
-  }
-}
-function ransDecodeSymbolsTrioU8(a, outA, countA, b, outB, countB, c, outC, countC) {
+function ransDecodeSymbolsTrioU16(a, outA, countA, b, outB, countB, c, outC, countC) {
   const lutA = a.lutTable;
   const lutB = b.lutTable;
   const lutC = c.lutTable;
@@ -1407,7 +1256,7 @@ function ransDecodeSymbolsTrioU8(a, outA, countA, b, outB, countB, c, outC, coun
   if (restB > 0) tails.push([b, outB.subarray(shared), restB]);
   if (restC > 0) tails.push([c, outC.subarray(shared), restC]);
   if (tails.length === 2) {
-    ransDecodeSymbolsPairU8(tails[0][0], tails[0][1], tails[0][2], tails[1][0], tails[1][1], tails[1][2]);
+    ransDecodeSymbolsPairU16(tails[0][0], tails[0][1], tails[0][2], tails[1][0], tails[1][1], tails[1][2]);
   } else {
     for (const [decoder, out, count] of tails) {
       decoder.decodeSymbols(out, count);
@@ -1417,14 +1266,14 @@ function ransDecodeSymbolsTrioU8(a, outA, countA, b, outB, countB, c, outC, coun
 
 // src/decoder/compression/point_cloud/PointCloudDecoder.ts
 var PointCloudDecoder = class {
-  M = null;
-  d = null;
-  r = [];
-  xa = [];
+  O = null;
+  c = null;
+  s = [];
+  Ha = [];
   // Returns an error message, or '' on success (outHeader is then populated).
   static decodeHeader(buffer, outHeader) {
     const kIoErrorMsg = "Failed to parse Draco header.";
-    const bytes = buffer.decodeBytes(5);
+    const bytes = buffer.decodeBytesView(5);
     if (bytes === void 0) {
       return kIoErrorMsg;
     }
@@ -1449,12 +1298,12 @@ var PointCloudDecoder = class {
   }
   // Main entry point, given the already-parsed header (see Decode.ts).
   decode(header, inBuffer, outPointCloud) {
-    this.d = inBuffer;
-    this.M = outPointCloud;
+    this.c = inBuffer;
+    this.O = outPointCloud;
     if (header.versionMajor !== 2 || header.versionMinor !== 2) {
       return "Unsupported bitstream version (Draco 2.2 meshes only).";
     }
-    if (header.flags & METADATA_FLAG_MASK && !new MetadataDecoder(this.d).skipGeometryMetadata()) {
+    if (header.flags & METADATA_FLAG_MASK && !new MetadataDecoder(this.c).skipGeometryMetadata()) {
       return "Failed to decode metadata.";
     }
     if (!this.initializeDecoder()) {
@@ -1472,30 +1321,30 @@ var PointCloudDecoder = class {
     if (attDecoderId < 0) {
       return false;
     }
-    while (this.r.length <= attDecoderId) {
-      this.r.push(null);
+    while (this.s.length <= attDecoderId) {
+      this.s.push(null);
     }
-    this.r[attDecoderId] = decoder;
+    this.s[attDecoderId] = decoder;
     return true;
   }
   getPortableAttribute(parentAttId) {
-    if (parentAttId < 0 || parentAttId >= this.M.numAttributes()) {
+    if (parentAttId < 0 || parentAttId >= this.O.numAttributes()) {
       return null;
     }
-    const parentAttDecoderId = this.xa[parentAttId];
-    return this.r[parentAttDecoderId].getPortableAttribute(parentAttId);
+    const parentAttDecoderId = this.Ha[parentAttId];
+    return this.s[parentAttDecoderId].getPortableAttribute(parentAttId);
   }
   attributesDecoder(decId) {
-    return this.r[decId];
+    return this.s[decId];
   }
   numAttributesDecoders() {
-    return this.r.length;
+    return this.s.length;
   }
   pointCloud() {
-    return this.M;
+    return this.O;
   }
   buffer() {
-    return this.d;
+    return this.c;
   }
   // -- Protected virtual methods (override in subclasses) --
   initializeDecoder() {
@@ -1509,7 +1358,7 @@ var PointCloudDecoder = class {
     return true;
   }
   decodePointAttributes() {
-    const numAttributesDecoders = this.d.decodeUint8();
+    const numAttributesDecoders = this.c.decodeUint8();
     if (numAttributesDecoders === void 0) {
       return false;
     }
@@ -1518,32 +1367,32 @@ var PointCloudDecoder = class {
         return false;
       }
     }
-    for (let i = 0; i < this.r.length; ++i) {
-      if (!this.r[i].init(this, this.M)) {
+    for (let i = 0; i < this.s.length; ++i) {
+      if (!this.s[i].init(this, this.O)) {
         return false;
       }
     }
     for (let i = 0; i < numAttributesDecoders; ++i) {
-      if (!this.r[i].decodeAttributesDecoderData(this.d)) {
+      if (!this.s[i].decodeAttributesDecoderData(this.c)) {
         return false;
       }
     }
     for (let i = 0; i < numAttributesDecoders; ++i) {
-      const numAttributes = this.r[i].getNumAttributes();
+      const numAttributes = this.s[i].getNumAttributes();
       for (let j = 0; j < numAttributes; ++j) {
-        const attId = this.r[i].getAttributeId(j);
-        while (this.xa.length <= attId) {
-          this.xa.push(0);
+        const attId = this.s[i].getAttributeId(j);
+        while (this.Ha.length <= attId) {
+          this.Ha.push(0);
         }
-        this.xa[attId] = i;
+        this.Ha[attId] = i;
       }
     }
     return this.decodeAllAttributes();
   }
   decodeAllAttributes() {
-    const decoders = this.r;
+    const decoders = this.s;
     for (let i2 = 0; i2 < decoders.length; i2++) {
-      if (!decoders[i2].decodeAttributesParse(this.d)) {
+      if (!decoders[i2].decodeAttributesParse(this.c)) {
         return false;
       }
     }
@@ -1575,10 +1424,10 @@ var PointCloudDecoder = class {
 
 // src/decoder/compression/mesh/MeshDecoder.ts
 var MeshDecoder = class extends PointCloudDecoder {
-  B = null;
+  D = null;
   // Returns an error message, or '' on success.
   decodeMesh(header, inBuffer, outMesh) {
-    this.B = outMesh;
+    this.D = outMesh;
     return this.decode(header, inBuffer, outMesh);
   }
   // Connectivity accessors used by the mesh prediction schemes; the sequential
@@ -1593,7 +1442,7 @@ var MeshDecoder = class extends PointCloudDecoder {
     return null;
   }
   mesh() {
-    return this.B;
+    return this.D;
   }
   decodeGeometryData() {
     return this.decodeConnectivity() && super.decodeGeometryData();
@@ -1604,60 +1453,60 @@ var MeshDecoder = class extends PointCloudDecoder {
 var kInvalidCornerIndex = -1;
 var kInvalidVertexIndex = -1;
 var MeshAttributeCornerTable = class {
-  is_edge_on_seam_ = [];
-  is_vertex_on_seam_ = [];
-  corner_to_vertex_map_ = [];
-  vertex_to_left_most_corner_map_ = [];
+  Y = [];
+  ma = [];
+  Z = [];
+  na = [];
   // Attribute-vertex count. C++ keeps a vertex -> attribute-entry map here, but
   // the decoder only ever reads its size, so track the count directly instead
   // of allocating an Int32Array per attribute corner table.
-  num_attribute_vertices_ = 0;
-  corner_table_ = null;
+  oa = 0;
+  t = null;
   // Lazily built; see oppositeCornerArray.
-  N = null;
+  P = null;
   // Every corner passed to addSeamEdge (may contain duplicates); lets
   // oppositeCornerArray patch seams without scanning every corner's flag.
   // Preallocated to its exact upper bound (2 per seam edge) by the caller via
   // reserveSeamEdges -- a plain array grown by push() was measurable on
   // seam-heavy files.
-  U = [];
-  O = 0;
+  _ = [];
+  Q = 0;
   initEmpty(table) {
     if (table === null) {
       return false;
     }
-    this.is_edge_on_seam_ = scratchUint8Zeroed(table.numCorners());
-    this.is_vertex_on_seam_ = scratchUint8Zeroed(table.numVertices());
-    this.corner_to_vertex_map_ = scratchInt32Filled(table.numCorners(), kInvalidVertexIndex);
-    this.num_attribute_vertices_ = 0;
-    this.vertex_to_left_most_corner_map_ = [];
-    this.N = null;
-    this.U = [];
-    this.O = 0;
-    this.corner_table_ = table;
+    this.Y = scratchUint8Zeroed(table.numCorners());
+    this.ma = scratchUint8Zeroed(table.numVertices());
+    this.Z = scratchInt32Filled(table.numCorners(), kInvalidVertexIndex);
+    this.oa = 0;
+    this.na = [];
+    this.P = null;
+    this._ = [];
+    this.Q = 0;
+    this.t = table;
     return true;
   }
   // Sizes the seam-corner list for numSeamEdges upcoming addSeamEdge calls
   // (each adds at most two corners). Decode-scoped scratch.
   reserveSeamEdges(numSeamEdges) {
-    this.U = scratchInt32(numSeamEdges * 2);
-    this.O = 0;
+    this._ = scratchInt32(numSeamEdges * 2);
+    this.Q = 0;
   }
   addSeamEdge(c) {
-    const cornerToVertex = this.corner_table_.cornerToVertexArray();
-    const oppositeCorners = this.corner_table_.oppositeCornerArray();
-    const isEdge = this.is_edge_on_seam_;
-    const isVert = this.is_vertex_on_seam_;
-    const seamCorners = this.U;
+    const cornerToVertex = this.t.cornerToVertexArray();
+    const oppositeCorners = this.t.oppositeCornerArray();
+    const isEdge = this.Y;
+    const isVert = this.ma;
+    const seamCorners = this._;
     isEdge[c] = 1;
-    seamCorners[this.O++] = c;
+    seamCorners[this.Q++] = c;
     let rem = c - (c / 3 | 0) * 3;
     isVert[cornerToVertex[rem === 2 ? c - 2 : c + 1]] = 1;
     isVert[cornerToVertex[rem === 0 ? c + 2 : c - 1]] = 1;
     const oppCorner = oppositeCorners[c];
     if (oppCorner !== kInvalidCornerIndex) {
       isEdge[oppCorner] = 1;
-      seamCorners[this.O++] = oppCorner;
+      seamCorners[this.Q++] = oppCorner;
       rem = oppCorner - (oppCorner / 3 | 0) * 3;
       isVert[cornerToVertex[rem === 2 ? oppCorner - 2 : oppCorner + 1]] = 1;
       isVert[cornerToVertex[rem === 0 ? oppCorner + 2 : oppCorner - 1]] = 1;
@@ -1668,23 +1517,23 @@ var MeshAttributeCornerTable = class {
   // over the per-vertex left-most corners here). leftMostMap is decode-scoped
   // scratch sized for at least numNewVertices entries.
   setRecomputedVertices(leftMostMap, numNewVertices) {
-    this.num_attribute_vertices_ = numNewVertices;
-    this.vertex_to_left_most_corner_map_ = leftMostMap.length === numNewVertices ? leftMostMap : leftMostMap.subarray(0, numNewVertices);
+    this.oa = numNewVertices;
+    this.na = leftMostMap.length === numNewVertices ? leftMostMap : leftMostMap.subarray(0, numNewVertices);
   }
   isCornerOppositeToSeamEdge(corner) {
-    return this.is_edge_on_seam_[corner];
+    return this.Y[corner];
   }
   opposite(corner) {
     if (corner === kInvalidCornerIndex || this.isCornerOppositeToSeamEdge(corner)) {
       return kInvalidCornerIndex;
     }
-    return this.corner_table_.opposite(corner);
+    return this.t.opposite(corner);
   }
   next(corner) {
-    return this.corner_table_.next(corner);
+    return this.t.next(corner);
   }
   previous(corner) {
-    return this.corner_table_.previous(corner);
+    return this.t.previous(corner);
   }
   swingRight(corner) {
     return this.previous(this.opposite(this.previous(corner)));
@@ -1693,68 +1542,68 @@ var MeshAttributeCornerTable = class {
     return this.next(this.opposite(this.next(corner)));
   }
   numVertices() {
-    return this.num_attribute_vertices_;
+    return this.oa;
   }
   numFaces() {
-    return this.corner_table_.numFaces();
+    return this.t.numFaces();
   }
   numCorners() {
-    return this.corner_table_.numCorners();
+    return this.t.numCorners();
   }
   // --- Flat-array accessors: let DepthFirstTraverser avoid per-corner dispatch. ---
   cornerToVertexArray() {
-    return this.corner_to_vertex_map_;
+    return this.Z;
   }
   // Seam-aware opposite corners (seam edges -> -1), matching opposite(). Cached on
   // first use; seams and connectivity are finalized before traversal, so it's stable.
   oppositeCornerArray() {
-    if (this.N === null) {
-      const nc = this.corner_table_.numCorners();
-      const base = this.corner_table_.oppositeCornerArray();
-      const seamCorners = this.U;
-      const numSeamCorners = this.O;
+    if (this.P === null) {
+      const nc = this.t.numCorners();
+      const base = this.t.oppositeCornerArray();
+      const seamCorners = this._;
+      const numSeamCorners = this.Q;
       if (numSeamCorners === 0) {
-        this.N = base;
+        this.P = base;
       } else {
         const eff = scratchInt32(nc);
         eff.set(base.length === nc ? base : base.subarray(0, nc));
         for (let i = 0; i < numSeamCorners; ++i) {
           eff[seamCorners[i]] = kInvalidCornerIndex;
         }
-        this.N = eff;
+        this.P = eff;
       }
     }
-    return this.N;
+    return this.P;
   }
   vertexLeftmostCornerArray() {
-    return this.vertex_to_left_most_corner_map_;
+    return this.na;
   }
   // Takes over another table's state wholesale. Only valid when both tables
   // were built from the same corner table and the same seam edges, in which
   // case every one of these is identical and read-only from here on.
   adoptFrom(other) {
-    this.corner_table_ = other.corner_table_;
-    this.is_edge_on_seam_ = other.is_edge_on_seam_;
-    this.is_vertex_on_seam_ = other.is_vertex_on_seam_;
-    this.corner_to_vertex_map_ = other.corner_to_vertex_map_;
-    this.num_attribute_vertices_ = other.num_attribute_vertices_;
-    this.vertex_to_left_most_corner_map_ = other.vertex_to_left_most_corner_map_;
-    this.N = other.N;
-    this.U = other.U;
-    this.O = other.O;
+    this.t = other.t;
+    this.Y = other.Y;
+    this.ma = other.ma;
+    this.Z = other.Z;
+    this.oa = other.oa;
+    this.na = other.na;
+    this.P = other.P;
+    this._ = other._;
+    this.Q = other.Q;
   }
 };
 
 // src/decoder/compression/attributes/AttributesDecoder.ts
 var AttributesDecoder = class {
-  ya = [];
+  Ia = [];
   // Inverse of _pointAttributeIds: point attribute id -> local id.
-  ga = [];
-  fb = null;
-  M = null;
+  pa = [];
+  vb = null;
+  O = null;
   init(decoder, pointCloud) {
-    this.fb = decoder;
-    this.M = pointCloud;
+    this.vb = decoder;
+    this.O = pointCloud;
     return true;
   }
   decodeAttributesDecoderData(buffer) {
@@ -1762,8 +1611,8 @@ var AttributesDecoder = class {
     if (numAttributes === void 0 || numAttributes === 0 || numAttributes > 5 * buffer.remainingSize) {
       return false;
     }
-    this.ya.length = numAttributes;
-    const pc = this.M;
+    this.Ia.length = numAttributes;
+    const pc = this.O;
     for (let i = 0; i < numAttributes; i++) {
       const attType = buffer.decodeUint8();
       if (attType === void 0) return false;
@@ -1776,7 +1625,7 @@ var AttributesDecoder = class {
       if (attType >= Type.NAMED_ATTRIBUTES_COUNT) {
         return false;
       }
-      if (dataType === DataType.INVALID || dataType >= DataType.TYPES_COUNT) {
+      if (dataType === 0 /* INVALID */ || dataType >= 12 /* TYPES_COUNT */) {
         return false;
       }
       if (numComponents === 0) {
@@ -1789,42 +1638,42 @@ var AttributesDecoder = class {
       ga.uniqueId = uniqueId;
       const attId = pc.addAttribute(new PointAttribute(ga));
       pc.attribute(attId).uniqueId = uniqueId;
-      this.ya[i] = attId;
-      while (this.ga.length <= attId) {
-        this.ga.push(-1);
+      this.Ia[i] = attId;
+      while (this.pa.length <= attId) {
+        this.pa.push(-1);
       }
-      this.ga[attId] = i;
+      this.pa[attId] = i;
     }
     return true;
   }
   getAttributeId(i) {
-    return this.ya[i];
+    return this.Ia[i];
   }
   getNumAttributes() {
-    return this.ya.length;
+    return this.Ia.length;
   }
   getDecoder() {
-    return this.fb;
+    return this.vb;
   }
   getLocalIdForPointAttribute(pointAttributeId) {
-    if (pointAttributeId >= this.ga.length) {
+    if (pointAttributeId >= this.pa.length) {
       return -1;
     }
-    return this.ga[pointAttributeId];
+    return this.pa[pointAttributeId];
   }
 };
 
 // src/decoder/compression/attributes/SequentialAttributeDecoder.ts
 var SequentialAttributeDecoder = class {
-  m = null;
-  C = null;
-  gb = -1;
+  l = null;
+  E = null;
+  wb = -1;
   // Decoded portable attribute (after lossless decoding).
-  I = null;
+  $ = null;
   init(decoder, attributeId) {
-    this.m = decoder;
-    this.C = decoder.pointCloud().attribute(attributeId);
-    this.gb = attributeId;
+    this.l = decoder;
+    this.E = decoder.pointCloud().attribute(attributeId);
+    this.wb = attributeId;
     return true;
   }
   // --- Two-phase decode ---
@@ -1835,14 +1684,20 @@ var SequentialAttributeDecoder = class {
   // stream simply do the whole decode in Parse (decodeValues); the defaults
   // below are theirs.
   decodePortableAttributeParse(pointIds, buffer) {
-    if (this.C.numComponents <= 0) {
+    if (this.E.numComponents <= 0) {
       return false;
     }
-    if (!this.C.reset(pointIds.length)) {
+    if (!this.xb(pointIds.length)) {
       return false;
     }
     return this.decodeValues(pointIds, buffer);
   }
+  // Sizes (and here allocates) the attribute's storage for numValues values;
+  // the integer decoders override it to skip the allocation, their values
+  // staying in the portable attribute (see PointAttribute.setLazyInteger).
+  xb(numValues) {
+    return this.E.reset(numValues);
+  }
   pendingSymbolStream() {
     return null;
   }
@@ -1858,35 +1713,35 @@ var SequentialAttributeDecoder = class {
     return true;
   }
   getPortableAttribute() {
-    if (!this.C.isMappingIdentity && this.I && this.I.isMappingIdentity) {
-      const size = this.C.indicesMapSize;
-      this.I.setExplicitMappingScratch(size);
-      const src = this.C.indicesMap;
-      const dst = this.I.indicesMap;
+    if (!this.E.isMappingIdentity && this.$ && this.$.isMappingIdentity) {
+      const size = this.E.indicesMapSize;
+      this.$.setExplicitMappingScratch(size);
+      const src = this.E.indicesMap;
+      const dst = this.$.indicesMap;
       if (src.length === size) {
         dst.set(src);
       } else {
         dst.set(src.subarray(0, size));
       }
     }
-    return this.I;
+    return this.$;
   }
   get attribute() {
-    return this.C;
+    return this.E;
   }
   get attributeId() {
-    return this.gb;
+    return this.wb;
   }
   get decoder() {
-    return this.m;
+    return this.l;
   }
   initPredictionScheme(ps) {
     for (let i = 0; i < ps.getNumParentAttributes(); i++) {
-      const attId = this.m.pointCloud().getNamedAttributeId(ps.getParentAttributeType(i));
+      const attId = this.l.pointCloud().getNamedAttributeId(ps.getParentAttributeType(i));
       if (attId === -1) {
         return false;
       }
-      const pa = this.m.getPortableAttribute(attId);
+      const pa = this.l.getPortableAttribute(attId);
       if (pa === null || !ps.setParentAttribute(pa)) {
         return false;
       }
@@ -1896,13 +1751,13 @@ var SequentialAttributeDecoder = class {
   // Decodes raw attribute values in their original format.
   decodeValues(pointIds, buffer) {
     const numValues = pointIds.length;
-    const entrySize = this.C.byteStride;
+    const entrySize = this.E.byteStride;
     const totalSize = numValues * entrySize;
     const valueData = buffer.decodeBytesView(totalSize);
     if (valueData === void 0) {
       return false;
     }
-    this.C.buffer.write(0, valueData, totalSize);
+    this.E.buffer.write(0, valueData, totalSize);
     return true;
   }
 };
@@ -1917,14 +1772,14 @@ function convertSymbolsToSignedInts(input, count, output) {
 
 // src/decoder/compression/entropy/RAnsSymbolDecoder.ts
 var RAnsSymbolDecoder = class {
-  numSymbols_ = 0;
-  ans_;
+  yb = 0;
+  m;
   constructor(uniqueSymbolsBitLength) {
     const unclamped = Math.trunc(3 * uniqueSymbolsBitLength / 2);
-    this.ans_ = new RAnsDecoder(unclamped < 12 ? 12 : unclamped > 20 ? 20 : unclamped);
+    this.m = new RAnsDecoder(unclamped < 12 ? 12 : unclamped > 20 ? 20 : unclamped);
   }
   get numSymbols() {
-    return this.numSymbols_;
+    return this.yb;
   }
   // Initialize the decoder and decode the probability table. expectedCount is
   // the number of symbols the caller will decode (lets short streams skip the
@@ -1932,7 +1787,7 @@ var RAnsSymbolDecoder = class {
   create(buffer, expectedCount = 2147483647) {
     const numSymbols = decodeVarint(buffer);
     if (numSymbols === void 0) return false;
-    this.numSymbols_ = numSymbols;
+    this.yb = numSymbols;
     if (Math.trunc(numSymbols / 64) > buffer.remainingSize) {
       return false;
     }
@@ -1965,7 +1820,7 @@ var RAnsSymbolDecoder = class {
       }
     }
     buffer.advance(pos - startPos);
-    return this.ans_.ransBuildLookUpTable(probabilityTable, numSymbols, expectedCount);
+    return this.m.ransBuildLookUpTable(probabilityTable, numSymbols, expectedCount);
   }
   // Starts decoding, advancing buffer past the encoded data.
   startDecoding(buffer) {
@@ -1976,10 +1831,10 @@ var RAnsSymbolDecoder = class {
     }
     const base = buffer.decodedSize;
     buffer.advance(Number(bytesEncoded));
-    return ansReadInit(this.ans_, buffer.data, base + Number(bytesEncoded), base, this.ans_.lRansBase, 4);
+    return ansReadInit(this.m, buffer.data, base + Number(bytesEncoded), base, this.m.lRansBase, 4);
   }
   endDecoding() {
-    this.ans_.readEnd();
+    this.m.readEnd();
   }
 };
 
@@ -1989,9 +1844,9 @@ function decodeSymbols(numValues, numComponents, srcBuffer, outValues) {
     return true;
   }
   const scheme = srcBuffer.decodeUint8();
-  if (scheme === SymbolCodingMethod.SYMBOL_CODING_TAGGED) {
+  if (scheme === 0 /* SYMBOL_CODING_TAGGED */) {
     return decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues);
-  } else if (scheme === SymbolCodingMethod.SYMBOL_CODING_RAW) {
+  } else if (scheme === 1 /* SYMBOL_CODING_RAW */) {
     return decodeRawSymbols(numValues, srcBuffer, outValues);
   }
   return false;
@@ -2007,11 +1862,11 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
   if (numValues > 0 && tagDecoder.numSymbols === 0) {
     return false;
   }
-  const tagAns = tagDecoder.ans_;
+  const tagAns = tagDecoder.m;
   srcBuffer.startBitDecoding(false);
-  const bd = srcBuffer.fa;
-  const buf = bd.va;
-  const byteLength = bd.da;
+  const bd = srcBuffer.la;
+  const buf = bd.Ea;
+  const byteLength = bd.ka;
   let bitOffset = bd.o;
   let valueId = 0;
   for (let i = 0; i < numValues; i += numComponents) {
@@ -2079,15 +1934,15 @@ function decodeRawSymbols(numValues, srcBuffer, outValues) {
   if (decoder === null) {
     return false;
   }
-  decoder.ans_.decodeSymbols(outValues, numValues);
+  decoder.m.decodeSymbols(outValues, numValues);
   decoder.endDecoding();
   return true;
 }
 
 // src/decoder/compression/bit_coders/RAnsBitDecoder.ts
 var RAnsBitDecoder = class {
-  ansDecoder_ = new AnsDecoder();
-  p_ = 0;
+  Va = new AnsDecoder();
+  Wa = 0;
   // ANS_P8_PRECISION - probZero, precomputed
   // Returns false when the data is invalid.
   startDecoding(sourceBuffer) {
@@ -2095,21 +1950,21 @@ var RAnsBitDecoder = class {
     if (probZero === void 0) {
       return false;
     }
-    this.p_ = ANS_P8_PRECISION - probZero;
+    this.Wa = ANS_P8_PRECISION - probZero;
     const sizeInBytes = decodeVarint(sourceBuffer);
     if (sizeInBytes === void 0 || sizeInBytes > sourceBuffer.remainingSize) {
       return false;
     }
     const base = sourceBuffer.decodedSize;
-    if (!ansReadInit(this.ansDecoder_, sourceBuffer.data, base + sizeInBytes, base, ANS_L_BASE, 3)) {
+    if (!ansReadInit(this.Va, sourceBuffer.data, base + sizeInBytes, base, ANS_L_BASE, 3)) {
       return false;
     }
     sourceBuffer.advance(sizeInBytes);
     return true;
   }
   decodeNextBit() {
-    const ans = this.ansDecoder_;
-    const p = this.p_;
+    const ans = this.Va;
+    const p = this.Wa;
     if (ans.state < ANS_L_BASE && ans.bufOffset > ans.bufStart) {
       ans.state = ans.state << 8 | ans.buf[--ans.bufOffset];
     }
@@ -2205,18 +2060,18 @@ var MAX_NUM_PARALLELOGRAMS = 4;
 var MeshPredictionSchemeConstrainedMultiParallelogramDecoder = class extends MeshPredictionSchemeDecoder {
   // Crease edges stored per context (number of available parallelograms),
   // one list per context up to MAX_NUM_PARALLELOGRAMS.
-  za = [[], [], [], []];
+  Ja = [[], [], [], []];
   decodePredictionData(buffer) {
     for (let i = 0; i < MAX_NUM_PARALLELOGRAMS; ++i) {
       const numFlags = decodeVarint(buffer);
       if (numFlags === void 0) return false;
       if (numFlags > this.b.cornerTable.numCorners()) return false;
       if (numFlags > 0) {
-        this.za[i] = new Array(numFlags);
+        this.Ja[i] = new Array(numFlags);
         const decoder = new RAnsBitDecoder();
         if (!decoder.startDecoding(buffer)) return false;
         for (let j = 0; j < numFlags; ++j) {
-          this.za[i][j] = decoder.decodeNextBit();
+          this.Ja[i][j] = decoder.decodeNextBit();
         }
         decoder.endDecoding();
       }
@@ -2275,8 +2130,8 @@ var MeshPredictionSchemeConstrainedMultiParallelogramDecoder = class extends Mes
         for (let i = 0; i < numParallelograms; ++i) {
           const context = numParallelograms - 1;
           const pos = isCreaseEdgePos[context]++;
-          if (this.za[context].length <= pos) return false;
-          const isCrease = this.za[context][pos];
+          if (this.Ja[context].length <= pos) return false;
+          const isCrease = this.Ja[context][pos];
           if (!isCrease) {
             ++numUsedParallelograms;
             for (let j = 0; j < numComponents; ++j) {
@@ -2314,23 +2169,23 @@ var MeshPredictionSchemeData = class {
 
 // src/decoder/compression/attributes/NormalCompressionUtils.ts
 var OctahedronToolBox = class {
-  x = -1;
-  ha = -1;
+  J = -1;
+  qa = -1;
   k = -1;
-  hb = 1;
+  Xb = 1;
   e = -1;
   // q: quantization bits, valid range 2..30.
   setQuantizationBits(q) {
     if (q < 2 || q > 30) return false;
-    this.x = q;
-    this.ha = (1 << q) - 1;
-    this.k = this.ha - 1;
-    this.hb = Math.fround(2 / Math.fround(this.k));
+    this.J = q;
+    this.qa = (1 << q) - 1;
+    this.k = this.qa - 1;
+    this.Xb = Math.fround(2 / Math.fround(this.k));
     this.e = this.k / 2 | 0;
     return true;
   }
   quantizationBits() {
-    return this.x;
+    return this.J;
   }
   // Canonicalizes edge points into consistent quadrants. Writes result into
   // out[0], out[1] (caller-owned reusable 2-element array).
@@ -2387,14 +2242,14 @@ var OctahedronToolBox = class {
     }
   }
   // The octahedral -> unit vector direction (quantizedOctahedralCoordsToUnitVector
-  // in the source) lives inlined in AttributeOctahedronTransform.inverseTransformAttribute.
+  // in the source) lives inlined in PointAttribute._extractOctahedron.
 };
 
 // src/decoder/compression/attributes/prediction_schemes/MeshPredictionSchemeGeometricNormalPredictorArea.ts
 var UPPER_BOUND = 1 << 29;
 function fillInt32PositionCache(cache, att, map, numEntries, tempPos) {
   const bufData = att.buffer && att.buffer.data;
-  if (att.dataType === DataType.INT32 && att.numComponents === 3 && bufData) {
+  if (att.dataType === 5 /* INT32 */ && att.numComponents === 3 && bufData) {
     const src = new Int32Array(bufData.buffer);
     const srcStart = bufData.byteOffset + att.byteOffset >> 2;
     const stride = att.byteStride >> 2;
@@ -2428,31 +2283,31 @@ function fillInt32PositionCache(cache, att, map, numEntries, tempPos) {
   }
 }
 var MeshPredictionSchemeGeometricNormalPredictorArea = class {
-  ia = null;
-  ja = null;
+  ra = null;
+  sa = null;
   b;
-  Ka = new Array(3);
-  ka = null;
+  Xa = new Array(3);
+  ta = null;
   // flat Int32 positions, indexed by data id
-  n = null;
-  ib = null;
+  p = null;
+  zb = null;
   // corner -> posCache offset, precomputed
   constructor(meshData) {
     this.b = meshData;
   }
   setPositionAttribute(positionAttribute) {
-    this.ia = positionAttribute;
+    this.ra = positionAttribute;
   }
   setEntryToPointIdMap(map) {
-    this.ja = map;
+    this.sa = map;
   }
   buildPositionCache(numEntries) {
     const posCache = scratchInt32(numEntries * 3);
-    fillInt32PositionCache(posCache, this.ia, this.ja, numEntries, this.Ka);
-    this.ka = posCache;
+    fillInt32PositionCache(posCache, this.ra, this.sa, numEntries, this.Xa);
+    this.ta = posCache;
     const table = this.b.cornerTable;
     const cornerToVertex = table.cornerToVertexArray();
-    this.n = table.oppositeCornerArray();
+    this.p = table.oppositeCornerArray();
     const vertexToDataMap = this.b.vertexToDataMap;
     const nc = cornerToVertex.length;
     const c2o = scratchInt32(nc);
@@ -2460,12 +2315,12 @@ var MeshPredictionSchemeGeometricNormalPredictorArea = class {
       const v = cornerToVertex[c];
       c2o[c] = v < 0 ? -1 : vertexToDataMap[v] * 3;
     }
-    this.ib = c2o;
+    this.zb = c2o;
   }
   computePredictedValue(cornerId, prediction) {
-    const oppositeCorners = this.n;
-    const cornerToOffset = this.ib;
-    const posCache = this.ka;
+    const oppositeCorners = this.p;
+    const cornerToOffset = this.zb;
+    const posCache = this.ta;
     const centerOffset = cornerToOffset[cornerId];
     const centX = posCache[centerOffset];
     const centY = posCache[centerOffset + 1];
@@ -2542,12 +2397,12 @@ var MeshPredictionSchemeGeometricNormalPredictorArea = class {
 // src/decoder/compression/attributes/prediction_schemes/MeshPredictionSchemeGeometricNormalDecoder.ts
 var GEOMETRY_ATTRIBUTE_POSITION = 0;
 var MeshPredictionSchemeGeometricNormalDecoder = class extends MeshPredictionSchemeDecoder {
-  p;
+  q;
   y = new OctahedronToolBox();
-  La = new RAnsBitDecoder();
+  Ya = new RAnsBitDecoder();
   constructor(transform, meshData) {
     super(transform, meshData);
-    this.p = new MeshPredictionSchemeGeometricNormalPredictorArea(meshData);
+    this.q = new MeshPredictionSchemeGeometricNormalPredictorArea(meshData);
   }
   getNumParentAttributes() {
     return 1;
@@ -2558,25 +2413,25 @@ var MeshPredictionSchemeGeometricNormalDecoder = class extends MeshPredictionSch
   setParentAttribute(att) {
     if (att.attributeType !== GEOMETRY_ATTRIBUTE_POSITION) return false;
     if (att.numComponents !== 3) return false;
-    this.p.setPositionAttribute(att);
+    this.q.setPositionAttribute(att);
     return true;
   }
   decodePredictionData(buffer) {
     if (!this.f.decodeTransformData(buffer)) return false;
-    return this.La.startDecoding(buffer);
+    return this.Ya.startDecoding(buffer);
   }
   computeOriginalValues(inCorr, outData, _size, _numComponents, entryToPointIdMap) {
     this.y.setQuantizationBits(this.f.quantizationBits());
-    this.p.setEntryToPointIdMap(entryToPointIdMap);
+    this.q.setEntryToPointIdMap(entryToPointIdMap);
     const cornerMapSize = this.b.dataToCornerMap.length;
-    this.p.buildPositionCache(cornerMapSize);
+    this.q.buildPositionCache(cornerMapSize);
     const predNormal3D = new Int32Array(3);
     const predNormalOct = new Int32Array(2);
     for (let dataId = 0; dataId < cornerMapSize; ++dataId) {
       const cornerId = this.b.dataToCornerMap[dataId];
-      this.p.computePredictedValue(cornerId, predNormal3D);
+      this.q.computePredictedValue(cornerId, predNormal3D);
       this.y.canonicalizeIntegerVector(predNormal3D);
-      if (this.La.decodeNextBit()) {
+      if (this.Ya.decodeNextBit()) {
         predNormal3D[0] = -predNormal3D[0];
         predNormal3D[1] = -predNormal3D[1];
         predNormal3D[2] = -predNormal3D[2];
@@ -2585,7 +2440,7 @@ var MeshPredictionSchemeGeometricNormalDecoder = class extends MeshPredictionSch
       const dataOffset = dataId * 2;
       this.f.computeOriginalValue(predNormalOct, 0, inCorr, dataOffset, outData, dataOffset);
     }
-    this.La.endDecoding();
+    this.Ya.endDecoding();
     return true;
   }
 };
@@ -2652,7 +2507,7 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   // zigzag form, unpacking each one inline.
   computeOriginalValuesZigzag(inCorr, outData, _size, numComponents, _entryToPointIdMap) {
     this.f.init(numComponents);
-    return this.Eb(inCorr, outData, numComponents, true);
+    return this.Yb(inCorr, outData, numComponents, true);
   }
   // The wrap transform's corrections are zigzag-coded; with `zigzag` set the
   // decode folds the (val >>> 1) ^ -(val & 1) unpacking into each correction
@@ -2660,15 +2515,15 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   // whole array (see computeOriginalValuesZigzag). Every correction is read
   // exactly once before its slot is overwritten, so the in-place aliasing of
   // inCorr and outData is preserved.
-  Eb(inCorr, outData, numComponents, zigzag) {
+  Yb(inCorr, outData, numComponents, zigzag) {
     if (numComponents === 2) {
-      return this.Fb(inCorr, outData, zigzag);
+      return this.Zb(inCorr, outData, zigzag);
     }
     if (numComponents === 3) {
-      return this.Gb(inCorr, outData, zigzag);
+      return this._b(inCorr, outData, zigzag);
     }
     if (numComponents === 4) {
-      return this.Hb(inCorr, outData, zigzag);
+      return this.$b(inCorr, outData, zigzag);
     }
     const table = this.b.cornerTable;
     const vertexToDataMap = this.b.vertexToDataMap;
@@ -2676,9 +2531,9 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     const cornerToVertex = table.cornerToVertexArray();
     const dataToCornerMap = this.b.dataToCornerMap;
     const transform = this.f;
-    const minValue = transform.V;
+    const minValue = transform.aa;
     const maxValue = transform.k;
-    const maxDif = transform.W;
+    const maxDif = transform.ba;
     for (let c = 0; c < numComponents; ++c) {
       let pred = 0;
       if (pred > maxValue) {
@@ -2757,16 +2612,16 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     }
     return true;
   }
-  Fb(inCorr, outData, zigzag) {
+  Zb(inCorr, outData, zigzag) {
     const table = this.b.cornerTable;
     const vertexToDataMap = this.b.vertexToDataMap;
     const oppositeCorners = table.oppositeCornerArray();
     const cornerToVertex = table.cornerToVertexArray();
     const dataToCornerMap = this.b.dataToCornerMap;
     const transform = this.f;
-    const minValue = transform.V;
+    const minValue = transform.aa;
     const maxValue = transform.k;
-    const maxDif = transform.W;
+    const maxDif = transform.ba;
     let pred0 = 0;
     let pred1 = 0;
     if (pred0 > maxValue) {
@@ -2855,16 +2710,16 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     }
     return true;
   }
-  Gb(inCorr, outData, zigzag) {
+  _b(inCorr, outData, zigzag) {
     const table = this.b.cornerTable;
     const vertexToDataMap = this.b.vertexToDataMap;
     const oppositeCorners = table.oppositeCornerArray();
     const cornerToVertex = table.cornerToVertexArray();
     const dataToCornerMap = this.b.dataToCornerMap;
     const transform = this.f;
-    const minValue = transform.V;
+    const minValue = transform.aa;
     const maxValue = transform.k;
-    const maxDif = transform.W;
+    const maxDif = transform.ba;
     let pred0 = 0;
     let pred1 = 0;
     let pred2 = 0;
@@ -2984,16 +2839,16 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   }
   // Four components: tangents, RGBA colors, skin joints/weights. Same
   // structure as the 2/3-component loops.
-  Hb(inCorr, outData, zigzag) {
+  $b(inCorr, outData, zigzag) {
     const table = this.b.cornerTable;
     const vertexToDataMap = this.b.vertexToDataMap;
     const oppositeCorners = table.oppositeCornerArray();
     const cornerToVertex = table.cornerToVertexArray();
     const dataToCornerMap = this.b.dataToCornerMap;
     const transform = this.f;
-    const minValue = transform.V;
+    const minValue = transform.aa;
     const maxValue = transform.k;
-    const maxDif = transform.W;
+    const maxDif = transform.ba;
     let pred0 = 0;
     if (pred0 > maxValue) {
       pred0 = maxValue;
@@ -3112,39 +2967,39 @@ function bigIntSqrt(value) {
   return x;
 }
 var MeshPredictionSchemeTexCoordsPortablePredictor = class {
-  ia = null;
-  ja = null;
-  q = new Int32Array(2);
-  Aa = new Uint8Array(0);
-  la = 0;
+  ra = null;
+  sa = null;
+  r = new Int32Array(2);
+  Ka = new Uint8Array(0);
+  ua = 0;
   b;
-  Ka = new Array(3);
+  Xa = new Array(3);
   // Flat Int32 position cache so fetches are array reads, not convertValue calls.
-  ka = null;
+  ta = null;
   h = null;
   constructor(meshData) {
     this.b = meshData;
   }
   setPositionAttribute(positionAttribute) {
-    this.ia = positionAttribute;
+    this.ra = positionAttribute;
   }
   setEntryToPointIdMap(map) {
-    this.ja = map;
+    this.sa = map;
   }
   get predictedValue() {
-    return this.q;
+    return this.r;
   }
   resizeOrientations(numOrientations) {
-    this.Aa = new Uint8Array(numOrientations);
-    this.la = numOrientations;
+    this.Ka = new Uint8Array(numOrientations);
+    this.ua = numOrientations;
   }
   setOrientation(i, v) {
-    this.Aa[i] = v ? 1 : 0;
+    this.Ka[i] = v ? 1 : 0;
   }
   buildPositionCache(numEntries) {
     const posCache = new Int32Array(numEntries * 3);
-    fillInt32PositionCache(posCache, this.ia, this.ja, numEntries, this.Ka);
-    this.ka = posCache;
+    fillInt32PositionCache(posCache, this.ra, this.sa, numEntries, this.Xa);
+    this.ta = posCache;
     this.h = this.b.cornerTable.cornerToVertexArray();
   }
   computePredictedValue(cornerId, data, dataId) {
@@ -3163,11 +3018,11 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
       const nUV0 = data[nDataOff], nUV1 = data[nDataOff + 1];
       const pUV0 = data[pDataOff], pUV1 = data[pDataOff + 1];
       if (pUV0 === nUV0 && pUV1 === nUV1) {
-        this.q[0] = pUV0;
-        this.q[1] = pUV1;
+        this.r[0] = pUV0;
+        this.r[1] = pUV1;
         return true;
       }
-      const posCache = this.ka;
+      const posCache = this.ta;
       let posOffset = dataId * 3;
       const tip0 = posCache[posOffset];
       const tip1 = posCache[posOffset + 1];
@@ -3204,7 +3059,7 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
         const pnAbsMaxG = Math.max(Math.abs(pn0), Math.abs(pn1), Math.abs(pn2));
         const cnDotPnAbs = Math.abs(cnDotPn);
         if (cnNorm2 > SAFE_PRODUCT / pnNorm2Squared || nUVAbsMax > SAFE_PRODUCT / pnNorm2Squared || pnUVAbsMax > 0 && cnDotPnAbs > SAFE_PRODUCT / pnUVAbsMax || pnAbsMaxG > 0 && cnDotPnAbs > SAFE_PRODUCT / pnAbsMaxG) {
-          return this.Ib(
+          return this.ac(
             tip0,
             tip1,
             tip2,
@@ -3236,16 +3091,16 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
         const normSquared = Math.floor(Math.sqrt(cxNorm2Squared * pnNorm2Squared));
         const cxUV0 = pnUV1 * normSquared;
         const cxUV1 = -pnUV0 * normSquared;
-        if (this.la === 0) {
+        if (this.ua === 0) {
           return false;
         }
-        const orientation = this.Aa[--this.la];
+        const orientation = this.Ka[--this.ua];
         if (orientation) {
-          this.q[0] = Math.trunc((xUV0 + cxUV0) / pnNorm2Squared);
-          this.q[1] = Math.trunc((xUV1 + cxUV1) / pnNorm2Squared);
+          this.r[0] = Math.trunc((xUV0 + cxUV0) / pnNorm2Squared);
+          this.r[1] = Math.trunc((xUV1 + cxUV1) / pnNorm2Squared);
         } else {
-          this.q[0] = Math.trunc((xUV0 - cxUV0) / pnNorm2Squared);
-          this.q[1] = Math.trunc((xUV1 - cxUV1) / pnNorm2Squared);
+          this.r[0] = Math.trunc((xUV0 - cxUV0) / pnNorm2Squared);
+          this.r[1] = Math.trunc((xUV1 - cxUV1) / pnNorm2Squared);
         }
         return true;
       }
@@ -3260,13 +3115,13 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
       if (dataId > 0) {
         dataOffset = (dataId - 1) * 2;
       } else {
-        this.q[0] = 0;
-        this.q[1] = 0;
+        this.r[0] = 0;
+        this.r[1] = 0;
         return true;
       }
     }
-    this.q[0] = data[dataOffset];
-    this.q[1] = data[dataOffset + 1];
+    this.r[0] = data[dataOffset];
+    this.r[1] = data[dataOffset + 1];
     return true;
   }
   // 64-bit-exact projection prediction, used when the double path would lose
@@ -3274,7 +3129,7 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
   // <uint64_t>, including the uint64 wraparound in IntSqrt(cxNorm2*pnNorm2) and
   // the unsigned add/sub forming the final UV. Returns false in the same
   // overflow cases as the double path so encoder and decoder agree on fallback.
-  Ib(tip0, tip1, tip2, next0, next1, next2, pn0, pn1, pn2, nUV0, nUV1, pUV0, pUV1, pnNorm2SquaredNum) {
+  ac(tip0, tip1, tip2, next0, next1, next2, pn0, pn1, pn2, nUV0, nUV1, pUV0, pUV1, pnNorm2SquaredNum) {
     const B = BigInt;
     const tip = [B(tip0), B(tip1), B(tip2)];
     const nxt = [B(next0), B(next1), B(next2)];
@@ -3308,8 +3163,8 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
     const normSquared = bigIntSqrt(cxNorm2 * pnN2 & MASK64);
     const cxUV0 = B.asIntN(64, pnUV1 * normSquared);
     const cxUV1 = B.asIntN(64, -pnUV0 * normSquared);
-    if (this.la === 0) return false;
-    const orientation = this.Aa[--this.la];
+    if (this.ua === 0) return false;
+    const orientation = this.Ka[--this.ua];
     let s0, s1;
     if (orientation) {
       s0 = B.asUintN(64, B.asUintN(64, xUV0) + B.asUintN(64, cxUV0));
@@ -3318,8 +3173,8 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
       s0 = B.asUintN(64, B.asUintN(64, xUV0) - B.asUintN(64, cxUV0));
       s1 = B.asUintN(64, B.asUintN(64, xUV1) - B.asUintN(64, cxUV1));
     }
-    this.q[0] = Number(B.asIntN(32, B.asIntN(64, s0) / pnN2));
-    this.q[1] = Number(B.asIntN(32, B.asIntN(64, s1) / pnN2));
+    this.r[0] = Number(B.asIntN(32, B.asIntN(64, s0) / pnN2));
+    this.r[1] = Number(B.asIntN(32, B.asIntN(64, s1) / pnN2));
     return true;
   }
 };
@@ -3327,10 +3182,10 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
 // src/decoder/compression/attributes/prediction_schemes/MeshPredictionSchemeTexCoordsPortableDecoder.ts
 var GEOMETRY_ATTRIBUTE_POSITION2 = 0;
 var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionSchemeDecoder {
-  p;
+  q;
   constructor(transform, meshData) {
     super(transform, meshData);
-    this.p = new MeshPredictionSchemeTexCoordsPortablePredictor(meshData);
+    this.q = new MeshPredictionSchemeTexCoordsPortablePredictor(meshData);
   }
   getNumParentAttributes() {
     return 1;
@@ -3341,13 +3196,13 @@ var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionS
   setParentAttribute(att) {
     if (att.attributeType !== GEOMETRY_ATTRIBUTE_POSITION2) return false;
     if (att.numComponents !== 3) return false;
-    this.p.setPositionAttribute(att);
+    this.q.setPositionAttribute(att);
     return true;
   }
   decodePredictionData(buffer) {
     const numOrientations = buffer.decodeInt32();
     if (numOrientations === void 0 || numOrientations < 0) return false;
-    this.p.resizeOrientations(numOrientations);
+    this.q.resizeOrientations(numOrientations);
     let lastOrientation = true;
     const decoder = new RAnsBitDecoder();
     if (!decoder.startDecoding(buffer)) return false;
@@ -3355,7 +3210,7 @@ var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionS
       if (!decoder.decodeNextBit()) {
         lastOrientation = !lastOrientation;
       }
-      this.p.setOrientation(i, lastOrientation);
+      this.q.setOrientation(i, lastOrientation);
     }
     decoder.endDecoding();
     return super.decodePredictionData(buffer);
@@ -3364,17 +3219,17 @@ var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionS
     if (numComponents !== 2) {
       return false;
     }
-    this.p.setEntryToPointIdMap(entryToPointIdMap);
+    this.q.setEntryToPointIdMap(entryToPointIdMap);
     this.f.init(numComponents);
     const cornerMapSize = this.b.dataToCornerMap.length;
-    this.p.buildPositionCache(cornerMapSize);
+    this.q.buildPositionCache(cornerMapSize);
     for (let p = 0; p < cornerMapSize; ++p) {
       const cornerId = this.b.dataToCornerMap[p];
-      if (!this.p.computePredictedValue(cornerId, outData, p)) {
+      if (!this.q.computePredictedValue(cornerId, outData, p)) {
         return false;
       }
       const dstOffset = p * numComponents;
-      this.f.computeOriginalValue(this.p.predictedValue, 0, inCorr, dstOffset, outData, dstOffset);
+      this.f.computeOriginalValue(this.q.predictedValue, 0, inCorr, dstOffset, outData, dstOffset);
     }
     return true;
   }
@@ -3401,27 +3256,27 @@ var PredictionSchemeDeltaDecoder = class extends PredictionSchemeDecoder {
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeDecoderFactory.ts
 function createMeshPredictionSchemeDecoder(method, transform, meshData) {
   const transformType = transform.getType();
-  if (transformType === PredictionSchemeTransformType.PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED || transformType === PredictionSchemeTransformType.PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON) {
-    if (method === PredictionSchemeMethod.MESH_PREDICTION_GEOMETRIC_NORMAL) {
+  if (transformType === 3 /* PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED */ || transformType === 2 /* PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON */) {
+    if (method === 6 /* MESH_PREDICTION_GEOMETRIC_NORMAL */) {
       return new MeshPredictionSchemeGeometricNormalDecoder(transform, meshData);
     }
     return null;
   }
   switch (method) {
-    case PredictionSchemeMethod.MESH_PREDICTION_PARALLELOGRAM:
+    case 1 /* MESH_PREDICTION_PARALLELOGRAM */:
       return new MeshPredictionSchemeParallelogramDecoder(transform, meshData);
-    case PredictionSchemeMethod.MESH_PREDICTION_MULTI_PARALLELOGRAM:
+    case 2 /* MESH_PREDICTION_MULTI_PARALLELOGRAM */:
       return new MeshPredictionSchemeMultiParallelogramDecoder(transform, meshData);
-    case PredictionSchemeMethod.MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM:
+    case 4 /* MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM */:
       return new MeshPredictionSchemeConstrainedMultiParallelogramDecoder(transform, meshData);
-    case PredictionSchemeMethod.MESH_PREDICTION_TEX_COORDS_PORTABLE:
+    case 5 /* MESH_PREDICTION_TEX_COORDS_PORTABLE */:
       return new MeshPredictionSchemeTexCoordsPortableDecoder(transform, meshData);
     default:
       return null;
   }
 }
 function createPredictionSchemeForDecoder(method, attId, decoder, transform) {
-  if (method === PredictionSchemeMethod.PREDICTION_NONE) {
+  if (method === -2 /* PREDICTION_NONE */) {
     return null;
   }
   const meshDecoder = decoder;
@@ -3442,24 +3297,24 @@ function createPredictionSchemeForDecoder(method, attId, decoder, transform) {
 
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeWrapDecodingTransform.ts
 var PredictionSchemeWrapDecodingTransform = class {
-  A = 0;
-  V = 0;
+  w = 0;
+  aa = 0;
   k = 0;
-  W = 0;
+  ba = 0;
   getType() {
-    return PredictionSchemeTransformType.PREDICTION_TRANSFORM_WRAP;
+    return 1 /* PREDICTION_TRANSFORM_WRAP */;
   }
   init(numComponents) {
-    this.A = numComponents;
+    this.w = numComponents;
   }
   areCorrectionsPositive() {
     return false;
   }
   computeOriginalValue(predictedVals, predictedOffset, corrVals, corrOffset, outOriginalVals, outOffset) {
-    const nc = this.A;
-    const minValue = this.V;
+    const nc = this.w;
+    const minValue = this.aa;
     const maxValue = this.k;
-    const maxDif = this.W;
+    const maxDif = this.ba;
     for (let i = 0; i < nc; ++i) {
       let pred = predictedVals[predictedOffset + i];
       if (pred > maxValue) {
@@ -3483,63 +3338,65 @@ var PredictionSchemeWrapDecodingTransform = class {
     if (maxValue === void 0) return false;
     const dif = maxValue - minValue;
     if (dif < 0 || dif >= 2147483647) return false;
-    this.V = minValue;
+    this.aa = minValue;
     this.k = maxValue;
-    this.W = 1 + dif;
+    this.ba = 1 + dif;
     return true;
   }
 };
 
 // src/decoder/compression/attributes/SequentialIntegerAttributeDecoder.ts
 var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder {
-  X = null;
+  ca = null;
   // Two-phase decode state (see SequentialAttributeDecoder): the parse phase
   // stashes the primed raw-symbol stream here so the controller can batch and
   // pair several attributes' decodes; the finish phase consumes it.
-  Y = null;
-  Ma = 0;
-  jb = null;
+  da = null;
+  Za = 0;
+  Ab = null;
   // Int32 view over the portable attribute's storage (see preparePortableAttribute).
-  ma = null;
+  R = null;
   // --- Two-phase decode (parse headers / batch symbol decode / finish) ---
   pendingSymbolStream() {
-    if (this.Y === null) {
+    if (this.da === null) {
       return null;
     }
-    const portableData = this.ma;
+    const portableData = this.R;
     return {
-      ans: this.Y.ans_,
-      out: new Uint32Array(portableData.buffer, portableData.byteOffset, this.Ma),
-      count: this.Ma
+      ans: this.da.m,
+      out: new Uint32Array(portableData.buffer, portableData.byteOffset, this.Za),
+      count: this.Za
     };
   }
   decodePortableAttributeFinish() {
-    if (this.Y !== null) {
-      this.Y.endDecoding();
-      this.Y = null;
+    if (this.da !== null) {
+      this.da.endDecoding();
+      this.da = null;
     }
-    return this.Jb(this.jb);
+    return this.bc(this.Ab);
   }
   // The parse phase of the integer decode: prediction scheme, portable
   // attribute, the symbol stream (raw streams are deferred to the finish
   // phase) and the prediction data.
   decodeValues(pointIds, buffer) {
-    this.jb = pointIds;
-    const predictionSchemeMethod = buffer.decodeInt8();
+    this.Ab = pointIds;
+    let predictionSchemeMethod = buffer.decodeUint8();
+    if (predictionSchemeMethod !== void 0) predictionSchemeMethod = predictionSchemeMethod << 24 >> 24;
     if (predictionSchemeMethod === void 0) return false;
-    if (predictionSchemeMethod < PredictionSchemeMethod.PREDICTION_NONE || predictionSchemeMethod >= PredictionSchemeMethod.NUM_PREDICTION_SCHEMES) {
+    if (predictionSchemeMethod < -2 /* PREDICTION_NONE */ || predictionSchemeMethod >= 7 /* NUM_PREDICTION_SCHEMES */) {
       return false;
     }
-    if (predictionSchemeMethod !== PredictionSchemeMethod.PREDICTION_NONE) {
-      const predictionTransformType = buffer.decodeInt8();
+    if (predictionSchemeMethod !== -2 /* PREDICTION_NONE */) {
+      let predictionTransformType = buffer.decodeUint8();
+      if (predictionTransformType !== void 0) predictionTransformType = predictionTransformType << 24 >> 24;
       if (predictionTransformType === void 0) return false;
-      if (predictionTransformType < PredictionSchemeTransformType.PREDICTION_TRANSFORM_NONE || predictionTransformType >= PredictionSchemeTransformType.NUM_PREDICTION_SCHEME_TRANSFORM_TYPES) {
+      if (predictionTransformType < -1 /* PREDICTION_TRANSFORM_NONE */ || predictionTransformType >= 4 /* NUM_PREDICTION_SCHEME_TRANSFORM_TYPES */) {
         return false;
       }
-      this.X = this.createIntPredictionScheme(predictionSchemeMethod, predictionTransformType);
+      this.ca = this.createIntPredictionScheme(predictionSchemeMethod, predictionTransformType);
     }
-    if (this.X) {
-      if (!this.initPredictionScheme(this.X)) {
+    if (this.ca) {
+      if (!this.initPredictionScheme(this.ca)) {
         return false;
       }
     }
@@ -3550,7 +3407,7 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     const numEntries = pointIds.length;
     const numValues = numEntries * numComponents;
     this.preparePortableAttribute(numEntries, numComponents);
-    const portableAttributeData = this.ma;
+    const portableAttributeData = this.R;
     if (portableAttributeData === null) {
       return false;
     }
@@ -3559,14 +3416,14 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     if (compressed > 0) {
       if (numValues > 0) {
         const scheme = buffer.decodeUint8();
-        if (scheme === SymbolCodingMethod.SYMBOL_CODING_RAW) {
+        if (scheme === 1 /* SYMBOL_CODING_RAW */) {
           const decoder = parseRawSymbolStream(numValues, buffer);
           if (decoder === null) {
             return false;
           }
-          this.Y = decoder;
-          this.Ma = numValues;
-        } else if (scheme === SymbolCodingMethod.SYMBOL_CODING_TAGGED) {
+          this.da = decoder;
+          this.Za = numValues;
+        } else if (scheme === 0 /* SYMBOL_CODING_TAGGED */) {
           const outUint32 = new Uint32Array(portableAttributeData.buffer, portableAttributeData.byteOffset, numValues);
           if (!decodeTaggedSymbols(numValues, numComponents, buffer, outUint32)) {
             return false;
@@ -3589,25 +3446,25 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
         portableAttributeData[i] = val;
       }
     }
-    if (this.X) {
-      if (!this.X.decodePredictionData(buffer)) {
+    if (this.ca) {
+      if (!this.ca.decodePredictionData(buffer)) {
         return false;
       }
     }
     return true;
   }
   // The post-symbol tail of the decode: zigzag unpacking and prediction.
-  Jb(pointIds) {
+  bc(pointIds) {
     const numComponents = this.getNumValueComponents();
     const numValues = pointIds.length * numComponents;
-    const data = this.ma;
+    const data = this.R;
     if (data === null) {
       return false;
     }
     if (numValues === 0) {
       return true;
     }
-    const ps = this.X;
+    const ps = this.ca;
     if (ps === null) {
       convertSymbolsToSignedInts(new Uint32Array(data.buffer, data.byteOffset, numValues), numValues, data);
       return true;
@@ -3622,11 +3479,11 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     return ps.computeOriginalValues(data, data, numValues, numComponents, pointIds);
   }
   transformAttributeToOriginalFormat(pointIds) {
-    return this.Na(pointIds.length);
+    return this._a(pointIds.length);
   }
   // Prediction scheme for decoding integer values; subclasses override for others.
   createIntPredictionScheme(method, transformType) {
-    if (transformType !== PredictionSchemeTransformType.PREDICTION_TRANSFORM_WRAP) {
+    if (transformType !== 1 /* PREDICTION_TRANSFORM_WRAP */) {
       return null;
     }
     const transform = new PredictionSchemeWrapDecodingTransform();
@@ -3635,19 +3492,21 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
   getNumValueComponents() {
     return this.attribute.numComponents;
   }
-  // Stores decoded integer values into the attribute.
-  Na(numValues) {
-    const attribute = this.attribute;
-    const dt = attribute.dataType;
-    const IntArray = dt === DataType.UINT8 ? Uint8Array : dt === DataType.INT8 ? Int8Array : dt === DataType.UINT16 ? Uint16Array : dt === DataType.INT16 ? Int16Array : dt === DataType.UINT32 ? Uint32Array : dt === DataType.INT32 ? Int32Array : null;
-    if (IntArray === null) {
+  // The decoded values stay in the portable attribute; the final attribute
+  // only takes its size (see PointAttribute.setLazyInteger and the overrides
+  // in the quantization / normal decoders).
+  xb(numValues) {
+    this.attribute.resetLazy(numValues);
+    return true;
+  }
+  // Hands the decoded integer values to the attribute, converted to its
+  // integer type on extraction.
+  _a(_numValues) {
+    const dt = this.attribute.dataType;
+    if (dt < 1 /* INT8 */ || dt > 6 /* UINT32 */) {
       return false;
     }
-    const total = numValues * attribute.numComponents;
-    if (total > 0) {
-      const dstData = attribute.buffer.data;
-      new IntArray(dstData.buffer, dstData.byteOffset + attribute.byteOffset, total).set(this.ma);
-    }
+    this.attribute.setLazyInteger(this.R);
     return true;
   }
   preparePortableAttribute(numEntries, numComponents) {
@@ -3656,107 +3515,18 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
       this.attribute.attributeType,
       null,
       numComponents,
-      DataType.INT32,
+      5 /* INT32 */,
       false,
-      numComponents * dataTypeLength(DataType.INT32),
+      numComponents * dataTypeLength(5 /* INT32 */),
       0
     );
     const portAtt = new PointAttribute(ga);
     portAtt.setIdentityMapping();
-    portAtt.resetScratch(numEntries);
+    portAtt.reset(numEntries);
     portAtt.uniqueId = this.attribute.uniqueId;
-    this.I = portAtt;
+    this.$ = portAtt;
     const data = portAtt.buffer.data;
-    this.ma = numEntries === 0 ? null : new Int32Array(data.buffer, data.byteOffset + portAtt.byteOffset, numEntries * numComponents);
-  }
-};
-
-// src/decoder/attributes/AttributeTransformType.ts
-var AttributeTransformType = {
-  INVALID: -1,
-  NO_TRANSFORM: 0,
-  QUANTIZATION_TRANSFORM: 1,
-  OCTAHEDRON_TRANSFORM: 2
-};
-
-// src/decoder/attributes/AttributeTransformData.ts
-var AttributeTransformData = class {
-  transformType = AttributeTransformType.INVALID;
-  Kb = [];
-  Lb = [];
-  appendParameterValue(value, type) {
-    this.Kb.push(value);
-    this.Lb.push(type);
-  }
-};
-
-// src/decoder/attributes/AttributeTransform.ts
-var AttributeTransform = class {
-  transferToAttribute(attribute) {
-    const transformData = new AttributeTransformData();
-    this.copyToAttributeTransformData(transformData);
-    attribute.setAttributeTransformData(transformData);
-    return true;
-  }
-};
-
-// src/decoder/attributes/AttributeOctahedronTransform.ts
-var AttributeOctahedronTransform = class extends AttributeTransform {
-  x = -1;
-  copyToAttributeTransformData(outData) {
-    outData.transformType = AttributeTransformType.OCTAHEDRON_TRANSFORM;
-    outData.appendParameterValue(this.x, "int32");
-  }
-  decodeParameters(attribute, decoderBuffer) {
-    const qBits = decoderBuffer.decodeUint8();
-    if (qBits === void 0) return false;
-    this.x = qBits;
-    return true;
-  }
-  inverseTransformAttribute(attribute, targetAttribute) {
-    if (targetAttribute.dataType !== DataType.FLOAT32) {
-      return false;
-    }
-    const numPoints = targetAttribute.size;
-    const numComponents = targetAttribute.numComponents;
-    if (numComponents !== 3) {
-      return false;
-    }
-    const toolBox = new OctahedronToolBox();
-    if (!toolBox.setQuantizationBits(this.x)) {
-      return false;
-    }
-    const srcData = attribute.buffer.data;
-    const srcI32 = new Int32Array(srcData.buffer, srcData.byteOffset + attribute.byteOffset, numPoints * 2);
-    const dstData = targetAttribute.buffer.data;
-    const dstF32 = new Float32Array(dstData.buffer, dstData.byteOffset + targetAttribute.byteOffset, numPoints * 3);
-    const fround = Math.fround;
-    const scale = toolBox.hb;
-    let si = 0;
-    let di = 0;
-    for (let i = 0; i < numPoints; i++) {
-      let y = fround(fround(fround(srcI32[si]) * scale) - 1);
-      let z = fround(fround(fround(srcI32[si + 1]) * scale) - 1);
-      si += 2;
-      const x = fround(fround(1 - Math.abs(y)) - Math.abs(z));
-      let xOffset = -x;
-      if (xOffset < 0) xOffset = 0;
-      y = fround(y + (y < 0 ? xOffset : -xOffset));
-      z = fround(z + (z < 0 ? xOffset : -xOffset));
-      const normSquared = fround(fround(fround(x * x) + fround(y * y)) + fround(z * z));
-      if (normSquared < 1e-6) {
-        dstF32[di] = 0;
-        dstF32[di + 1] = 0;
-        dstF32[di + 2] = 0;
-      } else {
-        const d = fround(1 / fround(Math.sqrt(normSquared)));
-        dstF32[di] = fround(x * d);
-        dstF32[di + 1] = fround(y * d);
-        dstF32[di + 2] = fround(z * d);
-      }
-      di += 3;
-    }
-    return true;
+    this.R = numEntries === 0 ? null : new Int32Array(data.buffer, data.byteOffset + portAtt.byteOffset, numEntries * numComponents);
   }
 };
 
@@ -3772,7 +3542,7 @@ var PredictionSchemeNormalOctahedronTransformBase = class {
   quantizationBits() {
     return this.y.quantizationBits();
   }
-  kb(maxQuantizedValue) {
+  Bb(maxQuantizedValue) {
     if (maxQuantizedValue % 2 === 0) return false;
     let q = 0;
     let v = maxQuantizedValue;
@@ -3787,21 +3557,21 @@ var PredictionSchemeNormalOctahedronTransformBase = class {
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform.ts
 var PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform = class extends PredictionSchemeNormalOctahedronTransformBase {
   getType() {
-    return PredictionSchemeTransformType.PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED;
+    return 3 /* PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED */;
   }
   decodeTransformData(buffer) {
     const maxQuantizedValue = buffer.decodeInt32();
     if (maxQuantizedValue === void 0) return false;
     const centerValue = buffer.decodeInt32();
     if (centerValue === void 0) return false;
-    if (!this.kb(maxQuantizedValue)) return false;
+    if (!this.Bb(maxQuantizedValue)) return false;
     const q = this.y.quantizationBits();
     return q >= 2 && q <= 30;
   }
   computeOriginalValue(predVals, predOffset, corrVals, corrOffset, outOrigVals, outOffset) {
     const toolBox = this.y;
     const center = toolBox.e;
-    const maxQuantizedValue = toolBox.ha;
+    const maxQuantizedValue = toolBox.qa;
     const corrS = corrVals[corrOffset];
     const corrT = corrVals[corrOffset + 1];
     let predS = predVals[predOffset] - center;
@@ -3929,7 +3699,7 @@ var PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform = class exten
   computeOriginalValuesDelta(inCorr, outData, size, numComponents) {
     const toolBox = this.y;
     const center = toolBox.e;
-    const maxQuantizedValue = toolBox.ha;
+    const maxQuantizedValue = toolBox.qa;
     let prevS = 0;
     let prevT = 0;
     for (let i = 0; i < size; i += numComponents) {
@@ -4058,17 +3828,17 @@ var PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform = class exten
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeNormalOctahedronDecodingTransform.ts
 var PredictionSchemeNormalOctahedronDecodingTransform = class extends PredictionSchemeNormalOctahedronTransformBase {
   getType() {
-    return PredictionSchemeTransformType.PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON;
+    return 2 /* PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON */;
   }
   decodeTransformData(buffer) {
     const maxQuantizedValue = buffer.decodeInt32();
     if (maxQuantizedValue === void 0) return false;
-    return this.kb(maxQuantizedValue);
+    return this.Bb(maxQuantizedValue);
   }
   computeOriginalValue(predVals, predOffset, corrVals, corrOffset, outOrigVals, outOffset) {
     const toolBox = this.y;
     const center = toolBox.e;
-    const maxQuantizedValue = toolBox.ha;
+    const maxQuantizedValue = toolBox.qa;
     const predS = predVals[predOffset] - center;
     const predT = predVals[predOffset + 1] - center;
     const corrS = corrVals[corrOffset];
@@ -4147,28 +3917,34 @@ var PredictionSchemeNormalOctahedronDecodingTransform = class extends Prediction
 
 // src/decoder/compression/attributes/SequentialNormalAttributeDecoder.ts
 var SequentialNormalAttributeDecoder = class extends SequentialIntegerAttributeDecoder {
-  Oa = new AttributeOctahedronTransform();
+  J = -1;
   init(decoder, attributeId) {
     if (!super.init(decoder, attributeId)) {
       return false;
     }
-    return this.attribute.numComponents === 3 && this.attribute.dataType === DataType.FLOAT32;
+    return this.attribute.numComponents === 3 && this.attribute.dataType === 9 /* FLOAT32 */;
   }
   // Normals quantize into two octahedral components.
   getNumValueComponents() {
     return 2;
   }
+  // The octahedral quantization bits (AttributeOctahedronTransform::DecodeParameters).
   decodeDataNeededByPortableTransform(_pointIds, buffer) {
-    if (!this.Oa.decodeParameters(this.getPortableAttribute(), buffer)) {
-      return false;
-    }
-    return this.Oa.transferToAttribute(this.I);
+    const qBits = buffer.decodeUint8();
+    if (qBits === void 0) return false;
+    this.J = qBits;
+    return true;
   }
-  Na(_numPoints) {
-    return this.Oa.inverseTransformAttribute(this.getPortableAttribute(), this.attribute);
+  // The octahedral-to-unit-vector transform is deferred to extractTo (see
+  // PointAttribute.setLazyOctahedron).
+  _a(_numPoints) {
+    const q = this.J;
+    if (q < 2 || q > 30) return false;
+    this.attribute.setLazyOctahedron(this.R, Math.fround(2 / Math.fround((1 << q) - 2)));
+    return true;
   }
   createIntPredictionScheme(method, transformType) {
-    const transform = transformType === PredictionSchemeTransformType.PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON ? new PredictionSchemeNormalOctahedronDecodingTransform() : transformType === PredictionSchemeTransformType.PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED ? new PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform() : null;
+    const transform = transformType === 2 /* PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON */ ? new PredictionSchemeNormalOctahedronDecodingTransform() : transformType === 3 /* PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED */ ? new PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform() : null;
     if (transform === null) {
       return null;
     }
@@ -4176,110 +3952,53 @@ var SequentialNormalAttributeDecoder = class extends SequentialIntegerAttributeD
   }
 };
 
-// src/decoder/attributes/AttributeQuantizationTransform.ts
-var AttributeQuantizationTransform = class extends AttributeTransform {
-  x = -1;
-  na = [];
-  Pa = 0;
-  copyToAttributeTransformData(outData) {
-    outData.transformType = AttributeTransformType.QUANTIZATION_TRANSFORM;
-    outData.appendParameterValue(this.x, "int32");
-    for (let i = 0; i < this.na.length; i++) {
-      outData.appendParameterValue(this.na[i], "float32");
-    }
-    outData.appendParameterValue(this.Pa, "float32");
-  }
-  decodeParameters(attribute, decoderBuffer) {
-    const numComponents = attribute.numComponents;
-    this.na = new Array(numComponents);
-    for (let i = 0; i < numComponents; i++) {
-      const val = decoderBuffer.decodeFloat32();
-      if (val === void 0) return false;
-      this.na[i] = val;
-    }
-    const range = decoderBuffer.decodeFloat32();
-    if (range === void 0) return false;
-    this.Pa = range;
-    const qBits = decoderBuffer.decodeUint8();
-    if (qBits === void 0 || qBits < 1 || qBits > 30) return false;
-    this.x = qBits;
-    return true;
-  }
-  inverseTransformAttribute(attribute, targetAttribute) {
-    if (targetAttribute.dataType !== DataType.FLOAT32) {
-      return false;
-    }
-    const maxQuantizedValue = (1 << this.x >>> 0) - 1;
-    if (maxQuantizedValue <= 0) return false;
-    const delta = Math.fround(this.Pa / Math.fround(maxQuantizedValue));
-    const numComponents = targetAttribute.numComponents;
-    const numValues = targetAttribute.size;
-    const total = numValues * numComponents;
-    const minValues = this.na;
-    const srcData = attribute.buffer.data;
-    const srcI32 = new Int32Array(srcData.buffer, srcData.byteOffset + attribute.byteOffset, total);
-    const dstData = targetAttribute.buffer.data;
-    const dstF32 = new Float32Array(dstData.buffer, dstData.byteOffset + targetAttribute.byteOffset, total);
-    const fround = Math.fround;
-    if (numComponents === 3) {
-      const m0 = minValues[0], m1 = minValues[1], m2 = minValues[2];
-      for (let o2 = 0; o2 < total; o2 += 3) {
-        dstF32[o2] = fround(fround(srcI32[o2]) * delta) + m0;
-        dstF32[o2 + 1] = fround(fround(srcI32[o2 + 1]) * delta) + m1;
-        dstF32[o2 + 2] = fround(fround(srcI32[o2 + 2]) * delta) + m2;
-      }
-      return true;
-    }
-    if (numComponents === 2) {
-      const m0 = minValues[0], m1 = minValues[1];
-      for (let o2 = 0; o2 < total; o2 += 2) {
-        dstF32[o2] = fround(fround(srcI32[o2]) * delta) + m0;
-        dstF32[o2 + 1] = fround(fround(srcI32[o2 + 1]) * delta) + m1;
-      }
-      return true;
-    }
-    let o = 0;
-    for (let i = 0; i < numValues; i++) {
-      for (let c = 0; c < numComponents; c++) {
-        dstF32[o] = fround(fround(srcI32[o]) * delta) + minValues[c];
-        o++;
-      }
-    }
-    return true;
-  }
-};
-
 // src/decoder/compression/attributes/SequentialQuantizationAttributeDecoder.ts
 var SequentialQuantizationAttributeDecoder = class extends SequentialIntegerAttributeDecoder {
-  Qa = new AttributeQuantizationTransform();
+  J = -1;
+  $a = [];
+  Cb = 0;
   init(decoder, attributeId) {
     if (!super.init(decoder, attributeId)) {
       return false;
     }
-    return this.attribute.dataType === DataType.FLOAT32;
+    return this.attribute.dataType === 9 /* FLOAT32 */;
   }
+  // The quantization parameters (AttributeQuantizationTransform::DecodeParameters).
   decodeDataNeededByPortableTransform(_pointIds, buffer) {
-    const att = this.getPortableAttribute() ?? this.attribute;
-    if (!this.Qa.decodeParameters(att, buffer)) {
-      return false;
+    const numComponents = this.attribute.numComponents;
+    this.$a = new Array(numComponents);
+    for (let i = 0; i < numComponents; i++) {
+      const val = buffer.decodeFloat32();
+      if (val === void 0) return false;
+      this.$a[i] = val;
     }
-    return this.Qa.transferToAttribute(this.I);
+    const range = buffer.decodeFloat32();
+    if (range === void 0) return false;
+    this.Cb = range;
+    const qBits = buffer.decodeUint8();
+    if (qBits === void 0 || qBits < 1 || qBits > 30) return false;
+    this.J = qBits;
+    return true;
   }
-  // Dequantize the values instead of a generic integer store.
-  Na(_numValues) {
-    return this.Qa.inverseTransformAttribute(this.getPortableAttribute(), this.attribute);
+  // Dequantization is deferred to extractTo (see PointAttribute.setLazyQuantized).
+  _a(_numValues) {
+    const maxQuantizedValue = (1 << this.J >>> 0) - 1;
+    if (maxQuantizedValue <= 0) return false;
+    const delta = Math.fround(this.Cb / Math.fround(maxQuantizedValue));
+    this.attribute.setLazyQuantized(this.R, this.$a, delta);
+    return true;
   }
 };
 
 // src/decoder/compression/attributes/SequentialAttributeDecodersController.ts
 var SequentialAttributeDecodersController = class extends AttributesDecoder {
-  oa = [];
+  va = [];
   // Replaced by the sequencer's output in _prepareSequence.
-  Ba = new Int32Array(0);
-  P;
+  La = new Int32Array(0);
+  S;
   constructor(sequencer) {
     super();
-    this.P = sequencer;
+    this.S = sequencer;
   }
   decodeAttributesDecoderData(buffer) {
     if (!super.decodeAttributesDecoderData(buffer)) {
@@ -4293,19 +4012,19 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
       if (decoder === null || !decoder.init(this.getDecoder(), this.getAttributeId(i))) {
         return false;
       }
-      this.oa[i] = decoder;
+      this.va[i] = decoder;
     }
     return true;
   }
-  Mb() {
-    if (!this.P.generateSequence()) {
+  cc() {
+    if (!this.S.generateSequence()) {
       return false;
     }
-    this.Ba = this.P.getOutputPointIds();
+    this.La = this.S.getOutputPointIds();
     const numAttributes = this.getNumAttributes();
     for (let i = 0; i < numAttributes; i++) {
       const pa = this.getDecoder().pointCloud().attribute(this.getAttributeId(i));
-      if (!this.P.updatePointToAttributeIndexMapping(pa)) {
+      if (!this.S.updatePointToAttributeIndexMapping(pa)) {
         return false;
       }
     }
@@ -4319,24 +4038,24 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
   // of the finish work reads the buffer, and dependents only read parent
   // portable VALUES in finish, so ordering and output stay identical.
   decodeAttributesParse(buffer) {
-    if (!this.Mb()) {
+    if (!this.cc()) {
       return false;
     }
-    const decoders = this.oa;
+    const decoders = this.va;
     for (let i = 0; i < decoders.length; i++) {
-      if (!decoders[i].decodePortableAttributeParse(this.Ba, buffer)) {
+      if (!decoders[i].decodePortableAttributeParse(this.La, buffer)) {
         return false;
       }
     }
     for (let i = 0; i < decoders.length; i++) {
-      if (!decoders[i].decodeDataNeededByPortableTransform(this.Ba, buffer)) {
+      if (!decoders[i].decodeDataNeededByPortableTransform(this.La, buffer)) {
         return false;
       }
     }
     return true;
   }
   collectPendingSymbolStreams(out) {
-    const decoders = this.oa;
+    const decoders = this.va;
     for (let i = 0; i < decoders.length; i++) {
       const pending = decoders[i].pendingSymbolStream();
       if (pending !== null) {
@@ -4345,14 +4064,14 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
     }
   }
   decodeAttributesFinish() {
-    const decoders = this.oa;
+    const decoders = this.va;
     for (let i = 0; i < decoders.length; i++) {
       if (!decoders[i].decodePortableAttributeFinish()) {
         return false;
       }
     }
     for (let i = 0; i < decoders.length; i++) {
-      if (!decoders[i].transformAttributeToOriginalFormat(this.Ba)) {
+      if (!decoders[i].transformAttributeToOriginalFormat(this.La)) {
         return false;
       }
     }
@@ -4363,17 +4082,17 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
     if (locId < 0) {
       return null;
     }
-    return this.oa[locId].getPortableAttribute();
+    return this.va[locId].getPortableAttribute();
   }
   createSequentialDecoder(decoderType) {
     switch (decoderType) {
-      case SequentialAttributeEncoderType.SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC:
+      case 0 /* SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC */:
         return new SequentialAttributeDecoder();
-      case SequentialAttributeEncoderType.SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER:
+      case 1 /* SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER */:
         return new SequentialIntegerAttributeDecoder();
-      case SequentialAttributeEncoderType.SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION:
+      case 2 /* SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION */:
         return new SequentialQuantizationAttributeDecoder();
-      case SequentialAttributeEncoderType.SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS:
+      case 3 /* SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS */:
         return new SequentialNormalAttributeDecoder();
     }
     return null;
@@ -4402,27 +4121,27 @@ var kInvalidFaceIndex = -1;
 var kInvalidVertexIndex2 = -1;
 var DepthFirstTraverser = class {
   a = null;
-  pa = null;
-  Q = null;
-  lb = [];
-  Z = 0;
+  wa = null;
+  T = null;
+  Db = [];
+  ea = 0;
   // Identifies the traversal order for the shared traversal cache
   // (MESH_TRAVERSAL_DEPTH_FIRST). See MeshTraversalSequencer.
-  mb = 0;
+  Eb = 0;
   // The sequencer derives the point id sequence from the corner map after
   // the traversal (see traverseFromCorner).
   emitsPointIds = false;
   h = null;
-  n = null;
-  nb = null;
-  D = 0;
+  p = null;
+  Fb = null;
+  F = 0;
   init(cornerTable, observer) {
     this.a = cornerTable;
-    this.pa = observer;
+    this.wa = observer;
     this.h = cornerTable.cornerToVertexArray();
-    this.n = cornerTable.oppositeCornerArray();
-    this.nb = cornerTable.vertexLeftmostCornerArray();
-    this.D = cornerTable.numCorners();
+    this.p = cornerTable.oppositeCornerArray();
+    this.Fb = cornerTable.vertexLeftmostCornerArray();
+    this.F = cornerTable.numCorners();
   }
   cornerTable() {
     return this.a;
@@ -4436,8 +4155,8 @@ var DepthFirstTraverser = class {
   // Decode-scoped scratch: released in bulk at the end of the decode.
   onTraversalStart() {
     const cornerTable = this.a;
-    this.Q = scratchUint8Zeroed(cornerTable.numFaces());
-    this.lb = scratchInt32(this.D);
+    this.T = scratchUint8Zeroed(cornerTable.numFaces());
+    this.Db = scratchInt32(this.F);
   }
   // Traverses every face, seeding a new traversal at the first corner of each
   // face not yet reached. The visited check lives here rather than behind a
@@ -4446,8 +4165,8 @@ var DepthFirstTraverser = class {
   // was measurable next to the traversal itself.
   traverseAll() {
     const numFaces = this.a.numFaces();
-    const isFaceVisited = this.Q;
-    for (let f = 0; f < numFaces && this.Z < numFaces; ++f) {
+    const isFaceVisited = this.T;
+    for (let f = 0; f < numFaces && this.ea < numFaces; ++f) {
       if (isFaceVisited[f] === 0 && !this.traverseFromCorner(3 * f)) {
         return false;
       }
@@ -4455,19 +4174,19 @@ var DepthFirstTraverser = class {
     return true;
   }
   traverseFromCorner(cornerId) {
-    if (this.Q[cornerId / 3 | 0]) {
+    if (this.T[cornerId / 3 | 0]) {
       return true;
     }
-    const isFaceVisited = this.Q;
-    const observer = this.pa;
+    const isFaceVisited = this.T;
+    const observer = this.wa;
     const cornerToVertex = this.h;
-    const oppositeCorners = this.n;
-    const vertexLeftmost = this.nb;
-    const stack = this.lb;
-    let numVisitedFaces = this.Z;
+    const oppositeCorners = this.p;
+    const vertexLeftmost = this.Fb;
+    const stack = this.Db;
+    let numVisitedFaces = this.ea;
     const encodingData = observer.z;
-    const encodedToCornerMap = observer.Ra;
-    const vertexToEncodedMap = observer.Sa;
+    const encodedToCornerMap = observer.ab;
+    const vertexToEncodedMap = observer.bb;
     let numValues = encodingData.numValues;
     let stackSize = 0;
     stack[stackSize++] = cornerId;
@@ -4545,7 +4264,7 @@ var DepthFirstTraverser = class {
         }
       }
     }
-    this.Z = numVisitedFaces;
+    this.ea = numVisitedFaces;
     encodingData.numValues = numValues;
     return true;
   }
@@ -4557,51 +4276,51 @@ var kInvalidFaceIndex2 = -1;
 var kMaxPriority = 3;
 var MaxPredictionDegreeTraverser = class {
   a = null;
-  pa = null;
-  Q = null;
-  Ta = null;
-  Z = 0;
+  wa = null;
+  T = null;
+  cb = null;
+  ea = 0;
   // One stack (bucket) per priority level [0, kMaxPriority).
-  Ca = null;
-  R = 0;
+  Ma = null;
+  U = 0;
   // Prediction degree accumulated per vertex during traversal.
-  Ua = null;
+  db = null;
   // Flat connectivity arrays (see DepthFirstTraverser for why).
   h = null;
-  n = null;
+  p = null;
   // Identifies the traversal order for the shared traversal cache
   // (MESH_TRAVERSAL_PREDICTION_DEGREE). See MeshTraversalSequencer.
-  mb = 1;
+  Eb = 1;
   // Point ids are appended through the observer as vertices are visited.
   emitsPointIds = true;
   init(cornerTable, observer) {
     this.a = cornerTable;
-    this.pa = observer;
-    this.Q = new Uint8Array(cornerTable.numFaces());
-    this.Ta = new Uint8Array(cornerTable.numVertices());
+    this.wa = observer;
+    this.T = new Uint8Array(cornerTable.numFaces());
+    this.cb = new Uint8Array(cornerTable.numVertices());
     this.h = cornerTable.cornerToVertexArray();
-    this.n = cornerTable.oppositeCornerArray();
-    this.Ca = [[], [], []];
+    this.p = cornerTable.oppositeCornerArray();
+    this.Ma = [[], [], []];
   }
   cornerTable() {
     return this.a;
   }
   // corner is always valid (>= 0) where these are used.
-  ob(c) {
+  Gb(c) {
     return c % 3 === 2 ? c - 2 : c + 1;
   }
-  pb(c) {
+  Hb(c) {
     return c % 3 === 0 ? c + 2 : c - 1;
   }
   onTraversalStart() {
-    this.Ua = new Int32Array(this.a.numVertices());
+    this.db = new Int32Array(this.a.numVertices());
   }
   // Same contract as DepthFirstTraverser.traverseAll. Seeds every face
   // through traverseFromCorner (which re-checks the first face's vertices),
   // exactly as the sequencer's loop always has.
   traverseAll() {
     const numFaces = this.a.numFaces();
-    for (let f = 0; f < numFaces && this.Z < numFaces; ++f) {
+    for (let f = 0; f < numFaces && this.ea < numFaces; ++f) {
       if (!this.traverseFromCorner(3 * f)) {
         return false;
       }
@@ -4610,11 +4329,11 @@ var MaxPredictionDegreeTraverser = class {
   }
   // Returns the priority of traversing the edge leading to cornerId. Mutates
   // the prediction degree of the destination vertex.
-  qb(cornerId) {
+  Ib(cornerId) {
     const vTip = this.h[cornerId];
     let priority = 0;
-    if (!this.Ta[vTip]) {
-      const degree = ++this.Ua[vTip];
+    if (!this.cb[vTip]) {
+      const degree = ++this.db[vTip];
       priority = degree > 1 ? 1 : 2;
     }
     if (priority >= kMaxPriority) {
@@ -4622,38 +4341,38 @@ var MaxPredictionDegreeTraverser = class {
     }
     return priority;
   }
-  rb(ci, priority) {
-    this.Ca[priority].push(ci);
-    if (priority < this.R) {
-      this.R = priority;
+  Jb(ci, priority) {
+    this.Ma[priority].push(ci);
+    if (priority < this.U) {
+      this.U = priority;
     }
   }
   // Retrieves the next available corner to traverse, processed by priority.
   // Returns kInvalidCornerIndex when no corner is available.
-  Nb() {
-    for (let i = this.R; i < kMaxPriority; ++i) {
-      const stack = this.Ca[i];
+  dc() {
+    for (let i = this.U; i < kMaxPriority; ++i) {
+      const stack = this.Ma[i];
       if (stack.length > 0) {
         const ret = stack.pop();
-        this.R = i;
+        this.U = i;
         return ret;
       }
     }
     return kInvalidCornerIndex5;
   }
   traverseFromCorner(cornerId) {
-    if (this.Ua.length === 0) {
+    if (this.db.length === 0) {
       return true;
     }
     const cornerToVertex = this.h;
-    const oppositeCorners = this.n;
-    const isFaceVisited = this.Q;
-    const isVertexVisited = this.Ta;
-    const observer = this.pa;
-    this.Ca[0].push(cornerId);
-    this.R = 0;
-    const firstNext = this.ob(cornerId);
-    const firstPrev = this.pb(cornerId);
+    const oppositeCorners = this.p;
+    const isFaceVisited = this.T;
+    const isVertexVisited = this.cb;
+    const observer = this.wa;
+    this.Ma[0].push(cornerId);
+    this.U = 0;
+    const firstNext = this.Gb(cornerId);
+    const firstPrev = this.Hb(cornerId);
     const nextVert = cornerToVertex[firstNext];
     const prevVert = cornerToVertex[firstPrev];
     if (!isVertexVisited[nextVert]) {
@@ -4669,7 +4388,7 @@ var MaxPredictionDegreeTraverser = class {
       isVertexVisited[tipVertex] = 1;
       observer.onNewVertexVisited(tipVertex, cornerId);
     }
-    while ((cornerId = this.Nb()) !== kInvalidCornerIndex5) {
+    while ((cornerId = this.dc()) !== kInvalidCornerIndex5) {
       let faceId = cornerId / 3 | 0;
       if (isFaceVisited[faceId]) {
         continue;
@@ -4677,34 +4396,34 @@ var MaxPredictionDegreeTraverser = class {
       while (true) {
         faceId = cornerId / 3 | 0;
         isFaceVisited[faceId] = 1;
-        this.Z++;
+        this.ea++;
         const vertId = cornerToVertex[cornerId];
         if (!isVertexVisited[vertId]) {
           isVertexVisited[vertId] = 1;
           observer.onNewVertexVisited(vertId, cornerId);
         }
-        const rightCornerId = oppositeCorners[this.ob(cornerId)];
-        const leftCornerId = oppositeCorners[this.pb(cornerId)];
+        const rightCornerId = oppositeCorners[this.Gb(cornerId)];
+        const leftCornerId = oppositeCorners[this.Hb(cornerId)];
         const rightFaceId = rightCornerId === kInvalidCornerIndex5 ? kInvalidFaceIndex2 : rightCornerId / 3 | 0;
         const leftFaceId = leftCornerId === kInvalidCornerIndex5 ? kInvalidFaceIndex2 : leftCornerId / 3 | 0;
         const isRightFaceVisited = rightFaceId === kInvalidFaceIndex2 || isFaceVisited[rightFaceId] !== 0;
         const isLeftFaceVisited = leftFaceId === kInvalidFaceIndex2 || isFaceVisited[leftFaceId] !== 0;
         if (!isLeftFaceVisited) {
-          const priority = this.qb(leftCornerId);
-          if (isRightFaceVisited && priority <= this.R) {
+          const priority = this.Ib(leftCornerId);
+          if (isRightFaceVisited && priority <= this.U) {
             cornerId = leftCornerId;
             continue;
           } else {
-            this.rb(leftCornerId, priority);
+            this.Jb(leftCornerId, priority);
           }
         }
         if (!isRightFaceVisited) {
-          const priority = this.qb(rightCornerId);
-          if (priority <= this.R) {
+          const priority = this.Ib(rightCornerId);
+          if (priority <= this.U) {
             cornerId = rightCornerId;
             continue;
           } else {
-            this.rb(rightCornerId, priority);
+            this.Jb(rightCornerId, priority);
           }
         }
         break;
@@ -4717,66 +4436,66 @@ var MaxPredictionDegreeTraverser = class {
 // src/decoder/compression/mesh/traverser/MeshAttributeIndicesEncodingObserver.ts
 var MeshAttributeIndicesEncodingObserver = class {
   z;
-  P;
-  Sa;
-  Ra;
-  sb;
+  S;
+  bb;
+  ab;
+  Kb;
   constructor(mesh, sequencer, encodingData) {
     this.z = encodingData;
-    this.P = sequencer;
-    this.Sa = encodingData.vertexToEncodedAttributeValueIndexMap;
-    this.Ra = encodingData.encodedAttributeValueIndexToCornerMap;
-    this.sb = mesh.faces_;
+    this.S = sequencer;
+    this.bb = encodingData.vertexToEncodedAttributeValueIndexMap;
+    this.ab = encodingData.encodedAttributeValueIndexToCornerMap;
+    this.Kb = mesh.faces_;
   }
   onNewVertexVisited(vertex, corner) {
-    const pointId = this.sb[corner];
-    this.P.addPointId(pointId);
+    const pointId = this.Kb[corner];
+    this.S.addPointId(pointId);
     const numValues = this.z.numValues;
-    this.Ra[numValues] = corner;
-    this.Sa[vertex] = numValues;
+    this.ab[numValues] = corner;
+    this.bb[vertex] = numValues;
     this.z.numValues++;
   }
 };
 
 // src/decoder/compression/mesh/traverser/MeshTraversalSequencer.ts
 var MeshTraversalSequencer = class {
-  B;
+  D;
   z;
-  qa = null;
-  s = new Int32Array(0);
-  ra = 0;
+  xa = null;
+  u = new Int32Array(0);
+  ya = 0;
   // Per-decode cache, keyed by corner table, shared across the attribute
   // decoders of one mesh (see MeshEdgebreakerDecoderImpl).
-  Va;
+  eb;
   // The cache entry the last generateSequence resolved to (hit or store);
   // carries the shared indicesMap.
-  Wa = null;
+  fb = null;
   // One representative corner per point id, when the connectivity decoder
   // recorded them (see MeshEdgebreakerDecoderImpl._assignAttributeVerticesAndPoints).
-  _;
+  fa;
   constructor(mesh, encodingData, traversalCache, pointCorner) {
-    this.B = mesh;
+    this.D = mesh;
     this.z = encodingData;
-    this.Va = traversalCache;
-    this._ = pointCorner;
+    this.eb = traversalCache;
+    this.fa = pointCorner;
   }
   setTraverser(traverser) {
-    this.qa = traverser;
+    this.xa = traverser;
   }
   generateSequence() {
-    const cornerTable = this.qa.cornerTable();
-    const methodId = this.qa.mb;
+    const cornerTable = this.xa.cornerTable();
+    const methodId = this.xa.Eb;
     const cacheKey = cornerTable.cornerToVertexArray();
     const encodingData = this.z;
-    let byMethod = this.Va.get(cacheKey);
+    let byMethod = this.eb.get(cacheKey);
     const cached = byMethod && byMethod.get(methodId);
     if (cached !== void 0) {
-      this.s = cached.pointIds;
+      this.u = cached.pointIds;
       encodingData.adoptTraversalResult(cached.vertexMap, cached.cornerMap, cached.numValues);
-      this.Wa = cached;
+      this.fb = cached;
       return true;
     }
-    if (!this.Ob()) {
+    if (!this.ec()) {
       return false;
     }
     const numValues = encodingData.numValues;
@@ -4788,39 +4507,39 @@ var MeshTraversalSequencer = class {
     }
     if (byMethod === void 0) {
       byMethod = /* @__PURE__ */ new Map();
-      this.Va.set(cacheKey, byMethod);
+      this.eb.set(cacheKey, byMethod);
     }
     const entry = {
-      pointIds: this.s,
+      pointIds: this.u,
       vertexMap: encodingData.vertexToEncodedAttributeValueIndexMap,
       cornerMap: encodingData.encodedAttributeValueIndexToCornerMap,
       numValues,
       indicesMap: null
     };
     byMethod.set(methodId, entry);
-    this.Wa = entry;
+    this.fb = entry;
     return true;
   }
   getOutputPointIds() {
-    return this.s;
+    return this.u;
   }
   addPointId(pointId) {
-    this.s[this.ra++] = pointId;
+    this.u[this.ya++] = pointId;
   }
   updatePointToAttributeIndexMapping(attribute) {
-    const entry = this.Wa;
+    const entry = this.fb;
     if (entry !== null && entry.indicesMap !== null) {
       attribute.setExplicitMappingShared(entry.indicesMap);
       return true;
     }
-    const cornerTable = this.qa.cornerTable();
-    const numFaces = this.B.numFaces();
-    const numPoints = this.B.numPoints();
+    const cornerTable = this.xa.cornerTable();
+    const numFaces = this.D.numFaces();
+    const numPoints = this.D.numPoints();
     attribute.setExplicitMappingUnfilled(numPoints);
     const cornerToVertex = cornerTable.cornerToVertexArray();
     const vertexToAttEntry = this.z.vertexToEncodedAttributeValueIndexMap;
     const indicesMap = attribute.indicesMap;
-    const pointCorner = this._;
+    const pointCorner = this.fa;
     if (pointCorner !== null) {
       for (let p = 0; p < numPoints; ++p) {
         const vertId = cornerToVertex[pointCorner[p]];
@@ -4835,7 +4554,7 @@ var MeshTraversalSequencer = class {
       }
     } else {
       const numCorners = numFaces * 3;
-      const faces = this.B.faces_;
+      const faces = this.D.faces_;
       for (let ci = 0; ci < numCorners; ++ci) {
         const vertId = cornerToVertex[ci];
         if (vertId < 0) {
@@ -4854,10 +4573,10 @@ var MeshTraversalSequencer = class {
     }
     return true;
   }
-  Ob() {
-    this.ra = 0;
-    this.s = scratchInt32(this.B.numPoints());
-    const traverser = this.qa;
+  ec() {
+    this.ya = 0;
+    this.u = scratchInt32(this.D.numPoints());
+    const traverser = this.xa;
     traverser.onTraversalStart();
     if (!traverser.traverseAll()) {
       return false;
@@ -4865,15 +4584,15 @@ var MeshTraversalSequencer = class {
     if (!traverser.emitsPointIds) {
       const numValues = this.z.numValues;
       const cornerMap = this.z.encodedAttributeValueIndexToCornerMap;
-      const faces = this.B.faces_;
-      const outPointIds = this.s;
+      const faces = this.D.faces_;
+      const outPointIds = this.u;
       for (let i = 0; i < numValues; ++i) {
         outPointIds[i] = faces[cornerMap[i]];
       }
-      this.ra = numValues;
+      this.ya = numValues;
     }
-    if (this.ra < this.s.length) {
-      this.s = this.s.subarray(0, this.ra);
+    if (this.ya < this.u.length) {
+      this.u = this.u.subarray(0, this.ya);
     }
     return true;
   }
@@ -4882,36 +4601,38 @@ var MeshTraversalSequencer = class {
 // src/decoder/compression/mesh/MeshEdgebreakerDecoderImpl.ts
 var kInvalidCornerIndex6 = -1;
 var MeshEdgebreakerDecoderImpl = class {
-  m;
+  l;
   a = null;
-  J = [];
-  $ = new Uint8Array(0);
-  S = 0;
-  Xa = new MeshAttributeIndicesEncodingData();
-  tb = -1;
+  K = [];
+  ga = new Uint8Array(0);
+  V = 0;
+  gb = new MeshAttributeIndicesEncodingData();
+  Lb = -1;
   // Cache of vertex-traversal results keyed by corner table, so attributes
   // sharing connectivity traverse once.
-  Pb = /* @__PURE__ */ new Map();
+  fc = /* @__PURE__ */ new Map();
   g = [];
-  E;
+  G;
   // One corner per point id (decode-scoped scratch), filled by
   // _assignAttributeVerticesAndPoints; null when points are the base vertices.
-  _ = null;
+  fa = null;
+  // Corners on a boundary edge, counted by _decodeAttributeConnectivities.
+  Mb = 0;
   constructor(decoder, TraversalDecoderClass) {
-    this.m = decoder;
-    this.E = new TraversalDecoderClass();
+    this.l = decoder;
+    this.G = new TraversalDecoderClass();
   }
   getCornerTable() {
     return this.a;
   }
   // The attribute data set whose attributes decoder owns attId, if any.
-  ub(attId) {
+  Nb(attId) {
     for (let i = 0; i < this.g.length; ++i) {
       const ad = this.g[i];
-      if (ad.decoderId < 0 || ad.decoderId >= this.m.numAttributesDecoders()) {
+      if (ad.decoderId < 0 || ad.decoderId >= this.l.numAttributesDecoders()) {
         continue;
       }
-      const dec = this.m.attributesDecoder(ad.decoderId);
+      const dec = this.l.attributesDecoder(ad.decoderId);
       for (let j = 0; j < dec.getNumAttributes(); ++j) {
         if (dec.getAttributeId(j) === attId) {
           return ad;
@@ -4921,16 +4642,17 @@ var MeshEdgebreakerDecoderImpl = class {
     return null;
   }
   getAttributeCornerTable(attId) {
-    const ad = this.ub(attId);
+    const ad = this.Nb(attId);
     return ad !== null && ad.isConnectivityUsed ? ad.connectivityData : null;
   }
   getAttributeEncodingData(attId) {
-    const ad = this.ub(attId);
-    return ad !== null ? ad.encodingData : this.Xa;
+    const ad = this.Nb(attId);
+    return ad !== null ? ad.encodingData : this.gb;
   }
   createAttributesDecoder(attDecoderId) {
-    const buffer = this.m.buffer();
-    const attDataId = buffer.decodeInt8();
+    const buffer = this.l.buffer();
+    let attDataId = buffer.decodeUint8();
+    if (attDataId !== void 0) attDataId = attDataId << 24 >> 24;
     if (attDataId === void 0) return false;
     const decoderType = buffer.decodeUint8();
     if (decoderType === void 0) return false;
@@ -4943,55 +4665,57 @@ var MeshEdgebreakerDecoderImpl = class {
       }
       this.g[attDataId].decoderId = attDecoderId;
     } else {
-      if (this.tb >= 0) {
+      if (this.Lb >= 0) {
         return false;
       }
-      this.tb = attDecoderId;
+      this.Lb = attDecoderId;
     }
     const traversalMethod = buffer.decodeUint8();
-    if (traversalMethod === void 0 || traversalMethod >= MeshTraversalMethod.NUM_TRAVERSAL_METHODS) {
+    if (traversalMethod === void 0 || traversalMethod >= 2 /* NUM_TRAVERSAL_METHODS */) {
       return false;
     }
     let encodingData;
     let cornerTable;
-    if (decoderType === MeshAttributeElementType.MESH_VERTEX_ATTRIBUTE) {
+    if (decoderType === 0 /* MESH_VERTEX_ATTRIBUTE */) {
       if (attDataId < 0) {
-        encodingData = this.Xa;
+        encodingData = this.gb;
       } else {
         encodingData = this.g[attDataId].encodingData;
         this.g[attDataId].isConnectivityUsed = false;
       }
       cornerTable = this.a;
     } else {
-      if (traversalMethod !== MeshTraversalMethod.MESH_TRAVERSAL_DEPTH_FIRST || attDataId < 0) {
+      if (traversalMethod !== 0 /* MESH_TRAVERSAL_DEPTH_FIRST */ || attDataId < 0) {
         return false;
       }
-      encodingData = this.g[attDataId].encodingData;
-      cornerTable = this.g[attDataId].connectivityData;
+      const ad = this.g[attDataId];
+      if (ad.noInteriorSeams) this.gc(ad);
+      encodingData = ad.encodingData;
+      cornerTable = ad.connectivityData;
     }
-    const mesh = this.m.mesh();
-    const sequencer = new MeshTraversalSequencer(mesh, encodingData, this.Pb, this._);
+    const mesh = this.l.mesh();
+    const sequencer = new MeshTraversalSequencer(mesh, encodingData, this.fc, this.fa);
     const observer = new MeshAttributeIndicesEncodingObserver(mesh, sequencer, encodingData);
-    const traverser = traversalMethod === MeshTraversalMethod.MESH_TRAVERSAL_PREDICTION_DEGREE ? new MaxPredictionDegreeTraverser() : new DepthFirstTraverser();
+    const traverser = traversalMethod === 1 /* MESH_TRAVERSAL_PREDICTION_DEGREE */ ? new MaxPredictionDegreeTraverser() : new DepthFirstTraverser();
     traverser.init(cornerTable, observer);
     sequencer.setTraverser(traverser);
-    return this.m.setAttributesDecoder(attDecoderId, new SequentialAttributeDecodersController(sequencer));
+    return this.l.setAttributesDecoder(attDecoderId, new SequentialAttributeDecodersController(sequencer));
   }
   decodeConnectivity() {
-    const buffer = this.m.buffer();
+    const buffer = this.l.buffer();
     const numEncodedVertices = decodeVarint(buffer);
     if (numEncodedVertices === void 0) return false;
-    this.S = numEncodedVertices;
+    this.V = numEncodedVertices;
     const numFaces = decodeVarint(buffer);
     if (numFaces === void 0) return false;
     if (numFaces > 2147483647 / 3) {
       return false;
     }
-    if (this.S > numFaces * 3) {
+    if (this.V > numFaces * 3) {
       return false;
     }
     const minNumFaceEdges = Math.floor(3 * numFaces / 2);
-    const maxNumVertexEdges = this.S * (this.S - 1) / 2;
+    const maxNumVertexEdges = this.V * (this.V - 1) / 2;
     if (maxNumVertexEdges < minNumFaceEdges) {
       return false;
     }
@@ -5018,27 +4742,28 @@ var MeshEdgebreakerDecoderImpl = class {
       ad.numSeamCorners = 0;
       this.g.push(ad);
     }
-    this.a.reset(numFaces, this.S + numEncodedSplitSymbols);
-    this.$ = scratchUint8Filled(this.S + numEncodedSplitSymbols, 1);
-    if (!this.Qb(buffer)) {
+    this.a.reset(numFaces, this.V + numEncodedSplitSymbols);
+    this.ga = scratchUint8Filled(this.V + numEncodedSplitSymbols, 1);
+    if (!this.hc(buffer)) {
       return false;
     }
-    this.E.init(this);
-    this.E.setNumEncodedVertices(this.S + numEncodedSplitSymbols);
-    this.E.setNumAttributeData(numAttributeData);
+    this.G.init(this);
+    this.G.setNumEncodedVertices(this.V + numEncodedSplitSymbols);
+    this.G.setNumAttributeData(numAttributeData);
     const traversalEndBuffer = new DecoderBuffer();
-    if (!this.E.start(traversalEndBuffer)) {
+    if (!this.G.start(traversalEndBuffer)) {
       return false;
     }
-    const numConnectivityVerts = this.Rb(numEncodedSymbols);
+    const numConnectivityVerts = this.ic(numEncodedSymbols);
     if (numConnectivityVerts === -1) {
       return false;
     }
     buffer.init(traversalEndBuffer.dataHead, traversalEndBuffer.remainingSize);
     if (this.g.length > 0) {
-      this.Sb();
+      this.jc();
     }
-    this.E.done();
+    this.G.done();
+    const numBoundaryCorners = this.Mb;
     const distinctTables = [];
     const adoptions = [];
     let previousConnectivityData = null;
@@ -5048,6 +4773,10 @@ var MeshEdgebreakerDecoderImpl = class {
       const connectivityData = this.g[i].connectivityData;
       const seamCorners = this.g[i].attributeSeamCorners;
       const seamCount = this.g[i].numSeamCorners;
+      if (seamCount === numBoundaryCorners) {
+        this.g[i].noInteriorSeams = true;
+        continue;
+      }
       let sameAsPrevious = previousConnectivityData !== null && seamCount === previousSeamCount;
       if (sameAsPrevious) {
         const previous = previousSeamCorners;
@@ -5073,14 +4802,14 @@ var MeshEdgebreakerDecoderImpl = class {
       previousSeamCount = seamCount;
     }
     if (this.g.length === 0) {
-      this.Tb(numConnectivityVerts);
-    } else if (!this.Ub(distinctTables)) {
+      this.kc(numConnectivityVerts);
+    } else if (!this.lc(distinctTables)) {
       return false;
     }
     for (let i = 0; i < adoptions.length; i += 2) {
       adoptions[i].adoptFrom(adoptions[i + 1]);
     }
-    this.Xa.init(this.a.numVertices());
+    this.gb.init(this.a.numVertices());
     for (let i = 0; i < this.g.length; ++i) {
       let attConnectivityVerts = this.g[i].connectivityData.numVertices();
       if (attConnectivityVerts < this.a.numVertices()) {
@@ -5090,11 +4819,11 @@ var MeshEdgebreakerDecoderImpl = class {
     }
     return true;
   }
-  Vb(encoderSymbolId, outResult) {
-    if (this.J.length === 0) {
+  mc(encoderSymbolId, outResult) {
+    if (this.K.length === 0) {
       return false;
     }
-    const back = this.J[this.J.length - 1];
+    const back = this.K[this.K.length - 1];
     if (back.sourceSymbolId > encoderSymbolId) {
       outResult.encoderSplitSymbolId = -1;
       return true;
@@ -5104,24 +4833,24 @@ var MeshEdgebreakerDecoderImpl = class {
     }
     outResult.faceEdge = back.sourceEdge;
     outResult.encoderSplitSymbolId = back.splitSymbolId;
-    this.J.pop();
+    this.K.pop();
     return true;
   }
-  Rb(numSymbols) {
-    const activeCornerStack = scratchInt32(numSymbols + this.J.length + 16);
+  ic(numSymbols) {
+    const activeCornerStack = scratchInt32(numSymbols + this.K.length + 16);
     let activeCornerStackSize = 0;
     const topologySplitActiveCorners = /* @__PURE__ */ new Map();
     const splitResult = { faceEdge: 0, encoderSplitSymbolId: 0 };
     const invalidVertices = [];
     const removeInvalidVertices = this.g.length === 0;
-    let maxNumVertices = this.$.length;
+    let maxNumVertices = this.ga.length;
     let numFacesDecoded = 0;
     const cornerToVertex = this.a.h;
-    const oppositeCorners = this.a.n;
+    const oppositeCorners = this.a.p;
     const vc = this.a;
-    let vertexCorners = vc.t;
-    const isVertHole = this.$;
-    const traversalDecoder = this.E;
+    let vertexCorners = vc.v;
+    const isVertHole = this.ga;
+    const traversalDecoder = this.G;
     for (let symbolId = 0; symbolId < numSymbols; ++symbolId) {
       const faceIndex = numFacesDecoded++;
       let checkTopologySplit = false;
@@ -5177,7 +4906,7 @@ var MeshEdgebreakerDecoderImpl = class {
           newVertIndex = vc.j++;
         } else {
           newVertIndex = vc.addNewVertex();
-          vertexCorners = vc.t;
+          vertexCorners = vc.v;
         }
         if (vc.j > maxNumVertices) return -1;
         cornerToVertex[oppCorner] = newVertIndex;
@@ -5247,7 +4976,7 @@ var MeshEdgebreakerDecoderImpl = class {
           firstVertIndex = vc.addNewVertex();
           vc.addNewVertex();
           vc.addNewVertex();
-          vertexCorners = vc.t;
+          vertexCorners = vc.v;
         }
         if (vc.j > maxNumVertices) return -1;
         cornerToVertex[corner] = firstVertIndex;
@@ -5262,9 +4991,9 @@ var MeshEdgebreakerDecoderImpl = class {
         return -1;
       }
       traversalDecoder.newActiveCornerReached(activeCornerStack[activeCornerStackSize - 1]);
-      if (checkTopologySplit && this.J.length > 0) {
+      if (checkTopologySplit && this.K.length > 0) {
         const encoderSymbolId = numSymbols - symbolId - 1;
-        while (this.Vb(encoderSymbolId, splitResult)) {
+        while (this.mc(encoderSymbolId, splitResult)) {
           if (splitResult.encoderSplitSymbolId < 0) return -1;
           const actTopCorner = activeCornerStack[activeCornerStackSize - 1];
           let newActiveCorner;
@@ -5281,24 +5010,24 @@ var MeshEdgebreakerDecoderImpl = class {
     if (vc.j > maxNumVertices) {
       return -1;
     }
-    numFacesDecoded = this.Wb(activeCornerStack, activeCornerStackSize, numFacesDecoded);
+    numFacesDecoded = this.nc(activeCornerStack, activeCornerStackSize, numFacesDecoded);
     if (numFacesDecoded === -1) {
       return -1;
     }
     if (numFacesDecoded !== this.a.numFaces()) {
       return -1;
     }
-    return this.Xb(invalidVertices);
+    return this.oc(invalidVertices);
   }
   // Connects the remaining active-stack corners to newly decoded start faces.
   // Returns the updated decoded-face count, or -1 on malformed input.
-  Wb(activeCornerStack, activeCornerStackSize, numFacesDecoded) {
+  nc(activeCornerStack, activeCornerStackSize, numFacesDecoded) {
     const ct = this.a;
+    const oppositeCorners = ct.p;
     const cornerToVertex = ct.h;
-    const oppositeCorners = ct.n;
-    const vertexCorners = ct.t;
-    const isVertHole = this.$;
-    const traversalDecoder = this.E;
+    const vertexCorners = ct.v;
+    const isVertHole = this.ga;
+    const traversalDecoder = this.G;
     const numCorners = ct.numCorners();
     const numFaces = ct.numFaces();
     const next = (c) => c < 0 ? -1 : c % 3 === 2 ? c - 2 : c + 1;
@@ -5346,28 +5075,12 @@ var MeshEdgebreakerDecoderImpl = class {
   // Removes invalid (isolated) vertices by swapping them with the last valid
   // vertex in the table, matching C++ mesh_edgebreaker_decoder_impl.cc (the
   // forward iteration order matters). Returns the final vertex count, or -1.
-  Xb(invalidVertices) {
+  oc(invalidVertices) {
     const ct = this.a;
     const cornerToVertex = ct.h;
-    const oppositeCorners = ct.n;
-    const vertexCorners = ct.t;
-    const isVertHole = this.$;
-    const numCorners = ct.numCorners();
-    const next = (c) => c < 0 ? -1 : c % 3 === 2 ? c - 2 : c + 1;
-    const prev = (c) => c < 0 ? -1 : c % 3 === 0 ? c + 2 : c - 1;
-    const vertex = (c) => c < 0 || c >= numCorners ? -1 : cornerToVertex[c];
-    const opposite = (c) => c < 0 || c >= numCorners ? -1 : oppositeCorners[c];
+    const vertexCorners = ct.v;
+    const isVertHole = this.ga;
     const leftMostCorner = (v) => v < 0 || v >= vertexCorners.length ? -1 : vertexCorners[v];
-    const swingLeft = (c) => {
-      const n = next(c);
-      const o = opposite(n);
-      return o < 0 ? -1 : next(o);
-    };
-    const swingRight = (c) => {
-      const p = prev(c);
-      const o = opposite(p);
-      return o < 0 ? -1 : prev(o);
-    };
     let numVertices = ct.numVertices();
     for (let ivIdx = 0; ivIdx < invalidVertices.length; ++ivIdx) {
       const invalidVert = invalidVertices[ivIdx];
@@ -5380,22 +5093,22 @@ var MeshEdgebreakerDecoderImpl = class {
       let cid = startCid;
       let leftTraversal = true;
       while (cid !== kInvalidCornerIndex6) {
-        if (vertex(cid) !== srcVert) {
+        if (ct.vertex(cid) !== srcVert) {
           return -1;
         }
         cornerToVertex[cid] = invalidVert;
         if (leftTraversal) {
-          const nextC = swingLeft(cid);
+          const nextC = ct.swingLeft(cid);
           if (nextC === kInvalidCornerIndex6) {
             leftTraversal = false;
-            cid = swingRight(startCid);
+            cid = ct.swingRight(startCid);
           } else if (nextC === startCid) {
             break;
           } else {
             cid = nextC;
           }
         } else {
-          cid = swingRight(cid);
+          cid = ct.swingRight(cid);
         }
       }
       vertexCorners[invalidVert] = leftMostCorner(srcVert);
@@ -5408,7 +5121,7 @@ var MeshEdgebreakerDecoderImpl = class {
   }
   // Hole events were removed from the bitstream in 2.1; for 2.2 this only
   // decodes the inline topology-split events.
-  Qb(decoderBuffer) {
+  hc(decoderBuffer) {
     const numTopologySplits = decodeVarint(decoderBuffer);
     if (numTopologySplits === void 0) return false;
     if (numTopologySplits > 0) {
@@ -5426,12 +5139,12 @@ var MeshEdgebreakerDecoderImpl = class {
         if (delta2 > eventData.sourceSymbolId) return false;
         eventData.splitSymbolId = eventData.sourceSymbolId - delta2;
         lastSourceSymbolId = eventData.sourceSymbolId;
-        this.J.push(eventData);
+        this.K.push(eventData);
       }
       decoderBuffer.startBitDecoding(false);
       for (let i = 0; i < numTopologySplits; ++i) {
         const edgeData = decoderBuffer.decodeLeastSignificantBits32(1);
-        this.J[i].sourceEdge = edgeData & 1;
+        this.K[i].sourceEdge = edgeData & 1;
       }
       decoderBuffer.endBitDecoding();
     }
@@ -5449,32 +5162,37 @@ var MeshEdgebreakerDecoderImpl = class {
   // the face's base corner -- is just `oppCorner >= faceBaseCorner`, since the
   // base corner is a multiple of 3. That removes the per-corner division; the
   // invalid-corner case (-1) is still handled by the branch above it.
-  Sb() {
+  jc() {
     const oppositeCorners = this.a.oppositeCornerArray();
     const attributeData = this.g;
     const numAttrData = attributeData.length;
-    const connectivityDecoders = this.E.vb;
+    const connectivityDecoders = this.G.Ob;
     const numCorners = this.a.numCorners();
     const candidates = scratchInt32(numCorners);
     let numCandidates = 0;
+    let numBoundaryCorners = 0;
     for (let corner = 0; corner < numCorners; corner += 3) {
       let opp = oppositeCorners[corner];
       candidates[numCandidates] = corner ^ opp >> 31;
       numCandidates -= (opp | corner - opp - 1) >> 31;
+      numBoundaryCorners -= opp >> 31;
       opp = oppositeCorners[corner + 1];
       candidates[numCandidates] = corner + 1 ^ opp >> 31;
       numCandidates -= (opp | corner - opp - 1) >> 31;
+      numBoundaryCorners -= opp >> 31;
       opp = oppositeCorners[corner + 2];
       candidates[numCandidates] = corner + 2 ^ opp >> 31;
       numCandidates -= (opp | corner - opp - 1) >> 31;
+      numBoundaryCorners -= opp >> 31;
     }
+    this.Mb = numBoundaryCorners;
     for (let i = 0; i < numAttrData; ++i) {
       const ad = attributeData[i];
       const seamCorners = ad.attributeSeamCorners;
       let numSeamCorners = ad.numSeamCorners;
       const decoder = connectivityDecoders[i];
-      const ans = decoder.ansDecoder_;
-      const p = decoder.p_;
+      const ans = decoder.Va;
+      const p = decoder.Wa;
       const buf = ans.buf;
       const bufStart = ans.bufStart;
       let state = ans.state;
@@ -5502,8 +5220,8 @@ var MeshEdgebreakerDecoderImpl = class {
     }
   }
   // Position-only connectivity: vertex indices equal point indices.
-  Tb(numConnectivityVerts) {
-    const mesh = this.m.mesh();
+  kc(numConnectivityVerts) {
+    const mesh = this.l.mesh();
     const ct = this.a;
     mesh.setNumFaces(ct.numFaces());
     const numCorners = ct.numCorners();
@@ -5512,8 +5230,36 @@ var MeshEdgebreakerDecoderImpl = class {
     for (let c = 0; c < numCorners; ++c) {
       faces[c] = baseCornerToVertex[c];
     }
-    this._ = null;
-    this.m.pointCloud().setNumPoints(numConnectivityVerts);
+    this.fa = null;
+    this.l.pointCloud().setNumPoints(numConnectivityVerts);
+  }
+  // Builds an attribute corner table whose only seams are boundary edges (see
+  // decodeConnectivity), for a per-corner decoder that asked for it. With no
+  // interior seam every vertex ring is one attribute vertex, numbered in
+  // vertex order with isolated vertices skipped -- what the ring walk in
+  // _assignAttributeVerticesAndPoints assigns such a table, without the walk.
+  gc(ad) {
+    const ct = this.a;
+    const table = ad.connectivityData;
+    table.initEmpty(ct);
+    table.reserveSeamEdges(ad.numSeamCorners);
+    for (let s = 0; s < ad.numSeamCorners; ++s) table.addSeamEdge(ad.attributeSeamCorners[s]);
+    const numVertices = ct.numVertices();
+    const numCorners = ct.numCorners();
+    const vertexLeftmost = ct.vertexLeftmostCornerArray();
+    const cornerToVertex = ct.cornerToVertexArray();
+    const vertexIds = scratchInt32(numVertices);
+    const leftMost = scratchInt32(numVertices);
+    let numAttVertices = 0;
+    for (let v = 0; v < numVertices; ++v) {
+      const c = vertexLeftmost[v];
+      vertexIds[v] = c === kInvalidCornerIndex6 ? -1 : numAttVertices;
+      if (c !== kInvalidCornerIndex6) leftMost[numAttVertices++] = c;
+    }
+    const c2v = table.Z;
+    for (let c = 0; c < numCorners; ++c) c2v[c] = vertexIds[cornerToVertex[c]];
+    table.setRecomputedVertices(leftMost, numAttVertices);
+    ad.noInteriorSeams = false;
   }
   // One walk around every vertex ring that (a) numbers the attribute vertices
   // of every distinct attribute corner table (C++ MeshAttributeCornerTable::
@@ -5535,8 +5281,8 @@ var MeshEdgebreakerDecoderImpl = class {
   // corner of every boundary vertex, but allowed for by the C++ code) is
   // extended leftwards first, so the walk covers exactly the corners the
   // separate passes would have reached.
-  Ub(tables) {
-    const mesh = this.m.mesh();
+  lc(tables) {
+    const mesh = this.l.mesh();
     const ct = this.a;
     mesh.setNumFaces(ct.numFaces());
     const numCorners = ct.numCorners();
@@ -5544,7 +5290,7 @@ var MeshEdgebreakerDecoderImpl = class {
     const faces = mesh.faces_;
     const vertexLeftmost = ct.vertexLeftmostCornerArray();
     const baseOpposite = ct.oppositeCornerArray();
-    const isVertHole = this.$;
+    const isVertHole = this.ga;
     const numTables = tables.length;
     const attCornerToVertex = new Array(numTables);
     const edgeOnSeam = new Array(numTables);
@@ -5552,9 +5298,9 @@ var MeshEdgebreakerDecoderImpl = class {
     const leftMostMaps = new Array(numTables);
     const numAttVertices = new Int32Array(numTables);
     for (let t = 0; t < numTables; ++t) {
-      attCornerToVertex[t] = tables[t].corner_to_vertex_map_;
-      edgeOnSeam[t] = tables[t].is_edge_on_seam_;
-      vertexOnSeam[t] = tables[t].is_vertex_on_seam_;
+      attCornerToVertex[t] = tables[t].Z;
+      edgeOnSeam[t] = tables[t].Y;
+      vertexOnSeam[t] = tables[t].ma;
       leftMostMaps[t] = scratchInt32(numCorners);
     }
     const ring = scratchInt32(numCorners);
@@ -5562,9 +5308,33 @@ var MeshEdgebreakerDecoderImpl = class {
     const pointCorner = scratchInt32(numCorners);
     const idChange = scratchUint8Zeroed(numCorners);
     let numPoints = 0;
+    const plainPointId = scratchInt32(numVertices);
+    const plainVertIds = new Array(numTables);
+    for (let t = 0; t < numTables; ++t) plainVertIds[t] = scratchInt32(numVertices);
     for (let v = 0; v < numVertices; ++v) {
       const c = vertexLeftmost[v];
       if (c === kInvalidCornerIndex6) continue;
+      const hole = isVertHole[v] !== 0;
+      let anySeam = false;
+      for (let t = 0; t < numTables; ++t) {
+        if (vertexOnSeam[t][v] !== 0) {
+          anySeam = true;
+          break;
+        }
+      }
+      if (!hole && !anySeam) {
+        for (let t = 0; t < numTables; ++t) {
+          const vertId = numAttVertices[t];
+          leftMostMaps[t][vertId] = c;
+          plainVertIds[t][v] = vertId;
+          numAttVertices[t] = vertId + 1;
+        }
+        const pointId2 = numPoints++;
+        pointCorner[pointId2] = c;
+        plainPointId[v] = pointId2;
+        continue;
+      }
+      plainPointId[v] = -1;
       let start = 0;
       let k = 0;
       let actC = c;
@@ -5652,20 +5422,6 @@ var MeshEdgebreakerDecoderImpl = class {
         if (vertId !== firstVertId) idChange[first] = 1;
         numAttVertices[t] = vertId + 1;
       }
-      const hole = isVertHole[v] !== 0;
-      let anySeam = false;
-      for (let t = 0; t < numTables; ++t) {
-        if (vertexOnSeam[t][v] !== 0) {
-          anySeam = true;
-          break;
-        }
-      }
-      if (!hole && !anySeam) {
-        const pointId2 = numPoints++;
-        pointCorner[pointId2] = c;
-        for (let j2 = start; j2 < end; ++j2) faces[ring[j2]] = pointId2;
-        continue;
-      }
       let j = start;
       if (!hole) {
         for (let t = 0; t < numTables; ++t) {
@@ -5705,11 +5461,19 @@ var MeshEdgebreakerDecoderImpl = class {
         faces[rc] = pointId;
       }
     }
+    const baseCornerToVertex = ct.cornerToVertexArray();
+    for (let c = 0; c < numCorners; ++c) {
+      const v = baseCornerToVertex[c];
+      const pointId = plainPointId[v];
+      if (pointId < 0) continue;
+      faces[c] = pointId;
+      for (let t = 0; t < numTables; ++t) attCornerToVertex[t][c] = plainVertIds[t][v];
+    }
     for (let t = 0; t < numTables; ++t) {
       tables[t].setRecomputedVertices(leftMostMaps[t], numAttVertices[t]);
     }
-    this._ = pointCorner;
-    this.m.pointCloud().setNumPoints(numPoints);
+    this.fa = pointCorner;
+    this.l.pointCloud().setNumPoints(numPoints);
     return true;
   }
 };
@@ -5738,30 +5502,33 @@ var AttributeData = class {
   encodingData = new MeshAttributeIndicesEncodingData();
   attributeSeamCorners = new Int32Array(0);
   numSeamCorners = 0;
+  // Set when every seam is a boundary edge and connectivityData was therefore
+  // left unbuilt (see decodeConnectivity); cleared once it is built on demand.
+  noInteriorSeams = false;
 };
 var CornerTable = class {
-  wb = 0;
-  D = 0;
+  Pb = 0;
+  F = 0;
   j = 0;
   h = null;
   // corner -> vertex
-  n = null;
+  p = null;
   // corner -> opposite corner
-  t = null;
+  v = null;
   // vertex -> left-most corner
   reset(numFaces, numVertices) {
-    this.wb = numFaces;
-    this.D = numFaces * 3;
+    this.Pb = numFaces;
+    this.F = numFaces * 3;
     this.j = 0;
-    this.h = scratchInt32Filled(this.D, -1);
-    this.n = scratchInt32Filled(this.D, -1);
-    this.t = scratchInt32Filled(numVertices, -1);
+    this.h = scratchInt32Filled(this.F, -1);
+    this.p = scratchInt32Filled(this.F, -1);
+    this.v = scratchInt32Filled(numVertices, -1);
   }
   numFaces() {
-    return this.wb;
+    return this.Pb;
   }
   numCorners() {
-    return this.D;
+    return this.F;
   }
   numVertices() {
     return this.j;
@@ -5777,34 +5544,34 @@ var CornerTable = class {
     return rem === 0 ? corner + 2 : corner - 1;
   }
   vertex(corner) {
-    if (corner < 0 || corner >= this.D) return -1;
+    if (corner < 0 || corner >= this.F) return -1;
     return this.h[corner];
   }
   opposite(corner) {
-    if (corner < 0 || corner >= this.D) return -1;
-    return this.n[corner];
+    if (corner < 0 || corner >= this.F) return -1;
+    return this.p[corner];
   }
   // Flat-array accessors; let callers avoid polymorphic per-corner dispatch.
   cornerToVertexArray() {
     return this.h;
   }
   oppositeCornerArray() {
-    return this.n;
+    return this.p;
   }
   vertexLeftmostCornerArray() {
-    return this.t;
+    return this.v;
   }
   // Mirrors C++ CornerTable::AddNewVertex() (push_back(kInvalidCornerIndex)).
   addNewVertex() {
     const newVertex = this.j;
     this.j++;
-    if (newVertex >= this.t.length) {
-      const newCapacity = Math.max(newVertex + 1, this.t.length * 2, 64);
+    if (newVertex >= this.v.length) {
+      const newCapacity = Math.max(newVertex + 1, this.v.length * 2, 64);
       const newArr = scratchInt32Filled(newCapacity, -1);
-      newArr.set(this.t);
-      this.t = newArr;
+      newArr.set(this.v);
+      this.v = newArr;
     }
-    this.t[newVertex] = -1;
+    this.v[newVertex] = -1;
     return newVertex;
   }
   // Next corner around a vertex, CCW. SwingLeft(c) = Next(Opposite(Next(c))).
@@ -5825,24 +5592,24 @@ var CornerTable = class {
 
 // src/decoder/compression/mesh/MeshEdgebreakerTraversalDecoder.ts
 var MeshEdgebreakerTraversalDecoder = class {
-  d = new DecoderBuffer();
-  F = new DecoderBuffer();
-  Ya = null;
-  vb = [];
-  xb = 0;
+  c = new DecoderBuffer();
+  H = new DecoderBuffer();
+  hb = null;
+  Ob = [];
+  Qb = 0;
   // _symbolBuffer's bit cursor, captured once bit decoding starts: decodeSymbol
   // runs per decoded face and would otherwise reach it through two property
   // loads and a method call per read.
-  yb = null;
+  Rb = null;
   init(decoder) {
-    const srcBuffer = decoder.m.buffer();
-    this.d.init(srcBuffer.dataHead, srcBuffer.remainingSize);
+    const srcBuffer = decoder.l.buffer();
+    this.c.init(srcBuffer.dataHead, srcBuffer.remainingSize);
   }
   // Ignored by default; overridden by predictive/valence decoders.
   setNumEncodedVertices(_numVertices) {
   }
   setNumAttributeData(numData) {
-    this.xb = numData;
+    this.Qb = numData;
   }
   // Sets outBuffer to the data encoded after the traversal section.
   start(outBuffer) {
@@ -5855,19 +5622,19 @@ var MeshEdgebreakerTraversalDecoder = class {
     if (!this.decodeAttributeSeams()) {
       return false;
     }
-    outBuffer.init(this.d.dataHead, this.d.remainingSize);
+    outBuffer.init(this.c.dataHead, this.c.remainingSize);
     return true;
   }
   decodeStartFaceConfiguration() {
-    return this.Ya.decodeNextBit();
+    return this.hb.decodeNextBit();
   }
   decodeSymbol() {
-    const bd = this.yb;
+    const bd = this.Rb;
     if (bd !== null) {
-      const buf = bd.va;
+      const buf = bd.Ea;
       const off = bd.o;
       const byteOffset = off >> 3;
-      if (byteOffset + 4 < bd.da) {
+      if (byteOffset + 4 < bd.ka) {
         const bits = (buf[byteOffset] | buf[byteOffset + 1] << 8 | buf[byteOffset + 2] << 16 | buf[byteOffset + 3] << 24) >>> (off & 7) & 7;
         if ((bits & 1) === TOPOLOGY_C) {
           bd.o = off + 1;
@@ -5877,11 +5644,11 @@ var MeshEdgebreakerTraversalDecoder = class {
         return bits;
       }
     }
-    let symbol = this.F.decodeLeastSignificantBits32(1);
+    let symbol = this.H.decodeLeastSignificantBits32(1);
     if (symbol === TOPOLOGY_C) {
       return symbol;
     }
-    const symbolSuffix = this.F.decodeLeastSignificantBits32(2);
+    const symbolSuffix = this.H.decodeLeastSignificantBits32(2);
     symbol |= symbolSuffix << 1;
     return symbol;
   }
@@ -5890,39 +5657,39 @@ var MeshEdgebreakerTraversalDecoder = class {
   mergeVertices(_dest, _source) {
   }
   done() {
-    if (this.F.bitDecoderActive) {
-      this.F.endBitDecoding();
+    if (this.H.bitDecoderActive) {
+      this.H.endBitDecoding();
     }
   }
   decodeTraversalSymbols() {
-    this.F.init(this.d.dataHead, this.d.remainingSize);
-    const traversalSize = this.F.startBitDecoding(true);
+    this.H.init(this.c.dataHead, this.c.remainingSize);
+    const traversalSize = this.H.startBitDecoding(true);
     if (traversalSize === void 0) {
       return false;
     }
-    this.yb = this.F.fa;
-    this.d.init(this.F.dataHead, this.F.remainingSize);
-    if (traversalSize > this.d.remainingSize) {
+    this.Rb = this.H.la;
+    this.c.init(this.H.dataHead, this.H.remainingSize);
+    if (traversalSize > this.c.remainingSize) {
       return false;
     }
-    this.d.advance(traversalSize);
+    this.c.advance(traversalSize);
     return true;
   }
   decodeStartFaces() {
     try {
-      this.Ya = new RAnsBitDecoder();
-      return this.Ya.startDecoding(this.d);
+      this.hb = new RAnsBitDecoder();
+      return this.hb.startDecoding(this.c);
     } catch {
       return false;
     }
   }
   decodeAttributeSeams() {
-    for (let i = 0; i < this.xb; ++i) {
+    for (let i = 0; i < this.Qb; ++i) {
       const decoder = new RAnsBitDecoder();
-      if (!decoder.startDecoding(this.d)) {
+      if (!decoder.startDecoding(this.c)) {
         return false;
       }
-      this.vb.push(decoder);
+      this.Ob.push(decoder);
     }
     return true;
   }
@@ -5932,10 +5699,10 @@ var MeshEdgebreakerTraversalDecoder = class {
 var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTraversalDecoder {
   a = null;
   j = 0;
-  u = -1;
-  aa = -1;
+  x = -1;
+  ha = -1;
   i = [];
-  Za = null;
+  ib = null;
   init(decoder) {
     super.init(decoder);
     this.a = decoder.getCornerTable();
@@ -5955,24 +5722,24 @@ var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTra
       return false;
     }
     this.i = new Array(this.j).fill(0);
-    this.Za = new RAnsBitDecoder();
-    return this.Za.startDecoding(outBuffer);
+    this.ib = new RAnsBitDecoder();
+    return this.ib.startDecoding(outBuffer);
   }
   decodeSymbol() {
-    if (this.aa !== -1) {
-      if (this.Za.decodeNextBit()) {
-        this.u = this.aa;
-        return this.aa;
+    if (this.ha !== -1) {
+      if (this.ib.decodeNextBit()) {
+        this.x = this.ha;
+        return this.ha;
       }
     }
-    this.u = super.decodeSymbol();
-    return this.u;
+    this.x = super.decodeSymbol();
+    return this.x;
   }
   newActiveCornerReached(corner) {
     const ct = this.a;
     const next = ct.next(corner);
     const prev = ct.previous(corner);
-    switch (this.u) {
+    switch (this.x) {
       case TOPOLOGY_C:
       case TOPOLOGY_S:
         this.i[ct.vertex(next)] += 1;
@@ -5996,15 +5763,15 @@ var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTra
       default:
         break;
     }
-    if (this.u === TOPOLOGY_C || this.u === TOPOLOGY_R) {
+    if (this.x === TOPOLOGY_C || this.x === TOPOLOGY_R) {
       const pivot = ct.vertex(ct.next(corner));
       if (this.i[pivot] < 6) {
-        this.aa = TOPOLOGY_R;
+        this.ha = TOPOLOGY_R;
       } else {
-        this.aa = TOPOLOGY_C;
+        this.ha = TOPOLOGY_C;
       }
     } else {
-      this.aa = -1;
+      this.ha = -1;
     }
   }
   mergeVertices(dest, source) {
@@ -6016,14 +5783,14 @@ var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTra
 var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraversalDecoder {
   a = null;
   j = 0;
-  u = -1;
-  Da = -1;
-  Ea = 2;
-  _a = 7;
+  x = -1;
+  Na = -1;
+  Oa = 2;
+  jb = 7;
   i = new Int32Array(0);
-  ba = [];
+  ia = [];
   // Int32Array, not number[]: read and written once per decoded symbol.
-  sa = new Int32Array(0);
+  za = new Int32Array(0);
   // corner -> vertex of _cornerTable, cached at init(); the array is created
   // once by CornerTable.reset() before the traversal decoder is initialized and
   // never replaced, so the per-symbol hot path can read it without two property
@@ -6044,11 +5811,11 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     if (!this.decodeAttributeSeams()) {
       return false;
     }
-    outBuffer.init(this.d.dataHead, this.d.remainingSize);
+    outBuffer.init(this.c.dataHead, this.c.remainingSize);
     this.i = scratchInt32Filled(this.j, 0);
-    const numUniqueValences = this._a - this.Ea + 1;
-    this.ba = new Array(numUniqueValences);
-    this.sa = new Int32Array(numUniqueValences);
+    const numUniqueValences = this.jb - this.Oa + 1;
+    this.ia = new Array(numUniqueValences);
+    this.za = new Int32Array(numUniqueValences);
     const pending = [];
     for (let i = 0; i < numUniqueValences; ++i) {
       const numSymbols = decodeVarint(outBuffer);
@@ -6059,16 +5826,16 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
         return false;
       }
       if (numSymbols > 0) {
-        this.ba[i] = scratchUint32(numSymbols);
+        this.ia[i] = scratchUint32(numSymbols);
         const scheme = outBuffer.decodeUint8();
-        if (scheme === SymbolCodingMethod.SYMBOL_CODING_TAGGED) {
-          if (!decodeTaggedSymbols(numSymbols, 1, outBuffer, this.ba[i])) {
+        if (scheme === 0 /* SYMBOL_CODING_TAGGED */) {
+          if (!decodeTaggedSymbols(numSymbols, 1, outBuffer, this.ia[i])) {
             return false;
           }
-          this.sa[i] = numSymbols;
+          this.za[i] = numSymbols;
           continue;
         }
-        if (scheme !== SymbolCodingMethod.SYMBOL_CODING_RAW) {
+        if (scheme !== 1 /* SYMBOL_CODING_RAW */) {
           return false;
         }
         const maxBitLength = outBuffer.decodeUint8();
@@ -6085,27 +5852,27 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
         if (!decoder.startDecoding(outBuffer)) {
           return false;
         }
-        pending.push({ decoder, out: this.ba[i], count: numSymbols });
-        this.sa[i] = numSymbols;
+        pending.push({ decoder, out: this.ia[i], count: numSymbols });
+        this.za[i] = numSymbols;
       } else {
-        this.ba[i] = new Uint32Array(0);
-        this.sa[i] = 0;
+        this.ia[i] = new Uint32Array(0);
+        this.za[i] = 0;
       }
     }
-    const lockstep = pending.filter((entry) => entry.decoder.ans_.lutTable instanceof Uint8Array);
+    const lockstep = pending.filter((entry) => !entry.decoder.m.coarse);
     let p = 0;
     while (lockstep.length - p >= 3) {
       const a = lockstep[p];
       const b = lockstep[p + 1];
       const c = lockstep[p + 2];
-      ransDecodeSymbolsTrioU8(
-        a.decoder.ans_,
+      ransDecodeSymbolsTrioU16(
+        a.decoder.m,
         a.out,
         a.count,
-        b.decoder.ans_,
+        b.decoder.m,
         b.out,
         b.count,
-        c.decoder.ans_,
+        c.decoder.m,
         c.out,
         c.count
       );
@@ -6114,35 +5881,35 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     if (lockstep.length - p === 2) {
       const a = lockstep[p];
       const b = lockstep[p + 1];
-      ransDecodeSymbolsPairU8(a.decoder.ans_, a.out, a.count, b.decoder.ans_, b.out, b.count);
+      ransDecodeSymbolsPairU16(a.decoder.m, a.out, a.count, b.decoder.m, b.out, b.count);
       p += 2;
     }
     for (; p < lockstep.length; ++p) {
-      lockstep[p].decoder.ans_.decodeSymbols(lockstep[p].out, lockstep[p].count);
+      lockstep[p].decoder.m.decodeSymbols(lockstep[p].out, lockstep[p].count);
     }
     for (const entry of pending) {
-      if (!(entry.decoder.ans_.lutTable instanceof Uint8Array)) {
-        entry.decoder.ans_.decodeSymbols(entry.out, entry.count);
+      if (entry.decoder.m.coarse) {
+        entry.decoder.m.decodeSymbols(entry.out, entry.count);
       }
       entry.decoder.endDecoding();
     }
     return true;
   }
   decodeSymbol() {
-    if (this.Da !== -1) {
-      const contextCounter = --this.sa[this.Da];
+    if (this.Na !== -1) {
+      const contextCounter = --this.za[this.Na];
       if (contextCounter < 0) {
         return TOPOLOGY_INVALID;
       }
-      const symbolId = this.ba[this.Da][contextCounter];
+      const symbolId = this.ia[this.Na][contextCounter];
       if (symbolId > 4) {
         return TOPOLOGY_INVALID;
       }
-      this.u = edgeBreakerSymbolToTopologyId[symbolId];
+      this.x = edgeBreakerSymbolToTopologyId[symbolId];
     } else {
-      this.u = TOPOLOGY_E;
+      this.x = TOPOLOGY_E;
     }
-    return this.u;
+    return this.x;
   }
   newActiveCornerReached(corner) {
     const cornerToVertex = this.h;
@@ -6151,7 +5918,7 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     const prev = corner % 3 === 0 ? corner + 2 : corner - 1;
     const vertNext = cornerToVertex[next];
     const vertPrev = cornerToVertex[prev];
-    switch (this.u) {
+    switch (this.x) {
       case TOPOLOGY_C:
       case TOPOLOGY_S:
         valences[vertNext] += 1;
@@ -6177,14 +5944,14 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     }
     const activeValence = valences[vertNext];
     let clampedValence;
-    if (activeValence < this.Ea) {
-      clampedValence = this.Ea;
-    } else if (activeValence > this._a) {
-      clampedValence = this._a;
+    if (activeValence < this.Oa) {
+      clampedValence = this.Oa;
+    } else if (activeValence > this.jb) {
+      clampedValence = this.jb;
     } else {
       clampedValence = activeValence;
     }
-    this.Da = clampedValence - this.Ea;
+    this.Na = clampedValence - this.Oa;
   }
   mergeVertices(dest, source) {
     this.i[dest] += this.i[source];
@@ -6194,53 +5961,53 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
 // src/decoder/compression/mesh/MeshEdgebreakerDecoder.ts
 var MeshEdgebreakerDecoder = class extends MeshDecoder {
   // Set by initializeDecoder(), which runs before anything below is reached.
-  ca = null;
+  ja = null;
   getCornerTable() {
-    return this.ca.getCornerTable();
+    return this.ja.getCornerTable();
   }
   getAttributeCornerTable(attId) {
-    return this.ca.getAttributeCornerTable(attId);
+    return this.ja.getAttributeCornerTable(attId);
   }
   getAttributeEncodingData(attId) {
-    return this.ca.getAttributeEncodingData(attId);
+    return this.ja.getAttributeEncodingData(attId);
   }
   initializeDecoder() {
     const traversalDecoderType = this.buffer().decodeUint8();
-    const TraversalDecoderClass = traversalDecoderType === MeshEdgebreakerConnectivityEncodingMethod.MESH_EDGEBREAKER_STANDARD_ENCODING ? MeshEdgebreakerTraversalDecoder : traversalDecoderType === MeshEdgebreakerConnectivityEncodingMethod.MESH_EDGEBREAKER_PREDICTIVE_ENCODING ? MeshEdgebreakerTraversalPredictiveDecoder : traversalDecoderType === MeshEdgebreakerConnectivityEncodingMethod.MESH_EDGEBREAKER_VALENCE_ENCODING ? MeshEdgebreakerTraversalValenceDecoder : null;
+    const TraversalDecoderClass = traversalDecoderType === 0 /* MESH_EDGEBREAKER_STANDARD_ENCODING */ ? MeshEdgebreakerTraversalDecoder : traversalDecoderType === 1 /* MESH_EDGEBREAKER_PREDICTIVE_ENCODING */ ? MeshEdgebreakerTraversalPredictiveDecoder : traversalDecoderType === 2 /* MESH_EDGEBREAKER_VALENCE_ENCODING */ ? MeshEdgebreakerTraversalValenceDecoder : null;
     if (TraversalDecoderClass === null) {
       return false;
     }
-    this.ca = new MeshEdgebreakerDecoderImpl(this, TraversalDecoderClass);
+    this.ja = new MeshEdgebreakerDecoderImpl(this, TraversalDecoderClass);
     return true;
   }
   createAttributesDecoder(attDecoderId) {
-    return this.ca.createAttributesDecoder(attDecoderId);
+    return this.ja.createAttributesDecoder(attDecoderId);
   }
   decodeConnectivity() {
-    return this.ca.decodeConnectivity();
+    return this.ja.decodeConnectivity();
   }
 };
 
 // src/decoder/compression/attributes/LinearSequencer.ts
 var LinearSequencer = class {
-  Fa;
-  s = new Int32Array(0);
+  Pa;
+  u = new Int32Array(0);
   constructor(numPoints) {
-    this.Fa = numPoints;
+    this.Pa = numPoints;
   }
   generateSequence() {
-    if (this.Fa < 0) {
+    if (this.Pa < 0) {
       return false;
     }
-    const ids = new Int32Array(this.Fa);
-    for (let i = 0; i < this.Fa; ++i) {
+    const ids = new Int32Array(this.Pa);
+    for (let i = 0; i < this.Pa; ++i) {
       ids[i] = i;
     }
-    this.s = ids;
+    this.u = ids;
     return true;
   }
   getOutputPointIds() {
-    return this.s;
+    return this.u;
   }
   updatePointToAttributeIndexMapping(attribute) {
     attribute.setIdentityMapping();
@@ -6267,7 +6034,7 @@ var MeshSequentialDecoder = class extends MeshDecoder {
       return false;
     }
     if (connectivityMethod === 0) {
-      if (!this.Yb(numFaces)) {
+      if (!this.pc(numFaces)) {
         return false;
       }
     } else {
@@ -6306,7 +6073,7 @@ var MeshSequentialDecoder = class extends MeshDecoder {
       new SequentialAttributeDecodersController(new LinearSequencer(this.pointCloud().numPoints()))
     );
   }
-  Yb(numFaces) {
+  pc(numFaces) {
     const numIndices = numFaces * 3;
     const indicesBuffer = new Uint32Array(numIndices);
     if (!decodeSymbols(numIndices, 1, this.buffer(), indicesBuffer)) {
@@ -6339,9 +6106,9 @@ var MeshSequentialDecoder = class extends MeshDecoder {
 
 // src/decoder/compression/Decode.ts
 function createMeshDecoder(method) {
-  if (method === MeshEncoderMethod.MESH_SEQUENTIAL_ENCODING) {
+  if (method === 0 /* MESH_SEQUENTIAL_ENCODING */) {
     return new MeshSequentialDecoder();
-  } else if (method === MeshEncoderMethod.MESH_EDGEBREAKER_ENCODING) {
+  } else if (method === 1 /* MESH_EDGEBREAKER_ENCODING */) {
     return new MeshEdgebreakerDecoder();
   }
   throw new Error("Unsupported mesh encoding method.");
@@ -6354,7 +6121,7 @@ var Decoder = class {
     if (headerError !== "") {
       return { mesh: null, ok: false, message: headerError };
     }
-    if (header.encoderType !== EncodedGeometryType.TRIANGULAR_MESH) {
+    if (header.encoderType !== 1 /* TRIANGULAR_MESH */) {
       return { mesh: null, ok: false, message: "Input is not a Draco triangular mesh." };
     }
     try {