@codexo/exojs-tiled 0.15.3 → 0.16.0

package/dist/esm/validate.js

@@ -1,547 +1,498 @@
-// Runtime validation for Tiled JSON (TMJ/TSJ) data. Every exported function
-// takes `unknown` (the result of `JSON.parse`) and either returns a typed,
-// validated `Tiled*Data` value or throws a {@link TiledFormatError}.
-//
-// There is no fall-through: an unrecognised shape, an unsupported encoding,
-// or an out-of-range value is always a thrown error carrying the source URL
-// and a JSON-path-like field path, never a silently-substituted default.
+import { TILED_OBJECT_ALIGNMENTS } from "./objectAlignment.js";
+
+//#region src/validate.ts
 /**
- * Thrown when a Tiled JSON document does not match the expected shape.
- * `source` is the URL of the file being parsed; `path` is a JSON-path-like
- * pointer (e.g. `layers[2].objects[0].properties[1].value`) to the offending
- * value, or `''` for the document root.
- */
-class TiledFormatError extends Error {
-    source;
-    path;
-    constructor(source, path, message) {
-        super(`Invalid Tiled data in "${source}" at ${path === '' ? '<root>' : path}: ${message}`);
-        this.name = 'TiledFormatError';
-        this.source = source;
-        this.path = path;
-    }
-}
-// ── Primitive helpers ───────────────────────────────────────────────────────
-function describeValue(value) {
-    if (value === null)
-        return 'null';
-    if (Array.isArray(value))
-        return 'an array';
-    return typeof value;
-}
-function joinPath(path, key) {
-    if (typeof key === 'number')
-        return `${path}[${key}]`;
-    return path === '' ? key : `${path}.${key}`;
-}
-function expectObject(value, source, path) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-        throw new TiledFormatError(source, path, `expected an object, got ${describeValue(value)}`);
-    }
-    return value;
-}
-function expectArray(value, source, path) {
-    if (!Array.isArray(value)) {
-        throw new TiledFormatError(source, path, `expected an array, got ${describeValue(value)}`);
-    }
-    return value;
-}
-function expectString(value, source, path) {
-    if (typeof value !== 'string') {
-        throw new TiledFormatError(source, path, `expected a string, got ${describeValue(value)}`);
-    }
-    return value;
-}
-function expectNumber(value, source, path) {
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        throw new TiledFormatError(source, path, `expected a finite number, got ${describeValue(value)}`);
-    }
-    return value;
-}
-function expectInteger(value, source, path) {
-    const n = expectNumber(value, source, path);
-    if (!Number.isInteger(n)) {
-        throw new TiledFormatError(source, path, `expected an integer, got ${n}`);
-    }
-    return n;
-}
-function expectNonNegativeInteger(value, source, path) {
-    const n = expectInteger(value, source, path);
-    if (n < 0) {
-        throw new TiledFormatError(source, path, `expected a non-negative integer, got ${n}`);
-    }
-    return n;
-}
-function expectPositiveInteger(value, source, path) {
-    const n = expectInteger(value, source, path);
-    if (n <= 0) {
-        throw new TiledFormatError(source, path, `expected a positive integer, got ${n}`);
-    }
-    return n;
-}
-function expectBoolean(value, source, path) {
-    if (typeof value !== 'boolean') {
-        throw new TiledFormatError(source, path, `expected a boolean, got ${describeValue(value)}`);
-    }
-    return value;
-}
-function optionalString(obj, key, source, path) {
-    const value = obj[key];
-    return value === undefined ? undefined : expectString(value, source, joinPath(path, key));
-}
-function optionalNumber(obj, key, source, path) {
-    const value = obj[key];
-    return value === undefined ? undefined : expectNumber(value, source, joinPath(path, key));
-}
-function optionalInteger(obj, key, source, path) {
-    const value = obj[key];
-    return value === undefined ? undefined : expectInteger(value, source, joinPath(path, key));
-}
-function optionalNonNegativeInteger(obj, key, source, path) {
-    const value = obj[key];
-    return value === undefined ? undefined : expectNonNegativeInteger(value, source, joinPath(path, key));
-}
-function optionalBoolean(obj, key, source, path) {
-    const value = obj[key];
-    return value === undefined ? undefined : expectBoolean(value, source, joinPath(path, key));
-}
-function mapArray(value, source, path, fn) {
-    const arr = expectArray(value, source, path);
-    return arr.map((item, i) => fn(item, joinPath(path, i)));
-}
-function optionalMapArray(value, source, path, fn) {
-    return value === undefined ? undefined : mapArray(value, source, path, fn);
-}
-// ── Custom properties ───────────────────────────────────────────────────────
-const PROPERTY_TYPES = ['string', 'int', 'float', 'bool', 'color', 'file', 'object', 'class'];
-function validateTiledClassPropertyValue(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        const memberPath = joinPath(path, key);
-        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-            result[key] = value;
-        }
-        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-            result[key] = validateTiledClassPropertyValue(value, source, memberPath);
-        }
-        else {
-            throw new TiledFormatError(source, memberPath, `expected a string, number, boolean, or nested object, got ${describeValue(value)}`);
-        }
-    }
-    return result;
-}
+* Thrown when a Tiled JSON document does not match the expected shape.
+* `source` is the URL of the file being parsed; `path` is a JSON-path-like
+* pointer (e.g. `layers[2].objects[0].properties[1].value`) to the offending
+* value, or `''` for the document root.
+*/
+var TiledFormatError = class extends Error {
+	source;
+	path;
+	constructor(source, path, message) {
+		super(`Invalid Tiled data in "${source}" at ${path === "" ? "<root>" : path}: ${message}`);
+		this.name = "TiledFormatError";
+		this.source = source;
+		this.path = path;
+	}
+};
+const describeValue = (value) => {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "an array";
+	return typeof value;
+};
+const joinPath = (path, key) => {
+	if (typeof key === "number") return `${path}[${key}]`;
+	return path === "" ? key : `${path}.${key}`;
+};
+const expectObject = (value, source, path) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TiledFormatError(source, path, `expected an object, got ${describeValue(value)}`);
+	return value;
+};
+const expectArray = (value, source, path) => {
+	if (!Array.isArray(value)) throw new TiledFormatError(source, path, `expected an array, got ${describeValue(value)}`);
+	return value;
+};
+const expectString = (value, source, path) => {
+	if (typeof value !== "string") throw new TiledFormatError(source, path, `expected a string, got ${describeValue(value)}`);
+	return value;
+};
+const expectNumber = (value, source, path) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TiledFormatError(source, path, `expected a finite number, got ${describeValue(value)}`);
+	return value;
+};
+const expectInteger = (value, source, path) => {
+	const n = expectNumber(value, source, path);
+	if (!Number.isInteger(n)) throw new TiledFormatError(source, path, `expected an integer, got ${n}`);
+	return n;
+};
+const expectNonNegativeInteger = (value, source, path) => {
+	const n = expectInteger(value, source, path);
+	if (n < 0) throw new TiledFormatError(source, path, `expected a non-negative integer, got ${n}`);
+	return n;
+};
+const expectPositiveInteger = (value, source, path) => {
+	const n = expectInteger(value, source, path);
+	if (n <= 0) throw new TiledFormatError(source, path, `expected a positive integer, got ${n}`);
+	return n;
+};
+const expectBoolean = (value, source, path) => {
+	if (typeof value !== "boolean") throw new TiledFormatError(source, path, `expected a boolean, got ${describeValue(value)}`);
+	return value;
+};
+const optionalString = (obj, key, source, path) => {
+	const value = obj[key];
+	return value === void 0 ? void 0 : expectString(value, source, joinPath(path, key));
+};
+const optionalNumber = (obj, key, source, path) => {
+	const value = obj[key];
+	return value === void 0 ? void 0 : expectNumber(value, source, joinPath(path, key));
+};
+const optionalInteger = (obj, key, source, path) => {
+	const value = obj[key];
+	return value === void 0 ? void 0 : expectInteger(value, source, joinPath(path, key));
+};
+const optionalNonNegativeInteger = (obj, key, source, path) => {
+	const value = obj[key];
+	return value === void 0 ? void 0 : expectNonNegativeInteger(value, source, joinPath(path, key));
+};
+const optionalBoolean = (obj, key, source, path) => {
+	const value = obj[key];
+	return value === void 0 ? void 0 : expectBoolean(value, source, joinPath(path, key));
+};
+const mapArray = (value, source, path, fn) => {
+	return expectArray(value, source, path).map((item, i) => fn(item, joinPath(path, i)));
+};
+const optionalMapArray = (value, source, path, fn) => value === void 0 ? void 0 : mapArray(value, source, path, fn);
+const PROPERTY_TYPES = [
+	"string",
+	"int",
+	"float",
+	"bool",
+	"color",
+	"file",
+	"object",
+	"class"
+];
+const validateTiledClassPropertyValue = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const memberPath = joinPath(path, key);
+		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") result[key] = value;
+		else if (typeof value === "object" && value !== null && !Array.isArray(value)) result[key] = validateTiledClassPropertyValue(value, source, memberPath);
+		else throw new TiledFormatError(source, memberPath, `expected a string, number, boolean, or nested object, got ${describeValue(value)}`);
+	}
+	return result;
+};
 /** @internal */
