@ledgerhq/lumen-ui-react 0.1.13 → 0.1.15

package/dist/node_modules/@base-ui/react/esm/popover/store/PopoverStore.js

@@ -0,0 +1,94 @@
+import * as s from "react";
+import * as u from "react-dom";
+import { Timeout as m } from "../../../../utils/esm/useTimeout.js";
+import { useRefWithInit as g } from "../../../../utils/esm/useRefWithInit.js";
+import { useOnMount as h } from "../../../../utils/esm/useOnMount.js";
+import { PATIENT_CLICK_THRESHOLD as I } from "../../utils/constants.js";
+import { popupStoreSelectors as R, createInitialPopupStoreState as T } from "../../utils/popups/store.js";
+import { ReactStore as C } from "../../../../utils/esm/store/ReactStore.js";
+import { PopupTriggerMap as E } from "../../utils/popups/popupTriggerMap.js";
+import { createSelector as n } from "../../../../utils/esm/store/createSelector.js";
+import { focusOut as O, triggerHover as k, triggerPress as y, escapeKey as S } from "../../utils/reason-parts.js";
+function w() {
+  return {
+    ...T(),
+    disabled: !1,
+    modal: !1,
+    instantType: void 0,
+    openMethod: null,
+    openChangeReason: null,
+    titleElementId: void 0,
+    descriptionElementId: void 0,
+    stickIfOpen: !0,
+    nested: !1,
+    openOnHover: !1,
+    closeDelay: 0,
+    hasViewport: !1
+  };
+}
+const H = {
+  ...R,
+  disabled: n((e) => e.disabled),
+  instantType: n((e) => e.instantType),
+  openMethod: n((e) => e.openMethod),
+  openChangeReason: n((e) => e.openChangeReason),
+  modal: n((e) => e.modal),
+  stickIfOpen: n((e) => e.stickIfOpen),
+  titleElementId: n((e) => e.titleElementId),
+  descriptionElementId: n((e) => e.descriptionElementId),
+  openOnHover: n((e) => e.openOnHover),
+  closeDelay: n((e) => e.closeDelay),
+  hasViewport: n((e) => e.hasViewport)
+};
+class f extends C {
+  constructor(o) {
+    const t = {
+      ...w(),
+      ...o
+    };
+    t.open && o?.mounted === void 0 && (t.mounted = !0), super(t, {
+      popupRef: /* @__PURE__ */ s.createRef(),
+      backdropRef: /* @__PURE__ */ s.createRef(),
+      internalBackdropRef: /* @__PURE__ */ s.createRef(),
+      onOpenChange: void 0,
+      onOpenChangeComplete: void 0,
+      triggerFocusTargetRef: /* @__PURE__ */ s.createRef(),
+      beforeContentFocusGuardRef: /* @__PURE__ */ s.createRef(),
+      stickIfOpenTimeout: new m(),
+      triggerElements: new E()
+    }, H);
+  }
+  setOpen = (o, t) => {
+    const r = t.reason === k, i = t.reason === y && t.event.detail === 0, d = !o && (t.reason === S || t.reason == null);
+    if (t.preventUnmountOnClose = () => {
+      this.set("preventUnmountingOnClose", !0);
+    }, this.context.onOpenChange?.(o, t), t.isCanceled)
+      return;
+    const l = {
+      open: o,
+      nativeEvent: t.event,
+      reason: t.reason,
+      nested: this.state.nested,
+      triggerElement: t.trigger
+    };
+    this.state.floatingRootContext.context.events?.emit("openchange", l);
+    const c = () => {
+      const a = {
+        open: o,
+        openChangeReason: t.reason
+      }, p = t.trigger?.id ?? null;
+      (p || o) && (a.activeTriggerId = p, a.activeTriggerElement = t.trigger ?? null), this.update(a);
+    };
+    r ? (this.set("stickIfOpen", !0), this.context.stickIfOpenTimeout.start(I, () => {
+      this.set("stickIfOpen", !1);
+    }), u.flushSync(c)) : c(), i || d ? this.set("instantType", i ? "click" : "dismiss") : t.reason === O ? this.set("instantType", "focus") : this.set("instantType", void 0);
+  };
+  static useStore(o, t) {
+    const r = g(() => new f(t)).current, i = o ?? r;
+    return h(r.disposeEffect), i;
+  }
+  disposeEffect = () => this.context.stickIfOpenTimeout.disposeEffect();
+}
+export {
+  f as PopoverStore
+};

