parse-tmx 4.0.0 → 4.1.1

package/dist/index.js

@@ -1,166 +1,82 @@
-import { InvalidOperationError, Operation, exhaustiveGuard, normalizeString, takeOne } from "@esposter/shared";
-import { parseStringPromise } from "@esposter/xml2js";
-//#region src/models/Compression.ts
-let Compression = /* @__PURE__ */ function(Compression) {
-	Compression["Gzip"] = "gzip";
-	Compression["Zlib"] = "zlib";
-	return Compression;
-}({});
-//#endregion
-//#region src/models/Encoding.ts
-let Encoding = /* @__PURE__ */ function(Encoding) {
-	Encoding["Base64"] = "base64";
-	Encoding["Csv"] = "csv";
-	return Encoding;
-}({});
-//#endregion
-//#region src/models/Flipped.ts
-let Flipped = /* @__PURE__ */ function(Flipped) {
-	Flipped[Flipped["Diagonally"] = 536870912] = "Diagonally";
-	Flipped[Flipped["Vertically"] = 1073741824] = "Vertically";
-	Flipped[Flipped["Horizontally"] = 2147483648] = "Horizontally";
-	return Flipped;
-}({});
-const Flippeds = Object.values(Flipped).filter((value) => typeof value === "number");
-//#endregion
+import { InvalidOperationError, Operation, exhaustiveGuard, getResult, getResultAsync, normalizeString } from "@esposter/shared";
+import sax from "sax";
 //#region src/models/Shape.ts
 let Shape = /* @__PURE__ */ function(Shape) {
 	Shape["Ellipse"] = "ellipse";
 	Shape["Point"] = "point";
 	Shape["Polygon"] = "polygon";
+	Shape["Polyline"] = "polyline";
 	Shape["Rectangle"] = "rectangle";
 	return Shape;
 }({});
 //#endregion
