@flighthq/tilemap-formats 0.1.0

package/src/tiledJsonParse.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest';
+
+import { parseTiledTilesetJson, parseTiledTmj } from './tiledJsonParse';
+import type { TiledParseOptions } from './tiledOptions';
+
+function base64Layer(gids: readonly number[]): string {
+  const bytes = new Uint8Array(gids.length * 4);
+  const view = new DataView(bytes.buffer);
+  gids.forEach((gid, i) => view.setUint32(i * 4, gid, true));
+  const table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  let out = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += table[b0 >> 2] + table[((b0 & 3) << 4) | (b1 >> 4)];
+    out += i + 1 < bytes.length ? table[((b1 & 15) << 2) | (b2 >> 6)] : '=';
+    out += i + 2 < bytes.length ? table[b2 & 63] : '=';
+  }
+  return out;
+}
+
+function tmjWithData(data: unknown, extra: Record<string, unknown> = {}): string {
+  return JSON.stringify({
+    height: 2,
+    layers: [{ data, height: 2, id: 1, name: 'g', type: 'tilelayer', width: 2, ...extra }],
+    tilewidth: 32,
+    tileheight: 32,
+    type: 'map',
+    version: '1.10',
+    width: 2,
+  });
+}
+
+describe('parseTiledTilesetJson', () => {
+  it('parses a standalone TSJ tileset', () => {
+    const tsj = JSON.stringify({
+      columns: 3,
+      image: 'terrain.png',
+      imageheight: 50,
+      imagewidth: 50,
+      margin: 2,
+      name: 'terrain',
+      spacing: 1,
+      tilecount: 9,
+      tileheight: 16,
+      tiles: [{ animation: [{ duration: 100, tileid: 0 }], id: 0, type: 'water' }],
+      tilewidth: 16,
+    });
+    const tileset = parseTiledTilesetJson(tsj)!;
+    expect(tileset.name).toBe('terrain');
+    expect(tileset.image).toBe('terrain.png');
+    expect(tileset.columns).toBe(3);
+    expect(tileset.tiles[0].animation).toEqual([{ duration: 100, tileId: 0 }]);
+  });
+
+  it('returns null on malformed JSON', () => {
+    expect(parseTiledTilesetJson('{ not json')).toBeNull();
+    expect(parseTiledTilesetJson('[]')).toBeNull();
+  });
+});
+
+describe('parseTiledTmj', () => {
+  it('parses a polygon object and its points', () => {
+    const tmj = JSON.stringify({
+      height: 1,
+      layers: [
+        {
+          id: 1,
+          name: 'shapes',
+          objects: [
+            {
+              id: 1,
+              name: 'zone',
+              polygon: [
+                { x: 0, y: 0 },
+                { x: 32, y: 0 },
+                { x: 32, y: 32 },
+              ],
+              type: '',
+              x: 4,
+              y: 4,
+            },
+          ],
+          type: 'objectgroup',
+        },
+      ],
+      tileheight: 32,
+      tilewidth: 32,
+      type: 'map',
+      version: '1.10',
+      width: 1,
+    });
+    const map = parseTiledTmj(tmj)!;
+    const layer = map.layers[0];
+    if (layer.type !== 'objectgroup') throw new Error('expected an object group');
+    expect(layer.objects[0].polygon).toEqual([
+      { x: 0, y: 0 },
+      { x: 32, y: 0 },
+      { x: 32, y: 32 },
+    ]);
+  });
+
+  it('decodes an array-data tile layer', () => {
+    const map = parseTiledTmj(tmjWithData([1, 5, 2147483649, 6]))!;
+    const layer = map.layers[0];
+    if (layer.type !== 'tilelayer') throw new Error('expected a tile layer');
+    expect(Array.from(layer.data)).toEqual([1, 5, 2147483649, 6]);
+  });
+
+  it('decodes a base64 string tile layer', () => {
+    const map = parseTiledTmj(tmjWithData(base64Layer([1, 5, 2147483649, 6]), { encoding: 'base64' }))!;
+    const layer = map.layers[0];
+    if (layer.type !== 'tilelayer') throw new Error('expected a tile layer');
+    expect(Array.from(layer.data)).toEqual([1, 5, 2147483649, 6]);
+  });
+
+  it('preserves a compressed layer as empty without an inflate seam, and decodes with one', () => {
+    const json = tmjWithData(base64Layer([1, 5, 2147483649, 6]), { compression: 'zlib', encoding: 'base64' });
+
+    const dropped = parseTiledTmj(json)!;
+    const droppedLayer = dropped.layers[0];
+    if (droppedLayer.type !== 'tilelayer') throw new Error('expected a tile layer');
+    expect(Array.from(droppedLayer.data)).toEqual([0, 0, 0, 0]);
+
+    const options: TiledParseOptions = { inflate: (bytes) => new Uint8Array(bytes) };
+    const decoded = parseTiledTmj(json, options)!;
+    const decodedLayer = decoded.layers[0];
+    if (decodedLayer.type !== 'tilelayer') throw new Error('expected a tile layer');
+    expect(Array.from(decodedLayer.data)).toEqual([1, 5, 2147483649, 6]);
+  });
+
+  it('returns null on malformed JSON', () => {
+    expect(parseTiledTmj('{ not json')).toBeNull();
+    expect(parseTiledTmj('42')).toBeNull();
+  });
+});

