@nulib/clover 0.0.0-stage → 4.0.0-beta.0

package/dist/lib/renderer/backends/backend.mjs

@@ -0,0 +1,21 @@
+"use client";
+function hasPixels(source) {
+  if (typeof HTMLImageElement !== "undefined" && source instanceof HTMLImageElement) {
+    return source.complete && source.naturalWidth > 0;
+  }
+  return true;
+}
+function bleedInSourcePixels(command, pixelRatio) {
+  if (!command.bleed) return { x: 0, y: 0 };
+  const m = command.transform;
+  const sx = Math.hypot(m.a, m.b) * pixelRatio;
+  const sy = Math.hypot(m.c, m.d) * pixelRatio;
+  return {
+    x: command.bleed.right && sx > 0 ? 1 / sx : 0,
+    y: command.bleed.bottom && sy > 0 ? 1 / sy : 0
+  };
+}
+export {
+  bleedInSourcePixels,
+  hasPixels
+};

package/dist/lib/renderer/backends/canvas2d/Canvas2DBackend.mjs

@@ -0,0 +1,91 @@
+"use client";
+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);
+import { hasPixels, bleedInSourcePixels } from "../backend.mjs";
+class Canvas2DBackend {
+  constructor(canvas, ctx) {
+    __publicField(this, "kind", "canvas2d");
+    __publicField(this, "canvas");
+    __publicField(this, "ctx");
+    __publicField(this, "pixelRatio", 1);
+    /**
+     * Sources drawn before. An accelerated 2D canvas uploads a bitmap to the GPU on its
+     * first draw, so the renderer's upload budget applies here too.
+     */
+    __publicField(this, "drawn", /* @__PURE__ */ new Set());
+    this.canvas = canvas;
+    this.ctx = ctx;
+  }
+  static create(canvas) {
+    let ctx = null;
+    try {
+      ctx = canvas.getContext("2d", { alpha: true });
+    } catch {
+      ctx = null;
+    }
+    if (!ctx || typeof ctx.drawImage !== "function") return null;
+    return new Canvas2DBackend(canvas, ctx);
+  }
+  resize(width, height, pixelRatio) {
+    this.pixelRatio = pixelRatio;
+    const w = Math.max(1, Math.round(width * pixelRatio));
+    const h = Math.max(1, Math.round(height * pixelRatio));
+    if (this.canvas.width !== w) this.canvas.width = w;
+    if (this.canvas.height !== h) this.canvas.height = h;
+  }
+  begin() {
+    const ctx = this.ctx;
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.globalAlpha = 1;
+    ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = "high";
+  }
+  draw(command) {
+    if (!hasPixels(command.source)) return "skipped";
+    const ctx = this.ctx;
+    const m = command.transform;
+    const r = this.pixelRatio;
+    const crop = command.crop ?? {
+      x: 0,
+      y: 0,
+      width: command.width,
+      height: command.height
+    };
+    const bleed = bleedInSourcePixels(command, r);
+    ctx.setTransform(r * m.a, r * m.b, r * m.c, r * m.d, r * m.e, r * m.f);
+    ctx.globalAlpha = command.opacity;
+    ctx.drawImage(
+      command.source,
+      crop.x,
+      crop.y,
+      crop.width,
+      crop.height,
+      crop.x,
+      crop.y,
+      crop.width + bleed.x,
+      crop.height + bleed.y
+    );
+    this.drawn.add(command.key);
+    return "drawn";
+  }
+  end() {
+    this.ctx.setTransform(1, 0, 0, 1, 0, 0);
+    this.ctx.globalAlpha = 1;
+  }
+  has(key) {
+    return this.drawn.has(key);
+  }
+  release(key) {
+    this.drawn.delete(key);
+  }
+  dispose() {
+    this.drawn.clear();
+    this.canvas.width = 0;
+    this.canvas.height = 0;
+  }
+}
+export {
+  Canvas2DBackend
+};

package/dist/lib/renderer/backends/contexts.mjs

@@ -0,0 +1,27 @@
+"use client";
+const MAX_CONTEXTS = 6;
+const holders = /* @__PURE__ */ new Set();
+function claimContext(holder) {
+  if (holders.has(holder)) return true;
+  while (holders.size >= MAX_CONTEXTS) {
+    let idle;
+    for (const each of holders) {
+      if (each.hiddenSince !== null && (!idle || each.hiddenSince < idle.hiddenSince)) {
+        idle = each;
+      }
+    }
+    if (!idle) return false;
+    holders.delete(idle);
+    idle.release();
+  }
+  holders.add(holder);
+  return true;
+}
+function returnContext(holder) {
+  holders.delete(holder);
+}
+export {
+  MAX_CONTEXTS,
+  claimContext,
+  returnContext
+};