-//#region src/models/tmx/node/BaseTMXNode.ts
-var BaseTMXNode = class {
-	"#name";
-	$;
-};
-//#endregion
-//#region src/models/tmx/node/TMXNodeType.ts
-let TMXNodeType = /* @__PURE__ */ function(TMXNodeType) {
-	TMXNodeType["Data"] = "data";
-	TMXNodeType["EditorSettings"] = "editorsettings";
-	TMXNodeType["Export"] = "export";
-	TMXNodeType["Group"] = "group";
-	TMXNodeType["Image"] = "image";
-	TMXNodeType["ImageLayer"] = "imagelayer";
-	TMXNodeType["Layer"] = "layer";
-	TMXNodeType["Object"] = "object";
-	TMXNodeType["Objectgroup"] = "objectgroup";
-	TMXNodeType["Properties"] = "properties";
-	TMXNodeType["Property"] = "property";
-	TMXNodeType["Tileset"] = "tileset";
-	return TMXNodeType;
-}({});
-//#endregion
-//#region src/models/tmx/shared/TMXMapShared.ts
-var TMXMapShared = class {
+//#region src/models/tmx/parsed/TMXMapParsed.ts
+var TMXMapParsed = class {
+	editorsettings = {};
 	height = 0;
 	infinite = 0;
+	layers = [];
 	nextlayerid = 0;
 	nextobjectid = 0;
 	orientation = "";
+	properties = [];
 	renderorder = "";
 	tiledversion = "";
 	tileheight = 0;
+	tilesets = [];
 	tilewidth = 0;
 	version = 0;
 	width = 0;
 };
 //#endregion
-//#region src/models/tmx/parsed/TMXMapParsed.ts
-var TMXMapParsed = class extends TMXMapShared {
-	editorsettings = {};
-	layers = [];
-	properties = [];
-	tilesets = [];
-	constructor(init) {
-		super();
-		Object.assign(this, init);
-	}
-};
-//#endregion
 //#region src/models/tmx/parsed/TMXParsed.ts
 var TMXParsed = class {
-	map = new TMXMapParsed();
-	constructor(map) {
-		if (map) this.map = map;
+	map;
+	constructor(map = new TMXMapParsed()) {
+		this.map = map;
 	}
 };
 //#endregion
-//#region src/services/cloneNodeWithType.ts
-const cloneNodeWithType = (node) => {
-	const attributes = structuredClone(node.$);
-	attributes.type = node["#name"];
-	return attributes;
-};
-//#endregion
-//#region src/services/parseFlips.ts
-const parseFlips = (gid) => ({
-	Diagonal: Boolean(gid & 536870912),
-	Horizontal: Boolean(gid & 2147483648),
-	Vertical: Boolean(gid & 1073741824)
-});
-//#endregion
-//#region src/services/parseObjectShape.ts
-const parseObjectShape = (node) => {
-	if ("point" in node) return "point";
-	else if ("ellipse" in node) return "ellipse";
-	else if ("polygon" in node) return "polygon";
-	else return "rectangle";
-};
-//#endregion
-//#region src/services/parseProperties.ts
-const parseProperties = (properties) => properties.flatMap(({ property }) => property.map(({ $: { name, value }, _ }) => ({
-	name,
-	value: value ?? _
-})));
-//#endregion
-//#region src/services/parseTileId.ts
-const FLIPPED_MASK = ~Flippeds.reduce((accumulator, flipped) => accumulator | flipped, 0);
-const parseTileId = (gid) => gid & FLIPPED_MASK;
-//#endregion
-//#region src/services/parseObject.ts
-const parseObject = (node) => {
-	const { $, polygon, properties, text } = node;
-	const object = structuredClone($);
-	object.shape = parseObjectShape(node);
-	if (properties) object.properties = parseProperties(properties);
-	if (polygon) object.points = takeOne(polygon).$.points.split(" ").map((point) => {
-		const points = point.split(",");
-		const x = takeOne(points);
-		const y = takeOne(points, 1);
-		return [Number(x), Number(y)];
-	});
-	if (text) {
-		const textNode = takeOne(text);
-		object.text = textNode._;
-		object.properties = [...object.properties ?? [], ...Object.entries(textNode.$ ?? {}).map(([name, value]) => ({
-			name,
-			value
-		}))];
-	}
-	if (object.gid) {
-		object.flips = parseFlips(object.gid);
-		object.gid = parseTileId(object.gid);
-	}
-	return object;
-};
+//#region src/models/tmx/TMXTagName.ts
+let TMXTagName = /* @__PURE__ */ function(TMXTagName) {
+	TMXTagName["Animation"] = "animation";
+	TMXTagName["Chunk"] = "chunk";
+	TMXTagName["Data"] = "data";
+	TMXTagName["EditorSettings"] = "editorsettings";
+	TMXTagName["Ellipse"] = "ellipse";
+	TMXTagName["Export"] = "export";
+	TMXTagName["Frame"] = "frame";
+	TMXTagName["Group"] = "group";
+	TMXTagName["Image"] = "image";
+	TMXTagName["ImageLayer"] = "imagelayer";
+	TMXTagName["Layer"] = "layer";
+	TMXTagName["Map"] = "map";
+	TMXTagName["Object"] = "object";
+	TMXTagName["Objectgroup"] = "objectgroup";
+	TMXTagName["Point"] = "point";
+	TMXTagName["Polygon"] = "polygon";
+	TMXTagName["Polyline"] = "polyline";
+	TMXTagName["Properties"] = "properties";
+	TMXTagName["Property"] = "property";
+	TMXTagName["Text"] = "text";
+	TMXTagName["Tile"] = "tile";
+	TMXTagName["Tileset"] = "tileset";
+	return TMXTagName;
+}({});
 //#endregion
-//#region src/services/parseLayer.ts
-const parseLayer = (node) => {
-	const { image, object, properties } = node;
-	const layer = cloneNodeWithType(node);
-	if (image) layer.image = structuredClone(takeOne(image).$);
-	if (object) layer.objects = object.map((objectNode) => parseObject(objectNode));
-	if (properties) layer.properties = parseProperties(properties);
-	return layer;
-};
+//#region src/models/Compression.ts
+let Compression = /* @__PURE__ */ function(Compression) {
+	Compression["Gzip"] = "gzip";
+	Compression["Zlib"] = "zlib";
+	return Compression;
+}({});
 //#endregion
-//#region src/services/checkIsTMXEmbeddedTilesetNode.ts
-const checkIsTMXEmbeddedTilesetNode = (node) => "tile" in node;
+//#region src/models/Encoding.ts
+let Encoding = /* @__PURE__ */ function(Encoding) {
+	Encoding["Base64"] = "base64";
+	Encoding["Csv"] = "csv";
+	return Encoding;
+}({});
 //#endregion
 //#region src/services/getDecompressedBytes.ts
 const getDecompressedBytes = async (bytes, compression) => {
@@ -172,21 +88,45 @@ const getDecompressedBytes = async (bytes, compression) => {
 //#region 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 unpackedTiles = [];
 	const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	for (let byteIndex = 0; byteIndex < bytes.byteLength; byteIndex += Uint32Array.BYTES_PER_ELEMENT) unpackedTiles.push(dataView.getUint32(byteIndex, true));
-	return unpackedTiles;
+	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];
 };
 //#endregion
 //#region src/services/decodeTileData.ts
-const decodeTileData = async (nodeData) => {
-	if (checkIsTMXEmbeddedTilesetNode(nodeData)) return nodeData.tile?.map(({ $ }) => $.gid ?? 0) ?? [];
-	const { $, _ } = nodeData;
-	const { compression, encoding } = $;
-	const layerData = normalizeString(_);
+const CSV_SEPARATOR_CODE_POINT = ",".codePointAt(0) ?? 0;
+const ZERO_CODE_POINT = "0".codePointAt(0) ?? 0;
+const NINE_CODE_POINT = "9".codePointAt(0) ?? 0;
+const WHITESPACE_REGEX = /\s/u;
+const decodeCsv = (text) => {
+	const tiles = [];
+	let tile = 0;
+	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) {
+			tiles.push(tile);
+			tile = 0;
+			hasDigit = false;
+			isEnded = false;
+		} else if (codePoint >= ZERO_CODE_POINT && codePoint <= NINE_CODE_POINT) {
+			if (isEnded) throw new InvalidOperationError(Operation.Read, decodeCsv.name, "has a cell with two numbers");
+			tile = tile * 10 + codePoint - ZERO_CODE_POINT;
+			hasDigit = true;
+		} else if (WHITESPACE_REGEX.test(text.charAt(index))) isEnded ||= hasDigit;
+		else throw new InvalidOperationError(Operation.Read, decodeCsv.name, `${text.charAt(index)} is not a tile gid`);
+	}
+	return tiles;
+};
+const decodeTileData = async (source) => {
+	const { compression, encoding, gids, text } = source;
+	if (encoding === void 0) return gids;
+	const data = normalizeString(text);
 	switch (encoding) {
 		case "base64": {
-			const bytes = Uint8Array.fromBase64(layerData);
+			const bytes = Uint8Array.fromBase64(data);
 			switch (compression) {
 				case "gzip":
 				case "zlib": return unpackTileBytes(await getDecompressedBytes(bytes, compression));
@@ -194,124 +134,628 @@ const decodeTileData = async (nodeData) => {
 				default: return exhaustiveGuard(compression);
 			}
 		}
-		case "csv": return layerData.split(",").map(Number);
+		case "csv": return decodeCsv(data);
 		default: return exhaustiveGuard(encoding);
 	}
 };
+const Flippeds = Object.values(/* @__PURE__ */ function(Flipped) {
+	Flipped[Flipped["Diagonally"] = 536870912] = "Diagonally";
+	Flipped[Flipped["Vertically"] = 1073741824] = "Vertically";
+	Flipped[Flipped["Horizontally"] = 2147483648] = "Horizontally";
+	return Flipped;
+}({})).filter((value) => typeof value === "number");
+//#endregion
+//#region src/services/parseFlips.ts
+const parseFlips = (gid) => ({
+	Diagonal: Boolean(gid & 536870912),
+	Horizontal: Boolean(gid & 2147483648),
+	Vertical: Boolean(gid & 1073741824)
+});
+//#endregion
+//#region src/services/parseTileId.ts
+const FLIPPED_MASK = ~Flippeds.reduce((accumulator, flipped) => accumulator | flipped, 0);
+const parseTileId = (gid) => gid & FLIPPED_MASK;
+//#endregion
+//#region src/services/assignTileData.ts
+const assignTileData = async (pending, translateFlips) => {
+	await Promise.all(pending.map(async ({ expectedCount, owner, source }) => {
+		if (source.chunked) return;
+		const tiles = await decodeTileData(source);
+		if (expectedCount !== void 0 && tiles.length !== expectedCount) throw new InvalidOperationError(Operation.Read, "TMXLayer", `expected ${expectedCount} tiles, received ${tiles.length}`);
+		if (translateFlips) {
+			owner.data = tiles.map((gid) => parseTileId(gid));
+			owner.flips = tiles.map((gid) => parseFlips(gid));
+		} else owner.data = tiles;
+	}));
+};
+//#endregion
+//#region 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;
+}({});
+//#endregion
+//#region src/services/closeTmxFrame.ts
+const parsePropertyValue = (propertyType, value) => {
+	switch (propertyType) {
+		case "bool": return value === "true";
+		case "class":
+		case "color":
+		case "file":
+		case "object":
+		case "string": return value;
+		case "float":
+		case "int": return Number(value);
+		default: return exhaustiveGuard(propertyType);
+	}
+};
+const closeTmxFrame = (frame) => {
+	switch (frame.tag) {
+		case "chunk":
+		case "data":
+		case "text":
+			frame.target.text = frame.text;
+			return;
+		case "property":
+			if (frame.propertyType === "class") return;
+			frame.target.value = parsePropertyValue(frame.propertyType, frame.valueAttribute ?? frame.text);
+			return;
+		default: return;
+	}
+};
 //#endregion
-//#region src/services/parseTileLayer.ts
-const parseTileLayer = async (node, tileCount, translateFlips) => {
-	const { data, properties } = node;
-	if (!data) throw new InvalidOperationError(Operation.Read, "TMXLayer", "data is missing");
-	const layer = cloneNodeWithType(node);
-	if (properties) layer.properties = parseProperties(properties);
-	const nodeData = takeOne(data);
-	const tiles = await decodeTileData(nodeData);
-	if (tiles.length !== tileCount) throw new InvalidOperationError(Operation.Read, "TMXLayer", `expected ${tileCount} tiles, received ${tiles.length}`);
-	if (translateFlips) {
-		layer.data = tiles.map((gid) => parseTileId(gid));
-		layer.flips = tiles.map((gid) => parseFlips(gid));
-	} else layer.data = tiles;
-	return layer;
+//#region src/services/readTmxAttributes.ts
+const readTmxAttributes = (attributes, table) => {
+	const values = {};
+	for (const [name, kind] of Object.entries(table)) {
+		const isNumber = kind === "number" || kind === "requiredNumber";
+		const isRequired = kind === "requiredNumber" || kind === "requiredString";
+		const text = attributes[name];
+		if (text === void 0 || isNumber && text === "") {
+			if (isRequired) values[name] = isNumber ? 0 : "";
+		} else if (isNumber) {
+			const number = Number(text);
+			if (Number.isNaN(number)) throw new InvalidOperationError(Operation.Read, readTmxAttributes.name, `${text} is not a number`);
+			values[name] = number;
+		} else values[name] = text;
+	}
+	return values;
 };
 //#endregion
-//#region src/services/parseNode.ts
-const parseGroup = async (node, tileCount, translateFlips) => {
-	const group = cloneNodeWithType(node);
-	group.layers = await Promise.all(node.$$.map((layerNode) => parseNode(layerNode, tileCount, translateFlips)));
-	return group;
-};
-const parseNode = (node, tileCount, translateFlips) => {
-	const tmxNodeType = node["#name"];
-	switch (tmxNodeType) {
-		case "group": return parseGroup(node, tileCount, translateFlips);
-		case "imagelayer":
-		case "objectgroup": return Promise.resolve(parseLayer(node));
-		case "layer": return parseTileLayer(node, tileCount, translateFlips);
-		default: throw new InvalidOperationError(Operation.Read, parseNode.name, tmxNodeType);
+//#region src/services/createTmxImage.ts
+const imageAttributeKindMap = {
+	format: "string",
+	height: "requiredNumber",
+	source: "requiredString",
+	trans: "string",
+	width: "requiredNumber"
+};
+const createTmxImage = (attributes) => readTmxAttributes(attributes, imageAttributeKindMap);
+//#endregion
+//#region src/services/openTmxLayer.ts
+const groupAttributeKindMap = {
+	class: "string",
+	id: "requiredNumber",
+	name: "requiredString",
+	offsetx: "number",
+	offsety: "number",
+	opacity: "number",
+	parallaxx: "number",
+	parallaxy: "number",
+	tintcolor: "string",
+	visible: "number"
+};
+const layerAttributeKindMap = {
+	...groupAttributeKindMap,
+	color: "string",
+	draworder: "string",
+	height: "number",
+	locked: "number",
+	width: "number",
+	x: "number",
+	y: "number"
+};
+const openTmxLayer = (layers, tag, attributes) => {
+	if (tag === "group") {
+		const group = {
+			...readTmxAttributes(attributes, groupAttributeKindMap),
+			layers: [],
+			type: tag
+		};
+		layers.push(group);
+		return {
+			tag,
+			target: group,
+			text: ""
+		};
 	}
+	const layer = {
+		...readTmxAttributes(attributes, layerAttributeKindMap),
+		type: tag
+	};
+	layers.push(layer);
+	return {
+		tag,
+		target: layer,
+		text: ""
+	};
 };
 //#endregion
-//#region src/services/checkIsExternalTileset.ts
-const checkIsExternalTileset = (tileset) => "source" in tileset;
+//#region src/services/openTmxProperties.ts
+const openTmxProperties = (target) => {
+	target.properties ??= [];
+	return {
+		tag: "properties",
+		target: target.properties,
+		text: ""
+	};
+};
 //#endregion
-//#region src/services/parseTile.ts
-const parseTile = (node) => {
-	const { $, animation, objectgroup, properties } = node;
-	const tile = structuredClone($);
-	if (animation) tile.animation = { frames: takeOne(takeOne(animation), "frame").map(({ $: frameData }) => structuredClone(frameData)) };
-	if (objectgroup) tile.objects = takeOne(takeOne(objectgroup), "object").map((objectNode) => parseObject(objectNode));
-	if (properties) tile.properties = parseProperties(properties);
-	return tile;
+//#region 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}`);
 };
 //#endregion
-//#region src/services/parseTileset.ts
-const parseTileset = (node) => {
-	if (checkIsExternalTileset(node.$)) return structuredClone(node.$);
-	const { $, $$, tile } = node;
-	const imageNode = $$.find((childNode) => childNode["#name"] === "image");
-	if (!imageNode) throw new InvalidOperationError(Operation.Read, parseTileset.name, $.name);
-	const image = structuredClone(imageNode.$);
-	const tiles = tile?.map((tileNode) => parseTile(tileNode)) ?? [];
+//#region 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 {
-		...$,
-		image,
-		tiles
+		owner: layer,
+		tag: "data",
+		target: source,
+		text: ""
 	};
 };
+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({
+				owner: chunk,
+				source: chunkSource
+			});
+			return {
+				tag,
+				target: chunkSource,
+				text: ""
+			};
+		}
+		case "tile":
+			source.gids.push(readTmxAttributes(attributes, gidAttributeKindMap).gid);
+			return;
+		default: return;
+	}
+};
+const openTmxLayerChild = (parent, tag, attributes, context) => {
+	if (parent.tag === "chunk" || parent.tag === "data") return openTmxDataChild(parent, tag, attributes, context);
+	switch (tag) {
+		case "data":
+			if (parent.tag !== "layer") return void 0;
+			return openTileData(parent.target, attributes, context);
+		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);
+			return {
+				tag,
+				target: parent.target.image,
+				text: ""
+			};
+		case "properties": return openTmxProperties(parent.target);
+		default: return;
+	}
+};
 //#endregion
