pixi-tiledmap 2.0.0 → 2.2.0

package/dist/index.cjs

@@ -1,1411 +1,1552 @@
-'use strict';
-
-var pixi_js = require('pixi.js');
-
-// src/types/index.ts
-var FLIPPED_HORIZONTALLY_FLAG = 2147483648;
-var FLIPPED_VERTICALLY_FLAG = 1073741824;
-var FLIPPED_DIAGONALLY_FLAG = 536870912;
-var ROTATED_HEXAGONAL_120_FLAG = 268435456;
-var GID_MASK = 268435455;
-
-// src/parser/decodeGid.ts
-function decodeGid(raw) {
-  const gid = raw & GID_MASK;
-  if (gid === 0) return null;
-  return {
-    gid,
-    localId: 0,
-    tilesetIndex: 0,
-    horizontalFlip: (raw & FLIPPED_HORIZONTALLY_FLAG) !== 0,
-    verticalFlip: (raw & FLIPPED_VERTICALLY_FLAG) !== 0,
-    diagonalFlip: (raw & FLIPPED_DIAGONALLY_FLAG) !== 0
-  };
-}
-
-// src/parser/decodeData.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let pixi_js = require("pixi.js");
+//#region src/parser/decodeData.ts
 function decodeLayerData(data, encoding, compression) {
-  if (Array.isArray(data)) {
-    return data;
-  }
-  if (encoding === "base64") {
-    const bytes = base64ToBytes(data);
-    if (compression === "gzip" || compression === "zlib") {
-      const decompressed = decompressBytes(bytes, compression);
-      return bytesToGids(decompressed);
-    }
-    if (compression === "zstd") {
-      throw new Error("zstd compression is not supported in the browser");
-    }
-    return bytesToGids(bytes);
-  }
-  throw new Error(`Unsupported encoding: ${encoding ?? "unknown"}`);
+	if (Array.isArray(data)) return data;
+	if (encoding === "csv") return csvToGids(data);
+	if (encoding === "base64") {
+		const bytes = base64ToBytes(data);
+		if (compression === "gzip" || compression === "zlib") return bytesToGids(decompressBytes(bytes, compression));
+		if (compression === "zstd") throw new Error("zstd compression is not supported in the browser");
+		return bytesToGids(bytes);
+	}
+	throw new Error(`Unsupported encoding: ${encoding ?? "unknown"}`);
+}
+function csvToGids(csv) {
+	const out = [];
+	let cur = 0;
+	let hasDigit = false;
+	for (let i = 0; i < csv.length; i++) {
+		const code = csv.charCodeAt(i);
+		if (code >= 48 && code <= 57) {
+			cur = cur * 10 + (code - 48);
+			hasDigit = true;
+		} else if (code === 44) {
+			if (hasDigit) out.push(cur);
+			cur = 0;
+			hasDigit = false;
+		}
+	}
+	if (hasDigit) out.push(cur);
+	return out;
 }
 function base64ToBytes(base64) {
-  const trimmed = base64.trim();
-  if (typeof globalThis.atob === "function") {
-    const binary = globalThis.atob(trimmed);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-  }
-  const buf = Buffer.from(trimmed, "base64");
-  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+	const binary = globalThis.atob(base64.trim());
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
 }
 function bytesToGids(bytes) {
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const count = bytes.byteLength / 4;
-  const gids = new Array(count);
-  for (let i = 0; i < count; i++) {
-    gids[i] = view.getUint32(i * 4, true);
-  }
-  return gids;
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const count = bytes.byteLength / 4;
+	const gids = new Array(count);
+	for (let i = 0; i < count; i++) gids[i] = view.getUint32(i * 4, true);
+	return gids;
 }
 async function decompressBytesAsync(bytes, compression) {
-  const format = compression === "gzip" ? "gzip" : "deflate";
-  const ds = new DecompressionStream(format);
-  const writer = ds.writable.getWriter();
-  writer.write(bytes);
-  writer.close();
-  const reader = ds.readable.getReader();
-  const chunks = [];
-  let totalLength = 0;
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    chunks.push(value);
-    totalLength += value.byteLength;
-  }
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return result;
+	const format = compression === "gzip" ? "gzip" : "deflate";
+	const ds = new DecompressionStream(format);
+	const writer = ds.writable.getWriter();
+	writer.write(bytes);
+	writer.close();
+	const reader = ds.readable.getReader();
+	const chunks = [];
+	let totalLength = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+		totalLength += value.byteLength;
+	}
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return result;
 }
 function decompressBytes(_bytes, compression) {
-  if (typeof DecompressionStream !== "undefined") {
-    throw new Error(
-      `Compressed tile data (${compression}) requires the async parser. Use parseMapAsync() instead of parseMap() for compressed maps.`
-    );
-  }
-  throw new Error(
-    `Compressed tile data (${compression}) is not supported in this environment. DecompressionStream API is required.`
-  );
+	if (typeof DecompressionStream !== "undefined") throw new Error(`Compressed tile data (${compression}) requires the async parser. Use parseMapAsync() instead of parseMap() for compressed maps.`);
+	throw new Error(`Compressed tile data (${compression}) is not supported in this environment. DecompressionStream API is required.`);
 }
 async function decodeLayerDataAsync(data, encoding, compression) {
-  if (Array.isArray(data)) {
-    return data;
-  }
-  if (encoding === "base64") {
-    const bytes = base64ToBytes(data);
-    if (compression === "gzip" || compression === "zlib") {
-      const decompressed = await decompressBytesAsync(bytes, compression);
-      return bytesToGids(decompressed);
-    }
-    if (compression === "zstd") {
-      throw new Error("zstd compression is not supported in the browser");
-    }
-    return bytesToGids(bytes);
-  }
-  throw new Error(`Unsupported encoding: ${encoding ?? "unknown"}`);
-}
-
-// src/parser/resolveMap.ts
+	if (Array.isArray(data)) return data;
+	if (encoding === "csv") return csvToGids(data);
+	if (encoding === "base64") {
+		const bytes = base64ToBytes(data);
+		if (compression === "gzip" || compression === "zlib") return bytesToGids(await decompressBytesAsync(bytes, compression));
+		if (compression === "zstd") throw new Error("zstd compression is not supported in the browser");
+		return bytesToGids(bytes);
+	}
+	throw new Error(`Unsupported encoding: ${encoding ?? "unknown"}`);
+}
+//#endregion
+//#region src/types/index.ts
+const FLIPPED_HORIZONTALLY_FLAG = 2147483648;
+const FLIPPED_VERTICALLY_FLAG = 1073741824;
+const FLIPPED_DIAGONALLY_FLAG = 536870912;
+const ROTATED_HEXAGONAL_120_FLAG = 268435456;
+const GID_MASK = 268435455;
+//#endregion
+//#region src/parser/decodeGid.ts
+function decodeGid(raw) {
+	const gid = raw & GID_MASK;
+	if (gid === 0) return null;
+	return {
+		gid,
+		localId: 0,
+		tilesetIndex: 0,
+		horizontalFlip: (raw & FLIPPED_HORIZONTALLY_FLAG) !== 0,
+		verticalFlip: (raw & FLIPPED_VERTICALLY_FLAG) !== 0,
+		diagonalFlip: (raw & FLIPPED_DIAGONALLY_FLAG) !== 0
+	};
+}
+//#endregion
+//#region src/parser/tilesetHelpers.ts
 function isTilesetRef(ts) {
-  return "source" in ts && !("name" in ts);
-}
-function resolveTileset(raw) {
-  const tiles = /* @__PURE__ */ new Map();
-  if (raw.tiles) {
-    for (const tile of raw.tiles) {
-      tiles.set(tile.id, tile);
-    }
-  }
-  return {
-    firstgid: raw.firstgid,
-    name: raw.name,
-    tilewidth: raw.tilewidth,
-    tileheight: raw.tileheight,
-    columns: raw.columns > 0 ? raw.columns : raw.imagewidth && raw.tilewidth > 0 ? Math.floor((raw.imagewidth - 2 * raw.margin + raw.spacing) / (raw.tilewidth + raw.spacing)) : 0,
-    tilecount: raw.tilecount,
-    margin: raw.margin,
-    spacing: raw.spacing,
-    image: raw.image,
-    imagewidth: raw.imagewidth,
-    imageheight: raw.imageheight,
-    tileoffset: raw.tileoffset ?? { x: 0, y: 0 },
-    objectalignment: raw.objectalignment ?? "unspecified",
-    tilerendersize: raw.tilerendersize ?? "tile",
-    fillmode: raw.fillmode ?? "stretch",
-    tiles,
-    properties: raw.properties ?? [],
-    transformations: raw.transformations,
-    grid: raw.grid,
-    wangsets: raw.wangsets,
-    terrains: raw.terrains
-  };
-}
-function findTilesetIndex(gid, tilesets) {
-  for (let i = tilesets.length - 1; i >= 0; i--) {
-    const ts = tilesets[i];
-    if (ts && ts.firstgid <= gid) {
-      return i;
-    }
-  }
-  return 0;
-}
-function resolveGids(rawGids, tilesets) {
-  const result = new Array(rawGids.length);
-  for (let i = 0; i < rawGids.length; i++) {
-    const rawGid = rawGids[i];
-    if (rawGid === void 0 || rawGid === 0) {
-      result[i] = null;
-      continue;
-    }
-    const decoded = decodeGid(rawGid);
-    if (!decoded) {
-      result[i] = null;
-      continue;
-    }
-    const tsIdx = findTilesetIndex(decoded.gid, tilesets);
-    const ts = tilesets[tsIdx];
-    if (ts) {
-      decoded.tilesetIndex = tsIdx;
-      decoded.localId = decoded.gid - ts.firstgid;
-    }
-    result[i] = decoded;
-  }
-  return result;
-}
-function layerDefaults(layer) {
-  return {
-    id: layer.id,
-    name: layer.name,
-    opacity: layer.opacity,
-    visible: layer.visible,
-    offsetx: layer.offsetx ?? 0,
-    offsety: layer.offsety ?? 0,
-    parallaxx: layer.parallaxx ?? 1,
-    parallaxy: layer.parallaxy ?? 1,
-    tintcolor: layer.tintcolor,
-    properties: layer.properties ?? []
-  };
-}
-function resolveLayer(layer, tilesets) {
-  switch (layer.type) {
-    case "tilelayer": {
-      const hasChunks = layer.chunks && layer.chunks.length > 0;
-      if (hasChunks) {
-        const resolvedChunks = resolveChunksSync(
-          layer.chunks,
-          layer.encoding,
-          layer.compression,
-          tilesets
-        );
-        return {
-          type: "tilelayer",
-          ...layerDefaults(layer),
-          width: layer.width ?? 0,
-          height: layer.height ?? 0,
-          infinite: true,
-          tiles: [],
-          chunks: resolvedChunks
-        };
-      }
-      const rawGids = decodeLayerData(layer.data ?? [], layer.encoding, layer.compression);
-      const tiles = resolveGids(rawGids, tilesets);
-      return {
-        type: "tilelayer",
-        ...layerDefaults(layer),
-        width: layer.width ?? 0,
-        height: layer.height ?? 0,
-        infinite: false,
-        tiles
-      };
-    }
-    case "imagelayer":
-      return {
-        type: "imagelayer",
-        ...layerDefaults(layer),
-        image: layer.image ?? "",
-        imagewidth: layer.imagewidth,
-        imageheight: layer.imageheight,
-        repeatx: layer.repeatx ?? false,
-        repeaty: layer.repeaty ?? false,
-        transparentcolor: layer.transparentcolor
-      };
-    case "objectgroup":
-      return {
-        type: "objectgroup",
-        ...layerDefaults(layer),
-        draworder: layer.draworder ?? "topdown",
-        objects: layer.objects ?? []
-      };
-    case "group":
-      return {
-        type: "group",
-        ...layerDefaults(layer),
-        layers: (layer.layers ?? []).map((l) => resolveLayer(l, tilesets))
-      };
-  }
-}
-async function resolveLayerAsync(layer, tilesets) {
-  switch (layer.type) {
-    case "tilelayer": {
-      const hasChunks = layer.chunks && layer.chunks.length > 0;
-      if (hasChunks) {
-        const resolvedChunks = await resolveChunksAsync(
-          layer.chunks,
-          layer.encoding,
-          layer.compression,
-          tilesets
-        );
-        return {
-          type: "tilelayer",
-          ...layerDefaults(layer),
-          width: layer.width ?? 0,
-          height: layer.height ?? 0,
-          infinite: true,
-          tiles: [],
-          chunks: resolvedChunks
-        };
-      }
-      const rawGids = await decodeLayerDataAsync(
-        layer.data ?? [],
-        layer.encoding,
-        layer.compression
-      );
-      const tiles = resolveGids(rawGids, tilesets);
-      return {
-        type: "tilelayer",
-        ...layerDefaults(layer),
-        width: layer.width ?? 0,
-        height: layer.height ?? 0,
-        infinite: false,
-        tiles
-      };
-    }
-    case "imagelayer":
-      return {
-        type: "imagelayer",
-        ...layerDefaults(layer),
-        image: layer.image ?? "",
-        imagewidth: layer.imagewidth,
-        imageheight: layer.imageheight,
-        repeatx: layer.repeatx ?? false,
-        repeaty: layer.repeaty ?? false,
-        transparentcolor: layer.transparentcolor
-      };
-    case "objectgroup":
-      return {
-        type: "objectgroup",
-        ...layerDefaults(layer),
-        draworder: layer.draworder ?? "topdown",
-        objects: layer.objects ?? []
-      };
-    case "group": {
-      const resolvedChildren = await Promise.all(
-        (layer.layers ?? []).map((l) => resolveLayerAsync(l, tilesets))
-      );
-      return {
-        type: "group",
-        ...layerDefaults(layer),
-        layers: resolvedChildren
-      };
-    }
-  }
-}
-function parseMap(data, options) {
-  const resolvedTilesets = resolveTilesets(data.tilesets, options);
-  const layers = data.layers.map((l) => resolveLayer(l, resolvedTilesets));
-  return buildResolvedMap(data, resolvedTilesets, layers);
-}
-async function parseMapAsync(data, options) {
-  const resolvedTilesets = resolveTilesets(data.tilesets, options);
-  const layers = await Promise.all(data.layers.map((l) => resolveLayerAsync(l, resolvedTilesets)));
-  return buildResolvedMap(data, resolvedTilesets, layers);
-}
-function resolveChunksSync(chunks, encoding, compression, tilesets) {
-  return chunks.map((chunk) => {
-    const rawGids = decodeLayerData(chunk.data, encoding, compression);
-    return {
-      x: chunk.x,
-      y: chunk.y,
-      width: chunk.width,
-      height: chunk.height,
-      tiles: resolveGids(rawGids, tilesets)
-    };
-  });
-}
-async function resolveChunksAsync(chunks, encoding, compression, tilesets) {
-  return Promise.all(
-    chunks.map(async (chunk) => {
-      const rawGids = await decodeLayerDataAsync(chunk.data, encoding, compression);
-      return {
-        x: chunk.x,
-        y: chunk.y,
-        width: chunk.width,
-        height: chunk.height,
-        tiles: resolveGids(rawGids, tilesets)
-      };
-    })
-  );
-}
-function resolveTilesets(raw, options) {
-  return raw.map((ts) => {
-    if (isTilesetRef(ts)) {
-      const external = options?.externalTilesets?.get(ts.source);
-      if (!external) {
-        throw new Error(
-          `External tileset "${ts.source}" not provided. Pass it via options.externalTilesets.`
-        );
-      }
-      return resolveTileset({ ...external, firstgid: ts.firstgid });
-    }
-    return resolveTileset(ts);
-  });
-}
-function buildResolvedMap(data, tilesets, layers) {
-  return {
-    orientation: data.orientation,
-    renderorder: data.renderorder ?? "right-down",
-    width: data.width,
-    height: data.height,
-    tilewidth: data.tilewidth,
-    tileheight: data.tileheight,
-    infinite: data.infinite,
-    backgroundcolor: data.backgroundcolor,
-    hexsidelength: data.hexsidelength,
-    staggeraxis: data.staggeraxis,
-    staggerindex: data.staggerindex,
-    parallaxoriginx: data.parallaxoriginx ?? 0,
-    parallaxoriginy: data.parallaxoriginy ?? 0,
-    properties: data.properties ?? [],
-    tilesets,
-    layers,
-    version: data.version,
-    tiledversion: data.tiledversion
-  };
-}
-
-// src/parser/parseTmx.ts
+	return "source" in ts && !("name" in ts);
+}
+function computeTilesetColumns(ts) {
+	if (ts.columns && ts.columns > 0) return ts.columns;
+	if (!ts.imagewidth || ts.tilewidth <= 0) return 0;
+	return Math.floor((ts.imagewidth - 2 * ts.margin + ts.spacing) / (ts.tilewidth + ts.spacing));
+}
+/**
+* Finds the index of the tileset whose firstgid range contains `gid`.
+* Works with any array where each element exposes `firstgid`.
+* Returns -1 when no tileset matches.
+*/
+function findTilesetIndexForGid(gid, tilesets) {
+	for (let i = tilesets.length - 1; i >= 0; i--) {
+		const ts = tilesets[i];
+		if (ts && ts.firstgid <= gid) return i;
+	}
+	return -1;
+}
+//#endregion
+//#region src/parser/parseTmx.ts
 function str(el, name, fallback = "") {
-  return el.getAttribute(name) ?? fallback;
+	return el.getAttribute(name) ?? fallback;
 }
 function int(el, name, fallback = 0) {
-  const v = el.getAttribute(name);
-  return v != null ? parseInt(v, 10) : fallback;
+	const v = el.getAttribute(name);
+	return v != null ? parseInt(v, 10) : fallback;
 }
 function float(el, name, fallback = 0) {
-  const v = el.getAttribute(name);
-  return v != null ? parseFloat(v) : fallback;
+	const v = el.getAttribute(name);
+	return v != null ? parseFloat(v) : fallback;
 }
 function bool(el, name, fallback = false) {
-  const v = el.getAttribute(name);
-  if (v == null) return fallback;
-  return v === "1" || v === "true";
+	const v = el.getAttribute(name);
+	if (v == null) return fallback;
+	return v === "1" || v === "true";
 }
 function optStr(el, name) {
-  const v = el.getAttribute(name);
-  return v != null ? v : void 0;
+	const v = el.getAttribute(name);
+	return v != null ? v : void 0;
 }
 function optInt(el, name) {
-  const v = el.getAttribute(name);
-  return v != null ? parseInt(v, 10) : void 0;
+	const v = el.getAttribute(name);
+	return v != null ? parseInt(v, 10) : void 0;
 }
 function optFloat(el, name) {
-  const v = el.getAttribute(name);
-  return v != null ? parseFloat(v) : void 0;
+	const v = el.getAttribute(name);
+	return v != null ? parseFloat(v) : void 0;
 }
 function children(el, tag) {
-  const result = [];
-  for (let i = 0; i < el.children.length; i++) {
-    const child2 = el.children[i];
-    if (child2.tagName === tag) result.push(child2);
-  }
-  return result;
+	const result = [];
+	for (let i = 0; i < el.children.length; i++) {
+		const child = el.children[i];
+		if (child.tagName === tag) result.push(child);
+	}
+	return result;
 }
 function child(el, tag) {
-  for (let i = 0; i < el.children.length; i++) {
-    const c = el.children[i];
-    if (c.tagName === tag) return c;
-  }
-  return null;
+	for (let i = 0; i < el.children.length; i++) {
+		const c = el.children[i];
+		if (c.tagName === tag) return c;
+	}
+	return null;
 }
 function parseProperties(el) {
-  const propsEl = child(el, "properties");
-  if (!propsEl) return void 0;
-  const props = [];
-  for (const pEl of children(propsEl, "property")) {
-    const type = str(pEl, "type", "string");
-    let value = str(pEl, "value", "");
-    if (!pEl.hasAttribute("value")) {
-      value = pEl.textContent ?? "";
-    }
-    if (type === "int") value = parseInt(value, 10);
-    else if (type === "float") value = parseFloat(value);
-    else if (type === "bool") value = value === "true";
-    props.push({
-      name: str(pEl, "name"),
-      type,
-      propertytype: optStr(pEl, "propertytype"),
-      value
-    });
-  }
-  return props.length > 0 ? props : void 0;
+	const propsEl = child(el, "properties");
+	if (!propsEl) return void 0;
+	const props = [];
+	for (const pEl of children(propsEl, "property")) {
+		const type = str(pEl, "type", "string");
+		let value = str(pEl, "value", "");
+		if (!pEl.hasAttribute("value")) value = pEl.textContent ?? "";
+		if (type === "int") value = parseInt(value, 10);
+		else if (type === "float") value = parseFloat(value);
+		else if (type === "bool") value = value === "true";
+		props.push({
+			name: str(pEl, "name"),
+			type,
+			propertytype: optStr(pEl, "propertytype"),
+			value
+		});
+	}
+	return props.length > 0 ? props : void 0;
 }
 function parseImage(el) {
-  const imgEl = child(el, "image");
-  if (!imgEl) return {};
-  return {
-    image: optStr(imgEl, "source"),
-    imagewidth: optInt(imgEl, "width"),
-    imageheight: optInt(imgEl, "height"),
-    transparentcolor: optStr(imgEl, "trans")
-  };
+	const imgEl = child(el, "image");
+	if (!imgEl) return {};
+	return {
+		image: optStr(imgEl, "source"),
+		imagewidth: optInt(imgEl, "width"),
+		imageheight: optInt(imgEl, "height"),
+		transparentcolor: optStr(imgEl, "trans")
+	};
 }
 function parseTileOffset(el) {
-  const to = child(el, "tileoffset");
-  if (!to) return void 0;
-  return { x: int(to, "x"), y: int(to, "y") };
+	const to = child(el, "tileoffset");
+	if (!to) return void 0;
+	return {
+		x: int(to, "x"),
+		y: int(to, "y")
+	};
 }
 function parseGrid(el) {
-  const g = child(el, "grid");
-  if (!g) return void 0;
-  return {
-    orientation: str(g, "orientation", "orthogonal"),
-    width: int(g, "width"),
-    height: int(g, "height")
-  };
+	const g = child(el, "grid");
+	if (!g) return void 0;
+	return {
+		orientation: str(g, "orientation", "orthogonal"),
+		width: int(g, "width"),
+		height: int(g, "height")
+	};
 }
 function parseTransformations(el) {
-  const t = child(el, "transformations");
-  if (!t) return void 0;
-  return {
-    hflip: bool(t, "hflip"),
-    vflip: bool(t, "vflip"),
-    rotate: bool(t, "rotate"),
-    preferuntransformed: bool(t, "preferuntransformed")
-  };
+	const t = child(el, "transformations");
+	if (!t) return void 0;
+	return {
+		hflip: bool(t, "hflip"),
+		vflip: bool(t, "vflip"),
+		rotate: bool(t, "rotate"),
+		preferuntransformed: bool(t, "preferuntransformed")
+	};
 }
 function parseTerrains(el) {
-  const ttEl = child(el, "terraintypes");
-  if (!ttEl) return void 0;
-  return children(ttEl, "terrain").map((t) => ({
-    name: str(t, "name"),
-    tile: int(t, "tile"),
-    properties: parseProperties(t)
-  }));
+	const ttEl = child(el, "terraintypes");
+	if (!ttEl) return void 0;
+	return children(ttEl, "terrain").map((t) => ({
+		name: str(t, "name"),
+		tile: int(t, "tile"),
+		properties: parseProperties(t)
+	}));
 }
 function parseWangSets(el) {
-  const wsEl = child(el, "wangsets");
-  if (!wsEl) return void 0;
-  return children(wsEl, "wangset").map((ws) => {
-    const colors = children(ws, "wangcolor").map((wc) => ({
-      class: optStr(wc, "class"),
-      color: str(wc, "color"),
-      name: str(wc, "name"),
-      probability: float(wc, "probability"),
-      tile: int(wc, "tile"),
-      properties: parseProperties(wc)
-    }));
-    const tiles = children(ws, "wangtile").map((wt) => ({
-      tileid: int(wt, "tileid"),
-      wangid: str(wt, "wangid").split(",").map(Number)
-    }));
-    return {
-      class: optStr(ws, "class"),
-      colors,
-      name: str(ws, "name"),
-      properties: parseProperties(ws),
-      tile: int(ws, "tile"),
-      type: str(ws, "type", "corner"),
-      wangtiles: tiles
-    };
-  });
+	const wsEl = child(el, "wangsets");
+	if (!wsEl) return void 0;
+	return children(wsEl, "wangset").map((ws) => {
+		const colors = children(ws, "wangcolor").map((wc) => ({
+			class: optStr(wc, "class"),
+			color: str(wc, "color"),
+			name: str(wc, "name"),
+			probability: float(wc, "probability"),
+			tile: int(wc, "tile"),
+			properties: parseProperties(wc)
+		}));
+		const tiles = children(ws, "wangtile").map((wt) => ({
+			tileid: int(wt, "tileid"),
+			wangid: str(wt, "wangid").split(",").map(Number)
+		}));
+		return {
+			class: optStr(ws, "class"),
+			colors,
+			name: str(ws, "name"),
+			properties: parseProperties(ws),
+			tile: int(ws, "tile"),
+			type: str(ws, "type", "corner"),
+			wangtiles: tiles
+		};
+	});
 }
 function parseAnimation(el) {
-  const animEl = child(el, "animation");
-  if (!animEl) return void 0;
-  return children(animEl, "frame").map((f) => ({
-    tileid: int(f, "tileid"),
-    duration: int(f, "duration")
-  }));
+	const animEl = child(el, "animation");
+	if (!animEl) return void 0;
+	return children(animEl, "frame").map((f) => ({
+		tileid: int(f, "tileid"),
+		duration: int(f, "duration")
+	}));
 }
 function parseTileDefinitions(el) {
-  const tileEls = children(el, "tile");
-  if (tileEls.length === 0) return void 0;
-  return tileEls.map((t) => {
-    const img = parseImage(t);
-    const terrainAttr = optStr(t, "terrain");
-    const terrain = terrainAttr ? terrainAttr.split(",").map((v) => v === "" ? -1 : parseInt(v, 10)) : void 0;
-    const ogEl = child(t, "objectgroup");
-    const objectgroup = ogEl ? parseObjectGroup(ogEl) : void 0;
-    const def = {
-      id: int(t, "id"),
-      type: optStr(t, "type") ?? optStr(t, "class"),
-      probability: optFloat(t, "probability"),
-      x: optInt(t, "x"),
-      y: optInt(t, "y"),
-      width: optInt(t, "width"),
-      height: optInt(t, "height"),
-      properties: parseProperties(t),
-      animation: parseAnimation(t),
-      terrain,
-      objectgroup,
-      ...img
-    };
-    return def;
-  });
+	const tileEls = children(el, "tile");
+	if (tileEls.length === 0) return void 0;
+	return tileEls.map((t) => {
+		const img = parseImage(t);
+		const terrainAttr = optStr(t, "terrain");
+		const terrain = terrainAttr ? terrainAttr.split(",").map((v) => v === "" ? -1 : parseInt(v, 10)) : void 0;
+		const ogEl = child(t, "objectgroup");
+		const objectgroup = ogEl ? parseObjectGroup(ogEl) : void 0;
+		return {
+			id: int(t, "id"),
+			type: optStr(t, "type") ?? optStr(t, "class"),
+			probability: optFloat(t, "probability"),
+			x: optInt(t, "x"),
+			y: optInt(t, "y"),
+			width: optInt(t, "width"),
+			height: optInt(t, "height"),
+			properties: parseProperties(t),
+			animation: parseAnimation(t),
+			terrain,
+			objectgroup,
+			...img
+		};
+	});
 }
 function parseTileset(el) {
-  const source = optStr(el, "source");
-  if (source) {
-    return {
-      firstgid: int(el, "firstgid"),
-      source
-    };
-  }
-  const img = parseImage(el);
-  const tiles = parseTileDefinitions(el);
-  const tilewidth = int(el, "tilewidth");
-  const spacing = int(el, "spacing");
-  const margin = int(el, "margin");
-  const rawColumns = int(el, "columns");
-  const columns = rawColumns > 0 ? rawColumns : img.imagewidth && tilewidth > 0 ? Math.floor((img.imagewidth - 2 * margin + spacing) / (tilewidth + spacing)) : 0;
-  return {
-    backgroundcolor: optStr(el, "backgroundcolor"),
-    class: optStr(el, "class"),
-    columns,
-    fillmode: optStr(el, "fillmode"),
-    firstgid: int(el, "firstgid"),
-    grid: parseGrid(el),
-    margin,
-    name: str(el, "name"),
-    objectalignment: optStr(el, "objectalignment"),
-    properties: parseProperties(el),
-    spacing,
-    terrains: parseTerrains(el),
-    tilecount: int(el, "tilecount"),
-    tileheight: int(el, "tileheight"),
-    tileoffset: parseTileOffset(el),
-    tilerendersize: optStr(el, "tilerendersize"),
-    tiles,
-    tilewidth,
-    transformations: parseTransformations(el),
-    wangsets: parseWangSets(el),
-    ...img
-  };
+	const source = optStr(el, "source");
+	if (source) return {
+		firstgid: int(el, "firstgid"),
+		source
+	};
+	const img = parseImage(el);
+	const tiles = parseTileDefinitions(el);
+	const tilewidth = int(el, "tilewidth");
+	const spacing = int(el, "spacing");
+	const margin = int(el, "margin");
+	const columns = computeTilesetColumns({
+		columns: int(el, "columns"),
+		imagewidth: img.imagewidth,
+		tilewidth,
+		margin,
+		spacing
+	});
+	return {
+		backgroundcolor: optStr(el, "backgroundcolor"),
+		class: optStr(el, "class"),
+		columns,
+		fillmode: optStr(el, "fillmode"),
+		firstgid: int(el, "firstgid"),
+		grid: parseGrid(el),
+		margin,
+		name: str(el, "name"),
+		objectalignment: optStr(el, "objectalignment"),
+		properties: parseProperties(el),
+		spacing,
+		terrains: parseTerrains(el),
+		tilecount: int(el, "tilecount"),
+		tileheight: int(el, "tileheight"),
+		tileoffset: parseTileOffset(el),
+		tilerendersize: optStr(el, "tilerendersize"),
+		tiles,
+		tilewidth,
+		transformations: parseTransformations(el),
+		wangsets: parseWangSets(el),
+		...img
+	};
 }
 function parseData(dataEl) {
-  const encoding = optStr(dataEl, "encoding");
-  const compression = optStr(dataEl, "compression");
-  const chunkEls = children(dataEl, "chunk");
-  if (chunkEls.length > 0) {
-    const chunks = chunkEls.map((c) => ({
-      x: int(c, "x"),
-      y: int(c, "y"),
-      width: int(c, "width"),
-      height: int(c, "height"),
-      data: parseDataContent(c, encoding)
-    }));
-    return { encoding, compression, chunks };
-  }
-  return {
-    data: parseDataContent(dataEl, encoding),
-    encoding,
-    compression
-  };
+	const encoding = optStr(dataEl, "encoding");
+	const compression = optStr(dataEl, "compression");
+	const chunkEls = children(dataEl, "chunk");
+	if (chunkEls.length > 0) return {
+		encoding,
+		compression,
+		chunks: chunkEls.map((c) => ({
+			x: int(c, "x"),
+			y: int(c, "y"),
+			width: int(c, "width"),
+			height: int(c, "height"),
+			data: parseDataContent(c, encoding)
+		}))
+	};
+	return {
+		data: parseDataContent(dataEl, encoding),
+		encoding,
+		compression
+	};
 }
 function parseDataContent(el, encoding) {
-  if (encoding === "base64") {
-    return (el.textContent ?? "").trim();
-  }
-  if (encoding === "csv") {
-    return (el.textContent ?? "").trim().split(",").map((s) => parseInt(s.trim(), 10));
-  }
-  const tileEls = children(el, "tile");
-  return tileEls.map((t) => int(t, "gid"));
+	if (encoding === "base64") return (el.textContent ?? "").trim();
+	if (encoding === "csv") {
+		const out = [];
+		for (const token of (el.textContent ?? "").split(",")) {
+			const trimmed = token.trim();
+			if (trimmed.length === 0) continue;
+			out.push(parseInt(trimmed, 10));
+		}
+		return out;
+	}
+	return children(el, "tile").map((t) => int(t, "gid"));
 }
 function parsePoints(pointStr) {
-  return pointStr.trim().split(/\s+/).map((pair) => {
-    const [x, y] = pair.split(",").map(Number);
-    return { x, y };
-  });
+	return pointStr.trim().split(/\s+/).map((pair) => {
+		const [x, y] = pair.split(",").map(Number);
+		return {
+			x,
+			y
+		};
+	});
 }
 function parseTextObject(el) {
-  return {
-    text: el.textContent ?? "",
-    fontfamily: optStr(el, "fontfamily"),
-    pixelsize: optInt(el, "pixelsize"),
-    wrap: bool(el, "wrap") ? true : void 0,
-    color: optStr(el, "color"),
-    bold: bool(el, "bold") ? true : void 0,
-    italic: bool(el, "italic") ? true : void 0,
-    underline: bool(el, "underline") ? true : void 0,
-    strikeout: bool(el, "strikeout") ? true : void 0,
-    kerning: el.hasAttribute("kerning") ? bool(el, "kerning", true) : void 0,
-    halign: optStr(el, "halign"),
-    valign: optStr(el, "valign")
-  };
+	return {
+		text: el.textContent ?? "",
+		fontfamily: optStr(el, "fontfamily"),
+		pixelsize: optInt(el, "pixelsize"),
+		wrap: bool(el, "wrap") ? true : void 0,
+		color: optStr(el, "color"),
+		bold: bool(el, "bold") ? true : void 0,
+		italic: bool(el, "italic") ? true : void 0,
+		underline: bool(el, "underline") ? true : void 0,
+		strikeout: bool(el, "strikeout") ? true : void 0,
+		kerning: el.hasAttribute("kerning") ? bool(el, "kerning", true) : void 0,
+		halign: optStr(el, "halign"),
+		valign: optStr(el, "valign")
+	};
 }
 function parseObject(el) {
-  const obj = {
-    id: int(el, "id"),
-    name: str(el, "name"),
-    type: str(el, "type") || str(el, "class"),
-    x: float(el, "x"),
-    y: float(el, "y"),
-    width: float(el, "width"),
-    height: float(el, "height"),
-    rotation: float(el, "rotation"),
-    visible: el.hasAttribute("visible") ? bool(el, "visible", true) : true,
-    properties: parseProperties(el)
-  };
-  const gid = optInt(el, "gid");
-  if (gid != null) obj.gid = gid;
-  const template = optStr(el, "template");
-  if (template) obj.template = template;
-  if (child(el, "ellipse")) obj.ellipse = true;
-  if (child(el, "point")) obj.point = true;
-  const polygonEl = child(el, "polygon");
-  if (polygonEl) {
-    obj.polygon = parsePoints(str(polygonEl, "points"));
-  }
-  const polylineEl = child(el, "polyline");
-  if (polylineEl) {
-    obj.polyline = parsePoints(str(polylineEl, "points"));
-  }
-  const textEl = child(el, "text");
-  if (textEl) {
-    obj.text = parseTextObject(textEl);
-  }
-  return obj;
+	const obj = {
+		id: int(el, "id"),
+		name: str(el, "name"),
+		type: str(el, "type") || str(el, "class"),
+		x: float(el, "x"),
+		y: float(el, "y"),
+		width: float(el, "width"),
+		height: float(el, "height"),
+		rotation: float(el, "rotation"),
+		visible: el.hasAttribute("visible") ? bool(el, "visible", true) : true,
+		properties: parseProperties(el)
+	};
+	const gid = optInt(el, "gid");
+	if (gid != null) obj.gid = gid;
+	const template = optStr(el, "template");
+	if (template) obj.template = template;
+	if (child(el, "ellipse")) obj.ellipse = true;
+	if (child(el, "point")) obj.point = true;
+	const polygonEl = child(el, "polygon");
+	if (polygonEl) obj.polygon = parsePoints(str(polygonEl, "points"));
+	const polylineEl = child(el, "polyline");
+	if (polylineEl) obj.polyline = parsePoints(str(polylineEl, "points"));
+	const textEl = child(el, "text");
+	if (textEl) obj.text = parseTextObject(textEl);
+	return obj;
 }
 function parseLayerCommon(el) {
-  return {
-    id: int(el, "id"),
-    name: str(el, "name"),
-    class: optStr(el, "class"),
-    opacity: float(el, "opacity", 1),
-    visible: el.hasAttribute("visible") ? bool(el, "visible", true) : true,
-    tintcolor: optStr(el, "tintcolor"),
-    offsetx: optFloat(el, "offsetx"),
-    offsety: optFloat(el, "offsety"),
-    parallaxx: optFloat(el, "parallaxx"),
-    parallaxy: optFloat(el, "parallaxy"),
-    locked: el.hasAttribute("locked") ? bool(el, "locked") : void 0,
-    properties: parseProperties(el),
-    x: int(el, "x"),
-    y: int(el, "y")
-  };
+	return {
+		id: int(el, "id"),
+		name: str(el, "name"),
+		class: optStr(el, "class"),
+		opacity: float(el, "opacity", 1),
+		visible: el.hasAttribute("visible") ? bool(el, "visible", true) : true,
+		tintcolor: optStr(el, "tintcolor"),
+		offsetx: optFloat(el, "offsetx"),
+		offsety: optFloat(el, "offsety"),
+		parallaxx: optFloat(el, "parallaxx"),
+		parallaxy: optFloat(el, "parallaxy"),
+		locked: el.hasAttribute("locked") ? bool(el, "locked") : void 0,
+		properties: parseProperties(el),
+		x: int(el, "x"),
+		y: int(el, "y")
+	};
 }
 function parseTileLayer(el) {
-  const dataEl = child(el, "data");
-  const dataInfo = dataEl ? parseData(dataEl) : {};
-  return {
-    ...parseLayerCommon(el),
-    type: "tilelayer",
-    width: optInt(el, "width"),
-    height: optInt(el, "height"),
-    startx: optInt(el, "startx"),
-    starty: optInt(el, "starty"),
-    ...dataInfo
-  };
+	const dataEl = child(el, "data");
+	const dataInfo = dataEl ? parseData(dataEl) : {};
+	return {
+		...parseLayerCommon(el),
+		type: "tilelayer",
+		width: optInt(el, "width"),
+		height: optInt(el, "height"),
+		startx: optInt(el, "startx"),
+		starty: optInt(el, "starty"),
+		...dataInfo
+	};
 }
 function parseObjectGroup(el) {
-  return {
-    ...parseLayerCommon(el),
-    type: "objectgroup",
-    draworder: optStr(el, "draworder"),
-    objects: children(el, "object").map(parseObject)
-  };
+	return {
+		...parseLayerCommon(el),
+		type: "objectgroup",
+		draworder: optStr(el, "draworder"),
+		objects: children(el, "object").map(parseObject)
+	};
 }
 function parseImageLayer(el) {
-  const img = parseImage(el);
-  return {
-    ...parseLayerCommon(el),
-    type: "imagelayer",
-    repeatx: el.hasAttribute("repeatx") ? bool(el, "repeatx") : void 0,
-    repeaty: el.hasAttribute("repeaty") ? bool(el, "repeaty") : void 0,
-    transparentcolor: img.transparentcolor,
-    image: img.image,
-    imagewidth: img.imagewidth,
-    imageheight: img.imageheight
-  };
+	const img = parseImage(el);
+	return {
+		...parseLayerCommon(el),
+		type: "imagelayer",
+		repeatx: el.hasAttribute("repeatx") ? bool(el, "repeatx") : void 0,
+		repeaty: el.hasAttribute("repeaty") ? bool(el, "repeaty") : void 0,
+		transparentcolor: img.transparentcolor,
+		image: img.image,
+		imagewidth: img.imagewidth,
+		imageheight: img.imageheight
+	};
 }
 function parseGroupLayer(el) {
-  return {
-    ...parseLayerCommon(el),
-    type: "group",
-    layers: parseLayers(el)
-  };
+	return {
+		...parseLayerCommon(el),
+		type: "group",
+		layers: parseLayers(el)
+	};
 }
 function parseLayers(parentEl) {
-  const layers = [];
-  for (let i = 0; i < parentEl.children.length; i++) {
-    const el = parentEl.children[i];
-    switch (el.tagName) {
-      case "layer":
-        layers.push(parseTileLayer(el));
-        break;
-      case "objectgroup":
-        layers.push(parseObjectGroup(el));
-        break;
-      case "imagelayer":
-        layers.push(parseImageLayer(el));
-        break;
-      case "group":
-        layers.push(parseGroupLayer(el));
-        break;
-    }
-  }
-  return layers;
+	const layers = [];
+	for (let i = 0; i < parentEl.children.length; i++) {
+		const el = parentEl.children[i];
+		switch (el.tagName) {
+			case "layer":
+				layers.push(parseTileLayer(el));
+				break;
+			case "objectgroup":
+				layers.push(parseObjectGroup(el));
+				break;
+			case "imagelayer":
+				layers.push(parseImageLayer(el));
+				break;
+			case "group":
+				layers.push(parseGroupLayer(el));
+				break;
+		}
+	}
+	return layers;
 }
 function parseTmx(xml) {
-  const parser = new DOMParser();
-  const doc = parser.parseFromString(xml, "text/xml");
-  const errorNode = doc.querySelector("parsererror");
-  if (errorNode) {
-    throw new Error(`TMX XML parse error: ${errorNode.textContent}`);
-  }
-  const mapEl = doc.documentElement;
-  if (mapEl.tagName !== "map") {
-    throw new Error(`Expected root <map> element, got <${mapEl.tagName}>`);
-  }
-  const tilesets = children(mapEl, "tileset").map(parseTileset);
-  const layers = parseLayers(mapEl);
-  return {
-    backgroundcolor: optStr(mapEl, "backgroundcolor"),
-    class: optStr(mapEl, "class"),
-    compressionlevel: optInt(mapEl, "compressionlevel"),
-    height: int(mapEl, "height"),
-    hexsidelength: optInt(mapEl, "hexsidelength"),
-    infinite: bool(mapEl, "infinite"),
-    layers,
-    nextlayerid: int(mapEl, "nextlayerid"),
-    nextobjectid: int(mapEl, "nextobjectid"),
-    orientation: str(mapEl, "orientation", "orthogonal"),
-    parallaxoriginx: optFloat(mapEl, "parallaxoriginx"),
-    parallaxoriginy: optFloat(mapEl, "parallaxoriginy"),
-    properties: parseProperties(mapEl),
-    renderorder: optStr(mapEl, "renderorder"),
-    staggeraxis: optStr(mapEl, "staggeraxis"),
-    staggerindex: optStr(mapEl, "staggerindex"),
-    tiledversion: optStr(mapEl, "tiledversion"),
-    tileheight: int(mapEl, "tileheight"),
-    tilesets,
-    tilewidth: int(mapEl, "tilewidth"),
-    type: "map",
-    version: str(mapEl, "version", "1.0"),
-    width: int(mapEl, "width")
-  };
+	const doc = new DOMParser().parseFromString(xml, "text/xml");
+	const errorNode = doc.querySelector("parsererror");
+	if (errorNode) throw new Error(`TMX XML parse error: ${errorNode.textContent}`);
+	const mapEl = doc.documentElement;
+	if (mapEl.tagName !== "map") throw new Error(`Expected root <map> element, got <${mapEl.tagName}>`);
+	const tilesets = children(mapEl, "tileset").map(parseTileset);
+	const layers = parseLayers(mapEl);
+	return {
+		backgroundcolor: optStr(mapEl, "backgroundcolor"),
+		class: optStr(mapEl, "class"),
+		compressionlevel: optInt(mapEl, "compressionlevel"),
+		height: int(mapEl, "height"),
+		hexsidelength: optInt(mapEl, "hexsidelength"),
+		infinite: bool(mapEl, "infinite"),
+		layers,
+		nextlayerid: int(mapEl, "nextlayerid"),
+		nextobjectid: int(mapEl, "nextobjectid"),
+		orientation: str(mapEl, "orientation", "orthogonal"),
+		parallaxoriginx: optFloat(mapEl, "parallaxoriginx"),
+		parallaxoriginy: optFloat(mapEl, "parallaxoriginy"),
+		properties: parseProperties(mapEl),
+		renderorder: optStr(mapEl, "renderorder"),
+		staggeraxis: optStr(mapEl, "staggeraxis"),
+		staggerindex: optStr(mapEl, "staggerindex"),
+		tiledversion: optStr(mapEl, "tiledversion"),
+		tileheight: int(mapEl, "tileheight"),
+		tilesets,
+		tilewidth: int(mapEl, "tilewidth"),
+		type: "map",
+		version: str(mapEl, "version", "1.0"),
+		width: int(mapEl, "width")
+	};
 }
 function parseTsx(xml) {
-  const parser = new DOMParser();
-  const doc = parser.parseFromString(xml, "text/xml");
-  const errorNode = doc.querySelector("parsererror");
-  if (errorNode) {
-    throw new Error(`TSX XML parse error: ${errorNode.textContent}`);
-  }
-  const tsEl = doc.documentElement;
-  if (tsEl.tagName !== "tileset") {
-    throw new Error(`Expected root <tileset> element, got <${tsEl.tagName}>`);
-  }
-  const result = parseTileset(tsEl);
-  if ("source" in result) {
-    throw new Error("TSX file should not contain a source reference");
-  }
-  return result;
+	const doc = new DOMParser().parseFromString(xml, "text/xml");
+	const errorNode = doc.querySelector("parsererror");
+	if (errorNode) throw new Error(`TSX XML parse error: ${errorNode.textContent}`);
+	const tsEl = doc.documentElement;
+	if (tsEl.tagName !== "tileset") throw new Error(`Expected root <tileset> element, got <${tsEl.tagName}>`);
+	const result = parseTileset(tsEl);
+	if ("source" in result) throw new Error("TSX file should not contain a source reference");
+	return result;
+}
+function parseTx(xml) {
+	const doc = new DOMParser().parseFromString(xml, "text/xml");
+	const errorNode = doc.querySelector("parsererror");
+	if (errorNode) throw new Error(`TX XML parse error: ${errorNode.textContent}`);
+	const tplEl = doc.documentElement;
+	if (tplEl.tagName !== "template") throw new Error(`Expected root <template> element, got <${tplEl.tagName}>`);
+	const tilesetEl = child(tplEl, "tileset");
+	const objectEl = child(tplEl, "object");
+	if (!objectEl) throw new Error("Template is missing <object>");
+	return {
+		type: "template",
+		tileset: tilesetEl ? parseTileset(tilesetEl) : void 0,
+		object: parseObject(objectEl)
+	};
+}
+//#endregion
+//#region src/parser/resolveMap.ts
+function resolveTileset(raw, source) {
+	const tiles = /* @__PURE__ */ new Map();
+	if (raw.tiles) for (const tile of raw.tiles) tiles.set(tile.id, tile);
+	return {
+		firstgid: raw.firstgid,
+		name: raw.name,
+		source,
+		tilewidth: raw.tilewidth,
+		tileheight: raw.tileheight,
+		columns: computeTilesetColumns(raw),
+		tilecount: raw.tilecount,
+		margin: raw.margin,
+		spacing: raw.spacing,
+		image: raw.image,
+		imagewidth: raw.imagewidth,
+		imageheight: raw.imageheight,
+		tileoffset: raw.tileoffset ?? {
+			x: 0,
+			y: 0
+		},
+		objectalignment: raw.objectalignment ?? "unspecified",
+		tilerendersize: raw.tilerendersize ?? "tile",
+		fillmode: raw.fillmode ?? "stretch",
+		tiles,
+		properties: raw.properties ?? [],
+		transformations: raw.transformations,
+		grid: raw.grid,
+		wangsets: raw.wangsets,
+		terrains: raw.terrains
+	};
 }