-function validateTiledPropertyData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    const name = expectString(obj.name, source, joinPath(path, 'name'));
-    const typePath = joinPath(path, 'type');
-    const typeName = obj.type === undefined ? 'string' : expectString(obj.type, source, typePath);
-    if (!PROPERTY_TYPES.includes(typeName)) {
-        throw new TiledFormatError(source, typePath, `unknown property type "${typeName}"`);
-    }
-    const type = typeName;
-    const propertytype = optionalString(obj, 'propertytype', source, path);
-    const valuePath = joinPath(path, 'value');
-    let value;
-    switch (type) {
-        case 'string':
-        case 'color':
-        case 'file':
-            value = expectString(obj.value, source, valuePath);
-            break;
-        case 'int':
-        case 'float':
-        case 'object':
-            value = expectNumber(obj.value, source, valuePath);
-            break;
-        case 'bool':
-            value = expectBoolean(obj.value, source, valuePath);
-            break;
-        case 'class':
-            value = validateTiledClassPropertyValue(obj.value, source, valuePath);
-            break;
-    }
-    return { name, type, propertytype, value };
-}
-function validateTiledPropertiesArray(value, source, path) {
-    return optionalMapArray(value, source, path, (item, itemPath) => validateTiledPropertyData(item, source, itemPath));
-}
-// ── Points / animation frames ───────────────────────────────────────────────
-function validateTiledPointData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    return {
-        x: expectNumber(obj.x, source, joinPath(path, 'x')),
-        y: expectNumber(obj.y, source, joinPath(path, 'y')),
-    };
-}
-function validateTiledPointArray(value, source, path) {
-    return mapArray(value, source, path, (item, itemPath) => validateTiledPointData(item, source, itemPath));
-}
+const validateTiledPropertyData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	const name = expectString(obj.name, source, joinPath(path, "name"));
+	const typePath = joinPath(path, "type");
+	const typeName = obj.type === void 0 ? "string" : expectString(obj.type, source, typePath);
+	if (!PROPERTY_TYPES.includes(typeName)) throw new TiledFormatError(source, typePath, `unknown property type "${typeName}"`);
+	const type = typeName;
+	const propertytype = optionalString(obj, "propertytype", source, path);
+	const valuePath = joinPath(path, "value");
+	let value;
+	switch (type) {
+		case "string":
+		case "color":
+		case "file":
+			value = expectString(obj.value, source, valuePath);
+			break;
+		case "int":
+		case "float":
+		case "object":
+			value = expectNumber(obj.value, source, valuePath);
+			break;
+		case "bool":
+			value = expectBoolean(obj.value, source, valuePath);
+			break;
+		case "class": value = validateTiledClassPropertyValue(obj.value, source, valuePath);
+	}
+	return {
+		name,
+		type,
+		propertytype,
+		value
+	};
+};
+const validateTiledPropertiesArray = (value, source, path) => optionalMapArray(value, source, path, (item, itemPath) => validateTiledPropertyData(item, source, itemPath));
+const validateTiledPointData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	return {
+		x: expectNumber(obj.x, source, joinPath(path, "x")),
+		y: expectNumber(obj.y, source, joinPath(path, "y"))
+	};
+};
+const validateTiledPointArray = (value, source, path) => mapArray(value, source, path, (item, itemPath) => validateTiledPointData(item, source, itemPath));
 /** @internal */