-//#region src/services/parseXmlValue.ts
-const NUMBER_REGEX = /^[+-]?\d+(?<decimal>\.\d+)?$/u;
-const parseXmlValue = (value) => {
+//#region src/services/openTmxObjectChild.ts
+const NUMBER_REGEX = /^[+-]?\d+(?:\.\d+)?$/u;
+const objectAttributeKindMap = {
+	gid: "number",
+	height: "requiredNumber",
+	id: "requiredNumber",
+	name: "requiredString",
+	rotation: "number",
+	template: "string",
+	type: "requiredString",
+	visible: "number",
+	width: "requiredNumber",
+	x: "requiredNumber",
+	y: "requiredNumber"
+};
+const createObject = (attributes) => {
+	const { gid, ...object } = readTmxAttributes(attributes, objectAttributeKindMap);
+	const shaped = {
+		...object,
+		shape: "rectangle"
+	};
+	if (gid === void 0) return shaped;
+	return gid ? {
+		...shaped,
+		flips: parseFlips(gid),
+		gid: parseTileId(gid)
+	} : {
+		...shaped,
+		gid
+	};
+};
+const parsePoints = (points) => points === "" ? [] : points.split(" ").map((point) => {
+	const [x = "", y = ""] = point.split(",");
+	return [Number(x), Number(y)];
+});
+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;
 };
