parse-tmx 4.2.0 → 4.3.3

package/README.md

@@ -24,7 +24,7 @@ pnpm i parse-tmx
 
 ## <a name="documentation">📖 Documentation</a>
 
-We highly recommend you take a look at the [documentation](https://esposter.com/docs/api/modules/parse-tmx.html) to level up.
+We highly recommend you take a look at the [documentation](https://github.com/Esposter/Esposter/tree/main/openspec/specs/parse-tmx) to level up.
 
 ### Usage
 

package/dist/index.d.ts

@@ -0,0 +1,156 @@
+import { Result, ResultAsync } from "neverthrow";
+export declare enum Shape {
+  Ellipse = "ellipse",
+  Point = "point",
+  Polygon = "polygon",
+  Polyline = "polyline",
+  Rectangle = "rectangle"
+}
+interface TMXAnimationFrameParsed {
+  duration: number;
+  tileid: number;
+}
+interface TMXAnimationParsed {
+  frames: TMXAnimationFrameParsed[];
+}
+interface TMXFlipsParsed {
+  Diagonal: boolean;
+  Horizontal: boolean;
+  Vertical: boolean;
+}
+interface TMXChunkParsed {
+  data?: number[];
+  flips?: TMXFlipsParsed[];
+  height: number;
+  width: number;
+  x: number;
+  y: number;
+}
+interface TMXExportParsed {
+  format: string;
+  target: string;
+}
+interface TMXEditorSettingsParsed {
+  export?: TMXExportParsed;
+}
+interface TMXImageParsed {
+  format?: string;
+  height: number;
+  source: string;
+  trans?: string;
+  width: number;
+}
+interface TMXPropertyParsed {
+  name: string;
+  properties?: TMXPropertiesParsed;
+  value: boolean | number | string;
+}
+type TMXPropertiesParsed = TMXPropertyParsed[];
+interface TMXObjectParsed {
+  flips?: TMXFlipsParsed;
+  gid?: number;
+  height: number;
+  id: number;
+  name: string;
+  points?: [number, number][];
+  properties?: TMXPropertiesParsed;
+  rotation?: number;
+  shape: Shape;
+  template?: string;
+  text?: string;
+  type: string;
+  visible?: number;
+  width: number;
+  x: number;
+  y: number;
+}
+interface TMXTileParsed {
+  animation?: TMXAnimationParsed;
+  id: number;
+  image?: TMXImageParsed;
+  objects?: TMXObjectParsed[];
+  probability?: number;
+  properties?: TMXPropertiesParsed;
+  terrain?: string;
+  type?: string;
+}
+interface TMXEmbeddedTilesetParsed {
+  columns: number;
+  firstgid: number;
+  image?: TMXImageParsed;
+  margin?: number;
+  name: string;
+  spacing?: number;
+  tilecount: number;
+  tileheight: number;
+  tiles: TMXTileParsed[];
+  tilewidth: number;
+}
+interface TMXExternalTilesetParsed {
+  firstgid: number;
+  source: string;
+}
+interface TMXGroupLayerShared {
+  class?: string;
+  id: number;
+  name: string;
+  offsetx?: number;
+  offsety?: number;
+  opacity?: number;
+  parallaxx?: number;
+  parallaxy?: number;
+  tintcolor?: string;
+  type: string;
+  visible?: number;
+}
+interface TMXLayerParsed extends TMXGroupLayerShared {
+  chunks?: TMXChunkParsed[];
+  color?: string;
+  data?: number[];
+  draworder?: string;
+  flips?: TMXFlipsParsed[];
+  height?: number;
+  image?: TMXImageParsed;
+  locked?: number;
+  objects?: TMXObjectParsed[];
+  properties?: TMXPropertiesParsed;
+  width?: number;
+  x?: number;
+  y?: number;
+}
+interface TMXGroupLayerParsed extends TMXGroupLayerShared {
+  layers: (TMXGroupLayerParsed | TMXLayerParsed)[];
+  properties?: TMXPropertiesParsed;
+}
+type TMXTilesetParsed = TMXEmbeddedTilesetParsed | TMXExternalTilesetParsed;
+export declare class TMXMapParsed {
+  backgroundcolor?: string;
+  compressionlevel?: number;
+  editorsettings: TMXEditorSettingsParsed;
+  height: number;
+  hexsidelength?: number;
+  infinite: number;
+  layers: (TMXGroupLayerParsed | TMXLayerParsed)[];
+  nextlayerid: number;
+  nextobjectid: number;
+  orientation: string;
+  parallaxoriginx?: number;
+  parallaxoriginy?: number;
+  properties: TMXPropertiesParsed;
+  renderorder: string;
+  staggeraxis?: string;
+  staggerindex?: string;
+  tiledversion: string;
+  tileheight: number;
+  tilesets: TMXTilesetParsed[];
+  tilewidth: number;
+  version: number;
+  width: number;
+}
+export declare class TMXParsed {
+  map: TMXMapParsed;
+  constructor(map?: TMXMapParsed);
+}
+export declare const parseTmx: (xmlString: string, translateFlips?: boolean) => ResultAsync<TMXParsed, Error>;
+export declare const parseTileset: (xmlString: string) => Result<TMXEmbeddedTilesetParsed, Error>;
+export type { TMXAnimationFrameParsed, TMXAnimationParsed, TMXChunkParsed, TMXEditorSettingsParsed, TMXEmbeddedTilesetParsed, TMXExportParsed, TMXExternalTilesetParsed, TMXFlipsParsed, TMXGroupLayerParsed, TMXImageParsed, TMXLayerParsed, TMXObjectParsed, TMXPropertiesParsed, TMXPropertyParsed, TMXTileParsed, TMXTilesetParsed };

package/dist/index.js

@@ -0,0 +1,736 @@
+import { InvalidOperationError, Operation, exhaustiveGuard, getResult, getResultAsync, normalizeString } from "@esposter/shared";
+import sax from "sax";
+// 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;
+}({});
+// 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;
+};
+// src/models/tmx/parsed/TMXParsed.ts
+var TMXParsed = class {
+	map;
+	constructor(map = new TMXMapParsed()) {
+		this.map = map;
+	}
+};
+// 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;
+}({});
+// src/models/Compression.ts
+let Compression = /* @__PURE__ */ function(Compression) {
+	Compression["Gzip"] = "gzip";
+	Compression["Zlib"] = "zlib";
+	return Compression;
+}({});
+// src/models/Encoding.ts
+let Encoding = /* @__PURE__ */ function(Encoding) {
+	Encoding["Base64"] = "base64";
+	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
+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(data);
+			switch (compression) {
+				case "gzip":
+				case "zlib": return unpackTileBytes(await getDecompressedBytes(bytes, compression));
+				case void 0: return unpackTileBytes(bytes);
+				default: return exhaustiveGuard(compression);
+			}
+		}
+		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");
+// src/services/parseFlips.ts
+const parseFlips = (gid) => ({
+	Diagonal: Boolean(gid & 536870912),
+	Horizontal: Boolean(gid & 2147483648),
+	Vertical: Boolean(gid & 1073741824)
+});
+// src/services/parseTileId.ts
+const FLIPPED_MASK = ~Flippeds.reduce((accumulator, flipped) => accumulator | flipped, 0);
+const parseTileId = (gid) => gid & FLIPPED_MASK;
+// 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;
+	}));
+};
+// 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
+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;
+	}
+};
+// 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;
+};
+// src/services/createTmxImage.ts
+const imageAttributeKindMap = {
+	format: "string",
+	height: "requiredNumber",
+	source: "requiredString",
+	trans: "string",
+	width: "requiredNumber"
+};
+const createTmxImage = (attributes) => readTmxAttributes(attributes, imageAttributeKindMap);
+// 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: ""
+	};
+};
+// src/services/openTmxProperties.ts
+const openTmxProperties = (target) => {
+	target.properties ??= [];
+	return {
+		tag: "properties",
+		target: target.properties,
+		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;
+	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;
+	}
+};
+// 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;
+	}
+};
+// 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: []
+});
+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;
+			}
+			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;
+	}
+};
+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;
+	}
+};
+// 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;
+};
+// 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);
+	}));
+};
+// 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;
+}));
+export { Shape, TMXMapParsed, TMXParsed, parseTileset, parseTmx };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parse-tmx",
-  "version": "4.2.0",
+  "version": "4.3.3",
   "description": "A parser for tmx.",
   "keywords": [
     "game-development",
@@ -44,26 +44,21 @@
   "scripts": {
     "build": "tsdown",
     "bench": "vitest bench --run",
-    "format": "oxfmt",
-    "format:check": "oxfmt --check",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "test": "vitest",
     "typecheck": "tsc"
   },
   "dependencies": {
-    "@esposter/shared": "4.2.0",
+    "@esposter/shared": "4.3.3",
     "neverthrow": "^8.2.0",
     "sax": "^1.6.1"
   },
   "devDependencies": {
-    "@arethetypeswrong/core": "^0.18.5",
-    "@esposter/configuration": "4.2.0",
-    "@esposter/shared-node": "4.2.0",
+    "@esposter/configuration": "4.3.3",
+    "@esposter/shared-node": "4.3.3",
     "@types/sax": "^1.2.7",
-    "publint": "^0.3.25",
-    "tsdown": "^0.23.1",
-    "vitest": "^5.0.4"
+    "tsdown": "^0.23.1"
   },
-  "gitHead": "fef4971cf6a621a2c1850f32fcec19ee4ec0de99"
+  "gitHead": "955bbc130ad9b28877fd4ae8efc73a045141ce01"
 }