parse-tmx 4.3.3 → 4.4.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.
+A parser for [Tiled Map Editor](http://www.mapeditor.org/) \*.tmx files, 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parse-tmx",
-  "version": "4.3.3",
+  "version": "4.4.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.4.0",
     "neverthrow": "^8.2.0",
     "sax": "^1.6.1"
   },
   "devDependencies": {
-    "@esposter/configuration": "4.3.3",
-    "@esposter/shared-node": "4.3.3",
+    "@esposter/configuration": "4.4.0",
+    "@esposter/shared-node": "4.4.0",
     "@types/sax": "^1.2.7",
-    "tsdown": "^0.23.1"
+    "tsdown": "0.23.2"
   },
-  "gitHead": "955bbc130ad9b28877fd4ae8efc73a045141ce01"
+  "gitHead": "e1a416c4b91da69cc2aa259b50a4d656f204d272"
 }

package/dist/index.d.ts

@@ -1,156 +0,0 @@
-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

@@ -1,736 +0,0 @@
-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 };