@codexo/exojs-tiled 0.15.3 → 0.16.0

package/dist/esm/tiledExtension.js

@@ -1,31 +1,29 @@
-import { tilemapExtension } from '@codexo/exojs-tilemap';
-import { tiledMapBinding } from './tiledMapBinding.js';
-import { tiledRuntimeMapBinding } from './tiledRuntimeMapBinding.js';
+import { tiledSourceType } from "./tiledSourceType.js";
+import { tileMapType } from "./tileMapType.js";
+import { tilemapExtension } from "@codexo/exojs-tilemap";
 
+//#region src/tiledExtension.ts
 /**
- * Default immutable Tiled extension descriptor.
- *
- * Registers two asset bindings:
- * - {@link tiledRuntimeMapBinding} — `loader.load(TileMap, 'world.tmj')` →
- *   returns a format-independent runtime {@link TileMap} (common case).
- * - {@link tiledMapBinding} — `loader.load(TiledMap, 'world.tmj')` →
- *   returns the raw parsed {@link TiledMap} source model (advanced/diagnostic).
- *
- * Depends on {@link tilemapExtension} so that snapshot construction always
- * materialises the generic tilemap runtime before the Tiled adapter.
- *
- * Use with `ApplicationOptions.extensions` or call
- * `import '@codexo/exojs-tiled/register'` for global auto-registration.
- */
+* Default immutable Tiled extension descriptor.
+*
+* Installs two asset types:
+* - {@link tileMapType} - `loader.load(tileMapType.asset('world.tmj'))` returns
+*   a format-independent runtime {@link TileMap} (common case).
+* - {@link tiledSourceType} - `loader.load(tiledSourceType.asset('world.tmj'))`
+*   returns the raw parsed {@link TiledMap} source model (advanced/diagnostic).
+*
+* Depends on {@link tilemapExtension} so that snapshot construction always
+* materialises the generic tilemap runtime before the Tiled adapter.
+*
+* Pass it to the application that should have it via
+* `ApplicationOptions.extensions`.
+*/
 const tiledExtension = Object.freeze({
-    id: '@codexo/exojs-tiled',
-    dependencies: [tilemapExtension],
-    // Localized erasure cast: typed bindings (Options=TiledLoadOptions) meet the
-    // untyped Extension.assets contract here. Runtime behavior is unaffected —
-    // materializeAssetBindings calls create() and bindAsset() correctly regardless
-    // of the erased Options type.
-    assets: [tiledRuntimeMapBinding, tiledMapBinding],
+	id: "@codexo/exojs-tiled",
+	dependencies: [tilemapExtension],
+	assets: [tileMapType, tiledSourceType]
 });
 
+//#endregion
 export { tiledExtension };
-//# sourceMappingURL=tiledExtension.js.map
+//# sourceMappingURL=tiledExtension.js.map

package/dist/esm/tiledExtension.js.map