package/dist/lib/renderer/backends/dom/DomLayers.mjs

@@ -0,0 +1,91 @@
+"use client";
+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);
+import { toCssMatrix, compose, translate } from "../../math/affine.mjs";
+class DomLayers {
+  constructor(parent) {
+    __publicField(this, "container");
+    __publicField(this, "boxes", /* @__PURE__ */ new Map());
+    const container = document.createElement("div");
+    container.className = "clover-canvas-dom-layer";
+    Object.assign(container.style, {
+      position: "absolute",
+      inset: "0",
+      overflow: "hidden",
+      pointerEvents: "none"
+    });
+    parent.appendChild(container);
+    this.container = container;
+  }
+  /** Place every item for this frame, in paint order; anything not listed is removed. */
+  sync(items) {
+    const seen = /* @__PURE__ */ new Set();
+    items.forEach((item, index) => {
+      seen.add(item.key);
+      const box = this.boxFor(item);
+      const crop = item.crop ?? {
+        x: 0,
+        y: 0,
+        width: item.width,
+        height: item.height
+      };
+      box.style.width = `${crop.width}px`;
+      box.style.height = `${crop.height}px`;
+      box.style.transform = toCssMatrix(
+        compose(item.transform, translate(crop.x, crop.y))
+      );
+      box.style.opacity = String(item.opacity);
+      box.style.zIndex = String(index);
+      const el = item.element;
+      el.style.width = `${item.width}px`;
+      el.style.height = `${item.height}px`;
+      el.style.transform = `translate(${-crop.x}px, ${-crop.y}px)`;
+    });
+    for (const [key, box] of this.boxes) {
+      if (!seen.has(key)) {
+        box.remove();
+        this.boxes.delete(key);
+      }
+    }
+  }
+  dispose() {
+    this.boxes.clear();
+    this.container.remove();
+  }
+  boxFor(item) {
+    let box = this.boxes.get(item.key);
+    if (box && box.firstChild !== item.element) {
+      box.remove();
+      box = void 0;
+    }
+    if (!box) {
+      box = document.createElement("div");
+      box.className = "clover-canvas-dom-item";
+      box.dataset.key = item.key;
+      Object.assign(box.style, {
+        position: "absolute",
+        top: "0",
+        left: "0",
+        overflow: "hidden",
+        transformOrigin: "0 0"
+      });
+      item.element.classList.add("clover-canvas-dom-media");
+      Object.assign(item.element.style, {
+        position: "absolute",
+        top: "0",
+        left: "0",
+        maxWidth: "none",
+        maxHeight: "none",
+        transformOrigin: "0 0"
+      });
+      box.appendChild(item.element);
+      this.container.appendChild(box);
+      this.boxes.set(item.key, box);
+    }
+    return box;
+  }
+}
+export {
+  DomLayers
+};

package/dist/lib/renderer/backends/webgl2/WebGL2Backend.mjs