+const createTextProperties = (attributes) => Object.entries(attributes).map(([name, value]) => ({
+	name,
+	value: parseUntypedValue(value)
+}));
+const openTmxObjectChild = (parent, tag, attributes) => {
+	if (parent.tag === "objectgroup") {
+		if (tag === "properties") return openTmxProperties(parent.target);
+		if (tag !== "object") return void 0;
+		const object = createObject(attributes);
+		parent.target.objects ??= [];
+		parent.target.objects.push(object);
+		return {
+			tag,
+			target: object,
+			text: ""
+		};
+	}
+	const object = parent.target;
+	switch (tag) {
+		case "ellipse":
+		case "point":
+			object.shape = tag === "point" ? "point" : "ellipse";
+			return {
+				tag,
+				target: object,
+				text: ""
+			};
+		case "polygon":
+		case "polyline":
+			object.shape = tag === "polygon" ? "polygon" : "polyline";
+			object.points = parsePoints(attributes.points ?? "");
+			return {
+				tag,
+				target: object,
+				text: ""
+			};
+		case "properties": return openTmxProperties(object);
+		case "text":
+			object.properties = [...object.properties ?? [], ...createTextProperties(attributes)];
+			return {
+				tag,
+				target: object,
+				text: ""
+			};
+		default: return;
+	}
+};
 //#endregion