-var TileSetRenderer = class {
-  constructor(tileset, baseTexture) {
-    this._textureCache = /* @__PURE__ */ new Map();
-    this.tileset = tileset;
-    this.baseTexture = baseTexture;
-  }
-  getTexture(localId) {
-    const cached = this._textureCache.get(localId);
-    if (cached) return cached;
-    const tileDef = this.tileset.tiles.get(localId);
-    if (tileDef?.image) {
-      return null;
-    }
-    if (!this.baseTexture) return null;
-    const { tilewidth, tileheight, columns, margin, spacing } = this.tileset;
-    if (columns <= 0) return null;
-    const col = localId % columns;
-    const row = Math.floor(localId / columns);
-    const x = margin + col * (tilewidth + spacing);
-    const y = margin + row * (tileheight + spacing);
-    const frame = new pixi_js.Rectangle(x, y, tilewidth, tileheight);
-    const texture = new pixi_js.Texture({ source: this.baseTexture.source, frame });
-    this._textureCache.set(localId, texture);
-    return texture;
-  }
-  setTileTexture(localId, texture) {
-    this._textureCache.set(localId, texture);
-  }
-  getAnimationFrames(localId) {
-    return this.tileset.tiles.get(localId)?.animation;
-  }
-  destroy() {
-    for (const tex of this._textureCache.values()) {
-      tex.destroy();
-    }
-    this._textureCache.clear();
-  }
+function resolveGids(rawGids, tilesets) {
+	const result = new Array(rawGids.length);
+	for (let i = 0; i < rawGids.length; i++) {
+		const rawGid = rawGids[i];
+		if (rawGid === void 0 || rawGid === 0) {
+			result[i] = null;
+			continue;
+		}
+		const decoded = decodeGid(rawGid);
+		if (!decoded) {
+			result[i] = null;
+			continue;
+		}
+		const tsIdx = findTilesetIndexForGid(decoded.gid, tilesets);
+		const ts = tsIdx >= 0 ? tilesets[tsIdx] : void 0;
+		if (ts) {
+			decoded.tilesetIndex = tsIdx;
+			decoded.localId = decoded.gid - ts.firstgid;
+		}
+		result[i] = decoded;
+	}
+	return result;
+}
+function layerDefaults(layer) {
+	return {
+		id: layer.id,
+		name: layer.name,
+		opacity: layer.opacity,
+		visible: layer.visible,
+		offsetx: layer.offsetx ?? 0,
+		offsety: layer.offsety ?? 0,
+		parallaxx: layer.parallaxx ?? 1,
+		parallaxy: layer.parallaxy ?? 1,
+		tintcolor: layer.tintcolor,
+		properties: layer.properties ?? []
+	};
+}
+function mergeTemplate(obj, template, tilesets) {
+	const base = {
+		...template.object,
+		id: obj.id,
+		x: obj.x,
+		y: obj.y,
+		rotation: obj.rotation,
+		visible: obj.visible
+	};
+	if (obj.name) base.name = obj.name;
+	if (obj.type) base.type = obj.type;
+	if (obj.width) base.width = obj.width;
+	if (obj.height) base.height = obj.height;
+	if (obj.properties) base.properties = obj.properties;
+	if (obj.text) base.text = obj.text;
+	if (obj.gid !== void 0) base.gid = obj.gid;
+	if (obj.polygon) base.polygon = obj.polygon;
+	if (obj.polyline) base.polyline = obj.polyline;
+	if (obj.ellipse) base.ellipse = obj.ellipse;
+	if (obj.point) base.point = obj.point;
+	if (base.gid !== void 0 && template.tileset && "source" in template.tileset && template.tileset.source) {
+		const src = template.tileset.source;
+		const mapTs = tilesets.find((t) => t.source === src);
+		if (mapTs) {
+			const templateFirstGid = template.tileset.firstgid ?? 1;
+			const flipBits = base.gid & ~GID_MASK;
+			const localId = (base.gid & GID_MASK) - templateFirstGid;
+			if (localId >= 0) base.gid = mapTs.firstgid + localId | flipBits;
+		}
+	}
+	return base;
+}
+function resolveObjects(objects, tilesets, templates) {
+	if (!templates || templates.size === 0) return objects;
+	return objects.map((obj) => {
+		if (!obj.template) return obj;
+		const tpl = templates.get(obj.template);
+		if (!tpl) return obj;
+		return mergeTemplate(obj, tpl, tilesets);
+	});
+}
+function resolveLayer(layer, tilesets, templates) {
+	switch (layer.type) {
+		case "tilelayer": {
+			if (layer.chunks && layer.chunks.length > 0) {
+				const resolvedChunks = resolveChunksSync(layer.chunks, layer.encoding, layer.compression, tilesets);
+				return {
+					type: "tilelayer",
+					...layerDefaults(layer),
+					width: layer.width ?? 0,
+					height: layer.height ?? 0,
+					infinite: true,
+					tiles: [],
+					chunks: resolvedChunks
+				};
+			}
+			const tiles = resolveGids(decodeLayerData(layer.data ?? [], layer.encoding, layer.compression), tilesets);
+			return {
+				type: "tilelayer",
+				...layerDefaults(layer),
+				width: layer.width ?? 0,
+				height: layer.height ?? 0,
+				infinite: false,
+				tiles
+			};
+		}
+		case "imagelayer": return {
+			type: "imagelayer",
+			...layerDefaults(layer),
+			image: layer.image ?? "",
+			imagewidth: layer.imagewidth,
+			imageheight: layer.imageheight,
+			repeatx: layer.repeatx ?? false,
+			repeaty: layer.repeaty ?? false,
+			transparentcolor: layer.transparentcolor
+		};
+		case "objectgroup": return {
+			type: "objectgroup",
+			...layerDefaults(layer),
+			draworder: layer.draworder ?? "topdown",
+			objects: resolveObjects(layer.objects ?? [], tilesets, templates)
+		};
+		case "group": return {
+			type: "group",
+			...layerDefaults(layer),
+			layers: (layer.layers ?? []).map((l) => resolveLayer(l, tilesets, templates))
+		};
+	}
+}
+async function resolveLayerAsync(layer, tilesets, templates) {
+	switch (layer.type) {
+		case "tilelayer": {
+			if (layer.chunks && layer.chunks.length > 0) {
+				const resolvedChunks = await resolveChunksAsync(layer.chunks, layer.encoding, layer.compression, tilesets);
+				return {
+					type: "tilelayer",
+					...layerDefaults(layer),
+					width: layer.width ?? 0,
+					height: layer.height ?? 0,
+					infinite: true,
+					tiles: [],
+					chunks: resolvedChunks
+				};
+			}
+			const tiles = resolveGids(await decodeLayerDataAsync(layer.data ?? [], layer.encoding, layer.compression), tilesets);
+			return {
+				type: "tilelayer",
+				...layerDefaults(layer),
+				width: layer.width ?? 0,
+				height: layer.height ?? 0,
+				infinite: false,
+				tiles
+			};
+		}
+		case "imagelayer": return {
+			type: "imagelayer",
+			...layerDefaults(layer),
+			image: layer.image ?? "",
+			imagewidth: layer.imagewidth,
+			imageheight: layer.imageheight,
+			repeatx: layer.repeatx ?? false,
+			repeaty: layer.repeaty ?? false,
+			transparentcolor: layer.transparentcolor
+		};
+		case "objectgroup": return {
+			type: "objectgroup",
+			...layerDefaults(layer),
+			draworder: layer.draworder ?? "topdown",
+			objects: resolveObjects(layer.objects ?? [], tilesets, templates)
+		};
+		case "group": {
+			const resolvedChildren = await Promise.all((layer.layers ?? []).map((l) => resolveLayerAsync(l, tilesets, templates)));
+			return {
+				type: "group",
+				...layerDefaults(layer),
+				layers: resolvedChildren
+			};
+		}
+	}
+}
+function parseMap(data, options) {
+	const resolvedTilesets = resolveTilesets(data.tilesets, options);
+	return buildResolvedMap(data, resolvedTilesets, data.layers.map((l) => resolveLayer(l, resolvedTilesets, options?.templates)));
+}
+async function parseMapAsync(data, options) {
+	const resolvedTilesets = resolveTilesets(data.tilesets, options);
+	return buildResolvedMap(data, resolvedTilesets, await Promise.all(data.layers.map((l) => resolveLayerAsync(l, resolvedTilesets, options?.templates))));
+}
+function resolveChunksSync(chunks, encoding, compression, tilesets) {
+	return chunks.map((chunk) => {
+		const rawGids = decodeLayerData(chunk.data, encoding, compression);
+		return {
+			x: chunk.x,
+			y: chunk.y,
+			width: chunk.width,
+			height: chunk.height,
+			tiles: resolveGids(rawGids, tilesets)
+		};
+	});
+}
+async function resolveChunksAsync(chunks, encoding, compression, tilesets) {
+	return Promise.all(chunks.map(async (chunk) => {
+		const rawGids = await decodeLayerDataAsync(chunk.data, encoding, compression);
+		return {
+			x: chunk.x,
+			y: chunk.y,
+			width: chunk.width,
+			height: chunk.height,
+			tiles: resolveGids(rawGids, tilesets)
+		};
+	}));
+}
+function resolveTilesets(raw, options) {
+	return raw.map((ts) => {
+		if (isTilesetRef(ts)) {
+			const external = options?.externalTilesets?.get(ts.source);
+			if (!external) throw new Error(`External tileset "${ts.source}" not provided. Pass it via options.externalTilesets.`);
+			return resolveTileset({
+				...external,
+				firstgid: ts.firstgid
+			}, ts.source);
+		}
+		return resolveTileset(ts);
+	});
+}
+function buildResolvedMap(data, tilesets, layers) {
+	return {
+		orientation: data.orientation,
+		renderorder: data.renderorder ?? "right-down",
+		width: data.width,
+		height: data.height,
+		tilewidth: data.tilewidth,
+		tileheight: data.tileheight,
+		infinite: data.infinite,
+		backgroundcolor: data.backgroundcolor,
+		hexsidelength: data.hexsidelength,
+		staggeraxis: data.staggeraxis,
+		staggerindex: data.staggerindex,
+		parallaxoriginx: data.parallaxoriginx ?? 0,
+		parallaxoriginy: data.parallaxoriginy ?? 0,
+		properties: data.properties ?? [],
+		tilesets,
+		layers,
+		version: data.version,
+		tiledversion: data.tiledversion
+	};
+}
+//#endregion
+//#region src/renderer/parseColor.ts
+function parseTintColor(hex) {
+	const clean = hex.replace("#", "");
+	if (clean.length === 8) return parseInt(clean.slice(2), 16);
+	return parseInt(clean, 16);
+}
+//#endregion
+//#region src/renderer/GroupLayerRenderer.ts
+var GroupLayerRenderer = class extends pixi_js.Container {
+	constructor(layerData, tilesets, ctx, imageTextures) {
+		super();
+		this.layerData = layerData;
+		this.label = layerData.name;
+		this.alpha = layerData.opacity;
+		this.visible = layerData.visible;
+		this.layerBaseOffsetX = layerData.offsetx;
+		this.layerBaseOffsetY = layerData.offsety;
+		this.layerParallaxX = layerData.parallaxx;
+		this.layerParallaxY = layerData.parallaxy;
+		this.position.set(layerData.offsetx, layerData.offsety);
+		if (layerData.tintcolor) this.tint = parseTintColor(layerData.tintcolor);
+		for (const child of layerData.layers) {
+			const renderer = createLayerRenderer(child, tilesets, ctx, imageTextures);
+			if (renderer) this.addChild(renderer);
+		}
+	}
 };
-
-// src/renderer/tilePlacement.ts
+//#endregion
+//#region src/renderer/ImageLayerRenderer.ts
+var ImageLayerRenderer = class extends pixi_js.Container {
+	constructor(layerData, texture, ctx) {
+		super();
+		this.layerData = layerData;
+		this.label = layerData.name;
+		this.alpha = layerData.opacity;
+		this.visible = layerData.visible;
+		this.layerBaseOffsetX = layerData.offsetx;
+		this.layerBaseOffsetY = layerData.offsety;
+		this.layerParallaxX = layerData.parallaxx;
+		this.layerParallaxY = layerData.parallaxy;
+		this.position.set(layerData.offsetx, layerData.offsety);
+		if (layerData.tintcolor) this.tint = parseTintColor(layerData.tintcolor);
+		if (texture) this._buildImage(texture, ctx);
+	}
+	_buildImage(texture, ctx) {
+		const { repeatx, repeaty } = this.layerData;
+		if (!repeatx && !repeaty) {
+			this.addChild(new pixi_js.Sprite(texture));
+			return;
+		}
+		const spanW = ctx?.mapPixelWidth && ctx.mapPixelWidth > 0 ? ctx.mapPixelWidth : texture.width;
+		const spanH = ctx?.mapPixelHeight && ctx.mapPixelHeight > 0 ? ctx.mapPixelHeight : texture.height;
+		this.addChild(new pixi_js.TilingSprite({
+			texture,
+			width: repeatx ? spanW : texture.width,
+			height: repeaty ? spanH : texture.height
+		}));
+	}
+};
+//#endregion
+//#region src/renderer/ObjectLayerRenderer.ts
+var ObjectLayerRenderer = class extends pixi_js.Container {
+	constructor(layerData, tilesets) {
+		super();
+		this.layerData = layerData;
+		this.label = layerData.name;
+		this.alpha = layerData.opacity;
+		this.visible = layerData.visible;
+		this.layerBaseOffsetX = layerData.offsetx;
+		this.layerBaseOffsetY = layerData.offsety;
+		this.layerParallaxX = layerData.parallaxx;
+		this.layerParallaxY = layerData.parallaxy;
+		this.position.set(layerData.offsetx, layerData.offsety);
+		if (layerData.tintcolor) this.tint = parseTintColor(layerData.tintcolor);
+		this._buildObjects(tilesets);
+	}
+	_buildObjects(tilesets) {
+		for (const obj of this.layerData.objects) {
+			const child = this._createObject(obj, tilesets);
+			if (child) {
+				child.label = obj.name || `object_${obj.id}`;
+				this.addChild(child);
+			}
+		}
+	}
+	_createObject(obj, tilesets) {
+		if (obj.gid !== void 0) return this._createTileObject(obj, tilesets);
+		if (obj.text) return this._createTextObject(obj);
+		if (obj.ellipse) return this._createEllipse(obj);
+		if (obj.point) return this._createPoint(obj);
+		if (obj.polygon) return this._createPolygon(obj, obj.polygon, true);
+		if (obj.polyline) return this._createPolygon(obj, obj.polyline, false);
+		if (obj.width > 0 && obj.height > 0) return this._createRectangle(obj);
+		return null;
+	}
+	_createTileObject(obj, tilesets) {
+		if (obj.gid === void 0) return null;
+		const decoded = decodeGid(obj.gid);
+		if (!decoded) return null;
+		const ts = findRendererForGid(tilesets, decoded.gid);
+		if (!ts) return null;
+		const localId = decoded.gid - ts.tileset.firstgid;
+		const texture = ts.getTexture(localId);
+		if (!texture) return null;
+		const sprite = new pixi_js.Sprite(texture);
+		const offset = ts.tileset.tileoffset;
+		const sized = this._fitTileSize(ts, localId, obj.width, obj.height);
+		sprite.width = sized.width;
+		sprite.height = sized.height;
+		sprite.position.set(obj.x + offset.x, obj.y - sized.height + offset.y);
+		sprite.angle = obj.rotation;
+		sprite.visible = obj.visible;
+		if (decoded.horizontalFlip) {
+			sprite.scale.x *= -1;
+			sprite.anchor.x = 1;
+		}
+		if (decoded.verticalFlip) {
+			sprite.scale.y *= -1;
+			sprite.anchor.y = 1;
+		}
+		return sprite;
+	}
+	_fitTileSize(ts, localId, objWidth, objHeight) {
+		if (objWidth <= 0 || objHeight <= 0) return ts.getTileSize(localId);
+		if (ts.tileset.fillmode !== "preserve-aspect-fit") return {
+			width: objWidth,
+			height: objHeight
+		};
+		const intrinsic = ts.getTileSize(localId);
+		if (intrinsic.width === 0 || intrinsic.height === 0) return {
+			width: objWidth,
+			height: objHeight
+		};
+		const scale = Math.min(objWidth / intrinsic.width, objHeight / intrinsic.height);
+		return {
+			width: intrinsic.width * scale,
+			height: intrinsic.height * scale
+		};
+	}
+	_createTextObject(obj) {
+		const td = obj.text;
+		const color = td.color ?? "#000000";
+		const text = new pixi_js.Text({
+			text: td.text,
+			style: {
+				fontFamily: td.fontfamily ?? "sans-serif",
+				fontSize: td.pixelsize ?? 16,
+				fill: color,
+				fontWeight: td.bold ? "bold" : "normal",
+				fontStyle: td.italic ? "italic" : "normal",
+				wordWrap: td.wrap ?? false,
+				wordWrapWidth: obj.width,
+				align: td.halign ?? "left"
+			}
+		});
+		if (!td.underline && !td.strikeout) {
+			text.position.set(obj.x, obj.y);
+			text.angle = obj.rotation;
+			text.visible = obj.visible;
+			return text;
+		}
+		const container = new pixi_js.Container();
+		container.addChild(text);
+		const metrics = text.getSize();
+		const lineThickness = Math.max(1, (td.pixelsize ?? 16) / 16);
+		if (td.underline) {
+			const ul = new pixi_js.Graphics().moveTo(0, metrics.height - lineThickness).lineTo(metrics.width, metrics.height - lineThickness).stroke({
+				color,
+				width: lineThickness
+			});
+			container.addChild(ul);
+		}
+		if (td.strikeout) {
+			const y = metrics.height / 2;
+			const so = new pixi_js.Graphics().moveTo(0, y).lineTo(metrics.width, y).stroke({
+				color,
+				width: lineThickness
+			});
+			container.addChild(so);
+		}
+		container.position.set(obj.x, obj.y);
+		container.angle = obj.rotation;
+		container.visible = obj.visible;
+		return container;
+	}
+	_createRectangle(obj) {
+		const g = new pixi_js.Graphics().rect(0, 0, obj.width, obj.height).stroke({
+			color: 16777215,
+			width: 1
+		});
+		g.position.set(obj.x, obj.y);
+		g.angle = obj.rotation;
+		g.visible = obj.visible;
+		return g;
+	}
+	_createEllipse(obj) {
+		const rx = obj.width / 2;
+		const ry = obj.height / 2;
+		const g = new pixi_js.Graphics().ellipse(rx, ry, rx, ry).stroke({
+			color: 16777215,
+			width: 1
+		});
+		g.position.set(obj.x, obj.y);
+		g.angle = obj.rotation;
+		g.visible = obj.visible;
+		return g;
+	}
+	_createPoint(obj) {
+		const g = new pixi_js.Graphics().circle(0, 0, 3).fill(16777215);
+		g.position.set(obj.x, obj.y);
+		g.visible = obj.visible;
+		return g;
+	}
+	_createPolygon(obj, points, closed) {
+		const g = new pixi_js.Graphics();
+		if (points.length > 0) {
+			const first = points[0];
+			g.moveTo(first.x, first.y);
+			for (let i = 1; i < points.length; i++) {
+				const pt = points[i];
+				g.lineTo(pt.x, pt.y);
+			}
+			if (closed) g.closePath();
+			g.stroke({
+				color: 16777215,
+				width: 1
+			});
+		}
+		g.position.set(obj.x, obj.y);
+		g.angle = obj.rotation;
+		g.visible = obj.visible;
+		return g;
+	}
+};
+function findRendererForGid(tilesets, gid) {
+	for (let i = tilesets.length - 1; i >= 0; i--) {
+		const ts = tilesets[i];
+		if (ts && ts.tileset.firstgid <= gid) return ts;
+	}
+	return null;
+}
+//#endregion
+//#region src/renderer/tilePlacement.ts
 function tileToPixel(col, row, ctx) {
-  switch (ctx.orientation) {
-    case "orthogonal":
-      return orthogonalToPixel(col, row, ctx);
-    case "isometric":
-      return isometricToPixel(col, row, ctx);
-    case "staggered":
-      return staggeredToPixel(col, row, ctx);
-    case "hexagonal":
-      return hexagonalToPixel(col, row, ctx);
-  }
+	switch (ctx.orientation) {
+		case "orthogonal": return orthogonalToPixel(col, row, ctx);
+		case "isometric": return isometricToPixel(col, row, ctx);
+		case "staggered": return staggeredToPixel(col, row, ctx);
+		case "hexagonal": return hexagonalToPixel(col, row, ctx);
+	}
 }
 function orthogonalToPixel(col, row, ctx) {
-  return {
-    x: col * ctx.tilewidth,
-    y: row * ctx.tileheight
-  };
+	return {
+		x: col * ctx.tilewidth,
+		y: row * ctx.tileheight
+	};
 }
 function isometricToPixel(col, row, ctx) {
-  const halfW = ctx.tilewidth / 2;
-  const halfH = ctx.tileheight / 2;
-  return {
-    x: (col - row) * halfW,
-    y: (col + row) * halfH
-  };
+	const halfW = ctx.tilewidth / 2;
+	const halfH = ctx.tileheight / 2;
+	return {
+		x: (col - row) * halfW,
+		y: (col + row) * halfH
+	};
 }
 function staggeredToPixel(col, row, ctx) {
-  const staggerX = ctx.staggeraxis === "x";
-  const staggerEven = ctx.staggerindex === "even";
-  if (staggerX) {
-    const isStaggered2 = staggerEven ? col % 2 === 0 : col % 2 !== 0;
-    return {
-      x: col * (ctx.tilewidth / 2),
-      y: row * ctx.tileheight + (isStaggered2 ? ctx.tileheight / 2 : 0)
-    };
-  }
-  const isStaggered = staggerEven ? row % 2 === 0 : row % 2 !== 0;
-  return {
-    x: col * ctx.tilewidth + (isStaggered ? ctx.tilewidth / 2 : 0),
-    y: row * (ctx.tileheight / 2)
-  };
+	const staggerX = ctx.staggeraxis === "x";
+	const staggerEven = ctx.staggerindex === "even";
+	if (staggerX) {
+		const isStaggered = staggerEven ? col % 2 === 0 : col % 2 !== 0;
+		return {
+			x: col * (ctx.tilewidth / 2),
+			y: row * ctx.tileheight + (isStaggered ? ctx.tileheight / 2 : 0)
+		};
+	}
+	const isStaggered = staggerEven ? row % 2 === 0 : row % 2 !== 0;
+	return {
+		x: col * ctx.tilewidth + (isStaggered ? ctx.tilewidth / 2 : 0),
+		y: row * (ctx.tileheight / 2)
+	};
 }
 function hexagonalToPixel(col, row, ctx) {
-  const hexSide = ctx.hexsidelength ?? 0;
-  const staggerX = ctx.staggeraxis === "x";
-  const staggerEven = ctx.staggerindex === "even";
-  if (staggerX) {
-    const colWidth = (ctx.tilewidth + hexSide) / 2;
-    const isStaggered2 = staggerEven ? col % 2 === 0 : col % 2 !== 0;
-    return {
-      x: col * colWidth,
-      y: row * ctx.tileheight + (isStaggered2 ? ctx.tileheight / 2 : 0)
-    };
-  }
-  const rowHeight = (ctx.tileheight + hexSide) / 2;
-  const isStaggered = staggerEven ? row % 2 === 0 : row % 2 !== 0;
-  return {
-    x: col * ctx.tilewidth + (isStaggered ? ctx.tilewidth / 2 : 0),
-    y: row * rowHeight
-  };
-}
-
-// src/renderer/parseColor.ts
-function parseTintColor(hex) {
-  const clean = hex.replace("#", "");
-  if (clean.length === 8) {
-    return parseInt(clean.slice(2), 16);
-  }
-  return parseInt(clean, 16);
-}
-
-// src/renderer/TileLayerRenderer.ts
+	const hexSide = ctx.hexsidelength ?? 0;
+	const staggerX = ctx.staggeraxis === "x";
+	const staggerEven = ctx.staggerindex === "even";
+	if (staggerX) {
+		const colWidth = (ctx.tilewidth + hexSide) / 2;
+		const isStaggered = staggerEven ? col % 2 === 0 : col % 2 !== 0;
+		return {
+			x: col * colWidth,
+			y: row * ctx.tileheight + (isStaggered ? ctx.tileheight / 2 : 0)
+		};
+	}
+	const rowHeight = (ctx.tileheight + hexSide) / 2;
+	const isStaggered = staggerEven ? row % 2 === 0 : row % 2 !== 0;
+	return {
+		x: col * ctx.tilewidth + (isStaggered ? ctx.tilewidth / 2 : 0),
+		y: row * rowHeight
+	};
+}
+//#endregion
+//#region src/renderer/TileLayerRenderer.ts
 var TileLayerRenderer = class extends pixi_js.Container {
-  constructor(layerData, tilesets, ctx) {
-    super();
-    this.layerData = layerData;
-    this.label = layerData.name;
-    this.alpha = layerData.opacity;
-    this.visible = layerData.visible;
-    this.position.set(layerData.offsetx, layerData.offsety);
-    if (layerData.tintcolor) {
-      this.tint = parseTintColor(layerData.tintcolor);
-    }
-    if (layerData.infinite && layerData.chunks) {
-      this._buildChunks(layerData.chunks, tilesets, ctx);
-    } else {
-      this._buildTiles(
-        layerData.tiles,
-        layerData.width,
-        Math.floor(layerData.tiles.length / (layerData.width || 1)),
-        0,
-        0,
-        tilesets,
-        ctx
-      );
-    }
-  }
-  _buildChunks(chunks, tilesets, ctx) {
-    for (const chunk of chunks) {
-      this._buildTiles(chunk.tiles, chunk.width, chunk.height, chunk.x, chunk.y, tilesets, ctx);
-    }
-  }
-  _buildTiles(tiles, layerWidth, layerHeight, originCol, originRow, tilesets, ctx) {
-    const order = ctx.renderorder;
-    for (const [col, row] of iterateTiles(layerWidth, layerHeight, order)) {
-      const i = row * layerWidth + col;
-      const tile = tiles[i];
-      if (!tile) continue;
-      const tsRenderer = tilesets[tile.tilesetIndex];
-      if (!tsRenderer) continue;
-      const pos = tileToPixel(originCol + col, originRow + row, ctx);
-      const animFrames = tsRenderer.getAnimationFrames(tile.localId);
-      if (animFrames && animFrames.length > 1) {
-        const sprite = this._createAnimatedTile(tsRenderer, animFrames, tile, pos.x, pos.y);
-        if (sprite) this.addChild(sprite);
-      } else {
-        const texture = tsRenderer.getTexture(tile.localId);
-        if (!texture) continue;
-        const sprite = new pixi_js.Sprite(texture);
-        sprite.position.set(pos.x, pos.y);
-        applyFlip(sprite, tile, ctx.tilewidth);
-        this.addChild(sprite);
-      }
-    }
-  }
-  _createAnimatedTile(tsRenderer, frames, tile, x, y) {
-    const textures = [];
-    for (const frame of frames) {
-      const tex = tsRenderer.getTexture(frame.tileid);
-      if (!tex) return null;
-      textures.push({ texture: tex, time: frame.duration });
-    }
-    const sprite = new pixi_js.AnimatedSprite(textures);
-    sprite.position.set(x, y);
-    sprite.play();
-    applyFlip(sprite, tile, tsRenderer.tileset.tilewidth);
-    return sprite;
-  }
+	constructor(layerData, tilesets, ctx) {
+		super();
+		this.layerData = layerData;
+		this.label = layerData.name;
+		this.alpha = layerData.opacity;
+		this.visible = layerData.visible;
+		this.layerBaseOffsetX = layerData.offsetx;
+		this.layerBaseOffsetY = layerData.offsety;
+		this.layerParallaxX = layerData.parallaxx;
+		this.layerParallaxY = layerData.parallaxy;
+		this.position.set(layerData.offsetx, layerData.offsety);
+		if (layerData.tintcolor) this.tint = parseTintColor(layerData.tintcolor);
+		if (layerData.infinite && layerData.chunks) this._buildChunks(layerData.chunks, tilesets, ctx);
+		else this._buildTiles(layerData.tiles, layerData.width, Math.floor(layerData.tiles.length / (layerData.width || 1)), 0, 0, tilesets, ctx);
+	}
+	_buildChunks(chunks, tilesets, ctx) {
+		for (const chunk of chunks) this._buildTiles(chunk.tiles, chunk.width, chunk.height, chunk.x, chunk.y, tilesets, ctx);
+	}
+	_buildTiles(tiles, layerWidth, layerHeight, originCol, originRow, tilesets, ctx) {
+		const order = ctx.renderorder;
+		for (const [col, row] of iterateTiles(layerWidth, layerHeight, order)) {
+			const tile = tiles[row * layerWidth + col];
+			if (!tile) continue;
+			const tsRenderer = tilesets[tile.tilesetIndex];
+			if (!tsRenderer) continue;
+			const pos = tileToPixel(originCol + col, originRow + row, ctx);
+			const animFrames = tsRenderer.getAnimationFrames(tile.localId);
+			const offset = tsRenderer.tileset.tileoffset;
+			if (animFrames && animFrames.length > 1) {
+				const sprite = this._createAnimatedTile(tsRenderer, animFrames, tile, pos.x, pos.y, ctx);
+				if (sprite) {
+					sprite.position.x += offset.x;
+					sprite.position.y += offset.y;
+					this.addChild(sprite);
+				}
+			} else {
+				const texture = tsRenderer.getTexture(tile.localId);
+				if (!texture) continue;
+				const sprite = new pixi_js.Sprite(texture);
+				const renderSize = tsRenderer.getRenderSize(tile.localId, ctx);
+				sprite.width = renderSize.width;
+				sprite.height = renderSize.height;
+				sprite.position.set(pos.x + offset.x, pos.y + offset.y + ctx.tileheight - renderSize.height);
+				applyFlip(sprite, tile, renderSize.width);
+				this.addChild(sprite);
+			}
+		}
+	}
+	_createAnimatedTile(tsRenderer, frames, tile, x, y, ctx) {
+		const textures = [];
+		for (const frame of frames) {
+			const tex = tsRenderer.getTexture(frame.tileid);
+			if (!tex) return null;
+			textures.push({
+				texture: tex,
+				time: frame.duration
+			});
+		}
+		const sprite = new pixi_js.AnimatedSprite(textures);
+		const renderSize = tsRenderer.getRenderSize(tile.localId, ctx);
+		sprite.width = renderSize.width;
+		sprite.height = renderSize.height;
+		sprite.position.set(x, y + ctx.tileheight - renderSize.height);
+		sprite.play();
+		applyFlip(sprite, tile, renderSize.width);
+		return sprite;
+	}
 };
 function* iterateTiles(width, height, order) {
-  const rightToLeft = order === "left-down" || order === "left-up";
-  const bottomToTop = order === "right-up" || order === "left-up";
-  const rowStart = bottomToTop ? height - 1 : 0;
-  const rowEnd = bottomToTop ? -1 : height;
-  const rowStep = bottomToTop ? -1 : 1;
-  const colStart = rightToLeft ? width - 1 : 0;
-  const colEnd = rightToLeft ? -1 : width;
-  const colStep = rightToLeft ? -1 : 1;
-  for (let row = rowStart; row !== rowEnd; row += rowStep) {
-    for (let col = colStart; col !== colEnd; col += colStep) {
-      yield [col, row];
-    }
-  }
+	const rightToLeft = order === "left-down" || order === "left-up";
+	const bottomToTop = order === "right-up" || order === "left-up";
+	const rowStart = bottomToTop ? height - 1 : 0;
+	const rowEnd = bottomToTop ? -1 : height;
+	const rowStep = bottomToTop ? -1 : 1;
+	const colStart = rightToLeft ? width - 1 : 0;
+	const colEnd = rightToLeft ? -1 : width;
+	const colStep = rightToLeft ? -1 : 1;
+	for (let row = rowStart; row !== rowEnd; row += rowStep) for (let col = colStart; col !== colEnd; col += colStep) yield [col, row];
 }
 function applyFlip(sprite, tile, tileWidth) {
-  if (tile.diagonalFlip) {
-    sprite.rotation = Math.PI / 2;
-    sprite.scale.x = tile.horizontalFlip ? -1 : 1;
-    sprite.scale.y = tile.verticalFlip ? -1 : 1;
-    sprite.anchor.set(0, 1);
-    sprite.position.x += tileWidth;
-  } else {
-    if (tile.horizontalFlip) {
-      sprite.scale.x = -1;
-      sprite.anchor.x = 1;
-    }
-    if (tile.verticalFlip) {
-      sprite.scale.y = -1;
-      sprite.anchor.y = 1;
-    }
-  }
-}
-var ImageLayerRenderer = class extends pixi_js.Container {
-  constructor(layerData, texture) {
-    super();
-    this.layerData = layerData;
-    this.label = layerData.name;
-    this.alpha = layerData.opacity;
-    this.visible = layerData.visible;
-    this.position.set(layerData.offsetx, layerData.offsety);
-    if (layerData.tintcolor) {
-      this.tint = parseTintColor(layerData.tintcolor);
-    }
-    if (texture) {
-      this._buildImage(texture);
-    }
-  }
-  _buildImage(texture) {
-    const { repeatx, repeaty } = this.layerData;
-    if (repeatx || repeaty) {
-      const tiling = new pixi_js.TilingSprite({
-        texture,
-        width: repeatx ? texture.width * 10 : texture.width,
-        height: repeaty ? texture.height * 10 : texture.height
-      });
-      this.addChild(tiling);
-    } else {
-      const sprite = new pixi_js.Sprite(texture);
-      this.addChild(sprite);
-    }
-  }
-};
-var ObjectLayerRenderer = class extends pixi_js.Container {
-  constructor(layerData, tilesets) {
-    super();
-    this.layerData = layerData;
-    this.label = layerData.name;
-    this.alpha = layerData.opacity;
-    this.visible = layerData.visible;
-    this.position.set(layerData.offsetx, layerData.offsety);
-    if (layerData.tintcolor) {
-      this.tint = parseTintColor(layerData.tintcolor);
-    }
-    this._buildObjects(tilesets);
-  }
-  _buildObjects(tilesets) {
-    for (const obj of this.layerData.objects) {
-      const child2 = this._createObject(obj, tilesets);
-      if (child2) {
-        child2.label = obj.name || `object_${obj.id}`;
-        this.addChild(child2);
-      }
-    }
-  }
-  _createObject(obj, tilesets) {
-    if (obj.gid !== void 0) {
-      return this._createTileObject(obj, tilesets);
-    }
-    if (obj.text) {
-      return this._createTextObject(obj);
-    }
-    if (obj.ellipse) {
-      return this._createEllipse(obj);
-    }
-    if (obj.point) {
-      return this._createPoint(obj);
-    }
-    if (obj.polygon) {
-      return this._createPolygon(obj, obj.polygon, true);
-    }
-    if (obj.polyline) {
-      return this._createPolygon(obj, obj.polyline, false);
-    }
-    if (obj.width > 0 && obj.height > 0) {
-      return this._createRectangle(obj);
-    }
-    return null;
-  }
-  _createTileObject(obj, tilesets) {
-    if (obj.gid === void 0) return null;
-    const decoded = decodeGid(obj.gid);
-    if (!decoded) return null;
-    for (let i = tilesets.length - 1; i >= 0; i--) {
-      const ts = tilesets[i];
-      if (!ts) continue;
-      if (ts.tileset.firstgid <= decoded.gid) {
-        const localId = decoded.gid - ts.tileset.firstgid;
-        const texture = ts.getTexture(localId);
-        if (!texture) return null;
-        const sprite = new pixi_js.Sprite(texture);
-        sprite.position.set(obj.x, obj.y - obj.height);
-        sprite.width = obj.width;
-        sprite.height = obj.height;
-        sprite.angle = obj.rotation;
-        sprite.visible = obj.visible;
-        if (decoded.horizontalFlip) {
-          sprite.scale.x *= -1;
-          sprite.anchor.x = 1;
-        }
-        if (decoded.verticalFlip) {
-          sprite.scale.y *= -1;
-          sprite.anchor.y = 1;
-        }
-        return sprite;
-      }
-    }
-    return null;
-  }
-  _createTextObject(obj) {
-    const td = obj.text;
-    const text = new pixi_js.Text({
-      text: td.text,
-      style: {
-        fontFamily: td.fontfamily ?? "sans-serif",
-        fontSize: td.pixelsize ?? 16,
-        fill: td.color ?? "#000000",
-        fontWeight: td.bold ? "bold" : "normal",
-        fontStyle: td.italic ? "italic" : "normal",
-        wordWrap: td.wrap ?? false,
-        wordWrapWidth: obj.width,
-        align: td.halign ?? "left"
-      }
-    });
-    text.position.set(obj.x, obj.y);
-    text.angle = obj.rotation;
-    text.visible = obj.visible;
-    return text;
-  }
-  _createRectangle(obj) {
-    const g = new pixi_js.Graphics().rect(0, 0, obj.width, obj.height).stroke({ color: 16777215, width: 1 });
-    g.position.set(obj.x, obj.y);
-    g.angle = obj.rotation;
-    g.visible = obj.visible;
-    return g;
-  }
-  _createEllipse(obj) {
-    const rx = obj.width / 2;
-    const ry = obj.height / 2;
-    const g = new pixi_js.Graphics().ellipse(rx, ry, rx, ry).stroke({ color: 16777215, width: 1 });
-    g.position.set(obj.x, obj.y);
-    g.angle = obj.rotation;
-    g.visible = obj.visible;
-    return g;
-  }
-  _createPoint(obj) {
-    const g = new pixi_js.Graphics().circle(0, 0, 3).fill(16777215);
-    g.position.set(obj.x, obj.y);
-    g.visible = obj.visible;
-    return g;
-  }
-  _createPolygon(obj, points, closed) {
-    const g = new pixi_js.Graphics();
-    if (points.length > 0) {
-      const first = points[0];
-      g.moveTo(first.x, first.y);
-      for (let i = 1; i < points.length; i++) {
-        const pt = points[i];
-        g.lineTo(pt.x, pt.y);
-      }
-      if (closed) {
-        g.closePath();
-      }
-      g.stroke({ color: 16777215, width: 1 });
-    }
-    g.position.set(obj.x, obj.y);
-    g.angle = obj.rotation;
-    g.visible = obj.visible;
-    return g;
-  }
-};
-var GroupLayerRenderer = class extends pixi_js.Container {
-  constructor(layerData, tilesets, ctx, imageTextures) {
-    super();
-    this.layerData = layerData;
-    this.label = layerData.name;
-    this.alpha = layerData.opacity;
-    this.visible = layerData.visible;
-    this.position.set(layerData.offsetx, layerData.offsety);
-    if (layerData.tintcolor) {
-      this.tint = parseTintColor(layerData.tintcolor);
-    }
-    for (const child2 of layerData.layers) {
-      const renderer = createLayerRenderer(child2, tilesets, ctx, imageTextures);
-      if (renderer) this.addChild(renderer);
-    }
-  }
-};
-
-// src/renderer/createLayerRenderer.ts
+	if (tile.diagonalFlip) {
+		sprite.rotation = Math.PI / 2;
+		sprite.scale.x = tile.horizontalFlip ? -1 : 1;
+		sprite.scale.y = tile.verticalFlip ? -1 : 1;
+		sprite.anchor.set(0, 1);
+		sprite.position.x += tileWidth;
+	} else {
+		if (tile.horizontalFlip) {
+			sprite.scale.x = -1;
+			sprite.anchor.x = 1;
+		}
+		if (tile.verticalFlip) {
+			sprite.scale.y = -1;
+			sprite.anchor.y = 1;
+		}
+	}
+}
+//#endregion
+//#region src/renderer/createLayerRenderer.ts
 function createLayerRenderer(layer, tilesets, ctx, imageTextures) {
-  switch (layer.type) {
-    case "tilelayer":
-      return new TileLayerRenderer(layer, tilesets, ctx);
-    case "imagelayer": {
-      const tex = layer.image ? imageTextures.get(layer.image) ?? null : null;
-      return new ImageLayerRenderer(layer, tex);
-    }
-    case "objectgroup":
-      return new ObjectLayerRenderer(layer, tilesets);
-    case "group":
-      return new GroupLayerRenderer(layer, tilesets, ctx, imageTextures);
-  }
+	switch (layer.type) {
+		case "tilelayer": return new TileLayerRenderer(layer, tilesets, ctx);
+		case "imagelayer": return new ImageLayerRenderer(layer, layer.image ? imageTextures.get(layer.image) ?? null : null, ctx);
+		case "objectgroup": return new ObjectLayerRenderer(layer, tilesets);
+		case "group": return new GroupLayerRenderer(layer, tilesets, ctx, imageTextures);
+	}
+}
+//#endregion
+//#region src/renderer/mapSize.ts
+function computeMapPixelSize(mapData) {
+	const { orientation, width, height, tilewidth, tileheight, staggeraxis } = mapData;
+	switch (orientation) {
+		case "isometric": return {
+			width: (width + height) * (tilewidth / 2),
+			height: (width + height) * (tileheight / 2)
+		};
+		case "staggered":
+		case "hexagonal": return staggeraxis === "x" ? {
+			width: (width + 1) * (tilewidth / 2),
+			height: height * tileheight + tileheight / 2
+		} : {
+			width: width * tilewidth + tilewidth / 2,
+			height: (height + 1) * (tileheight / 2)
+		};
+		default: return {
+			width: width * tilewidth,
+			height: height * tileheight
+		};
+	}
+}
+//#endregion
+//#region src/renderer/TileSetRenderer.ts
+var TileSetRenderer = class {
+	constructor(tileset, baseTexture) {
+		this._ownedTextures = /* @__PURE__ */ new Map();
+		this._externalTextures = /* @__PURE__ */ new Map();
+		this.tileset = tileset;
+		this.baseTexture = baseTexture;
+	}
+	getTexture(localId) {
+		const external = this._externalTextures.get(localId);
+		if (external) return external;
+		const owned = this._ownedTextures.get(localId);
+		if (owned) return owned;
+		if (this.tileset.tiles.get(localId)?.image) return null;
+		if (!this.baseTexture) return null;
+		const { tilewidth, tileheight, columns, margin, spacing } = this.tileset;
+		if (columns <= 0) return null;
+		const col = localId % columns;
+		const row = Math.floor(localId / columns);
+		const frame = new pixi_js.Rectangle(margin + col * (tilewidth + spacing), margin + row * (tileheight + spacing), tilewidth, tileheight);
+		const texture = new pixi_js.Texture({
+			source: this.baseTexture.source,
+			frame
+		});
+		this._ownedTextures.set(localId, texture);
+		return texture;
+	}
+	setTileTexture(localId, texture) {
+		this._externalTextures.set(localId, texture);
+	}
+	getAnimationFrames(localId) {
+		return this.tileset.tiles.get(localId)?.animation;
+	}
+	/**
+	* Returns the intrinsic pixel size of a tile based on tileset metadata.
+	* For image-collection tilesets, each tile has its own image dimensions.
+	* For regular tilesets, all tiles share the tileset's tilewidth/tileheight.
+	*
+	* This does not read from the pixi Texture, so it is safe to call before
+	* textures have finished loading.
+	*/
+	getTileSize(localId) {
+		const tileDef = this.tileset.tiles.get(localId);
+		if (tileDef?.image) return {
+			width: tileDef.imagewidth ?? this.tileset.tilewidth,
+			height: tileDef.imageheight ?? this.tileset.tileheight
+		};
+		return {
+			width: this.tileset.tilewidth,
+			height: this.tileset.tileheight
+		};
+	}
+	/**
+	* Returns the pixel size a tile should be drawn at on the map grid.
+	* When `tilerendersize === 'grid'`, the tile is resized to the map cell
+	* size, honouring `fillmode` for non-stretch aspect handling.
+	* Otherwise the tile's intrinsic size is used.
+	*/
+	getRenderSize(localId, ctx) {
+		const intrinsic = this.getTileSize(localId);
+		if (this.tileset.tilerendersize !== "grid") return intrinsic;
+		const gridW = ctx.tilewidth;
+		const gridH = ctx.tileheight;
+		if (this.tileset.fillmode === "preserve-aspect-fit") {
+			if (intrinsic.width === 0 || intrinsic.height === 0) return {
+				width: gridW,
+				height: gridH
+			};
+			const scale = Math.min(gridW / intrinsic.width, gridH / intrinsic.height);
+			return {
+				width: intrinsic.width * scale,
+				height: intrinsic.height * scale
+			};
+		}
+		return {
+			width: gridW,
+			height: gridH
+		};
+	}
+	destroy() {
+		for (const tex of this._ownedTextures.values()) tex.destroy();
+		this._ownedTextures.clear();
+		this._externalTextures.clear();
+	}
+};
+//#endregion
+//#region src/renderer/TiledMap.ts
+function isParallaxLayer(c) {
+	return c instanceof TileLayerRenderer || c instanceof ImageLayerRenderer || c instanceof ObjectLayerRenderer || c instanceof GroupLayerRenderer;
 }