-function validateTiledAnimationFrameData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    return {
-        tileid: expectNonNegativeInteger(obj.tileid, source, joinPath(path, 'tileid')),
-        duration: expectNonNegativeInteger(obj.duration, source, joinPath(path, 'duration')),
-    };
-}
-// ── Text objects ─────────────────────────────────────────────────────────────
-const HALIGN_VALUES = ['center', 'right', 'justify', 'left'];
-const VALIGN_VALUES = ['center', 'bottom', 'top'];
-function validateTiledTextData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    const text = expectString(obj.text, source, joinPath(path, 'text'));
-    let halign;
-    if (obj.halign !== undefined) {
-        const value = expectString(obj.halign, source, joinPath(path, 'halign'));
-        if (!HALIGN_VALUES.includes(value)) {
-            throw new TiledFormatError(source, joinPath(path, 'halign'), `unknown horizontal alignment "${value}"`);
-        }
-        halign = value;
-    }
-    let valign;
-    if (obj.valign !== undefined) {
-        const value = expectString(obj.valign, source, joinPath(path, 'valign'));
-        if (!VALIGN_VALUES.includes(value)) {
-            throw new TiledFormatError(source, joinPath(path, 'valign'), `unknown vertical alignment "${value}"`);
-        }
-        valign = value;
-    }
-    return {
-        text,
-        bold: optionalBoolean(obj, 'bold', source, path),
-        color: optionalString(obj, 'color', source, path),
-        fontfamily: optionalString(obj, 'fontfamily', source, path),
-        halign,
-        italic: optionalBoolean(obj, 'italic', source, path),
-        kerning: optionalBoolean(obj, 'kerning', source, path),
-        pixelsize: optionalNonNegativeInteger(obj, 'pixelsize', source, path),
-        strikeout: optionalBoolean(obj, 'strikeout', source, path),
-        underline: optionalBoolean(obj, 'underline', source, path),
-        valign,
-        wrap: optionalBoolean(obj, 'wrap', source, path),
-    };
-}
-// ── Objects ──────────────────────────────────────────────────────────────────
+const validateTiledAnimationFrameData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	return {
+		tileid: expectNonNegativeInteger(obj.tileid, source, joinPath(path, "tileid")),
+		duration: expectNonNegativeInteger(obj.duration, source, joinPath(path, "duration"))
+	};
+};
+const HALIGN_VALUES = [
+	"center",
+	"right",
+	"justify",
+	"left"
+];
+const VALIGN_VALUES = [
+	"center",
+	"bottom",
+	"top"
+];
+const validateTiledTextData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	const text = expectString(obj.text, source, joinPath(path, "text"));
+	let halign;
+	if (obj.halign !== void 0) {
+		const value = expectString(obj.halign, source, joinPath(path, "halign"));
+		if (!HALIGN_VALUES.includes(value)) throw new TiledFormatError(source, joinPath(path, "halign"), `unknown horizontal alignment "${value}"`);
+		halign = value;
+	}
+	let valign;
+	if (obj.valign !== void 0) {
+		const value = expectString(obj.valign, source, joinPath(path, "valign"));
+		if (!VALIGN_VALUES.includes(value)) throw new TiledFormatError(source, joinPath(path, "valign"), `unknown vertical alignment "${value}"`);
+		valign = value;
+	}
+	return {
+		text,
+		bold: optionalBoolean(obj, "bold", source, path),
+		color: optionalString(obj, "color", source, path),
+		fontfamily: optionalString(obj, "fontfamily", source, path),
+		halign,
+		italic: optionalBoolean(obj, "italic", source, path),
+		kerning: optionalBoolean(obj, "kerning", source, path),
+		pixelsize: optionalNonNegativeInteger(obj, "pixelsize", source, path),
+		strikeout: optionalBoolean(obj, "strikeout", source, path),
+		underline: optionalBoolean(obj, "underline", source, path),
+		valign,
+		wrap: optionalBoolean(obj, "wrap", source, path)
+	};
+};
 /** @internal */
