@yagejs/tilemap 0.1.0

package/README.md

@@ -0,0 +1,43 @@
+# @yagejs/tilemap
+
+Tile-based map loading and rendering for the [YAGE](https://yage.dev) 2D game engine.
+
+## Install
+
+```bash
+npm install @yagejs/tilemap
+```
+
+Supports [Tiled](https://www.mapeditor.org/) map format out of the box. Bundles `@pixi/tilemap` for efficient rendering.
+
+## Usage
+
+```ts
+import { Engine } from "@yagejs/core";
+import { TilemapPlugin, TilemapComponent, tiledMap } from "@yagejs/tilemap";
+
+const engine = new Engine();
+engine.use(new TilemapPlugin());
+```
+
+Load and render a Tiled map:
+
+```ts
+const map = await assets.load(tiledMap("level1.json"));
+entity.add(new TilemapComponent({ map }));
+```
+
+## What's in the box
+
+- **TilemapPlugin / TilemapComponent** - tile-based map rendering
+- **Tiled loader** - JSON format support with tilesets, object layers, properties
+- **Collision extraction** - convert map shapes to `@yagejs/physics` colliders (optional)
+- **Custom properties** - typed access to Tiled object properties
+
+## Docs
+
+Full documentation at [yage.dev](https://yage.dev).
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,618 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TilemapComponent: () => TilemapComponent,
+  TilemapPlugin: () => TilemapPlugin,
+  TilemapRenderSystem: () => TilemapRenderSystem,
+  createTilemapLayers: () => createTilemapLayers,
+  extractCollisionShapes: () => extractCollisionShapes,
+  extractObjects: () => extractObjects,
+  getProperty: () => getProperty,
+  getPropertyArray: () => getPropertyArray,
+  resolveObjectRef: () => resolveObjectRef,
+  resolveObjectRefArray: () => resolveObjectRefArray,
+  tiledMap: () => tiledMap,
+  tiledMapAssetExtension: () => tiledMapAssetExtension,
+  toPhysicsColliders: () => toPhysicsColliders,
+  toTilemapData: () => toTilemapData
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/TilemapPlugin.ts
+var import_core3 = require("@yagejs/core");
+var import_pixi4 = require("pixi.js");
+
+// src/tiled/tiledMapLoader.ts
+var import_pixi = require("pixi.js");
+var tiledMapLoaderParser = {
+  id: "tiledMapLoader",
+  extension: {
+    type: import_pixi.ExtensionType.LoadParser,
+    priority: import_pixi.LoaderParserPriority.High
+  },
+  async testParse(asset, resolvedAsset) {
+    if (!resolvedAsset?.src) return false;
+    if (import_pixi.path.extname(resolvedAsset.src).toLowerCase() !== ".json") return false;
+    const obj = asset;
+    return !!(obj.tilesets && obj.layers);
+  },
+  async parse(asset, resolvedAsset, loader) {
+    const src = resolvedAsset?.src;
+    if (!src || !loader) return asset;
+    let basePath = import_pixi.path.dirname(src);
+    if (basePath && !basePath.endsWith("/")) {
+      basePath += "/";
+    }
+    for (const tilesetRef of asset.tilesets) {
+      if (tilesetRef.source) {
+        const tilesetPath = basePath + tilesetRef.source;
+        const tilesetData = await loader.load({
+          src: tilesetPath
+        });
+        tilesetRef.data = tilesetData;
+      }
+      const tileset = tilesetRef.data;
+      if (!tileset) continue;
+      if (tileset.image && !tileset.tiles?.length) {
+        const imagePath = basePath + tileset.image;
+        const baseTexture = await import_pixi.Assets.load(imagePath);
+        const cols = tileset.columns;
+        const tw = tileset.tilewidth;
+        const th = tileset.tileheight;
+        const margin = tileset.margin ?? 0;
+        const spacing = tileset.spacing ?? 0;
+        for (let id = 0; id < tileset.tilecount; id++) {
+          const col = id % cols;
+          const row = Math.floor(id / cols);
+          const x = margin + col * (tw + spacing);
+          const y = margin + row * (th + spacing);
+          const frame = new import_pixi.Rectangle(x, y, tw, th);
+          const subtex = new import_pixi.Texture({
+            source: baseTexture.source,
+            frame
+          });
+          const cacheKey = `${tileset.name}:${id}`;
+          import_pixi.Assets.cache.set(cacheKey, subtex);
+        }
+      }
+    }
+    return asset;
+  },
+  unload() {
+  }
+};
+var tiledMapAssetExtension = {
+  extension: import_pixi.ExtensionType.Asset,
+  loader: tiledMapLoaderParser
+};
+
+// src/TilemapRenderSystem.ts
+var import_core2 = require("@yagejs/core");
+
+// src/TilemapComponent.ts
+var import_core = require("@yagejs/core");
+var import_pixi3 = require("pixi.js");
+var import_renderer = require("@yagejs/renderer");
+
+// src/tiled/parseTiledMap.ts
+var import_tilemap = require("@pixi/tilemap");
+var import_pixi2 = require("pixi.js");
+function toTilemapData(map) {
+  const tileLayers = [];
+  const objectLayers = [];
+  for (const layer of map.layers) {
+    if (layer.type === "tilelayer") {
+      tileLayers.push({
+        name: layer.name,
+        data: layer.data,
+        width: layer.width,
+        height: layer.height,
+        visible: layer.visible
+      });
+    } else if (layer.type === "objectgroup") {
+      objectLayers.push({
+        name: layer.name,
+        objects: layer.objects.map(tiledObjectToMapObject),
+        visible: layer.visible
+      });
+    }
+  }
+  return {
+    width: map.width,
+    height: map.height,
+    tileWidth: map.tilewidth,
+    tileHeight: map.tileheight,
+    tileLayers,
+    objectLayers
+  };
+}
+__name(toTilemapData, "toTilemapData");
+function tiledObjectToMapObject(obj) {
+  const result = {
+    id: obj.id,
+    name: obj.name,
+    x: obj.x,
+    y: obj.y,
+    width: obj.width,
+    height: obj.height,
+    rotation: obj.rotation,
+    visible: obj.visible
+  };
+  const cls = obj.class ?? obj.type;
+  if (cls) result.class = cls;
+  if (obj.point === true) result.point = true;
+  if (obj.polygon) result.polygon = obj.polygon;
+  if (obj.properties) {
+    result.properties = obj.properties.map((p) => ({
+      name: p.name,
+      type: p.type,
+      value: p.value
+    }));
+  }
+  return result;
+}
+__name(tiledObjectToMapObject, "tiledObjectToMapObject");
+function findTileset(tilesets, gid) {
+  let result = null;
+  for (const ts of tilesets) {
+    if (ts.firstgid <= gid) {
+      if (!result || ts.firstgid > result.firstgid) {
+        result = ts;
+      }
+    }
+  }
+  return result;
+}
+__name(findTileset, "findTileset");
+function resolveTileTexture(gid, tileset) {
+  const data = tileset.data;
+  if (!data) return null;
+  const localId = gid - tileset.firstgid;
+  if (data.tiles?.length) {
+    const tileData = data.tiles[localId];
+    if (!tileData?.image) return null;
+    const filenameMatch = tileData.image.match(/[^/]*$/);
+    const filename = filenameMatch?.[0];
+    if (!filename) return null;
+    const tex = import_pixi2.Assets.get(filename);
+    return tex ?? null;
+  }
+  if (data.image) {
+    const cacheKey = `${data.name}:${localId}`;
+    const tex = import_pixi2.Assets.get(cacheKey);
+    if (tex) return tex;
+    const filenameMatch = data.image.match(/[^/]*$/);
+    const filename = filenameMatch?.[0];
+    if (!filename) return null;
+    const baseTex = import_pixi2.Assets.get(filename);
+    if (!baseTex) return null;
+    const cols = data.columns;
+    const tw = data.tilewidth;
+    const th = data.tileheight;
+    const margin = data.margin ?? 0;
+    const spacing = data.spacing ?? 0;
+    const col = localId % cols;
+    const row = Math.floor(localId / cols);
+    const x = margin + col * (tw + spacing);
+    const y = margin + row * (th + spacing);
+    return new import_pixi2.Texture({
+      source: baseTex.source,
+      frame: new import_pixi2.Rectangle(x, y, tw, th)
+    });
+  }
+  return null;
+}
+__name(resolveTileTexture, "resolveTileTexture");
+function createTilemapLayers(map, layerNames) {
+  const tileLayers = map.layers.filter(
+    (l) => l.type === "tilelayer"
+  );
+  const filtered = layerNames ? tileLayers.filter((l) => layerNames.includes(l.name)) : tileLayers;
+  return filtered.map((layer) => {
+    const tilemap = new import_tilemap.CompositeTilemap();
+    const { data, width } = layer;
+    for (let index = 0; index < data.length; index++) {
+      const gid = data[index];
+      if (gid === 0) continue;
+      const tileset = findTileset(map.tilesets, gid);
+      if (!tileset) {
+        throw new Error(`No tileset found for tile GID ${gid}`);
+      }
+      const texture = resolveTileTexture(gid, tileset);
+      if (!texture) {
+        throw new Error(
+          `Could not resolve texture for tile GID ${gid} in tileset "${tileset.data?.name}"`
+        );
+      }
+      const x = index % width;
+      const y = Math.floor(index / width);
+      tilemap.tile(texture, x * map.tilewidth, y * map.tileheight);
+    }
+    return tilemap;
+  });
+}
+__name(createTilemapLayers, "createTilemapLayers");
+function extractObjects(map, objectLayerName) {
+  const objectLayers = map.layers.filter(
+    (l) => l.type === "objectgroup"
+  );
+  const filtered = objectLayerName ? objectLayers.filter((l) => l.name === objectLayerName) : objectLayers;
+  const result = {};
+  for (const layer of filtered) {
+    for (const obj of layer.objects) {
+      const key = obj.class ?? obj.type ?? obj.name;
+      if (!result[key]) {
+        result[key] = [];
+      }
+      result[key].push(obj);
+    }
+  }
+  return result;
+}
+__name(extractObjects, "extractObjects");
+
+// src/colliders.ts
+function extractCollisionShapes(map, objectLayerName) {
+  const filtered = objectLayerName ? map.objectLayers.filter((l) => l.name === objectLayerName) : map.objectLayers;
+  const shapes = [];
+  for (const layer of filtered) {
+    for (const obj of layer.objects) {
+      const shape = objectToColliderConfig(obj);
+      if (shape) shapes.push(shape);
+    }
+  }
+  return shapes;
+}
+__name(extractCollisionShapes, "extractCollisionShapes");
+function objectToColliderConfig(obj) {
+  if (obj.point) return null;
+  if (obj.polygon) {
+    const config2 = {
+      type: "polygon",
+      x: obj.x,
+      y: obj.y,
+      vertices: obj.polygon.map((v) => ({ x: v.x, y: v.y }))
+    };
+    return config2;
+  }
+  const config = {
+    type: "rect",
+    x: obj.x,
+    y: obj.y,
+    width: obj.width,
+    height: obj.height
+  };
+  return config;
+}
+__name(objectToColliderConfig, "objectToColliderConfig");
+
+// src/TilemapComponent.ts
+var _TilemapComponent_decorators, _init, _a;
+_TilemapComponent_decorators = [import_core.serializable];
+var _TilemapComponent = class _TilemapComponent extends (_a = import_core.Component) {
+  static {
+    __name(this, "TilemapComponent");
+  }
+  container;
+  data;
+  _tiledMap;
+  _mapKey;
+  layerNames;
+  renderLayerName;
+  constructor(options) {
+    super();
+    if (!options.map && !options.mapKey) {
+      throw new Error(
+        "TilemapComponent requires either `map` or `mapKey`."
+      );
+    }
+    this._mapKey = options.mapKey ?? null;
+    const tiledMap2 = options.map ?? import_pixi3.Assets.get(options.mapKey);
+    if (!tiledMap2) {
+      throw new Error(
+        `TilemapComponent: map "${options.mapKey}" is not loaded. Add it to scene preload.`
+      );
+    }
+    this._tiledMap = tiledMap2;
+    this.data = toTilemapData(tiledMap2);
+    this.layerNames = options.layers;
+    this.renderLayerName = options.layer ?? "default";
+    this.container = new import_pixi3.Container();
+  }
+  onAdd() {
+    const tilemapLayers = createTilemapLayers(this._tiledMap, this.layerNames);
+    for (const layer of tilemapLayers) {
+      this.container.addChild(layer);
+    }
+    const layers = this.use(import_renderer.RenderLayerManagerKey);
+    const renderLayer = layers.get(this.renderLayerName);
+    renderLayer.container.addChild(this.container);
+  }
+  onDestroy() {
+    this.container.removeFromParent();
+    this.container.destroy({ children: true });
+  }
+  serialize() {
+    if (!this._mapKey) {
+      console.warn(
+        `TilemapComponent on "${this.entity?.name}": created with a TiledMapData object. Use { mapKey } for save/load support.`
+      );
+      return null;
+    }
+    return {
+      mapKey: this._mapKey,
+      layer: this.renderLayerName,
+      ...this.layerNames && { layers: this.layerNames }
+    };
+  }
+  static fromSnapshot(data) {
+    return new _TilemapComponent({
+      mapKey: data.mapKey,
+      layer: data.layer,
+      ...data.layers && { layers: data.layers }
+    });
+  }
+  /** Map width in pixels. */
+  get widthPx() {
+    return this.data.width * this.data.tileWidth;
+  }
+  /** Map height in pixels. */
+  get heightPx() {
+    return this.data.height * this.data.tileHeight;
+  }
+  /** Tile width in pixels. */
+  get tileWidth() {
+    return this.data.tileWidth;
+  }
+  /** Tile height in pixels. */
+  get tileHeight() {
+    return this.data.tileHeight;
+  }
+  /**
+   * Returns the tile GID at a world position, accounting for entity Transform offset.
+   * Returns null if the position is outside the map or the tile is empty.
+   */
+  getTileAt(worldX, worldY, layerName) {
+    const transform = this.entity.tryGet(import_core.Transform);
+    const offsetX = transform ? transform.position.x : 0;
+    const offsetY = transform ? transform.position.y : 0;
+    const localX = worldX - offsetX;
+    const localY = worldY - offsetY;
+    const col = Math.floor(localX / this.data.tileWidth);
+    const row = Math.floor(localY / this.data.tileHeight);
+    if (col < 0 || col >= this.data.width) return null;
+    if (row < 0 || row >= this.data.height) return null;
+    const layers = layerName ? this.data.tileLayers.filter((l) => l.name === layerName) : this.data.tileLayers;
+    for (let i = layers.length - 1; i >= 0; i--) {
+      const layer = layers[i];
+      const gid = layer.data[row * layer.width + col];
+      if (gid !== void 0 && gid !== 0) return gid;
+    }
+    return null;
+  }
+  /** Extract physics-agnostic collision shapes from object layers. */
+  getCollisionShapes(objectLayerName) {
+    return extractCollisionShapes(this.data, objectLayerName);
+  }
+  /** Extract objects from object layers grouped by class/name. */
+  getObjects(objectLayerName) {
+    const filtered = objectLayerName ? this.data.objectLayers.filter((l) => l.name === objectLayerName) : this.data.objectLayers;
+    const result = {};
+    for (const layer of filtered) {
+      for (const obj of layer.objects) {
+        const key = obj.class ?? obj.name;
+        if (!result[key]) {
+          result[key] = [];
+        }
+        result[key].push(obj);
+      }
+    }
+    return result;
+  }
+};
+_init = __decoratorStart(_a);
+_TilemapComponent = __decorateElement(_init, 0, "TilemapComponent", _TilemapComponent_decorators, _TilemapComponent);
+__runInitializers(_init, 1, _TilemapComponent);
+var TilemapComponent = _TilemapComponent;
+
+// src/TilemapRenderSystem.ts
+var TilemapRenderSystem = class extends import_core2.System {
+  static {
+    __name(this, "TilemapRenderSystem");
+  }
+  phase = import_core2.Phase.Render;
+  priority = -1;
+  // Before DisplaySystem (0), so tilemaps render behind sprites
+  query;
+  onRegister(context) {
+    const queryCache = context.resolve(import_core2.QueryCacheKey);
+    this.query = queryCache.register([import_core2.Transform, TilemapComponent]);
+  }
+  update() {
+    for (const entity of this.query) {
+      const transform = entity.get(import_core2.Transform);
+      const tilemap = entity.get(TilemapComponent);
+      if (!tilemap.enabled) continue;
+      tilemap.container.position.x = transform.worldPosition.x;
+      tilemap.container.position.y = transform.worldPosition.y;
+      tilemap.container.rotation = transform.worldRotation;
+      tilemap.container.scale.x = transform.worldScale.x;
+      tilemap.container.scale.y = transform.worldScale.y;
+    }
+  }
+};
+
+// src/TilemapPlugin.ts
+var TilemapPlugin = class {
+  static {
+    __name(this, "TilemapPlugin");
+  }
+  name = "tilemap";
+  version = "2.0.0";
+  dependencies = ["renderer"];
+  install(context) {
+    import_pixi4.extensions.add(tiledMapAssetExtension);
+    const am = context.tryResolve(import_core3.AssetManagerKey);
+    am?.registerLoader("tiledMap", {
+      load: /* @__PURE__ */ __name((path2) => import_pixi4.Assets.load(path2), "load"),
+      unload: /* @__PURE__ */ __name((path2) => {
+        import_pixi4.Assets.unload(path2);
+      }, "unload")
+    });
+  }
+  registerSystems(scheduler) {
+    scheduler.add(new TilemapRenderSystem());
+  }
+};
+
+// src/assets.ts
+var import_core4 = require("@yagejs/core");
+function tiledMap(path2) {
+  return new import_core4.AssetHandle("tiledMap", path2);
+}
+__name(tiledMap, "tiledMap");
+
+// src/toPhysicsColliders.ts
+function toPhysicsColliders(shapes) {
+  return shapes.map(toPhysicsCollider);
+}
+__name(toPhysicsColliders, "toPhysicsColliders");
+function toPhysicsCollider(config) {
+  switch (config.type) {
+    case "polygon":
+      return {
+        shape: {
+          type: "polygon",
+          vertices: config.vertices
+        },
+        offset: { x: config.x, y: config.y }
+      };
+    case "rect":
+      return {
+        shape: { type: "box", width: config.width, height: config.height },
+        offset: {
+          x: config.x + config.width / 2,
+          y: config.y + config.height / 2
+        }
+      };
+  }
+}
+__name(toPhysicsCollider, "toPhysicsCollider");
+
+// src/properties.ts
+function getProperty(obj, name) {
+  const prop = obj.properties?.find((p) => p.name === name);
+  return prop?.value;
+}
+__name(getProperty, "getProperty");
+function getPropertyArray(obj, name) {
+  const pattern = new RegExp(`^${escapeRegex(name)}\\[(\\d+)\\]$`);
+  const values = [];
+  if (!obj.properties) return values;
+  for (const prop of obj.properties) {
+    const match = prop.name.match(pattern);
+    if (match) {
+      const index = Number.parseInt(match[1], 10);
+      values[index] = prop.value;
+    }
+  }
+  return values;
+}
+__name(getPropertyArray, "getPropertyArray");
+function resolveObjectRef(obj, propName, allObjects) {
+  const id = getProperty(obj, propName);
+  if (id === void 0) return void 0;
+  return allObjects.find((o) => o.id === id);
+}
+__name(resolveObjectRef, "resolveObjectRef");
+function resolveObjectRefArray(obj, propName, allObjects) {
+  const ids = getPropertyArray(obj, propName);
+  return ids.map((id) => allObjects.find((o) => o.id === id)).filter((o) => o !== void 0);
+}
+__name(resolveObjectRefArray, "resolveObjectRefArray");
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegex, "escapeRegex");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TilemapComponent,
+  TilemapPlugin,
+  TilemapRenderSystem,
+  createTilemapLayers,
+  extractCollisionShapes,
+  extractObjects,
+  getProperty,
+  getPropertyArray,
+  resolveObjectRef,
+  resolveObjectRefArray,
+  tiledMap,
+  tiledMapAssetExtension,
+  toPhysicsColliders,
+  toTilemapData
+});
+//# sourceMappingURL=index.cjs.map