@@ -1 +1 @@
-{"version":3,"file":"tiledExtension.js","sources":["../../../src/tiledExtension.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;AAcG;AACI,MAAM,cAAc,GAAc,MAAM,CAAC,MAAM,CAAC;AACrD,IAAA,EAAE,EAAE,qBAAqB;IACzB,YAAY,EAAE,CAAC,gBAAgB,CAAC;;;;;AAKhC,IAAA,MAAM,EAAE,CAAC,sBAAsB,EAAE,eAAe,CAA8B;AAC/E,CAAA;;;;"}
+{"version":3,"file":"tiledExtension.js","names":[],"sources":["../../src/tiledExtension.ts"],"sourcesContent":["import type { Extension } from '@codexo/exojs/extensions';\nimport { tilemapExtension } from '@codexo/exojs-tilemap';\n\nimport { tiledSourceType } from './tiledSourceType';\nimport { tileMapType } from './tileMapType';\n\n/**\n * Default immutable Tiled extension descriptor.\n *\n * Installs two asset types:\n * - {@link tileMapType} - `loader.load(tileMapType.asset('world.tmj'))` returns\n *   a format-independent runtime {@link TileMap} (common case).\n * - {@link tiledSourceType} - `loader.load(tiledSourceType.asset('world.tmj'))`\n *   returns the raw parsed {@link TiledMap} source model (advanced/diagnostic).\n *\n * Depends on {@link tilemapExtension} so that snapshot construction always\n * materialises the generic tilemap runtime before the Tiled adapter.\n *\n * Pass it to the application that should have it via\n * `ApplicationOptions.extensions`.\n */\nexport const tiledExtension: Extension = Object.freeze({\n  id: '@codexo/exojs-tiled',\n  dependencies: [tilemapExtension],\n  // Localized erasure cast: typed types (Options=TiledLoadOptions) meet the\n  // untyped Extension.assets contract here. Runtime behavior is unaffected.\n  assets: [tileMapType, tiledSourceType],\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAA4B,OAAO,OAAO;CACrD,IAAI;CACJ,cAAc,CAAC,gBAAgB;CAG/B,QAAQ,CAAC,aAAa,eAAe;AACvC,CAAC"}

package/dist/esm/tiledOptions.d.ts

@@ -9,7 +9,7 @@ export interface TiledLoadOptions {
      *
      * `.tmj`/`.tsj` paths are recognised by extension and need no hint. Provide
      * `format: 'tiled'` when loading Tiled map data from a generic `.json` path:
-     * `loader.load(TileMap, 'world.json', { format: 'tiled' })`. `'tiled'` is the
+     * `loader.load(Asset.type('tileMap', 'world.json', { format: 'tiled' }))`. `'tiled'` is the
      * only accepted value, so a foreign format (e.g. `'ldtk'`) is a compile error
      * rather than a silent runtime fall-through.
      *
@@ -23,9 +23,10 @@ export interface TiledLoadOptions {
  *
  * Tiled parsing is unconditionally strict: {@link validateTiledMapData} throws
  * a `TiledFormatError` on any malformed *known* field and silently preserves
- * unknown fields. There is intentionally no `strict` toggle — a permissive
+ * unknown fields. There is intentionally no `strict` toggle - a permissive
  * parse mode is a potential v0.14 follow-up, not part of v0.13.
  */
-export declare function resolveTiledOptions(options: TiledLoadOptions | undefined): {
-    format: 'tiled';
+export declare const resolveTiledOptions: (options: TiledLoadOptions | undefined) => {
+    format: "tiled";
 };
+//# sourceMappingURL=tiledOptions.d.ts.map

package/dist/esm/tiledOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiledOptions.d.ts","sourceRoot":"","sources":["../../src/tiledOptions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,gBAAgB,GAAG,SAAS,KAAG;IAAE,MAAM,EAAE,OAAO,CAAA;CAE3F,CAAC"}

package/dist/esm/tiledOptions.js

@@ -1,16 +1,14 @@
+//#region src/tiledOptions.ts
 /**
- * Applies defaults and returns a normalized options object.
- *
- * Tiled parsing is unconditionally strict: {@link validateTiledMapData} throws
- * a `TiledFormatError` on any malformed *known* field and silently preserves
- * unknown fields. There is intentionally no `strict` toggle — a permissive
- * parse mode is a potential v0.14 follow-up, not part of v0.13.
- */
-function resolveTiledOptions(options) {
-    return {
-        format: options?.format ?? 'tiled',
-    };
-}
+* Applies defaults and returns a normalized options object.
+*
+* Tiled parsing is unconditionally strict: {@link validateTiledMapData} throws
+* a `TiledFormatError` on any malformed *known* field and silently preserves
+* unknown fields. There is intentionally no `strict` toggle - a permissive
+* parse mode is a potential v0.14 follow-up, not part of v0.13.
+*/
+const resolveTiledOptions = (options) => ({ format: options?.format ?? "tiled" });
 
+//#endregion
 export { resolveTiledOptions };
-//# sourceMappingURL=tiledOptions.js.map
+//# sourceMappingURL=tiledOptions.js.map

package/dist/esm/tiledOptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"tiledOptions.js","sources":["../../../src/tiledOptions.ts"],"sourcesContent":[null],"names":[],"mappings":"AAqBA;;;;;;;AAOG;AACG,SAAU,mBAAmB,CAAC,OAAqC,EAAA;IACvE,OAAO;AACL,QAAA,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,OAAO;KACnC;AACH;;;;"}
+{"version":3,"file":"tiledOptions.js","names":[],"sources":["../../src/tiledOptions.ts"],"sourcesContent":["/**\n * Options accepted by both the runtime (`TileMap`) and source (`TiledMap`)\n * asset bindings when loading a Tiled map.\n * @advanced\n */\nexport interface TiledLoadOptions {\n  /**\n   * Explicit format hint for ambiguous file extensions.\n   *\n   * `.tmj`/`.tsj` paths are recognised by extension and need no hint. Provide\n   * `format: 'tiled'` when loading Tiled map data from a generic `.json` path:\n   * `loader.load(Asset.type('tileMap', 'world.json', { format: 'tiled' }))`. `'tiled'` is the\n   * only accepted value, so a foreign format (e.g. `'ldtk'`) is a compile error\n   * rather than a silent runtime fall-through.\n   *\n   * The hint participates in the asset identity key, so the same source loaded\n   * under different (future) formats resolves to distinct cache entries.\n   */\n  readonly format?: 'tiled';\n}\n\n/**\n * Applies defaults and returns a normalized options object.\n *\n * Tiled parsing is unconditionally strict: {@link validateTiledMapData} throws\n * a `TiledFormatError` on any malformed *known* field and silently preserves\n * unknown fields. There is intentionally no `strict` toggle - a permissive\n * parse mode is a potential v0.14 follow-up, not part of v0.13.\n */\nexport const resolveTiledOptions = (options: TiledLoadOptions | undefined): { format: 'tiled' } => ({\n  format: options?.format ?? 'tiled',\n});\n"],"mappings":";;;;;;;;;AA6BA,MAAa,uBAAuB,aAAgE,EAClG,QAAQ,SAAS,UAAU,QAC7B"}

package/dist/esm/tiledSourceType.d.ts

@@ -0,0 +1,24 @@
+import type { AssetFactory, AssetSourceCodec } from '@codexo/exojs';
+import { type AssetRequest, AssetType } from '@codexo/exojs';
+import type { TiledMapData } from './data';
+import { TiledMap } from './TiledMap';
+import { type TiledLoadOptions } from './tiledOptions';
+/**
+ * The raw parsed Tiled source model, for diagnostics and for tools that need
+ * the `.tmj` as authored.
+ *
+ * It claims no file suffixes: `.tmj` belongs to the runtime `tileMap` type,
+ * which is what a bare Tiled path should resolve to. The name is `tiledSource`
+ * rather than `tiledMap` because the runtime type next to it is `tileMap`, and
+ * two ids one letter apart resolve to the wrong type instead of failing.
+ */
+export declare class TiledSourceAssetType extends AssetType<TiledMapData, TiledMap, TiledLoadOptions, string> {
+    readonly id = "tiledSource";
+    readonly _token: typeof TiledMap;
+    readonly codec: AssetSourceCodec<TiledMapData, string>;
+    resourceIdentity({ options }: AssetRequest<TiledLoadOptions>): string;
+    createFactory(): AssetFactory<TiledMapData, TiledMap, TiledLoadOptions>;
+}
+/** The Tiled source-model asset type. Install it through `tiledExtension`. */
+export declare const tiledSourceType: TiledSourceAssetType;
+//# sourceMappingURL=tiledSourceType.d.ts.map

package/dist/esm/tiledSourceType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiledSourceType.d.ts","sourceRoot":"","sources":["../../src/tiledSourceType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,KAAK,YAAY,EAAE,SAAS,EAAmB,MAAM,eAAe,CAAC;AAE9E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAG3C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAM5E;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,SAAQ,SAAS,CAAC,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,CAAC;IACnG,SAAgB,EAAE,iBAAiB;IACnC,SAAyB,MAAM,kBAAY;IAI3C,SAAyB,KAAK,EAAE,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,CAYpE;IAEc,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE,YAAY,CAAC,gBAAgB,CAAC,GAAG,MAAM;IAI9E,aAAa,IAAI,YAAY,CAAC,YAAY,EAAE,QAAQ,EAAE,gBAAgB,CAAC;CAG/E;AAED,8EAA8E;AAC9E,eAAO,MAAM,eAAe,sBAA6B,CAAC"}

package/dist/esm/tiledSourceType.js

@@ -0,0 +1,44 @@
+import { validateTiledMapData } from "./validate.js";
+import { decodeTiledLayerData } from "./decodeLayerData.js";
+import { TiledMap } from "./TiledMap.js";
+import { loadTiledMap } from "./loadTiledMap.js";
+import { resolveTiledOptions } from "./tiledOptions.js";
+import { AssetType, jsonSourceCodec } from "@codexo/exojs";
+
+//#region src/tiledSourceType.ts
+/** The JSON codec, narrowed to the two acquisition halves this type reuses verbatim. */
+const jsonStringCodec = jsonSourceCodec;
+/**
+* The raw parsed Tiled source model, for diagnostics and for tools that need
+* the `.tmj` as authored.
+*
+* It claims no file suffixes: `.tmj` belongs to the runtime `tileMap` type,
+* which is what a bare Tiled path should resolve to. The name is `tiledSource`
+* rather than `tiledMap` because the runtime type next to it is `tileMap`, and
+* two ids one letter apart resolve to the wrong type instead of failing.
+*/
+var TiledSourceAssetType = class extends AssetType {
+	id = "tiledSource";
+	_token = TiledMap;
+	codec = {
+		fromResponse: (response, context) => jsonStringCodec.fromResponse(response, context),
+		fromBytes: (bytes, context) => jsonStringCodec.fromBytes(bytes, context),
+		async decode(stored, context) {
+			const raw = JSON.parse(stored);
+			await decodeTiledLayerData(raw, context.locator);
+			return validateTiledMapData(raw, context.locator);
+		}
+	};
+	resourceIdentity({ options }) {
+		return resolveTiledOptions(options).format;
+	}
+	createFactory() {
+		return { create: (source, context) => loadTiledMap(source, context) };
+	}
+};
+/** The Tiled source-model asset type. Install it through `tiledExtension`. */
+const tiledSourceType = new TiledSourceAssetType();
+
+//#endregion
+export { TiledSourceAssetType, tiledSourceType };
+//# sourceMappingURL=tiledSourceType.js.map

package/dist/esm/tiledSourceType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiledSourceType.js","names":[],"sources":["../../src/tiledSourceType.ts"],"sourcesContent":["import type { AssetFactory, AssetSourceCodec } from '@codexo/exojs';\nimport { type AssetRequest, AssetType, jsonSourceCodec } from '@codexo/exojs';\n\nimport type { TiledMapData } from './data';\nimport { decodeTiledLayerData } from './decodeLayerData';\nimport { loadTiledMap } from './loadTiledMap';\nimport { TiledMap } from './TiledMap';\nimport { resolveTiledOptions, type TiledLoadOptions } from './tiledOptions';\nimport { validateTiledMapData } from './validate';\n\n/** The JSON codec, narrowed to the two acquisition halves this type reuses verbatim. */\nconst jsonStringCodec = jsonSourceCodec as Required<AssetSourceCodec<unknown, string>>;\n\n/**\n * The raw parsed Tiled source model, for diagnostics and for tools that need\n * the `.tmj` as authored.\n *\n * It claims no file suffixes: `.tmj` belongs to the runtime `tileMap` type,\n * which is what a bare Tiled path should resolve to. The name is `tiledSource`\n * rather than `tiledMap` because the runtime type next to it is `tileMap`, and\n * two ids one letter apart resolve to the wrong type instead of failing.\n */\nexport class TiledSourceAssetType extends AssetType<TiledMapData, TiledMap, TiledLoadOptions, string> {\n  public readonly id = 'tiledSource';\n  public override readonly _token = TiledMap;\n  // Stored as the text that arrived; decoding is where the compressed layer\n  // payloads are expanded and the document is validated, so a cache hit is\n  // re-read exactly like a fresh download.\n  public override readonly codec: AssetSourceCodec<TiledMapData, string> = {\n    fromResponse: (response, context) => jsonStringCodec.fromResponse(response, context),\n    fromBytes: (bytes, context) => jsonStringCodec.fromBytes(bytes, context),\n    async decode(stored, context) {\n      const raw: unknown = JSON.parse(stored);\n\n      // Expand any base64/gzip/zlib tile-layer payload before validation, so the\n      // rest of the pipeline stays CSV-shaped and synchronous.\n      await decodeTiledLayerData(raw, context.locator);\n\n      return validateTiledMapData(raw, context.locator);\n    },\n  };\n\n  public override resourceIdentity({ options }: AssetRequest<TiledLoadOptions>): string {\n    return resolveTiledOptions(options).format;\n  }\n\n  public createFactory(): AssetFactory<TiledMapData, TiledMap, TiledLoadOptions> {\n    return { create: (source, context) => loadTiledMap(source, context) };\n  }\n}\n\n/** The Tiled source-model asset type. Install it through `tiledExtension`. */\nexport const tiledSourceType = new TiledSourceAssetType();\n"],"mappings":";;;;;;;;;AAWA,MAAM,kBAAkB;;;;;;;;;;AAWxB,IAAa,uBAAb,cAA0C,UAA4D;CACpG,AAAgB,KAAK;CACrB,AAAyB,SAAS;CAIlC,AAAyB,QAAgD;EACvE,eAAe,UAAU,YAAY,gBAAgB,aAAa,UAAU,OAAO;EACnF,YAAY,OAAO,YAAY,gBAAgB,UAAU,OAAO,OAAO;EACvE,MAAM,OAAO,QAAQ,SAAS;GAC5B,MAAM,MAAe,KAAK,MAAM,MAAM;GAItC,MAAM,qBAAqB,KAAK,QAAQ,OAAO;GAE/C,OAAO,qBAAqB,KAAK,QAAQ,OAAO;EAClD;CACF;CAEA,AAAgB,iBAAiB,EAAE,WAAmD;EACpF,OAAO,oBAAoB,OAAO,CAAC,CAAC;CACtC;CAEA,AAAO,gBAAwE;EAC7E,OAAO,EAAE,SAAS,QAAQ,YAAY,aAAa,QAAQ,OAAO,EAAE;CACtE;AACF;;AAGA,MAAa,kBAAkB,IAAI,qBAAqB"}

package/dist/esm/url.d.ts

@@ -15,4 +15,5 @@
  *
  * @internal
  */
-export declare function resolveTiledUrl(ref: string, base: string): string;
+export declare const resolveTiledUrl: (ref: string, base: string) => string;
+//# sourceMappingURL=url.d.ts.map

package/dist/esm/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../src/url.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,EAAE,MAAM,MAAM,KAAG,MAgB3D,CAAC"}

package/dist/esm/url.js

@@ -1,45 +1,34 @@
-// Relative-path resolution for Tiled source references (TMJ → TSJ, TMJ/TSJ →
-// image). Tiled stores every cross-file reference as a path relative to the
-// file that contains it; ExoJS asset sources are themselves often relative
-// (resolved against an asset root configured outside the Loader), so plain
-// `new URL(ref, base)` cannot be used directly when `base` has no scheme.
+//#region src/url.ts
 /** Matches references that are already absolute and must not be re-resolved: scheme:, protocol-relative `//`, root-relative `/`, and data/blob URLs. */
 const ABSOLUTE_REF = /^(?:[a-z][a-z\d+.-]*:|\/\/|\/)/i;
 /** Matches a base that is itself an absolute URL with a scheme. */
 const ABSOLUTE_BASE = /^[a-z][a-z\d+.-]*:/i;
 /** Synthetic origin used to borrow `URL`'s `../`/`./` collapsing for relative bases. */
-const SYNTHETIC_ORIGIN = 'https://exojs.invalid/';
+const SYNTHETIC_ORIGIN = "https://exojs.invalid/";
 /**
- * Resolves `ref` (a path read from a Tiled JSON file, e.g. a tileset
- * `source` or an `image`) relative to `base` (the resolved location of the
- * file that referenced it).
- *
- * - If `ref` is already absolute (has a scheme, is protocol- or
- *   root-relative, or is a `data:`/`blob:` URL), it is returned unchanged.
- * - If `base` is an absolute URL, standard `new URL(ref, base)` resolution
- *   is used.
- * - Otherwise both `ref` and `base` are relative ExoJS asset paths; `../`
- *   and `./` segments are collapsed via a synthetic origin and the result is
- *   returned relative again.
- *
- * Query strings and fragments on `ref` are preserved.
- *
- * @internal
- */
-function resolveTiledUrl(ref, base) {
-    if (ABSOLUTE_REF.test(ref)) {
-        return ref;
-    }
-    if (ABSOLUTE_BASE.test(base)) {
-        return new URL(ref, base).href;
-    }
-    const resolved = new URL(ref, SYNTHETIC_ORIGIN + base.replace(/^\/+/, ''));
-    const relative = resolved.href.slice(SYNTHETIC_ORIGIN.length);
-    // A root-relative base must produce a root-relative result again — dropping
-    // the leading slash would make the browser re-resolve the reference against
-    // the document base URL (e.g. `/site/assets/x.png` → `/site/site/assets/…`).
-    return base.startsWith('/') ? `/${relative}` : relative;
-}
+* Resolves `ref` (a path read from a Tiled JSON file, e.g. a tileset
+* `source` or an `image`) relative to `base` (the resolved location of the
+* file that referenced it).
+*
+* - If `ref` is already absolute (has a scheme, is protocol- or
+*   root-relative, or is a `data:`/`blob:` URL), it is returned unchanged.
+* - If `base` is an absolute URL, standard `new URL(ref, base)` resolution
+*   is used.
+* - Otherwise both `ref` and `base` are relative ExoJS asset paths; `../`
+*   and `./` segments are collapsed via a synthetic origin and the result is
+*   returned relative again.
+*
+* Query strings and fragments on `ref` are preserved.
+*
+* @internal
+*/
+const resolveTiledUrl = (ref, base) => {
+	if (ABSOLUTE_REF.test(ref)) return ref;
+	if (ABSOLUTE_BASE.test(base)) return new URL(ref, base).href;
+	const relative = new URL(ref, SYNTHETIC_ORIGIN + base.replace(/^\/+/, "")).href.slice(22);
+	return base.startsWith("/") ? `/${relative}` : relative;
+};
 
+//#endregion
 export { resolveTiledUrl };
-//# sourceMappingURL=url.js.map
+//# sourceMappingURL=url.js.map

package/dist/esm/url.js.map

@@ -1 +1 @@
-{"version":3,"file":"url.js","sources":["../../../src/url.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AAEA;AACA,MAAM,YAAY,GAAG,iCAAiC;AAEtD;AACA,MAAM,aAAa,GAAG,qBAAqB;AAE3C;AACA,MAAM,gBAAgB,GAAG,wBAAwB;AAEjD;;;;;;;;;;;;;;;;AAgBG;AACG,SAAU,eAAe,CAAC,GAAW,EAAE,IAAY,EAAA;AACvD,IAAA,IAAI,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;AAC1B,QAAA,OAAO,GAAG;IACZ;AAEA,IAAA,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QAC5B,OAAO,IAAI,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,IAAI;IAChC;AAEA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AAC1E,IAAA,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC;;;;AAK7D,IAAA,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAA,CAAA,EAAI,QAAQ,CAAA,CAAE,GAAG,QAAQ;AACzD;;;;"}
+{"version":3,"file":"url.js","names":[],"sources":["../../src/url.ts"],"sourcesContent":["// Relative-path resolution for Tiled source references (TMJ → TSJ, TMJ/TSJ →\n// image). Tiled stores every cross-file reference as a path relative to the\n// file that contains it; ExoJS asset sources are themselves often relative\n// (resolved against an asset root configured outside the Loader), so plain\n// `new URL(ref, base)` cannot be used directly when `base` has no scheme.\n\n/** Matches references that are already absolute and must not be re-resolved: scheme:, protocol-relative `//`, root-relative `/`, and data/blob URLs. */\nconst ABSOLUTE_REF = /^(?:[a-z][a-z\\d+.-]*:|\\/\\/|\\/)/i;\n\n/** Matches a base that is itself an absolute URL with a scheme. */\nconst ABSOLUTE_BASE = /^[a-z][a-z\\d+.-]*:/i;\n\n/** Synthetic origin used to borrow `URL`'s `../`/`./` collapsing for relative bases. */\nconst SYNTHETIC_ORIGIN = 'https://exojs.invalid/';\n\n/**\n * Resolves `ref` (a path read from a Tiled JSON file, e.g. a tileset\n * `source` or an `image`) relative to `base` (the resolved location of the\n * file that referenced it).\n *\n * - If `ref` is already absolute (has a scheme, is protocol- or\n *   root-relative, or is a `data:`/`blob:` URL), it is returned unchanged.\n * - If `base` is an absolute URL, standard `new URL(ref, base)` resolution\n *   is used.\n * - Otherwise both `ref` and `base` are relative ExoJS asset paths; `../`\n *   and `./` segments are collapsed via a synthetic origin and the result is\n *   returned relative again.\n *\n * Query strings and fragments on `ref` are preserved.\n *\n * @internal\n */\nexport const resolveTiledUrl = (ref: string, base: string): string => {\n  if (ABSOLUTE_REF.test(ref)) {\n    return ref;\n  }\n\n  if (ABSOLUTE_BASE.test(base)) {\n    return new URL(ref, base).href;\n  }\n\n  const resolved = new URL(ref, SYNTHETIC_ORIGIN + base.replace(/^\\/+/, ''));\n  const relative = resolved.href.slice(SYNTHETIC_ORIGIN.length);\n\n  // A root-relative base must produce a root-relative result again - dropping\n  // the leading slash would make the browser re-resolve the reference against\n  // the document base URL (e.g. `/site/assets/x.png` → `/site/site/assets/...`).\n  return base.startsWith('/') ? `/${relative}` : relative;\n};\n"],"mappings":";;AAOA,MAAM,eAAe;;AAGrB,MAAM,gBAAgB;;AAGtB,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;AAmBzB,MAAa,mBAAmB,KAAa,SAAyB;CACpE,IAAI,aAAa,KAAK,GAAG,GACvB,OAAO;CAGT,IAAI,cAAc,KAAK,IAAI,GACzB,OAAO,IAAI,IAAI,KAAK,IAAI,CAAC,CAAC;CAI5B,MAAM,WAAW,IADI,IAAI,KAAK,mBAAmB,KAAK,QAAQ,QAAQ,EAAE,CAChD,CAAC,CAAC,KAAK,MAAM,EAAuB;CAK5D,OAAO,KAAK,WAAW,GAAG,IAAI,IAAI,aAAa;AACjD"}

package/dist/esm/validate.d.ts

@@ -11,39 +11,40 @@ export declare class TiledFormatError extends Error {
     constructor(source: string, path: string, message: string);
 }
 /** @internal */
-export declare function validateTiledPropertyData(raw: unknown, source: string, path: string): TiledPropertyData;
+export declare const validateTiledPropertyData: (raw: unknown, source: string, path: string) => TiledPropertyData;
 /** @internal */
-export declare function validateTiledAnimationFrameData(raw: unknown, source: string, path: string): TiledAnimationFrameData;
+export declare const validateTiledAnimationFrameData: (raw: unknown, source: string, path: string) => TiledAnimationFrameData;
 /** @internal */
-export declare function validateTiledObjectData(raw: unknown, source: string, path: string): TiledObjectData;
+export declare const validateTiledObjectData: (raw: unknown, source: string, path: string) => TiledObjectData;
 /** @internal */
-export declare function validateTiledLayerData(raw: unknown, source: string, path: string): TiledLayerData;
+export declare const validateTiledLayerData: (raw: unknown, source: string, path: string) => TiledLayerData;
 /**
  * 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
  */
-export declare function checkTiledLayerInfiniteConsistency(layers: readonly TiledLayerData[], infinite: boolean, source: string, path: string): void;
+export declare const checkTiledLayerInfiniteConsistency: (layers: readonly TiledLayerData[], infinite: boolean, source: string, path: string) => void;
 /** @internal */
-export declare function validateTiledTileData(raw: unknown, source: string, path: string): TiledTileData;
+export declare const validateTiledTileData: (raw: unknown, source: string, path: string) => TiledTileData;
 /** @internal */
-export declare function validateTiledTilesetData(obj: Record<string, unknown>, source: string, path: string): TiledTilesetData;
+export declare const validateTiledTilesetData: (obj: Record<string, unknown>, source: string, path: string) => TiledTilesetData;
 /**
  * Validates one entry of a map's `tilesets` array: either `{ firstgid,
  * source }` (external `.tsj`) or `{ firstgid, ...embedded tileset fields }`.
  * @internal
  */
-export declare function validateTiledTilesetRefData(raw: unknown, source: string, path: string): TiledTilesetRefData;
+export declare const validateTiledTilesetRefData: (raw: unknown, source: string, path: string) => TiledTilesetRefData;
 /**
  * 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
  */
-export declare function validateTiledMapData(raw: unknown, source: string): TiledMapData;
+export declare const validateTiledMapData: (raw: unknown, source: string) => TiledMapData;
 /**
  * Validates a standalone `.tsj` tileset file's root object.
  * @internal
  */
-export declare function validateTiledTilesetFileData(raw: unknown, source: string): TiledTilesetData;
+export declare const validateTiledTilesetFileData: (raw: unknown, source: string) => TiledTilesetData;
+//# sourceMappingURL=validate.d.ts.map

package/dist/esm/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/validate.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,uBAAuB,EAKvB,cAAc,EAEd,YAAY,EAEZ,eAAe,EAIf,iBAAiB,EAIjB,aAAa,EAEb,gBAAgB,EAChB,mBAAmB,EAIpB,MAAM,QAAQ,CAAC;AAGhB;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEV,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAMjE;AA+HD,gBAAgB;AAChB,eAAO,MAAM,yBAAyB,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,iBAmCtF,CAAC;AAkBF,gBAAgB;AAChB,eAAO,MAAM,+BAA+B,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,uBAM5F,CAAC;AA+CF,gBAAgB;AAChB,eAAO,MAAM,uBAAuB,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,eA0BpF,CAAC;AAgHF,gBAAgB;AAChB,eAAO,MAAM,sBAAsB,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,cAmBnF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC,GAAI,QAAQ,SAAS,cAAc,EAAE,EAAE,UAAU,OAAO,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,IAmBvI,CAAC;AAIF,gBAAgB;AAChB,eAAO,MAAM,qBAAqB,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,aAyBlF,CAAC;AA2DF,gBAAgB;AAChB,eAAO,MAAM,wBAAwB,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,gBAmBpG,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,mBASxF,CAAC;AAOF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,KAAG,YAiDnE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,KAAG,gBACP,CAAC"}