maplibre-gl 6.4.1 → 6.5.0

package/dist/maplibre-gl-shared-dev.mjs

@@ -1,6 +1,6 @@
 /**
 * MapLibre GL JS
-* @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v6.4.1/LICENSE.txt
+* @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v6.5.0/LICENSE.txt
 */
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -25996,8 +25996,8 @@ var SequenceVector = class extends Vector {
 //#endregion
 //#region node_modules/@maplibre/mlt/dist/vector/sequence/int32SequenceVector.js
 var Int32SequenceVector = class extends SequenceVector {
-	constructor(name, baseValue, delta, size) {
-		super(name, Int32Array.of(baseValue), delta, size);
+	constructor(name, baseValue, delta, size, isSigned) {
+		super(name, isSigned ? Int32Array.of(baseValue) : Uint32Array.of(baseValue), delta, size);
 	}
 	getValueFromBuffer(index) {
 		return this.dataBuffer[0] + index * this.delta;
@@ -26034,10 +26034,10 @@ var FeatureTable = class {
 		return this._geometryVector;
 	}
 	get propertyVectors() {
-		return this._propertyVectors;
+		return this._propertyVectors ?? [];
 	}
 	getPropertyVector(name) {
-		if (!this.propertyVectorsMap) this.propertyVectorsMap = new Map(this._propertyVectors.map((vector) => [vector.name, vector]));
+		if (!this.propertyVectorsMap) this.propertyVectorsMap = new Map(this.propertyVectors.map((vector) => [vector.name, vector]));
 		return this.propertyVectorsMap.get(name);
 	}
 	get numFeatures() {
@@ -26056,7 +26056,7 @@ var FeatureTable = class {
 			let id;
 			if (this.idVector) {
 				const idValue = this.idVector.getValue(i);
-				id = this.containsMaxSafeIntegerValues(this.idVector) && idValue !== null ? Number(idValue) : idValue;
+				if (idValue !== null) id = this.containsMaxSafeIntegerValues(this.idVector) ? Number(idValue) : idValue;
 			}
 			const geometry = {
 				coordinates: geometries[i],
@@ -26101,7 +26101,8 @@ const ScalarType = {
 };
 const ComplexType = {
 	GEOMETRY: 0,
-	STRUCT: 1
+	STRUCT: 1,
+	MAP: 2
 };
 const LogicalScalarType = { ID: 0 };
 //#endregion
@@ -28264,6 +28265,130 @@ function unpackNullableBoolean(dataStream, dataStreamSize, presentBits) {
 	return result.getBuffer();
 }
 //#endregion
+//#region node_modules/@maplibre/mlt/dist/decoding/decodingUtils.js
+function skipColumn(numStreams, tile, offset) {
+	for (let i = 0; i < numStreams; i++) {
+		const streamMetadata = decodeStreamMetadata(tile, offset);
+		offset.add(streamMetadata.byteLength);
+	}
+}
+function decodeBooleanRle(buffer, numBooleans, byteLength, pos, nullabilityBuffer) {
+	const values = decodeByteRle(buffer, Math.ceil(numBooleans / 8), byteLength, pos);
+	if (nullabilityBuffer) return unpackNullableBoolean(values, numBooleans, nullabilityBuffer);
+	return values;
+}
+function decodeByteRle(buffer, numBytes, byteLength, pos) {
+	const values = new Uint8Array(numBytes);
+	let valueOffset = 0;
+	const streamEndPos = pos.get() + byteLength;
+	while (valueOffset < numBytes) {
+		if (pos.get() >= streamEndPos) break;
+		const header = buffer[pos.increment()];
+		if (header <= 127) {
+			const numRuns = header + 3;
+			const value = buffer[pos.increment()];
+			const endValueOffset = Math.min(valueOffset + numRuns, numBytes);
+			values.fill(value, valueOffset, endValueOffset);
+			valueOffset = endValueOffset;
+		} else {
+			const numLiterals = 256 - header;
+			for (let i = 0; i < numLiterals && valueOffset < numBytes; i++) values[valueOffset++] = buffer[pos.increment()];
+		}
+	}
+	pos.set(streamEndPos);
+	return values;
+}
+function decodeFloatsLE(encodedValues, pos, numValues, nullabilityBuffer) {
+	const currentPos = pos.get();
+	const newOffset = currentPos + numValues * Float32Array.BYTES_PER_ELEMENT;
+	const newBuf = new Uint8Array(encodedValues.subarray(currentPos, newOffset)).buffer;
+	const fb = new Float32Array(newBuf);
+	pos.set(newOffset);
+	if (nullabilityBuffer) return unpackNullable(fb, nullabilityBuffer, 0);
+	return fb;
+}
+function decodeDoublesLE(encodedValues, pos, numValues, nullabilityBuffer) {
+	const currentPos = pos.get();
+	const newOffset = currentPos + numValues * Float64Array.BYTES_PER_ELEMENT;
+	const newBuf = new Uint8Array(encodedValues.subarray(currentPos, newOffset)).buffer;
+	const fb = new Float64Array(newBuf);
+	pos.set(newOffset);
+	if (nullabilityBuffer) return unpackNullable(fb, nullabilityBuffer, 0);
+	return fb;
+}
+function decodeUint32sLE(encodedValues, pos, numValues) {
+	const currentPos = pos.get();
+	const byteLength = numValues * Uint32Array.BYTES_PER_ELEMENT;
+	const view = new DataView(encodedValues.buffer, encodedValues.byteOffset, encodedValues.byteLength);
+	const values = new Uint32Array(numValues);
+	for (let i = 0; i < numValues; i++) values[i] = view.getUint32(currentPos + i * Uint32Array.BYTES_PER_ELEMENT, true);
+	pos.add(byteLength);
+	return values;
+}
+function decodeUint64sLE(encodedValues, pos, numValues) {
+	const currentPos = pos.get();
+	const byteLength = numValues * BigUint64Array.BYTES_PER_ELEMENT;
+	const view = new DataView(encodedValues.buffer, encodedValues.byteOffset, encodedValues.byteLength);
+	const values = new BigUint64Array(numValues);
+	for (let i = 0; i < numValues; i++) values[i] = view.getBigUint64(currentPos + i * BigUint64Array.BYTES_PER_ELEMENT, true);
+	pos.add(byteLength);
+	return values;
+}
+const TEXT_DECODER_MIN_LENGTH = 12;
+const utf8TextDecoder = new TextDecoder();
+function decodeString$2(buf, pos, end) {
+	if (end - pos >= TEXT_DECODER_MIN_LENGTH) return utf8TextDecoder.decode(buf.subarray(pos, end));
+	return readUtf8(buf, pos, end);
+}
+function readUtf8(buf, pos, end) {
+	let str = "";
+	let i = pos;
+	while (i < end) {
+		const b0 = buf[i];
+		let c = null;
+		let bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
+		if (i + bytesPerSequence > end) break;
+		let b1;
+		let b2;
+		let b3;
+		if (bytesPerSequence === 1) {
+			if (b0 < 128) c = b0;
+		} else if (bytesPerSequence === 2) {
+			b1 = buf[i + 1];
+			if ((b1 & 192) === 128) {
+				c = (b0 & 31) << 6 | b1 & 63;
+				if (c <= 127) c = null;
+			}
+		} else if (bytesPerSequence === 3) {
+			b1 = buf[i + 1];
+			b2 = buf[i + 2];
+			if ((b1 & 192) === 128 && (b2 & 192) === 128) {
+				c = (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
+				if (c <= 2047 || c >= 55296 && c <= 57343) c = null;
+			}
+		} else if (bytesPerSequence === 4) {
+			b1 = buf[i + 1];
+			b2 = buf[i + 2];
+			b3 = buf[i + 3];
+			if ((b1 & 192) === 128 && (b2 & 192) === 128 && (b3 & 192) === 128) {
+				c = (b0 & 15) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
+				if (c <= 65535 || c >= 1114112) c = null;
+			}
+		}
+		if (c === null) {
+			c = 65533;
+			bytesPerSequence = 1;
+		} else if (c > 65535) {
+			c -= 65536;
+			str += String.fromCharCode(c >>> 10 & 1023 | 55296);
+			c = 56320 | c & 1023;
+		}
+		str += String.fromCharCode(c);
+		i += bytesPerSequence;
+	}
+	return str;
+}
+//#endregion
 //#region node_modules/@maplibre/mlt/dist/decoding/integerStreamDecoder.js
 function decodeSignedInt32Stream(data, offset, streamMetadata, scalingData, nullabilityBuffer) {
 	return decodeSignedInt32(decodePhysicalLevelTechnique(data, offset, streamMetadata), streamMetadata, scalingData, nullabilityBuffer);
@@ -28279,13 +28404,15 @@ function decodePhysicalLevelTechnique(data, offset, streamMetadata) {
 	switch (physicalLevelTechnique) {
 		case PhysicalLevelTechnique.FAST_PFOR: return decodeFastPfor(data, streamMetadata.numValues, streamMetadata.byteLength, offset);
 		case PhysicalLevelTechnique.VARINT: return decodeVarintInt32(data, offset, streamMetadata.numValues);
-		case PhysicalLevelTechnique.NONE: {
-			const dataOffset = offset.get();
-			const byteLength = streamMetadata.byteLength;
-			offset.add(byteLength);
-			const slice = data.subarray(dataOffset, offset.get());
-			return new Uint32Array(slice);
-		}
+		case PhysicalLevelTechnique.NONE: return decodeUint32sLE(data, offset, streamMetadata.numValues);
+		default: throw new Error(`Specified physicalLevelTechnique ${physicalLevelTechnique} is not supported (yet).`);
+	}
+}
+function decodePhysicalLevelTechniqueInt64(data, offset, streamMetadata) {
+	const physicalLevelTechnique = streamMetadata.physicalLevelTechnique;
+	switch (physicalLevelTechnique) {
+		case PhysicalLevelTechnique.VARINT: return decodeVarintInt64(data, offset, streamMetadata.numValues);
+		case PhysicalLevelTechnique.NONE: return decodeUint64sLE(data, offset, streamMetadata.numValues);
 		default: throw new Error(`Specified physicalLevelTechnique ${physicalLevelTechnique} is not supported (yet).`);
 	}
 }
@@ -28309,21 +28436,28 @@ function decodeSequenceInt64Stream(data, offset, streamMetadata) {
 	return decodeZigZagSequenceRleInt64(decodeVarintInt64(data, offset, streamMetadata.numValues));
 }
 function decodeSignedInt64Stream(data, offset, streamMetadata, nullabilityBuffer) {
-	return decodeSignedInt64(decodeVarintInt64(data, offset, streamMetadata.numValues), streamMetadata, nullabilityBuffer);
+	return decodeSignedInt64(decodePhysicalLevelTechniqueInt64(data, offset, streamMetadata), streamMetadata, nullabilityBuffer);
 }
 function decodeUnsignedInt64Stream(data, offset, streamMetadata, nullabilityBuffer) {
-	return decodeUnsignedInt64(decodeVarintInt64(data, offset, streamMetadata.numValues), streamMetadata, nullabilityBuffer);
+	return decodeUnsignedInt64(decodePhysicalLevelTechniqueInt64(data, offset, streamMetadata), streamMetadata, nullabilityBuffer);
 }
-function decodeUnsignedInt64AsFloat64Stream(data, offset, streamMetadata) {
-	return decodeFloat64Values(decodeVarintFloat64(data, offset, streamMetadata.numValues), streamMetadata, false);
+function decodeUnsignedInt64AsFloat64Stream(data, offset, streamMetadata, nullabilityBuffer) {
+	const values = decodeInt64AsFloat64(data, offset, streamMetadata, false);
+	return nullabilityBuffer ? unpackNullable(values, nullabilityBuffer, 0) : values;
+}
+function decodeInt64AsFloat64(data, offset, streamMetadata, isSigned) {
+	if (streamMetadata.physicalLevelTechnique === PhysicalLevelTechnique.VARINT) return decodeFloat64Values(decodeVarintFloat64(data, offset, streamMetadata.numValues), streamMetadata, isSigned);
+	const values = decodePhysicalLevelTechniqueInt64(data, offset, streamMetadata);
+	const decodedValues = isSigned ? decodeSignedInt64(values, streamMetadata) : decodeUnsignedInt64(values, streamMetadata);
+	return Float64Array.from(decodedValues, Number);
 }
 function decodeSignedConstInt64Stream(data, offset, streamMetadata) {
-	const values = decodeVarintInt64(data, offset, streamMetadata.numValues);
+	const values = decodePhysicalLevelTechniqueInt64(data, offset, streamMetadata);
 	if (values.length === 1) return decodeZigZagInt64Value(values[0]);
 	return decodeZigZagConstRleInt64(values);
 }
 function decodeUnsignedConstInt64Stream(data, offset, streamMetadata) {
-	const values = decodeVarintInt64(data, offset, streamMetadata.numValues);
+	const values = decodePhysicalLevelTechniqueInt64(data, offset, streamMetadata);
 	if (values.length === 1) {
 		if (streamMetadata.logicalLevelTechnique1 === LogicalLevelTechnique.DELTA) return decodeZigZagInt64Value(values[0]);
 		return values[0];
@@ -28521,8 +28655,8 @@ var Int64FlatVector = class extends FixedSizeVector {
 //#endregion
 //#region node_modules/@maplibre/mlt/dist/vector/sequence/int64SequenceVector.js
 var Int64SequenceVector = class extends SequenceVector {
-	constructor(name, baseValue, delta, size) {
-		super(name, BigInt64Array.of(baseValue), delta, size);
+	constructor(name, baseValue, delta, size, isSigned) {
+		super(name, isSigned ? BigInt64Array.of(baseValue) : BigUint64Array.of(baseValue), delta, size);
 	}
 	getValueFromBuffer(index) {
 		return this.dataBuffer[0] + BigInt(index) * this.delta;
@@ -28615,17 +28749,17 @@ function convertGeometryVector(geometryVector) {
 				{
 					const numPoints = geometryOffsets[geometryOffsetsCounter] - geometryOffsets[geometryOffsetsCounter - 1];
 					geometryOffsetsCounter++;
-					const points = new Array(numPoints);
-					if (nonOffset) for (let j = 0; j < numPoints; j++) {
-						const x = vertexBuffer[vertexBufferOffset++];
-						const y = vertexBuffer[vertexBufferOffset++];
-						points[j] = new Point(x, y);
-					}
-					else for (let j = 0; j < numPoints; j++) {
-						const offset = vertexOffsets[vertexOffsetsOffset++] * 2;
-						const x = vertexBuffer[offset];
-						const y = vertexBuffer[offset + 1];
-						points[j] = new Point(x, y);
+					let points;
+					if (nonOffset) {
+						points = new Array(numPoints);
+						for (let j = 0; j < numPoints; j++) {
+							const x = vertexBuffer[vertexBufferOffset++];
+							const y = vertexBuffer[vertexBufferOffset++];
+							points[j] = new Point(x, y);
+						}
+					} else {
+						points = decodeDictionaryEncodedVertices(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numPoints, false, mortonSettings);
+						vertexOffsetsOffset += numPoints;
 					}
 					geometries[geometryCounter++] = points.map((point) => [point]);
 					partOffsetCounter += numPoints;
@@ -28645,7 +28779,7 @@ function convertGeometryVector(geometryVector) {
 						vertices = getLineStringOrRing(vertexBuffer, vertexBufferOffset, numVertices, false);
 						vertexBufferOffset += numVertices * 2;
 					} else {
-						vertices = decodeDictionaryEncodedLineStringOrRing(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, false, mortonSettings);
+						vertices = decodeDictionaryEncodedVertices(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, false, mortonSettings);
 						vertexOffsetsOffset += numVertices;
 					}
 					geometries[geometryCounter++] = [vertices];
@@ -28670,12 +28804,12 @@ function convertGeometryVector(geometryVector) {
 							vertexBufferOffset += numVertices * 2;
 						}
 					} else {
-						shell = decodeDictionaryEncodedLineStringOrRing(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, true, mortonSettings);
+						shell = decodeDictionaryEncodedVertices(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, true, mortonSettings);
 						vertexOffsetsOffset += numVertices;
 						for (let j = 0; j < rings.length; j++) {
 							numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
 							ringOffsetsCounter++;
-							rings[j] = decodeDictionaryEncodedLineStringOrRing(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, true, mortonSettings);
+							rings[j] = decodeDictionaryEncodedVertices(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, true, mortonSettings);
 							vertexOffsetsOffset += numVertices;
 						}
 					}
@@ -28699,7 +28833,7 @@ function convertGeometryVector(geometryVector) {
 							lineStrings[j] = getLineStringOrRing(vertexBuffer, vertexBufferOffset, numVertices, false);
 							vertexBufferOffset += numVertices * 2;
 						} else {
-							const vertices = decodeDictionaryEncodedLineStringOrRing(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, false, mortonSettings);
+							const vertices = decodeDictionaryEncodedVertices(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, false, mortonSettings);
 							lineStrings[j] = vertices;
 							vertexOffsetsOffset += numVertices;
 						}
@@ -28723,7 +28857,7 @@ function convertGeometryVector(geometryVector) {
 							shell = getLineStringOrRing(vertexBuffer, vertexBufferOffset, numVertices, true);
 							vertexBufferOffset += numVertices * 2;
 						} else {
-							shell = decodeDictionaryEncodedLineStringOrRing(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, true, mortonSettings);
+							shell = decodeDictionaryEncodedVertices(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, true, mortonSettings);
 							vertexOffsetsOffset += numVertices;
 						}
 						for (let k = 0; k < rings.length; k++) {
@@ -28733,7 +28867,7 @@ function convertGeometryVector(geometryVector) {
 								rings[k] = getLineStringOrRing(vertexBuffer, vertexBufferOffset, numRingVertices, true);
 								vertexBufferOffset += numRingVertices * 2;
 							} else {
-								rings[k] = decodeDictionaryEncodedLineStringOrRing(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numRingVertices, true, mortonSettings);
+								rings[k] = decodeDictionaryEncodedVertices(geometryVector.vertexBufferType, vertexBuffer, vertexOffsets, vertexOffsetsOffset, numRingVertices, true, mortonSettings);
 								vertexOffsetsOffset += numRingVertices;
 							}
 						}
@@ -28747,39 +28881,39 @@ function convertGeometryVector(geometryVector) {
 	}
 	return geometries;
 }
-function decodeDictionaryEncodedLineStringOrRing(vertexBufferType, vertexBuffer, vertexOffsets, vertexOffset, numVertices, closeLineString, mortonSettings) {
-	if (vertexBufferType === VertexBufferType.MORTON) return decodeMortonDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffset, numVertices, closeLineString, mortonSettings);
-	else return decodeDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffset, numVertices, closeLineString);
+function decodeDictionaryEncodedVertices(vertexBufferType, vertexBuffer, vertexOffsets, vertexOffset, numVertices, isRing, mortonSettings) {
+	if (vertexBufferType === VertexBufferType.MORTON) return decodeMortonDictionaryEncodedVertices(vertexBuffer, vertexOffsets, vertexOffset, numVertices, isRing, mortonSettings);
+	else return decodeVec2DictionaryEncodedVertices(vertexBuffer, vertexOffsets, vertexOffset, numVertices, isRing);
 }
-function getLineStringOrRing(vertexBuffer, startIndex, numVertices, closeLineString) {
-	const vertices = new Array(closeLineString ? numVertices + 1 : numVertices);
+function getLineStringOrRing(vertexBuffer, startIndex, numVertices, isRing) {
+	const vertices = new Array(isRing ? numVertices + 1 : numVertices);
 	for (let i = 0; i < numVertices * 2; i += 2) {
 		const x = vertexBuffer[startIndex + i];
 		const y = vertexBuffer[startIndex + i + 1];
 		vertices[i / 2] = new Point(x, y);
 	}
-	if (closeLineString) vertices[vertices.length - 1] = vertices[0];
+	if (isRing) vertices[vertices.length - 1] = vertices[0];
 	return vertices;
 }
-function decodeDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffset, numVertices, closeLineString) {
-	const vertices = new Array(closeLineString ? numVertices + 1 : numVertices);
+function decodeVec2DictionaryEncodedVertices(vertexBuffer, vertexOffsets, vertexOffset, numVertices, isRing) {
+	const vertices = new Array(isRing ? numVertices + 1 : numVertices);
 	for (let i = 0; i < numVertices * 2; i += 2) {
 		const offset = vertexOffsets[vertexOffset + i / 2] * 2;
 		const x = vertexBuffer[offset];
 		const y = vertexBuffer[offset + 1];
 		vertices[i / 2] = new Point(x, y);
 	}
-	if (closeLineString) vertices[vertices.length - 1] = vertices[0];
+	if (isRing) vertices[vertices.length - 1] = vertices[0];
 	return vertices;
 }
-function decodeMortonDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffset, numVertices, closeLineString, mortonSettings) {
-	const vertices = new Array(closeLineString ? numVertices + 1 : numVertices);
+function decodeMortonDictionaryEncodedVertices(vertexBuffer, vertexOffsets, vertexOffset, numVertices, isRing, mortonSettings) {
+	const vertices = new Array(isRing ? numVertices + 1 : numVertices);
 	for (let i = 0; i < numVertices; i++) {
 		const mortonEncodedVertex = vertexBuffer[vertexOffsets[vertexOffset + i]];
 		const vertex = decodeZOrderCurve(mortonEncodedVertex, mortonSettings.numBits, mortonSettings.coordinateShift);
 		vertices[i] = new Point(vertex.x, vertex.y);
 	}
-	if (closeLineString) vertices[vertices.length - 1] = vertices[0];
+	if (isRing) vertices[vertices.length - 1] = vertices[0];
 	return vertices;
 }
 //#endregion
@@ -28900,67 +29034,11 @@ var GpuVector = class {
 	get topologyVector() {
 		return this._topologyVector;
 	}
-	/**
-	* Returns geometries as coordinate arrays by extracting polygon outlines from topology.
-	* The vertexBuffer contains the outline vertices, separate from the tessellated triangles.
-	*/
 	getGeometries() {
 		if (!this._topologyVector) throw new Error("Cannot convert GpuVector to coordinates without topology information");
-		const geometries = new Array(this.numGeometries);
-		const topology = this._topologyVector;
-		const partOffsets = topology.partOffsets;
-		const ringOffsets = topology.ringOffsets;
-		const geometryOffsets = topology.geometryOffsets;
-		let vertexBufferOffset = 0;
-		let partOffsetCounter = 1;
-		let ringOffsetsCounter = 1;
-		let geometryOffsetsCounter = 1;
-		for (let i = 0; i < this.numGeometries; i++) switch (this.geometryType(i)) {
-			case GEOMETRY_TYPE.POLYGON:
-				{
-					const numRings = partOffsets[partOffsetCounter] - partOffsets[partOffsetCounter - 1];
-					partOffsetCounter++;
-					const rings = [];
-					for (let j = 0; j < numRings; j++) {
-						const numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
-						ringOffsetsCounter++;
-						const ring = [];
-						for (let k = 0; k < numVertices; k++) {
-							const x = this._vertexBuffer[vertexBufferOffset++];
-							const y = this._vertexBuffer[vertexBufferOffset++];
-							ring.push(new Point(x, y));
-						}
-						if (ring.length > 0) ring.push(ring[0]);
-						rings.push(ring);
-					}
-					geometries[i] = rings;
-					if (geometryOffsets) geometryOffsetsCounter++;
-				}
-				break;
-			case GEOMETRY_TYPE.MULTIPOLYGON: {
-				const numPolygons = geometryOffsets[geometryOffsetsCounter] - geometryOffsets[geometryOffsetsCounter - 1];
-				geometryOffsetsCounter++;
-				const allRings = [];
-				for (let p = 0; p < numPolygons; p++) {
-					const numRings = partOffsets[partOffsetCounter] - partOffsets[partOffsetCounter - 1];
-					partOffsetCounter++;
-					for (let j = 0; j < numRings; j++) {
-						const numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
-						ringOffsetsCounter++;
-						const ring = [];
-						for (let k = 0; k < numVertices; k++) {
-							const x = this._vertexBuffer[vertexBufferOffset++];
-							const y = this._vertexBuffer[vertexBufferOffset++];
-							ring.push(new Point(x, y));
-						}
-						if (ring.length > 0) ring.push(ring[0]);
-						allRings.push(ring);
-					}
-				}
-				geometries[i] = allRings;
-			}
-		}
-		return geometries;
+		const types = new Uint32Array(this.numGeometries);
+		for (let i = 0; i < this.numGeometries; i++) types[i] = this.geometryType(i);
+		return createFlatGeometryVector(types, this._topologyVector, void 0, this._vertexBuffer).getGeometries();
 	}
 	[Symbol.iterator]() {
 		return null;
@@ -29233,112 +29311,6 @@ var Int64ConstVector = class extends Vector {
 	}
 };
 //#endregion
-//#region node_modules/@maplibre/mlt/dist/decoding/decodingUtils.js
-function skipColumn(numStreams, tile, offset) {
-	for (let i = 0; i < numStreams; i++) {
-		const streamMetadata = decodeStreamMetadata(tile, offset);
-		offset.add(streamMetadata.byteLength);
-	}
-}
-function decodeBooleanRle(buffer, numBooleans, byteLength, pos, nullabilityBuffer) {
-	const values = decodeByteRle(buffer, Math.ceil(numBooleans / 8), byteLength, pos);
-	if (nullabilityBuffer) return unpackNullableBoolean(values, numBooleans, nullabilityBuffer);
-	return values;
-}
-function decodeByteRle(buffer, numBytes, byteLength, pos) {
-	const values = new Uint8Array(numBytes);
-	let valueOffset = 0;
-	const streamEndPos = pos.get() + byteLength;
-	while (valueOffset < numBytes) {
-		if (pos.get() >= streamEndPos) break;
-		const header = buffer[pos.increment()];
-		if (header <= 127) {
-			const numRuns = header + 3;
-			const value = buffer[pos.increment()];
-			const endValueOffset = Math.min(valueOffset + numRuns, numBytes);
-			values.fill(value, valueOffset, endValueOffset);
-			valueOffset = endValueOffset;
-		} else {
-			const numLiterals = 256 - header;
-			for (let i = 0; i < numLiterals && valueOffset < numBytes; i++) values[valueOffset++] = buffer[pos.increment()];
-		}
-	}
-	pos.set(streamEndPos);
-	return values;
-}
-function decodeFloatsLE(encodedValues, pos, numValues, nullabilityBuffer) {
-	const currentPos = pos.get();
-	const newOffset = currentPos + numValues * Float32Array.BYTES_PER_ELEMENT;
-	const newBuf = new Uint8Array(encodedValues.subarray(currentPos, newOffset)).buffer;
-	const fb = new Float32Array(newBuf);
-	pos.set(newOffset);
-	if (nullabilityBuffer) return unpackNullable(fb, nullabilityBuffer, 0);
-	return fb;
-}
-function decodeDoublesLE(encodedValues, pos, numValues, nullabilityBuffer) {
-	const currentPos = pos.get();
-	const newOffset = currentPos + numValues * Float64Array.BYTES_PER_ELEMENT;
-	const newBuf = new Uint8Array(encodedValues.subarray(currentPos, newOffset)).buffer;
-	const fb = new Float64Array(newBuf);
-	pos.set(newOffset);
-	if (nullabilityBuffer) return unpackNullable(fb, nullabilityBuffer, 0);
-	return fb;
-}
-const TEXT_DECODER_MIN_LENGTH = 12;
-const utf8TextDecoder = new TextDecoder();
-function decodeString$2(buf, pos, end) {
-	if (end - pos >= TEXT_DECODER_MIN_LENGTH) return utf8TextDecoder.decode(buf.subarray(pos, end));
-	return readUtf8(buf, pos, end);
-}
-function readUtf8(buf, pos, end) {
-	let str = "";
-	let i = pos;
-	while (i < end) {
-		const b0 = buf[i];
-		let c = null;
-		let bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
-		if (i + bytesPerSequence > end) break;
-		let b1;
-		let b2;
-		let b3;
-		if (bytesPerSequence === 1) {
-			if (b0 < 128) c = b0;
-		} else if (bytesPerSequence === 2) {
-			b1 = buf[i + 1];
-			if ((b1 & 192) === 128) {
-				c = (b0 & 31) << 6 | b1 & 63;
-				if (c <= 127) c = null;
-			}
-		} else if (bytesPerSequence === 3) {
-			b1 = buf[i + 1];
-			b2 = buf[i + 2];
-			if ((b1 & 192) === 128 && (b2 & 192) === 128) {
-				c = (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
-				if (c <= 2047 || c >= 55296 && c <= 57343) c = null;
-			}
-		} else if (bytesPerSequence === 4) {
-			b1 = buf[i + 1];
-			b2 = buf[i + 2];
-			b3 = buf[i + 3];
-			if ((b1 & 192) === 128 && (b2 & 192) === 128 && (b3 & 192) === 128) {
-				c = (b0 & 15) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
-				if (c <= 65535 || c >= 1114112) c = null;
-			}
-		}
-		if (c === null) {
-			c = 65533;
-			bytesPerSequence = 1;
-		} else if (c > 65535) {
-			c -= 65536;
-			str += String.fromCharCode(c >>> 10 & 1023 | 55296);
-			c = 56320 | c & 1023;
-		}
-		str += String.fromCharCode(c);
-		i += bytesPerSequence;
-	}
-	return str;
-}
-//#endregion
 //#region node_modules/@maplibre/mlt/dist/vector/variableSizeVector.js
 var VariableSizeVector = class extends Vector {
 	constructor(name, offsetBuffer, dataBuffer, sizeOrNullabilityBuffer) {
@@ -29376,6 +29348,24 @@ var StringDictionaryVector = class extends VariableSizeVector {
 //#endregion
 //#region node_modules/@maplibre/mlt/dist/decoding/fsstDecoder.js
 /**
+* Calculates the exact output size before decoding. This allows one final
+* `Uint8Array` allocation and avoids growing a JavaScript number array and
+* copying it into a typed array afterward. Traversing the compressed data
+* twice is always worthwhile here because it avoids those larger temporary
+* allocations.
+*/
+function getDecodedLength(symbolLengths, compressedData) {
+	let decodedLength = 0;
+	for (let i = 0; i < compressedData.length; i++) {
+		const symbolIndex = compressedData[i];
+		if (symbolIndex === 255) {
+			decodedLength++;
+			i++;
+		} else decodedLength += symbolLengths[symbolIndex];
+	}
+	return decodedLength;
+}
+/**
 * Decode FSST compressed data
 *
 * @param symbols           Array of symbols, where each symbol can be between 1 and 8 bytes
@@ -29384,36 +29374,50 @@ var StringDictionaryVector = class extends VariableSizeVector {
 * @returns                 Decoded data as Uint8Array
 */
 function decodeFsst(symbols, symbolLengths, compressedData) {
-	const decodedData = [];
-	const symbolOffsets = new Array(symbolLengths.length).fill(0);
+	const symbolOffsets = new Uint32Array(symbolLengths.length);
 	for (let i = 1; i < symbolLengths.length; i++) symbolOffsets[i] = symbolOffsets[i - 1] + symbolLengths[i - 1];
-	for (let i = 0; i < compressedData.length; i++) if (compressedData[i] === 255) decodedData.push(compressedData[++i]);
-	else {
-		const symbolLength = symbolLengths[compressedData[i]];
-		const symbolOffset = symbolOffsets[compressedData[i]];
-		for (let j = 0; j < symbolLength; j++) decodedData.push(symbols[symbolOffset + j]);
+	const decodedData = new Uint8Array(getDecodedLength(symbolLengths, compressedData));
+	let decodedOffset = 0;
+	for (let i = 0; i < compressedData.length; i++) {
+		const symbolIndex = compressedData[i];
+		if (symbolIndex === 255) {
+			i++;
+			decodedData[decodedOffset++] = compressedData[i];
+		} else {
+			let symbolLength = symbolLengths[symbolIndex];
+			let symbolOffset = symbolOffsets[symbolIndex];
+			while (symbolLength-- > 0) decodedData[decodedOffset++] = symbols[symbolOffset++];
+		}
 	}
-	return new Uint8Array(decodedData);
+	return decodedData;
 }
 //#endregion
 //#region node_modules/@maplibre/mlt/dist/vector/fsst-dictionary/stringFsstDictionaryVector.js
 var StringFsstDictionaryVector = class extends VariableSizeVector {
-	constructor(name, indexBuffer, offsetBuffer, dictionaryBuffer, symbolOffsetBuffer, symbolTableBuffer, nullabilityBuffer) {
+	constructor(name, indexBuffer, offsetBuffer, dictionaryBuffer, symbolOffsetBuffer, symbolTableBuffer, nullabilityBuffer, sharedDictionaryCache) {
 		super(name, offsetBuffer, dictionaryBuffer, nullabilityBuffer ?? indexBuffer.length);
 		this.indexBuffer = indexBuffer;
 		this.symbolOffsetBuffer = symbolOffsetBuffer;
 		this.symbolTableBuffer = symbolTableBuffer;
+		this.sharedDictionaryCache = sharedDictionaryCache;
 	}
 	getValueFromBuffer(index) {
 		if (this.decodedDictionary == null) {
-			if (this.symbolLengthBuffer == null) this.symbolLengthBuffer = this.offsetToLengthBuffer(this.symbolOffsetBuffer);
-			this.decodedDictionary = decodeFsst(this.symbolTableBuffer, this.symbolLengthBuffer, this.dataBuffer);
+			this.decodedDictionary = this.sharedDictionaryCache?.decodedDictionary;
+			if (this.decodedDictionary == null) {
+				this.decodedDictionary = this.decodeDictionary();
+				if (this.sharedDictionaryCache) this.sharedDictionaryCache.decodedDictionary = this.decodedDictionary;
+			}
 		}
 		const offset = this.indexBuffer[index];
 		const start = this.offsetBuffer[offset];
 		const end = this.offsetBuffer[offset + 1];
 		return decodeString$2(this.decodedDictionary, start, end);
 	}
+	decodeDictionary() {
+		if (this.symbolLengthBuffer == null) this.symbolLengthBuffer = this.offsetToLengthBuffer(this.symbolOffsetBuffer);
+		return decodeFsst(this.symbolTableBuffer, this.symbolLengthBuffer, this.dataBuffer);
+	}
 	offsetToLengthBuffer(offsetBuffer) {
 		const lengthBuffer = new Uint32Array(offsetBuffer.length - 1);
 		let previousOffset = offsetBuffer[0];
@@ -29428,14 +29432,14 @@ var StringFsstDictionaryVector = class extends VariableSizeVector {
 //#endregion
 //#region node_modules/@maplibre/mlt/dist/decoding/stringDecoder.js
 function decodeString$1(name, data, offset, numStreams, bitVector) {
-	let dictionaryLengthStream = null;
-	let offsetStream = null;
-	let dictionaryStream = null;
-	let symbolLengthStream = null;
-	let symbolTableStream = null;
-	let nullabilityBuffer = bitVector ?? null;
-	let plainLengthStream = null;
-	let plainDataStream = null;
+	let dictionaryLengthStream;
+	let offsetStream;
+	let dictionaryStream;
+	let symbolLengthStream;
+	let symbolTableStream;
+	let nullabilityBuffer = bitVector;
+	let plainLengthStream;
+	let plainDataStream;
 	for (let i = 0; i < numStreams; i++) {
 		const streamMetadata = decodeStreamMetadata(data, offset);
 		switch (streamMetadata.physicalStreamType) {
@@ -29468,15 +29472,17 @@ function decodeString$1(name, data, offset, numStreams, bitVector) {
 	return decodeFsstDictionaryVector(name, symbolTableStream, offsetStream, dictionaryLengthStream, dictionaryStream, symbolLengthStream, nullabilityBuffer) ?? decodeDictionaryVector(name, dictionaryStream, offsetStream, dictionaryLengthStream, nullabilityBuffer) ?? decodePlainStringVector(name, plainLengthStream, plainDataStream, offsetStream, nullabilityBuffer);
 }
 function decodeFsstDictionaryVector(name, symbolTableStream, offsetStream, dictionaryLengthStream, dictionaryStream, symbolLengthStream, nullabilityBuffer) {
-	if (!symbolTableStream) return null;
+	if (!symbolTableStream) return;
+	if (!offsetStream || !dictionaryLengthStream || !dictionaryStream || !symbolLengthStream) throw new Error(`Incomplete FSST dictionary string column "${name}"`);
 	return new StringFsstDictionaryVector(name, offsetStream, dictionaryLengthStream, dictionaryStream, symbolLengthStream, symbolTableStream, nullabilityBuffer);
 }
 function decodeDictionaryVector(name, dictionaryStream, offsetStream, dictionaryLengthStream, nullabilityBuffer) {
-	if (!dictionaryStream) return null;
+	if (!dictionaryStream) return;
+	if (!offsetStream || !dictionaryLengthStream) throw new Error(`Incomplete dictionary string column "${name}"`);
 	return nullabilityBuffer ? new StringDictionaryVector(name, offsetStream, dictionaryLengthStream, dictionaryStream, nullabilityBuffer) : new StringDictionaryVector(name, offsetStream, dictionaryLengthStream, dictionaryStream);
 }
 function decodePlainStringVector(name, plainLengthStream, plainDataStream, offsetStream, nullabilityBuffer) {
-	if (!plainLengthStream || !plainDataStream) return null;
+	if (!plainLengthStream || !plainDataStream) return;
 	if (offsetStream) return nullabilityBuffer ? new StringDictionaryVector(name, offsetStream, plainLengthStream, plainDataStream, nullabilityBuffer) : new StringDictionaryVector(name, offsetStream, plainLengthStream, plainDataStream);
 	if (nullabilityBuffer && nullabilityBuffer.size() !== plainLengthStream.length - 1) {
 		const sparseOffsetStream = new Uint32Array(nullabilityBuffer.size());
@@ -29488,10 +29494,10 @@ function decodePlainStringVector(name, plainLengthStream, plainDataStream, offse
 	return nullabilityBuffer ? new StringFlatVector(name, plainLengthStream, plainDataStream, nullabilityBuffer) : new StringFlatVector(name, plainLengthStream, plainDataStream);
 }
 function decodeSharedDictionary(data, offset, column, propertyColumnNames) {
-	let dictionaryOffsetBuffer = null;
-	let dictionaryBuffer = null;
-	let symbolOffsetBuffer = null;
-	let symbolTableBuffer = null;
+	let dictionaryOffsetBuffer;
+	let dictionaryBuffer;
+	let symbolOffsetBuffer;
+	let symbolTableBuffer;
 	let dictionaryStreamDecoded = false;
 	while (!dictionaryStreamDecoded) {
 		const streamMetadata = decodeStreamMetadata(data, offset);
@@ -29508,8 +29514,12 @@ function decodeSharedDictionary(data, offset, column, propertyColumnNames) {
 				offset.add(streamMetadata.byteLength);
 		}
 	}
+	if (column.type !== "complexType") throw new Error(`Shared dictionary column ${column.name} must be a complex (struct) column.`);
+	if (!dictionaryOffsetBuffer || !dictionaryBuffer) throw new Error(`Incomplete shared dictionary for column "${column.name}"`);
 	const childFields = column.complexType.children;
 	const stringDictionaryVectors = [];
+	/** Shared by every FSST child-column vector in this SharedDict and populated on first access. */
+	const sharedDictionaryCache = symbolTableBuffer ? {} : void 0;
 	let i = 0;
 	for (const childField of childFields) {
 		const numStreams = decodeVarintInt32(data, offset, 1)[0];
@@ -29529,11 +29539,320 @@ function decodeSharedDictionary(data, offset, column, propertyColumnNames) {
 			presentStreamBitVector = new BitVector(decodeBooleanRle(data, presentStreamMetadata.numValues, presentStreamMetadata.byteLength, offset), presentStreamMetadata.numValues);
 		}
 		const offsetStream = decodeUnsignedInt32Stream(data, offset, decodeStreamMetadata(data, offset), void 0, presentStreamBitVector);
-		stringDictionaryVectors[i++] = symbolTableBuffer ? new StringFsstDictionaryVector(columnName, offsetStream, dictionaryOffsetBuffer, dictionaryBuffer, symbolOffsetBuffer, symbolTableBuffer, presentStreamBitVector) : new StringDictionaryVector(columnName, offsetStream, dictionaryOffsetBuffer, dictionaryBuffer, presentStreamBitVector);
+		if (symbolTableBuffer) {
+			if (!symbolOffsetBuffer) throw new Error(`Incomplete shared FSST dictionary for column "${columnName}"`);
+			stringDictionaryVectors[i++] = new StringFsstDictionaryVector(columnName, offsetStream, dictionaryOffsetBuffer, dictionaryBuffer, symbolOffsetBuffer, symbolTableBuffer, presentStreamBitVector, sharedDictionaryCache);
+		} else stringDictionaryVectors[i++] = new StringDictionaryVector(columnName, offsetStream, dictionaryOffsetBuffer, dictionaryBuffer, presentStreamBitVector);
 	}
 	return stringDictionaryVectors;
 }
 //#endregion
+//#region node_modules/@maplibre/mlt/dist/vector/flat/objectFlatVector.js
+/**
+* Holds already-decoded values of arbitrary shape, one per feature.
+*
+* Unlike the other vectors there is no packed buffer to index into: nested property (MAP) columns
+* decode to plain JavaScript maps, arrays and scalars, so the values are kept as-is. Features
+* without a value are marked absent in the nullability buffer, so `has` reports them as missing and
+* `getValue` returns `null`.
+*/
+var ObjectFlatVector = class extends Vector {
+	constructor(name, values, nullabilityBuffer) {
+		super(name, /* @__PURE__ */ new Uint8Array(0), nullabilityBuffer ?? values.length);
+		this.values = values;
+	}
+	getValueFromBuffer(index) {
+		return this.values[index];
+	}
+};
+//#endregion
+//#region node_modules/@maplibre/mlt/dist/metadata/tile/mapMask.js
+/**
+* Bitmask written ahead of a nested property (MAP) column, marking which optional streams follow
+* the mandatory length stream. Only one of INT32/INT64 and one of UINT32/UINT64 is ever set: the
+* encoder picks the narrower width that fits every value.
+*/
+var MapMask;
+(function(MapMask) {
+	MapMask[MapMask["STRING"] = 1] = "STRING";
+	MapMask[MapMask["INT32"] = 2] = "INT32";
+	MapMask[MapMask["UINT32"] = 4] = "UINT32";
+	MapMask[MapMask["INT64"] = 8] = "INT64";
+	MapMask[MapMask["UINT64"] = 16] = "UINT64";
+	MapMask[MapMask["FLOAT"] = 32] = "FLOAT";
+	MapMask[MapMask["DOUBLE"] = 64] = "DOUBLE";
+	MapMask[MapMask["PRESENCE"] = 128] = "PRESENCE";
+})(MapMask || (MapMask = {}));
+//#endregion
+//#region node_modules/@maplibre/mlt/dist/metadata/tile/mapControlValue.js
+/**
+* Tokens in the data stream of a nested property (MAP) column. Values below `COUNT` describe the
+* structure; anything else is an index into the combined dictionary, offset by `COUNT`. Booleans are
+* encoded directly as tokens rather than being added to a dictionary.
+*/
+var MapControlValue;
+(function(MapControlValue) {
+	MapControlValue[MapControlValue["FALSE"] = 0] = "FALSE";
+	MapControlValue[MapControlValue["TRUE"] = 1] = "TRUE";
+	/** A nested map follows: this token, the payload length including these two tokens, the payload. */
+	MapControlValue[MapControlValue["START_MAP"] = 2] = "START_MAP";
+	/** A list follows, laid out the same way as START_MAP. */
+	MapControlValue[MapControlValue["START_LIST"] = 3] = "START_LIST";
+	/** Number of reserved tokens, i.e. the first dictionary index. */
+	MapControlValue[MapControlValue["COUNT"] = 4] = "COUNT";
+})(MapControlValue || (MapControlValue = {}));
+//#endregion
+//#region node_modules/@maplibre/mlt/dist/decoding/mapPropertyDecoder.js
+/**
+* Decodes a nested property (MAP) column into one vector per child column.
+*
+* The column is stored as a length stream (values per feature), a dictionary stream per value type
+* present, an optional presence stream, and a data stream of dictionary indices interleaved with
+* the control tokens that describe the map/list structure.
+*
+* Ported from the Java reference implementation (`MapPropertyDecoder`).
+*/
+function decodeMapPropertyColumn(data, offset, columnMetadata, numStreams) {
+	const columnNames = getMapColumnNames(columnMetadata);
+	if (numStreams === 0) return columnNames.map((name) => new ObjectFlatVector(name, []));
+	const streams = decodeMapStreams(data, offset, numStreams);
+	const featureCount = (streams.presentStream ? streams.presentCount : streams.lengthStream.length) / columnNames.length;
+	const vectors = [];
+	let countsCursor = 0;
+	let valuesCursor = 0;
+	for (let childIndex = 0; childIndex < columnNames.length; childIndex++) {
+		const child = decodeChildColumn(streams, childIndex, featureCount, countsCursor, valuesCursor);
+		vectors.push(new ObjectFlatVector(columnNames[childIndex], child.value, child.nullabilityBuffer));
+		countsCursor = child.countsEnd;
+		valuesCursor = child.valuesEnd;
+	}
+	return vectors;
+}
+/**
+* A single map column carries its own name. A shared column carries one child per sibling, whose
+* full name is the parent name followed by the child name.
+*/
+function getMapColumnNames(columnMetadata) {
+	const children = columnMetadata.type === "complexType" ? columnMetadata.complexType.children : void 0;
+	if (!children || children.length === 0) return [columnMetadata.name];
+	return children.map((child) => columnMetadata.name + (child.name ?? ""));
+}
+/** Reads the stream mask and every stream it announces, in the order the encoder wrote them. */
+function decodeMapStreams(data, offset, numStreams) {
+	const dictionaryMask = data[offset.get()];
+	offset.add(1);
+	const lengthStream = decodeUnsignedInt32Stream(data, offset, decodeStreamMetadata(data, offset));
+	let remainingStreams = numStreams - 1;
+	const dictionary = [];
+	if (dictionaryMask & MapMask.STRING) remainingStreams -= decodeStringDictionary(data, offset, dictionary);
+	remainingStreams -= decodeIntegerDictionaries(data, offset, dictionaryMask, dictionary);
+	remainingStreams -= decodeFloatingPointDictionaries(data, offset, dictionaryMask, dictionary);
+	let presentStream;
+	let presentCount = 0;
+	if (dictionaryMask & MapMask.PRESENCE) {
+		const presence = decodePresenceStream(data, offset);
+		presentStream = presence.value;
+		presentCount = presence.count;
+		remainingStreams--;
+	}
+	let flattenedValues = /* @__PURE__ */ new Uint32Array(0);
+	if (remainingStreams > 0) {
+		flattenedValues = decodeUnsignedInt32Stream(data, offset, decodeStreamMetadata(data, offset));
+		remainingStreams--;
+	}
+	if (remainingStreams !== 0) throw new Error(`Unexpected number of remaining streams while decoding map column: ${remainingStreams}`);
+	return {
+		lengthStream,
+		dictionary,
+		presentStream,
+		presentCount,
+		flattenedValues
+	};
+}
+/** @returns the number of streams consumed, which the string encoding decides for itself. */
+function decodeStringDictionary(data, offset, dictionary) {
+	const stringStreamCount = data[offset.get()];
+	offset.add(1);
+	const strings = decodeString$1("", data, offset, stringStreamCount);
+	if (strings) for (let i = 0; i < strings.size; i++) dictionary.push(strings.getValue(i));
+	return stringStreamCount;
+}
+/**
+* Signed and unsigned integers each get at most one stream, whose width the encoder chose to fit
+* the widest value.
+*
+* @returns the number of streams consumed.
+*/
+function decodeIntegerDictionaries(data, offset, dictionaryMask, dictionary) {
+	let consumed = 0;
+	if (dictionaryMask & MapMask.INT32) {
+		pushAll(dictionary, decodeSignedInt32Stream(data, offset, decodeStreamMetadata(data, offset)));
+		consumed++;
+	} else if (dictionaryMask & MapMask.INT64) {
+		pushAll(dictionary, decodeSignedInt64Stream(data, offset, decodeStreamMetadata(data, offset)));
+		consumed++;
+	}
+	if (dictionaryMask & MapMask.UINT32) {
+		pushAll(dictionary, decodeUnsignedInt32Stream(data, offset, decodeStreamMetadata(data, offset)));
+		consumed++;
+	} else if (dictionaryMask & MapMask.UINT64) {
+		pushAll(dictionary, decodeUnsignedInt64Stream(data, offset, decodeStreamMetadata(data, offset)));
+		consumed++;
+	}
+	return consumed;
+}
+/** @returns the number of streams consumed. */
+function decodeFloatingPointDictionaries(data, offset, dictionaryMask, dictionary) {
+	let consumed = 0;
+	if (dictionaryMask & MapMask.FLOAT) {
+		pushAll(dictionary, decodeFloatsLE(data, offset, decodeStreamMetadata(data, offset).numValues));
+		consumed++;
+	}
+	if (dictionaryMask & MapMask.DOUBLE) {
+		pushAll(dictionary, decodeDoublesLE(data, offset, decodeStreamMetadata(data, offset).numValues));
+		consumed++;
+	}
+	return consumed;
+}
+function decodePresenceStream(data, offset) {
+	const streamMetadata = decodeStreamMetadata(data, offset);
+	if (streamMetadata.physicalStreamType !== PhysicalStreamType.PRESENT) throw new Error(`Expected PRESENT stream for map column but found: ${streamMetadata.physicalStreamType}`);
+	const count = streamMetadata.numValues;
+	const streamDataStart = offset.get();
+	const value = new BitVector(decodeBooleanRle(data, count, streamMetadata.byteLength, offset), count);
+	offset.set(streamDataStart + streamMetadata.byteLength);
+	return {
+		value,
+		count
+	};
+}
+/**
+* Decodes one child column's per-feature values.
+*
+* Lengths, presence bits and tokens are all laid out child-major, so each child picks up where the
+* previous one left off.
+*/
+function decodeChildColumn(streams, childIndex, featureCount, countsCursor, valuesCursor) {
+	const { lengthStream, flattenedValues, presentStream, dictionary } = streams;
+	const presentOffset = childIndex * featureCount;
+	let presentInChild = featureCount;
+	let nullabilityBuffer;
+	if (presentStream) {
+		nullabilityBuffer = new BitVector(new Uint8Array(Math.ceil(featureCount / 8)), featureCount);
+		presentInChild = 0;
+		for (let i = 0; i < featureCount; i++) if (presentStream.get(presentOffset + i)) {
+			nullabilityBuffer.set(i, true);
+			presentInChild++;
+		}
+	}
+	const countsEnd = countsCursor + presentInChild;
+	if (countsEnd > lengthStream.length) throw new Error("Merged map counts underflow while decoding child streams");
+	const value = new Array(featureCount);
+	let countCursor = countsCursor;
+	let flattenedIndex = valuesCursor;
+	for (let featureIndex = 0; featureIndex < featureCount; featureIndex++) {
+		if (presentStream && !presentStream.get(presentOffset + featureIndex)) {
+			value[featureIndex] = null;
+			continue;
+		}
+		const endIndex = flattenedIndex + lengthStream[countCursor++];
+		if (endIndex > flattenedValues.length) throw new Error("Map value stream underflow while decoding feature payload");
+		const decoded = decodeFeatureValue(flattenedValues, flattenedIndex, endIndex, dictionary);
+		value[featureIndex] = decoded.value;
+		flattenedIndex = decoded.nextIndex;
+	}
+	let childValueCount = 0;
+	for (let i = countsCursor; i < countsEnd; i++) childValueCount += lengthStream[i];
+	const valuesEnd = valuesCursor + childValueCount;
+	if (flattenedIndex !== valuesEnd) throw new Error("Unused flattened map values remain after decode");
+	return {
+		value,
+		nullabilityBuffer,
+		countsEnd,
+		valuesEnd
+	};
+}
+/**
+* A feature's payload is a bare sequence of map entries, unless it is a single token — a root-level
+* scalar — or opens with a list token. Those two shapes are what distinguish it from map entries.
+*/
+function decodeFeatureValue(flattenedValues, startIndex, endIndex, dictionary) {
+	if (endIndex - startIndex === 1 || flattenedValues[startIndex] === MapControlValue.START_LIST) return decodeValue(flattenedValues, startIndex, endIndex, dictionary);
+	return decodeMapEntries(flattenedValues, startIndex, endIndex, dictionary);
+}
+function decodeMapEntries(flattenedValues, startIndex, endIndex, dictionary) {
+	const value = Object.create(null);
+	let index = startIndex;
+	while (index < endIndex) {
+		const key = decodeScalarByIndex(flattenedValues[index++], dictionary);
+		if (typeof key !== "string") throw new Error(`Map key dictionary index does not resolve to a string: ${key}`);
+		const decoded = decodeValue(flattenedValues, index, endIndex, dictionary);
+		value[key] = decoded.value;
+		index = decoded.nextIndex;
+	}
+	return {
+		value,
+		nextIndex: index
+	};
+}
+function decodeValue(flattenedValues, startIndex, endIndex, dictionary) {
+	if (startIndex >= endIndex) throw new Error("Unexpected end of map value stream");
+	const token = flattenedValues[startIndex];
+	if (token === MapControlValue.FALSE) return {
+		value: false,
+		nextIndex: startIndex + 1
+	};
+	if (token === MapControlValue.TRUE) return {
+		value: true,
+		nextIndex: startIndex + 1
+	};
+	if (token === MapControlValue.START_MAP) {
+		const valueEndIndex = decodeNestedPayloadEnd(flattenedValues, startIndex, endIndex);
+		return {
+			value: decodeMapEntries(flattenedValues, startIndex + 2, valueEndIndex, dictionary).value,
+			nextIndex: valueEndIndex
+		};
+	}
+	if (token === MapControlValue.START_LIST) {
+		const valueEndIndex = decodeNestedPayloadEnd(flattenedValues, startIndex, endIndex);
+		const value = [];
+		let index = startIndex + 2;
+		while (index < valueEndIndex) {
+			const nested = decodeValue(flattenedValues, index, valueEndIndex, dictionary);
+			value.push(nested.value);
+			index = nested.nextIndex;
+		}
+		return {
+			value,
+			nextIndex: valueEndIndex
+		};
+	}
+	return {
+		value: decodeScalarByIndex(token, dictionary),
+		nextIndex: startIndex + 1
+	};
+}
+/**
+* Reads the length prefix of a nested payload and returns where it ends, the counterpart of
+* `encodeNestedPayloadLength`. The length covers the two header tokens as well.
+*/
+function decodeNestedPayloadEnd(flattenedValues, startIndex, endIndex) {
+	if (startIndex + 1 >= endIndex) throw new Error("Missing length for nested map/list payload");
+	const encodedLength = flattenedValues[startIndex + 1];
+	if (encodedLength < 2) throw new Error(`Invalid nested payload length: ${encodedLength}`);
+	const valueEndIndex = startIndex + encodedLength;
+	if (valueEndIndex > endIndex) throw new Error("Nested payload exceeds containing payload bounds");
+	return valueEndIndex;
+}
+function decodeScalarByIndex(token, dictionary) {
+	const dictionaryIndex = token - MapControlValue.COUNT;
+	if (dictionaryIndex < 0 || dictionaryIndex >= dictionary.length) throw new Error(`Scalar dictionary index out of range: ${token}`);
+	return dictionary[dictionaryIndex];
+}
+function pushAll(dictionary, values) {
+	for (const value of values) dictionary.push(value);
+}
+//#endregion
 //#region node_modules/@maplibre/mlt/dist/decoding/propertyDecoder.js
 function decodePropertyColumn(data, offset, columnMetadata, numStreams, numFeatures, propertyColumnNames) {
 	if (columnMetadata.type === "scalarType") {
@@ -29543,11 +29862,12 @@ function decodePropertyColumn(data, offset, columnMetadata, numStreams, numFeatu
 		}
 		return decodeScalarPropertyColumn(numStreams, data, offset, numFeatures, columnMetadata.scalarType, columnMetadata);
 	}
+	if (columnMetadata.complexType?.physicalType === ComplexType.MAP) return decodeMapPropertyColumn(data, offset, columnMetadata, numStreams);
 	if (numStreams === 0) return null;
 	return decodeSharedDictionary(data, offset, columnMetadata, propertyColumnNames);
 }
 function decodeScalarPropertyColumn(numStreams, data, offset, numFeatures, column, columnMetadata) {
-	let nullabilityBuffer = null;
+	let nullabilityBuffer;
 	if (numStreams === 0) return null;
 	if (columnMetadata.nullable) {
 		const presentStreamMetadata = decodeStreamMetadata(data, offset);
@@ -29563,7 +29883,7 @@ function decodeScalarPropertyColumn(numStreams, data, offset, numFeatures, colum
 		case ScalarType.INT_32: return decodeInt32Column(data, offset, columnMetadata, column, sizeOrNullabilityBuffer);
 		case ScalarType.STRING: {
 			const stringDataStreams = columnMetadata.nullable ? numStreams - 1 : numStreams;
-			return decodeString$1(columnMetadata.name, data, offset, stringDataStreams, nullabilityBuffer);
+			return decodeString$1(columnMetadata.name, data, offset, stringDataStreams, nullabilityBuffer) ?? null;
 		}
 		case ScalarType.BOOLEAN: return decodeBooleanColumn(data, offset, columnMetadata, numFeatures, sizeOrNullabilityBuffer);
 		case ScalarType.UINT_64:
@@ -29606,7 +29926,7 @@ function decodeInt64Column(data, offset, column, sizeOrNullabilityBuffer, scalar
 	}
 	if (vectorType === VectorType.SEQUENCE) {
 		const id = decodeSequenceInt64Stream(data, offset, dataStreamMetadata);
-		return new Int64SequenceVector(column.name, id[0], id[1], dataStreamMetadata.numRleValues);
+		return new Int64SequenceVector(column.name, id[0], id[1], dataStreamMetadata.numRleValues, isSigned);
 	}
 	const constValue = isSigned ? decodeSignedConstInt64Stream(data, offset, dataStreamMetadata) : decodeUnsignedConstInt64Stream(data, offset, dataStreamMetadata);
 	return new Int64ConstVector(column.name, constValue, sizeOrNullabilityBuffer, isSigned);
@@ -29622,7 +29942,7 @@ function decodeInt32Column(data, offset, column, scalarColumn, sizeOrNullability
 	}
 	if (vectorType === VectorType.SEQUENCE) {
 		const id = decodeSequenceInt32Stream(data, offset, dataStreamMetadata);
-		return new Int32SequenceVector(column.name, id[0], id[1], dataStreamMetadata.numRleValues);
+		return new Int32SequenceVector(column.name, id[0], id[1], dataStreamMetadata.numRleValues, isSigned);
 	}
 	const constValue = isSigned ? decodeSignedConstInt32Stream(data, offset, dataStreamMetadata) : decodeUnsignedConstInt32Stream(data, offset, dataStreamMetadata);
 	return new Int32ConstVector(column.name, constValue, sizeOrNullabilityBuffer, isSigned);
@@ -29633,10 +29953,28 @@ function isNullabilityBuffer(sizeOrNullabilityBuffer) {
 //#endregion
 //#region node_modules/@maplibre/mlt/dist/metadata/tileset/typeMap.js
 /**
+* The single varint32 that introduces every column in the tile metadata, identifying what kind of
+* column follows. Ids occupy a small range of flagged codes, geometry has one code of its own, and
+* scalar properties are laid out from `SCALAR_BASE` upwards, two codes per type.
+*/
+const ColumnTypeCode = {
+	/** Id columns occupy 0..3. */
+	ID: 0,
+	/** Set on an id column whose values can be null. */
+	ID_NULLABLE: 1,
+	/** Set on an id column holding 64-bit rather than 32-bit ids. */
+	ID_LONG: 2,
+	GEOMETRY: 4,
+	/** Scalar properties are `SCALAR_BASE + scalarType * 2 + (nullable ? 1 : 0)`. */
+	SCALAR_BASE: 10,
+	STRUCT: 30,
+	MAP: 31
+};
+/**
 * The type code is a single varint32 that encodes:
 * - Physical or logical type
 * - Nullable flag
-* - Whether the column has a name (typeCode >= 10)
+* - Whether the column has a name (typeCode >= ColumnTypeCode.SCALAR_BASE)
 * - Whether the column has children (typeCode == 30 for STRUCT)
 * - For ID types: whether it uses long (64-bit) IDs
 */
@@ -29652,60 +29990,66 @@ function isNullabilityBuffer(sizeOrNullabilityBuffer) {
 */
 function decodeColumnType(typeCode) {
 	switch (typeCode) {
-		case 0:
-		case 1:
-		case 2:
-		case 3: {
-			const column = {};
-			column.nullable = (typeCode & 1) !== 0;
-			column.columnScope = ColumnScope.FEATURE;
-			const scalarCol = {};
-			scalarCol.type = "logicalType";
-			scalarCol.logicalType = LogicalScalarType.ID;
-			scalarCol.longID = (typeCode & 2) !== 0;
-			column.scalarType = scalarCol;
-			column.type = "scalarType";
-			return column;
-		}
-		case 4: {
-			const column = {};
-			column.nullable = false;
-			column.columnScope = ColumnScope.FEATURE;
-			const complexCol = {};
-			complexCol.type = "physicalType";
-			complexCol.physicalType = ComplexType.GEOMETRY;
-			column.type = "complexType";
-			column.complexType = complexCol;
-			return column;
-		}
-		case 30: {
-			const column = {};
-			column.nullable = false;
-			column.columnScope = ColumnScope.FEATURE;
-			const complexCol = {};
-			complexCol.type = "physicalType";
-			complexCol.physicalType = ComplexType.STRUCT;
-			column.type = "complexType";
-			column.complexType = complexCol;
-			return column;
-		}
+		case ColumnTypeCode.ID:
+		case ColumnTypeCode.ID | ColumnTypeCode.ID_NULLABLE:
+		case ColumnTypeCode.ID | ColumnTypeCode.ID_LONG:
+		case ColumnTypeCode.ID | ColumnTypeCode.ID_LONG | ColumnTypeCode.ID_NULLABLE: return {
+			nullable: (typeCode & ColumnTypeCode.ID_NULLABLE) !== 0,
+			columnScope: ColumnScope.FEATURE,
+			type: "scalarType",
+			scalarType: {
+				longID: (typeCode & ColumnTypeCode.ID_LONG) !== 0,
+				type: "logicalType",
+				logicalType: LogicalScalarType.ID
+			}
+		};
+		case ColumnTypeCode.GEOMETRY: return {
+			nullable: false,
+			columnScope: ColumnScope.FEATURE,
+			type: "complexType",
+			complexType: {
+				type: "physicalType",
+				physicalType: ComplexType.GEOMETRY,
+				children: []
+			}
+		};
+		case ColumnTypeCode.STRUCT: return {
+			nullable: false,
+			columnScope: ColumnScope.FEATURE,
+			type: "complexType",
+			complexType: {
+				type: "physicalType",
+				physicalType: ComplexType.STRUCT,
+				children: []
+			}
+		};
+		case ColumnTypeCode.MAP: return {
+			nullable: true,
+			columnScope: ColumnScope.FEATURE,
+			type: "complexType",
+			complexType: {
+				type: "physicalType",
+				physicalType: ComplexType.MAP,
+				children: []
+			}
+		};
 		default: return mapScalarType(typeCode);
 	}
 }
 /**
 * Returns true if this type code requires a name to be stored.
 * ID (0-3) and GEOMETRY (4) columns have implicit names.
-* All other types (>= 10) require explicit names.
+* All other types (>= ColumnTypeCode.SCALAR_BASE) require explicit names.
 */
 function columnTypeHasName(typeCode) {
-	return typeCode >= 10;
+	return typeCode >= ColumnTypeCode.SCALAR_BASE;
 }
 /**
 * Returns true if this type code has child fields.
-* Only STRUCT (typeCode 30) has children.
+* STRUCT (typeCode 30) and MAP (typeCode 31) have children.
 */
 function columnTypeHasChildren(typeCode) {
-	return typeCode === 30;
+	return typeCode === ColumnTypeCode.STRUCT || typeCode === ColumnTypeCode.MAP;
 }
 /**
 * Determines if a stream count needs to be read for this column.
@@ -29732,7 +30076,8 @@ function hasStreamCount(column) {
 		const complexCol = column.complexType;
 		if (complexCol.type === "physicalType") switch (complexCol.physicalType) {
 			case ComplexType.GEOMETRY:
-			case ComplexType.STRUCT: return true;
+			case ComplexType.STRUCT:
+			case ComplexType.MAP: return true;
 			default: return false;
 		}
 	}
@@ -29751,65 +30096,66 @@ function isGeometryColumn(column) {
 * Even codes are non-nullable, odd codes are nullable.
 */
 function mapScalarType(typeCode) {
-	let scalarType;
+	let physicalType;
 	switch (typeCode) {
 		case 10:
 		case 11:
-			scalarType = ScalarType.BOOLEAN;
+			physicalType = ScalarType.BOOLEAN;
 			break;
 		case 12:
 		case 13:
-			scalarType = ScalarType.INT_8;
+			physicalType = ScalarType.INT_8;
 			break;
 		case 14:
 		case 15:
-			scalarType = ScalarType.UINT_8;
+			physicalType = ScalarType.UINT_8;
 			break;
 		case 16:
 		case 17:
-			scalarType = ScalarType.INT_32;
+			physicalType = ScalarType.INT_32;
 			break;
 		case 18:
 		case 19:
-			scalarType = ScalarType.UINT_32;
+			physicalType = ScalarType.UINT_32;
 			break;
 		case 20:
 		case 21:
-			scalarType = ScalarType.INT_64;
+			physicalType = ScalarType.INT_64;
 			break;
 		case 22:
 		case 23:
-			scalarType = ScalarType.UINT_64;
+			physicalType = ScalarType.UINT_64;
 			break;
 		case 24:
 		case 25:
-			scalarType = ScalarType.FLOAT;
+			physicalType = ScalarType.FLOAT;
 			break;
 		case 26:
 		case 27:
-			scalarType = ScalarType.DOUBLE;
+			physicalType = ScalarType.DOUBLE;
 			break;
 		case 28:
 		case 29:
-			scalarType = ScalarType.STRING;
+			physicalType = ScalarType.STRING;
 			break;
 		default: return null;
 	}
-	const column = {};
-	column.nullable = (typeCode & 1) !== 0;
-	column.columnScope = ColumnScope.FEATURE;
-	const scalarCol = {};
-	scalarCol.type = "physicalType";
-	scalarCol.physicalType = scalarType;
-	column.type = "scalarType";
-	column.scalarType = scalarCol;
-	return column;
+	return {
+		nullable: (typeCode & 1) !== 0,
+		columnScope: ColumnScope.FEATURE,
+		type: "scalarType",
+		scalarType: {
+			longID: false,
+			type: "physicalType",
+			physicalType
+		}
+	};
 }
 //#endregion
 //#region node_modules/@maplibre/mlt/dist/metadata/tileset/embeddedTilesetMetadataDecoder.js
 const textDecoder = new TextDecoder();
-const SUPPORTED_COLUMN_TYPES = "0-3(ID), 4(GEOMETRY), 10-29(scalars), 30(STRUCT)";
-const SUPPORTED_FIELD_TYPES = "10-29(scalars), 30(STRUCT)";
+const SUPPORTED_COLUMN_TYPES = "0-3(ID), 4(GEOMETRY), 10-29(scalars), 30(STRUCT), 31(MAP)";
+const SUPPORTED_FIELD_TYPES = "10-29(scalars), 30(STRUCT), 31(MAP)";
 /**
 * Decodes a length-prefixed UTF-8 string.
 * Layout: [len: varint32][bytes: len]
@@ -29828,12 +30174,18 @@ function decodeString(src, offset) {
 * Used when decoding Field metadata which has the same format as Column.
 */
 function columnToField(column) {
-	return {
-		name: column.name,
-		nullable: column.nullable,
+	const name = column.name;
+	const nullable = column.nullable;
+	return column.type === "scalarType" ? {
+		type: "scalarField",
 		scalarField: column.scalarType,
+		name,
+		nullable
+	} : {
+		type: "complexField",
 		complexField: column.complexType,
-		type: column.type === "scalarType" ? "scalarField" : "complexField"
+		name,
+		nullable
 	};
 }
 /**
@@ -29841,13 +30193,17 @@ function columnToField(column) {
 */
 function decodeField(src, offset) {
 	const typeCode = decodeVarintInt32(src, offset, 1)[0] >>> 0;
-	if (typeCode < 10 || typeCode > 30) throw new Error(`Unsupported field type code ${typeCode}. Supported: ${SUPPORTED_FIELD_TYPES}`);
-	const column = decodeColumnType(typeCode);
-	if (columnTypeHasName(typeCode)) column.name = decodeString(src, offset);
-	if (columnTypeHasChildren(typeCode)) {
+	const base = typeCode >= ColumnTypeCode.SCALAR_BASE ? decodeColumnType(typeCode) : null;
+	if (!base) throw new Error(`Unsupported field type code ${typeCode}. Supported: ${SUPPORTED_FIELD_TYPES}`);
+	const column = {
+		...base,
+		name: decodeString(src, offset)
+	};
+	if (column.type === "complexType" && columnTypeHasChildren(typeCode)) {
+		const complexCol = column.complexType;
 		const childCount = decodeVarintInt32(src, offset, 1)[0] >>> 0;
-		column.complexType.children = new Array(childCount);
-		for (let i = 0; i < childCount; i++) column.complexType.children[i] = decodeField(src, offset);
+		complexCol.children = new Array(childCount);
+		for (let i = 0; i < childCount; i++) complexCol.children[i] = decodeField(src, offset);
 	}
 	return columnToField(column);
 }
@@ -29856,12 +30212,18 @@ function decodeField(src, offset) {
 */
 function decodeColumn(src, offset) {
 	const typeCode = decodeVarintInt32(src, offset, 1)[0] >>> 0;
-	const column = decodeColumnType(typeCode);
-	if (!column) throw new Error(`Unsupported column type code ${typeCode}. Supported: ${SUPPORTED_COLUMN_TYPES}`);
-	if (columnTypeHasName(typeCode)) column.name = decodeString(src, offset);
-	else if (typeCode >= 0 && typeCode <= 3) column.name = "id";
-	else if (typeCode === 4) column.name = "geometry";
-	if (columnTypeHasChildren(typeCode)) {
+	const base = decodeColumnType(typeCode);
+	if (!base) throw new Error(`Unsupported column type code ${typeCode}. Supported: ${SUPPORTED_COLUMN_TYPES}`);
+	let name;
+	if (columnTypeHasName(typeCode)) name = decodeString(src, offset);
+	else if (typeCode < ColumnTypeCode.GEOMETRY) name = "id";
+	else if (typeCode === ColumnTypeCode.GEOMETRY) name = "geometry";
+	else throw new Error(`Unsupported column type code ${typeCode}. Supported: ${SUPPORTED_COLUMN_TYPES}`);
+	const column = {
+		...base,
+		name
+	};
+	if (column.type === "complexType" && columnTypeHasChildren(typeCode)) {
 		const childCount = decodeVarintInt32(src, offset, 1)[0] >>> 0;
 		const complexCol = column.complexType;
 		complexCol.children = new Array(childCount);
@@ -29906,7 +30268,8 @@ function decodeTile(tile, geometryScaling, idWithinMaxSafeInteger = true) {
 		const blockLength = decodeVarintInt32(tile, offset, 1)[0] >>> 0;
 		const blockEnd = offset.get() + blockLength;
 		if (blockEnd > tile.length) throw new Error(`Block overruns tile: ${blockEnd} > ${tile.length}`);
-		if (decodeVarintInt32(tile, offset, 1)[0] >>> 0 !== 1) {
+		const tag = decodeVarintInt32(tile, offset, 1)[0] >>> 0;
+		if (tag !== 1 && tag !== 2) {
 			offset.set(blockEnd);
 			continue;
 		}
@@ -29956,26 +30319,24 @@ function decodeTile(tile, geometryScaling, idWithinMaxSafeInteger = true) {
 	return featureTables;
 }
 function decodeIdColumn(tile, columnMetadata, offset, columnName, idDataStreamMetadata, sizeOrNullabilityBuffer, idWithinMaxSafeInteger = false) {
-	const scalarTypeMetadata = columnMetadata.scalarType;
-	if (scalarTypeMetadata?.type !== "logicalType" || scalarTypeMetadata.logicalType !== LogicalScalarType.ID) throw new Error(`ID column must be a logical ID scalar type: ${columnName}`);
-	const idDataType = scalarTypeMetadata.longID ? ScalarType.UINT_64 : ScalarType.UINT_32;
+	const idDataType = columnMetadata.scalarType?.longID ? ScalarType.UINT_64 : ScalarType.UINT_32;
 	const nullabilityBuffer = typeof sizeOrNullabilityBuffer === "number" ? void 0 : sizeOrNullabilityBuffer;
 	const vectorType = getVectorType(idDataStreamMetadata, sizeOrNullabilityBuffer, tile, offset, idDataType === ScalarType.UINT_64 ? "int64" : "int32");
 	if (idDataType === ScalarType.UINT_32) switch (vectorType) {
 		case VectorType.FLAT: return new Int32FlatVector(columnName, decodeUnsignedInt32Stream(tile, offset, idDataStreamMetadata, void 0, nullabilityBuffer), sizeOrNullabilityBuffer);
 		case VectorType.SEQUENCE: {
 			const id = decodeSequenceInt32Stream(tile, offset, idDataStreamMetadata);
-			return new Int32SequenceVector(columnName, id[0], id[1], idDataStreamMetadata.numRleValues);
+			return new Int32SequenceVector(columnName, id[0], id[1], idDataStreamMetadata.numRleValues, false);
 		}
 		case VectorType.CONST: return new Int32ConstVector(columnName, decodeUnsignedConstInt32Stream(tile, offset, idDataStreamMetadata), sizeOrNullabilityBuffer, false);
 	}
 	switch (vectorType) {
 		case VectorType.FLAT:
-			if (idWithinMaxSafeInteger) return new DoubleFlatVector(columnName, decodeUnsignedInt64AsFloat64Stream(tile, offset, idDataStreamMetadata), sizeOrNullabilityBuffer);
+			if (idWithinMaxSafeInteger) return new DoubleFlatVector(columnName, decodeUnsignedInt64AsFloat64Stream(tile, offset, idDataStreamMetadata, nullabilityBuffer), sizeOrNullabilityBuffer);
 			return new Int64FlatVector(columnName, decodeUnsignedInt64Stream(tile, offset, idDataStreamMetadata, nullabilityBuffer), sizeOrNullabilityBuffer);
 		case VectorType.SEQUENCE: {
 			const id = decodeSequenceInt64Stream(tile, offset, idDataStreamMetadata);
-			return new Int64SequenceVector(columnName, id[0], id[1], idDataStreamMetadata.numRleValues);
+			return new Int64SequenceVector(columnName, id[0], id[1], idDataStreamMetadata.numRleValues, false);
 		}
 		case VectorType.CONST: return new Int64ConstVector(columnName, decodeUnsignedConstInt64Stream(tile, offset, idDataStreamMetadata), sizeOrNullabilityBuffer, false);
 	}