package/dist/node_modules/@base-ui/react/esm/popover/trigger/PopoverTrigger.js

@@ -0,0 +1,120 @@
+import z from "../../../../utils/esm/formatErrorMessage.js";
+import * as o from "react";
+import * as T from "react-dom";
+import { useStableCallback as h } from "../../../../utils/esm/useStableCallback.js";
+import { usePopoverRootContext as J } from "../root/PopoverRootContext.js";
+import { useButton as Q } from "../../use-button/useButton.js";
+import { pressableTriggerOpenStateMapping as W, triggerOpenStateMapping as X } from "../../utils/popupStateMapping.js";
+import { useRenderElement as Z } from "../../utils/useRenderElement.js";
+import { CLICK_TRIGGER_IDENTIFIER as $ } from "../../utils/constants.js";
+import { OPEN_DELAY as ee } from "../utils/constants.js";
+import { useBaseUiId as te } from "../../utils/useBaseUiId.js";
+import { FocusGuard as v } from "../../utils/FocusGuard.js";
+import { createChangeEventDetails as R } from "../../utils/createBaseUIEventDetails.js";
+import { jsxs as re, jsx as c } from "react/jsx-runtime";
+import { useTriggerDataForwarding as oe } from "../../utils/popups/popupStoreUtils.js";
+import { useHoverReferenceInteraction as ne } from "../../floating-ui-react/hooks/useHoverReferenceInteraction.js";
+import { safePolygon as se } from "../../floating-ui-react/safePolygon.js";
+import { useClick as ie } from "../../floating-ui-react/hooks/useClick.js";
+import { useInteractions as ae } from "../../floating-ui-react/hooks/useInteractions.js";
+import { getTabbableBeforeElement as ce, isOutsideEvent as pe, getTabbableAfterElement as ue, getNextTabbable as le } from "../../floating-ui-react/utils/tabbable.js";
+import { triggerPress as E, focusOut as P } from "../../utils/reason-parts.js";
+import { contains as ge } from "../../floating-ui-react/utils/element.js";
+const fe = /* @__PURE__ */ o.forwardRef(function(l, F) {
+  const {
+    render: de,
+    className: be,
+    disabled: p = !1,
+    nativeButton: O = !0,
+    handle: x,
+    payload: y,
+    openOnHover: g = !1,
+    delay: C = ee,
+    closeDelay: f = 0,
+    id: I,
+    ...S
+  } = l, M = J(!0), e = x?.store ?? M?.store;
+  if (!e)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Popover.Trigger> must be either used within a <Popover.Root> component or provided with a handle." : z(74));
+  const n = te(I), m = e.useState("isTriggerActive", n), s = e.useState("floatingRootContext"), B = e.useState("isOpenedByTrigger", n), i = o.useRef(null), {
+    registerTrigger: N,
+    isMountedByThisTrigger: D
+  } = oe(n, i, e, {
+    payload: y,
+    disabled: p,
+    openOnHover: g,
+    closeDelay: f
+  }), u = e.useState("openChangeReason"), w = e.useState("stickIfOpen"), k = e.useState("openMethod"), A = ne(s, {
+    enabled: s != null && g && (k !== "touch" || u !== E),
+    mouseOnly: !0,
+    move: !1,
+    handleClose: se(),
+    restMs: C,
+    delay: {
+      close: f
+    },
+    triggerElementRef: i,
+    isActiveTrigger: m
+  }), G = ie(s, {
+    enabled: s != null,
+    stickIfOpen: w
+  }), _ = ae([G]), j = e.useState("triggerProps", D), H = {
+    disabled: p,
+    open: B
+  }, {
+    getButtonProps: L,
+    buttonRef: U
+  } = Q({
+    disabled: p,
+    native: O
+  }), V = o.useMemo(() => ({
+    open(t) {
+      return t && u === E ? W.open(t) : X.open(t);
+    }
+  }), [u]), d = Z("button", l, {
+    state: H,
+    ref: [U, F, N, i],
+    props: [_.getReferenceProps(), A, j, {
+      [$]: "",
+      id: n
+    }, S, L],
+    stateAttributesMapping: V
+  }), b = o.useRef(null), K = h((t) => {
+    T.flushSync(() => {
+      e.setOpen(!1, R(P, t.nativeEvent, t.currentTarget));
+    }), ce(b.current)?.focus();
+  }), Y = h((t) => {
+    const a = e.select("positionerElement");
+    if (a && pe(t, a))
+      e.context.beforeContentFocusGuardRef.current?.focus();
+    else {
+      T.flushSync(() => {
+        e.setOpen(!1, R(P, t.nativeEvent, t.currentTarget));
+      });
+      let r = ue(e.context.triggerFocusTargetRef.current || i.current);
+      for (; r !== null && ge(a, r); ) {
+        const q = r;
+        if (r = le(r), r === q)
+          break;
+      }
+      r?.focus();
+    }
+  });
+  return m ? /* @__PURE__ */ re(o.Fragment, {
+    children: [/* @__PURE__ */ c(v, {
+      ref: b,
+      onFocus: K
+    }), /* @__PURE__ */ c(o.Fragment, {
+      children: d
+    }, n), /* @__PURE__ */ c(v, {
+      ref: e.context.triggerFocusTargetRef,
+      onFocus: Y
+    })]
+  }) : /* @__PURE__ */ c(o.Fragment, {
+    children: d
+  }, n);
+});
+process.env.NODE_ENV !== "production" && (fe.displayName = "PopoverTrigger");
+export {
+  fe as PopoverTrigger
+};