package/src/tiledLayerData.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+
+import { decodeTiledBase64Layer, decodeTiledCsvLayer } from './tiledLayerData';
+
+// GIDs [1, 5, 0x80000001, 6] as little-endian 32-bit ints.
+const gids = [1, 5, 0x80000001, 6];
+const bytes = new Uint8Array(gids.length * 4);
+const view = new DataView(bytes.buffer);
+gids.forEach((gid, i) => view.setUint32(i * 4, gid, true));
+const base64 = encodeBase64(bytes);
+
+// Portable base64 encoder for fixtures (avoids depending on Node's Buffer in the type-check).
+function encodeBase64(input: Readonly<Uint8Array>): string {
+  const table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  let out = '';
+  for (let i = 0; i < input.length; i += 3) {
+    const b0 = input[i];
+    const b1 = i + 1 < input.length ? input[i + 1] : 0;
+    const b2 = i + 2 < input.length ? input[i + 2] : 0;
+    out += table[b0 >> 2] + table[((b0 & 3) << 4) | (b1 >> 4)];
+    out += i + 1 < input.length ? table[((b1 & 15) << 2) | (b2 >> 6)] : '=';
+    out += i + 2 < input.length ? table[b2 & 63] : '=';
+  }
+  return out;
+}
+
+describe('decodeTiledBase64Layer', () => {
+  it('decodes an uncompressed base64 payload as little-endian GIDs', () => {
+    expect(Array.from(decodeTiledBase64Layer(base64, null)!)).toEqual(gids);
+  });
+
+  it('agrees with the CSV decode of the same GIDs', () => {
+    expect(Array.from(decodeTiledBase64Layer(base64, null)!)).toEqual(
+      Array.from(decodeTiledCsvLayer('1,5,2147483649,6')),
+    );
+  });
+
+  it('returns null when compressed with no inflate seam', () => {
+    expect(decodeTiledBase64Layer(base64, 'gzip')).toBeNull();
+  });
+
+  it('decodes through an inflate seam when supplied', () => {
+    const inflate = (input: Readonly<Uint8Array>) => new Uint8Array(input);
+    expect(Array.from(decodeTiledBase64Layer(base64, 'gzip', inflate)!)).toEqual(gids);
+  });
+
+  it('returns null when the inflate seam fails', () => {
+    expect(decodeTiledBase64Layer(base64, 'zlib', () => null)).toBeNull();
+  });
+});
+
+describe('decodeTiledCsvLayer', () => {
+  it('parses comma-separated GIDs and ignores whitespace', () => {
+    expect(Array.from(decodeTiledCsvLayer('\n1, 5,\n2147483649, 6\n'))).toEqual(gids);
+  });
+});

package/src/tiledProject.test.ts

