@marimo-team/frontend 0.19.7-dev35 → 0.19.7-dev36

package/src/utils/__tests__/async-capture-tracker.test.ts

@@ -0,0 +1,353 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { beforeEach, describe, expect, it } from "vitest";
+import { AsyncCaptureTracker } from "../async-capture-tracker";
+
+describe("AsyncCaptureTracker", () => {
+  let tracker: AsyncCaptureTracker<string, string>;
+
+  beforeEach(() => {
+    tracker = new AsyncCaptureTracker();
+  });
+
+  describe("needsCapture", () => {
+    it("should return true for keys not yet captured", () => {
+      expect(tracker.needsCapture("a", "value1")).toBe(true);
+    });
+
+    it("should return false for keys captured with the same value", () => {
+      const handle = tracker.startCapture("a", "value1");
+      handle.markCaptured("result");
+      expect(tracker.needsCapture("a", "value1")).toBe(false);
+    });
+
+    it("should return true for keys captured with a different value", () => {
+      const handle = tracker.startCapture("a", "value1");
+      handle.markCaptured("result");
+      expect(tracker.needsCapture("a", "value2")).toBe(true);
+    });
+
+    it("should return false for keys in-flight with the same value", () => {
+      tracker.startCapture("a", "value1");
+      expect(tracker.needsCapture("a", "value1")).toBe(false);
+    });
+
+    it("should return true for keys in-flight with a different value", () => {
+      tracker.startCapture("a", "value1");
+      expect(tracker.needsCapture("a", "value2")).toBe(true);
+    });
+
+    it("should return true for keys that failed (returned to idle)", () => {
+      const handle = tracker.startCapture("a", "value1");
+      handle.markFailed();
+      expect(tracker.needsCapture("a", "value1")).toBe(true);
+    });
+  });
+
+  describe("startCapture", () => {
+    it("should return a handle with a non-aborted signal", () => {
+      const handle = tracker.startCapture("a", "v");
+      expect(handle.signal.aborted).toBe(false);
+    });
+
+    it("should abort only the same key's previous signal", () => {
+      const handleA = tracker.startCapture("a", "v1");
+      const handleB = tracker.startCapture("b", "v1");
+      const handleA2 = tracker.startCapture("a", "v2");
+
+      expect(handleA.signal.aborted).toBe(true);
+      expect(handleB.signal.aborted).toBe(false);
+      expect(handleA2.signal.aborted).toBe(false);
+
+      // Unrelated key still completes independently
+      handleB.markCaptured("result-b");
+      expect(tracker.needsCapture("b", "v1")).toBe(false);
+    });
+
+    it("should not abort other keys when one is re-captured", () => {
+      tracker.startCapture("a", "v");
+      tracker.startCapture("b", "v");
+      tracker.startCapture("c", "v");
+
+      const handleB2 = tracker.startCapture("b", "v2");
+
+      expect(tracker.needsCapture("a", "v")).toBe(false); // still in-flight
+      expect(tracker.needsCapture("c", "v")).toBe(false); // still in-flight
+      expect(handleB2.signal.aborted).toBe(false);
+    });
+
+    it("should mark key as in-flight", () => {
+      tracker.startCapture("a", "v");
+      expect(tracker.isCapturing).toBe(true);
+      expect(tracker.needsCapture("a", "v")).toBe(false);
+    });
+  });
+
+  describe("handle.markCaptured", () => {
+    it("should remove key from in-flight", () => {
+      const handle = tracker.startCapture("a", "v");
+      expect(tracker.isCapturing).toBe(true);
+      handle.markCaptured("result");
+      expect(tracker.isCapturing).toBe(false);
+    });
+
+    it("should persist the captured value", () => {
+      const handle = tracker.startCapture("a", "value1");
+      handle.markCaptured("result");
+      expect(tracker.needsCapture("a", "value1")).toBe(false);
+      expect(tracker.needsCapture("a", "value2")).toBe(true);
+    });
+
+    it("should update the captured value on re-capture", () => {
+      const h1 = tracker.startCapture("a", "v1");
+      h1.markCaptured("r1");
+
+      const h2 = tracker.startCapture("a", "v2");
+      h2.markCaptured("r2");
+
+      expect(tracker.needsCapture("a", "v1")).toBe(true);
+      expect(tracker.needsCapture("a", "v2")).toBe(false);
+    });
+
+    it("should be a no-op when handle is stale (superseded)", () => {
+      const handle1 = tracker.startCapture("a", "v1");
+      const handle2 = tracker.startCapture("a", "v2");
+
+      // handle1 is stale — markCaptured should not affect state
+      handle1.markCaptured("stale-result");
+
+      // "a" should still be in-flight with v2
+      expect(tracker.needsCapture("a", "v2")).toBe(false); // in-flight
+      expect(tracker.needsCapture("a", "v1")).toBe(true); // not captured
+      expect(tracker.isCapturing).toBe(true);
+
+      // handle2 still works
+      handle2.markCaptured("real-result");
+      expect(tracker.needsCapture("a", "v2")).toBe(false); // captured
+      expect(tracker.isCapturing).toBe(false);
+    });
+  });
+
+  describe("handle.markFailed", () => {
+    it("should remove key from in-flight", () => {
+      const handle = tracker.startCapture("a", "v");
+      handle.markFailed();
+      expect(tracker.isCapturing).toBe(false);
+    });
+
+    it("should not add a captured entry", () => {
+      const handle = tracker.startCapture("a", "v");
+      handle.markFailed();
+      expect(tracker.needsCapture("a", "v")).toBe(true);
+    });
+
+    it("should not clear a previously captured value", () => {
+      const h1 = tracker.startCapture("a", "v1");
+      h1.markCaptured("r1");
+
+      const h2 = tracker.startCapture("a", "v2");
+      h2.markFailed();
+
+      expect(tracker.needsCapture("a", "v1")).toBe(false);
+      expect(tracker.needsCapture("a", "v2")).toBe(true);
+    });
+
+    it("should be a no-op when handle is stale", () => {
+      const handle1 = tracker.startCapture("a", "v1");
+      tracker.startCapture("a", "v2");
+
+      handle1.markFailed();
+
+      // "a" should still be in-flight with v2
+      expect(tracker.isCapturing).toBe(true);
+      expect(tracker.needsCapture("a", "v2")).toBe(false);
+    });
+  });
+
+  describe("waitForInFlight", () => {
+    it("should return a promise for in-flight key with same value", async () => {
+      const handle = tracker.startCapture("a", "v1");
+      const promise = tracker.waitForInFlight("a", "v1");
+      expect(promise).not.toBeNull();
+
+      handle.markCaptured("result-a");
+      const result = await promise;
+      expect(result).toBe("result-a");
+    });
+
+    it("should return null for captured key (not in-flight)", () => {
+      const handle = tracker.startCapture("a", "v1");
+      handle.markCaptured("result");
+      expect(tracker.waitForInFlight("a", "v1")).toBeNull();
+    });
+
+    it("should return null for key not being tracked", () => {
+      expect(tracker.waitForInFlight("a", "v1")).toBeNull();
+    });
+
+    it("should return null for in-flight key with different value", () => {
+      tracker.startCapture("a", "v1");
+      expect(tracker.waitForInFlight("a", "v2")).toBeNull();
+    });
+
+    it("should resolve with undefined when capture fails", async () => {
+      const handle = tracker.startCapture("a", "v1");
+      const promise = tracker.waitForInFlight("a", "v1");
+
+      handle.markFailed();
+      const result = await promise;
+      expect(result).toBeUndefined();
+    });
+
+    it("should resolve with undefined when capture is superseded", async () => {
+      tracker.startCapture("a", "v1");
+      const promise = tracker.waitForInFlight("a", "v1");
+
+      // Supersede with new capture
+      tracker.startCapture("a", "v2");
+      const result = await promise;
+      expect(result).toBeUndefined();
+    });
+
+    it("should resolve with undefined when aborted", async () => {
+      tracker.startCapture("a", "v1");
+      const promise = tracker.waitForInFlight("a", "v1");
+
+      tracker.abort();
+      const result = await promise;
+      expect(result).toBeUndefined();
+    });
+
+    it("should allow multiple waiters on the same key", async () => {
+      const handle = tracker.startCapture("a", "v1");
+      const p1 = tracker.waitForInFlight("a", "v1");
+      const p2 = tracker.waitForInFlight("a", "v1");
+
+      handle.markCaptured("shared-result");
+
+      const [r1, r2] = await Promise.all([p1, p2]);
+      expect(r1).toBe("shared-result");
+      expect(r2).toBe("shared-result");
+    });
+  });
+
+  describe("prune", () => {
+    it("should remove captured entries for keys not in the set", () => {
+      const hA = tracker.startCapture("a", "v1");
+      hA.markCaptured("r1");
+      const hB = tracker.startCapture("b", "v2");
+      hB.markCaptured("r2");
+
+      tracker.prune(new Set(["a"]));
+
+      expect(tracker.needsCapture("a", "v1")).toBe(false);
+      expect(tracker.needsCapture("b", "v2")).toBe(true);
+    });
+
+    it("should abort and remove in-flight entries for pruned keys", () => {
+      const handleA = tracker.startCapture("a", "v");
+      const handleB = tracker.startCapture("b", "v");
+
+      tracker.prune(new Set(["a"]));
+
+      expect(handleA.signal.aborted).toBe(false);
+      expect(handleB.signal.aborted).toBe(true);
+      expect(tracker.needsCapture("b", "v")).toBe(true);
+    });
+
+    it("should resolve pruned in-flight deferreds with undefined", async () => {
+      tracker.startCapture("b", "v");
+      const promise = tracker.waitForInFlight("b", "v");
+
+      tracker.prune(new Set(["a"]));
+      const result = await promise;
+      expect(result).toBeUndefined();
+    });
+
+    it("should do nothing if all keys are current", () => {
+      const hA = tracker.startCapture("a", "v1");
+      hA.markCaptured("r1");
+      const hB = tracker.startCapture("b", "v2");
+      hB.markCaptured("r2");
+
+      tracker.prune(new Set(["a", "b"]));
+
+      expect(tracker.needsCapture("a", "v1")).toBe(false);
+      expect(tracker.needsCapture("b", "v2")).toBe(false);
+    });
+  });
+
+  describe("abort", () => {
+    it("should abort all in-flight signals", () => {
+      const handleA = tracker.startCapture("a", "v");
+      const handleB = tracker.startCapture("b", "v");
+      tracker.abort();
+      expect(handleA.signal.aborted).toBe(true);
+      expect(handleB.signal.aborted).toBe(true);
+    });
+
+    it("should clear in-flight state", () => {
+      tracker.startCapture("a", "v");
+      tracker.abort();
+      expect(tracker.isCapturing).toBe(false);
+      expect(tracker.needsCapture("a", "v")).toBe(true);
+    });
+
+    it("should not clear captured state", () => {
+      const handle = tracker.startCapture("a", "v1");
+      handle.markCaptured("result");
+      tracker.abort();
+      expect(tracker.needsCapture("a", "v1")).toBe(false);
+    });
+  });
+
+  describe("reset", () => {
+    it("should clear all state", () => {
+      const hA = tracker.startCapture("a", "v1");
+      hA.markCaptured("r1");
+      tracker.startCapture("b", "v2");
+
+      tracker.reset();
+
+      expect(tracker.isCapturing).toBe(false);
+      expect(tracker.needsCapture("a", "v1")).toBe(true);
+      expect(tracker.needsCapture("b", "v2")).toBe(true);
+    });
+  });
+
+  describe("isCapturing", () => {
+    it("should be false when nothing is in-flight", () => {
+      expect(tracker.isCapturing).toBe(false);
+    });
+
+    it("should be true when items are in-flight", () => {
+      tracker.startCapture("a", "v");
+      expect(tracker.isCapturing).toBe(true);
+    });
+
+    it("should be false when all items are completed", () => {
+      const hA = tracker.startCapture("a", "v");
+      const hB = tracker.startCapture("b", "v");
+      hA.markCaptured("r");
+      hB.markFailed();
+      expect(tracker.isCapturing).toBe(false);
+    });
+  });
+
+  describe("granular abort", () => {
+    it("should allow independent completion of unrelated keys", () => {
+      const hA = tracker.startCapture("a", "v1");
+      tracker.startCapture("b", "v1");
+      const hC = tracker.startCapture("c", "v1");
+
+      hA.markCaptured("ra");
+      tracker.startCapture("b", "v2"); // abort old "b", start new
+      hC.markCaptured("rc");
+
+      expect(tracker.needsCapture("a", "v1")).toBe(false);
+      expect(tracker.needsCapture("c", "v1")).toBe(false);
+      expect(tracker.needsCapture("b", "v2")).toBe(false); // in-flight
+      expect(tracker.needsCapture("b", "v1")).toBe(true);
+    });
+  });
+});