-
-// src/renderer/TiledMap.ts
 var TiledMap = class extends pixi_js.Container {
-  constructor(mapData, options) {
-    super();
-    this._background = null;
-    this.mapData = mapData;
-    this.label = "TiledMap";
-    const tilesetTextures = options?.tilesetTextures ?? /* @__PURE__ */ new Map();
-    const imageLayerTextures = options?.imageLayerTextures ?? /* @__PURE__ */ new Map();
-    const tileImageTextures = options?.tileImageTextures ?? /* @__PURE__ */ new Map();
-    this.tileSetRenderers = mapData.tilesets.map((ts) => {
-      const baseTex = ts.image ? tilesetTextures.get(ts.image) ?? null : null;
-      const renderer = new TileSetRenderer(ts, baseTex);
-      for (const [localId, tileDef] of ts.tiles) {
-        if (tileDef.image) {
-          const tex = tileImageTextures.get(tileDef.image);
-          if (tex) renderer.setTileTexture(localId, tex);
-        }
-      }
-      return renderer;
-    });
-    const ctx = {
-      orientation: mapData.orientation,
-      renderorder: mapData.renderorder,
-      tilewidth: mapData.tilewidth,
-      tileheight: mapData.tileheight,
-      hexsidelength: mapData.hexsidelength,
-      staggeraxis: mapData.staggeraxis,
-      staggerindex: mapData.staggerindex
-    };
-    if (mapData.backgroundcolor) {
-      this._buildBackground(mapData);
-    }
-    for (const layer of mapData.layers) {
-      const child2 = createLayerRenderer(layer, this.tileSetRenderers, ctx, imageLayerTextures);
-      if (child2) this.addChild(child2);
-    }
-  }
-  get orientation() {
-    return this.mapData.orientation;
-  }
-  get mapWidth() {
-    return this.mapData.width;
-  }
-  get mapHeight() {
-    return this.mapData.height;
-  }
-  get tileWidth() {
-    return this.mapData.tilewidth;
-  }
-  get tileHeight() {
-    return this.mapData.tileheight;
-  }
-  getLayer(name) {
-    return this.children.find((c) => c.label === name);
-  }
-  _buildBackground(mapData) {
-    const color = parseTintColor(mapData.backgroundcolor);
-    const pixelWidth = mapData.width * mapData.tilewidth;
-    const pixelHeight = mapData.height * mapData.tileheight;
-    this._background = new pixi_js.Graphics().rect(0, 0, pixelWidth, pixelHeight).fill(color);
-    this._background.label = "background";
-    this.addChild(this._background);
-  }
-  destroy(options) {
-    for (const ts of this.tileSetRenderers) {
-      ts.destroy();
-    }
-    super.destroy(options);
-  }
+	constructor(mapData, options) {
+		super();
+		this._background = null;
+		this.mapData = mapData;
+		this.label = "TiledMap";
+		const pixelSize = computeMapPixelSize(mapData);
+		this.boundsArea = new pixi_js.Rectangle(0, 0, pixelSize.width, pixelSize.height);
+		const tilesetTextures = options?.tilesetTextures ?? /* @__PURE__ */ new Map();
+		const imageLayerTextures = options?.imageLayerTextures ?? /* @__PURE__ */ new Map();
+		const tileImageTextures = options?.tileImageTextures ?? /* @__PURE__ */ new Map();
+		this.tileSetRenderers = mapData.tilesets.map((ts) => {
+			const renderer = new TileSetRenderer(ts, ts.image ? tilesetTextures.get(ts.image) ?? null : null);
+			for (const [localId, tileDef] of ts.tiles) if (tileDef.image) {
+				const tex = tileImageTextures.get(tileDef.image);
+				if (tex) renderer.setTileTexture(localId, tex);
+			}
+			return renderer;
+		});
+		const ctx = {
+			orientation: mapData.orientation,
+			renderorder: mapData.renderorder,
+			tilewidth: mapData.tilewidth,
+			tileheight: mapData.tileheight,
+			hexsidelength: mapData.hexsidelength,
+			staggeraxis: mapData.staggeraxis,
+			staggerindex: mapData.staggerindex,
+			mapPixelWidth: pixelSize.width,
+			mapPixelHeight: pixelSize.height
+		};
+		if (mapData.backgroundcolor) this._buildBackground(pixelSize.width, pixelSize.height, mapData.backgroundcolor);
+		for (const layer of mapData.layers) {
+			const child = createLayerRenderer(layer, this.tileSetRenderers, ctx, imageLayerTextures);
+			if (child) this.addChild(child);
+		}
+	}
+	get orientation() {
+		return this.mapData.orientation;
+	}
+	get mapWidth() {
+		return this.mapData.width;
+	}
+	get mapHeight() {
+		return this.mapData.height;
+	}
+	get tileWidth() {
+		return this.mapData.tilewidth;
+	}
+	get tileHeight() {
+		return this.mapData.tileheight;
+	}
+	getLayer(name) {
+		return this.children.find((c) => c.label === name);
+	}
+	/**
+	* Reposition layers to reflect the camera's current position through the
+	* map's parallax factors. Call after moving the camera.
+	*
+	* Effective layer screen position (after your camera transform) is:
+	*   base_offset - parallax_origin * (1 - parallax) - camera * parallax
+	*
+	* so a layer with parallax 1 moves normally with the camera and a layer
+	* with parallax 0 is pinned in screen space. Nested group layers compose
+	* parallax multiplicatively per the Tiled spec.
+	*/
+	applyParallax(cameraX, cameraY) {
+		const ox = this.mapData.parallaxoriginx;
+		const oy = this.mapData.parallaxoriginy;
+		for (const child of this.children) if (isParallaxLayer(child)) applyParallaxRecursive(child, cameraX, cameraY, ox, oy, 1, 1);
+	}
+	_buildBackground(pixelWidth, pixelHeight, colorHex) {
+		const color = parseTintColor(colorHex);
+		this._background = new pixi_js.Graphics().rect(0, 0, pixelWidth, pixelHeight).fill(color);
+		this._background.label = "background";
+		this.addChild(this._background);
+	}
+	destroy(options) {
+		for (const ts of this.tileSetRenderers) ts.destroy();
+		super.destroy(options);
+	}
 };