-function validateTiledObjectData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    return {
-        id: expectNonNegativeInteger(obj.id, source, joinPath(path, 'id')),
-        name: expectString(obj.name, source, joinPath(path, 'name')),
-        type: expectString(obj.type, source, joinPath(path, 'type')),
-        x: expectNumber(obj.x, source, joinPath(path, 'x')),
-        y: expectNumber(obj.y, source, joinPath(path, 'y')),
-        width: expectNumber(obj.width, source, joinPath(path, 'width')),
-        height: expectNumber(obj.height, source, joinPath(path, 'height')),
-        rotation: expectNumber(obj.rotation, source, joinPath(path, 'rotation')),
-        visible: expectBoolean(obj.visible, source, joinPath(path, 'visible')),
-        gid: optionalNonNegativeInteger(obj, 'gid', source, path),
-        point: optionalBoolean(obj, 'point', source, path),
-        ellipse: optionalBoolean(obj, 'ellipse', source, path),
-        polygon: obj.polygon === undefined ? undefined : validateTiledPointArray(obj.polygon, source, joinPath(path, 'polygon')),
-        polyline: obj.polyline === undefined ? undefined : validateTiledPointArray(obj.polyline, source, joinPath(path, 'polyline')),
-        text: obj.text === undefined ? undefined : validateTiledTextData(obj.text, source, joinPath(path, 'text')),
-        template: optionalString(obj, 'template', source, path),
-        properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, 'properties')),
-    };
-}
-// ── Layers ───────────────────────────────────────────────────────────────────
-const LAYER_TYPES = ['tilelayer', 'objectgroup', 'imagelayer', 'group'];
-const SUPPORTED_TILE_LAYER_ENCODINGS = new Set(['csv']);
-const DRAW_ORDERS = ['topdown', 'index'];
-function validateTiledLayerBase(obj, source, path) {
-    return {
-        id: expectNonNegativeInteger(obj.id, source, joinPath(path, 'id')),
-        name: expectString(obj.name, source, joinPath(path, 'name')),
-        class: optionalString(obj, 'class', source, path),
-        visible: expectBoolean(obj.visible, source, joinPath(path, 'visible')),
-        opacity: expectNumber(obj.opacity, source, joinPath(path, 'opacity')),
-        x: expectNumber(obj.x, source, joinPath(path, 'x')),
-        y: expectNumber(obj.y, source, joinPath(path, 'y')),
-        offsetx: optionalNumber(obj, 'offsetx', source, path),
-        offsety: optionalNumber(obj, 'offsety', source, path),
-        parallaxx: optionalNumber(obj, 'parallaxx', source, path),
-        parallaxy: optionalNumber(obj, 'parallaxy', source, path),
-        tintcolor: optionalString(obj, 'tintcolor', source, path),
-        properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, 'properties')),
-    };
-}
-function validateTiledGidArray(value, source, path) {
-    return mapArray(value, source, path, (item, itemPath) => expectNonNegativeInteger(item, source, itemPath));
-}
-function validateTiledChunkData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    return {
-        x: expectInteger(obj.x, source, joinPath(path, 'x')),
-        y: expectInteger(obj.y, source, joinPath(path, 'y')),
-        width: expectPositiveInteger(obj.width, source, joinPath(path, 'width')),
-        height: expectPositiveInteger(obj.height, source, joinPath(path, 'height')),
-        data: validateTiledGidArray(obj.data, source, joinPath(path, 'data')),
-    };
-}
-function validateTiledTileLayerData(obj, base, source, path) {
-    // Validation runs AFTER the async decode pass (`decodeLayerData.ts`), which
-    // turns base64/gzip/zlib `data` into a plain GID array and strips these
-    // markers. Reaching here with them still set means the data was not decoded
-    // (e.g. validate was called directly) — reject rather than mis-parse.
-    if (obj.compression !== undefined) {
-        throw new TiledFormatError(source, joinPath(path, 'compression'), `compressed tile layer data is not supported (compression: ${JSON.stringify(obj.compression)})`);
-    }
-    const encoding = obj.encoding;
-    if (encoding !== undefined && !(typeof encoding === 'string' && SUPPORTED_TILE_LAYER_ENCODINGS.has(encoding))) {
-        throw new TiledFormatError(source, joinPath(path, 'encoding'), `unsupported tile layer encoding ${JSON.stringify(encoding)} (only plain CSV/array data is supported)`);
-    }
-    const width = expectNonNegativeInteger(obj.width, source, joinPath(path, 'width'));
-    const height = expectNonNegativeInteger(obj.height, source, joinPath(path, 'height'));
-    const hasData = obj.data !== undefined;
-    const hasChunks = obj.chunks !== undefined;
-    if (hasData === hasChunks) {
-        throw new TiledFormatError(source, path, hasData ? 'tile layer has both "data" and "chunks"' : 'tile layer has neither "data" nor "chunks"');
-    }
-    return {
-        ...base,
-        type: 'tilelayer',
-        width,
-        height,
-        data: hasData ? validateTiledGidArray(obj.data, source, joinPath(path, 'data')) : undefined,
-        chunks: hasChunks ? mapArray(obj.chunks, source, joinPath(path, 'chunks'), (item, itemPath) => validateTiledChunkData(item, source, itemPath)) : undefined,
-    };
-}
-function validateTiledObjectLayerData(obj, base, source, path) {
-    let draworder;
-    if (obj.draworder !== undefined) {
-        const value = expectString(obj.draworder, source, joinPath(path, 'draworder'));
-        if (!DRAW_ORDERS.includes(value)) {
-            throw new TiledFormatError(source, joinPath(path, 'draworder'), `unknown draw order "${value}"`);
-        }
-        draworder = value;
-    }
-    return {
-        ...base,
-        type: 'objectgroup',
-        draworder,
-        objects: mapArray(obj.objects, source, joinPath(path, 'objects'), (item, itemPath) => validateTiledObjectData(item, source, itemPath)),
-    };
-}
-function validateTiledImageLayerData(obj, base, source, path) {
-    return {
-        ...base,
-        type: 'imagelayer',
-        image: obj.image === undefined ? '' : expectString(obj.image, source, joinPath(path, 'image')),
-        repeatx: optionalBoolean(obj, 'repeatx', source, path),
-        repeaty: optionalBoolean(obj, 'repeaty', source, path),
-    };
-}
-function validateTiledGroupLayerData(obj, base, source, path) {
-    return {
-        ...base,
-        type: 'group',
-        layers: mapArray(obj.layers, source, joinPath(path, 'layers'), (item, itemPath) => validateTiledLayerData(item, source, itemPath)),
-    };
-}
+const validateTiledObjectData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	return {
+		id: expectNonNegativeInteger(obj.id, source, joinPath(path, "id")),
+		name: expectString(obj.name, source, joinPath(path, "name")),
+		type: optionalString(obj, "type", source, path) ?? "",
+		class: optionalString(obj, "class", source, path),
+		x: expectNumber(obj.x, source, joinPath(path, "x")),
+		y: expectNumber(obj.y, source, joinPath(path, "y")),
+		width: expectNumber(obj.width, source, joinPath(path, "width")),
+		height: expectNumber(obj.height, source, joinPath(path, "height")),
+		rotation: expectNumber(obj.rotation, source, joinPath(path, "rotation")),
+		visible: expectBoolean(obj.visible, source, joinPath(path, "visible")),
+		gid: optionalNonNegativeInteger(obj, "gid", source, path),
+		point: optionalBoolean(obj, "point", source, path),
+		ellipse: optionalBoolean(obj, "ellipse", source, path),
+		polygon: obj.polygon === void 0 ? void 0 : validateTiledPointArray(obj.polygon, source, joinPath(path, "polygon")),
+		polyline: obj.polyline === void 0 ? void 0 : validateTiledPointArray(obj.polyline, source, joinPath(path, "polyline")),
+		text: obj.text === void 0 ? void 0 : validateTiledTextData(obj.text, source, joinPath(path, "text")),
+		template: optionalString(obj, "template", source, path),
+		properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, "properties"))
+	};
+};
+const LAYER_TYPES = [
+	"tilelayer",
+	"objectgroup",
+	"imagelayer",
+	"group"
+];
+const SUPPORTED_TILE_LAYER_ENCODINGS = /* @__PURE__ */ new Set(["csv"]);
+const DRAW_ORDERS = ["topdown", "index"];
+const validateTiledLayerBase = (obj, source, path) => ({
+	id: expectNonNegativeInteger(obj.id, source, joinPath(path, "id")),
+	name: expectString(obj.name, source, joinPath(path, "name")),
+	class: optionalString(obj, "class", source, path),
+	visible: expectBoolean(obj.visible, source, joinPath(path, "visible")),
+	opacity: expectNumber(obj.opacity, source, joinPath(path, "opacity")),
+	x: expectNumber(obj.x, source, joinPath(path, "x")),
+	y: expectNumber(obj.y, source, joinPath(path, "y")),
+	offsetx: optionalNumber(obj, "offsetx", source, path),
+	offsety: optionalNumber(obj, "offsety", source, path),
+	parallaxx: optionalNumber(obj, "parallaxx", source, path),
+	parallaxy: optionalNumber(obj, "parallaxy", source, path),
+	tintcolor: optionalString(obj, "tintcolor", source, path),
+	properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, "properties"))
+});
+const validateTiledGidArray = (value, source, path) => mapArray(value, source, path, (item, itemPath) => expectNonNegativeInteger(item, source, itemPath));
+const validateTiledChunkData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	return {
+		x: expectInteger(obj.x, source, joinPath(path, "x")),
+		y: expectInteger(obj.y, source, joinPath(path, "y")),
+		width: expectPositiveInteger(obj.width, source, joinPath(path, "width")),
+		height: expectPositiveInteger(obj.height, source, joinPath(path, "height")),
+		data: validateTiledGidArray(obj.data, source, joinPath(path, "data"))
+	};
+};
+const validateTiledTileLayerData = (obj, base, source, path) => {
+	if (obj.compression !== void 0) throw new TiledFormatError(source, joinPath(path, "compression"), `compressed tile layer data is not supported (compression: ${JSON.stringify(obj.compression)})`);
+	const encoding = obj.encoding;
+	if (encoding !== void 0 && !(typeof encoding === "string" && SUPPORTED_TILE_LAYER_ENCODINGS.has(encoding))) throw new TiledFormatError(source, joinPath(path, "encoding"), `unsupported tile layer encoding ${JSON.stringify(encoding)} (only plain CSV/array data is supported)`);
+	const width = expectNonNegativeInteger(obj.width, source, joinPath(path, "width"));
+	const height = expectNonNegativeInteger(obj.height, source, joinPath(path, "height"));
+	const hasData = obj.data !== void 0;
+	const hasChunks = obj.chunks !== void 0;
+	if (hasData === hasChunks) throw new TiledFormatError(source, path, hasData ? "tile layer has both \"data\" and \"chunks\"" : "tile layer has neither \"data\" nor \"chunks\"");
+	return {
+		...base,
+		type: "tilelayer",
+		width,
+		height,
+		data: hasData ? validateTiledGidArray(obj.data, source, joinPath(path, "data")) : void 0,
+		chunks: hasChunks ? mapArray(obj.chunks, source, joinPath(path, "chunks"), (item, itemPath) => validateTiledChunkData(item, source, itemPath)) : void 0
+	};
+};
+const validateTiledObjectLayerData = (obj, base, source, path) => {
+	let draworder;
+	if (obj.draworder !== void 0) {
+		const value = expectString(obj.draworder, source, joinPath(path, "draworder"));
+		if (!DRAW_ORDERS.includes(value)) throw new TiledFormatError(source, joinPath(path, "draworder"), `unknown draw order "${value}"`);
+		draworder = value;
+	}
+	return {
+		...base,
+		type: "objectgroup",
+		draworder,
+		objects: mapArray(obj.objects, source, joinPath(path, "objects"), (item, itemPath) => validateTiledObjectData(item, source, itemPath))
+	};
+};
+const validateTiledImageLayerData = (obj, base, source, path) => ({
+	...base,
+	type: "imagelayer",
+	image: obj.image === void 0 ? "" : expectString(obj.image, source, joinPath(path, "image")),
+	repeatx: optionalBoolean(obj, "repeatx", source, path),
+	repeaty: optionalBoolean(obj, "repeaty", source, path)
+});
+const validateTiledGroupLayerData = (obj, base, source, path) => ({
+	...base,
+	type: "group",
+	layers: mapArray(obj.layers, source, joinPath(path, "layers"), (item, itemPath) => validateTiledLayerData(item, source, itemPath))
+});
 /** @internal */
