maplibre-gl-layers 0.5.0 → 0.10.0

package/dist/index.mjs

@@ -1,11 +1,14 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 /*!
  * name: maplibre-gl-layers
- * version: 0.5.0
+ * version: 0.10.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: ce37eea48b788c36b4bf98cdfce83b95a85833ee
+ * git.commit.hash: 58b99588e56fc80c6874d78a17e91a50901abc17
  */
 const UNLIMITED_SPRITE_SCALING_OPTIONS = {
   metersPerPixel: 1,
@@ -25,6 +28,282 @@ const STANDARD_SPRITE_SCALING_OPTIONS = {
   spriteMinPixel: 24,
   spriteMaxPixel: 100
 };
+const DEFAULT_TEXTURE_FILTERING_OPTIONS = {
+  minFilter: "linear",
+  magFilter: "linear",
+  generateMipmaps: false,
+  maxAnisotropy: 1
+};
+const BETTER_TEXTURE_FILTERING_OPTIONS = {
+  minFilter: "linear-mipmap-linear",
+  magFilter: "linear",
+  generateMipmaps: true,
+  maxAnisotropy: 8
+};
+class SvgSizeResolutionError extends Error {
+  constructor(message, code) {
+    super(message);
+    __publicField(this, "code");
+    this.name = "SvgSizeResolutionError";
+    this.code = code;
+  }
+}
+const parseNumericLength = (value) => {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const parsed = Number.parseFloat(trimmed);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return void 0;
+  }
+  return parsed;
+};
+const extractStyleLength = (styleValue, property) => {
+  if (!styleValue) {
+    return void 0;
+  }
+  const declarations = styleValue.split(";").map((decl) => decl.trim()).filter((decl) => decl.length > 0);
+  for (const declaration of declarations) {
+    const [prop, rawValue] = declaration.split(":");
+    if (!prop || !rawValue) {
+      continue;
+    }
+    if (prop.trim().toLowerCase() === property) {
+      return parseNumericLength(rawValue);
+    }
+  }
+  return void 0;
+};
+const parseSvgSize = (svgText) => {
+  try {
+    const doc = new DOMParser().parseFromString(svgText, "image/svg+xml");
+    const svg = doc.documentElement;
+    if (!svg || svg.tagName.toLowerCase() !== "svg") {
+      return { hasViewBox: false };
+    }
+    const attrWidth = parseNumericLength(svg.getAttribute("width"));
+    const attrHeight = parseNumericLength(svg.getAttribute("height"));
+    const styleWidth = extractStyleLength(svg.getAttribute("style"), "width");
+    const styleHeight = extractStyleLength(svg.getAttribute("style"), "height");
+    const width = attrWidth != null ? attrWidth : styleWidth;
+    const height = attrHeight != null ? attrHeight : styleHeight;
+    let viewBoxWidth;
+    let viewBoxHeight;
+    let hasViewBox = false;
+    const viewBox = svg.getAttribute("viewBox");
+    if (viewBox) {
+      const parts = viewBox.split(/[\s,]+/).map((part) => Number.parseFloat(part)).filter((part) => Number.isFinite(part));
+      if (parts.length === 4) {
+        viewBoxWidth = parts[2];
+        viewBoxHeight = parts[3];
+        if (viewBoxWidth > 0 && viewBoxHeight > 0) {
+          hasViewBox = true;
+        } else {
+          viewBoxWidth = void 0;
+          viewBoxHeight = void 0;
+        }
+      }
+    }
+    return {
+      width: width !== void 0 && width > 0 ? width : void 0,
+      height: height !== void 0 && height > 0 ? height : void 0,
+      viewBoxWidth,
+      viewBoxHeight,
+      hasViewBox
+    };
+  } catch (e) {
+    return { hasViewBox: false };
+  }
+};
+const determineSvgRasterDimensions = (parsed, options) => {
+  var _a, _b;
+  const overrideWidth = options == null ? void 0 : options.width;
+  const overrideHeight = options == null ? void 0 : options.height;
+  if (overrideWidth !== void 0 && overrideHeight !== void 0 && overrideWidth > 0 && overrideHeight > 0) {
+    return {
+      width: Math.max(1, Math.round(overrideWidth)),
+      height: Math.max(1, Math.round(overrideHeight))
+    };
+  }
+  const intrinsicWidth = parsed == null ? void 0 : parsed.width;
+  const intrinsicHeight = parsed == null ? void 0 : parsed.height;
+  const hasValidViewBox = Boolean(
+    (parsed == null ? void 0 : parsed.hasViewBox) && parsed.viewBoxWidth !== void 0 && parsed.viewBoxHeight !== void 0 && parsed.viewBoxWidth > 0 && parsed.viewBoxHeight > 0
+  );
+  const viewBoxAspect = hasValidViewBox ? parsed.viewBoxWidth / parsed.viewBoxHeight : void 0;
+  let baseWidth;
+  let baseHeight;
+  let aspect = intrinsicWidth !== void 0 && intrinsicHeight !== void 0 && intrinsicHeight > 0 ? intrinsicWidth / intrinsicHeight : viewBoxAspect;
+  if (intrinsicWidth !== void 0 && intrinsicWidth > 0 && intrinsicHeight !== void 0 && intrinsicHeight > 0) {
+    baseWidth = intrinsicWidth;
+    baseHeight = intrinsicHeight;
+  } else if (intrinsicWidth !== void 0 && intrinsicWidth > 0 && aspect !== void 0) {
+    baseWidth = intrinsicWidth;
+    baseHeight = intrinsicWidth / aspect;
+  } else if (intrinsicHeight !== void 0 && intrinsicHeight > 0 && aspect !== void 0) {
+    baseHeight = intrinsicHeight;
+    baseWidth = intrinsicHeight * aspect;
+  } else if (hasValidViewBox && ((_a = options == null ? void 0 : options.svg) == null ? void 0 : _a.useViewBoxDimensions)) {
+    baseWidth = parsed.viewBoxWidth;
+    baseHeight = parsed.viewBoxHeight;
+    aspect = baseWidth / baseHeight;
+  }
+  if ((baseWidth === void 0 || baseHeight === void 0) && hasValidViewBox && !((_b = options == null ? void 0 : options.svg) == null ? void 0 : _b.useViewBoxDimensions)) {
+    throw new SvgSizeResolutionError(
+      "SVG width/height attributes are missing and useViewBoxDimensions option is disabled.",
+      "viewbox-disabled"
+    );
+  }
+  if (baseWidth === void 0 || baseHeight === void 0) {
+    throw new SvgSizeResolutionError(
+      "SVG image lacks sufficient sizing information.",
+      "size-missing"
+    );
+  }
+  aspect = aspect != null ? aspect : baseWidth / baseHeight;
+  let finalWidth = baseWidth;
+  let finalHeight = baseHeight;
+  if (overrideWidth !== void 0 && overrideWidth > 0) {
+    finalWidth = overrideWidth;
+    if (overrideHeight === void 0) {
+      if (aspect === void 0) {
+        throw new SvgSizeResolutionError(
+          "Unable to infer SVG height from width; aspect ratio is undefined.",
+          "invalid-dimensions"
+        );
+      }
+      finalHeight = finalWidth / aspect;
+    }
+  }
+  if (overrideHeight !== void 0 && overrideHeight > 0) {
+    finalHeight = overrideHeight;
+    if (overrideWidth === void 0) {
+      if (aspect === void 0) {
+        throw new SvgSizeResolutionError(
+          "Unable to infer SVG width from height; aspect ratio is undefined.",
+          "invalid-dimensions"
+        );
+      }
+      finalWidth = finalHeight * aspect;
+    }
+  }
+  if (!Number.isFinite(finalWidth) || !Number.isFinite(finalHeight) || finalWidth <= 0 || finalHeight <= 0) {
+    throw new SvgSizeResolutionError(
+      "Resolved SVG dimensions are invalid.",
+      "invalid-dimensions"
+    );
+  }
+  return {
+    width: Math.max(1, Math.round(finalWidth)),
+    height: Math.max(1, Math.round(finalHeight))
+  };
+};
+const isSvgMimeType = (mimeType) => {
+  if (!mimeType) {
+    return false;
+  }
+  return mimeType.toLowerCase().includes("image/svg");
+};
+const rasterizeSvgWithCanvas = async (blob, width, height, options) => {
+  if (typeof document === "undefined") {
+    throw new Error(
+      "SVG rasterization fallback requires a browser environment"
+    );
+  }
+  const blobUrl = URL.createObjectURL(blob);
+  try {
+    const image = await new Promise((resolve, reject) => {
+      const element = new Image();
+      element.onload = () => resolve(element);
+      element.onerror = () => reject(new Error("Failed to load SVG for rasterization"));
+      element.src = blobUrl;
+    });
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("Failed to acquire 2D context for SVG rasterization");
+    }
+    ctx.clearRect(0, 0, width, height);
+    ctx.imageSmoothingEnabled = true;
+    if ((options == null ? void 0 : options.resizeQuality) === "pixelated") {
+      ctx.imageSmoothingEnabled = false;
+    } else if (options == null ? void 0 : options.resizeQuality) {
+      ctx.imageSmoothingQuality = options.resizeQuality;
+    }
+    ctx.drawImage(image, 0, 0, width, height);
+    try {
+      return await createImageBitmap(canvas);
+    } catch (e) {
+      const canvasBlob = await new Promise((resolve, reject) => {
+        canvas.toBlob((result) => {
+          if (result) {
+            resolve(result);
+          } else {
+            reject(
+              new Error("Failed to convert canvas to blob during rasterization")
+            );
+          }
+        });
+      });
+      return await createImageBitmap(canvasBlob);
+    }
+  } finally {
+    URL.revokeObjectURL(blobUrl);
+  }
+};
+const resolveSvgBitmapWithFallback = async (blob, width, height, options) => {
+  const bitmapOptions = {
+    resizeWidth: width,
+    resizeHeight: height
+  };
+  if (options == null ? void 0 : options.resizeQuality) {
+    bitmapOptions.resizeQuality = options.resizeQuality;
+  }
+  try {
+    return await createImageBitmap(blob, bitmapOptions);
+  } catch (error) {
+    return await rasterizeSvgWithCanvas(blob, width, height, options);
+  }
+};
+const internalReadImageBitmap = async (blob, shouldTreatAsSvg, options) => {
+  const svgOptions = options == null ? void 0 : options.svg;
+  if (shouldTreatAsSvg) {
+    let parsed = null;
+    if ((svgOptions == null ? void 0 : svgOptions.inspectSize) !== false) {
+      const text = await blob.text();
+      parsed = parseSvgSize(text);
+    }
+    const { width, height } = determineSvgRasterDimensions(parsed, options);
+    return await resolveSvgBitmapWithFallback(blob, width, height, options);
+  }
+  return await createImageBitmap(blob, {
+    resizeWidth: options == null ? void 0 : options.width,
+    resizeHeight: options == null ? void 0 : options.height,
+    resizeQuality: options == null ? void 0 : options.resizeQuality
+  });
+};
+const readImageBitmap = (blob, options) => {
+  const svgOptions = options == null ? void 0 : options.svg;
+  const shouldTreatAsSvg = (svgOptions == null ? void 0 : svgOptions.assumeSvg) === true;
+  return internalReadImageBitmap(blob, shouldTreatAsSvg, options);
+};
+const loadImageBitmap = async (url, options) => {
+  var _a;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch image from ${url}`);
+  }
+  const mimeType = response.headers.get("content-type");
+  const blob = await response.blob();
+  const shouldTreatAsSvg = ((_a = options == null ? void 0 : options.svg) == null ? void 0 : _a.assumeSvg) === true || isSvgMimeType(mimeType);
+  return await internalReadImageBitmap(blob, shouldTreatAsSvg, options);
+};
 var maplibreGl$1 = { exports: {} };
 /**
  * MapLibre GL JS
@@ -21099,14 +21378,6 @@ function transformMat4(out, a, m) {
     return a;
   };
 })();
-const loadImageBitmap = async (url) => {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch image from ${url}`);
-  }
-  const blob = await response.blob();
-  return await createImageBitmap(blob);
-};
 const cloneSpriteLocation = (location2) => {
   if (location2.z === void 0) {
     return { lng: location2.lng, lat: location2.lat };
@@ -21163,7 +21434,7 @@ const computeFeedforwardTarget = (previous, next) => {
   }
   return target;
 };
-const normaliseOptions$1 = (options) => {
+const normalizeOptions$2 = (options) => {
   var _a;
   return {
     durationMs: Math.max(0, options.durationMs),
@@ -21173,7 +21444,7 @@ const normaliseOptions$1 = (options) => {
 };
 const createInterpolationState = (params) => {
   const { currentLocation, lastCommandLocation, nextCommandLocation } = params;
-  const options = normaliseOptions$1(params.options);
+  const options = normalizeOptions$2(params.options);
   const from = cloneSpriteLocation(currentLocation);
   const easing = resolveEasing(options.easing);
   let to;
@@ -21218,8 +21489,8 @@ const evaluateInterpolation = (params) => {
   };
 };
 const NUMERIC_EPSILON = 1e-6;
-const normaliseDuration = (durationMs) => Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0;
-const normaliseDelta = (delta) => {
+const normalizeDuration$1 = (durationMs) => Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0;
+const normalizeDelta = (delta) => {
   if (!Number.isFinite(delta)) {
     return 0;
   }
@@ -21231,16 +21502,24 @@ const normaliseDelta = (delta) => {
   }
   return adjusted;
 };
-const normaliseOptions = (options) => {
+const normalizeOptions$1 = (options) => {
+  var _a;
   return {
-    durationMs: normaliseDuration(options.durationMs),
-    easing: resolveEasing(options.easing)
+    durationMs: normalizeDuration$1(options.durationMs),
+    easing: resolveEasing(options.easing),
+    mode: (_a = options.mode) != null ? _a : "feedback"
   };
 };
-const createNumericInterpolationState = (params) => {
+const createDegreeInterpolationState = (params) => {
   const { currentValue, targetValue } = params;
-  const options = normaliseOptions(params.options);
-  const delta = normaliseDelta(targetValue - currentValue);
+  const options = normalizeOptions$1(params.options);
+  let effectiveTarget = targetValue;
+  const previousCommand = params.previousCommandValue;
+  if (options.mode === "feedforward" && previousCommand !== void 0 && Number.isFinite(previousCommand)) {
+    const commandDelta = normalizeDelta(targetValue - previousCommand);
+    effectiveTarget = targetValue + commandDelta;
+  }
+  const delta = normalizeDelta(effectiveTarget - currentValue);
   const pathTarget = currentValue + delta;
   const requiresInterpolation = options.durationMs > 0 && Math.abs(delta) > NUMERIC_EPSILON;
   const state = {
@@ -21248,7 +21527,7 @@ const createNumericInterpolationState = (params) => {
     easing: options.easing,
     from: currentValue,
     to: pathTarget,
-    finalValue: targetValue,
+    finalValue: effectiveTarget,
     startTimestamp: -1
   };
   return {
@@ -21256,7 +21535,7 @@ const createNumericInterpolationState = (params) => {
     requiresInterpolation
   };
 };
-const clamp01 = (value) => {
+const clamp01$1 = (value) => {
   if (!Number.isFinite(value)) {
     return 1;
   }
@@ -21268,7 +21547,7 @@ const clamp01 = (value) => {
   }
   return value;
 };
-const evaluateNumericInterpolation = (params) => {
+const evaluateDegreeInterpolation = (params) => {
   const { state } = params;
   const timestamp = Number.isFinite(params.timestamp) ? params.timestamp : Date.now();
   const duration = Math.max(0, state.durationMs);
@@ -21282,7 +21561,7 @@ const evaluateNumericInterpolation = (params) => {
   }
   const elapsed = timestamp - effectiveStart;
   const rawProgress = duration <= 0 ? 1 : elapsed / duration;
-  const eased = clamp01(state.easing(rawProgress));
+  const eased = clamp01$1(state.easing(rawProgress));
   const interpolated = state.from + (state.to - state.from) * eased;
   const completed = rawProgress >= 1;
   return {
@@ -21291,7 +21570,7 @@ const evaluateNumericInterpolation = (params) => {
     effectiveStartTimestamp: effectiveStart
   };
 };
-const normaliseAngleDeg = (angle) => {
+const normalizeAngleDeg = (angle) => {
   if (!Number.isFinite(angle)) {
     return 0;
   }
@@ -21301,17 +21580,19 @@ const normaliseAngleDeg = (angle) => {
 };
 const resolveRotationTarget = (params) => {
   const options = params.options;
-  const targetAngle = normaliseAngleDeg(params.targetAngleDeg);
-  const currentAngle = normaliseAngleDeg(params.currentAngleDeg);
+  const targetAngle = normalizeAngleDeg(params.targetAngleDeg);
+  const currentAngle = normalizeAngleDeg(params.currentAngleDeg);
+  const previousCommandAngleDeg = params.previousCommandAngleDeg !== void 0 ? normalizeAngleDeg(params.previousCommandAngleDeg) : void 0;
   if (!options || options.durationMs <= 0) {
     return {
       nextAngleDeg: targetAngle,
       interpolationState: null
     };
   }
-  const { state, requiresInterpolation } = createNumericInterpolationState({
+  const { state, requiresInterpolation } = createDegreeInterpolationState({
     currentValue: currentAngle,
     targetValue: targetAngle,
+    previousCommandValue: previousCommandAngleDeg,
     options
   });
   if (!requiresInterpolation) {
@@ -21991,6 +22272,243 @@ const calculateSurfaceCornerDisplacements = (params) => {
   }
   return corners;
 };
+const DISTANCE_EPSILON = 1e-6;
+const normalizeDuration = (durationMs) => Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0;
+const normalizeOptions = (options) => {
+  var _a;
+  return {
+    durationMs: normalizeDuration(options.durationMs),
+    easing: resolveEasing(options.easing),
+    mode: (_a = options.mode) != null ? _a : "feedback"
+  };
+};
+const createDistanceInterpolationState = (params) => {
+  const { currentValue, targetValue } = params;
+  const options = normalizeOptions(params.options);
+  let effectiveTarget = targetValue;
+  const previousCommand = params.previousCommandValue;
+  if (options.mode === "feedforward" && previousCommand !== void 0 && Number.isFinite(previousCommand)) {
+    const commandDelta = targetValue - previousCommand;
+    effectiveTarget = targetValue + commandDelta;
+  }
+  const delta = effectiveTarget - currentValue;
+  const requiresInterpolation = options.durationMs > 0 && Math.abs(delta) > DISTANCE_EPSILON;
+  const state = {
+    durationMs: options.durationMs,
+    easing: options.easing,
+    from: currentValue,
+    to: currentValue + delta,
+    finalValue: effectiveTarget,
+    startTimestamp: -1
+  };
+  return {
+    state,
+    requiresInterpolation
+  };
+};
+const clamp01 = (value) => {
+  if (!Number.isFinite(value)) {
+    return 1;
+  }
+  if (value <= 0) {
+    return 0;
+  }
+  if (value >= 1) {
+    return 1;
+  }
+  return value;
+};
+const evaluateDistanceInterpolation = (params) => {
+  const { state } = params;
+  const timestamp = Number.isFinite(params.timestamp) ? params.timestamp : Date.now();
+  const duration = Math.max(0, state.durationMs);
+  const effectiveStart = state.startTimestamp >= 0 ? state.startTimestamp : timestamp;
+  if (duration === 0 || Math.abs(state.to - state.from) <= DISTANCE_EPSILON) {
+    return {
+      value: state.finalValue,
+      completed: true,
+      effectiveStartTimestamp: effectiveStart
+    };
+  }
+  const elapsed = timestamp - effectiveStart;
+  const rawProgress = duration <= 0 ? 1 : elapsed / duration;
+  const eased = clamp01(state.easing(rawProgress));
+  const interpolated = state.from + (state.to - state.from) * eased;
+  const completed = rawProgress >= 1;
+  return {
+    value: completed ? state.finalValue : interpolated,
+    completed,
+    effectiveStartTimestamp: effectiveStart
+  };
+};
+const stepDegreeInterpolationState = (interpolationState, timestamp, applyValue, options) => {
+  var _a, _b;
+  if (!interpolationState) {
+    return { state: null, active: false };
+  }
+  const evaluation = evaluateDegreeInterpolation({
+    state: interpolationState,
+    timestamp
+  });
+  if (interpolationState.startTimestamp < 0) {
+    interpolationState.startTimestamp = evaluation.effectiveStartTimestamp;
+  }
+  const normalizeValue = (_a = options == null ? void 0 : options.normalize) != null ? _a : ((value) => value);
+  const applyFinalValue = (_b = options == null ? void 0 : options.applyFinalValue) != null ? _b : applyValue;
+  const interpolatedValue = normalizeValue(evaluation.value);
+  applyValue(interpolatedValue);
+  if (evaluation.completed) {
+    const finalValue = normalizeValue(interpolationState.finalValue);
+    applyFinalValue(finalValue);
+    return { state: null, active: false };
+  }
+  return { state: interpolationState, active: true };
+};
+const updateImageDisplayedRotation = (image, optionsOverride) => {
+  const targetAngle = normalizeAngleDeg(
+    image.resolvedBaseRotateDeg + image.rotateDeg
+  );
+  const currentAngle = Number.isFinite(image.displayedRotateDeg) ? image.displayedRotateDeg : targetAngle;
+  const previousCommandAngle = image.lastCommandRotateDeg;
+  const options = optionsOverride === void 0 ? image.rotationInterpolationOptions : optionsOverride;
+  const { nextAngleDeg, interpolationState } = resolveRotationTarget({
+    currentAngleDeg: currentAngle,
+    targetAngleDeg: targetAngle,
+    previousCommandAngleDeg: previousCommandAngle,
+    options: options != null ? options : void 0
+  });
+  image.displayedRotateDeg = nextAngleDeg;
+  image.rotationInterpolationState = interpolationState;
+  if (!interpolationState) {
+    image.displayedRotateDeg = targetAngle;
+  }
+  image.lastCommandRotateDeg = targetAngle;
+};
+const syncImageRotationChannel = (image, optionsOverride) => {
+  updateImageDisplayedRotation(image, optionsOverride);
+};
+const stepRotationInterpolation = (image, timestamp) => {
+  const { state, active } = stepDegreeInterpolationState(
+    image.rotationInterpolationState,
+    timestamp,
+    (value) => {
+      image.displayedRotateDeg = value;
+    },
+    {
+      normalize: normalizeAngleDeg
+    }
+  );
+  image.rotationInterpolationState = state;
+  return active;
+};
+const stepOffsetDegInterpolation = (image, timestamp) => {
+  const { state, active } = stepDegreeInterpolationState(
+    image.offsetDegInterpolationState,
+    timestamp,
+    (value) => {
+      image.offset.offsetDeg = value;
+    }
+  );
+  image.offsetDegInterpolationState = state;
+  return active;
+};
+const clearOffsetDegInterpolation = (image) => {
+  image.offsetDegInterpolationState = null;
+};
+const stepDistanceInterpolationState = (interpolationState, timestamp, applyValue) => {
+  if (!interpolationState) {
+    return { state: null, active: false };
+  }
+  const evaluation = evaluateDistanceInterpolation({
+    state: interpolationState,
+    timestamp
+  });
+  if (interpolationState.startTimestamp < 0) {
+    interpolationState.startTimestamp = evaluation.effectiveStartTimestamp;
+  }
+  applyValue(evaluation.value);
+  if (evaluation.completed) {
+    applyValue(interpolationState.finalValue);
+    return { state: null, active: false };
+  }
+  return { state: interpolationState, active: true };
+};
+const clearOffsetMetersInterpolation = (image) => {
+  image.offsetMetersInterpolationState = null;
+};
+const applyOffsetDegUpdate = (image, nextOffset, interpolationOptions) => {
+  const options = interpolationOptions;
+  if (!options || options.durationMs <= 0) {
+    image.offset.offsetDeg = nextOffset.offsetDeg;
+    image.offsetDegInterpolationState = null;
+    image.lastCommandOffsetDeg = nextOffset.offsetDeg;
+    return;
+  }
+  const { state, requiresInterpolation } = createDegreeInterpolationState({
+    currentValue: image.offset.offsetDeg,
+    targetValue: nextOffset.offsetDeg,
+    previousCommandValue: image.lastCommandOffsetDeg,
+    options
+  });
+  image.lastCommandOffsetDeg = nextOffset.offsetDeg;
+  if (requiresInterpolation) {
+    image.offsetDegInterpolationState = state;
+  } else {
+    image.offset.offsetDeg = nextOffset.offsetDeg;
+    image.offsetDegInterpolationState = null;
+  }
+};
+const applyOffsetMetersUpdate = (image, nextOffset, interpolationOptions) => {
+  const options = interpolationOptions;
+  if (!options || options.durationMs <= 0) {
+    image.offset.offsetMeters = nextOffset.offsetMeters;
+    image.offsetMetersInterpolationState = null;
+    image.lastCommandOffsetMeters = nextOffset.offsetMeters;
+    return;
+  }
+  const { state, requiresInterpolation } = createDistanceInterpolationState({
+    currentValue: image.offset.offsetMeters,
+    targetValue: nextOffset.offsetMeters,
+    previousCommandValue: image.lastCommandOffsetMeters,
+    options
+  });
+  image.lastCommandOffsetMeters = nextOffset.offsetMeters;
+  if (requiresInterpolation) {
+    image.offsetMetersInterpolationState = state;
+  } else {
+    image.offset.offsetMeters = nextOffset.offsetMeters;
+    image.offsetMetersInterpolationState = null;
+  }
+};
+const stepOffsetMetersInterpolation = (image, timestamp) => {
+  const { state, active } = stepDistanceInterpolationState(
+    image.offsetMetersInterpolationState,
+    timestamp,
+    (value) => {
+      image.offset.offsetMeters = value;
+    }
+  );
+  image.offsetMetersInterpolationState = state;
+  return active;
+};
+const IMAGE_INTERPOLATION_STEPPERS = [
+  stepRotationInterpolation,
+  stepOffsetDegInterpolation,
+  stepOffsetMetersInterpolation
+];
+const stepSpriteImageInterpolations = (image, timestamp) => {
+  let active = false;
+  for (const stepper of IMAGE_INTERPOLATION_STEPPERS) {
+    if (stepper(image, timestamp)) {
+      active = true;
+    }
+  }
+  return active;
+};
+const applyOffsetUpdate = (image, nextOffset, options = {}) => {
+  applyOffsetDegUpdate(image, nextOffset, options.deg);
+  applyOffsetMetersUpdate(image, nextOffset, options.meters);
+};
 const DEFAULT_ANCHOR = { x: 0, y: 0 };
 const DEFAULT_AUTO_ROTATION_MIN_DISTANCE_METERS = 20;
 const DEFAULT_IMAGE_OFFSET = {
@@ -22002,6 +22520,91 @@ const MIN_CLIP_Z_EPSILON = 1e-7;
 const EPS_NDC = 1e-6;
 const ORDER_MAX = 16;
 const ORDER_BUCKET = 16;
+const MIN_FILTER_VALUES = [
+  "nearest",
+  "linear",
+  "nearest-mipmap-nearest",
+  "nearest-mipmap-linear",
+  "linear-mipmap-nearest",
+  "linear-mipmap-linear"
+];
+const MAG_FILTER_VALUES = [
+  "nearest",
+  "linear"
+];
+const MIPMAP_MIN_FILTERS = /* @__PURE__ */ new Set([
+  "nearest-mipmap-nearest",
+  "nearest-mipmap-linear",
+  "linear-mipmap-nearest",
+  "linear-mipmap-linear"
+]);
+const filterRequiresMipmaps = (filter) => MIPMAP_MIN_FILTERS.has(filter);
+const resolveTextureFilteringOptions = (options) => {
+  var _a, _b;
+  const minCandidate = options == null ? void 0 : options.minFilter;
+  const minFilter = MIN_FILTER_VALUES.includes(
+    minCandidate
+  ) ? minCandidate : DEFAULT_TEXTURE_FILTERING_OPTIONS.minFilter;
+  const magCandidate = options == null ? void 0 : options.magFilter;
+  const magFilter = MAG_FILTER_VALUES.includes(
+    magCandidate
+  ) ? magCandidate : DEFAULT_TEXTURE_FILTERING_OPTIONS.magFilter;
+  let generateMipmaps = (_a = options == null ? void 0 : options.generateMipmaps) != null ? _a : DEFAULT_TEXTURE_FILTERING_OPTIONS.generateMipmaps;
+  if (filterRequiresMipmaps(minFilter)) {
+    generateMipmaps = true;
+  }
+  let maxAnisotropy = (_b = options == null ? void 0 : options.maxAnisotropy) != null ? _b : DEFAULT_TEXTURE_FILTERING_OPTIONS.maxAnisotropy;
+  if (!Number.isFinite(maxAnisotropy) || maxAnisotropy < 1) {
+    maxAnisotropy = 1;
+  }
+  return {
+    minFilter,
+    magFilter,
+    generateMipmaps,
+    maxAnisotropy
+  };
+};
+const ANISOTROPY_EXTENSION_NAMES = [
+  "EXT_texture_filter_anisotropic",
+  "WEBKIT_EXT_texture_filter_anisotropic",
+  "MOZ_EXT_texture_filter_anisotropic"
+];
+const resolveAnisotropyExtension = (glContext) => {
+  for (const name of ANISOTROPY_EXTENSION_NAMES) {
+    const extension = glContext.getExtension(name);
+    if (extension) {
+      return extension;
+    }
+  }
+  return null;
+};
+const isPowerOfTwo = (value) => value > 0 && (value & value - 1) === 0;
+const resolveGlMinFilter = (glContext, filter) => {
+  switch (filter) {
+    case "nearest":
+      return glContext.NEAREST;
+    case "nearest-mipmap-nearest":
+      return glContext.NEAREST_MIPMAP_NEAREST;
+    case "nearest-mipmap-linear":
+      return glContext.NEAREST_MIPMAP_LINEAR;
+    case "linear-mipmap-nearest":
+      return glContext.LINEAR_MIPMAP_NEAREST;
+    case "linear-mipmap-linear":
+      return glContext.LINEAR_MIPMAP_LINEAR;
+    case "linear":
+    default:
+      return glContext.LINEAR;
+  }
+};
+const resolveGlMagFilter = (glContext, filter) => {
+  switch (filter) {
+    case "nearest":
+      return glContext.NEAREST;
+    case "linear":
+    default:
+      return glContext.LINEAR;
+  }
+};
 const calculatePerspectiveRatio = (mapInstance, location2) => {
   var _a, _b, _c;
   const transform = mapInstance.transform;
@@ -22123,14 +22726,14 @@ const applyAutoRotation = (sprite, nextLocation) => {
     return false;
   }
   const resolvedAngleRaw = isFiniteNumber(bearingDeg) ? bearingDeg : sprite.lastAutoRotationAngleDeg;
-  const resolvedAngle = normaliseAngleDeg(resolvedAngleRaw);
+  const resolvedAngle = normalizeAngleDeg(resolvedAngleRaw);
   sprite.images.forEach((orderMap) => {
     orderMap.forEach((image) => {
       if (!image.autoRotation) {
         return;
       }
       image.resolvedBaseRotateDeg = resolvedAngle;
-      updateImageDisplayedRotation(image);
+      syncImageRotationChannel(image);
     });
   });
   sprite.lastAutoRotationLocation = cloneSpriteLocation(nextLocation);
@@ -22566,23 +23169,6 @@ const cloneOffset = (offset) => {
     offsetDeg: offset.offsetDeg
   };
 };
-const updateImageDisplayedRotation = (image, optionsOverride) => {
-  const targetAngle = normaliseAngleDeg(
-    image.resolvedBaseRotateDeg + image.rotateDeg
-  );
-  const currentAngle = Number.isFinite(image.displayedRotateDeg) ? image.displayedRotateDeg : targetAngle;
-  const options = optionsOverride === void 0 ? image.rotationInterpolationOptions : optionsOverride;
-  const { nextAngleDeg, interpolationState } = resolveRotationTarget({
-    currentAngleDeg: currentAngle,
-    targetAngleDeg: targetAngle,
-    options: options != null ? options : void 0
-  });
-  image.displayedRotateDeg = nextAngleDeg;
-  image.rotationInterpolationState = interpolationState;
-  if (!interpolationState) {
-    image.displayedRotateDeg = targetAngle;
-  }
-};
 const cloneInterpolationOptions = (options) => {
   return {
     mode: options.mode,
@@ -22590,46 +23176,49 @@ const cloneInterpolationOptions = (options) => {
     easing: options.easing
   };
 };
-const cloneNumericInterpolationOptions = (options) => {
-  return {
-    durationMs: options.durationMs,
-    easing: options.easing
-  };
-};
 const createImageStateFromInit = (imageInit, subLayer, order) => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   const mode = (_a = imageInit.mode) != null ? _a : "surface";
   const autoRotationDefault = mode === "surface";
+  const initialOffset = cloneOffset(imageInit.offset);
+  const initialRotateDeg = normalizeAngleDeg((_b = imageInit.rotateDeg) != null ? _b : 0);
   const state = {
     subLayer,
     order,
     imageId: imageInit.imageId,
     mode,
-    opacity: (_b = imageInit.opacity) != null ? _b : 1,
-    scale: (_c = imageInit.scale) != null ? _c : 1,
+    opacity: (_c = imageInit.opacity) != null ? _c : 1,
+    scale: (_d = imageInit.scale) != null ? _d : 1,
     anchor: cloneAnchor(imageInit.anchor),
-    offset: cloneOffset(imageInit.offset),
-    rotateDeg: (_d = imageInit.rotateDeg) != null ? _d : 0,
-    displayedRotateDeg: normaliseAngleDeg((_e = imageInit.rotateDeg) != null ? _e : 0),
+    offset: initialOffset,
+    rotateDeg: (_e = imageInit.rotateDeg) != null ? _e : 0,
+    displayedRotateDeg: initialRotateDeg,
     autoRotation: (_f = imageInit.autoRotation) != null ? _f : autoRotationDefault,
     autoRotationMinDistanceMeters: (_g = imageInit.autoRotationMinDistanceMeters) != null ? _g : DEFAULT_AUTO_ROTATION_MIN_DISTANCE_METERS,
     resolvedBaseRotateDeg: 0,
     originLocation: cloneOriginLocation(imageInit.originLocation),
     rotationInterpolationState: null,
     rotationInterpolationOptions: null,
-    offsetInterpolationState: null
+    offsetDegInterpolationState: null,
+    offsetMetersInterpolationState: null,
+    lastCommandRotateDeg: initialRotateDeg,
+    lastCommandOffsetDeg: initialOffset.offsetDeg,
+    lastCommandOffsetMeters: initialOffset.offsetMeters
   };
-  const rotateInitOption = (_i = (_h = imageInit.rotationInterpolation) == null ? void 0 : _h.rotateDeg) != null ? _i : null;
+  const rotateInitOption = (_i = (_h = imageInit.interpolation) == null ? void 0 : _h.rotateDeg) != null ? _i : null;
   if (rotateInitOption) {
-    state.rotationInterpolationOptions = cloneNumericInterpolationOptions(rotateInitOption);
+    state.rotationInterpolationOptions = cloneInterpolationOptions(rotateInitOption);
   }
-  updateImageDisplayedRotation(state);
+  syncImageRotationChannel(state);
   return state;
 };
 const createSpriteLayer = (options) => {
   var _a;
   const id = (_a = options == null ? void 0 : options.id) != null ? _a : "sprite-layer";
   const resolvedScaling = resolveScalingOptions(options == null ? void 0 : options.spriteScaling);
+  const resolvedTextureFiltering = resolveTextureFilteringOptions(
+    options == null ? void 0 : options.textureFiltering
+  );
   let gl = null;
   let map = null;
   let program = null;
@@ -22638,6 +23227,8 @@ const createSpriteLayer = (options) => {
   let attribUvLocation = -1;
   let uniformTextureLocation = null;
   let uniformOpacityLocation = null;
+  let anisotropyExtension = null;
+  let maxSupportedAnisotropy = 1;
   const images = /* @__PURE__ */ new Map();
   const queuedTextureIds = /* @__PURE__ */ new Set();
   const queueTextureUpload = (image) => {
@@ -22768,7 +23359,7 @@ const createSpriteLayer = (options) => {
         baseY = refCenter.y;
       }
     }
-    const totalRotDeg = Number.isFinite(img.displayedRotateDeg) ? img.displayedRotateDeg : normaliseAngleDeg(
+    const totalRotDeg = Number.isFinite(img.displayedRotateDeg) ? img.displayedRotateDeg : normalizeAngleDeg(
       ((_d = img.resolvedBaseRotateDeg) != null ? _d : 0) + ((_e = img.rotateDeg) != null ? _e : 0)
     );
     const imageScaleLocal = (_f = img.scale) != null ? _f : 1;
@@ -22918,13 +23509,15 @@ const createSpriteLayer = (options) => {
   };
   let canvasElement = null;
   const inputListenerDisposers = [];
-  const hasSpriteClickListeners = () => {
+  const hasSpriteListeners = (type) => {
     var _a2, _b;
     return (
       // Treat missing listener sets as zero, otherwise check the registered count.
-      ((_b = (_a2 = eventListeners.get("spriteclick")) == null ? void 0 : _a2.size) != null ? _b : 0) > 0
+      ((_b = (_a2 = eventListeners.get(type)) == null ? void 0 : _a2.size) != null ? _b : 0) > 0
     );
   };
+  const hasSpriteClickListeners = () => hasSpriteListeners("spriteclick");
+  const hasSpriteHoverListeners = () => hasSpriteListeners("spritehover");
   const resolveScreenPointFromEvent = (nativeEvent) => {
     var _a2, _b, _c, _d;
     if (!canvasElement) {
@@ -22949,20 +23542,31 @@ const createSpriteLayer = (options) => {
     const mouseLike = nativeEvent;
     return toScreenPoint(mouseLike.clientX, mouseLike.clientY);
   };
+  const resolveSpriteEventPayload = (hitEntry) => {
+    var _a2, _b;
+    if (!hitEntry) {
+      return {
+        sprite: void 0,
+        image: void 0
+      };
+    }
+    const spriteState = getSpriteState(hitEntry.sprite.spriteId);
+    const imageState = (_b = (_a2 = spriteState == null ? void 0 : spriteState.images.get(hitEntry.image.subLayer)) == null ? void 0 : _a2.get(hitEntry.image.order)) != null ? _b : void 0;
+    return {
+      sprite: spriteState,
+      image: imageState
+    };
+  };
   const dispatchSpriteClick = (hitEntry, screenPoint, originalEvent) => {
     const listeners = eventListeners.get("spriteclick");
     if (!listeners || listeners.size === 0) {
       return;
     }
-    const spriteState = getSpriteState(hitEntry.sprite.spriteId);
-    if (!spriteState) {
-      return;
-    }
-    const imageState = hitEntry.image;
+    const payload = resolveSpriteEventPayload(hitEntry);
     const clickEvent = {
       type: "spriteclick",
-      sprite: spriteState,
-      image: imageState,
+      sprite: payload.sprite,
+      image: payload.image,
       screenPoint,
       originalEvent
     };
@@ -22970,22 +23574,50 @@ const createSpriteLayer = (options) => {
       listener(clickEvent);
     });
   };
-  const processInteractionEvent = (nativeEvent) => {
+  const dispatchSpriteHover = (hitEntry, screenPoint, originalEvent) => {
+    const listeners = eventListeners.get("spritehover");
+    if (!listeners || listeners.size === 0) {
+      return;
+    }
+    const payload = resolveSpriteEventPayload(hitEntry);
+    const hoverEvent = {
+      type: "spritehover",
+      sprite: payload.sprite,
+      image: payload.image,
+      screenPoint,
+      originalEvent
+    };
+    listeners.forEach((listener) => {
+      listener(hoverEvent);
+    });
+  };
+  const resolveHitTestResult = (nativeEvent) => {
+    const screenPoint = resolveScreenPointFromEvent(nativeEvent);
+    if (!screenPoint) {
+      return null;
+    }
+    const hitEntry = findTopmostHitEntry(screenPoint);
+    return { hitEntry: hitEntry != null ? hitEntry : null, screenPoint };
+  };
+  const processClickEvent = (nativeEvent) => {
     if (!hasSpriteClickListeners()) {
       return;
     }
-    if (hitTestEntries.length === 0) {
+    const hitResult = resolveHitTestResult(nativeEvent);
+    if (!hitResult || !hitResult.hitEntry) {
       return;
     }
-    const screenPoint = resolveScreenPointFromEvent(nativeEvent);
-    if (!screenPoint) {
+    dispatchSpriteClick(hitResult.hitEntry, hitResult.screenPoint, nativeEvent);
+  };
+  const processHoverEvent = (nativeEvent) => {
+    if (!hasSpriteHoverListeners()) {
       return;
     }
-    const hitEntry = findTopmostHitEntry(screenPoint);
-    if (!hitEntry) {
+    const hitResult = resolveHitTestResult(nativeEvent);
+    if (!hitResult) {
       return;
     }
-    dispatchSpriteClick(hitEntry, screenPoint, nativeEvent);
+    dispatchSpriteHover(hitResult.hitEntry, hitResult.screenPoint, nativeEvent);
   };
   const ensureTextures = () => {
     if (!gl) {
@@ -23020,16 +23652,6 @@ const createSpriteLayer = (options) => {
         glContext.TEXTURE_WRAP_T,
         glContext.CLAMP_TO_EDGE
       );
-      glContext.texParameteri(
-        glContext.TEXTURE_2D,
-        glContext.TEXTURE_MIN_FILTER,
-        glContext.LINEAR
-      );
-      glContext.texParameteri(
-        glContext.TEXTURE_2D,
-        glContext.TEXTURE_MAG_FILTER,
-        glContext.LINEAR
-      );
       glContext.pixelStorei(glContext.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 1);
       glContext.texImage2D(
         glContext.TEXTURE_2D,
@@ -23039,6 +23661,52 @@ const createSpriteLayer = (options) => {
         glContext.UNSIGNED_BYTE,
         image.bitmap
       );
+      let minFilterEnum = resolveGlMinFilter(
+        glContext,
+        resolvedTextureFiltering.minFilter
+      );
+      const magFilterEnum = resolveGlMagFilter(
+        glContext,
+        resolvedTextureFiltering.magFilter
+      );
+      let usedMipmaps = false;
+      if (resolvedTextureFiltering.generateMipmaps) {
+        const isWebGL2 = typeof WebGL2RenderingContext !== "undefined" && glContext instanceof WebGL2RenderingContext;
+        const canUseMipmaps = isWebGL2 || isPowerOfTwo(image.width) && isPowerOfTwo(image.height);
+        if (canUseMipmaps) {
+          glContext.generateMipmap(glContext.TEXTURE_2D);
+          usedMipmaps = true;
+        } else {
+          minFilterEnum = glContext.LINEAR;
+        }
+      }
+      if (!usedMipmaps && filterRequiresMipmaps(resolvedTextureFiltering.minFilter)) {
+        minFilterEnum = glContext.LINEAR;
+      }
+      glContext.texParameteri(
+        glContext.TEXTURE_2D,
+        glContext.TEXTURE_MIN_FILTER,
+        minFilterEnum
+      );
+      glContext.texParameteri(
+        glContext.TEXTURE_2D,
+        glContext.TEXTURE_MAG_FILTER,
+        magFilterEnum
+      );
+      if (usedMipmaps && anisotropyExtension && resolvedTextureFiltering.maxAnisotropy > 1) {
+        const ext = anisotropyExtension;
+        const targetAnisotropy = Math.min(
+          resolvedTextureFiltering.maxAnisotropy,
+          maxSupportedAnisotropy
+        );
+        if (targetAnisotropy > 1) {
+          glContext.texParameterf(
+            glContext.TEXTURE_2D,
+            ext.TEXTURE_MAX_ANISOTROPY_EXT,
+            targetAnisotropy
+          );
+        }
+      }
       image.texture = texture;
     });
   };
@@ -23081,6 +23749,20 @@ const createSpriteLayer = (options) => {
   const onAdd = (mapInstance, glContext) => {
     map = mapInstance;
     gl = glContext;
+    anisotropyExtension = resolveAnisotropyExtension(glContext);
+    if (anisotropyExtension) {
+      const ext = anisotropyExtension;
+      const supported = glContext.getParameter(
+        ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT
+      );
+      if (typeof supported === "number" && Number.isFinite(supported) && supported >= 1) {
+        maxSupportedAnisotropy = supported;
+      } else {
+        maxSupportedAnisotropy = 1;
+      }
+    } else {
+      maxSupportedAnisotropy = 1;
+    }
     canvasElement = mapInstance.getCanvas();
     const registerDisposer = (disposer) => {
       inputListenerDisposers.push(disposer);
@@ -23088,24 +23770,42 @@ const createSpriteLayer = (options) => {
     const supportsPointerEvents = typeof window !== "undefined" && "PointerEvent" in window;
     if (canvasElement) {
       if (supportsPointerEvents) {
-        const pointerListener = (event) => {
+        const pointerUpListener = (event) => {
           if (event.pointerType === "mouse" && event.button !== 0) {
             return;
           }
-          processInteractionEvent(event);
+          processClickEvent(event);
         };
-        canvasElement.addEventListener("pointerup", pointerListener, {
+        canvasElement.addEventListener("pointerup", pointerUpListener, {
           passive: true
         });
         registerDisposer(() => {
-          canvasElement == null ? void 0 : canvasElement.removeEventListener("pointerup", pointerListener);
+          canvasElement == null ? void 0 : canvasElement.removeEventListener("pointerup", pointerUpListener);
+        });
+        const pointerMoveListener = (event) => {
+          if (!event.isPrimary) {
+            return;
+          }
+          if (event.pointerType === "touch") {
+            return;
+          }
+          processHoverEvent(event);
+        };
+        canvasElement.addEventListener("pointermove", pointerMoveListener, {
+          passive: true
+        });
+        registerDisposer(() => {
+          canvasElement == null ? void 0 : canvasElement.removeEventListener(
+            "pointermove",
+            pointerMoveListener
+          );
         });
       } else {
         const clickListener = (event) => {
           if (event.button !== 0) {
             return;
           }
-          processInteractionEvent(event);
+          processClickEvent(event);
         };
         canvasElement.addEventListener("click", clickListener, {
           passive: true
@@ -23114,7 +23814,7 @@ const createSpriteLayer = (options) => {
           canvasElement == null ? void 0 : canvasElement.removeEventListener("click", clickListener);
         });
         const touchListener = (event) => {
-          processInteractionEvent(event);
+          processClickEvent(event);
         };
         canvasElement.addEventListener("touchend", touchListener, {
           passive: true
@@ -23122,6 +23822,15 @@ const createSpriteLayer = (options) => {
         registerDisposer(() => {
           canvasElement == null ? void 0 : canvasElement.removeEventListener("touchend", touchListener);
         });
+        const mouseMoveListener = (event) => {
+          processHoverEvent(event);
+        };
+        canvasElement.addEventListener("mousemove", mouseMoveListener, {
+          passive: true
+        });
+        registerDisposer(() => {
+          canvasElement == null ? void 0 : canvasElement.removeEventListener("mousemove", mouseMoveListener);
+        });
       }
     }
     const buffer = glContext.createBuffer();
@@ -23215,6 +23924,8 @@ const createSpriteLayer = (options) => {
     attribUvLocation = -1;
     uniformTextureLocation = null;
     uniformOpacityLocation = null;
+    anisotropyExtension = null;
+    maxSupportedAnisotropy = 1;
   };
   const render = (glContext, _options) => {
     hitTestEntries.length = 0;
@@ -23255,41 +23966,8 @@ const createSpriteLayer = (options) => {
       }
       sprite.images.forEach((orderMap) => {
         orderMap.forEach((image) => {
-          const rotationState = image.rotationInterpolationState;
-          if (rotationState) {
-            const evaluation = evaluateNumericInterpolation({
-              state: rotationState,
-              timestamp
-            });
-            if (rotationState.startTimestamp < 0) {
-              rotationState.startTimestamp = evaluation.effectiveStartTimestamp;
-            }
-            image.displayedRotateDeg = normaliseAngleDeg(evaluation.value);
-            if (evaluation.completed) {
-              image.displayedRotateDeg = normaliseAngleDeg(
-                rotationState.finalValue
-              );
-              image.rotationInterpolationState = null;
-            } else {
-              hasActiveInterpolation = true;
-            }
-          }
-          const offsetState = image.offsetInterpolationState;
-          if (offsetState) {
-            const evaluation = evaluateNumericInterpolation({
-              state: offsetState,
-              timestamp
-            });
-            if (offsetState.startTimestamp < 0) {
-              offsetState.startTimestamp = evaluation.effectiveStartTimestamp;
-            }
-            image.offset.offsetDeg = evaluation.value;
-            if (evaluation.completed) {
-              image.offset.offsetDeg = offsetState.finalValue;
-              image.offsetInterpolationState = null;
-            } else {
-              hasActiveInterpolation = true;
-            }
+          if (stepSpriteImageInterpolations(image, timestamp)) {
+            hasActiveInterpolation = true;
           }
         });
       });
@@ -23346,7 +24024,7 @@ const createSpriteLayer = (options) => {
       let screenCornerBuffer = null;
       const anchor = (_a2 = imageEntry.anchor) != null ? _a2 : DEFAULT_ANCHOR;
       const offsetDef = (_b = imageEntry.offset) != null ? _b : DEFAULT_IMAGE_OFFSET;
-      const totalRotateDeg = Number.isFinite(imageEntry.displayedRotateDeg) ? imageEntry.displayedRotateDeg : normaliseAngleDeg(
+      const totalRotateDeg = Number.isFinite(imageEntry.displayedRotateDeg) ? imageEntry.displayedRotateDeg : normalizeAngleDeg(
         ((_c = imageEntry.resolvedBaseRotateDeg) != null ? _c : 0) + ((_d = imageEntry.rotateDeg) != null ? _d : 0)
       );
       const projected = mapInstance.project(spriteEntry.currentLocation);
@@ -23645,7 +24323,7 @@ const createSpriteLayer = (options) => {
               spriteMaxPixel
             }
           );
-          const totalRotateDeg = Number.isFinite(imageEntry.displayedRotateDeg) ? imageEntry.displayedRotateDeg : normaliseAngleDeg(
+          const totalRotateDeg = Number.isFinite(imageEntry.displayedRotateDeg) ? imageEntry.displayedRotateDeg : normalizeAngleDeg(
             ((_e = imageEntry.resolvedBaseRotateDeg) != null ? _e : 0) + ((_f = imageEntry.rotateDeg) != null ? _f : 0)
           );
           const offsetMeters = calculateSurfaceOffsetMeters(
@@ -23765,8 +24443,20 @@ const createSpriteLayer = (options) => {
     glContext.disable(glContext.BLEND);
     scheduleRender();
   };
-  const registerImage = async (imageId, imageSource) => {
-    const bitmap = typeof imageSource === "string" ? await loadImageBitmap(imageSource) : imageSource;
+  const registerImage = async (imageId, imageSource, options2) => {
+    let bitmap;
+    try {
+      bitmap = typeof imageSource === "string" ? await loadImageBitmap(imageSource, options2) : imageSource;
+    } catch (error) {
+      if (error instanceof SvgSizeResolutionError) {
+        console.warn(
+          `[SpriteLayer] Unable to register image "${imageId}": ${error.message}`,
+          error
+        );
+        return false;
+      }
+      throw error;
+    }
     if (images.has(imageId)) {
       return false;
     }
@@ -24215,7 +24905,7 @@ const createSpriteLayer = (options) => {
     if (state.autoRotation) {
       state.resolvedBaseRotateDeg = sprite.lastAutoRotationAngleDeg;
     }
-    updateImageDisplayedRotation(state);
+    syncImageRotationChannel(state);
     setImageState(sprite, state);
     resultOut.isUpdated = true;
     return true;
@@ -24256,41 +24946,32 @@ const createSpriteLayer = (options) => {
     if (imageUpdate.anchor !== void 0) {
       state.anchor = cloneAnchor(imageUpdate.anchor);
     }
-    const rotationInterpolation = imageUpdate.rotationInterpolation;
-    const offsetInterpolationOption = rotationInterpolation == null ? void 0 : rotationInterpolation.offsetDeg;
-    const rotateInterpolationOption = rotationInterpolation == null ? void 0 : rotationInterpolation.rotateDeg;
+    const interpolationOptions = imageUpdate.interpolation;
+    const offsetDegInterpolationOption = interpolationOptions == null ? void 0 : interpolationOptions.offsetDeg;
+    const offsetMetersInterpolationOption = interpolationOptions == null ? void 0 : interpolationOptions.offsetMeters;
+    const rotateInterpolationOption = interpolationOptions == null ? void 0 : interpolationOptions.rotateDeg;
     let rotationOverride;
     let hasRotationOverride = false;
     if (imageUpdate.offset !== void 0) {
-      const newOffset = cloneOffset(imageUpdate.offset);
-      if (offsetInterpolationOption && offsetInterpolationOption.durationMs > 0) {
-        const { state: interpolationState, requiresInterpolation } = createNumericInterpolationState({
-          currentValue: state.offset.offsetDeg,
-          targetValue: newOffset.offsetDeg,
-          options: offsetInterpolationOption
-        });
-        if (requiresInterpolation) {
-          state.offset.offsetMeters = newOffset.offsetMeters;
-          state.offsetInterpolationState = interpolationState;
-        } else {
-          state.offset = newOffset;
-          state.offsetInterpolationState = null;
-        }
-      } else {
-        state.offset = newOffset;
-        state.offsetInterpolationState = null;
+      const clonedOffset = cloneOffset(imageUpdate.offset);
+      applyOffsetUpdate(state, clonedOffset, {
+        deg: offsetDegInterpolationOption,
+        meters: offsetMetersInterpolationOption
+      });
+    } else {
+      if (offsetDegInterpolationOption === null) {
+        clearOffsetDegInterpolation(state);
+      }
+      if (offsetMetersInterpolationOption === null) {
+        clearOffsetMetersInterpolation(state);
       }
-    } else if (offsetInterpolationOption === null) {
-      state.offsetInterpolationState = null;
     }
     if (rotateInterpolationOption !== void 0) {
       if (rotateInterpolationOption === null) {
         state.rotationInterpolationOptions = null;
         rotationOverride = null;
       } else {
-        const cloned = cloneNumericInterpolationOptions(
-          rotateInterpolationOption
-        );
+        const cloned = cloneInterpolationOptions(rotateInterpolationOption);
         state.rotationInterpolationOptions = cloned;
         rotationOverride = cloned;
       }
@@ -24332,7 +25013,7 @@ const createSpriteLayer = (options) => {
       }
     }
     if (requireRotationSync) {
-      updateImageDisplayedRotation(
+      syncImageRotationChannel(
         state,
         // When a rotation override has been computed, pass it along (null clears interpolation); otherwise leave undefined.
         hasRotationOverride ? rotationOverride != null ? rotationOverride : null : void 0
@@ -24497,34 +25178,6 @@ const createSpriteLayer = (options) => {
         return true;
     }
   };
-  const updateBulk = (updateBulkList) => {
-    let updatedCount = 0;
-    let isRequiredRender = false;
-    updateBulkList.forEach((update) => {
-      const result = updateSpriteInternal(update.spriteId, update);
-      switch (result) {
-        case "notfound":
-        // Sprite missing; nothing to do for this entry.
-        case "ignored":
-          break;
-        case "updated":
-          updatedCount++;
-          break;
-        // When rendering must occur because of this update
-        case "isRequiredRender":
-          ensureRenderTargetEntries();
-          scheduleRender();
-          updatedCount++;
-          isRequiredRender = true;
-          break;
-      }
-    });
-    if (isRequiredRender) {
-      ensureRenderTargetEntries();
-      scheduleRender();
-    }
-    return updatedCount;
-  };
   const mutateSprites = (sourceItems, mutator) => {
     if (sourceItems.length === 0) {
       return 0;
@@ -24537,6 +25190,10 @@ const createSpriteLayer = (options) => {
       isUpdated: false
     };
     const updateObject = {
+      isEnabled: void 0,
+      location: void 0,
+      interpolation: void 0,
+      tag: void 0,
       getImageIndexMap: () => {
         const map2 = /* @__PURE__ */ new Map();
         currentSprite.images.forEach((inner, subLayer) => {
@@ -24730,7 +25387,6 @@ const createSpriteLayer = (options) => {
     updateSpriteImage,
     removeSpriteImage,
     updateSprite,
-    updateBulk,
     mutateSprites,
     updateForEach,
     on: addEventListener2,
@@ -24739,7 +25395,10 @@ const createSpriteLayer = (options) => {
   return spriteLayout;
 };
 export {
+  BETTER_TEXTURE_FILTERING_OPTIONS,
+  DEFAULT_TEXTURE_FILTERING_OPTIONS,
   STANDARD_SPRITE_SCALING_OPTIONS,
+  SvgSizeResolutionError,
   UNLIMITED_SPRITE_SCALING_OPTIONS,
   applyAutoRotation,
   calculatePerspectiveRatio,
@@ -24750,7 +25409,9 @@ export {
   createImageStateFromInit,
   createShaderProgram,
   createSpriteLayer,
+  loadImageBitmap,
   multiplyMatrixAndVector,
-  projectLngLatToClipSpace
+  projectLngLatToClipSpace,
+  readImageBitmap
 };
 //# sourceMappingURL=index.mjs.map