@jsenv/dom 0.17.19 → 0.17.21

package/dist/jsenv_dom.js

@@ -261,11 +261,22 @@ const chainEvent = (customEvent, parentEvent) => {
   if (!parentEvent) {
     return customEvent;
   }
-  if (!customEvent.detail) {
-    console.warn(
-      `Event "${customEvent.type}" has no detail object. Cannot chain to parent event "${parentEvent.type}".`,
-    );
-    return customEvent;
+  if (!customEvent.detail || typeof customEvent.detail !== "object") {
+    // A native event has nowhere to hang the chain: `Event` has no detail at
+    // all and `UIEvent` (so `InputEvent` too) exposes it as a readonly number.
+    // Give it an own detail object, shadowing the prototype getter, so a
+    // synthetic event dispatched on behalf of a gesture can still say what
+    // caused it.
+    if (nativeDetailHasMeaning(customEvent)) {
+      console.warn(
+        `Chaining "${customEvent.type}" to "${parentEvent.type}" replaces its native detail (${customEvent.detail}), which carries the click count on this event type. Chain a custom event instead, or read the click count before chaining.`,
+      );
+    }
+    Object.defineProperty(customEvent, "detail", {
+      value: {},
+      configurable: true,
+      enumerable: true,
+    });
   }
   // Always build eventChain from the first wrapping so callers can rely on it
   // being present whenever `parentEvent` is set.
@@ -309,6 +320,24 @@ const findEvent = (event, predicate) => {
   return undefined;
 };
 
+// `detail` is a click count on the pointer events that define one, and 0
+// everywhere else (`input`, `focus`, `wheel`…). Overwriting it there loses the
+// only way to tell a real click from a keyboard/programmatic one (detail === 0),
+// so those events must not be chained.
+const EVENT_TYPES_WITH_MEANINGFUL_DETAIL = new Set([
+  "click",
+  "auxclick",
+  "dblclick",
+  "mousedown",
+  "mouseup",
+]);
+const nativeDetailHasMeaning = (event) => {
+  if (EVENT_TYPES_WITH_MEANINGFUL_DETAIL.has(event.type)) {
+    return true;
+  }
+  return typeof event.detail === "number" && event.detail !== 0;
+};
+
 const resolveEventPredicate = (predicate) => {
   if (typeof predicate === "string") {
     return (e) => e.type === predicate;
@@ -9117,12 +9146,16 @@ const css$4 = /* css */`
     /* A source taken by long press must let the scroll through until the grab —
        which is exactly what the long press is there to tell apart. Zoom has
        nothing to do with the gesture and nobody should lose it by resting a
-       finger on a word. */
+       finger on a word.
+
+       Vertical, because that is the way the page and the lists in it go: a
+       source dragged along one axis is surrounded by something scrolling along
+       that same axis (a row of a list runs the way the list scrolls), and a
+       source dragged both ways sits on the usual vertical page. */
     touch-action: pan-y pinch-zoom;
   }
   [data-drag-source="x"] {
-    /* The axis is the one thing the caller has to say, being the only one who
-       knows which way what surrounds the source scrolls. */
+    /* …and the sideways one, for the same reason read the other way. */
     touch-action: pan-x pinch-zoom;
   }
   [data-drag-on-contact] [data-drag-source],
@@ -9158,23 +9191,36 @@ import.meta.css = [css$4, "@jsenv/dom/src/interaction/drag/drag_after_intent.js"
  *
  * On the element and not on the window, so the rest of the page keeps its
  * touches on the compositor's fast path.
+ *
+ * Exported because a drag does not always begin on a drag source: a copy caught
+ * on its way home is pressed through the pictures of a view transition, and the
+ * touch lands on the document root (see letCopyBeCaught in drag_to.js). Same
+ * rule, other element — and it has to be the same function, or the listener put
+ * down is not the one taken back off.
  */
 const keepTouchRefusable = () => {
   // Being registered IS the whole of it — see above.
 };
 
 /**
- * Says an element is something a drag can start from.
+ * Says an element is something a drag can start from, and which way that drag
+ * goes.
+ *
+ * The axes are written in the DOM rather than kept here because they are what
+ * someone ELSE reads: a box above this one that travels under the same finger
+ * (a row of slides, a sheet pushed down to close it) has to know which axes are
+ * already spoken for before it answers the press — the same thing a travel says
+ * about itself with `data-travel-by-drag`. It is also what leaves the browser
+ * the pan it may still do until the grab (see the stylesheet above).
  *
  * @param {Element} element
- * @param {string} [axes]
- *   Which way the SURROUNDINGS scroll, so the other axis is left to them until
- *   the grab: `"x"` for a source inside something travelling sideways, anything
- *   else for the usual vertical page.
+ * @param {"x"|"y"|"xy"} [axes="xy"]
+ *   Which way the drag walks. A list reordered along its own line says `"y"`;
+ *   something carried across a board, or thrown, goes both ways.
  * @returns {function} Takes the mark back off.
  */
-const markDragSource = (element, axes) => {
-  element.setAttribute("data-drag-source", axes === "x" ? "x" : "");
+const markDragSource = (element, axes = "xy") => {
+  element.setAttribute("data-drag-source", axes);
   element.addEventListener("touchmove", keepTouchRefusable, {
     passive: false
   });
@@ -11569,6 +11615,18 @@ const css$1 = /* css */`
     pointer-events: auto;
   }
 
+  /* …and a FINGER reaching for it does not land on it: the pictures of the
+     transition cover the page, so as far as the browser is concerned the touch
+     began on the document root. What a touch may do is decided there and at that
+     moment, so the root says it for as long as the copy can be caught — the pan
+     is ours (nothing should scroll while something is landing), zoom stays the
+     reader's. Half of a pair: without the non-passive listener put down at the
+     same moment (see letCopyBeCaught) every touchmove arrives already
+     non-cancelable and refusing it does nothing. */
+  [data-drag-catchable] {
+    touch-action: pinch-zoom;
+  }
+
   /* Ce qui a été lancé: il continue dans la direction du geste jusqu'à sortir de
      l'écran, et revient par le même chemin si la réponse refuse. */
   [navi-drag-clone-wrapper][data-tossed] {
@@ -12514,7 +12572,15 @@ const startDragToCarryCopy = (event, {
       return dragGesture;
     }, {
       threshold,
-      longPress,
+      // A copy caught on its way home is not an ambiguous press: the hand
+      // reached for something moving, and the press was already matched
+      // against the copy's own box before it got here. The wait a finger is
+      // asked for elsewhere tells a scroll from a drag, and there is no scroll
+      // to tell it from — the copy covers that spot from the top layer. Asked
+      // for anyway it cannot even be answered: the wait is about as long as the
+      // journey, so the thing is home before the proof is done, while a mouse
+      // takes it in five pixels.
+      longPress: cloneWrapperCaught ? false : longPress,
       longPressDelay,
       longPressSlop,
       onPressStart,
@@ -12704,6 +12770,17 @@ const letCopyBeCaught = (cloneWrapper, carryAgain) => {
   // gesture holds what it grabbed rather than whatever was behind.
   cloneWrapper.setAttribute("data-catchable", "");
   document.addEventListener("pointerdown", onPointerDown, true);
+  // The touch half of the same reach, said on the root because that is where a
+  // finger pressing through the pictures lands (see the stylesheet). Both go
+  // down before the copy sets off, since what a touch may do is settled when it
+  // begins: put down later, the press is still read, the carry still starts, and
+  // the browser cancels the pointer one move afterwards — a copy that cannot be
+  // caught with a finger and can with a mouse.
+  const root = document.documentElement;
+  root.setAttribute("data-drag-catchable", "");
+  root.addEventListener("touchmove", keepTouchRefusable, {
+    passive: false
+  });
   return {
     settled: async () => {
       // A hand that lets go and presses again while the copy is still there is
@@ -12715,6 +12792,8 @@ const letCopyBeCaught = (cloneWrapper, carryAgain) => {
       }
       cloneWrapper.removeAttribute("data-catchable");
       document.removeEventListener("pointerdown", onPointerDown, true);
+      root.removeAttribute("data-drag-catchable");
+      root.removeEventListener("touchmove", keepTouchRefusable);
       return caught;
     }
   };
@@ -13006,12 +13085,13 @@ const DRAG_FLICK_DISTANCE = 8;
 // way. Let go and it comes back — a wall one can lean on, never walk through.
 const DRAG_RESISTANCE = 0.3;
 
-// What a drag must not start on: something that reads the pointer itself. A
-// button or a link is not in the list — dragging from one travels, and the
-// click it would have made is swallowed on the way out. A drag source is: it
-// answers the same press, and a travel starting there takes the pointer capture
-// away from a gesture already carrying something.
-const DRAG_EXCLUDED_SELECTOR = ["input", "textarea", "select", '[contenteditable=""]', '[contenteditable="true"]', "[data-drag-source]", "[data-drag-handle]", "[data-no-drag-travel]"].join(",");
+// What a drag must not start on: something that reads the pointer itself, whole,
+// with no axis left to share. A button or a link is not in the list — dragging
+// from one travels, and the click it would have made is swallowed on the way
+// out. A drag SOURCE is not either: it says which way it goes and only takes
+// that (see DRAG_SOURCE_AXES_ATTRIBUTE) — but a dedicated handle is, being a
+// place whose only purpose is to be taken hold of, from the first pixel.
+const DRAG_EXCLUDED_SELECTOR = ["input", "textarea", "select", '[contenteditable=""]', '[contenteditable="true"]', "[data-drag-handle]", "[data-no-drag-travel]"].join(",");
 
 // Which axes a box travels on, one attribute per gesture, said in the DOM by
 // whoever owns the box: it is what a box ABOVE another reads to know the
@@ -13019,6 +13099,12 @@ const DRAG_EXCLUDED_SELECTOR = ["input", "textarea", "select", '[contenteditable
 // from the outside.
 const DRAG_AXES_ATTRIBUTE = "data-travel-by-drag";
 const WHEEL_AXES_ATTRIBUTE = "data-travel-by-wheel";
+// The same thing said by something that is PICKED UP rather than travelled: a
+// row taken out of a list, a card carried across a board (see markDragSource).
+// It holds the pointer from the press exactly as a nested travel does, so it is
+// read exactly as one — a list reordered along its own line takes the axis it
+// runs on and leaves the other to whoever is above.
+const DRAG_SOURCE_AXES_ATTRIBUTE = "data-drag-source";
 
 // A surface the browser paints in the top layer: it is still a DOM descendant
 // of whatever it was written in, and it is nowhere near it on screen — it
@@ -13234,10 +13320,12 @@ const startDragToTravel = (pointerDownEvent, {
   if (!target.closest || target.closest(DRAG_EXCLUDED_SELECTOR)) {
     return null;
   }
-  // A box between the finger and this one that travels the same way: the
-  // gesture is its, and this one is left with the axes it does not walk — none
-  // at all, most of the time, and then there is no gesture here to read.
-  const axesLeft = axesLeftBy(axes, target, element, DRAG_AXES_ATTRIBUTE);
+  // A box between the finger and this one that travels the same way, and then
+  // anything between them that is picked up and carried the same way: the
+  // gesture is theirs, and this one is left with the axes none of them walks —
+  // none at all, most of the time, and then there is no gesture here to read.
+  const axesLeftByTravels = axesLeftBy(axes, target, element, DRAG_AXES_ATTRIBUTE);
+  const axesLeft = axesLeftByTravels && axesLeftBy(axesLeftByTravels, target, element, DRAG_SOURCE_AXES_ATTRIBUTE);
   if (!axesLeft) {
     return null;
   }
@@ -14275,6 +14363,90 @@ const stickyAsRelativeCoords = (
   return [leftPosition, topPosition];
 };
 
+/**
+ * The on-screen keyboard, when the app takes it over.
+ *
+ * By default a mobile browser answers the keyboard by shrinking the VISUAL
+ * viewport, and everything sized against that viewport follows for free —
+ * which is what the whole positioning layer here already relies on (see
+ * pickPositionRelativeTo's own visualViewport reads). The VirtualKeyboard API
+ * (Chromium only — no Firefox, no Safari) offers the other deal:
+ * `overlaysContent = true` and the keyboard stops resizing anything, painting
+ * over the page instead, while its geometry becomes readable — `boundingRect`
+ * and a `geometrychange` event here, `env(keyboard-inset-*)` in CSS.
+ *
+ * That deal has to be taken whole: the instant the viewport stops shrinking,
+ * whoever was sizing against it is sizing against a rectangle the keyboard now
+ * covers. So this module answers ONE question — how many pixels at the bottom
+ * of the visual viewport the keyboard covers — and the positioning layer
+ * subtracts it. The answer is 0 in every other case (unsupported, never opted
+ * in, keyboard closed), which is exactly what makes the two paths one path:
+ * where the browser shrinks the viewport itself, there is nothing left to
+ * subtract.
+ *
+ * Why take the deal at all, then, if the outcome is meant to match? Because a
+ * resizing viewport is a resize of EVERYTHING, whether or not it had anything
+ * to do with the field being typed into — the page reflows, fixed bars move,
+ * and a mobile browser fires that resize transiently as focus goes from one
+ * input to the next. Overlaying leaves the layout alone and hands over a
+ * number instead. So navi takes it by default (see its own index.js) and only
+ * offers a way back out, for an app whose own layout was built around the
+ * viewport shrinking.
+ */
+
+const virtualKeyboard = window.navigator.virtualKeyboard;
+
+/**
+ * Whether the keyboard overlays the content instead of resizing the viewport.
+ * Returns whether it applies at all — false means the browser has no
+ * VirtualKeyboard API and keeps shrinking the visual viewport, which is the
+ * behavior everything here already follows, so there is nothing to report to
+ * the caller beyond "not this way".
+ */
+const setVirtualKeyboardOverlaysContent = (value) => {
+  if (!virtualKeyboard) {
+    return false;
+  }
+  virtualKeyboard.overlaysContent = value;
+  return true;
+};
+
+/**
+ * How many pixels at the bottom of the visual viewport the keyboard currently
+ * covers — 0 unless the app opted in above AND the keyboard is up.
+ *
+ * `boundingRect` is all-zero when the keyboard is hidden, and also while
+ * `overlaysContent` is false: a keyboard that resized the viewport covers
+ * nothing that is left of it, so the zero is the right answer rather than a
+ * missing one.
+ */
+const getVirtualKeyboardOverlayHeight = () => {
+  if (!virtualKeyboard) {
+    return 0;
+  }
+  const { height } = virtualKeyboard.boundingRect;
+  return height > 0 ? height : 0;
+};
+
+/**
+ * Calls `callback` whenever the keyboard shows, hides or resizes. Returns an
+ * unsubscribe function; a no-op (never calls back) without support.
+ *
+ * Undebounced on purpose, unlike window/visualViewport resize
+ * (window_size.js): "geometrychange" is not the transient storm those are —
+ * it fires on the keyboard itself changing, not on the layout reacting to it,
+ * which is the whole point of overlaying.
+ */
+const subscribeVirtualKeyboardGeometryChange = (callback) => {
+  if (!virtualKeyboard) {
+    return () => {};
+  }
+  virtualKeyboard.addEventListener("geometrychange", callback);
+  return () => {
+    virtualKeyboard.removeEventListener("geometrychange", callback);
+  };
+};
+
 // Both "resize" sources fire transiently on mobile (keyboard/UI chrome
 // briefly shifting when focus moves between inputs) — debounced so
 // consumers skip that in-between state. One shared timer per source (not
@@ -14289,17 +14461,29 @@ const [publishVisualViewportResize, subscribeVisualViewportResizeSettled] =
   createPubSub();
 const [publishWindowResize, subscribeWindowResizeSettled] = createPubSub();
 
+let visualViewportResizeTimeoutId;
+const scheduleVisualViewportResize = (event) => {
+  visualViewportResizePending = true;
+  clearTimeout(visualViewportResizeTimeoutId);
+  visualViewportResizeTimeoutId = setTimeout(() => {
+    visualViewportResizePending = false;
+    publishVisualViewportResize(event);
+  }, RESIZE_SETTLE_MS);
+};
 if (window.visualViewport) {
-  let timeoutId;
-  window.visualViewport.addEventListener("resize", (event) => {
-    visualViewportResizePending = true;
-    clearTimeout(timeoutId);
-    timeoutId = setTimeout(() => {
-      visualViewportResizePending = false;
-      publishVisualViewportResize(event);
-    }, RESIZE_SETTLE_MS);
-  });
+  window.visualViewport.addEventListener(
+    "resize",
+    scheduleVisualViewportResize,
+  );
 }
+// The same event, said differently: where the keyboard overlays the content
+// (virtual_keyboard.js) there is no visualViewport resize at all when it
+// opens — the room left to place anything in changed
+// all the same, and every consumer here asks the same question either way
+// (getVisibleViewportRect in visible_rect.js already subtracts it). Through
+// the same debounce, and for the same reason: going straight from one input
+// to the next hides and re-shows the keyboard.
+subscribeVirtualKeyboardGeometryChange(scheduleVisualViewportResize);
 
 let windowResizeTimeoutId;
 window.addEventListener("resize", (event) => {
@@ -14318,6 +14502,39 @@ window.addEventListener("resize", (event) => {
   }, RESIZE_SETTLE_MS);
 });
 
+/**
+ * The part of the viewport something can actually be placed in.
+ *
+ * visualViewport, not the layout viewport: only the visual one shrinks when
+ * the on-screen keyboard opens (where the browser is the one shrinking it —
+ * see below). Its offsetLeft/Top matter too, for pinch-zoom/pan.
+ *
+ * document.documentElement.clientWidth/Height is the fallback without
+ * visualViewport support — the layout viewport net of any classic scrollbar,
+ * which is what visualViewport itself reports, unlike window.innerWidth/Height
+ * which counts the scrollbar in. Both readings existed here, one per call
+ * site, for no reason anyone stated; they only ever differed by that scrollbar
+ * and only on browsers with no visualViewport at all.
+ *
+ * The keyboard is then subtracted rather than assumed to have already shrunk
+ * the viewport: with `overlaysContent` (virtual_keyboard.js, navi turns it on)
+ * the viewport stays full height and the keyboard is painted over its bottom.
+ * Zero everywhere else, the browser having done the subtraction itself.
+ */
+const getVisibleViewportRect = () => {
+  const visualViewport = window.visualViewport;
+  const documentElement = document.documentElement;
+  const height = visualViewport
+    ? visualViewport.height
+    : documentElement.clientHeight;
+  return {
+    left: visualViewport ? visualViewport.offsetLeft : 0,
+    top: visualViewport ? visualViewport.offsetTop : 0,
+    width: visualViewport ? visualViewport.width : documentElement.clientWidth,
+    height: Math.max(0, height - getVirtualKeyboardOverlayHeight()),
+  };
+};
+
 // Minimum fraction of element width/height that must be visible on the preferred side
 // before flipping to the opposite side. Prevents flickering near the flip threshold.
 const MIN_CONTENT_VISIBILITY_RATIO = 0.6;
@@ -14440,23 +14657,17 @@ const visibleRectEffect = (
   const UNSET_EVENT = { type: "unset" };
   const check = (event = UNSET_EVENT) => {
 
-    // visualViewport, not window.innerWidth/Height: the layout viewport
-    // doesn't shrink when the on-screen keyboard opens (same reasoning as
-    // pickPositionRelativeTo's own identical choice). offsetLeft/Top matter
-    // too, for pinch-zoom/pan. Computed here regardless of scroll container
-    // (not just where the non-document branch below needs it) because a
-    // keyboard opening can change pickPositionRelativeTo's available space
-    // without moving this element's own visibleRect at all — see
-    // viewportRectChanged further down.
-    const visualViewport = window.visualViewport;
-    const viewportWidth = visualViewport
-      ? visualViewport.width
-      : window.innerWidth;
-    const viewportHeight = visualViewport
-      ? visualViewport.height
-      : window.innerHeight;
-    const viewportOffsetLeft = visualViewport ? visualViewport.offsetLeft : 0;
-    const viewportOffsetTop = visualViewport ? visualViewport.offsetTop : 0;
+    // Computed here regardless of scroll container (not just where the
+    // non-document branch below needs it) because a keyboard opening can
+    // change pickPositionRelativeTo's available space without moving this
+    // element's own visibleRect at all — see viewportRectChanged further
+    // down.
+    const {
+      left: viewportOffsetLeft,
+      top: viewportOffsetTop,
+      width: viewportWidth,
+      height: viewportHeight,
+    } = getVisibleViewportRect();
 
     // 1. Calculate element position relative to scrollable parent
     const { scrollLeft, scrollTop } = scrollContainer;
@@ -15313,19 +15524,13 @@ const pickPositionRelativeTo = (
     container,
   } = {},
 ) => {
-  // Needed before hasValidAnchor below. visualViewport, not
-  // document.documentElement.clientWidth/Height: the layout viewport
-  // doesn't shrink when the on-screen keyboard opens, only the visual one
-  // does.
-  const visualViewport = window.visualViewport;
-  const viewportWidth = visualViewport
-    ? visualViewport.width
-    : document.documentElement.clientWidth;
-  const viewportHeight = visualViewport
-    ? visualViewport.height
-    : document.documentElement.clientHeight;
-  const viewportLeft = visualViewport ? visualViewport.offsetLeft : 0;
-  const viewportTop = visualViewport ? visualViewport.offsetTop : 0;
+  // Needed before hasValidAnchor below.
+  const {
+    left: viewportLeft,
+    top: viewportTop,
+    width: viewportWidth,
+    height: viewportHeight,
+  } = getVisibleViewportRect();
 
   // Resolved early: everything below that would otherwise reach for
   // viewportLeft/Top/Width/Height instead uses these, so a "local" popover
@@ -19318,4 +19523,4 @@ const useResizeStatus = (elementRef, { as = "number" } = {}) => {
   };
 };
 
-export { EASING, ELEMENT_SIZE_CHANGE, activeElementSignal, addActiveElementEffect, addAttributeEffect, allowWheelThrough, appendStyles, applyNewPosition, canScroll, captureScrollState, chainEvent, claimWheelGesture, closestOpenableAncestor, contrastColor, createBackgroundColorTransition, createBackgroundTransition, createBorderRadiusTransition, createBorderTransition, createDragGestureController, createDragToMoveGestureController, createEventGroupLogger, createGroupTransitionController, createHeightTransition, createIterableWeakSet, createOpacityTransition, createPubSub, createStyleController, createTimelineTransition, createTransition, createTranslateXTransition, createValueEffect, createWidthTransition, cubicBezier, dispatchCustomEvent, dispatchInternalCustomEvent, dispatchPublicCustomEvent, dragAfterIntent, elementIsFocusable, elementIsVisibleForFocus, elementIsVisuallyVisible, findAfter, findAncestor, findBefore, findDescendant, findEvent, findFocusDelegateTarget, findFocusable, findSelfOrAncestorFixedPosition, formatEventSideEffect, getAncestorOpenType, getAvailableHeight, getAvailableWidth, getBackground, getBackgroundColor, getBorder, getBorderRadius, getBorderSizes, getContrastRatio, getDefaultStyles, getDragCoordinates, getDropTargetInfo, getElementSignature, getFirstVisuallyVisibleAncestor, getFocusVisibilityInfo, getHeight, getHeightWithoutTransition, getInnerHeight, getInnerWidth, getKeyboardEventDefaultAction, getLuminance, getMarginSizes, getMaxHeight, getMaxWidth, getMinHeight, getMinWidth, getOpacity, getOpacityWithoutTransition, getPaddingSizes, getPositionedParent, getPositioningScrollOffset, getPreferedColorScheme, getScrollBox, getScrollContainer, getScrollContainerSet, getScrollRelativeRect, getSelfAndAncestorScrolls, getStyle, getTranslateX, getTranslateXWithoutTransition, getTranslateY, getVisuallyVisibleInfo, getWidth, getWidthWithoutTransition, hasCSSSizeUnit, initFlexDetailsSet, initFocusGroup, initPositionSticky, isAncestorOpen, isPrimaryButtonEvent, isSameColor, isScrollable, markDragSource, measureLongestVisualLineWidth, measureScrollbar, measureWidestChildRow, mergeOneStyle, mergeTwoStyles, normalizeKeyboardKey, normalizeStyle, normalizeStyles, observeAncestorOpenState, onAncestorReopen, parsePositionArea, parseStyle, performTabNavigation, pickPositionRelativeTo, prefersDarkColors, prefersLightColors, preventFocusNav, preventFocusNavViaKeyboard, preventIntermediateScrollbar, releaseWheelGesture, resolveCSSColor, resolveCSSSize, resolveColorLuminance, resolveOklchLightness, scrollIntoViewScoped, scrollIntoViewWithStickyAwareness, scrollRoomTowards, setAttribute, setAttributes, setStyles, snapToPixel, startDragTo, startDragToResizeGesture, startDragToTravel, stickyAsRelativeCoords, stringifyStyle, subscribeVisualViewportResizeSettled, subscribeWindowResizeSettled, suppressClickAfterGesture, trapFocusInside, trapScrollInside, useActiveElement, useAvailableHeight, useAvailableWidth, useMaxHeight, useMaxWidth, useResizeStatus, visibleRectEffect, waitForPressHeld, watchWheelTravel, wheelGestureIsTakenFrom };
+export { EASING, ELEMENT_SIZE_CHANGE, activeElementSignal, addActiveElementEffect, addAttributeEffect, allowWheelThrough, appendStyles, applyNewPosition, canScroll, captureScrollState, chainEvent, claimWheelGesture, closestOpenableAncestor, contrastColor, createBackgroundColorTransition, createBackgroundTransition, createBorderRadiusTransition, createBorderTransition, createDragGestureController, createDragToMoveGestureController, createEventGroupLogger, createGroupTransitionController, createHeightTransition, createIterableWeakSet, createOpacityTransition, createPubSub, createStyleController, createTimelineTransition, createTransition, createTranslateXTransition, createValueEffect, createWidthTransition, cubicBezier, dispatchCustomEvent, dispatchInternalCustomEvent, dispatchPublicCustomEvent, dragAfterIntent, elementIsFocusable, elementIsVisibleForFocus, elementIsVisuallyVisible, findAfter, findAncestor, findBefore, findDescendant, findEvent, findFocusDelegateTarget, findFocusable, findSelfOrAncestorFixedPosition, formatEventSideEffect, getAncestorOpenType, getAvailableHeight, getAvailableWidth, getBackground, getBackgroundColor, getBorder, getBorderRadius, getBorderSizes, getContrastRatio, getDefaultStyles, getDragCoordinates, getDropTargetInfo, getElementSignature, getFirstVisuallyVisibleAncestor, getFocusVisibilityInfo, getHeight, getHeightWithoutTransition, getInnerHeight, getInnerWidth, getKeyboardEventDefaultAction, getLuminance, getMarginSizes, getMaxHeight, getMaxWidth, getMinHeight, getMinWidth, getOpacity, getOpacityWithoutTransition, getPaddingSizes, getPositionedParent, getPositioningScrollOffset, getPreferedColorScheme, getScrollBox, getScrollContainer, getScrollContainerSet, getScrollRelativeRect, getSelfAndAncestorScrolls, getStyle, getTranslateX, getTranslateXWithoutTransition, getTranslateY, getVirtualKeyboardOverlayHeight, getVisuallyVisibleInfo, getWidth, getWidthWithoutTransition, hasCSSSizeUnit, initFlexDetailsSet, initFocusGroup, initPositionSticky, isAncestorOpen, isPrimaryButtonEvent, isSameColor, isScrollable, markDragSource, measureLongestVisualLineWidth, measureScrollbar, measureWidestChildRow, mergeOneStyle, mergeTwoStyles, normalizeKeyboardKey, normalizeStyle, normalizeStyles, observeAncestorOpenState, onAncestorReopen, parsePositionArea, parseStyle, performTabNavigation, pickPositionRelativeTo, prefersDarkColors, prefersLightColors, preventFocusNav, preventFocusNavViaKeyboard, preventIntermediateScrollbar, releaseWheelGesture, resolveCSSColor, resolveCSSSize, resolveColorLuminance, resolveOklchLightness, scrollIntoViewScoped, scrollIntoViewWithStickyAwareness, scrollRoomTowards, setAttribute, setAttributes, setStyles, setVirtualKeyboardOverlaysContent, snapToPixel, startDragTo, startDragToResizeGesture, startDragToTravel, stickyAsRelativeCoords, stringifyStyle, subscribeVirtualKeyboardGeometryChange, subscribeVisualViewportResizeSettled, subscribeWindowResizeSettled, suppressClickAfterGesture, trapFocusInside, trapScrollInside, useActiveElement, useAvailableHeight, useAvailableWidth, useMaxHeight, useMaxWidth, useResizeStatus, visibleRectEffect, waitForPressHeld, watchWheelTravel, wheelGestureIsTakenFrom };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/dom",
-  "version": "0.17.19",
+  "version": "0.17.21",
   "type": "module",
   "description": "DOM utilities for writing frontend code",
   "repository": {