package/dist/node_modules/@base-ui/react/esm/popover/utils/constants.js

@@ -0,0 +1,4 @@
+const o = 300;
+export {
+  o as OPEN_DELAY
+};

package/dist/node_modules/@base-ui/react/esm/toolbar/root/ToolbarRootContext.js

@@ -0,0 +1,10 @@
+import * as o from "react";
+const t = /* @__PURE__ */ o.createContext(void 0);
+process.env.NODE_ENV !== "production" && (t.displayName = "ToolbarRootContext");
+function r(e) {
+  return o.useContext(t);
+}
+export {
+  t as ToolbarRootContext,
+  r as useToolbarRootContext
+};

package/dist/node_modules/@base-ui/react/esm/use-button/useButton.js

@@ -0,0 +1,113 @@
+import * as l from "react";
+import { isHTMLElement as M } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useStableCallback as H } from "../../../utils/esm/useStableCallback.js";
+import { error as y } from "../../../utils/esm/error.js";
+import { SafeReact as B } from "../../../utils/esm/safeReact.js";
+import { useIsoLayoutEffect as A } from "../../../utils/esm/useIsoLayoutEffect.js";
+import { useCompositeRootContext as L } from "../composite/root/CompositeRootContext.js";
+import { useFocusableWhenDisabled as W } from "../utils/useFocusableWhenDisabled.js";
+import { mergeProps as $, makeEventPreventable as x } from "../merge-props/mergeProps.js";
+function Y(a = {}) {
+  const {
+    disabled: o = !1,
+    focusableWhenDisabled: C,
+    tabIndex: P = 0,
+    native: t = !0,
+    composite: T
+  } = a, i = l.useRef(null), E = L(!0), s = T ?? E !== void 0, {
+    props: u
+  } = W({
+    focusableWhenDisabled: C,
+    disabled: o,
+    composite: s,
+    tabIndex: P,
+    isNativeButton: t
+  });
+  process.env.NODE_ENV !== "production" && l.useEffect(() => {
+    if (!i.current)
+      return;
+    const n = f(i.current);
+    if (t) {
+      if (!n) {
+        const r = B.captureOwnerStack?.() || "";
+        y(`A component that acts as a button expected a native <button> because the \`nativeButton\` prop is true. Rendering a non-<button> removes native button semantics, which can impact forms and accessibility. Use a real <button> in the \`render\` prop, or set \`nativeButton\` to \`false\`.${r}`);
+      }
+    } else if (n) {
+      const r = B.captureOwnerStack?.() || "";
+      y(`A component that acts as a button expected a non-<button> because the \`nativeButton\` prop is false. Rendering a <button> keeps native behavior while Base UI applies non-native attributes and handlers, which can add unintended extra attributes (such as \`role\` or \`aria-disabled\`). Use a non-<button> in the \`render\` prop, or set \`nativeButton\` to \`true\`.${r}`);
+    }
+  }, [t]);
+  const p = l.useCallback(() => {
+    const n = i.current;
+    f(n) && s && o && u.disabled === void 0 && n.disabled && (n.disabled = !1);
+  }, [o, u.disabled, s]);
+  A(p, [p]);
+  const U = l.useCallback((n = {}) => {
+    const {
+      onClick: r,
+      onMouseDown: d,
+      onKeyUp: O,
+      onKeyDown: I,
+      onPointerDown: K,
+      ...N
+    } = n;
+    return $({
+      type: t ? "button" : void 0,
+      onClick(e) {
+        if (o) {
+          e.preventDefault();
+          return;
+        }
+        r?.(e);
+      },
+      onMouseDown(e) {
+        o || d?.(e);
+      },
+      onKeyDown(e) {
+        if (o || (x(e), I?.(e), e.baseUIHandlerPrevented))
+          return;
+        const b = e.target === e.currentTarget, c = e.currentTarget, g = f(c), h = !t && V(c), k = b && (t ? g : !h), D = e.key === "Enter", w = e.key === " ", m = c.getAttribute("role"), S = m?.startsWith("menuitem") || m === "option" || m === "gridcell";
+        if (b && s && w) {
+          if (e.defaultPrevented && S)
+            return;
+          e.preventDefault(), h || t && g ? (c.click(), e.preventBaseUIHandler()) : k && (r?.(e), e.preventBaseUIHandler());
+          return;
+        }
+        k && (!t && (w || D) && e.preventDefault(), !t && D && r?.(e));
+      },
+      onKeyUp(e) {
+        if (!o) {
+          if (x(e), O?.(e), e.target === e.currentTarget && t && s && f(e.currentTarget) && e.key === " ") {
+            e.preventDefault();
+            return;
+          }
+          e.baseUIHandlerPrevented || e.target === e.currentTarget && !t && !s && e.key === " " && r?.(e);
+        }
+      },
+      onPointerDown(e) {
+        if (o) {
+          e.preventDefault();
+          return;
+        }
+        K?.(e);
+      }
+    }, t ? void 0 : {
+      role: "button"
+    }, u, N);
+  }, [o, u, s, t]), R = H((n) => {
+    i.current = n, p();
+  });
+  return {
+    getButtonProps: U,
+    buttonRef: R
+  };
+}
+function f(a) {
+  return M(a) && a.tagName === "BUTTON";
+}
+function V(a) {
+  return !!(a?.tagName === "A" && a?.href);
+}
+export {
+  Y as useButton
+};

