parse-tmx 4.3.3 → 4.5.0

package/README.md

@@ -5,13 +5,15 @@
 [![NPM downloads][badge-npm-downloads]][url-npm]
 [![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
 
-Inspired by [tmx-map-parser](https://github.com/praghus/tmx-map-parser).
-A parser for [Tiled Map Editor](http://www.mapeditor.org/) \*.tmx files.
+This package parses \*.tmx files written by [Tiled Map Editor](http://www.mapeditor.org/). It is inspired by [tmx-map-parser](https://github.com/praghus/tmx-map-parser).
+
+Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/parse-tmx).
 
 ## Table of Contents
 
 - 🚀 [Getting Started](#getting-started)
-- 📖 [Documentation](#documentation)
+- 🧩 [Key Exports](#key-exports)
+- 📝 [Usage](#usage)
 - ⚖️ [License](#license)
 
 ---
@@ -22,33 +24,42 @@ A parser for [Tiled Map Editor](http://www.mapeditor.org/) \*.tmx files.
 pnpm i parse-tmx
 ```
 
-## <a name="documentation">📖 Documentation</a>
+## <a name="key-exports">🧩 Key Exports</a>
 
-We highly recommend you take a look at the [documentation](https://github.com/Esposter/Esposter/tree/main/openspec/specs/parse-tmx) to level up.
+| Export             | Kind      | Purpose                                                                                                      |
+| :----------------- | :-------- | :----------------------------------------------------------------------------------------------------------- |
+| `parseTileset`     | function  | Reads an external tileset file, as Tiled writes one, into the embedded tileset it holds, without a map       |
+| `parseTmx`         | function  | Parses a `.tmx` string into a `TMXParsed`, matching Phaser's tilemap export and supporting external tilesets |
+| `PropertyType`     | enum      | The types a Tiled custom property can have, such as `int` or `string`                                        |
+| `Shape`            | enum      | The shapes a Tiled object can take, such as `rectangle` or `polygon`                                         |
+| `TMXLayerParsed`   | interface | A layer as parsed: its tile data, flips, objects and properties                                              |
+| `TMXMapParsed`     | class     | The map element's attributes, with the defaults a map that omits them reads as                               |
+| `TMXParsed`        | class     | The parse result, holding the parsed map as `map`                                                            |
+| `TMXTilesetParsed` | type      | A tileset as parsed: an embedded one or an external one                                                      |
 
-### Usage
+## <a name="usage">📝 Usage</a>
 
 ```ts
 import { parseTmx } from "parse-tmx";
-// The *.tmx file can be loaded as a string or URL encoded data
-import map from "map.tmx";
+
+// The *.tmx file is read as text, here from a URL
+const xmlString = await (await fetch("/maps/dungeon.tmx")).text();
 
 // Translates the tile flips in the layer data (default: false)
 const translateFlips = true;
 
-const loadMap = async () => {
-  // parseTmx resolves to a neverthrow Result, so the map is taken from its Ok branch and an error is rethrown
-  const data = (await parseTmx(map, translateFlips)).match(
-    (tmxParsed) => tmxParsed.map,
-    (error) => {
-      throw error;
-    },
-  );
-  ...
-};
+// parseTmx resolves to a neverthrow Result, so the parsed map is taken from its Ok branch and an error is rethrown
+const { map } = (await parseTmx(xmlString, translateFlips)).match(
+  (tmxParsed) => tmxParsed,
+  (error) => {
+    throw error;
+  },
+);
+
+console.log(map.layers.length);
 ```
 
-### Example data
+### <a name="example-data">📄 Example data</a>
 
 [TMX Map Format documentation](https://doc.mapeditor.org/en/stable/reference/tmx-map-format/)
 
@@ -117,17 +128,6 @@ const loadMap = async () => {
 }
 ```
 
-### Commands
-
-Run from `packages/parse-tmx/`:
-
-```bash
-pnpm build        # compile to dist/
-pnpm test         # vitest watch mode (coverage is run from the repo root)
-pnpm lint:fix     # auto-fix lint
-pnpm typecheck    # type check
-```
-
 ## <a name="license">⚖️ License</a>
 
 This project is licensed under the [Apache-2.0 license](https://github.com/Esposter/Esposter/blob/main/LICENSE).

package/dist/index.d.ts

@@ -1,4 +1,15 @@
 import { Result, ResultAsync } from "neverthrow";
+export declare enum PropertyType {
+  Bool = "bool",
+  Class = "class",
+  Color = "color",
+  Enum = "enum",
+  File = "file",
+  Float = "float",
+  Int = "int",
+  Object = "object",
+  String = "string"
+}
 export declare enum Shape {
   Ellipse = "ellipse",
   Point = "point",

package/dist/index.js

@@ -1,5 +1,18 @@
 import { InvalidOperationError, Operation, exhaustiveGuard, getResult, getResultAsync, normalizeString } from "@esposter/shared";
 import sax from "sax";
+// src/models/PropertyType.ts
+let PropertyType = /* @__PURE__ */ function(PropertyType) {
+	PropertyType["Bool"] = "bool";
+	PropertyType["Class"] = "class";
+	PropertyType["Color"] = "color";
+	PropertyType["Enum"] = "enum";
+	PropertyType["File"] = "file";
+	PropertyType["Float"] = "float";
+	PropertyType["Int"] = "int";
+	PropertyType["Object"] = "object";
+	PropertyType["String"] = "string";
+	return PropertyType;
+}({});
 // src/models/Shape.ts
 let Shape = /* @__PURE__ */ function(Shape) {
 	Shape["Ellipse"] = "ellipse";
@@ -72,21 +85,7 @@ let Encoding = /* @__PURE__ */ function(Encoding) {
 	Encoding["Csv"] = "csv";
 	return Encoding;
 }({});
-// src/services/getDecompressedBytes.ts
-const getDecompressedBytes = async (bytes, compression) => {
-	const format = compression === "gzip" ? "gzip" : "deflate";
-	const decompressedTileStream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream(format));
-	return new Uint8Array(await new Response(decompressedTileStream).arrayBuffer());
-};
-// src/services/unpackTileBytes.ts
-const unpackTileBytes = (bytes) => {
-	if (bytes.byteLength % Uint32Array.BYTES_PER_ELEMENT !== 0) throw new InvalidOperationError(Operation.Read, "TMXLayer", `expected whole ${Uint32Array.BYTES_PER_ELEMENT}-byte tiles, received ${bytes.byteLength} bytes`);
-	const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	const tiles = new Uint32Array(bytes.byteLength / Uint32Array.BYTES_PER_ELEMENT);
-	for (let index = 0; index < tiles.length; index++) tiles[index] = dataView.getUint32(index * Uint32Array.BYTES_PER_ELEMENT, true);
-	return [...tiles];
-};
-// src/services/decodeTileData.ts
+// src/services/decodeCsv.ts
 const CSV_SEPARATOR_CODE_POINT = ",".codePointAt(0) ?? 0;
 const ZERO_CODE_POINT = "0".codePointAt(0) ?? 0;
 const NINE_CODE_POINT = "9".codePointAt(0) ?? 0;
@@ -97,8 +96,10 @@ const decodeCsv = (text) => {
 	let hasDigit = false;
 	let isEnded = false;
 	for (let index = 0; index <= text.length; index++) {
-		const codePoint = text.codePointAt(index) ?? CSV_SEPARATOR_CODE_POINT;
-		if (codePoint === CSV_SEPARATOR_CODE_POINT) {
+		const codePoint = text.codePointAt(index);
+		if (codePoint === void 0) {
+			if (hasDigit || tiles.length > 0) tiles.push(tile);
+		} else if (codePoint === CSV_SEPARATOR_CODE_POINT) {
 			tiles.push(tile);
 			tile = 0;
 			hasDigit = false;
@@ -112,6 +113,21 @@ const decodeCsv = (text) => {
 	}
 	return tiles;
 };
+// src/services/getDecompressedBytes.ts
+const getDecompressedBytes = async (bytes, compression) => {
+	const format = compression === "gzip" ? "gzip" : "deflate";
+	const decompressedTileStream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream(format));
+	return new Uint8Array(await new Response(decompressedTileStream).arrayBuffer());
+};
+// src/services/unpackTileBytes.ts
+const unpackTileBytes = (bytes) => {
+	if (bytes.byteLength % Uint32Array.BYTES_PER_ELEMENT !== 0) throw new InvalidOperationError(Operation.Read, "TMXLayer", `expected whole ${Uint32Array.BYTES_PER_ELEMENT}-byte tiles, received ${bytes.byteLength} bytes`);
+	const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const tiles = new Uint32Array(bytes.byteLength / Uint32Array.BYTES_PER_ELEMENT);
+	for (let index = 0; index < tiles.length; index++) tiles[index] = dataView.getUint32(index * Uint32Array.BYTES_PER_ELEMENT, true);
+	return [...tiles];
+};
+// src/services/decodeTileData.ts
 const decodeTileData = async (source) => {
 	const { compression, encoding, gids, text } = source;
 	if (encoding === void 0) return gids;
@@ -157,24 +173,13 @@ const assignTileData = async (pending, translateFlips) => {
 		} else owner.data = tiles;
 	}));
 };
-// src/models/PropertyType.ts
-let PropertyType = /* @__PURE__ */ function(PropertyType) {
-	PropertyType["Bool"] = "bool";
-	PropertyType["Class"] = "class";
-	PropertyType["Color"] = "color";
-	PropertyType["File"] = "file";
-	PropertyType["Float"] = "float";
-	PropertyType["Int"] = "int";
-	PropertyType["Object"] = "object";
-	PropertyType["String"] = "string";
-	return PropertyType;
-}({});
-// src/services/closeTmxFrame.ts
+// src/services/parsePropertyValue.ts
 const parsePropertyValue = (propertyType, value) => {
 	switch (propertyType) {
 		case "bool": return value === "true";
 		case "class":
 		case "color":
+		case "enum":
 		case "file":
 		case "object":
 		case "string": return value;
@@ -183,6 +188,7 @@ const parsePropertyValue = (propertyType, value) => {
 		default: return exhaustiveGuard(propertyType);
 	}
 };
+// src/services/closeTmxFrame.ts
 const closeTmxFrame = (frame) => {
 	switch (frame.tag) {
 		case "chunk":
@@ -223,6 +229,75 @@ const imageAttributeKindMap = {
 	width: "requiredNumber"
 };
 const createTmxImage = (attributes) => readTmxAttributes(attributes, imageAttributeKindMap);
+// src/services/createDataSource.ts
+const createDataSource = (compression, encoding) => ({
+	chunked: false,
+	compression,
+	encoding,
+	gids: [],
+	text: ""
+});
+// src/services/parseEnumAttribute.ts
+const parseEnumAttribute = (operation, label, enumObject, value) => {
+	if (value === void 0) return void 0;
+	const enumValue = Object.values(enumObject).find((member) => member === value);
+	if (enumValue !== void 0) return enumValue;
+	throw new InvalidOperationError(Operation.Read, operation, `${value} is not a supported ${label}`);
+};
+// src/services/parseCompression.ts
+const parseCompression = (value) => parseEnumAttribute(parseCompression.name, "compression", Compression, value);
+// src/services/parseEncoding.ts
+const parseEncoding = (value) => parseEnumAttribute(parseEncoding.name, "encoding", Encoding, value);
+// src/services/openTileData.ts
+const openTileData = (layer, attributes, context) => {
+	const source = createDataSource(parseCompression(attributes.compression), parseEncoding(attributes.encoding));
+	context.pending.push({
+		expectedCount: context.tileCount,
+		owner: layer,
+		source
+	});
+	return {
+		owner: layer,
+		tag: "data",
+		target: source,
+		text: ""
+	};
+};
+// src/services/openTmxDataChild.ts
+const gidAttributeKindMap = { gid: "requiredNumber" };
+const chunkAttributeKindMap = {
+	height: "requiredNumber",
+	width: "requiredNumber",
+	x: "requiredNumber",
+	y: "requiredNumber"
+};
+const openTmxDataChild = (parent, tag, attributes, context) => {
+	const source = parent.target;
+	switch (tag) {
+		case "chunk": {
+			if (parent.tag !== "data") return void 0;
+			const chunk = readTmxAttributes(attributes, chunkAttributeKindMap);
+			parent.owner.chunks ??= [];
+			parent.owner.chunks.push(chunk);
+			source.chunked = true;
+			const chunkSource = createDataSource(source.compression, source.encoding);
+			context.pending.push({
+				expectedCount: chunk.width * chunk.height,
+				owner: chunk,
+				source: chunkSource
+			});
+			return {
+				tag,
+				target: chunkSource,
+				text: ""
+			};
+		}
+		case "tile":
+			source.gids.push(readTmxAttributes(attributes, gidAttributeKindMap).gid);
+			return;
+		default: return;
+	}
+};
 // src/services/openTmxLayer.ts
 const groupAttributeKindMap = {
 	class: "string",
@@ -280,96 +355,88 @@ const openTmxProperties = (target) => {
 		text: ""
 	};
 };
-// src/services/parseEnumAttribute.ts
-const parseEnumAttribute = (operation, label, enumObject, value) => {
-	if (value === void 0) return void 0;
-	const enumValue = Object.values(enumObject).find((member) => member === value);
-	if (enumValue !== void 0) return enumValue;
-	throw new InvalidOperationError(Operation.Read, operation, `${value} is not a supported ${label}`);
-};
 // src/services/openTmxLayerChild.ts
-const gidAttributeKindMap = { gid: "requiredNumber" };
-const chunkAttributeKindMap = {
-	height: "requiredNumber",
-	width: "requiredNumber",
-	x: "requiredNumber",
-	y: "requiredNumber"
-};
-const parseCompression = (value) => parseEnumAttribute(parseCompression.name, "compression", Compression, value);
-const parseEncoding = (value) => parseEnumAttribute(parseEncoding.name, "encoding", Encoding, value);
-const createDataSource = (compression, encoding) => ({
-	chunked: false,
-	compression,
-	encoding,
-	gids: [],
-	text: ""
-});
-const openTileData = (layer, attributes, context) => {
-	const source = createDataSource(parseCompression(attributes.compression), parseEncoding(attributes.encoding));
-	context.pending.push({
-		expectedCount: context.tileCount,
-		owner: layer,
-		source
-	});
-	return {
-		owner: layer,
-		tag: "data",
-		target: source,
-		text: ""
-	};
-};
-const openTmxDataChild = (parent, tag, attributes, context) => {
-	const source = parent.target;
+const openTmxLayerChild = (parent, tag, attributes, context) => {
+	if (parent.tag === "chunk" || parent.tag === "data") return openTmxDataChild(parent, tag, attributes, context);
 	switch (tag) {
-		case "chunk": {
-			if (parent.tag !== "data") return void 0;
-			const chunk = readTmxAttributes(attributes, chunkAttributeKindMap);
-			parent.owner.chunks ??= [];
-			parent.owner.chunks.push(chunk);
-			source.chunked = true;
-			const chunkSource = createDataSource(source.compression, source.encoding);
-			context.pending.push({
-				owner: chunk,
-				source: chunkSource
-			});
+		case "data": if (parent.tag === "layer") return openTileData(parent.target, attributes, context);
+		else return void 0;
+		case "group":
+		case "imagelayer":
+		case "layer":
+		case "objectgroup": if (parent.tag === "group") return openTmxLayer(parent.target.layers, tag, attributes);
+		else return void 0;
+		case "image":
+			if (parent.tag !== "imagelayer") return void 0;
+			parent.target.image = createTmxImage(attributes);
 			return {
 				tag,
-				target: chunkSource,
+				target: parent.target.image,
 				text: ""
 			};
-		}
-		case "tile":
-			source.gids.push(readTmxAttributes(attributes, gidAttributeKindMap).gid);
-			return;
+		case "properties": return openTmxProperties(parent.target);
 		default: return;
 	}
 };
-const openTmxLayerChild = (parent, tag, attributes, context) => {
-	if (parent.tag === "chunk" || parent.tag === "data") return openTmxDataChild(parent, tag, attributes, context);
+// src/services/createEmbeddedTileset.ts
+const embeddedTilesetAttributeKindMap = {
+	columns: "requiredNumber",
+	firstgid: "requiredNumber",
+	margin: "number",
+	name: "requiredString",
+	spacing: "number",
+	tilecount: "requiredNumber",
+	tileheight: "requiredNumber",
+	tilewidth: "requiredNumber"
+};
+const createEmbeddedTileset = (attributes) => ({
+	...readTmxAttributes(attributes, embeddedTilesetAttributeKindMap),
+	tiles: []
+});
+// src/services/openTmxMapChild.ts
+const externalTilesetAttributeKindMap = {
+	firstgid: "requiredNumber",
+	source: "requiredString"
+};
+const openTmxMapChild = (parent, name, tag, attributes) => {
+	const map = parent.target;
 	switch (tag) {
 		case "data":
-			if (parent.tag !== "layer") return void 0;
-			return openTileData(parent.target, attributes, context);
+		case "export":
+		case "image":
+		case "object":
+		case "property": return;
+		case "editorsettings": {
+			const editorSettings = {};
+			map.editorsettings = editorSettings;
+			return {
+				tag,
+				target: editorSettings,
+				text: ""
+			};
+		}
 		case "group":
 		case "imagelayer":
 		case "layer":
-		case "objectgroup":
-			if (parent.tag !== "group") return void 0;
-			return openTmxLayer(parent.target.layers, tag, attributes);
-		case "image":
-			if (parent.tag !== "imagelayer") return void 0;
-			parent.target.image = createTmxImage(attributes);
+		case "objectgroup": return openTmxLayer(map.layers, tag, attributes);
+		case "properties": return openTmxProperties(map);
+		case "tileset": {
+			if (attributes.source !== void 0) {
+				map.tilesets.push(readTmxAttributes(attributes, externalTilesetAttributeKindMap));
+				return;
+			}
+			const tileset = createEmbeddedTileset(attributes);
+			map.tilesets.push(tileset);
 			return {
 				tag,
-				target: parent.target.image,
+				target: tileset,
 				text: ""
 			};
-		case "properties": return openTmxProperties(parent.target);
-		default: return;
+		}
+		default: throw new InvalidOperationError(Operation.Read, openTmxMapChild.name, `${name} is not a map child`);
 	}
 };
-// src/services/openTmxObjectChild.ts
-const NUMBER_REGEX = /^[+-]?\d+(?:\.\d+)?$/u;
+// src/services/createObject.ts
 const objectAttributeKindMap = {
 	gid: "number",
 	height: "requiredNumber",
@@ -390,7 +457,7 @@ const createObject = (attributes) => {
 		shape: "rectangle"
 	};
 	if (gid === void 0) return shaped;
-	return gid ? {
+	else return gid ? {
 		...shaped,
 		flips: parseFlips(gid),
 		gid: parseTileId(gid)
@@ -399,20 +466,25 @@ const createObject = (attributes) => {
 		gid
 	};
 };
-const parsePoints = (points) => points === "" ? [] : points.split(" ").map((point) => {
-	const [x = "", y = ""] = point.split(",");
-	return [Number(x), Number(y)];
-});
+// src/services/parseUntypedValue.ts
+const NUMBER_REGEX = /^[+-]?\d+(?:\.\d+)?$/u;
 const parseUntypedValue = (value) => {
 	if (value === "true") return true;
 	else if (value === "false") return false;
 	else if (NUMBER_REGEX.test(value)) return Number(value);
 	else return value;
 };
+// src/services/createTextProperties.ts
 const createTextProperties = (attributes) => Object.entries(attributes).map(([name, value]) => ({
 	name,
 	value: parseUntypedValue(value)
 }));
+// src/services/parsePoints.ts
+const parsePoints = (points) => points === "" ? [] : points.split(" ").map((point) => {
+	const [x = "", y = ""] = point.split(",");
+	return [Number(x), Number(y)];
+});
+// src/services/openTmxObjectChild.ts
 const openTmxObjectChild = (parent, tag, attributes) => {
 	if (parent.tag === "objectgroup") {
 		if (tag === "properties") return openTmxProperties(parent.target);
@@ -456,7 +528,28 @@ const openTmxObjectChild = (parent, tag, attributes) => {
 		default: return;
 	}
 };
-// src/services/openTmxFrame.ts
+// src/services/parsePropertyType.ts
+const parsePropertyType = (value) => parseEnumAttribute(parsePropertyType.name, "property type", PropertyType, value) ?? "string";
+// src/services/openTmxPropertyChild.ts
+const propertyAttributeKindMap = { name: "requiredString" };
+const openTmxPropertyChild = (parent, tag, attributes) => {
+	if (tag !== "property") return void 0;
+	const target = {
+		...readTmxAttributes(attributes, propertyAttributeKindMap),
+		value: ""
+	};
+	parent.target.push(target);
+	return {
+		propertyType: parsePropertyType(attributes.type),
+		tag,
+		target,
+		text: "",
+		valueAttribute: attributes.value
+	};
+};
+// src/services/parseTmxTagName.ts
+const parseTmxTagName = (name) => Object.values(TMXTagName).find((tagName) => tagName === name);
+// src/services/openTmxRoot.ts
 const mapAttributeKindMap = {
 	backgroundcolor: "string",
 	compressionlevel: "number",
@@ -477,41 +570,6 @@ const mapAttributeKindMap = {
 	version: "requiredNumber",
 	width: "requiredNumber"
 };
-const embeddedTilesetAttributeKindMap = {
-	columns: "requiredNumber",
-	firstgid: "requiredNumber",
-	margin: "number",
-	name: "requiredString",
-	spacing: "number",
-	tilecount: "requiredNumber",
-	tileheight: "requiredNumber",
-	tilewidth: "requiredNumber"
-};
-const externalTilesetAttributeKindMap = {
-	firstgid: "requiredNumber",
-	source: "requiredString"
-};
-const tileAttributeKindMap = {
-	id: "requiredNumber",
-	probability: "number",
-	terrain: "string",
-	type: "string"
-};
-const animationFrameAttributeKindMap = {
-	duration: "requiredNumber",
-	tileid: "requiredNumber"
-};
-const exportAttributeKindMap = {
-	format: "requiredString",
-	target: "requiredString"
-};
-const propertyAttributeKindMap = { name: "requiredString" };
-const createEmbeddedTileset = (attributes) => ({
-	...readTmxAttributes(attributes, embeddedTilesetAttributeKindMap),
-	tiles: []
-});
-const parseTmxTagName = (name) => Object.values(TMXTagName).find((tagName) => tagName === name);
-const parsePropertyType = (value) => parseEnumAttribute(parsePropertyType.name, "property type", PropertyType, value) ?? "string";
 const openTmxRoot = (name, attributes, context) => {
 	const tag = parseTmxTagName(name);
 	switch (tag) {
@@ -524,54 +582,16 @@ const openTmxRoot = (name, attributes, context) => {
 				text: ""
 			};
 		}
-		case "tileset":
-			if (attributes.source !== void 0) return void 0;
-			return {
-				tag,
-				target: createEmbeddedTileset(attributes),
-				text: ""
-			};
+		case "tileset": if (attributes.source === void 0) return {
+			tag,
+			target: createEmbeddedTileset(attributes),
+			text: ""
+		};
+		else return void 0;
 		default: throw new InvalidOperationError(Operation.Read, openTmxRoot.name, `${name} is not a map or a tileset`);
 	}
 };
-const openTmxMapChild = (parent, name, tag, attributes) => {
-	const map = parent.target;
-	switch (tag) {
-		case "data":
-		case "export":
-		case "image":
-		case "object":
-		case "property": return;
-		case "editorsettings": {
-			const editorSettings = {};
-			map.editorsettings = editorSettings;
-			return {
-				tag,
-				target: editorSettings,
-				text: ""
-			};
-		}
-		case "group":
-		case "imagelayer":
-		case "layer":
-		case "objectgroup": return openTmxLayer(map.layers, tag, attributes);
-		case "properties": return openTmxProperties(map);
-		case "tileset": {
-			if (attributes.source !== void 0) {
-				map.tilesets.push(readTmxAttributes(attributes, externalTilesetAttributeKindMap));
-				return;
-			}
-			const tileset = createEmbeddedTileset(attributes);
-			map.tilesets.push(tileset);
-			return {
-				tag,
-				target: tileset,
-				text: ""
-			};
-		}
-		default: throw new InvalidOperationError(Operation.Read, openTmxMapChild.name, `${name} is not a map child`);
-	}
-};
+// src/services/openTmxTileChild.ts
 const openTmxTileChild = (parent, tag, attributes) => {
 	const tile = parent.target;
 	switch (tag) {
@@ -602,6 +622,13 @@ const openTmxTileChild = (parent, tag, attributes) => {
 		default: return;
 	}
 };
+// src/services/openTmxTilesetChild.ts
+const tileAttributeKindMap = {
+	id: "requiredNumber",
+	probability: "number",
+	terrain: "string",
+	type: "string"
+};
 const openTmxTilesetChild = (parent, tag, attributes) => {
 	const tileset = parent.target;
 	switch (tag) {
@@ -626,20 +653,14 @@ const openTmxTilesetChild = (parent, tag, attributes) => {
 		default: return;
 	}
 };
-const openTmxPropertyChild = (parent, tag, attributes) => {
-	if (tag !== "property") return void 0;
-	const target = {
-		...readTmxAttributes(attributes, propertyAttributeKindMap),
-		value: ""
-	};
-	parent.target.push(target);
-	return {
-		propertyType: parsePropertyType(attributes.type),
-		tag,
-		target,
-		text: "",
-		valueAttribute: attributes.value
-	};
+// src/services/openTmxFrame.ts
+const animationFrameAttributeKindMap = {
+	duration: "requiredNumber",
+	tileid: "requiredNumber"
+};
+const exportAttributeKindMap = {
+	format: "requiredString",
+	target: "requiredString"
 };
 const openTmxFrame = (parent, name, attributes, context) => {
 	if (parent === void 0) return openTmxRoot(name, attributes, context);
@@ -678,9 +699,10 @@ const openTmxFrame = (parent, name, attributes, context) => {
 		default: return;
 	}
 };
-// src/services/readTmxDocument.ts
-const BYTE_ORDER_MARK_REGEX = /^\uFEFF/u;
+// src/services/toTmxAttributes.ts
 const toTmxAttributes = (attributes) => Object.fromEntries(Object.entries(attributes).map(([name, attribute]) => [name, typeof attribute === "string" ? attribute : attribute.value]));
+// src/services/readTmxDocument.ts
+const BYTE_ORDER_MARK_REGEX = /^/u;
 const readTmxDocument = (xmlString, context) => {
 	const parser = sax.parser(true, {
 		normalize: false,
@@ -733,4 +755,4 @@ const parseTileset = (xmlString) => getResult(() => readTmxDocument(xmlString, {
 	if (root?.tag !== "tileset") throw new InvalidOperationError(Operation.Read, parseTileset.name, "has no embedded tileset root element");
 	return root.target;
 }));
-export { Shape, TMXMapParsed, TMXParsed, parseTileset, parseTmx };
+export { PropertyType, Shape, TMXMapParsed, TMXParsed, parseTileset, parseTmx };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parse-tmx",
-  "version": "4.3.3",
+  "version": "4.5.0",
   "description": "A parser for tmx.",
   "keywords": [
     "game-development",
@@ -47,18 +47,18 @@
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "test": "vitest",
-    "typecheck": "tsc"
+    "typecheck": "tsrs --fast"
   },
   "dependencies": {
-    "@esposter/shared": "4.3.3",
+    "@esposter/shared": "4.5.0",
     "neverthrow": "^8.2.0",
     "sax": "^1.6.1"
   },
   "devDependencies": {
-    "@esposter/configuration": "4.3.3",
-    "@esposter/shared-node": "4.3.3",
+    "@esposter/configuration": "4.5.0",
+    "@esposter/shared-node": "4.5.0",
     "@types/sax": "^1.2.7",
-    "tsdown": "^0.23.1"
+    "tsdown": "^0.23.5"
   },
-  "gitHead": "955bbc130ad9b28877fd4ae8efc73a045141ce01"
+  "gitHead": "e30c001f3b4b15693e75fb53092d62a97ade4d2b"
 }