@@ -0,0 +1,71 @@
+import { createTileset } from '@flighthq/tileset';
+import { describe, expect, it } from 'vitest';
+
+import type { TiledTilesetResolver } from './tiledOptions';
+import { buildTilemapLayersFromTiled } from './tiledProject';
+import { parseTiledTmx } from './tiledXmlParse';
+
+function mapWithLayerData(data: string): ReturnType<typeof parseTiledTmx> {
+  return parseTiledTmx(
+    '<map version="1" width="2" height="2" tilewidth="16" tileheight="16">' +
+      '<tileset firstgid="1" source="a.tsx"/>' +
+      '<tileset firstgid="5" source="b.tsx"/>' +
+      `<layer id="1" name="g" width="2" height="2"><data encoding="csv">${data}</data></layer>` +
+      '<objectgroup id="2" name="o"><object id="1" x="0" y="0"/></objectgroup>' +
+      '</map>',
+  );
+}
+
+const tilesetA = createTileset({ columns: 2, rows: 2, tileHeight: 16, tileWidth: 16 });
+const tilesetB = createTileset({ columns: 2, rows: 2, tileHeight: 16, tileWidth: 16 });
+
+const resolve: TiledTilesetResolver = (ref) => {
+  if (ref.firstGid === 1) return tilesetA;
+  if (ref.firstGid === 5) return tilesetB;
+  return null;
+};
+
+describe('buildTilemapLayersFromTiled', () => {
+  it('splits a two-tileset layer into one TilemapData per tileset with local ids', () => {
+    const map = mapWithLayerData('1,5,2147483649,6')!;
+    const result = buildTilemapLayersFromTiled(map, 0, resolve)!;
+    expect(result).toHaveLength(2);
+
+    expect(result[0].tileset).toBe(tilesetA);
+    // Cell 2's GID has the flip bit set; its tile id (1) still resolves to tileset A as local id 0.
+    expect(Array.from(result[0].tiles)).toEqual([0, -1, 0, -1]);
+
+    expect(result[1].tileset).toBe(tilesetB);
+    expect(Array.from(result[1].tiles)).toEqual([-1, 0, -1, 1]);
+    expect(result[1].columns).toBe(2);
+    expect(result[1].rows).toBe(2);
+  });
+
+  it('returns a one-element array for a single-tileset layer', () => {
+    const map = mapWithLayerData('1,2,1,2')!;
+    const result = buildTilemapLayersFromTiled(map, 0, resolve)!;
+    expect(result).toHaveLength(1);
+    expect(result[0].tileset).toBe(tilesetA);
+    expect(Array.from(result[0].tiles)).toEqual([0, 1, 0, 1]);
+  });
+
+  it('leaves an unresolved tileset empty while projecting the resolved one', () => {
+    const map = mapWithLayerData('1,5,1,5')!;
+    const onlyA: TiledTilesetResolver = (ref) => (ref.firstGid === 1 ? tilesetA : null);
+    const result = buildTilemapLayersFromTiled(map, 0, onlyA)!;
+    expect(result).toHaveLength(1);
+    expect(result[0].tileset).toBe(tilesetA);
+    expect(Array.from(result[0].tiles)).toEqual([0, -1, 0, -1]);
+  });
+
+  it('returns null when no referenced tileset resolves', () => {
+    const map = mapWithLayerData('1,5,2147483649,6')!;
+    expect(buildTilemapLayersFromTiled(map, 0, () => null)).toBeNull();
+  });
+
+  it('returns null for a non-tile layer or an out-of-range index', () => {
+    const map = mapWithLayerData('1,5,2147483649,6')!;
+    expect(buildTilemapLayersFromTiled(map, 1, resolve)).toBeNull();
+    expect(buildTilemapLayersFromTiled(map, 9, resolve)).toBeNull();
+  });
+});