package/dist/node_modules/@base-ui/react/esm/utils/FocusGuard.js

@@ -0,0 +1,26 @@
+import * as r from "react";
+import { useIsoLayoutEffect as a } from "../../../utils/esm/useIsoLayoutEffect.js";
+import { isSafari as u } from "../../../utils/esm/detectBrowser.js";
+import { visuallyHidden as i } from "../../../utils/esm/visuallyHidden.js";
+import { jsx as f } from "react/jsx-runtime";
+const d = /* @__PURE__ */ r.forwardRef(function(t, e) {
+  const [o, s] = r.useState();
+  return a(() => {
+    u && s("button");
+  }, []), /* @__PURE__ */ f("span", {
+    ...t,
+    ref: e,
+    style: i,
+    "aria-hidden": o ? void 0 : !0,
+    ...{
+      tabIndex: 0,
+      // Role is only for VoiceOver
+      role: o
+    },
+    "data-base-ui-focus-guard": ""
+  });
+});
+process.env.NODE_ENV !== "production" && (d.displayName = "FocusGuard");
+export {
+  d as FocusGuard
+};

package/dist/node_modules/@base-ui/react/esm/utils/InternalBackdrop.js

@@ -0,0 +1,41 @@
+import * as i from "react";
+import { jsx as a } from "react/jsx-runtime";
+const c = /* @__PURE__ */ i.forwardRef(function(r, n) {
+  const {
+    cutout: e,
+    ...p
+  } = r;
+  let o;
+  if (e) {
+    const t = e?.getBoundingClientRect();
+    o = `polygon(
+      0% 0%,
+      100% 0%,
+      100% 100%,
+      0% 100%,
+      0% 0%,
+      ${t.left}px ${t.top}px,
+      ${t.left}px ${t.bottom}px,
+      ${t.right}px ${t.bottom}px,
+      ${t.right}px ${t.top}px,
+      ${t.left}px ${t.top}px
+    )`;
+  }
+  return /* @__PURE__ */ a("div", {
+    ref: n,
+    role: "presentation",
+    "data-base-ui-inert": "",
+    ...p,
+    style: {
+      position: "fixed",
+      inset: 0,
+      userSelect: "none",
+      WebkitUserSelect: "none",
+      clipPath: o
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (c.displayName = "InternalBackdrop");
+export {
+  c as InternalBackdrop
+};

package/dist/node_modules/@base-ui/react/esm/utils/adaptiveOriginMiddleware.js

@@ -0,0 +1,63 @@
+import { ownerDocument as D } from "../../../utils/esm/owner.js";
+import { getSide as v } from "../../../../@floating-ui/utils/dist/floating-ui.utils.js";
+import { getWindow as x } from "../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+const d = {
+  sideX: "left",
+  sideY: "top"
+}, O = {
+  name: "adaptiveOrigin",
+  async fn(g) {
+    const {
+      x: o,
+      y: s,
+      rects: {
+        floating: f
+      },
+      elements: {
+        floating: i
+      },
+      platform: a,
+      strategy: w,
+      placement: p
+    } = g, t = x(i), l = t.getComputedStyle(i);
+    if (!(l.transitionDuration !== "0s" && l.transitionDuration !== ""))
+      return {
+        x: o,
+        y: s,
+        data: d
+      };
+    const r = await a.getOffsetParent?.(i);
+    let e = {
+      width: 0,
+      height: 0
+    };
+    if (w === "fixed" && t?.visualViewport)
+      e = {
+        width: t.visualViewport.width,
+        height: t.visualViewport.height
+      };
+    else if (r === t) {
+      const m = D(i);
+      e = {
+        width: m.documentElement.clientWidth,
+        height: m.documentElement.clientHeight
+      };
+    } else await a.isElement?.(r) && (e = await a.getDimensions(r));
+    const n = v(p);
+    let h = o, c = s;
+    n === "left" && (h = e.width - (o + f.width)), n === "top" && (c = e.height - (s + f.height));
+    const u = n === "left" ? "right" : d.sideX, y = n === "top" ? "bottom" : d.sideY;
+    return {
+      x: h,
+      y: c,
+      data: {
+        sideX: u,
+        sideY: y
+      }
+    };
+  }
+};
+export {
+  d as DEFAULT_SIDES,
+  O as adaptiveOrigin
+};

package/dist/node_modules/@base-ui/react/esm/utils/closePart.js

@@ -0,0 +1,30 @@
+import * as n from "react";
+import { useStableCallback as a } from "../../../utils/esm/useStableCallback.js";
+import { jsx as c } from "react/jsx-runtime";
+const s = /* @__PURE__ */ n.createContext(void 0);
+process.env.NODE_ENV !== "production" && (s.displayName = "ClosePartContext");
+function C() {
+  const [o, t] = n.useState(0), e = a(() => (t((r) => r + 1), () => {
+    t((r) => Math.max(0, r - 1));
+  }));
+  return {
+    context: n.useMemo(() => ({
+      register: e
+    }), [e]),
+    hasClosePart: o > 0
+  };
+}
+function m(o) {
+  const {
+    value: t,
+    children: e
+  } = o;
+  return /* @__PURE__ */ c(s.Provider, {
+    value: t,
+    children: e
+  });
+}
+export {
+  m as ClosePartProvider,
+  C as useClosePartCount
+};

package/dist/node_modules/@base-ui/react/esm/utils/constants.js

@@ -0,0 +1,19 @@
+const t = 500, i = {
+  style: {
+    transition: "none"
+  }
+}, n = "data-base-ui-click-trigger", I = {
+  fallbackAxisSide: "end"
+}, e = {
+  clipPath: "inset(50%)",
+  position: "fixed",
+  top: 0,
+  left: 0
+};
+export {
+  n as CLICK_TRIGGER_IDENTIFIER,
+  i as DISABLED_TRANSITIONS_STYLE,
+  t as PATIENT_CLICK_THRESHOLD,
+  I as POPUP_COLLISION_AVOIDANCE,
+  e as ownerVisuallyHidden
+};

package/dist/node_modules/@base-ui/react/esm/utils/createBaseUIEventDetails.js

@@ -0,0 +1,26 @@
+import { EMPTY_OBJECT as l } from "../../../utils/esm/empty.js";
+function u(a, n, o, s) {
+  let e = !1, t = !1;
+  const r = l;
+  return {
+    reason: a,
+    event: n ?? new Event("base-ui"),
+    cancel() {
+      e = !0;
+    },
+    allowPropagation() {
+      t = !0;
+    },
+    get isCanceled() {
+      return e;
+    },
+    get isPropagationAllowed() {
+      return t;
+    },
+    trigger: o,
+    ...r
+  };
+}
+export {
+  u as createChangeEventDetails
+};

package/dist/node_modules/@base-ui/react/esm/utils/getDisabledMountTransitionStyles.js

@@ -0,0 +1,8 @@
+import { DISABLED_TRANSITIONS_STYLE as r } from "./constants.js";
+import { EMPTY_OBJECT as o } from "../../../utils/esm/empty.js";
+function T(t) {
+  return t === "starting" ? r : o;
+}
+export {
+  T as getDisabledMountTransitionStyles
+};

package/dist/node_modules/@base-ui/react/esm/utils/getStateAttributesProps.js

@@ -0,0 +1,16 @@
+function i(r, n) {
+  const o = {};
+  for (const t in r) {
+    const e = r[t];
+    if (n?.hasOwnProperty(t)) {
+      const s = n[t](e);
+      s != null && Object.assign(o, s);
+      continue;
+    }
+    e === !0 ? o[`data-${t.toLowerCase()}`] = "" : e && (o[`data-${t.toLowerCase()}`] = e.toString());
+  }
+  return o;
+}
+export {
+  i as getStateAttributesProps
+};

package/dist/node_modules/@base-ui/react/esm/utils/hideMiddleware.js

@@ -0,0 +1,20 @@
+import { hide as a } from "../../../../@floating-ui/react-dom/dist/floating-ui.react-dom.js";
+const o = {
+  name: "hide",
+  async fn(e) {
+    const {
+      width: n,
+      height: d,
+      x: i,
+      y: t
+    } = e.rects.reference, r = n === 0 && d === 0 && i === 0 && t === 0;
+    return {
+      data: {
+        referenceHidden: (await a().fn(e)).data?.referenceHidden || r
+      }
+    };
+  }
+};
+export {
+  o as hide
+};

package/dist/node_modules/@base-ui/react/esm/utils/popupStateMapping.js

@@ -0,0 +1,40 @@
+import { TransitionStatusDataAttributes as d } from "./stateAttributesMapping.js";
+let r = (function(n) {
+  return n.open = "data-open", n.closed = "data-closed", n[n.startingStyle = d.startingStyle] = "startingStyle", n[n.endingStyle = d.endingStyle] = "endingStyle", n.anchorHidden = "data-anchor-hidden", n.side = "data-side", n.align = "data-align", n;
+})({}), e = /* @__PURE__ */ (function(n) {
+  return n.popupOpen = "data-popup-open", n.pressed = "data-pressed", n;
+})({});
+const p = {
+  [e.popupOpen]: ""
+}, t = {
+  [e.popupOpen]: "",
+  [e.pressed]: ""
+}, l = {
+  [r.open]: ""
+}, O = {
+  [r.closed]: ""
+}, i = {
+  [r.anchorHidden]: ""
+}, c = {
+  open(n) {
+    return n ? p : null;
+  }
+}, a = {
+  open(n) {
+    return n ? t : null;
+  }
+}, g = {
+  open(n) {
+    return n ? l : O;
+  },
+  anchorHidden(n) {
+    return n ? i : null;
+  }
+};
+export {
+  r as CommonPopupDataAttributes,
+  e as CommonTriggerDataAttributes,
+  g as popupStateMapping,
+  a as pressableTriggerOpenStateMapping,
+  c as triggerOpenStateMapping
+};