-function validateTiledLayerData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    const type = expectString(obj.type, source, joinPath(path, 'type'));
-    const base = validateTiledLayerBase(obj, source, path);
-    switch (type) {
-        case 'tilelayer':
-            return validateTiledTileLayerData(obj, base, source, path);
-        case 'objectgroup':
-            return validateTiledObjectLayerData(obj, base, source, path);
-        case 'imagelayer':
-            return validateTiledImageLayerData(obj, base, source, path);
-        case 'group':
-            return validateTiledGroupLayerData(obj, base, source, path);
-        default: {
-            const known = LAYER_TYPES;
-            throw new TiledFormatError(source, joinPath(path, 'type'), `unknown layer type "${type}" (expected one of ${known.join(', ')})`);
-        }
-    }
-}
+const validateTiledLayerData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	const type = expectString(obj.type, source, joinPath(path, "type"));
+	const base = validateTiledLayerBase(obj, source, path);
+	switch (type) {
+		case "tilelayer": return validateTiledTileLayerData(obj, base, source, path);
+		case "objectgroup": return validateTiledObjectLayerData(obj, base, source, path);
+		case "imagelayer": return validateTiledImageLayerData(obj, base, source, path);
+		case "group": return validateTiledGroupLayerData(obj, base, source, path);
+		default: {
+			const known = LAYER_TYPES;
+			throw new TiledFormatError(source, joinPath(path, "type"), `unknown layer type "${type}" (expected one of ${known.join(", ")})`);
+		}
+	}
+};
 /**
- * Walks a layer tree and ensures every tile layer's `data`/`chunks` choice
- * matches the map's `infinite` flag. Tiled itself is consistent across an
- * entire map; a mismatch indicates a hand-edited or corrupt file.
- * @internal
- */
-function checkTiledLayerInfiniteConsistency(layers, infinite, source, path) {
-    for (let i = 0; i < layers.length; i++) {
-        const layer = layers[i];
-        if (layer === undefined)
-            continue;
-        const layerPath = joinPath(path, i);
-        if (layer.type === 'tilelayer') {
-            const hasChunks = layer.chunks !== undefined;
-            if (hasChunks !== infinite) {
-                throw new TiledFormatError(source, layerPath, infinite ? 'tile layer is missing "chunks" on an infinite map' : 'tile layer has "chunks" on a finite map (expected "data")');
-            }
-        }
-        else if (layer.type === 'group') {
-            checkTiledLayerInfiniteConsistency(layer.layers, infinite, source, joinPath(layerPath, 'layers'));
-        }
-    }
-}
-// ── Tile definitions ─────────────────────────────────────────────────────────
+* Walks a layer tree and ensures every tile layer's `data`/`chunks` choice
+* matches the map's `infinite` flag. Tiled itself is consistent across an
+* entire map; a mismatch indicates a hand-edited or corrupt file.
+* @internal
+*/
+const checkTiledLayerInfiniteConsistency = (layers, infinite, source, path) => {
+	for (let i = 0; i < layers.length; i++) {
+		const layer = layers[i];
+		if (layer === void 0) continue;
+		const layerPath = joinPath(path, i);
+		if (layer.type === "tilelayer") {
+			if (layer.chunks !== void 0 !== infinite) throw new TiledFormatError(source, layerPath, infinite ? "tile layer is missing \"chunks\" on an infinite map" : "tile layer has \"chunks\" on a finite map (expected \"data\")");
+		} else if (layer.type === "group") checkTiledLayerInfiniteConsistency(layer.layers, infinite, source, joinPath(layerPath, "layers"));
+	}
+};
 /** @internal */