package/src/tiledTmxFormat.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatTiledTmx } from './tiledTmxFormat';
+import { parseTiledTmx } from './tiledXmlParse';
+
+// A map exercising every modeled TMX construct: background + typed properties, an embedded tileset
+// with an animated tile, an external tileset ref, a CSV tile layer (with a flipped GID), an object
+// group (point / polygon-with-property), an image layer, and a nested group layer.
+const richTmx = [
+  '<?xml version="1.0" encoding="UTF-8"?>',
+  '<map version="1.10" tiledversion="1.10.2" orientation="orthogonal" renderorder="right-down" width="2" height="2" tilewidth="16" tileheight="16" infinite="0" backgroundcolor="#204060">',
+  ' <properties><property name="name" value="demo"/><property name="score" type="int" value="10"/></properties>',
+  ' <tileset firstgid="1" name="base" tilewidth="16" tileheight="16" tilecount="4" columns="2">',
+  '  <image source="base.png" width="32" height="32"/>',
+  '  <tile id="0" type="lava"><animation><frame tileid="0" duration="200"/></animation></tile>',
+  ' </tileset>',
+  ' <tileset firstgid="5" source="extra.tsx"/>',
+  ' <layer id="1" name="ground" width="2" height="2"><data encoding="csv">1,2,5,2147483649</data></layer>',
+  ' <objectgroup id="2" name="objs">',
+  '  <object id="1" name="p" type="marker" x="1" y="2"><point/></object>',
+  '  <object id="2" type="poly" x="0" y="0"><polygon points="0,0 8,0 8,8"/><properties><property name="tag" value="zone"/></properties></object>',
+  ' </objectgroup>',
+  ' <imagelayer id="3" name="bg"><image source="sky.png"/></imagelayer>',
+  ' <group id="4" name="grp">',
+  '  <layer id="5" name="over" width="2" height="2"><data encoding="csv">0,0,1,1</data></layer>',
+  ' </group>',
+  '</map>',
+].join('\n');
+
+describe('formatTiledTmx', () => {
+  it('round-trips parse -> format -> parse for the modeled fields', () => {
+    const map = parseTiledTmx(richTmx)!;
+    const reparsed = parseTiledTmx(formatTiledTmx(map));
+    expect(reparsed).toEqual(map);
+  });
+
+  it('writes tile layers as CSV data', () => {
+    const map = parseTiledTmx(richTmx)!;
+    const text = formatTiledTmx(map);
+    expect(text).toContain('<data encoding="csv">');
+    expect(text).toContain('1,2,5,2147483649');
+  });
+
+  it('emits external tileset refs by source and embedded tilesets inline', () => {
+    const map = parseTiledTmx(richTmx)!;
+    const text = formatTiledTmx(map);
+    expect(text).toContain('<tileset firstgid="5" source="extra.tsx"/>');
+    expect(text).toContain('firstgid="1" name="base"');
+  });
+});

package/src/tiledXmlParse.test.ts