-function isXmlExt(ext) {
-  return ext === ".tmx";
-}
-function isTsxExt(ext) {
-  return ext === ".tsx";
-}
-var tiledMapLoader = {
-  extension: {
-    type: pixi_js.ExtensionType.LoadParser,
-    name: "tiledmap-loader"
-  },
-  id: "tiledmap-loader",
-  name: "tiledmap-loader",
-  test(url) {
-    const ext = pixi_js.path.extname(url).toLowerCase();
-    return ext === ".tmx" || ext === ".tmj";
-  },
-  async load(url) {
-    const ext = pixi_js.path.extname(url).toLowerCase();
-    const response = await fetch(url);
-    let data;
-    if (isXmlExt(ext)) {
-      const xml = await response.text();
-      data = parseTmx(xml);
-    } else {
-      data = await response.json();
-    }
-    const basePath = pixi_js.path.dirname(url);
-    const externalTilesets = /* @__PURE__ */ new Map();
-    for (const ts of data.tilesets) {
-      if ("source" in ts && !("name" in ts)) {
-        const tsUrl = pixi_js.path.join(basePath, ts.source);
-        const tsResponse = await fetch(tsUrl);
-        const tsExt = pixi_js.path.extname(ts.source).toLowerCase();
-        let tsData;
-        if (isTsxExt(tsExt)) {
-          const tsXml = await tsResponse.text();
-          tsData = parseTsx(tsXml);
-        } else {
-          tsData = await tsResponse.json();
-        }
-        externalTilesets.set(ts.source, tsData);
-      }
-    }
-    const mapData = await parseMapAsync(data, { externalTilesets });
-    const tilesetTextures = /* @__PURE__ */ new Map();
-    const imageLayerTextures = /* @__PURE__ */ new Map();
-    const tileImageTextures = /* @__PURE__ */ new Map();
-    const textureLoads = [];
-    for (const ts of mapData.tilesets) {
-      if (ts.image) {
-        const imageUrl = pixi_js.path.join(basePath, ts.image);
-        textureLoads.push(
-          pixi_js.Assets.load(imageUrl).then((tex) => {
-            tilesetTextures.set(ts.image, tex);
-          })
-        );
-      }
-      for (const [_localId, tileDef] of ts.tiles) {
-        if (tileDef.image) {
-          const tileImgUrl = pixi_js.path.join(basePath, tileDef.image);
-          textureLoads.push(
-            pixi_js.Assets.load(tileImgUrl).then((tex) => {
-              tileImageTextures.set(tileDef.image, tex);
-            })
-          );
-        }
-      }
-    }
-    for (const layer of flattenLayers(mapData.layers)) {
-      if (layer.type === "imagelayer" && layer.image) {
-        const imgUrl = pixi_js.path.join(basePath, layer.image);
-        textureLoads.push(
-          pixi_js.Assets.load(imgUrl).then((tex) => {
-            imageLayerTextures.set(layer.image, tex);
-          })
-        );
-      }
-    }
-    await Promise.all(textureLoads);
-    const container = new TiledMap(mapData, {
-      tilesetTextures,
-      imageLayerTextures,
-      tileImageTextures
-    });
-    return { mapData, container };
-  }
+function applyParallaxRecursive(layer, cameraX, cameraY, originX, originY, parentParallaxX, parentParallaxY) {
+	const px = layer.layerParallaxX * parentParallaxX;
+	const py = layer.layerParallaxY * parentParallaxY;
+	layer.position.set(layer.layerBaseOffsetX + (cameraX - originX) * (1 - px), layer.layerBaseOffsetY + (cameraY - originY) * (1 - py));
+	if (layer instanceof GroupLayerRenderer) {
+		for (const child of layer.children) if (isParallaxLayer(child)) applyParallaxRecursive(child, cameraX, cameraY, originX, originY, px, py);
+	}
+}
+//#endregion
+//#region src/renderer/tiledAssetLoader.ts
+const tiledMapLoader = {
+	extension: {
+		type: pixi_js.ExtensionType.LoadParser,
+		name: "tiledmap-loader"
+	},
+	id: "tiledmap-loader",
+	name: "tiledmap-loader",
+	test(url) {
+		const ext = pixi_js.path.extname(url).toLowerCase();
+		return ext === ".tmx" || ext === ".tmj";
+	},
+	async load(url) {
+		const ext = pixi_js.path.extname(url).toLowerCase();
+		const response = await fetch(url);
+		let data;
+		if (ext === ".tmx") data = parseTmx(await response.text());
+		else data = await response.json();
+		const basePath = pixi_js.path.dirname(url);
+		const externalTilesets = /* @__PURE__ */ new Map();
+		for (const ts of data.tilesets) {
+			if (!isTilesetRef(ts)) continue;
+			const tsUrl = pixi_js.path.join(basePath, ts.source);
+			const tsResponse = await fetch(tsUrl);
+			const tsExt = pixi_js.path.extname(ts.source).toLowerCase();
+			let tsData;
+			if (tsExt === ".tsx") tsData = parseTsx(await tsResponse.text());
+			else tsData = await tsResponse.json();
+			externalTilesets.set(ts.source, tsData);
+		}
+		const templates = /* @__PURE__ */ new Map();
+		const templateSources = /* @__PURE__ */ new Set();
+		for (const obj of walkObjects(data.layers)) if (obj.template) templateSources.add(obj.template);
+		await Promise.all(Array.from(templateSources).map(async (src) => {
+			const tplUrl = pixi_js.path.join(basePath, src);
+			const tplResponse = await fetch(tplUrl);
+			const tplExt = pixi_js.path.extname(src).toLowerCase();
+			let tpl;
+			if (tplExt === ".tx") tpl = parseTx(await tplResponse.text());
+			else tpl = await tplResponse.json();
+			templates.set(src, tpl);
+		}));
+		const mapData = await parseMapAsync(data, {
+			externalTilesets,
+			templates
+		});
+		const tilesetTextures = /* @__PURE__ */ new Map();
+		const imageLayerTextures = /* @__PURE__ */ new Map();
+		const tileImageTextures = /* @__PURE__ */ new Map();
+		const textureLoads = [];
+		for (const ts of mapData.tilesets) {
+			if (ts.image) {
+				const imageUrl = pixi_js.path.join(basePath, ts.image);
+				textureLoads.push(pixi_js.Assets.load(imageUrl).then((tex) => {
+					tilesetTextures.set(ts.image, tex);
+				}));
+			}
+			for (const [_localId, tileDef] of ts.tiles) if (tileDef.image) {
+				const tileImgUrl = pixi_js.path.join(basePath, tileDef.image);
+				textureLoads.push(pixi_js.Assets.load(tileImgUrl).then((tex) => {
+					tileImageTextures.set(tileDef.image, tex);
+				}));
+			}
+		}
+		for (const layer of flattenLayers(mapData.layers)) if (layer.type === "imagelayer" && layer.image) {
+			const imgUrl = pixi_js.path.join(basePath, layer.image);
+			textureLoads.push(pixi_js.Assets.load(imgUrl).then((tex) => {
+				imageLayerTextures.set(layer.image, tex);
+			}));
+		}
+		await Promise.all(textureLoads);
+		return {
+			mapData,
+			container: new TiledMap(mapData, {
+				tilesetTextures,
+				imageLayerTextures,
+				tileImageTextures
+			})
+		};
+	}
 };
 function flattenLayers(layers) {
-  const result = [];
-  for (const layer of layers) {
-    result.push(layer);
-    if (layer.type === "group") {
-      result.push(...flattenLayers(layer.layers));
-    }
-  }
-  return result;
+	const result = [];
+	for (const layer of layers) {
+		result.push(layer);
+		if (layer.type === "group" && layer.layers) result.push(...flattenLayers(layer.layers));
+	}
+	return result;
 }
-
+function* walkObjects(layers) {
+	for (const layer of flattenLayers(layers)) if (layer.type === "objectgroup" && layer.objects) for (const obj of layer.objects) yield obj;
+}
+//#endregion
 exports.FLIPPED_DIAGONALLY_FLAG = FLIPPED_DIAGONALLY_FLAG;
 exports.FLIPPED_HORIZONTALLY_FLAG = FLIPPED_HORIZONTALLY_FLAG;
 exports.FLIPPED_VERTICALLY_FLAG = FLIPPED_VERTICALLY_FLAG;
@@ -1425,7 +1566,8 @@ exports.parseMap = parseMap;
 exports.parseMapAsync = parseMapAsync;
 exports.parseTmx = parseTmx;
 exports.parseTsx = parseTsx;
+exports.parseTx = parseTx;
 exports.tileToPixel = tileToPixel;
 exports.tiledMapLoader = tiledMapLoader;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map