-function validateTiledTileData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    let objectgroup;
-    if (obj.objectgroup !== undefined) {
-        const objectgroupPath = joinPath(path, 'objectgroup');
-        const layer = validateTiledLayerData(obj.objectgroup, source, objectgroupPath);
-        if (layer.type !== 'objectgroup') {
-            throw new TiledFormatError(source, objectgroupPath, `expected an "objectgroup" layer, got "${layer.type}"`);
-        }
-        objectgroup = layer;
-    }
-    return {
-        id: expectNonNegativeInteger(obj.id, source, joinPath(path, 'id')),
-        type: optionalString(obj, 'type', source, path),
-        properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, 'properties')),
-        animation: optionalMapArray(obj.animation, source, joinPath(path, 'animation'), (item, itemPath) => validateTiledAnimationFrameData(item, source, itemPath)),
-        objectgroup,
-        image: optionalString(obj, 'image', source, path),
-        imagewidth: optionalNonNegativeInteger(obj, 'imagewidth', source, path),
-        imageheight: optionalNonNegativeInteger(obj, 'imageheight', source, path),
-    };
-}
-// ── Wangsets ─────────────────────────────────────────────────────────────────
-function validateTiledWangColorData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    return {
-        name: expectString(obj.name, source, joinPath(path, 'name')),
-        color: expectString(obj.color, source, joinPath(path, 'color')),
-        tile: expectInteger(obj.tile, source, joinPath(path, 'tile')),
-        probability: expectNumber(obj.probability, source, joinPath(path, 'probability')),
-    };
-}
-function validateTiledWangTileData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    const tileid = expectNonNegativeInteger(obj.tileid, source, joinPath(path, 'tileid'));
-    const wangid = mapArray(obj.wangid, source, joinPath(path, 'wangid'), (item, itemPath) => expectNonNegativeInteger(item, source, itemPath));
-    return { tileid, wangid };
-}
-function validateTiledWangSetData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    return {
-        name: expectString(obj.name, source, joinPath(path, 'name')),
-        // type is accepted as any string — unknown values are treated as-is per spec
-        type: expectString(obj.type, source, joinPath(path, 'type')),
-        tile: expectInteger(obj.tile, source, joinPath(path, 'tile')),
-        colors: mapArray(obj.colors, source, joinPath(path, 'colors'), (item, itemPath) => validateTiledWangColorData(item, source, itemPath)),
-        wangtiles: mapArray(obj.wangtiles, source, joinPath(path, 'wangtiles'), (item, itemPath) => validateTiledWangTileData(item, source, itemPath)),
-        properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, 'properties')),
-    };
-}
-function validateTiledWangSets(value, source, path) {
-    return optionalMapArray(value, source, path, (item, itemPath) => validateTiledWangSetData(item, source, itemPath));
-}
-// ── Tilesets ─────────────────────────────────────────────────────────────────
-function validateTiledVersion(value, source, path) {
-    if (typeof value !== 'string' && typeof value !== 'number') {
-        throw new TiledFormatError(source, path, `expected a string or number, got ${describeValue(value)}`);
-    }
-    return value;
-}
+const validateTiledTileData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	let objectgroup;
+	if (obj.objectgroup !== void 0) {
+		const objectgroupPath = joinPath(path, "objectgroup");
+		const layer = validateTiledLayerData(obj.objectgroup, source, objectgroupPath);
+		if (layer.type !== "objectgroup") throw new TiledFormatError(source, objectgroupPath, `expected an "objectgroup" layer, got "${layer.type}"`);
+		objectgroup = layer;
+	}
+	return {
+		id: expectNonNegativeInteger(obj.id, source, joinPath(path, "id")),
+		type: optionalString(obj, "type", source, path),
+		properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, "properties")),
+		animation: optionalMapArray(obj.animation, source, joinPath(path, "animation"), (item, itemPath) => validateTiledAnimationFrameData(item, source, itemPath)),
+		objectgroup,
+		image: optionalString(obj, "image", source, path),
+		imagewidth: optionalNonNegativeInteger(obj, "imagewidth", source, path),
+		imageheight: optionalNonNegativeInteger(obj, "imageheight", source, path)
+	};
+};
+const validateTiledWangColorData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	return {
+		name: expectString(obj.name, source, joinPath(path, "name")),
+		color: expectString(obj.color, source, joinPath(path, "color")),
+		tile: expectInteger(obj.tile, source, joinPath(path, "tile")),
+		probability: expectNumber(obj.probability, source, joinPath(path, "probability"))
+	};
+};
+const validateTiledWangTileData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	return {
+		tileid: expectNonNegativeInteger(obj.tileid, source, joinPath(path, "tileid")),
+		wangid: mapArray(obj.wangid, source, joinPath(path, "wangid"), (item, itemPath) => expectNonNegativeInteger(item, source, itemPath))
+	};
+};
+const validateTiledWangSetData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	return {
+		name: expectString(obj.name, source, joinPath(path, "name")),
+		type: expectString(obj.type, source, joinPath(path, "type")),
+		tile: expectInteger(obj.tile, source, joinPath(path, "tile")),
+		colors: mapArray(obj.colors, source, joinPath(path, "colors"), (item, itemPath) => validateTiledWangColorData(item, source, itemPath)),
+		wangtiles: mapArray(obj.wangtiles, source, joinPath(path, "wangtiles"), (item, itemPath) => validateTiledWangTileData(item, source, itemPath)),
+		properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, "properties"))
+	};
+};
+const validateTiledWangSets = (value, source, path) => optionalMapArray(value, source, path, (item, itemPath) => validateTiledWangSetData(item, source, itemPath));
+const validateTiledVersion = (value, source, path) => {
+	if (typeof value !== "string" && typeof value !== "number") throw new TiledFormatError(source, path, `expected a string or number, got ${describeValue(value)}`);
+	return value;
+};
+const validateTiledObjectAlignment = (obj, source, path) => {
+	const value = obj.objectalignment;
+	if (value === void 0) return void 0;
+	const alignmentPath = joinPath(path, "objectalignment");
+	const name = expectString(value, source, alignmentPath);
+	if (!TILED_OBJECT_ALIGNMENTS.includes(name)) throw new TiledFormatError(source, alignmentPath, `unknown object alignment "${name}" (expected one of ${TILED_OBJECT_ALIGNMENTS.join(", ")})`);
+	return name;
+};
 /** @internal */