@@ -0,0 +1,241 @@
+import { describe, expect, it } from 'vitest';
+
+import { decodeTiledGid } from './tiledGid';
+import { parseTiledTilesetJson, parseTiledTmj } from './tiledJsonParse';
+import type { TiledParseOptions } from './tiledOptions';
+import { parseTiledTileset, parseTiledTmx } from './tiledXmlParse';
+
+// A 2x2 orthogonal map with a CSV tile layer drawing from two tilesets (firstgid 1 and 5), one
+// embedded tileset and one external `source="ext.tsx"` ref, an object group with a point and a
+// rectangle, and a typed property block. Cell (0,1) sets the horizontal flip bit on tile id 1.
+const orthogonalTmx = [
+  '<?xml version="1.0" encoding="UTF-8"?>',
+  '<map version="1.10" tiledversion="1.10.2" orientation="orthogonal" renderorder="right-down" width="2" height="2" tilewidth="32" tileheight="32" infinite="0" backgroundcolor="#ff8800">',
+  ' <properties>',
+  '  <property name="author" value="flight"/>',
+  '  <property name="level" type="int" value="3"/>',
+  '  <property name="hard" type="bool" value="true"/>',
+  ' </properties>',
+  ' <tileset firstgid="1" name="A" tilewidth="32" tileheight="32" tilecount="4" columns="2">',
+  '  <image source="a.png" width="64" height="64"/>',
+  ' </tileset>',
+  ' <tileset firstgid="5" source="ext.tsx"/>',
+  ' <layer id="1" name="ground" width="2" height="2">',
+  '  <data encoding="csv">1,5,2147483649,6</data>',
+  ' </layer>',
+  ' <objectgroup id="2" name="things">',
+  '  <object id="1" name="spawn" type="marker" x="16" y="16"><point/></object>',
+  '  <object id="2" name="wall" type="collider" x="0" y="0" width="32" height="32"/>',
+  ' </objectgroup>',
+  '</map>',
+].join('\n');
+
+const orthogonalTmj = JSON.stringify({
+  backgroundcolor: '#ff8800',
+  height: 2,
+  infinite: false,
+  layers: [
+    {
+      data: [1, 5, 2147483649, 6],
+      height: 2,
+      id: 1,
+      name: 'ground',
+      opacity: 1,
+      type: 'tilelayer',
+      visible: true,
+      width: 2,
+    },
+    {
+      id: 2,
+      name: 'things',
+      objects: [
+        { id: 1, name: 'spawn', point: true, type: 'marker', x: 16, y: 16 },
+        { height: 32, id: 2, name: 'wall', type: 'collider', width: 32, x: 0, y: 0 },
+      ],
+      opacity: 1,
+      type: 'objectgroup',
+      visible: true,
+    },
+  ],
+  orientation: 'orthogonal',
+  properties: [
+    { name: 'author', type: 'string', value: 'flight' },
+    { name: 'level', type: 'int', value: 3 },
+    { name: 'hard', type: 'bool', value: true },
+  ],
+  renderorder: 'right-down',
+  tiledversion: '1.10.2',
+  tileheight: 32,
+  tilesets: [
+    {
+      columns: 2,
+      firstgid: 1,
+      image: 'a.png',
+      imageheight: 64,
+      imagewidth: 64,
+      name: 'A',
+      tilecount: 4,
+      tileheight: 32,
+      tiles: [],
+      tilewidth: 32,
+    },
+    { firstgid: 5, source: 'ext.tsx' },
+  ],
+  tilewidth: 32,
+  type: 'map',
+  version: '1.10',
+  width: 2,
+});
+
+function base64Layer(gids: readonly number[]): string {
+  const bytes = new Uint8Array(gids.length * 4);
+  const view = new DataView(bytes.buffer);
+  gids.forEach((gid, i) => view.setUint32(i * 4, gid, true));
+  const table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  let out = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += table[b0 >> 2] + table[((b0 & 3) << 4) | (b1 >> 4)];
+    out += i + 1 < bytes.length ? table[((b1 & 15) << 2) | (b2 >> 6)] : '=';
+    out += i + 2 < bytes.length ? table[b2 & 63] : '=';
+  }
+  return out;
+}
+
+function tmxWithData(dataElement: string): string {
+  return `<map version="1" width="2" height="2" tilewidth="32" tileheight="32"><layer id="1" name="g" width="2" height="2">${dataElement}</layer></map>`;
+}
+
+describe('parseTiledTileset', () => {
+  it('parses a standalone TSX tileset with per-tile animation and properties', () => {
+    const tsx = [
+      '<tileset name="terrain" tilewidth="16" tileheight="16" tilecount="9" columns="3" spacing="1" margin="2">',
+      ' <image source="terrain.png" width="50" height="50"/>',
+      ' <properties><property name="solid" type="bool" value="true"/></properties>',
+      ' <tile id="0" type="water">',
+      '  <animation><frame tileid="0" duration="100"/><frame tileid="1" duration="120"/></animation>',
+      ' </tile>',
+      '</tileset>',
+    ].join('\n');
+    const tileset = parseTiledTileset(tsx)!;
+    expect(tileset.name).toBe('terrain');
+    expect(tileset.image).toBe('terrain.png');
+    expect(tileset.imageWidth).toBe(50);
+    expect(tileset.columns).toBe(3);
+    expect(tileset.spacing).toBe(1);
+    expect(tileset.margin).toBe(2);
+    expect(tileset.properties).toEqual([{ name: 'solid', type: 'bool', value: true }]);
+    expect(tileset.tiles).toHaveLength(1);
+    expect(tileset.tiles[0].type).toBe('water');
+    expect(tileset.tiles[0].animation).toEqual([
+      { duration: 100, tileId: 0 },
+      { duration: 120, tileId: 1 },
+    ]);
+  });
+
+  it('returns null when the root is not a tileset', () => {
+    expect(parseTiledTileset('<map/>')).toBeNull();
+    expect(parseTiledTileset('not xml')).toBeNull();
+  });
+});
+
+describe('parseTiledTmx', () => {
+  it('parses map metadata, orientation, and background color', () => {
+    const map = parseTiledTmx(orthogonalTmx)!;
+    expect(map.orientation).toBe('orthogonal');
+    expect(map.renderOrder).toBe('right-down');
+    expect(map.width).toBe(2);
+    expect(map.height).toBe(2);
+    expect(map.tileWidth).toBe(32);
+    expect(map.infinite).toBe(false);
+    expect(map.version).toBe('1.10');
+    expect(map.tiledVersion).toBe('1.10.2');
+    expect(map.backgroundColor).toBe(0xff8800ff);
+  });
+
+  it('parses typed properties', () => {
+    const map = parseTiledTmx(orthogonalTmx)!;
+    expect(map.properties).toEqual([
+      { name: 'author', type: 'string', value: 'flight' },
+      { name: 'level', type: 'int', value: 3 },
+      { name: 'hard', type: 'bool', value: true },
+    ]);
+  });
+
+  it('parses embedded and external tileset refs', () => {
+    const map = parseTiledTmx(orthogonalTmx)!;
+    expect(map.tilesets).toHaveLength(2);
+    expect(map.tilesets[0].firstGid).toBe(1);
+    expect(map.tilesets[0].source).toBeNull();
+    expect(map.tilesets[0].tileset?.name).toBe('A');
+    expect(map.tilesets[0].tileset?.image).toBe('a.png');
+    expect(map.tilesets[1].firstGid).toBe(5);
+    expect(map.tilesets[1].source).toBe('ext.tsx');
+    expect(map.tilesets[1].tileset).toBeNull();
+  });
+
+  it('preserves raw GIDs including the flip bit', () => {
+    const map = parseTiledTmx(orthogonalTmx)!;
+    const layer = map.layers[0];
+    expect(layer.type).toBe('tilelayer');
+    if (layer.type !== 'tilelayer') return;
+    expect(Array.from(layer.data)).toEqual([1, 5, 2147483649, 6]);
+    expect(decodeTiledGid(layer.data[2])).toMatchObject({ flipHorizontal: true, tileId: 1 });
+  });
+
+  it('parses object groups with point and rectangle objects', () => {
+    const map = parseTiledTmx(orthogonalTmx)!;
+    const layer = map.layers[1];
+    expect(layer.type).toBe('objectgroup');
+    if (layer.type !== 'objectgroup') return;
+    expect(layer.objects).toHaveLength(2);
+    expect(layer.objects[0]).toMatchObject({ name: 'spawn', point: true, type: 'marker', x: 16, y: 16 });
+    expect(layer.objects[1]).toMatchObject({ ellipse: false, height: 32, name: 'wall', point: false, width: 32 });
+  });
+
+  it('decodes base64 and csv layer data to the same GIDs', () => {
+    const csv = parseTiledTmx(tmxWithData('<data encoding="csv">1,5,2147483649,6</data>'))!;
+    const b64 = parseTiledTmx(tmxWithData(`<data encoding="base64">${base64Layer([1, 5, 2147483649, 6])}</data>`))!;
+    const csvLayer = csv.layers[0];
+    const b64Layer = b64.layers[0];
+    if (csvLayer.type !== 'tilelayer' || b64Layer.type !== 'tilelayer') throw new Error('expected tile layers');
+    expect(Array.from(b64Layer.data)).toEqual(Array.from(csvLayer.data));
+  });
+
+  it('preserves a compressed layer as an empty grid without an inflate seam, and decodes with one', () => {
+    const payload = base64Layer([1, 5, 2147483649, 6]);
+    const tmx = tmxWithData(`<data encoding="base64" compression="gzip">${payload}</data>`);
+
+    const dropped = parseTiledTmx(tmx)!;
+    const droppedLayer = dropped.layers[0];
+    if (droppedLayer.type !== 'tilelayer') throw new Error('expected a tile layer');
+    expect(Array.from(droppedLayer.data)).toEqual([0, 0, 0, 0]);
+
+    const options: TiledParseOptions = { inflate: (bytes) => new Uint8Array(bytes) };
+    const decoded = parseTiledTmx(tmx, options)!;
+    const decodedLayer = decoded.layers[0];
+    if (decodedLayer.type !== 'tilelayer') throw new Error('expected a tile layer');
+    expect(Array.from(decodedLayer.data)).toEqual([1, 5, 2147483649, 6]);
+  });
+
+  it('parses to a document equivalent to the TMJ form', () => {
+    expect(parseTiledTmx(orthogonalTmx)).toEqual(parseTiledTmj(orthogonalTmj));
+    // Cross-check that the TSJ/TSX embedded tileset shapes also match.
+    expect(
+      parseTiledTilesetJson(
+        '{"name":"A","tilewidth":32,"tileheight":32,"tilecount":4,"columns":2,"image":"a.png","imagewidth":64,"imageheight":64,"tiles":[]}',
+      ),
+    ).toEqual(
+      parseTiledTileset(
+        '<tileset name="A" tilewidth="32" tileheight="32" tilecount="4" columns="2"><image source="a.png" width="64" height="64"/></tileset>',
+      ),
+    );
+  });
+
+  it('returns null for malformed input', () => {
+    expect(parseTiledTmx('<foo/>')).toBeNull();
+    expect(parseTiledTmx('garbage')).toBeNull();
+  });
+});