@@ -0,0 +1,248 @@
+"use client";
+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);
+import { hasPixels, bleedInSourcePixels } from "../backend.mjs";
+import { FRAGMENT_SHADER, VERTEX_SHADER } from "./shaders.mjs";
+import { compose, scale, translate, toClipMat3 } from "../../math/affine.mjs";
+class WebGL2Backend {
+  constructor(canvas, gl, callbacks) {
+    __publicField(this, "kind", "webgl2");
+    __publicField(this, "canvas");
+    __publicField(this, "maxTextureSize");
+    __publicField(this, "gl");
+    __publicField(this, "program", null);
+    __publicField(this, "vao", null);
+    __publicField(this, "uniforms", { matrix: null, crop: null, opacity: null, texture: null });
+    __publicField(this, "textures", /* @__PURE__ */ new Map());
+    __publicField(this, "cssWidth", 1);
+    __publicField(this, "cssHeight", 1);
+    __publicField(this, "pixelRatio", 1);
+    __publicField(this, "matrixScratch", new Float32Array(9));
+    __publicField(this, "isLost", false);
+    __publicField(this, "callbacks");
+    /*
+     * The browser took the context. Nothing waits for it back: the renderer lets this
+     * backend and its canvas go at once (`onLost`), and draws on another.
+     */
+    __publicField(this, "handleLost", () => {
+      var _a, _b;
+      this.isLost = true;
+      this.textures.clear();
+      (_b = (_a = this.callbacks).onLost) == null ? void 0 : _b.call(_a);
+    });
+    this.canvas = canvas;
+    this.gl = gl;
+    this.callbacks = callbacks;
+    this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE) || 4096;
+    const program = linkProgram(gl, VERTEX_SHADER, FRAGMENT_SHADER);
+    this.program = program;
+    this.uniforms = {
+      matrix: gl.getUniformLocation(program, "u_matrix"),
+      crop: gl.getUniformLocation(program, "u_crop"),
+      opacity: gl.getUniformLocation(program, "u_opacity"),
+      texture: gl.getUniformLocation(program, "u_texture")
+    };
+    const vao = gl.createVertexArray();
+    gl.bindVertexArray(vao);
+    const buffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.bufferData(
+      gl.ARRAY_BUFFER,
+      new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]),
+      gl.STATIC_DRAW
+    );
+    const location = gl.getAttribLocation(program, "a_position");
+    gl.enableVertexAttribArray(location);
+    gl.vertexAttribPointer(location, 2, gl.FLOAT, false, 0, 0);
+    gl.bindVertexArray(null);
+    this.vao = vao;
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+    gl.pixelStorei(
+      gl.UNPACK_COLORSPACE_CONVERSION_WEBGL,
+      gl.BROWSER_DEFAULT_WEBGL
+    );
+    canvas.addEventListener("webglcontextlost", this.handleLost);
+  }
+  /** Returns null when WebGL2 is unavailable, so the caller can fall back. */
+  static create(canvas, callbacks = {}) {
+    let gl = null;
+    try {
+      gl = canvas.getContext("webgl2", {
+        alpha: true,
+        premultipliedAlpha: true,
+        antialias: false,
+        depth: false,
+        stencil: false,
+        preserveDrawingBuffer: false
+      });
+    } catch {
+      gl = null;
+    }
+    if (!gl || typeof gl.createShader !== "function") return null;
+    try {
+      return new WebGL2Backend(canvas, gl, callbacks);
+    } catch {
+      return null;
+    }
+  }
+  resize(width, height, pixelRatio) {
+    this.cssWidth = Math.max(1, width);
+    this.cssHeight = Math.max(1, height);
+    this.pixelRatio = pixelRatio;
+    const w = Math.max(1, Math.round(width * pixelRatio));
+    const h = Math.max(1, Math.round(height * pixelRatio));
+    if (this.canvas.width !== w) this.canvas.width = w;
+    if (this.canvas.height !== h) this.canvas.height = h;
+  }
+  begin() {
+    if (this.isLost) return;
+    const gl = this.gl;
+    gl.viewport(0, 0, this.canvas.width, this.canvas.height);
+    gl.clearColor(0, 0, 0, 0);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    gl.useProgram(this.program);
+    gl.bindVertexArray(this.vao);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.uniform1i(this.uniforms.texture, 0);
+  }
+  draw(command) {
+    if (this.isLost) return "skipped";
+    if (!hasPixels(command.source)) return "skipped";
+    const gl = this.gl;
+    const entry = this.upload(command);
+    if (entry === "tainted") return "tainted";
+    if (!entry) return "skipped";
+    const crop = command.crop ?? {
+      x: 0,
+      y: 0,
+      width: command.width,
+      height: command.height
+    };
+    const bleed = bleedInSourcePixels(command, this.pixelRatio);
+    const quad = compose(
+      command.transform,
+      translate(crop.x, crop.y),
+      scale(crop.width + bleed.x, crop.height + bleed.y)
+    );
+    gl.uniformMatrix3fv(
+      this.uniforms.matrix,
+      false,
+      toClipMat3(quad, this.cssWidth, this.cssHeight, this.matrixScratch)
+    );
+    gl.uniform4f(
+      this.uniforms.crop,
+      crop.x / command.width,
+      crop.y / command.height,
+      crop.width / command.width,
+      crop.height / command.height
+    );
+    gl.uniform1f(this.uniforms.opacity, command.opacity);
+    gl.bindTexture(gl.TEXTURE_2D, entry.texture);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    return "drawn";
+  }
+  end() {
+    if (this.isLost) return;
+    this.gl.bindVertexArray(null);
+  }
+  has(key) {
+    return !this.isLost && this.textures.has(key);
+  }
+  release(key) {
+    const entry = this.textures.get(key);
+    if (!entry) return;
+    if (!this.isLost) this.gl.deleteTexture(entry.texture);
+    this.textures.delete(key);
+  }
+  dispose() {
+    var _a;
+    this.canvas.removeEventListener("webglcontextlost", this.handleLost);
+    if (!this.isLost) {
+      for (const key of [...this.textures.keys()]) this.release(key);
+      if (this.program) this.gl.deleteProgram(this.program);
+      if (this.vao) this.gl.deleteVertexArray(this.vao);
+    }
+    this.textures.clear();
+    (_a = this.gl.getExtension("WEBGL_lose_context")) == null ? void 0 : _a.loseContext();
+    this.isLost = true;
+  }
+  upload(command) {
+    const gl = this.gl;
+    const existing = this.textures.get(command.key);
+    if (existing && existing.width === command.width && existing.height === command.height) {
+      return existing;
+    }
+    const texture = (existing == null ? void 0 : existing.texture) ?? gl.createTexture();
+    if (!texture) return null;
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    try {
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        command.source
+      );
+    } catch (error) {
+      if (!existing) gl.deleteTexture(texture);
+      if (isSecurityError(error)) return "tainted";
+      throw error;
+    }
+    gl.generateMipmap(gl.TEXTURE_2D);
+    gl.texParameteri(
+      gl.TEXTURE_2D,
+      gl.TEXTURE_MIN_FILTER,
+      gl.LINEAR_MIPMAP_LINEAR
+    );
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    const entry = {
+      texture,
+      width: command.width,
+      height: command.height
+    };
+    this.textures.set(command.key, entry);
+    return entry;
+  }
+}
+function linkProgram(gl, vertexSource, fragmentSource) {
+  const vertex = compileShader(gl, gl.VERTEX_SHADER, vertexSource);
+  const fragment = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
+  const program = gl.createProgram();
+  if (!program) throw new Error("Could not create WebGL program");
+  gl.attachShader(program, vertex);
+  gl.attachShader(program, fragment);
+  gl.linkProgram(program);
+  gl.deleteShader(vertex);
+  gl.deleteShader(fragment);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(program);
+    gl.deleteProgram(program);
+    throw new Error(`Could not link WebGL program: ${log}`);
+  }
+  return program;
+}
+function compileShader(gl, type, source) {
+  const shader = gl.createShader(type);
+  if (!shader) throw new Error("Could not create WebGL shader");
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    throw new Error(`Could not compile WebGL shader: ${log}`);
+  }
+  return shader;
+}
+function isSecurityError(error) {
+  return typeof error === "object" && error !== null && error.name === "SecurityError";
+}
+export {
+  WebGL2Backend
+};

