@rogieking/figui3 3.16.0 → 3.18.0

package/fig.js

@@ -75,24 +75,31 @@ function figUniqueId() {
   return Date.now().toString(36) + Math.random().toString(36).substring(2);
 }
 
-/**
- * Gets the highest z-index currently in use on the page
- * @returns {number} The highest z-index found, minimum of 1000
- */
+let _figZCounter = 10000;
 function figGetHighestZIndex() {
-  let highest = 1000; // Baseline minimum
+  return _figZCounter++;
+}
 
-  // Check all elements with inline z-index or computed z-index
-  const elements = document.querySelectorAll("*");
-  for (const el of elements) {
-    const zIndex = parseInt(getComputedStyle(el).zIndex, 10);
-    if (!isNaN(zIndex) && zIndex > highest) {
-      highest = zIndex;
-    }
+function figSyncCssVar(el, prop, value) {
+  if (value && value.trim()) {
+    el.style.setProperty(prop, value.trim());
+  } else {
+    el.style.removeProperty(prop);
   }
+}
 
-  return highest;
+let _figSharedCanvas = null;
+let _figSharedCtx = null;
+function figGetSharedCanvas(width = 1, height = 1) {
+  if (!_figSharedCanvas) {
+    _figSharedCanvas = document.createElement("canvas");
+    _figSharedCtx = _figSharedCanvas.getContext("2d");
+  }
+  if (_figSharedCanvas.width !== width) _figSharedCanvas.width = width;
+  if (_figSharedCanvas.height !== height) _figSharedCanvas.height = height;
+  return { canvas: _figSharedCanvas, ctx: _figSharedCtx };
 }
+
 /**
  * Checks if the browser supports the native popover API
  * @returns {boolean} True if popover is supported
@@ -253,6 +260,7 @@ class FigDropdown extends HTMLElement {
   set label(value) {
     this.#label = value;
   }
+  #boundSlotChange;
   constructor() {
     super();
     this.select = document.createElement("select");
@@ -260,6 +268,7 @@ class FigDropdown extends HTMLElement {
     this.attachShadow({ mode: "open" });
     this.#boundHandleSelectInput = this.#handleSelectInput.bind(this);
     this.#boundHandleSelectChange = this.#handleSelectChange.bind(this);
+    this.#boundSlotChange = this.slotChange.bind(this);
   }
 
   #supportsSelectedContent() {
@@ -342,7 +351,7 @@ class FigDropdown extends HTMLElement {
     this.appendChild(this.select);
     this.shadowRoot.appendChild(this.optionsSlot);
 
-    this.optionsSlot.addEventListener("slotchange", this.slotChange.bind(this));
+    this.optionsSlot.addEventListener("slotchange", this.#boundSlotChange);
 
     this.#addEventListeners();
   }
@@ -478,6 +487,12 @@ class FigDropdown extends HTMLElement {
       this.select.setAttribute("aria-label", this.#label);
     }
   }
+
+  disconnectedCallback() {
+    this.optionsSlot.removeEventListener("slotchange", this.#boundSlotChange);
+    this.select.removeEventListener("input", this.#boundHandleSelectInput);
+    this.select.removeEventListener("change", this.#boundHandleSelectChange);
+  }
 }
 
 customElements.define("fig-dropdown", FigDropdown);
@@ -496,6 +511,12 @@ class FigTooltip extends HTMLElement {
 
   #boundHideOnChromeOpen;
   #boundHidePopupOutsideClick;
+  #boundShowDelayedPopup;
+  #boundHandlePointerLeave;
+  #boundHandleTouchStart;
+  #boundHandleTouchMove;
+  #boundHandleTouchEnd;
+  #boundHandleTouchCancel;
   #touchTimeout;
   #isTouching = false;
   #observer = null;
@@ -506,9 +527,14 @@ class FigTooltip extends HTMLElement {
     let delay = parseInt(this.getAttribute("delay"));
     this.delay = !isNaN(delay) ? delay : 500;
 
-    // Bind methods that will be used as event listeners
     this.#boundHideOnChromeOpen = this.#hideOnChromeOpen.bind(this);
     this.#boundHidePopupOutsideClick = this.hidePopupOutsideClick.bind(this);
+    this.#boundShowDelayedPopup = this.showDelayedPopup.bind(this);
+    this.#boundHandlePointerLeave = this.#handlePointerLeave.bind(this);
+    this.#boundHandleTouchStart = this.#handleTouchStart.bind(this);
+    this.#boundHandleTouchMove = this.#handleTouchMove.bind(this);
+    this.#boundHandleTouchEnd = this.#handleTouchEnd.bind(this);
+    this.#boundHandleTouchCancel = this.#handleTouchCancel.bind(this);
   }
   connectedCallback() {
     this.setup();
@@ -517,16 +543,13 @@ class FigTooltip extends HTMLElement {
 
   disconnectedCallback() {
     this.destroy();
-    // Remove global listeners
     document.removeEventListener(
       "mousedown",
       this.#boundHideOnChromeOpen,
       true,
     );
-    // Disconnect mutation observer
     this.#stopObserving();
 
-    // Remove click outside listener for click action
     if (this.action === "click") {
       document.body.removeEventListener(
         "click",
@@ -534,15 +557,17 @@ class FigTooltip extends HTMLElement {
       );
     }
 
-    // Clean up touch-related timers and listeners
     clearTimeout(this.#touchTimeout);
     if (this.action === "hover") {
-      this.removeEventListener("touchstart", this.#handleTouchStart);
-      this.removeEventListener("touchmove", this.#handleTouchMove);
-      this.removeEventListener("touchend", this.#handleTouchEnd);
-      this.removeEventListener("touchcancel", this.#handleTouchCancel);
+      this.removeEventListener("pointerenter", this.#boundShowDelayedPopup);
+      this.removeEventListener("pointerleave", this.#boundHandlePointerLeave);
+      this.removeEventListener("touchstart", this.#boundHandleTouchStart);
+      this.removeEventListener("touchmove", this.#boundHandleTouchMove);
+      this.removeEventListener("touchend", this.#boundHandleTouchEnd);
+      this.removeEventListener("touchcancel", this.#boundHandleTouchCancel);
     } else if (this.action === "click") {
-      this.removeEventListener("touchstart", this.showDelayedPopup);
+      this.removeEventListener("click", this.#boundShowDelayedPopup);
+      this.removeEventListener("touchstart", this.#boundShowDelayedPopup);
     }
   }
 
@@ -613,36 +638,29 @@ class FigTooltip extends HTMLElement {
     if (this.action === "manual") return;
     if (this.action === "hover") {
       if (!this.isTouchDevice()) {
-        this.addEventListener("pointerenter", this.showDelayedPopup.bind(this));
-        this.addEventListener(
-          "pointerleave",
-          this.#handlePointerLeave.bind(this),
-        );
+        this.addEventListener("pointerenter", this.#boundShowDelayedPopup);
+        this.addEventListener("pointerleave", this.#boundHandlePointerLeave);
       }
-      // Touch support for mobile hover simulation
-      this.addEventListener("touchstart", this.#handleTouchStart.bind(this), {
+      this.addEventListener("touchstart", this.#boundHandleTouchStart, {
         passive: true,
       });
-      this.addEventListener("touchmove", this.#handleTouchMove.bind(this), {
+      this.addEventListener("touchmove", this.#boundHandleTouchMove, {
         passive: true,
       });
-      this.addEventListener("touchend", this.#handleTouchEnd.bind(this), {
+      this.addEventListener("touchend", this.#boundHandleTouchEnd, {
         passive: true,
       });
-      this.addEventListener("touchcancel", this.#handleTouchCancel.bind(this), {
+      this.addEventListener("touchcancel", this.#boundHandleTouchCancel, {
         passive: true,
       });
     } else if (this.action === "click") {
-      this.addEventListener("click", this.showDelayedPopup.bind(this));
+      this.addEventListener("click", this.#boundShowDelayedPopup);
       document.body.addEventListener("click", this.#boundHidePopupOutsideClick);
-
-      // Touch support for better mobile responsiveness
-      this.addEventListener("touchstart", this.showDelayedPopup.bind(this), {
+      this.addEventListener("touchstart", this.#boundShowDelayedPopup, {
         passive: true,
       });
     }
 
-    // Add listener for chrome interactions
     document.addEventListener("mousedown", this.#boundHideOnChromeOpen, true);
   }
 
@@ -934,6 +952,7 @@ class FigDialog extends HTMLDialogElement {
   #boundPointerDown;
   #boundPointerMove;
   #boundPointerUp;
+  #boundClose;
   #offset = 16; // 1rem in pixels
   #positionInitialized = false;
   #dragThreshold = 3; // pixels before drag starts
@@ -943,6 +962,7 @@ class FigDialog extends HTMLDialogElement {
     this.#boundPointerDown = this.#handlePointerDown.bind(this);
     this.#boundPointerMove = this.#handlePointerMove.bind(this);
     this.#boundPointerUp = this.#handlePointerUp.bind(this);
+    this.#boundClose = this.close.bind(this);
   }
 
   connectedCallback() {
@@ -962,12 +982,15 @@ class FigDialog extends HTMLDialogElement {
 
   disconnectedCallback() {
     this.#removeDragListeners();
+    this.querySelectorAll("fig-button[close-dialog]").forEach((button) => {
+      button.removeEventListener("click", this.#boundClose);
+    });
   }
 
   #addCloseListeners() {
     this.querySelectorAll("fig-button[close-dialog]").forEach((button) => {
-      button.removeEventListener("click", this.close);
-      button.addEventListener("click", this.close.bind(this));
+      button.removeEventListener("click", this.#boundClose);
+      button.addEventListener("click", this.#boundClose);
     });
   }
 
@@ -2242,16 +2265,18 @@ figDefineCustomizedBuiltIn("fig-popup", FigPopup, { extends: "dialog" });
  */
 class FigTab extends HTMLElement {
   #selected;
+  #boundHandleClick;
   constructor() {
     super();
     this.content = null;
     this.#selected = false;
+    this.#boundHandleClick = this.handleClick.bind(this);
   }
   connectedCallback() {
     this.setAttribute("label", this.innerText);
     this.setAttribute("role", "tab");
     this.setAttribute("tabindex", "0");
-    this.addEventListener("click", this.handleClick.bind(this));
+    this.addEventListener("click", this.#boundHandleClick);
 
     requestAnimationFrame(() => {
       if (typeof this.getAttribute("content") === "string") {
@@ -2276,7 +2301,7 @@ class FigTab extends HTMLElement {
     this.setAttribute("selected", value ? "true" : "false");
   }
   disconnectedCallback() {
-    this.removeEventListener("click", this.handleClick);
+    this.removeEventListener("click", this.#boundHandleClick);
   }
   handleClick() {
     this.selected = true;
@@ -2305,8 +2330,12 @@ customElements.define("fig-tab", FigTab);
  * @attr {string} name - Identifier for the tabs group
  */
 class FigTabs extends HTMLElement {
+  #boundHandleClick;
+  #boundHandleKeyDown;
   constructor() {
     super();
+    this.#boundHandleClick = this.handleClick.bind(this);
+    this.#boundHandleKeyDown = this.#handleKeyDown.bind(this);
   }
 
   static get observedAttributes() {
@@ -2316,8 +2345,8 @@ class FigTabs extends HTMLElement {
   connectedCallback() {
     this.name = this.getAttribute("name") || "tabs";
     this.setAttribute("role", "tablist");
-    this.addEventListener("click", this.handleClick.bind(this));
-    this.addEventListener("keydown", this.#handleKeyDown.bind(this));
+    this.addEventListener("click", this.#boundHandleClick);
+    this.addEventListener("keydown", this.#boundHandleKeyDown);
     requestAnimationFrame(() => {
       const value = this.getAttribute("value");
       if (value) {
@@ -2345,8 +2374,8 @@ class FigTabs extends HTMLElement {
   }
 
   disconnectedCallback() {
-    this.removeEventListener("click", this.handleClick);
-    this.removeEventListener("keydown", this.#handleKeyDown);
+    this.removeEventListener("click", this.#boundHandleClick);
+    this.removeEventListener("keydown", this.#boundHandleKeyDown);
   }
 
   #handleKeyDown(event) {
@@ -2446,14 +2475,16 @@ customElements.define("fig-tabs", FigTabs);
 class FigSegment extends HTMLElement {
   #value;
   #selected;
+  #boundHandleClick;
   constructor() {
     super();
+    this.#boundHandleClick = this.handleClick.bind(this);
   }
   connectedCallback() {
-    this.addEventListener("click", this.handleClick.bind(this));
+    this.addEventListener("click", this.#boundHandleClick);
   }
   disconnectedCallback() {
-    this.removeEventListener("click", this.handleClick);
+    this.removeEventListener("click", this.#boundHandleClick);
   }
   handleClick() {
     const parentControl = this.closest("fig-segmented-control");
@@ -5084,6 +5115,12 @@ class FigInputFill extends HTMLElement {
     this.#render();
   }
 
+  disconnectedCallback() {
+    this.#fillPicker = null;
+    this.#opacityInput = null;
+    this.#hexInput = null;
+  }
+
   #parseValue() {
     const valueAttr = this.getAttribute("value");
     if (!valueAttr) return;
@@ -6074,6 +6111,16 @@ class FigInputGradient extends HTMLElement {
 
   disconnectedCallback() {
     document.removeEventListener("keydown", this.#onKeyDown);
+    if (this.#colorObserver) {
+      this.#colorObserver.disconnect();
+      this.#colorObserver = null;
+    }
+    clearTimeout(this.#arrowTooltipTimer);
+    this.removeEventListener("pointerenter", this.#onTrackEnter);
+    this.removeEventListener("pointermove", this.#onTrackMove);
+    this.removeEventListener("pointerleave", this.#onTrackLeave);
+    this.removeEventListener("click", this.#onTrackClick);
+    this.removeEventListener("dblclick", this.#onTrackDblClick);
   }
 
   #onKeyDown = (e) => {
@@ -6208,10 +6255,8 @@ class FigInputGradient extends HTMLElement {
   }
 
   #sampleGradientColor(position) {
-    const canvas = document.createElement("canvas");
-    canvas.width = 256;
-    canvas.height = 1;
-    const ctx = canvas.getContext("2d");
+    const { ctx } = figGetSharedCanvas(256, 1);
+    ctx.clearRect(0, 0, 256, 1);
     const grad = ctx.createLinearGradient(0, 0, 256, 0);
     for (const stop of this.#gradient.stops) {
       try {
@@ -6450,6 +6495,44 @@ class FigInputGradient extends HTMLElement {
   #setupEventListeners() {
     if (!this.#track) return;
 
+    this.#track.addEventListener("pointerdown", (e) => {
+      if (this.hasAttribute("disabled")) return;
+      if (e.target.closest("fig-handle:not(.fig-input-gradient-ghost)")) return;
+      if (e.button !== 0) return;
+      e.preventDefault();
+
+      const trackRect = this.#track.getBoundingClientRect();
+      const pct = Math.max(0, Math.min(1, (e.clientX - trackRect.left) / trackRect.width));
+      const position = Math.round(pct * 100);
+      const color = this.#sampleGradientColor(pct);
+      this.#gradient.stops.push({ position, color, opacity: 100 });
+      this.#gradient.stops.sort((a, b) => a.position - b.position);
+      const newIndex = this.#gradient.stops.findIndex(
+        (s) => s.position === position && s.color === color,
+      );
+      this.#syncHandles();
+      this.#syncChit();
+      this.#emitInput();
+      this.#hideGhost();
+
+      const handles = this.#track.querySelectorAll(
+        "fig-handle:not(.fig-input-gradient-ghost)",
+      );
+      const newHandle = handles[newIndex];
+      if (newHandle) {
+        newHandle.select();
+        newHandle.dispatchEvent(new PointerEvent("pointerdown", {
+          bubbles: true,
+          clientX: e.clientX,
+          clientY: e.clientY,
+          pointerId: e.pointerId,
+          pointerType: e.pointerType,
+          button: e.button,
+          buttons: e.buttons,
+        }));
+      }
+    });
+
     this.#track.addEventListener("input", (e) => {
       const handle = e.target.closest("fig-handle");
       if (!handle) return;
@@ -6851,9 +6934,11 @@ customElements.define("fig-switch", FigSwitch);
 class FigToast extends HTMLDialogElement {
   _defaultOffset = 16; // 1rem in pixels
   _autoCloseTimer = null;
+  #boundHandleClose;
 
   constructor() {
     super();
+    this.#boundHandleClose = this.handleClose.bind(this);
   }
 
   getOffset() {
@@ -6903,8 +6988,8 @@ class FigToast extends HTMLDialogElement {
 
   addCloseListeners() {
     this.querySelectorAll("[close-toast]").forEach((button) => {
-      button.removeEventListener("click", this.handleClose);
-      button.addEventListener("click", this.handleClose.bind(this));
+      button.removeEventListener("click", this.#boundHandleClose);
+      button.addEventListener("click", this.#boundHandleClose);
     });
   }
 
@@ -7191,12 +7276,10 @@ class FigChit extends HTMLElement {
   }
 
   #toHex(color) {
-    // Convert color to hex for the native input
     if (!color) return "#D9D9D9";
     if (color.startsWith("#")) return color.slice(0, 7);
-    // Use canvas to convert rgba/named colors to hex
     try {
-      const ctx = document.createElement("canvas").getContext("2d");
+      const { ctx } = figGetSharedCanvas(1, 1);
       ctx.fillStyle = color;
       return ctx.fillStyle;
     } catch {
@@ -7665,7 +7748,7 @@ class FigEasingCurve extends HTMLElement {
 
   connectedCallback() {
     this.#precision = parseInt(this.getAttribute("precision") || "2");
-    this.#syncAspectRatioVar(this.getAttribute("aspect-ratio"));
+    figSyncCssVar(this, "--aspect-ratio", this.getAttribute("aspect-ratio"));
     const val = this.getAttribute("value");
     if (val) this.#parseValue(val);
     this.#presetName = this.#matchPreset();
@@ -7681,17 +7764,9 @@ class FigEasingCurve extends HTMLElement {
     }
   }
 
-  #syncAspectRatioVar(value) {
-    if (value && value.trim()) {
-      this.style.setProperty("--aspect-ratio", value.trim());
-    } else {
-      this.style.removeProperty("--aspect-ratio");
-    }
-  }
-
   attributeChangedCallback(name, oldValue, newValue) {
     if (name === "aspect-ratio") {
-      this.#syncAspectRatioVar(newValue);
+      figSyncCssVar(this, "--aspect-ratio", newValue);
       if (this.#svg) {
         this.#syncViewportSize();
         this.#updatePaths();
@@ -8486,12 +8561,9 @@ class Fig3DRotate extends HTMLElement {
 
   connectedCallback() {
     this.#precision = parseInt(this.getAttribute("precision") || "1");
-    this.#syncAspectRatioVar(this.getAttribute("aspect-ratio"));
-    this.#syncPerspectiveVar(this.getAttribute("perspective"));
-    this.#syncCSSVar(
-      "--perspective-origin",
-      this.getAttribute("perspective-origin"),
-    );
+    figSyncCssVar(this, "--aspect-ratio", this.getAttribute("aspect-ratio"));
+    figSyncCssVar(this, "--perspective", this.getAttribute("perspective"));
+    figSyncCssVar(this, "--perspective-origin", this.getAttribute("perspective-origin"));
     this.#syncTransformOrigin(this.getAttribute("transform-origin"));
     this.#parseFields(this.getAttribute("fields"));
     const val = this.getAttribute("value");
@@ -8509,29 +8581,7 @@ class Fig3DRotate extends HTMLElement {
     }
   }
 
-  #syncAspectRatioVar(value) {
-    if (value && value.trim()) {
-      this.style.setProperty("--aspect-ratio", value.trim());
-    } else {
-      this.style.removeProperty("--aspect-ratio");
-    }
-  }
-
-  #syncPerspectiveVar(value) {
-    if (value && value.trim()) {
-      this.style.setProperty("--perspective", value.trim());
-    } else {
-      this.style.removeProperty("--perspective");
-    }
-  }
-
-  #syncCSSVar(prop, value) {
-    if (value && value.trim()) {
-      this.style.setProperty(prop, value.trim());
-    } else {
-      this.style.removeProperty(prop);
-    }
-  }
+  
 
   #syncTransformOrigin(value) {
     if (!value || !value.trim()) {
@@ -8580,15 +8630,15 @@ class Fig3DRotate extends HTMLElement {
 
   attributeChangedCallback(name, oldValue, newValue) {
     if (name === "aspect-ratio") {
-      this.#syncAspectRatioVar(newValue);
+      figSyncCssVar(this, "--aspect-ratio", newValue);
       return;
     }
     if (name === "perspective") {
-      this.#syncPerspectiveVar(newValue);
+      figSyncCssVar(this, "--perspective", newValue);
       return;
     }
     if (name === "perspective-origin") {
-      this.#syncCSSVar("--perspective-origin", newValue);
+      figSyncCssVar(this, "--perspective-origin", newValue);
       return;
     }
     if (name === "transform-origin") {
@@ -8838,7 +8888,7 @@ class FigOriginGrid extends HTMLElement {
 
   connectedCallback() {
     this.#precision = parseInt(this.getAttribute("precision") || "0");
-    this.#syncAspectRatioVar(this.getAttribute("aspect-ratio"));
+    figSyncCssVar(this, "--aspect-ratio", this.getAttribute("aspect-ratio"));
     this.#applyIncomingValue(this.getAttribute("value"));
 
     this.#render();
@@ -8862,7 +8912,7 @@ class FigOriginGrid extends HTMLElement {
 
   attributeChangedCallback(name, oldValue, newValue) {
     if (name === "aspect-ratio") {
-      this.#syncAspectRatioVar(newValue);
+      figSyncCssVar(this, "--aspect-ratio", newValue);
       return;
     }
     if (name === "drag") {
@@ -8901,14 +8951,6 @@ class FigOriginGrid extends HTMLElement {
     return attr.toLowerCase() !== "false";
   }
 
-  #syncAspectRatioVar(value) {
-    if (value && value.trim()) {
-      this.style.setProperty("--aspect-ratio", value.trim());
-    } else {
-      this.style.removeProperty("--aspect-ratio");
-    }
-  }
-
   #syncDragState() {
     if (!this.#grid) return;
     this.#grid.classList.toggle("drag-disabled", !this.#dragEnabled);
@@ -9292,6 +9334,7 @@ class FigInputJoystick extends HTMLElement {
   #boundYFocusOut = null;
   #isSyncingValueAttr = false;
   #defaultPosition = { x: 0.5, y: 0.5 };
+  #initialized = false;
 
   constructor() {
     super();
@@ -9303,7 +9346,6 @@ class FigInputJoystick extends HTMLElement {
     this.xInput = null;
     this.yInput = null;
     this.coordinates = "screen";
-    this.#initialized = false;
     this.#boundPlanePointerDown = (e) => this.#handlePlanePointerDown(e);
     this.#boundHandlePointerDown = () => {
       this.isDragging = true;
@@ -9317,8 +9359,6 @@ class FigInputJoystick extends HTMLElement {
     this.#boundYFocusOut = () => this.#handleFieldFocusOut();
   }
 
-  #initialized = false;
-
   connectedCallback() {
     // Initialize position
     requestAnimationFrame(() => {
@@ -9327,7 +9367,7 @@ class FigInputJoystick extends HTMLElement {
       this.transform = this.getAttribute("transform") || 1;
       this.transform = Number(this.transform);
       this.coordinates = this.getAttribute("coordinates") || "screen";
-      this.#syncAspectRatioVar(this.getAttribute("aspect-ratio"));
+      figSyncCssVar(this, "--aspect-ratio", this.getAttribute("aspect-ratio"));
       if (!this.hasAttribute("value")) {
         this.setAttribute("value", "50% 50%");
       }
@@ -9346,14 +9386,6 @@ class FigInputJoystick extends HTMLElement {
     return this.coordinates === "math" ? 1 - y : y;
   }
 
-  #syncAspectRatioVar(value) {
-    if (value && value.trim()) {
-      this.style.setProperty("--aspect-ratio", value.trim());
-    } else {
-      this.style.removeProperty("--aspect-ratio");
-    }
-  }
-
   disconnectedCallback() {
     this.#cleanupListeners();
   }
@@ -9655,7 +9687,7 @@ class FigInputJoystick extends HTMLElement {
   }
   attributeChangedCallback(name, oldValue, newValue) {
     if (name === "aspect-ratio") {
-      this.#syncAspectRatioVar(newValue);
+      figSyncCssVar(this, "--aspect-ratio", newValue);
       return;
     }
     if (name === "value") {
@@ -9705,6 +9737,11 @@ class FigInputAngle extends HTMLElement {
   #opposite;
   #prevRawAngle = null;
   #boundHandleRawChange;
+  #boundHandleMouseDown;
+  #boundHandleTouchStart;
+  #boundHandleKeyDown;
+  #boundHandleKeyUp;
+  #boundHandleAngleInput;
 
   constructor() {
     super();
@@ -9725,6 +9762,11 @@ class FigInputAngle extends HTMLElement {
     this.rotationSpan = null;
 
     this.#boundHandleRawChange = this.#handleRawChange.bind(this);
+    this.#boundHandleMouseDown = this.#handleMouseDown.bind(this);
+    this.#boundHandleTouchStart = this.#handleTouchStart.bind(this);
+    this.#boundHandleKeyDown = this.#handleKeyDown.bind(this);
+    this.#boundHandleKeyUp = this.#handleKeyUp.bind(this);
+    this.#boundHandleAngleInput = this.#handleAngleInput.bind(this);
   }
 
   connectedCallback() {
@@ -9899,30 +9941,23 @@ class FigInputAngle extends HTMLElement {
     this.angleInput = this.querySelector("fig-input-number[name='angle']");
     this.rotationSpan = this.querySelector(".fig-input-angle-rotations");
     this.#updateRotationDisplay();
-    this.plane?.addEventListener("mousedown", this.#handleMouseDown.bind(this));
-    this.plane?.addEventListener(
-      "touchstart",
-      this.#handleTouchStart.bind(this),
-    );
-    window.addEventListener("keydown", this.#handleKeyDown.bind(this));
-    window.addEventListener("keyup", this.#handleKeyUp.bind(this));
+    this.plane?.addEventListener("mousedown", this.#boundHandleMouseDown);
+    this.plane?.addEventListener("touchstart", this.#boundHandleTouchStart);
+    window.addEventListener("keydown", this.#boundHandleKeyDown);
+    window.addEventListener("keyup", this.#boundHandleKeyUp);
     if (this.text && this.angleInput) {
-      this.angleInput.addEventListener(
-        "input",
-        this.#handleAngleInput.bind(this),
-      );
+      this.angleInput.addEventListener("input", this.#boundHandleAngleInput);
     }
-    // Capture-phase listener for unit suffix parsing
     this.addEventListener("change", this.#boundHandleRawChange, true);
   }
 
   #cleanupListeners() {
-    this.plane?.removeEventListener("mousedown", this.#handleMouseDown);
-    this.plane?.removeEventListener("touchstart", this.#handleTouchStart);
-    window.removeEventListener("keydown", this.#handleKeyDown);
-    window.removeEventListener("keyup", this.#handleKeyUp);
+    this.plane?.removeEventListener("mousedown", this.#boundHandleMouseDown);
+    this.plane?.removeEventListener("touchstart", this.#boundHandleTouchStart);
+    window.removeEventListener("keydown", this.#boundHandleKeyDown);
+    window.removeEventListener("keyup", this.#boundHandleKeyUp);
     if (this.text && this.angleInput) {
-      this.angleInput.removeEventListener("input", this.#handleAngleInput);
+      this.angleInput.removeEventListener("input", this.#boundHandleAngleInput);
     }
     this.removeEventListener("change", this.#boundHandleRawChange, true);
   }
@@ -10427,6 +10462,8 @@ class FigFillPicker extends HTMLElement {
   #opacitySlider = null;
   #isDraggingColor = false;
   #teardownColorAreaEvents = null;
+  #dialogOpenObserver = null;
+  #webcamTabObserver = null;
 
   constructor() {
     super();
@@ -10452,10 +10489,26 @@ class FigFillPicker extends HTMLElement {
       this.#teardownColorAreaEvents();
       this.#teardownColorAreaEvents = null;
     }
+    if (this.#dialogOpenObserver) {
+      this.#dialogOpenObserver.disconnect();
+      this.#dialogOpenObserver = null;
+    }
+    if (this.#webcamTabObserver) {
+      this.#webcamTabObserver.disconnect();
+      this.#webcamTabObserver = null;
+    }
+    if (this.#webcam.stream) {
+      this.#webcam.stream.getTracks().forEach((track) => track.stop());
+      this.#webcam.stream = null;
+    }
+    if (this.#video.url && this.#video.url.startsWith("blob:")) {
+      URL.revokeObjectURL(this.#video.url);
+    }
     if (this.#chit) this.#chit.removeAttribute("selected");
     if (this.#dialog) {
       this.#dialog.close();
       this.#dialog.remove();
+      this.#dialog = null;
     }
   }
 
@@ -10792,11 +10845,11 @@ class FigFillPicker extends HTMLElement {
     };
     this.#dialog.addEventListener("close", onDialogClose);
 
-    const observer = new MutationObserver(() => {
+    this.#dialogOpenObserver = new MutationObserver(() => {
       const isOpen = this.#dialog.hasAttribute("open") && this.#dialog.getAttribute("open") !== "false";
       if (!isOpen) onDialogClose();
     });
-    observer.observe(this.#dialog, { attributes: true, attributeFilter: ["open"] });
+    this.#dialogOpenObserver.observe(this.#dialog, { attributes: true, attributeFilter: ["open"] });
 
     // Initialize built-in tabs (skip any overridden by custom slots)
     const builtinInits = {
@@ -11718,10 +11771,15 @@ class FigFillPicker extends HTMLElement {
     }
   }
 
+  static #gradientSupportCache = new Map();
   #testGradientSupport(css) {
+    const cached = FigFillPicker.#gradientSupportCache.get(css);
+    if (cached !== undefined) return cached;
     const el = document.createElement("div");
     el.style.background = css;
-    return !!el.style.background;
+    const result = !!el.style.background;
+    FigFillPicker.#gradientSupportCache.set(css, result);
+    return result;
   }
 
   #getGradientCSS() {
@@ -12066,13 +12124,12 @@ class FigFillPicker extends HTMLElement {
       }
     };
 
-    // Start webcam when tab is shown
-    const observer = new MutationObserver(() => {
+    this.#webcamTabObserver = new MutationObserver(() => {
       if (container.style.display !== "none" && !this.#webcam.stream) {
         startWebcam();
       }
     });
-    observer.observe(container, {
+    this.#webcamTabObserver.observe(container, {
       attributes: true,
       attributeFilter: ["style"],
     });
@@ -12591,8 +12648,8 @@ class FigColorTip extends HTMLElement {
     }
 
     try {
-      const ctx = document.createElement("canvas").getContext("2d");
-      if (!ctx) return "#D9D9D9";
+      const { ctx } = figGetSharedCanvas(1, 1);
+      ctx.fillStyle = "#000000";
       ctx.fillStyle = value;
       const resolved = ctx.fillStyle;
       if (resolved.startsWith("#")) {
@@ -13286,6 +13343,640 @@ class FigChooser extends HTMLElement {
 }
 customElements.define("fig-chooser", FigChooser);
 
+/* Canvas Point */
+class FigCanvasPoint extends HTMLElement {
+  static observedAttributes = [
+    "type",
+    "value",
+    "color",
+    "name",
+    "tooltips",
+    "disabled",
+    "drag-surface",
+    "snapping",
+  ];
+
+  #x = 50;
+  #y = 50;
+  #radius = 0;
+  #radiusIsPercent = false;
+  #angle = 0;
+  #pointHandle = null;
+  #angleHandle = null;
+  #radiusSvg = null;
+  #angleSvg = null;
+  #pointTooltip = null;
+  #radiusTooltip = null;
+  #angleTooltip = null;
+  #isDragging = false;
+  #isRadiusDragging = false;
+  #isAngleDragging = false;
+
+  get #type() {
+    return this.getAttribute("type") || "point";
+  }
+
+  get #hasRadius() {
+    return this.#type === "point-radius" || this.#type === "point-radius-angle";
+  }
+
+  get #hasAngle() {
+    return this.#type === "point-radius-angle";
+  }
+
+  get #tooltipsEnabled() {
+    const v = this.getAttribute("tooltips");
+    return v === null || v !== "false";
+  }
+
+  get #snappingMode() {
+    const raw = this.getAttribute("snapping");
+    if (raw === null) return "false";
+    const n = raw.trim().toLowerCase();
+    if (n === "modifier") return "modifier";
+    if (n === "" || n === "true") return "true";
+    return "false";
+  }
+
+  #shouldSnap(shiftKey) {
+    const mode = this.#snappingMode;
+    if (mode === "true") return true;
+    if (mode === "modifier") return !!shiftKey;
+    return false;
+  }
+
+  get #pointTipText() {
+    const name = this.getAttribute("name");
+    if (name) return name;
+    return `${Math.round(this.#x)}%, ${Math.round(this.#y)}%`;
+  }
+
+  get #dragSurface() {
+    return this.getAttribute("drag-surface") || "parent";
+  }
+
+  get #container() {
+    const surface = this.#dragSurface;
+    if (surface === "parent") return this.parentElement;
+    return this.closest(surface);
+  }
+
+  get #handleDragSurface() {
+    const surface = this.#dragSurface;
+    if (surface === "parent") {
+      const container = this.parentElement;
+      if (container) {
+        container.setAttribute("data-fig-canvas-point-surface", "");
+        return "[data-fig-canvas-point-surface]";
+      }
+    }
+    return surface;
+  }
+
+  #resolveRadius(containerWidth) {
+    if (this.#radiusIsPercent) return (this.#radius / 100) * containerWidth;
+    return this.#radius;
+  }
+
+  #formatRadius() {
+    if (this.#radiusIsPercent) return `${Math.round(this.#radius)}%`;
+    return `${Math.round(this.#radius)}px`;
+  }
+
+  connectedCallback() {
+    this.#parseValue();
+    this.#render();
+  }
+
+  disconnectedCallback() {
+    this.#teardownRadiusDrag();
+  }
+
+  attributeChangedCallback(name, oldVal, newVal) {
+    if (oldVal === newVal) return;
+    if (name === "value" && !this.#isDragging && !this.#isRadiusDragging && !this.#isAngleDragging) {
+      this.#parseValue();
+      if (this.#pointHandle) this.#syncPositions();
+      else this.#render();
+    }
+    if (name === "type") {
+      this.#parseValue();
+      this.#render();
+    }
+    if (name === "color" && this.#pointHandle) {
+      if (newVal) this.#pointHandle.setAttribute("color", newVal);
+      else this.#pointHandle.removeAttribute("color");
+    }
+    if (name === "disabled") {
+      this.#render();
+    }
+    if (name === "tooltips") {
+      this.#render();
+    }
+    if (name === "snapping" && this.#pointHandle) {
+      this.#pointHandle.setAttribute("drag-snapping", newVal || "false");
+    }
+    if (name === "name" && this.#pointTooltip) {
+      this.#pointTooltip.setAttribute("text", this.#pointTipText);
+    }
+  }
+
+  #parseValue() {
+    const raw = this.getAttribute("value");
+    if (!raw) return;
+    try {
+      const v = JSON.parse(raw);
+      if (typeof v.x === "number") this.#x = v.x;
+      if (typeof v.y === "number") this.#y = v.y;
+      if (v.radius !== undefined) {
+        const rs = String(v.radius);
+        if (rs.endsWith("%")) {
+          this.#radiusIsPercent = true;
+          this.#radius = parseFloat(rs);
+        } else {
+          this.#radiusIsPercent = false;
+          this.#radius = parseFloat(rs);
+        }
+        if (!Number.isFinite(this.#radius)) this.#radius = 0;
+      }
+      if (typeof v.angle === "number") this.#angle = v.angle;
+    } catch { /* ignore */ }
+  }
+
+  get value() {
+    const v = { x: this.#x, y: this.#y };
+    if (this.#hasRadius) {
+      v.radius = this.#radiusIsPercent ? `${this.#radius}%` : this.#radius;
+    }
+    if (this.#hasAngle) v.angle = this.#angle;
+    return v;
+  }
+
+  set value(val) {
+    if (typeof val === "object") {
+      this.setAttribute("value", JSON.stringify(val));
+    } else if (typeof val === "string") {
+      this.setAttribute("value", val);
+    }
+  }
+
+  #render() {
+    this.innerHTML = "";
+    this.#pointHandle = null;
+    this.#angleHandle = null;
+    this.#radiusSvg = null;
+    this.#angleSvg = null;
+    this.#pointTooltip = null;
+    this.#radiusTooltip = null;
+    this.#angleTooltip = null;
+
+    const disabled = this.hasAttribute("disabled");
+    const type = this.#type;
+    const tooltips = this.#tooltipsEnabled;
+
+    const handleSurface = this.#handleDragSurface;
+
+    const handle = document.createElement("fig-handle");
+    handle.setAttribute("drag", "true");
+    handle.setAttribute("drag-surface", handleSurface);
+    handle.setAttribute("drag-axes", "x,y");
+    handle.setAttribute("drag-snapping", this.#snappingMode);
+    handle.setAttribute("value", `${this.#x}% ${this.#y}%`);
+    if (disabled) handle.setAttribute("disabled", "");
+    if (type === "color") {
+      handle.setAttribute("type", "color");
+      const color = this.getAttribute("color");
+      if (color) handle.setAttribute("color", color);
+    }
+    this.#pointHandle = handle;
+
+    if (this.#hasRadius) {
+      this.#createRadiusSvg();
+    }
+
+    if (this.#hasAngle) {
+      this.#createAngleSvg();
+    }
+
+    if (tooltips) {
+      const tip = document.createElement("fig-tooltip");
+      tip.setAttribute("action", "manual");
+      tip.setAttribute("text", this.#pointTipText);
+      tip.appendChild(handle);
+      this.appendChild(tip);
+      this.#pointTooltip = tip;
+    } else {
+      this.appendChild(handle);
+    }
+
+    if (this.#hasAngle) {
+      this.#createAngleHandle(disabled, tooltips, handleSurface);
+    }
+
+    this.#setupEventListeners();
+    requestAnimationFrame(() => this.#syncPositions());
+  }
+
+  #createRadiusSvg() {
+    const ns = "http://www.w3.org/2000/svg";
+    const svg = document.createElementNS(ns, "svg");
+    svg.classList.add("fig-canvas-point-radius");
+    svg.setAttribute("overflow", "visible");
+    const hitCircle = document.createElementNS(ns, "circle");
+    hitCircle.classList.add("fig-canvas-point-radius-hit");
+    svg.appendChild(hitCircle);
+    const circle = document.createElementNS(ns, "circle");
+    svg.appendChild(circle);
+    this.#radiusSvg = svg;
+
+    if (this.#tooltipsEnabled) {
+      const tip = document.createElement("fig-tooltip");
+      tip.setAttribute("action", "manual");
+      tip.setAttribute("text", this.#formatRadius());
+      tip.appendChild(svg);
+      this.appendChild(tip);
+      this.#radiusTooltip = tip;
+    } else {
+      this.appendChild(svg);
+    }
+
+    this.#setupRadiusDrag(hitCircle);
+  }
+
+  #createAngleSvg() {
+    const ns = "http://www.w3.org/2000/svg";
+    const svg = document.createElementNS(ns, "svg");
+    svg.classList.add("fig-canvas-point-angle-svg");
+    svg.setAttribute("overflow", "visible");
+    svg.style.position = "absolute";
+    svg.style.pointerEvents = "none";
+    const line = document.createElementNS(ns, "line");
+    line.classList.add("fig-canvas-point-angle-line");
+    svg.appendChild(line);
+    this.#angleSvg = svg;
+    this.appendChild(svg);
+  }
+
+  #createAngleHandle(disabled, tooltips, handleSurface) {
+    const handle = document.createElement("fig-handle");
+    handle.setAttribute("drag", "true");
+    handle.setAttribute("drag-surface", handleSurface);
+    handle.setAttribute("drag-axes", "x,y");
+    handle.setAttribute("size", "small");
+    handle.setAttribute("hit-area", "12 circle");
+    handle.setAttribute("hit-area-mode", "delegate");
+    if (disabled) handle.setAttribute("disabled", "");
+    this.#angleHandle = handle;
+
+    if (tooltips) {
+      const tip = document.createElement("fig-tooltip");
+      tip.setAttribute("action", "manual");
+      tip.setAttribute("text", `${Math.round(this.#angle)}°`);
+      tip.appendChild(handle);
+      this.appendChild(tip);
+      this.#angleTooltip = tip;
+    } else {
+      this.appendChild(handle);
+    }
+  }
+
+  #resizeCursorSvg(deg) {
+    const r = Math.round(deg);
+    return `url("data:image/svg+xml,%3Csvg width='32' height='32' viewBox='0 0 32 32' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cg transform='rotate(${r} 16 16)'%3E%3Cg filter='url(%23f)'%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M11.1212 16.9998L11.5607 17.4394C12.1465 18.0252 12.1464 18.975 11.5606 19.5607C10.9748 20.1465 10.0251 20.1465 9.4393 19.5606L6.4393 16.5604C5.85354 15.9746 5.85357 15.0249 6.43938 14.4391L9.43938 11.4393C10.0252 10.8535 10.9749 10.8536 11.5607 11.4394C12.1465 12.0252 12.1464 12.9749 11.5606 13.5607L11.1215 13.9998L20.8786 13.9999L20.4394 13.5607C19.8536 12.9749 19.8535 12.0252 20.4393 11.4394C21.0251 10.8536 21.9749 10.8536 22.5606 11.4394L25.5606 14.4393C25.842 14.7206 26 15.1021 26 15.4999C26 15.8978 25.842 16.2793 25.5607 16.5606L22.5607 19.5607C21.9749 20.1465 21.0251 20.1465 20.4393 19.5607C19.8536 18.9749 19.8535 18.0252 20.4393 17.4394L20.8788 16.9999L11.1212 16.9998Z' fill='white'/%3E%3C/g%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M10.8536 12.1465C11.0488 12.3417 11.0488 12.6583 10.8535 12.8536L8.70715 14.9998L23.2929 14.9999L21.1465 12.8536C20.9512 12.6583 20.9512 12.3417 21.1464 12.1465C21.3417 11.9512 21.6583 11.9512 21.8535 12.1465L24.8535 15.1464C24.9473 15.2402 25 15.3673 25 15.4999C25 15.6326 24.9473 15.7597 24.8536 15.8535L21.8536 18.8536C21.6583 19.0488 21.3417 19.0488 21.1465 18.8536C20.9512 18.6583 20.9512 18.3417 21.1464 18.1465L23.2929 15.9999L8.70705 15.9998L10.8536 18.1465C11.0488 18.3417 11.0488 18.6583 10.8535 18.8536C10.6583 19.0488 10.3417 19.0488 10.1464 18.8535L7.14643 15.8533C6.95118 15.658 6.95119 15.3415 7.14646 15.1462L10.1465 12.1464C10.3417 11.9512 10.6583 11.9512 10.8536 12.1465Z' fill='black'/%3E%3C/g%3E%3Cdefs%3E%3Cfilter id='f' x='3' y='9' width='26' height='15' filterUnits='userSpaceOnUse' color-interpolation-filters='sRGB'%3E%3CfeFlood flood-opacity='0' result='a'/%3E%3CfeColorMatrix in='SourceAlpha' values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0' result='b'/%3E%3CfeOffset dy='1'/%3E%3CfeGaussianBlur stdDeviation='1.5'/%3E%3CfeColorMatrix values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.35 0'/%3E%3CfeBlend in2='a' result='c'/%3E%3CfeBlend in='SourceGraphic' in2='c'/%3E%3C/filter%3E%3C/defs%3E%3C/svg%3E") 16 16, nwse-resize`;
+  }
+
+  #rotateCursorSvg(deg) {
+    const r = Math.round(deg - 45);
+    return `url("data:image/svg+xml,%3Csvg width='32' height='32' viewBox='0 0 32 32' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cg transform='rotate(${r} 16 16)'%3E%3Cg filter='url(%23f)'%3E%3Cpath d='M12.5607 22.4393L12.0216 21.9002C17.1558 21.2216 21.2216 17.1558 21.9002 12.0216L22.4393 12.5607C23.0251 13.1464 23.9749 13.1464 24.5607 12.5607C25.1464 11.9749 25.1464 11.0251 24.5607 10.4393L21.5607 7.43934C20.9749 6.85355 20.0251 6.85355 19.4393 7.43934L16.4393 10.4393C15.8536 11.0251 15.8536 11.9749 16.4393 12.5607C17.0251 13.1464 17.9749 13.1464 18.5607 12.5607L18.8056 12.3157C18.1013 15.5527 15.5527 18.1013 12.3157 18.8056L12.5607 18.5607C13.1464 17.9749 13.1464 17.0251 12.5607 16.4393C11.9749 15.8536 11.0251 15.8536 10.4393 16.4393L7.43934 19.4393C6.85356 20.0251 6.85356 20.9749 7.43934 21.5607L10.4393 24.5607C11.0251 25.1464 11.9749 25.1464 12.5607 24.5607C13.1464 23.9749 13.1464 23.0251 12.5607 22.4393Z' fill='white'/%3E%3C/g%3E%3Cpath d='M23.8536 11.8536C23.6583 12.0488 23.3417 12.0488 23.1464 11.8536L21 9.70711V10.5C21 16.299 16.299 21 10.5 21H9.70711L11.8536 23.1464C12.0488 23.3417 12.0488 23.6583 11.8536 23.8536C11.6583 24.0488 11.3417 24.0488 11.1464 23.8536L8.14645 20.8536C7.95119 20.6583 7.95119 20.3417 8.14645 20.1464L11.1464 17.1464C11.3417 16.9512 11.6583 16.9512 11.8536 17.1464C12.0488 17.3417 12.0488 17.6583 11.8536 17.8536L9.70711 20H10.5C15.7467 20 20 15.7467 20 10.5V9.70711L17.8536 11.8536C17.6583 12.0488 17.3417 12.0488 17.1464 11.8536C16.9512 11.6583 16.9512 11.3417 17.1464 11.1464L20.1464 8.14645C20.3417 7.95119 20.6583 7.95119 20.8536 8.14645L23.8536 11.1464C24.0488 11.3417 24.0488 11.6583 23.8536 11.8536Z' fill='black'/%3E%3C/g%3E%3Cdefs%3E%3Cfilter id='f' x='4' y='5' width='24' height='24' filterUnits='userSpaceOnUse' color-interpolation-filters='sRGB'%3E%3CfeFlood flood-opacity='0' result='a'/%3E%3CfeColorMatrix in='SourceAlpha' values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0' result='b'/%3E%3CfeOffset dy='1'/%3E%3CfeGaussianBlur stdDeviation='1.5'/%3E%3CfeColorMatrix values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.35 0'/%3E%3CfeBlend in2='a' result='c'/%3E%3CfeBlend in='SourceGraphic' in2='c'/%3E%3C/filter%3E%3C/defs%3E%3C/svg%3E") 16 16, pointer`;
+  }
+
+  #syncAngleCursor() {
+    if (!this.#angleHandle || !this.#hasAngle) return;
+    const hitArea = this.#angleHandle.querySelector(".fig-handle-hit-area");
+    if (!hitArea) return;
+    hitArea.style.cursor = this.#rotateCursorSvg(this.#angle);
+  }
+
+  #syncPositions() {
+    const container = this.#container;
+    if (!container || !this.#pointHandle) return;
+    const rect = container.getBoundingClientRect();
+
+    this.#pointHandle.setAttribute("value", `${this.#x}% ${this.#y}%`);
+
+    if (this.#radiusSvg) {
+      const cx = (this.#x / 100) * rect.width;
+      const cy = (this.#y / 100) * rect.height;
+      const r = this.#resolveRadius(rect.width);
+      const svg = this.#radiusSvg;
+      const d = Math.max(r * 2, 1);
+      svg.style.position = "absolute";
+      svg.style.width = `${d}px`;
+      svg.style.height = `${d}px`;
+      svg.style.left = `${cx - r}px`;
+      svg.style.top = `${cy - r}px`;
+      svg.setAttribute("viewBox", `0 0 ${d} ${d}`);
+      const circles = svg.querySelectorAll("circle");
+      for (const c of circles) {
+        c.setAttribute("cx", String(r));
+        c.setAttribute("cy", String(r));
+        c.setAttribute("r", String(Math.max(r - 1, 0)));
+      }
+      if (this.#radiusTooltip) {
+        this.#radiusTooltip.setAttribute("text", this.#formatRadius());
+      }
+    }
+
+    if (this.#angleSvg && this.#hasAngle) {
+      const cx = (this.#x / 100) * rect.width;
+      const cy = (this.#y / 100) * rect.height;
+      const r = this.#resolveRadius(rect.width);
+      const angleRad = (this.#angle * Math.PI) / 180;
+      const ax = cx + r * Math.cos(angleRad);
+      const ay = cy + r * Math.sin(angleRad);
+
+      const svg = this.#angleSvg;
+      svg.style.width = `${rect.width}px`;
+      svg.style.height = `${rect.height}px`;
+      svg.style.left = "0";
+      svg.style.top = "0";
+      svg.setAttribute("viewBox", `0 0 ${rect.width} ${rect.height}`);
+      const line = svg.querySelector("line");
+      if (line) {
+        line.setAttribute("x1", String(cx));
+        line.setAttribute("y1", String(cy));
+        line.setAttribute("x2", String(ax));
+        line.setAttribute("y2", String(ay));
+      }
+    }
+
+    if (this.#angleHandle && this.#hasAngle) {
+      const cx = (this.#x / 100) * rect.width;
+      const cy = (this.#y / 100) * rect.height;
+      const r = this.#resolveRadius(rect.width);
+      const angleRad = (this.#angle * Math.PI) / 180;
+      const ax = cx + r * Math.cos(angleRad);
+      const ay = cy + r * Math.sin(angleRad);
+      const pxPct = rect.width > 0 ? (ax / rect.width) * 100 : 0;
+      const pyPct = rect.height > 0 ? (ay / rect.height) * 100 : 0;
+      this.#angleHandle.setAttribute("value", `${pxPct}% ${pyPct}%`);
+
+      if (this.#angleTooltip) {
+        this.#angleTooltip.setAttribute("text", `${Math.round(this.#angle)}°`);
+      }
+    }
+
+    this.#syncAngleCursor();
+  }
+
+  #emitInput() {
+    this.dispatchEvent(new CustomEvent("input", { bubbles: true, detail: this.value }));
+  }
+
+  #emitChange() {
+    this.dispatchEvent(new CustomEvent("change", { bubbles: true, detail: this.value }));
+  }
+
+  #syncValueAttribute() {
+    this.setAttribute("value", JSON.stringify(this.value));
+  }
+
+  #setupEventListeners() {
+    if (!this.#pointHandle) return;
+
+    this.#pointHandle.addEventListener("input", (e) => {
+      e.stopPropagation();
+      this.#isDragging = true;
+      const px = e.detail?.px ?? this.#x / 100;
+      const py = e.detail?.py ?? this.#y / 100;
+      this.#x = Math.round(Math.max(0, Math.min(100, px * 100)));
+      this.#y = Math.round(Math.max(0, Math.min(100, py * 100)));
+      if (this.#pointTooltip) {
+        this.#pointTooltip.setAttribute("text", this.#pointTipText);
+        this.#pointTooltip.setAttribute("show", "true");
+        this.#pointTooltip.showPopup?.();
+      }
+      this.#syncPositions();
+      this.#emitInput();
+    });
+
+    this.#pointHandle.addEventListener("change", (e) => {
+      e.stopPropagation();
+      const px = e.detail?.px ?? this.#x / 100;
+      const py = e.detail?.py ?? this.#y / 100;
+      this.#x = Math.round(Math.max(0, Math.min(100, px * 100)));
+      this.#y = Math.round(Math.max(0, Math.min(100, py * 100)));
+      if (this.#pointTooltip) this.#pointTooltip.removeAttribute("show");
+      this.#syncPositions();
+      this.#syncValueAttribute();
+      this.#emitChange();
+      requestAnimationFrame(() => { this.#isDragging = false; });
+    });
+
+    if (this.#angleHandle) {
+      this.#angleHandle.addEventListener("input", (e) => {
+        e.stopPropagation();
+        this.#isAngleDragging = true;
+        this.classList.add("fig-canvas-point-ring-active");
+        const container = this.#container;
+        if (!container) return;
+        const rect = container.getBoundingClientRect();
+        const cx = (this.#x / 100) * rect.width;
+        const cy = (this.#y / 100) * rect.height;
+        const hx = e.detail?.x ?? 0;
+        const hy = e.detail?.y ?? 0;
+        const hw = this.#angleHandle.offsetWidth / 2;
+        const hh = this.#angleHandle.offsetHeight / 2;
+        const dx = (hx + hw) - cx;
+        const dy = (hy + hh) - cy;
+        let angle = (Math.atan2(dy, dx) * 180) / Math.PI;
+        if (this.#shouldSnap(e.detail?.shiftKey)) {
+          angle = Math.round(angle / 15) * 15;
+        }
+        this.#angle = angle;
+
+        let dist = Math.sqrt(dx * dx + dy * dy);
+        if (this.#shouldSnap(e.detail?.shiftKey)) {
+          const step = this.#radiusIsPercent ? 5 : 10;
+          if (this.#radiusIsPercent) {
+            let pct = (dist / rect.width) * 100;
+            pct = Math.round(pct / step) * step;
+            dist = (pct / 100) * rect.width;
+          } else {
+            dist = Math.round(dist / step) * step;
+          }
+        }
+        if (this.#radiusIsPercent) {
+          this.#radius = Math.max(0, (dist / rect.width) * 100);
+        } else {
+          this.#radius = Math.max(0, dist);
+        }
+
+        this.#syncPositions();
+        if (this.#angleTooltip) {
+          this.#angleTooltip.setAttribute("text", `${Math.round(this.#angle)}°`);
+          this.#angleTooltip.setAttribute("show", "true");
+          this.#angleTooltip.showPopup?.();
+        }
+        if (this.#radiusTooltip) {
+          this.#radiusTooltip.setAttribute("text", this.#formatRadius());
+        }
+        this.#emitInput();
+      });
+
+      this.#angleHandle.addEventListener("change", (e) => {
+        e.stopPropagation();
+        this.classList.remove("fig-canvas-point-ring-active");
+        if (this.#angleTooltip) this.#angleTooltip.removeAttribute("show");
+        this.#syncPositions();
+        this.#syncValueAttribute();
+        this.#emitChange();
+        requestAnimationFrame(() => { this.#isAngleDragging = false; });
+      });
+
+      this.#angleHandle.addEventListener("hitareadown", (e) => {
+        e.stopPropagation();
+        const origEvent = e.detail?.originalEvent;
+        if (!origEvent) return;
+        origEvent.preventDefault();
+        this.#isAngleDragging = true;
+        this.classList.add("fig-canvas-point-ring-active");
+        const container = this.#container;
+        if (!container) return;
+
+        if (this.#angleTooltip) {
+          this.#angleTooltip.setAttribute("show", "true");
+          this.#angleTooltip.showPopup?.();
+        }
+
+        const prevBodyCursor = document.body.style.cursor;
+        document.body.style.cursor = this.#rotateCursorSvg(this.#angle);
+
+        const onMove = (ev) => {
+          const rect = container.getBoundingClientRect();
+          const cx = (this.#x / 100) * rect.width;
+          const cy = (this.#y / 100) * rect.height;
+          const dx = ev.clientX - rect.left - cx;
+          const dy = ev.clientY - rect.top - cy;
+          let angle = (Math.atan2(dy, dx) * 180) / Math.PI;
+          if (this.#shouldSnap(ev.shiftKey)) {
+            angle = Math.round(angle / 15) * 15;
+          }
+          this.#angle = angle;
+          this.#syncPositions();
+          document.body.style.cursor = this.#rotateCursorSvg(this.#angle);
+          if (this.#angleTooltip) {
+            this.#angleTooltip.setAttribute("text", `${Math.round(this.#angle)}°`);
+          }
+          this.#emitInput();
+        };
+
+        const onUp = () => {
+          this.#isAngleDragging = false;
+          this.classList.remove("fig-canvas-point-ring-active");
+          document.body.style.cursor = prevBodyCursor;
+          if (this.#angleTooltip) this.#angleTooltip.removeAttribute("show");
+          this.#syncValueAttribute();
+          this.#emitChange();
+          window.removeEventListener("pointermove", onMove);
+          window.removeEventListener("pointerup", onUp);
+        };
+
+        window.addEventListener("pointermove", onMove);
+        window.addEventListener("pointerup", onUp);
+      });
+    }
+  }
+
+  #setupRadiusDrag(circle) {
+    if (!circle) return;
+    circle.addEventListener("pointermove", (e) => {
+      if (this.#isRadiusDragging) return;
+      const container = this.#container;
+      if (!container) return;
+      const rect = container.getBoundingClientRect();
+      const cx = (this.#x / 100) * rect.width;
+      const cy = (this.#y / 100) * rect.height;
+      const deg = (Math.atan2(e.clientY - rect.top - cy, e.clientX - rect.left - cx) * 180) / Math.PI;
+      circle.style.cursor = this.#resizeCursorSvg(deg);
+    });
+    const onDown = (e) => {
+      if (this.hasAttribute("disabled")) return;
+      e.preventDefault();
+      e.stopPropagation();
+      this.#isRadiusDragging = true;
+      this.classList.add("fig-canvas-point-ring-active");
+      const container = this.#container;
+      if (!container) return;
+
+      if (this.#radiusTooltip) {
+        this.#radiusTooltip.setAttribute("show", "true");
+        this.#radiusTooltip.showPopup?.();
+      }
+
+      const prevBodyCursor = document.body.style.cursor;
+      circle.style.pointerEvents = "none";
+      const rect0 = container.getBoundingClientRect();
+      const cx0 = (this.#x / 100) * rect0.width;
+      const cy0 = (this.#y / 100) * rect0.height;
+      const initDeg = (Math.atan2(e.clientY - rect0.top - cy0, e.clientX - rect0.left - cx0) * 180) / Math.PI;
+      document.body.style.cursor = this.#resizeCursorSvg(initDeg);
+
+      const onMove = (ev) => {
+        const rect = container.getBoundingClientRect();
+        const cx = (this.#x / 100) * rect.width;
+        const cy = (this.#y / 100) * rect.height;
+        const dx = ev.clientX - rect.left - cx;
+        const dy = ev.clientY - rect.top - cy;
+        document.body.style.cursor = this.#resizeCursorSvg((Math.atan2(dy, dx) * 180) / Math.PI);
+        let dist = Math.sqrt(dx * dx + dy * dy);
+        if (this.#shouldSnap(ev.shiftKey)) {
+          const step = this.#radiusIsPercent ? 5 : 10;
+          if (this.#radiusIsPercent) {
+            let pct = (dist / rect.width) * 100;
+            pct = Math.round(pct / step) * step;
+            dist = (pct / 100) * rect.width;
+          } else {
+            dist = Math.round(dist / step) * step;
+          }
+        }
+        if (this.#radiusIsPercent) {
+          this.#radius = Math.max(0, (dist / rect.width) * 100);
+        } else {
+          this.#radius = Math.max(0, dist);
+        }
+        this.#syncPositions();
+        this.#emitInput();
+      };
+
+      const onUp = () => {
+        this.#isRadiusDragging = false;
+        this.classList.remove("fig-canvas-point-ring-active");
+        circle.style.pointerEvents = "";
+        document.body.style.cursor = prevBodyCursor;
+        if (this.#radiusTooltip) this.#radiusTooltip.removeAttribute("show");
+        this.#syncValueAttribute();
+        this.#emitChange();
+        window.removeEventListener("pointermove", onMove);
+        window.removeEventListener("pointerup", onUp);
+      };
+
+      window.addEventListener("pointermove", onMove);
+      window.addEventListener("pointerup", onUp);
+    };
+    circle.addEventListener("pointerdown", onDown);
+    this._radiusDragCleanup = () => circle.removeEventListener("pointerdown", onDown);
+  }
+
+  #teardownRadiusDrag() {
+    if (this._radiusDragCleanup) {
+      this._radiusDragCleanup();
+      this._radiusDragCleanup = null;
+    }
+  }
+}
+customElements.define("fig-canvas-point", FigCanvasPoint);
+
 /* Handle */
 class FigHandle extends HTMLElement {
   static observedAttributes = [
@@ -13299,6 +13990,8 @@ class FigHandle extends HTMLElement {
     "value",
     "type",
     "control",
+    "hit-area",
+    "hit-area-mode",
   ];
 
   #isDragging = false;
@@ -13306,6 +13999,7 @@ class FigHandle extends HTMLElement {
   #boundPointerDown = null;
   #applyingValue = false;
   #colorTip = null;
+  #hitAreaEl = null;
 
   get #controlMode() {
     return this.getAttribute("control") || null;
@@ -13443,8 +14137,70 @@ class FigHandle extends HTMLElement {
     this.#applyingValue = false;
   }
 
+  get #hitAreaMode() {
+    return this.getAttribute("hit-area-mode") || "handle";
+  }
+
+  #parseHitArea() {
+    const raw = this.getAttribute("hit-area");
+    if (!raw) return null;
+    const tokens = raw.trim().split(/\s+/);
+    let vPad = 0, hPad = 0, circle = false;
+    const nums = [];
+    for (const t of tokens) {
+      if (t === "circle") { circle = true; continue; }
+      const n = parseFloat(t);
+      if (Number.isFinite(n)) nums.push(n);
+    }
+    if (nums.length >= 2) { vPad = nums[0]; hPad = nums[1]; }
+    else if (nums.length === 1) { vPad = nums[0]; hPad = nums[0]; }
+    else return null;
+    return { vPad, hPad, circle };
+  }
+
+  #syncHitArea() {
+    const parsed = this.#parseHitArea();
+    if (!parsed) {
+      if (this.#hitAreaEl) {
+        this.#hitAreaEl.remove();
+        this.#hitAreaEl = null;
+      }
+      this.style.removeProperty("--fig-handle-hit-area-size");
+      return;
+    }
+    if (!this.#hitAreaEl) {
+      const el = document.createElement("div");
+      el.classList.add("fig-handle-hit-area");
+      el.addEventListener("pointerdown", (e) => this.#onHitAreaPointerDown(e));
+      this.prepend(el);
+      this.#hitAreaEl = el;
+    }
+    this.style.setProperty("--fig-handle-hit-area-size", String(parsed.hPad * 2));
+    if (parsed.circle) {
+      this.#hitAreaEl.style.borderRadius = "50%";
+    } else {
+      this.#hitAreaEl.style.borderRadius = "inherit";
+    }
+  }
+
+  #onHitAreaPointerDown(e) {
+    if (this.hasAttribute("disabled")) return;
+    if (e.target !== this.#hitAreaEl) return;
+    if (this.#hitAreaMode === "delegate") {
+      e.preventDefault();
+      e.stopPropagation();
+      this.dispatchEvent(new CustomEvent("hitareadown", {
+        bubbles: true,
+        detail: { originalEvent: e },
+      }));
+    } else {
+      this.#onPointerDown(e);
+    }
+  }
+
   connectedCallback() {
     this.#syncDrag();
+    this.#syncHitArea();
     this.addEventListener("click", this.#handleSelect);
     document.addEventListener("pointerdown", this.#handleDeselect);
     document.addEventListener("keydown", this.#handleKeyDown);
@@ -13456,6 +14212,7 @@ class FigHandle extends HTMLElement {
   disconnectedCallback() {
     this.#teardownDrag();
     this.#hideColorTip();
+    if (this.#hitAreaEl) { this.#hitAreaEl.remove(); this.#hitAreaEl = null; }
     this.removeEventListener("click", this.#handleSelect);
     document.removeEventListener("pointerdown", this.#handleDeselect);
     document.removeEventListener("keydown", this.#handleKeyDown);
@@ -13509,6 +14266,7 @@ class FigHandle extends HTMLElement {
       }
     }
     if (name === "drag") this.#syncDrag();
+    if (name === "hit-area") this.#syncHitArea();
     if (name === "value" && !this.#applyingValue && !this.#isDragging) {
       this.#applyValue(value);
     }
@@ -13547,16 +14305,23 @@ class FigHandle extends HTMLElement {
 
     this.#isDragging = true;
     const axes = this.#axes;
-    const containerRect = container.getBoundingClientRect();
     const handleW = this.offsetWidth;
     const handleH = this.offsetHeight;
+    let lastRect = null;
+
+    const handleRect = this.getBoundingClientRect();
+    const handleCenterX = handleRect.left + handleRect.width / 2;
+    const handleCenterY = handleRect.top + handleRect.height / 2;
+    const offsetX = e.clientX - handleCenterX;
+    const offsetY = e.clientY - handleCenterY;
 
     const clampAndApply = (clientX, clientY, shiftKey = false) => {
       const rect = container.getBoundingClientRect();
+      lastRect = rect;
       const currentLeft = parseFloat(this.style.left) || 0;
       const currentTop = parseFloat(this.style.top) || 0;
-      const rawX = clientX - rect.left - handleW / 2;
-      const rawY = clientY - rect.top - handleH / 2;
+      const rawX = (clientX - offsetX) - rect.left - handleW / 2;
+      const rawY = (clientY - offsetY) - rect.top - handleH / 2;
 
       const clampedX = Math.max(
         -handleW / 2,
@@ -13609,7 +14374,7 @@ class FigHandle extends HTMLElement {
         new CustomEvent("input", {
           bubbles: true,
           detail: {
-            ...this.#positionDetail(container.getBoundingClientRect()),
+            ...this.#positionDetail(lastRect),
             shiftKey: e.shiftKey,
           },
         }),
@@ -13628,7 +14393,7 @@ class FigHandle extends HTMLElement {
         this.dispatchEvent(
           new CustomEvent("change", {
             bubbles: true,
-            detail: this.#positionDetail(container.getBoundingClientRect()),
+            detail: this.#positionDetail(lastRect),
           }),
         );
         const swallowClick = (evt) => {