-//#region src/services/parseXmlString.ts
-const parseXmlString = (xmlString) => parseStringPromise(xmlString, {
-	attrValueProcessors: [(value) => parseXmlValue(value)],
-	explicitChildren: true,
-	preserveChildrenOrder: true
+//#region src/services/openTmxFrame.ts
+const mapAttributeKindMap = {
+	backgroundcolor: "string",
+	compressionlevel: "number",
+	height: "requiredNumber",
+	hexsidelength: "number",
+	infinite: "requiredNumber",
+	nextlayerid: "requiredNumber",
+	nextobjectid: "requiredNumber",
+	orientation: "requiredString",
+	parallaxoriginx: "number",
+	parallaxoriginy: "number",
+	renderorder: "requiredString",
+	staggeraxis: "string",
+	staggerindex: "string",
+	tiledversion: "requiredString",
+	tileheight: "requiredNumber",
+	tilewidth: "requiredNumber",
+	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: []
 });
-//#endregion
-//#region src/parseTmx.ts
-const parseTmx = async (xmlString, translateFlips = false) => {
-	const { map: { $, $$ } } = await parseXmlString(xmlString);
-	const map = new TMXMapParsed($);
-	const tileCount = map.width * map.height;
-	for (const node of $$) {
-		const tmxNodeType = node["#name"];
-		switch (tmxNodeType) {
-			case "data": break;
-			case "editorsettings":
-				if (!node.$$) break;
-				map.editorsettings = Object.fromEntries(node.$$.map((exportNode) => [exportNode["#name"], exportNode.$]));
-				break;
-			case "export":
-			case "image":
-			case "object":
-			case "property": break;
-			case "group":
-			case "imagelayer":
-			case "layer":
-			case "objectgroup": {
-				const layer = await parseNode(node, tileCount, translateFlips);
-				map.layers.push(layer);
-				break;
+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) {
+		case "map": {
+			const map = Object.assign(new TMXMapParsed(), readTmxAttributes(attributes, mapAttributeKindMap));
+			context.tileCount = map.width * map.height;
+			return {
+				tag,
+				target: map,
+				text: ""
+			};
+		}
+		case "tileset":
+			if (attributes.source !== void 0) return void 0;
+			return {
+				tag,
+				target: createEmbeddedTileset(attributes),
+				text: ""
+			};
+		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;
 			}
-			case "properties":
-				if (!node.$$) break;
-				map.properties = parseProperties([{ property: node.$$ }]);
-				break;
-			case "tileset":
-				map.tilesets.push(parseTileset(node));
-				break;
-			default: exhaustiveGuard(tmxNodeType);
+			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`);
+	}
+};
+const openTmxTileChild = (parent, tag, attributes) => {
+	const tile = parent.target;
+	switch (tag) {
+		case "animation": {
+			const animation = { frames: [] };
+			tile.animation = animation;
+			return {
+				tag,
+				target: animation,
+				text: ""
+			};
+		}
+		case "image": {
+			const image = createTmxImage(attributes);
+			tile.image = image;
+			return {
+				tag,
+				target: image,
+				text: ""
+			};
 		}
+		case "objectgroup": return {
+			tag,
+			target: tile,
+			text: ""
+		};
+		case "properties": return openTmxProperties(tile);
+		default: return;
 	}
-	return new TMXParsed(map);
 };
+const openTmxTilesetChild = (parent, tag, attributes) => {
+	const tileset = parent.target;
+	switch (tag) {
+		case "image": {
+			const image = createTmxImage(attributes);
+			tileset.image = image;
+			return {
+				tag,
+				target: image,
+				text: ""
+			};
+		}
+		case "tile": {
+			const tile = readTmxAttributes(attributes, tileAttributeKindMap);
+			tileset.tiles.push(tile);
+			return {
+				tag,
+				target: tile,
+				text: ""
+			};
+		}
+		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
+	};
+};
+const openTmxFrame = (parent, name, attributes, context) => {
+	if (parent === void 0) return openTmxRoot(name, attributes, context);
+	const tag = parseTmxTagName(name);
+	switch (parent.tag) {
+		case "animation": {
+			if (tag !== "frame") return void 0;
+			const frame = readTmxAttributes(attributes, animationFrameAttributeKindMap);
+			parent.target.frames.push(frame);
+			return {
+				tag,
+				target: frame,
+				text: ""
+			};
+		}
+		case "chunk":
+		case "data":
+		case "group":
+		case "imagelayer":
+		case "layer": return openTmxLayerChild(parent, tag, attributes, context);
+		case "editorsettings":
+			if (tag !== "export") return void 0;
+			parent.target.export = readTmxAttributes(attributes, exportAttributeKindMap);
+			return {
+				tag,
+				target: parent.target.export,
+				text: ""
+			};
+		case "map": return openTmxMapChild(parent, name, tag, attributes);
+		case "object":
+		case "objectgroup": return openTmxObjectChild(parent, tag, attributes);
+		case "properties": return openTmxPropertyChild(parent, tag, attributes);
+		case "property": return tag === "properties" ? openTmxProperties(parent.target) : void 0;
+		case "tile": return openTmxTileChild(parent, tag, attributes);
+		case "tileset": return openTmxTilesetChild(parent, tag, attributes);
+		default: return;
+	}
+};
+//#endregion
+//#region src/services/readTmxDocument.ts
+const BYTE_ORDER_MARK_REGEX = /^\uFEFF/u;
+const toTmxAttributes = (attributes) => Object.fromEntries(Object.entries(attributes).map(([name, attribute]) => [name, typeof attribute === "string" ? attribute : attribute.value]));
+const readTmxDocument = (xmlString, context) => {
+	const parser = sax.parser(true, {
+		normalize: false,
+		trim: false
+	});
+	const stack = [];
+	let root;
+	parser.onerror = (error) => {
+		throw new InvalidOperationError(Operation.Read, readTmxDocument.name, error.message);
+	};
+	parser.onopentag = (node) => {
+		if (stack.length === 0) {
+			root = openTmxFrame(void 0, node.name, toTmxAttributes(node.attributes), context);
+			stack.push(root);
+			return;
+		}
+		const parent = stack.at(-1);
+		stack.push(parent && openTmxFrame(parent, node.name, toTmxAttributes(node.attributes), context));
+	};
+	parser.onclosetag = () => {
+		const frame = stack.pop();
+		if (frame) closeTmxFrame(frame);
+	};
+	const appendText = (text) => {
+		const frame = stack.at(-1);
+		if (frame) frame.text += text;
+	};
+	parser.ontext = appendText;
+	parser.oncdata = appendText;
+	parser.write(xmlString.replace(BYTE_ORDER_MARK_REGEX, "")).close();
+	return root;
+};
+//#endregion
+//#region src/parseTmx.ts
+const parseTmx = (xmlString, translateFlips = false) => {
+	const context = {
+		pending: [],
+		tileCount: 0
+	};
+	return getResult(() => readTmxDocument(xmlString, context)).asyncAndThen((root) => getResultAsync(async () => {
+		if (root?.tag !== "map") throw new InvalidOperationError(Operation.Read, parseTmx.name, "has no map root element");
+		await assignTileData(context.pending, translateFlips);
+		return new TMXParsed(root.target);
+	}));
+};
+//#endregion
+//#region src/services/parseTileset.ts
+const parseTileset = (xmlString) => getResult(() => readTmxDocument(xmlString, {
+	pending: [],
+	tileCount: 0
+})).andThen((root) => getResult(() => {
+	if (root?.tag !== "tileset") throw new InvalidOperationError(Operation.Read, parseTileset.name, "has no embedded tileset root element");
+	return root.target;
+}));
 //#endregion
-export { BaseTMXNode, Compression, Encoding, Flipped, Flippeds, Shape, TMXMapParsed, TMXMapShared, TMXNodeType, TMXParsed, checkIsExternalTileset, checkIsTMXEmbeddedTilesetNode, cloneNodeWithType, decodeTileData, getDecompressedBytes, parseFlips, parseLayer, parseNode, parseObject, parseObjectShape, parseProperties, parseTile, parseTileId, parseTileLayer, parseTileset, parseTmx, parseXmlString, parseXmlValue, unpackTileBytes };
+export { Shape, TMXMapParsed, TMXParsed, parseTileset, parseTmx };