package/dist/lib/renderer/backends/webgl2/shaders.mjs

@@ -0,0 +1,28 @@
+"use client";
+const VERTEX_SHADER = `#version 300 es
+in vec2 a_position;
+uniform mat3 u_matrix;
+uniform vec4 u_crop;
+out vec2 v_uv;
+
+void main() {
+  vec3 clip = u_matrix * vec3(a_position, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  v_uv = u_crop.xy + a_position * u_crop.zw;
+}
+`;
+const FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_texture;
+uniform float u_opacity;
+out vec4 outColor;
+
+void main() {
+  outColor = texture(u_texture, v_uv) * u_opacity;
+}
+`;
+export {
+  FRAGMENT_SHADER,
+  VERTEX_SHADER
+};

package/dist/lib/renderer/camera/Camera.mjs

@@ -0,0 +1,64 @@
+"use client";
+import { apply, compose, rotate, translate, scale } from "../math/affine.mjs";
+import { transformRect, rectCenter } from "../math/rect.mjs";
+function worldToScreen(camera, viewport) {
+  return compose(
+    translate(viewport.width / 2, viewport.height / 2),
+    rotate(camera.rotation),
+    scale(camera.zoom),
+    translate(-camera.x, -camera.y)
+  );
+}
+function screenToWorld(camera, viewport) {
+  return compose(
+    translate(camera.x, camera.y),
+    scale(1 / camera.zoom),
+    rotate(-camera.rotation),
+    translate(-viewport.width / 2, -viewport.height / 2)
+  );
+}
+function screenPointToWorld(camera, viewport, point) {
+  return apply(screenToWorld(camera, viewport), point);
+}
+function worldPointToScreen(camera, viewport, point) {
+  return apply(worldToScreen(camera, viewport), point);
+}
+function visibleWorldRect(camera, viewport) {
+  return transformRect(screenToWorld(camera, viewport), {
+    x: 0,
+    y: 0,
+    width: viewport.width,
+    height: viewport.height
+  });
+}
+function fitCamera(bounds, viewport, rotation = 0, padding = 0) {
+  const rotated = transformRect(rotate(rotation), bounds);
+  const usableW = Math.max(1, viewport.width * (1 - padding * 2));
+  const usableH = Math.max(1, viewport.height * (1 - padding * 2));
+  const zoom = Math.min(
+    usableW / Math.max(rotated.width, Number.EPSILON),
+    usableH / Math.max(rotated.height, Number.EPSILON)
+  );
+  const center = rectCenter(bounds);
+  return { x: center.x, y: center.y, zoom, rotation };
+}
+function anchoredCenter(anchor, screen, zoom, rotation, viewport) {
+  const offset = apply(compose(scale(1 / zoom), rotate(-rotation)), {
+    x: screen.x - viewport.width / 2,
+    y: screen.y - viewport.height / 2
+  });
+  return { x: anchor.x - offset.x, y: anchor.y - offset.y };
+}
+function sameCamera(a, b) {
+  return a.x === b.x && a.y === b.y && a.zoom === b.zoom && a.rotation === b.rotation;
+}
+export {
+  anchoredCenter,
+  fitCamera,
+  sameCamera,
+  screenPointToWorld,
+  screenToWorld,
+  visibleWorldRect,
+  worldPointToScreen,
+  worldToScreen
+};

package/dist/lib/renderer/camera/CameraAnimator.mjs

@@ -0,0 +1,90 @@
+"use client";
+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);
+import { anchoredCenter } from "./Camera.mjs";
+const DEFAULT_TIME_CONSTANT = 0.09;
+const ZOOM_EPSILON = 1e-4;
+const PIXEL_EPSILON = 0.05;
+const ROTATION_EPSILON = 1e-4;
+class CameraAnimator {
+  constructor(initial, timeConstant = DEFAULT_TIME_CONSTANT) {
+    __publicField(this, "current");
+    __publicField(this, "target", null);
+    __publicField(this, "timeConstant");
+    this.current = { ...initial };
+    this.timeConstant = timeConstant;
+  }
+  /** The state the camera is heading to (or at, when idle). */
+  get destination() {
+    return this.target ? { ...this.target.state } : { ...this.current };
+  }
+  /** Jump, canceling any animation. Used by drags, which must track the pointer 1:1. */
+  set(state) {
+    this.current = { ...state };
+    this.target = null;
+  }
+  animateTo(target, viewport, immediate = false) {
+    if (immediate || this.timeConstant === 0) {
+      this.set(target.state);
+      return;
+    }
+    let anchor = target.anchor;
+    if (anchor) {
+      const landing = anchoredCenter(
+        anchor.world,
+        anchor.screen,
+        target.state.zoom,
+        target.state.rotation,
+        viewport
+      );
+      const miss = Math.hypot(landing.x - target.state.x, landing.y - target.state.y) * target.state.zoom;
+      if (miss > PIXEL_EPSILON) anchor = void 0;
+    }
+    this.target = { state: { ...target.state }, anchor };
+  }
+  stop() {
+    this.target = null;
+  }
+  /**
+   * Advance by `dt` seconds. Returns true while still moving, so the frame loop knows to
+   * keep ticking.
+   */
+  step(dt, viewport) {
+    const target = this.target;
+    if (!target) return false;
+    const k = 1 - Math.exp(-Math.max(dt, 0) / this.timeConstant);
+    const from = this.current;
+    const to = target.state;
+    const zoom = Math.exp(
+      Math.log(from.zoom) + (Math.log(to.zoom) - Math.log(from.zoom)) * k
+    );
+    const rotation = from.rotation + (to.rotation - from.rotation) * k;
+    let center;
+    if (target.anchor) {
+      center = anchoredCenter(
+        target.anchor.world,
+        target.anchor.screen,
+        zoom,
+        rotation,
+        viewport
+      );
+    } else {
+      center = {
+        x: from.x + (to.x - from.x) * k,
+        y: from.y + (to.y - from.y) * k
+      };
+    }
+    this.current = { x: center.x, y: center.y, zoom, rotation };
+    const settled = Math.abs(Math.log(to.zoom / zoom)) < ZOOM_EPSILON && Math.abs(to.rotation - rotation) < ROTATION_EPSILON && Math.hypot(to.x - center.x, to.y - center.y) * zoom < PIXEL_EPSILON;
+    if (settled) {
+      this.current = { ...to };
+      this.target = null;
+      return false;
+    }
+    return true;
+  }
+}
+export {
+  CameraAnimator
+};