-function validateTiledTilesetData(obj, source, path) {
-    return {
-        name: expectString(obj.name, source, joinPath(path, 'name')),
-        class: optionalString(obj, 'class', source, path),
-        tilewidth: expectPositiveInteger(obj.tilewidth, source, joinPath(path, 'tilewidth')),
-        tileheight: expectPositiveInteger(obj.tileheight, source, joinPath(path, 'tileheight')),
-        tilecount: expectNonNegativeInteger(obj.tilecount, source, joinPath(path, 'tilecount')),
-        columns: expectNonNegativeInteger(obj.columns, source, joinPath(path, 'columns')),
-        spacing: optionalNonNegativeInteger(obj, 'spacing', source, path),
-        margin: optionalNonNegativeInteger(obj, 'margin', source, path),
-        image: optionalString(obj, 'image', source, path),
-        imagewidth: optionalNonNegativeInteger(obj, 'imagewidth', source, path),
-        imageheight: optionalNonNegativeInteger(obj, 'imageheight', source, path),
-        tileoffset: obj.tileoffset === undefined ? undefined : validateTiledPointData(obj.tileoffset, source, joinPath(path, 'tileoffset')),
-        objectalignment: optionalString(obj, 'objectalignment', source, path),
-        tiles: optionalMapArray(obj.tiles, source, joinPath(path, 'tiles'), (item, itemPath) => validateTiledTileData(item, source, itemPath)),
-        wangsets: validateTiledWangSets(obj.wangsets, source, joinPath(path, 'wangsets')),
-        properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, 'properties')),
-        tiledversion: optionalString(obj, 'tiledversion', source, path),
-        version: obj.version === undefined ? undefined : validateTiledVersion(obj.version, source, joinPath(path, 'version')),
-    };
-}
+const validateTiledTilesetData = (obj, source, path) => ({
+	name: expectString(obj.name, source, joinPath(path, "name")),
+	class: optionalString(obj, "class", source, path),
+	tilewidth: expectPositiveInteger(obj.tilewidth, source, joinPath(path, "tilewidth")),
+	tileheight: expectPositiveInteger(obj.tileheight, source, joinPath(path, "tileheight")),
+	tilecount: expectNonNegativeInteger(obj.tilecount, source, joinPath(path, "tilecount")),
+	columns: expectNonNegativeInteger(obj.columns, source, joinPath(path, "columns")),
+	spacing: optionalNonNegativeInteger(obj, "spacing", source, path),
+	margin: optionalNonNegativeInteger(obj, "margin", source, path),
+	image: optionalString(obj, "image", source, path),
+	imagewidth: optionalNonNegativeInteger(obj, "imagewidth", source, path),
+	imageheight: optionalNonNegativeInteger(obj, "imageheight", source, path),
+	tileoffset: obj.tileoffset === void 0 ? void 0 : validateTiledPointData(obj.tileoffset, source, joinPath(path, "tileoffset")),
+	objectalignment: validateTiledObjectAlignment(obj, source, path),
+	tiles: optionalMapArray(obj.tiles, source, joinPath(path, "tiles"), (item, itemPath) => validateTiledTileData(item, source, itemPath)),
+	wangsets: validateTiledWangSets(obj.wangsets, source, joinPath(path, "wangsets")),
+	properties: validateTiledPropertiesArray(obj.properties, source, joinPath(path, "properties")),
+	tiledversion: optionalString(obj, "tiledversion", source, path),
+	version: obj.version === void 0 ? void 0 : validateTiledVersion(obj.version, source, joinPath(path, "version"))
+});
 /**
- * Validates one entry of a map's `tilesets` array: either `{ firstgid,
- * source }` (external `.tsj`) or `{ firstgid, ...embedded tileset fields }`.
- * @internal
- */
-function validateTiledTilesetRefData(raw, source, path) {
-    const obj = expectObject(raw, source, path);
-    const firstgid = expectPositiveInteger(obj.firstgid, source, joinPath(path, 'firstgid'));
-    if ('source' in obj) {
-        return { firstgid, source: expectString(obj.source, source, joinPath(path, 'source')) };
-    }
-    return { ...validateTiledTilesetData(obj, source, path), firstgid };
-}
-// ── Map ──────────────────────────────────────────────────────────────────────
-const ORIENTATIONS = ['orthogonal', 'isometric', 'staggered', 'hexagonal'];
-const RENDER_ORDERS = ['right-down', 'right-up', 'left-down', 'left-up'];
+* Validates one entry of a map's `tilesets` array: either `{ firstgid,
+* source }` (external `.tsj`) or `{ firstgid, ...embedded tileset fields }`.
+* @internal
+*/
+const validateTiledTilesetRefData = (raw, source, path) => {
+	const obj = expectObject(raw, source, path);
+	const firstgid = expectPositiveInteger(obj.firstgid, source, joinPath(path, "firstgid"));
+	if ("source" in obj) return {
+		firstgid,
+		source: expectString(obj.source, source, joinPath(path, "source"))
+	};
+	return {
+		...validateTiledTilesetData(obj, source, path),
+		firstgid
+	};
+};
+const ORIENTATIONS = [
+	"orthogonal",
+	"isometric",
+	"staggered",
+	"hexagonal"
+];
+const RENDER_ORDERS = [
+	"right-down",
+	"right-up",
+	"left-down",
+	"left-up"
+];
 /**
- * Validates the root of a `.tmj` file. Throws {@link TiledFormatError} on
- * any structural problem, including unsupported tile-layer encodings and
- * `infinite`/`data`/`chunks` inconsistencies.
- * @internal
- */
-function validateTiledMapData(raw, source) {
-    const obj = expectObject(raw, source, '');
-    const type = expectString(obj.type, source, 'type');
-    if (type !== 'map') {
-        throw new TiledFormatError(source, 'type', `expected "map", got "${type}"`);
-    }
-    const version = validateTiledVersion(obj.version, source, 'version');
-    const orientationValue = expectString(obj.orientation, source, 'orientation');
-    if (!ORIENTATIONS.includes(orientationValue)) {
-        throw new TiledFormatError(source, 'orientation', `unknown orientation "${orientationValue}" (expected one of ${ORIENTATIONS.join(', ')})`);
-    }
-    const orientation = orientationValue;
-    let renderorder;
-    if (obj.renderorder !== undefined) {
-        const value = expectString(obj.renderorder, source, 'renderorder');
-        if (!RENDER_ORDERS.includes(value)) {
-            throw new TiledFormatError(source, 'renderorder', `unknown render order "${value}" (expected one of ${RENDER_ORDERS.join(', ')})`);
-        }
-        renderorder = value;
-    }
-    const infinite = expectBoolean(obj.infinite, source, 'infinite');
-    const layers = mapArray(obj.layers, source, 'layers', (item, itemPath) => validateTiledLayerData(item, source, itemPath));
-    checkTiledLayerInfiniteConsistency(layers, infinite, source, 'layers');
-    return {
-        type: 'map',
-        version,
-        tiledversion: optionalString(obj, 'tiledversion', source, ''),
-        class: optionalString(obj, 'class', source, ''),
-        orientation,
-        renderorder,
-        width: expectNonNegativeInteger(obj.width, source, 'width'),
-        height: expectNonNegativeInteger(obj.height, source, 'height'),
-        tilewidth: expectPositiveInteger(obj.tilewidth, source, 'tilewidth'),
-        tileheight: expectPositiveInteger(obj.tileheight, source, 'tileheight'),
-        infinite,
-        compressionlevel: optionalInteger(obj, 'compressionlevel', source, ''),
-        nextlayerid: optionalNonNegativeInteger(obj, 'nextlayerid', source, ''),
-        nextobjectid: optionalNonNegativeInteger(obj, 'nextobjectid', source, ''),
-        backgroundcolor: optionalString(obj, 'backgroundcolor', source, ''),
-        layers,
-        tilesets: mapArray(obj.tilesets, source, 'tilesets', (item, itemPath) => validateTiledTilesetRefData(item, source, itemPath)),
-        properties: validateTiledPropertiesArray(obj.properties, source, 'properties'),
-    };
-}
+* Validates the root of a `.tmj` file. Throws {@link TiledFormatError} on
+* any structural problem, including unsupported tile-layer encodings and
+* `infinite`/`data`/`chunks` inconsistencies.
+* @internal
+*/
+const validateTiledMapData = (raw, source) => {
+	const obj = expectObject(raw, source, "");
+	const type = expectString(obj.type, source, "type");
+	if (type !== "map") throw new TiledFormatError(source, "type", `expected "map", got "${type}"`);
+	const version = validateTiledVersion(obj.version, source, "version");
+	const orientationValue = expectString(obj.orientation, source, "orientation");
+	if (!ORIENTATIONS.includes(orientationValue)) throw new TiledFormatError(source, "orientation", `unknown orientation "${orientationValue}" (expected one of ${ORIENTATIONS.join(", ")})`);
+	const orientation = orientationValue;
+	let renderorder;
+	if (obj.renderorder !== void 0) {
+		const value = expectString(obj.renderorder, source, "renderorder");
+		if (!RENDER_ORDERS.includes(value)) throw new TiledFormatError(source, "renderorder", `unknown render order "${value}" (expected one of ${RENDER_ORDERS.join(", ")})`);
+		renderorder = value;
+	}
+	const infinite = expectBoolean(obj.infinite, source, "infinite");
+	const layers = mapArray(obj.layers, source, "layers", (item, itemPath) => validateTiledLayerData(item, source, itemPath));
+	checkTiledLayerInfiniteConsistency(layers, infinite, source, "layers");
+	return {
+		type: "map",
+		version,
+		tiledversion: optionalString(obj, "tiledversion", source, ""),
+		class: optionalString(obj, "class", source, ""),
+		orientation,
+		renderorder,
+		width: expectNonNegativeInteger(obj.width, source, "width"),
+		height: expectNonNegativeInteger(obj.height, source, "height"),
+		tilewidth: expectPositiveInteger(obj.tilewidth, source, "tilewidth"),
+		tileheight: expectPositiveInteger(obj.tileheight, source, "tileheight"),
+		infinite,
+		compressionlevel: optionalInteger(obj, "compressionlevel", source, ""),
+		nextlayerid: optionalNonNegativeInteger(obj, "nextlayerid", source, ""),
+		nextobjectid: optionalNonNegativeInteger(obj, "nextobjectid", source, ""),
+		backgroundcolor: optionalString(obj, "backgroundcolor", source, ""),
+		layers,
+		tilesets: mapArray(obj.tilesets, source, "tilesets", (item, itemPath) => validateTiledTilesetRefData(item, source, itemPath)),
+		properties: validateTiledPropertiesArray(obj.properties, source, "properties")
+	};
+};
 /**
- * Validates a standalone `.tsj` tileset file's root object.
- * @internal
- */
-function validateTiledTilesetFileData(raw, source) {
-    return validateTiledTilesetData(expectObject(raw, source, ''), source, '');
-}
+* Validates a standalone `.tsj` tileset file's root object.
+* @internal
+*/
+const validateTiledTilesetFileData = (raw, source) => validateTiledTilesetData(expectObject(raw, source, ""), source, "");
 
+//#endregion
 export { TiledFormatError, checkTiledLayerInfiniteConsistency, validateTiledAnimationFrameData, validateTiledLayerData, validateTiledMapData, validateTiledObjectData, validateTiledPropertyData, validateTiledTileData, validateTiledTilesetData, validateTiledTilesetFileData, validateTiledTilesetRefData };
-//# sourceMappingURL=validate.js.map
+//# sourceMappingURL=validate.js.map