maplibre-gl-layers 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.2.0
+ * version: 0.4.0
  * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: 4fe3389ad068a5950d4f01e01ec9d3b34c049fb2
+ * git.commit.hash: 366a9e1190bfe770b4002a06284ff627188b5c76
  */
 
 export * from './types.ts';

package/dist/index.mjs

@@ -1,12 +1,30 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.2.0
+ * version: 0.4.0
  * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: 4fe3389ad068a5950d4f01e01ec9d3b34c049fb2
+ * git.commit.hash: 366a9e1190bfe770b4002a06284ff627188b5c76
  */
+const UNLIMITED_SPRITE_SCALING_OPTIONS = {
+  metersPerPixel: 1,
+  zoomMin: 0,
+  zoomMax: 30,
+  scaleMin: 1,
+  scaleMax: 1,
+  spriteMinPixel: 0,
+  spriteMaxPixel: 1e5
+};
+const STANDARD_SPRITE_SCALING_OPTIONS = {
+  metersPerPixel: 1,
+  zoomMin: 8,
+  zoomMax: 20,
+  scaleMin: 0.1,
+  scaleMax: 1,
+  spriteMinPixel: 24,
+  spriteMaxPixel: 100
+};
 var maplibreGl$1 = { exports: {} };
 /**
  * MapLibre GL JS
@@ -21311,26 +21329,134 @@ const EARTH_RADIUS_METERS = 6378137;
 const DEG2RAD = Math.PI / 180;
 const RAD2DEG = 180 / Math.PI;
 const TILE_SIZE = 512;
-const DEFAULT_SPRITE_SCALING_OPTIONS = {
-  metersPerPixel: 1,
-  zoomMin: 0,
-  zoomMax: 30,
-  scaleMin: 1,
-  scaleMax: 1,
-  spriteMinPixel: 0,
-  spriteMaxPixel: 1e4
-};
 const resolveScalingOptions = (options) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
-  const base = DEFAULT_SPRITE_SCALING_OPTIONS;
+  var _a, _b;
+  const base = UNLIMITED_SPRITE_SCALING_OPTIONS;
+  const warnings = [];
+  const fallbackMetersPerPixel = Number.isFinite(base.metersPerPixel) && ((_a = base.metersPerPixel) != null ? _a : 0) > 0 ? base.metersPerPixel : 1;
+  let metersPerPixel = (options == null ? void 0 : options.metersPerPixel) !== void 0 ? options.metersPerPixel : fallbackMetersPerPixel;
+  if (!Number.isFinite(metersPerPixel) || metersPerPixel <= 0) {
+    if ((options == null ? void 0 : options.metersPerPixel) !== void 0) {
+      warnings.push(
+        `metersPerPixel(${String(options.metersPerPixel)}) is invalid; using ${fallbackMetersPerPixel}`
+      );
+    }
+    metersPerPixel = fallbackMetersPerPixel;
+  }
+  const fallbackZoomMin = Number.isFinite(base.zoomMin) ? base.zoomMin : 0;
+  let zoomMin = (options == null ? void 0 : options.zoomMin) !== void 0 ? options.zoomMin : fallbackZoomMin;
+  if (!Number.isFinite(zoomMin)) {
+    if ((options == null ? void 0 : options.zoomMin) !== void 0) {
+      warnings.push(
+        `zoomMin(${String(options.zoomMin)}) is not finite; using ${fallbackZoomMin}`
+      );
+    }
+    zoomMin = fallbackZoomMin;
+  }
+  const fallbackZoomMax = Number.isFinite(base.zoomMax) && base.zoomMax > fallbackZoomMin ? base.zoomMax : fallbackZoomMin;
+  let zoomMax = (options == null ? void 0 : options.zoomMax) !== void 0 ? options.zoomMax : fallbackZoomMax;
+  if (!Number.isFinite(zoomMax)) {
+    if ((options == null ? void 0 : options.zoomMax) !== void 0) {
+      warnings.push(
+        `zoomMax(${String(options.zoomMax)}) is not finite; using ${fallbackZoomMax}`
+      );
+    }
+    zoomMax = fallbackZoomMax;
+  }
+  if (zoomMax < zoomMin) {
+    warnings.push(
+      `zoomMax(${zoomMax}) < zoomMin(${zoomMin}); swapped values to maintain ascending order`
+    );
+    [zoomMin, zoomMax] = [zoomMax, zoomMin];
+  }
+  const fallbackScaleMin = Number.isFinite(base.scaleMin) ? base.scaleMin : 1;
+  let scaleMin = (options == null ? void 0 : options.scaleMin) !== void 0 ? options.scaleMin : fallbackScaleMin;
+  if (!Number.isFinite(scaleMin)) {
+    if ((options == null ? void 0 : options.scaleMin) !== void 0) {
+      warnings.push(
+        `scaleMin(${String(options.scaleMin)}) is not finite; using ${fallbackScaleMin}`
+      );
+    }
+    scaleMin = fallbackScaleMin;
+  }
+  if (scaleMin < 0) {
+    warnings.push(`scaleMin(${scaleMin}) is negative; clamped to 0`);
+    scaleMin = 0;
+  }
+  const fallbackScaleMax = Number.isFinite(base.scaleMax) ? base.scaleMax : 1;
+  let scaleMax = (options == null ? void 0 : options.scaleMax) !== void 0 ? options.scaleMax : fallbackScaleMax;
+  if (!Number.isFinite(scaleMax)) {
+    if ((options == null ? void 0 : options.scaleMax) !== void 0) {
+      warnings.push(
+        `scaleMax(${String(options.scaleMax)}) is not finite; using ${fallbackScaleMax}`
+      );
+    }
+    scaleMax = fallbackScaleMax;
+  }
+  if (scaleMax < 0) {
+    warnings.push(`scaleMax(${scaleMax}) is negative; clamped to 0`);
+    scaleMax = 0;
+  }
+  if (scaleMax < scaleMin) {
+    warnings.push(
+      `scaleMax(${scaleMax}) < scaleMin(${scaleMin}); swapped values to maintain ascending order`
+    );
+    [scaleMin, scaleMax] = [scaleMax, scaleMin];
+  }
+  const fallbackSpriteMin = Number.isFinite(base.spriteMinPixel) && base.spriteMinPixel >= 0 ? base.spriteMinPixel : 0;
+  let spriteMinPixel = (options == null ? void 0 : options.spriteMinPixel) !== void 0 ? options.spriteMinPixel : fallbackSpriteMin;
+  if (!Number.isFinite(spriteMinPixel)) {
+    if ((options == null ? void 0 : options.spriteMinPixel) !== void 0) {
+      warnings.push(
+        `spriteMinPixel(${String(
+          options.spriteMinPixel
+        )}) is not finite; using ${fallbackSpriteMin}`
+      );
+    }
+    spriteMinPixel = fallbackSpriteMin;
+  } else if (spriteMinPixel < 0) {
+    warnings.push(
+      `spriteMinPixel(${spriteMinPixel}) is negative; clamped to 0`
+    );
+    spriteMinPixel = 0;
+  }
+  const fallbackSpriteMax = Number.isFinite(base.spriteMaxPixel) && base.spriteMaxPixel >= 0 ? base.spriteMaxPixel : 0;
+  let spriteMaxPixel = (options == null ? void 0 : options.spriteMaxPixel) !== void 0 ? options.spriteMaxPixel : fallbackSpriteMax;
+  if (!Number.isFinite(spriteMaxPixel)) {
+    if ((options == null ? void 0 : options.spriteMaxPixel) !== void 0) {
+      warnings.push(
+        `spriteMaxPixel(${String(
+          options.spriteMaxPixel
+        )}) is not finite; using ${fallbackSpriteMax}`
+      );
+    }
+    spriteMaxPixel = fallbackSpriteMax;
+  } else if (spriteMaxPixel < 0) {
+    warnings.push(
+      `spriteMaxPixel(${spriteMaxPixel}) is negative; clamped to 0`
+    );
+    spriteMaxPixel = 0;
+  }
+  if (spriteMinPixel > 0 && spriteMaxPixel > 0 && spriteMaxPixel < spriteMinPixel) {
+    warnings.push(
+      `spriteMaxPixel(${spriteMaxPixel}) < spriteMinPixel(${spriteMinPixel}); swapped values to maintain ascending order`
+    );
+    [spriteMinPixel, spriteMaxPixel] = [spriteMaxPixel, spriteMinPixel];
+  }
+  if (warnings.length > 0 && typeof console !== "undefined") {
+    const warn = (_b = console.warn) != null ? _b : null;
+    if (typeof warn === "function") {
+      warn(`[SpriteScalingOptions] ${warnings.join("; ")}`);
+    }
+  }
   return {
-    metersPerPixel: (_b = (_a = options == null ? void 0 : options.metersPerPixel) != null ? _a : base.metersPerPixel) != null ? _b : 1,
-    zoomMin: (_d = (_c = options == null ? void 0 : options.zoomMin) != null ? _c : base.zoomMin) != null ? _d : 0,
-    zoomMax: (_f = (_e = options == null ? void 0 : options.zoomMax) != null ? _e : base.zoomMax) != null ? _f : 24,
-    scaleMin: (_h = (_g = options == null ? void 0 : options.scaleMin) != null ? _g : base.scaleMin) != null ? _h : 1,
-    scaleMax: (_j = (_i = options == null ? void 0 : options.scaleMax) != null ? _i : base.scaleMax) != null ? _j : 1,
-    spriteMinPixel: (_l = (_k = options == null ? void 0 : options.spriteMinPixel) != null ? _k : base.spriteMinPixel) != null ? _l : 0,
-    spriteMaxPixel: (_n = (_m = options == null ? void 0 : options.spriteMaxPixel) != null ? _m : base.spriteMaxPixel) != null ? _n : 0
+    metersPerPixel,
+    zoomMin,
+    zoomMax,
+    scaleMin,
+    scaleMax,
+    spriteMinPixel,
+    spriteMaxPixel
   };
 };
 const calculateZoomScaleFactor = (zoom, scaling) => {
@@ -21448,13 +21574,37 @@ const calculateBillboardAnchorShiftPixels = (halfWidth, halfHeight, anchor, tota
   const shiftY = -anchorX * sinR - anchorY * cosR;
   return { x: shiftX, y: shiftY };
 };
-const calculateSurfaceWorldDimensions = (imageWidth, imageHeight, baseMetersPerPixel, imageScale, zoomScaleFactor) => {
+const calculateSurfaceWorldDimensions = (imageWidth, imageHeight, baseMetersPerPixel, imageScale, zoomScaleFactor, options) => {
+  var _a, _b;
   if (!imageWidth || !imageHeight || imageWidth <= 0 || imageHeight <= 0 || baseMetersPerPixel <= 0) {
     return { width: 0, height: 0 };
   }
   const scaleFactor = baseMetersPerPixel * imageScale * zoomScaleFactor;
-  const width = ensureFinite(imageWidth * scaleFactor);
-  const height = ensureFinite(imageHeight * scaleFactor);
+  let width = ensureFinite(imageWidth * scaleFactor);
+  let height = ensureFinite(imageHeight * scaleFactor);
+  const effectivePixelsPerMeter = (options == null ? void 0 : options.effectivePixelsPerMeter) !== void 0 ? options.effectivePixelsPerMeter : 0;
+  const spriteMinPixel = (_a = options == null ? void 0 : options.spriteMinPixel) != null ? _a : 0;
+  const spriteMaxPixel = (_b = options == null ? void 0 : options.spriteMaxPixel) != null ? _b : 0;
+  if (effectivePixelsPerMeter > 0 && Number.isFinite(effectivePixelsPerMeter) && (spriteMinPixel > 0 || spriteMaxPixel > 0)) {
+    const largestMeters = Math.max(width, height);
+    if (largestMeters > 0 && Number.isFinite(largestMeters)) {
+      const largestPixels = largestMeters * effectivePixelsPerMeter;
+      if (Number.isFinite(largestPixels) && largestPixels > 0) {
+        let scale = 1;
+        if (spriteMinPixel > 0 && largestPixels < spriteMinPixel) {
+          scale = spriteMinPixel / largestPixels;
+        }
+        const scaledLargest = largestPixels * scale;
+        if (spriteMaxPixel > 0 && scaledLargest > spriteMaxPixel) {
+          scale = spriteMaxPixel / largestPixels;
+        }
+        if (scale !== 1) {
+          width *= scale;
+          height *= scale;
+        }
+      }
+    }
+  }
   return { width, height };
 };
 const calculateSurfaceAnchorShiftMeters = (halfWidthMeters, halfHeightMeters, anchor, totalRotateDeg) => {
@@ -21474,9 +21624,9 @@ const calculateSurfaceAnchorShiftMeters = (halfWidthMeters, halfHeightMeters, an
   const north = -anchorEast * sinR - anchorNorth * cosR;
   return { east, north };
 };
-const calculateSurfaceOffsetMeters = (offset, imageScale) => {
+const calculateSurfaceOffsetMeters = (offset, imageScale, zoomScaleFactor) => {
   var _a, _b;
-  const offsetMeters = ((_a = offset == null ? void 0 : offset.offsetMeters) != null ? _a : 0) * imageScale;
+  const offsetMeters = ((_a = offset == null ? void 0 : offset.offsetMeters) != null ? _a : 0) * imageScale * zoomScaleFactor;
   if (offsetMeters === 0) {
     return { east: 0, north: 0 };
   }
@@ -21694,6 +21844,9 @@ const calculateSurfaceCenterPosition = (params) => {
     totalRotateDeg,
     anchor,
     offset,
+    effectivePixelsPerMeter = 0,
+    spriteMinPixel = 0,
+    spriteMaxPixel = 0,
     project,
     projectToClipSpace,
     drawingBufferWidth,
@@ -21731,7 +21884,12 @@ const calculateSurfaceCenterPosition = (params) => {
     imageHeight,
     baseMetersPerPixel,
     imageScale,
-    zoomScaleFactor
+    zoomScaleFactor,
+    {
+      effectivePixelsPerMeter,
+      spriteMinPixel,
+      spriteMaxPixel
+    }
   );
   const halfWidthMeters = worldDims.width / 2;
   const halfHeightMeters = worldDims.height / 2;
@@ -21741,7 +21899,11 @@ const calculateSurfaceCenterPosition = (params) => {
     anchor,
     totalRotateDeg
   );
-  const offsetMeters = calculateSurfaceOffsetMeters(offset, imageScale);
+  const offsetMeters = calculateSurfaceOffsetMeters(
+    offset,
+    imageScale,
+    zoomScaleFactor
+  );
   const totalEast = anchorShiftMeters.east + offsetMeters.east;
   const totalNorth = anchorShiftMeters.north + offsetMeters.north;
   const displaced = applySurfaceDisplacement(
@@ -22073,6 +22235,35 @@ const resolveTextGlyphPadding = (padding) => {
   }
   return { top: 0, right: 0, bottom: 0, left: 0 };
 };
+const resolveBorderSides = (sides) => {
+  if (!Array.isArray(sides) || sides.length === 0) {
+    return { top: true, right: true, bottom: true, left: true };
+  }
+  let top = false;
+  let right = false;
+  let bottom = false;
+  let left = false;
+  for (const side of sides) {
+    switch (side) {
+      case "top":
+        top = true;
+        break;
+      case "right":
+        right = true;
+        break;
+      case "bottom":
+        bottom = true;
+        break;
+      case "left":
+        left = true;
+        break;
+    }
+  }
+  if (!top && !right && !bottom && !left) {
+    return { top: true, right: true, bottom: true, left: true };
+  }
+  return { top, right, bottom, left };
+};
 const resolveTextAlign = (align) => {
   switch (align) {
     case "left":
@@ -22116,7 +22307,7 @@ const resolveTextGlyphOptions = (options, preferredLineHeight) => {
     DEFAULT_TEXT_GLYPH_FONT_SIZE
   );
   const resolvedFontSize = resolvePositiveFinite(
-    options == null ? void 0 : options.fontSizePixel,
+    options == null ? void 0 : options.fontSizePixelHint,
     fallbackFontSize
   );
   return {
@@ -22131,6 +22322,7 @@ const resolveTextGlyphOptions = (options, preferredLineHeight) => {
     borderColor: options == null ? void 0 : options.borderColor,
     borderWidthPixel: resolveNonNegativeFinite(options == null ? void 0 : options.borderWidthPixel, 0),
     borderRadiusPixel: resolveNonNegativeFinite(options == null ? void 0 : options.borderRadiusPixel, 0),
+    borderSides: resolveBorderSides(options == null ? void 0 : options.borderSides),
     textAlign: resolveTextAlign(options == null ? void 0 : options.textAlign),
     renderPixelRatio: resolveRenderPixelRatio(options == null ? void 0 : options.renderPixelRatio)
   };
@@ -22242,13 +22434,58 @@ const fillRoundedRect = (ctx, width, height, radius, color) => {
   ctx.fill();
   ctx.restore();
 };
-const strokeRoundedRect = (ctx, width, height, radius, color, lineWidth) => {
+const strokeRoundedRect = (ctx, width, height, radius, color, lineWidth, sides) => {
+  const { top, right, bottom, left } = sides;
+  if (lineWidth <= 0 || !top && !right && !bottom && !left) {
+    return;
+  }
   ctx.save();
-  ctx.beginPath();
-  drawRoundedRectPath(ctx, 0, 0, width, height, radius);
   ctx.strokeStyle = color;
   ctx.lineWidth = lineWidth;
-  ctx.stroke();
+  const cornerRadius = Math.max(0, Math.min(radius, width / 2, height / 2));
+  const previousCap = ctx.lineCap;
+  ctx.lineCap = cornerRadius === 0 ? "square" : "butt";
+  if (top) {
+    const startX = cornerRadius;
+    const endX = width - cornerRadius;
+    if (endX > startX) {
+      ctx.beginPath();
+      ctx.moveTo(startX, 0);
+      ctx.lineTo(endX, 0);
+      ctx.stroke();
+    }
+  }
+  if (right) {
+    const startY = cornerRadius;
+    const endY = height - cornerRadius;
+    if (endY > startY) {
+      ctx.beginPath();
+      ctx.moveTo(width, startY);
+      ctx.lineTo(width, endY);
+      ctx.stroke();
+    }
+  }
+  if (bottom) {
+    const startX = width - cornerRadius;
+    const endX = cornerRadius;
+    if (startX > endX) {
+      ctx.beginPath();
+      ctx.moveTo(startX, height);
+      ctx.lineTo(endX, height);
+      ctx.stroke();
+    }
+  }
+  if (left) {
+    const startY = height - cornerRadius;
+    const endY = cornerRadius;
+    if (startY > endY) {
+      ctx.beginPath();
+      ctx.moveTo(0, startY);
+      ctx.lineTo(0, endY);
+      ctx.stroke();
+    }
+  }
+  ctx.lineCap = previousCap;
   ctx.restore();
 };
 const measureTextWidthWithSpacing = (ctx, text, letterSpacing) => {
@@ -22574,6 +22811,9 @@ const createSpriteLayer = (options) => {
       totalRotateDeg: totalRotDeg,
       anchor: img.anchor,
       offset: img.offset,
+      effectivePixelsPerMeter,
+      spriteMinPixel,
+      spriteMaxPixel,
       projectToClipSpace,
       drawingBufferWidth,
       drawingBufferHeight,
@@ -23174,6 +23414,9 @@ const createSpriteLayer = (options) => {
           totalRotateDeg,
           anchor,
           offset: offsetDef,
+          effectivePixelsPerMeter,
+          spriteMinPixel,
+          spriteMaxPixel,
           projectToClipSpace: (lng, lat, elevation) => projectLngLatToClipSpace(lng, lat, elevation, clipContext),
           drawingBufferWidth,
           drawingBufferHeight,
@@ -23189,7 +23432,8 @@ const createSpriteLayer = (options) => {
         }
         const offsetMeters = calculateSurfaceOffsetMeters(
           offsetDef,
-          imageScale
+          imageScale,
+          zoomScaleFactor
         );
         const cornerDisplacements = calculateSurfaceCornerDisplacements({
           worldWidthMeters: surfaceCenter.worldDimensions.width,
@@ -23384,14 +23628,20 @@ const createSpriteLayer = (options) => {
             imageResource.height,
             baseMetersPerPixel,
             imageScale,
-            zoomScaleFactor
+            zoomScaleFactor,
+            {
+              effectivePixelsPerMeter,
+              spriteMinPixel,
+              spriteMaxPixel
+            }
           );
           const totalRotateDeg = Number.isFinite(imageEntry.displayedRotateDeg) ? imageEntry.displayedRotateDeg : normaliseAngleDeg(
             ((_e = imageEntry.resolvedBaseRotateDeg) != null ? _e : 0) + ((_f = imageEntry.rotateDeg) != null ? _f : 0)
           );
           const offsetMeters = calculateSurfaceOffsetMeters(
             offsetResolved,
-            imageScale
+            imageScale,
+            zoomScaleFactor
           );
           const cornerDisplacements = calculateSurfaceCornerDisplacements({
             worldWidthMeters: worldDims.width,
@@ -23654,7 +23904,8 @@ const createSpriteLayer = (options) => {
         strokeHeight,
         strokeRadius,
         resolved.borderColor,
-        borderWidth
+        borderWidth,
+        resolved.borderSides
       );
       ctx.restore();
     }
@@ -24263,6 +24514,124 @@ const createSpriteLayer = (options) => {
     }
     return updatedCount;
   };
+  const mutateSprites = (sourceItems, mutator) => {
+    if (sourceItems.length === 0) {
+      return 0;
+    }
+    let changedCount = 0;
+    let isRequiredRender = false;
+    let currentSprite = void 0;
+    let didMutateImages = false;
+    const operationResult = {
+      isUpdated: false
+    };
+    const updateObject = {
+      getImageIndexMap: () => {
+        const map2 = /* @__PURE__ */ new Map();
+        currentSprite.images.forEach((inner, subLayer) => {
+          map2.set(subLayer, new Set(inner.keys()));
+        });
+        return map2;
+      },
+      addImage: (subLayer, order, imageInit) => {
+        const added = addSpriteImageInternal(
+          currentSprite,
+          subLayer,
+          order,
+          imageInit,
+          operationResult
+        );
+        if (added) {
+          didMutateImages = true;
+        }
+        return added;
+      },
+      updateImage: (subLayer, order, imageUpdate) => {
+        const updated = updateSpriteImageInternal(
+          currentSprite,
+          subLayer,
+          order,
+          imageUpdate,
+          operationResult
+        );
+        if (updated) {
+          didMutateImages = true;
+        }
+        return updated;
+      },
+      removeImage: (subLayer, order) => {
+        const removed = removeSpriteImageInternal(
+          currentSprite,
+          subLayer,
+          order,
+          operationResult
+        );
+        if (removed) {
+          didMutateImages = true;
+        }
+        return removed;
+      }
+    };
+    for (const sourceItem of sourceItems) {
+      const spriteId = sourceItem.spriteId;
+      const sprite = sprites.get(spriteId);
+      if (!sprite) {
+        const init = mutator.add(sourceItem);
+        if (!init) {
+          continue;
+        }
+        if (addSpriteInternal(spriteId, init)) {
+          changedCount++;
+          isRequiredRender = true;
+        }
+        continue;
+      }
+      currentSprite = sprite;
+      operationResult.isUpdated = false;
+      didMutateImages = false;
+      const decision = mutator.modify(
+        sourceItem,
+        sprite,
+        updateObject
+      );
+      if (decision === "remove") {
+        if (removeSpriteInternal(spriteId)) {
+          changedCount++;
+          isRequiredRender = true;
+        }
+      } else {
+        const updateResult = updateSpriteInternal(spriteId, updateObject);
+        let spriteChanged = false;
+        switch (updateResult) {
+          case "updated":
+            spriteChanged = true;
+            break;
+          case "isRequiredRender":
+            spriteChanged = true;
+            isRequiredRender = true;
+            break;
+        }
+        if (didMutateImages) {
+          spriteChanged = true;
+          isRequiredRender = true;
+        }
+        if (spriteChanged) {
+          changedCount++;
+        }
+      }
+      updateObject.isEnabled = void 0;
+      updateObject.location = void 0;
+      updateObject.interpolation = void 0;
+      updateObject.tag = void 0;
+      operationResult.isUpdated = false;
+      didMutateImages = false;
+    }
+    if (isRequiredRender) {
+      ensureRenderTargetEntries();
+      scheduleRender();
+    }
+    return changedCount;
+  };
   const updateForEach = (updater) => {
     let updatedCount = 0;
     let isRequiredRender = false;
@@ -24351,6 +24720,7 @@ const createSpriteLayer = (options) => {
     removeSpriteImage,
     updateSprite,
     updateBulk,
+    mutateSprites,
     updateForEach,
     on: addEventListener2,
     off: removeEventListener2
@@ -24358,6 +24728,8 @@ const createSpriteLayer = (options) => {
   return spriteLayout;
 };
 export {
+  STANDARD_SPRITE_SCALING_OPTIONS,
+  UNLIMITED_SPRITE_SCALING_OPTIONS,
   applyAutoRotation,
   calculatePerspectiveRatio,
   cloneAnchor,