package/src/utils/__tests__/download.test.tsx

@@ -166,51 +166,6 @@ describe("getImageDataUrlForCell", () => {
     );
   });
 
-  it("should add printing classes before capture when snappy is false", async () => {
-    vi.mocked(toPng).mockImplementation(async () => {
-      // Check classes are applied during capture
-      expect(mockElement.classList.contains("printing-output")).toBe(true);
-      expect(document.body.classList.contains("printing")).toBe(true);
-      expect(mockElement.style.overflow).toBe("auto");
-      return mockDataUrl;
-    });
-
-    await getImageDataUrlForCell("cell-1" as CellId, false);
-  });
-
-  it("should remove printing classes after capture when snappy is false", async () => {
-    vi.mocked(toPng).mockResolvedValue(mockDataUrl);
-
-    await getImageDataUrlForCell("cell-1" as CellId, false);
-
-    expect(mockElement.classList.contains("printing-output")).toBe(false);
-    expect(document.body.classList.contains("printing")).toBe(false);
-  });
-
-  it("should add printing-output but NOT body.printing when snappy is true", async () => {
-    vi.mocked(toPng).mockImplementation(async () => {
-      // printing-output should still be added to the element
-      expect(mockElement.classList.contains("printing-output")).toBe(true);
-      // but body.printing should NOT be added when snappy mode is on
-      expect(document.body.classList.contains("printing")).toBe(false);
-      expect(mockElement.style.overflow).toBe("auto");
-      return mockDataUrl;
-    });
-
-    await getImageDataUrlForCell("cell-1" as CellId, true);
-  });
-
-  it("should cleanup printing-output when snappy is true", async () => {
-    mockElement.style.overflow = "hidden";
-    vi.mocked(toPng).mockResolvedValue(mockDataUrl);
-
-    await getImageDataUrlForCell("cell-1" as CellId, true);
-
-    expect(mockElement.classList.contains("printing-output")).toBe(false);
-    expect(document.body.classList.contains("printing")).toBe(false);
-    expect(mockElement.style.overflow).toBe("hidden");
-  });
-
   it("should restore original overflow style after capture", async () => {
     mockElement.style.overflow = "hidden";
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
@@ -234,88 +189,27 @@ describe("getImageDataUrlForCell", () => {
 
     await expect(getImageDataUrlForCell("cell-1" as CellId)).rejects.toThrow();
 
-    expect(mockElement.classList.contains("printing-output")).toBe(false);
     expect(document.body.classList.contains("printing")).toBe(false);
     expect(mockElement.style.overflow).toBe("scroll");
   });
 
-  it("should maintain body.printing during concurrent captures when snappy is false", async () => {
-    // Create a second element
-    const mockElement2 = document.createElement("div");
-    mockElement2.id = CellOutputId.create("cell-2" as CellId);
-    document.body.append(mockElement2);
-
-    // Track body.printing state during each capture
-    const printingStateDuringCaptures: boolean[] = [];
-    let resolveFirst: () => void;
-    let resolveSecond: () => void;
-
-    const firstPromise = new Promise<void>((resolve) => {
-      resolveFirst = resolve;
-    });
-    const secondPromise = new Promise<void>((resolve) => {
-      resolveSecond = resolve;
-    });
-
-    vi.mocked(toPng).mockImplementation(async (element) => {
-      printingStateDuringCaptures.push(
-        document.body.classList.contains("printing"),
-      );
-
-      // Simulate async work - first capture takes longer
-      await (element.id.includes("cell-1") ? firstPromise : secondPromise);
-
-      // Check state again after waiting
-      printingStateDuringCaptures.push(
-        document.body.classList.contains("printing"),
-      );
-
-      return mockDataUrl;
-    });
-
-    // Start both captures concurrently with snappy = false (body.printing should be added)
-    const capture1 = getImageDataUrlForCell("cell-1" as CellId, false);
-    const capture2 = getImageDataUrlForCell("cell-2" as CellId, false);
-
-    // Let second capture complete first
-    resolveSecond!();
-    await new Promise((r) => setTimeout(r, 0));
-
-    // body.printing should still be present because cell-1 is still capturing
-    expect(document.body.classList.contains("printing")).toBe(true);
-
-    // Now let first capture complete
-    resolveFirst!();
-    await Promise.all([capture1, capture2]);
-
-    // After all captures complete, body.printing should be removed
-    expect(document.body.classList.contains("printing")).toBe(false);
-
-    // All captures should have seen body.printing = true
-    expect(printingStateDuringCaptures.every(Boolean)).toBe(true);
-
-    mockElement2.remove();
-  });
-
-  it("should not interfere with body.printing during concurrent captures when snappy is true", async () => {
+  it("should handle concurrent captures correctly", async () => {
     // Create a second element
     const mockElement2 = document.createElement("div");
     mockElement2.id = CellOutputId.create("cell-2" as CellId);
     document.body.append(mockElement2);
 
     vi.mocked(toPng).mockImplementation(async () => {
-      // body.printing should never be added when snappy is true
+      // body.printing should not be added during cell captures
       expect(document.body.classList.contains("printing")).toBe(false);
       return mockDataUrl;
     });
 
-    // Start both captures concurrently with snappy = true (body.printing should NOT be added)
-    const capture1 = getImageDataUrlForCell("cell-1" as CellId, true);
-    const capture2 = getImageDataUrlForCell("cell-2" as CellId, true);
+    const capture1 = getImageDataUrlForCell("cell-1" as CellId);
+    const capture2 = getImageDataUrlForCell("cell-2" as CellId);
 
     await Promise.all([capture1, capture2]);
 
-    // body.printing should still not be present
     expect(document.body.classList.contains("printing")).toBe(false);
 
     mockElement2.remove();
@@ -515,9 +409,7 @@ describe("downloadCellOutputAsImage", () => {
   it("should apply cell-specific preparation", async () => {
     vi.mocked(toPng).mockImplementation(async () => {
       // Check that cell-specific classes are applied
-      expect(mockElement.classList.contains("printing-output")).toBe(true);
-      expect(document.body.classList.contains("printing")).toBe(true);
-      expect(mockElement.style.overflow).toBe("auto");
+      expect(mockElement.style.overflow).toBe("visible");
       return mockDataUrl;
     });
 
@@ -530,7 +422,6 @@ describe("downloadCellOutputAsImage", () => {
 
     await downloadCellOutputAsImage("cell-1" as CellId, "result");
 
-    expect(mockElement.classList.contains("printing-output")).toBe(false);
     expect(document.body.classList.contains("printing")).toBe(false);
     expect(mockElement.style.overflow).toBe("visible");
   });

package/src/utils/async-capture-tracker.ts

@@ -0,0 +1,168 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { Deferred } from "./Deferred";
+
+/**
+ * Handle returned by {@link AsyncCaptureTracker.startCapture}.
+ *
+ * The handle is scoped to one capture attempt. If the same key is re-captured
+ * before this handle completes, calling `markCaptured` or `markFailed` on
+ * the stale handle is a safe no-op.
+ */
+export interface CaptureHandle<R> {
+  /** Per-key AbortSignal — check between async steps. */
+  readonly signal: AbortSignal;
+  /** Mark the capture as successful and resolve waiters with the result. */
+  markCaptured(result: R): void;
+  /** Mark the capture as failed — the key returns to idle for retry. */
+  markFailed(): void;
+}
+
+interface InFlightEntry<R> {
+  controller: AbortController;
+  inputValue: unknown;
+  deferred: Deferred<R | undefined>;
+}
+
+/**
+ * Tracks async capture operations to prevent race conditions.
+ *
+ * Each key transitions through states:
+ * - **idle**: Not captured or previously failed — eligible for capture
+ * - **in-flight**: Capture started but not completed — skipped unless value changed
+ * - **captured(value)**: Successfully captured — skipped until value changes
+ *
+ * Abort is per-key: aborting one key's in-flight capture does not affect others.
+ *
+ * Guarantees:
+ * - Items are only marked "captured" after successful async completion
+ * - In-flight items with the same value are skipped (prevents duplicates)
+ * - In-flight items whose value changed are aborted and re-captured
+ * - Failed items return to idle (retried next cycle)
+ * - Concurrent callers can await an in-flight capture via {@link waitForInFlight}
+ * - Stale handles are safe no-ops (checked via entry identity)
+ */
+export class AsyncCaptureTracker<K, R = unknown> {
+  /** Input values for successfully captured keys */
+  private capturedInputs = new Map<K, unknown>();
+  /** Per-key in-flight state */
+  private inFlight = new Map<K, InFlightEntry<R>>();
+
+  /** Abort an in-flight entry and resolve its waiters with `undefined`. */
+  private cancelEntry(entry: InFlightEntry<R>): void {
+    entry.controller.abort();
+    if (entry.deferred.status === "pending") {
+      entry.deferred.resolve(undefined);
+    }
+  }
+
+  /**
+   * Whether a key needs capturing based on its current input value.
+   * Returns false if:
+   * - Already captured with the same value
+   * - In-flight with the same value (let it finish — use {@link waitForInFlight} to get the result)
+   * Returns true if:
+   * - Never captured
+   * - Captured with a different value
+   * - In-flight with a different value (will be aborted on {@link startCapture})
+   */
+  needsCapture(key: K, inputValue: unknown): boolean {
+    if (this.capturedInputs.get(key) === inputValue) {
+      return false;
+    }
+    const flight = this.inFlight.get(key);
+    if (flight && flight.inputValue === inputValue) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * If the key is in-flight with the given input value, returns a promise
+   * that resolves when the capture completes (with the result, or `undefined`
+   * on failure/abort). Returns `null` otherwise.
+   */
+  waitForInFlight(key: K, inputValue: unknown): Promise<R | undefined> | null {
+    const flight = this.inFlight.get(key);
+    if (flight && flight.inputValue === inputValue) {
+      return flight.deferred.promise;
+    }
+    return null;
+  }
+
+  /**
+   * Start capturing a single key. If the key is already in-flight,
+   * aborts only that key's previous capture and resolves its waiters
+   * with `undefined`.
+   *
+   * @returns A {@link CaptureHandle} scoped to this attempt.
+   */
+  startCapture(key: K, inputValue: unknown): CaptureHandle<R> {
+    const prev = this.inFlight.get(key);
+    if (prev) {
+      this.cancelEntry(prev);
+    }
+
+    const controller = new AbortController();
+    const deferred = new Deferred<R | undefined>();
+    const entry: InFlightEntry<R> = { controller, inputValue, deferred };
+    this.inFlight.set(key, entry);
+
+    return {
+      signal: controller.signal,
+      markCaptured: (result: R) => {
+        // No-op if this handle was superseded by a newer startCapture
+        if (this.inFlight.get(key) !== entry) {
+          return;
+        }
+        deferred.resolve(result);
+        this.capturedInputs.set(key, inputValue);
+        this.inFlight.delete(key);
+      },
+      markFailed: () => {
+        if (this.inFlight.get(key) !== entry) {
+          return;
+        }
+        deferred.resolve(undefined);
+        this.inFlight.delete(key);
+      },
+    };
+  }
+
+  /**
+   * Remove tracking for keys not in the given set.
+   * Aborts in-flight captures and resolves their waiters with `undefined`.
+   */
+  prune(currentKeys: Set<K>): void {
+    for (const key of this.capturedInputs.keys()) {
+      if (!currentKeys.has(key)) {
+        this.capturedInputs.delete(key);
+      }
+    }
+    for (const [key, entry] of this.inFlight) {
+      if (!currentKeys.has(key)) {
+        this.cancelEntry(entry);
+        this.inFlight.delete(key);
+      }
+    }
+  }
+
+  /** Whether any captures are currently in-flight. */
+  get isCapturing(): boolean {
+    return this.inFlight.size > 0;
+  }
+
+  /** Abort all in-flight captures. Resolves all waiters with `undefined`. */
+  abort(): void {
+    for (const entry of this.inFlight.values()) {
+      this.cancelEntry(entry);
+    }
+    this.inFlight.clear();
+  }
+
+  /** Reset all state. */
+  reset(): void {
+    this.abort();
+    this.capturedInputs.clear();
+  }
+}