@tamagui/react-native-web-internals 1.116.0 → 1.116.2

package/dist/cjs/modules/createEventHandle/__tests__/index-test.js

@@ -0,0 +1,242 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+));
+var import_dom_event_testing_library = require("dom-event-testing-library"), React = __toESM(require("react")), ReactDOM = __toESM(require("react-dom")), ReactDOMServer = __toESM(require("react-dom/server")), import_test_utils = require("react-dom/test-utils"), import__ = __toESM(require("..")), import_jsx_runtime = require("react/jsx-runtime");
+function createRoot(rootNode) {
+  return {
+    render(element) {
+      ReactDOM.render(element, rootNode);
+    }
+  };
+}
+describe("create-event-handle", () => {
+  let root, rootNode;
+  beforeEach(() => {
+    rootNode = document.createElement("div"), document.body.appendChild(rootNode), root = createRoot(rootNode);
+  }), afterEach(() => {
+    root.render(null), document.body.removeChild(rootNode), rootNode = null, root = null;
+  }), test("can render correctly using ReactDOMServer", () => {
+    const listener = jest.fn(), targetRef = React.createRef(), addClickListener = (0, import__.default)("click");
+    function Component() {
+      return React.useEffect(() => addClickListener(targetRef.current, listener)), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+    }
+    const output = ReactDOMServer.renderToString(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+    expect(output).toBe('<div data-reactroot=""></div>');
+  }), describe("createEventTarget()", () => {
+    test("event dispatched on target", () => {
+      const listener = jest.fn(), targetRef = React.createRef(), addClickListener = (0, import__.default)("click");
+      function Component() {
+        return React.useEffect(() => addClickListener(targetRef.current, listener)), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("event dispatched on parent", () => {
+      const listener = jest.fn(), listenerCapture = jest.fn(), targetRef = React.createRef(), parentRef = React.createRef(), addClickListener = (0, import__.default)("click"), addClickCaptureListener = (0, import__.default)("click", {
+        capture: !0
+      });
+      function Component() {
+        return React.useEffect(() => {
+          const removeClickListener = addClickListener(targetRef.current, listener), removeClickCaptureListener = addClickCaptureListener(
+            targetRef.current,
+            listenerCapture
+          );
+          return () => {
+            removeClickListener(), removeClickCaptureListener();
+          };
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: parentRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const parent = (0, import_dom_event_testing_library.createEventTarget)(parentRef.current);
+      (0, import_test_utils.act)(() => {
+        parent.click();
+      }), expect(listener).toBeCalledTimes(0), expect(listenerCapture).toBeCalledTimes(0);
+    }), test("event dispatched on child", () => {
+      const log = [], listener = jest.fn(() => {
+        log.push("bubble");
+      }), listenerCapture = jest.fn(() => {
+        log.push("capture");
+      }), targetRef = React.createRef(), childRef = React.createRef(), addClickListener = (0, import__.default)("click"), addClickCaptureListener = (0, import__.default)("click", {
+        capture: !0
+      });
+      function Component() {
+        return React.useEffect(() => {
+          const removeClickListener = addClickListener(targetRef.current, listener), removeClickCaptureListener = addClickCaptureListener(
+            targetRef.current,
+            listenerCapture
+          );
+          return () => {
+            removeClickListener(), removeClickCaptureListener();
+          };
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        child.click();
+      }), expect(listenerCapture).toBeCalledTimes(1), expect(listener).toBeCalledTimes(1), expect(log).toEqual(["capture", "bubble"]);
+    }), test("event dispatched on text node", () => {
+      const listener = jest.fn(), targetRef = React.createRef(), childRef = React.createRef(), addClickListener = (0, import__.default)("click");
+      function Component() {
+        return React.useEffect(() => addClickListener(targetRef.current, listener)), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef, children: "text" }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const text = (0, import_dom_event_testing_library.createEventTarget)(childRef.current.firstChild);
+      (0, import_test_utils.act)(() => {
+        text.click();
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("listener can be attached to document", () => {
+      const listener = jest.fn(), targetRef = React.createRef(), addClickListener = (0, import__.default)("click");
+      function Component({ target: target2 }) {
+        return React.useEffect(() => addClickListener(target2, listener)), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { target: document }));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("listener can be attached to window ", () => {
+      const listener = jest.fn(), targetRef = React.createRef(), addClickListener = (0, import__.default)("click");
+      function Component({ target: target2 }) {
+        return React.useEffect(() => addClickListener(target2, listener)), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { target: window }));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("custom event dispatched on target", () => {
+      const listener = jest.fn(), targetRef = React.createRef(), addMagicEventListener = (0, import__.default)("magic-event");
+      function Component() {
+        return React.useEffect(() => addMagicEventListener(targetRef.current, listener)), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      }), (0, import_test_utils.act)(() => {
+        const event = new CustomEvent("magic-event", { bubbles: !0 });
+        targetRef.current.dispatchEvent(event);
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("listeners can be set on multiple targets simultaneously", () => {
+      const log = [], targetRef = React.createRef(), parentRef = React.createRef(), childRef = React.createRef(), addClickListener = (0, import__.default)("click"), addClickCaptureListener = (0, import__.default)("click", {
+        capture: !0
+      }), listener = jest.fn((e) => {
+        log.push(["bubble", e.currentTarget.id]);
+      }), listenerCapture = jest.fn((e) => {
+        log.push(["capture", e.currentTarget.id]);
+      });
+      function Component() {
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, listener), addClickListener(parentRef.current, listener), addClickCaptureListener(targetRef.current, listenerCapture), addClickCaptureListener(parentRef.current, listenerCapture);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { id: "parent", ref: parentRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { id: "target", ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        child.click();
+      }), expect(listenerCapture).toBeCalledTimes(2), expect(listener).toBeCalledTimes(2), expect(log).toEqual([
+        ["capture", "parent"],
+        ["capture", "target"],
+        ["bubble", "target"],
+        ["bubble", "parent"]
+      ]);
+    }), test("listeners are specific to each event handle", () => {
+      const log = [], targetRef = React.createRef(), childRef = React.createRef(), addClickListener = (0, import__.default)("click"), addClickAltListener = (0, import__.default)("click"), addClickCaptureListener = (0, import__.default)("click", {
+        capture: !0
+      }), addClickCaptureAltListener = (0, import__.default)("click", {
+        capture: !0
+      }), listener = jest.fn((e) => {
+        log.push(["bubble", "target"]);
+      }), listenerAlt = jest.fn((e) => {
+        log.push(["bubble", "target-alt"]);
+      }), listenerCapture = jest.fn((e) => {
+        log.push(["capture", "target"]);
+      }), listenerCaptureAlt = jest.fn((e) => {
+        log.push(["capture", "target-alt"]);
+      });
+      function Component() {
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, listener), addClickAltListener(targetRef.current, listenerAlt), addClickCaptureListener(targetRef.current, listenerCapture), addClickCaptureAltListener(targetRef.current, listenerCaptureAlt);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { id: "target", ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        child.click();
+      }), expect(listenerCapture).toBeCalledTimes(1), expect(listenerCaptureAlt).toBeCalledTimes(1), expect(listener).toBeCalledTimes(1), expect(listenerAlt).toBeCalledTimes(1), expect(log).toEqual([
+        ["capture", "target"],
+        ["capture", "target-alt"],
+        ["bubble", "target"],
+        ["bubble", "target-alt"]
+      ]);
+    });
+  }), describe("stopPropagation and stopImmediatePropagation", () => {
+    test("stopPropagation works as expected", () => {
+      const childListener = jest.fn((e) => {
+        e.stopPropagation();
+      }), targetListener = jest.fn(), targetRef = React.createRef(), childRef = React.createRef(), addClickListener = (0, import__.default)("click");
+      function Component() {
+        return React.useEffect(() => {
+          addClickListener(childRef.current, childListener), addClickListener(targetRef.current, targetListener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        child.click();
+      }), expect(childListener).toBeCalledTimes(1), expect(targetListener).toBeCalledTimes(0);
+    }), test("stopImmediatePropagation works as expected", () => {
+      const firstListener = jest.fn((e) => {
+        e.stopImmediatePropagation();
+      }), secondListener = jest.fn(), targetRef = React.createRef(), addFirstClickListener = (0, import__.default)("click"), addSecondClickListener = (0, import__.default)("click");
+      function Component() {
+        return React.useEffect(() => {
+          addFirstClickListener(targetRef.current, firstListener), addSecondClickListener(targetRef.current, secondListener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(firstListener).toBeCalledTimes(1), expect(secondListener).toBeCalledTimes(0);
+    });
+  });
+});
+//# sourceMappingURL=index-test.js.map

package/dist/cjs/modules/createEventHandle/index.js

@@ -0,0 +1,74 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var createEventHandle_exports = {};
+__export(createEventHandle_exports, {
+  default: () => createEventHandle
+});
+module.exports = __toCommonJS(createEventHandle_exports);
+var import_canUseDOM = __toESM(require("../canUseDOM"));
+const emptyFunction = () => {
+};
+function supportsPassiveEvents() {
+  let supported = !1;
+  if (import_canUseDOM.default)
+    try {
+      const options = {};
+      Object.defineProperty(options, "passive", {
+        get() {
+          return supported = !0, !1;
+        }
+      }), window.addEventListener("test", null, options), window.removeEventListener("test", null, options);
+    } catch {
+    }
+  return supported;
+}
+const canUsePassiveEvents = supportsPassiveEvents();
+function getOptions(options) {
+  return options == null ? !1 : canUsePassiveEvents ? options : !!options.capture;
+}
+function isPropagationStopped() {
+  return this.cancelBubble;
+}
+function isDefaultPrevented() {
+  return this.defaultPrevented;
+}
+function normalizeEvent(event) {
+  return event.nativeEvent = event, event.persist = emptyFunction, event.isDefaultPrevented = isDefaultPrevented, event.isPropagationStopped = isPropagationStopped, event;
+}
+function createEventHandle(type, options) {
+  const opts = getOptions(options);
+  return function(target, listener) {
+    if (target == null || typeof target.addEventListener != "function")
+      throw new Error("createEventHandle: called on an invalid target.");
+    const element = target;
+    if (listener != null) {
+      const compatListener = (e) => listener(normalizeEvent(e));
+      return element.addEventListener(type, compatListener, opts), function() {
+        element?.removeEventListener(type, compatListener, opts);
+      };
+    } else
+      return emptyFunction;
+  };
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/dismissKeyboard/index.js

@@ -0,0 +1,33 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var dismissKeyboard_exports = {};
+__export(dismissKeyboard_exports, {
+  default: () => dismissKeyboard_default
+});
+module.exports = __toCommonJS(dismissKeyboard_exports);
+var import_TextInputState = __toESM(require("../TextInputState/index"));
+const dismissKeyboard = () => {
+  import_TextInputState.default.blurTextInput(import_TextInputState.default.currentlyFocusedField());
+};
+var dismissKeyboard_default = dismissKeyboard;
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/forwardedProps/index.js

@@ -0,0 +1,145 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var forwardedProps_exports = {};
+__export(forwardedProps_exports, {
+  accessibilityProps: () => accessibilityProps,
+  clickProps: () => clickProps,
+  defaultProps: () => defaultProps,
+  focusProps: () => focusProps,
+  forwardPropsListText: () => forwardPropsListText,
+  forwardPropsListView: () => forwardPropsListView,
+  forwardedProps: () => forwardedProps,
+  keyboardProps: () => keyboardProps,
+  mouseProps: () => mouseProps,
+  styleProps: () => styleProps,
+  touchProps: () => touchProps
+});
+module.exports = __toCommonJS(forwardedProps_exports);
+const defaultProps = {
+  children: !0,
+  dataSet: !0,
+  nativeID: !0,
+  ref: !0,
+  suppressHydrationWarning: !0,
+  testID: !0,
+  id: !0
+}, accessibilityProps = {
+  accessibilityActiveDescendant: !0,
+  accessibilityAtomic: !0,
+  accessibilityAutoComplete: !0,
+  accessibilityBusy: !0,
+  accessibilityChecked: !0,
+  accessibilityColumnCount: !0,
+  accessibilityColumnIndex: !0,
+  accessibilityColumnSpan: !0,
+  accessibilityControls: !0,
+  accessibilityCurrent: !0,
+  accessibilityDescribedBy: !0,
+  accessibilityDetails: !0,
+  accessibilityDisabled: !0,
+  accessibilityErrorMessage: !0,
+  accessibilityExpanded: !0,
+  accessibilityFlowTo: !0,
+  accessibilityHasPopup: !0,
+  accessibilityHidden: !0,
+  accessibilityInvalid: !0,
+  accessibilityKeyShortcuts: !0,
+  accessibilityLabel: !0,
+  accessibilityLabelledBy: !0,
+  accessibilityLevel: !0,
+  accessibilityLiveRegion: !0,
+  accessibilityModal: !0,
+  accessibilityMultiline: !0,
+  accessibilityMultiSelectable: !0,
+  accessibilityOrientation: !0,
+  accessibilityOwns: !0,
+  accessibilityPlaceholder: !0,
+  accessibilityPosInSet: !0,
+  accessibilityPressed: !0,
+  accessibilityReadOnly: !0,
+  accessibilityRequired: !0,
+  accessibilityRole: !0,
+  accessibilityRoleDescription: !0,
+  accessibilityRowCount: !0,
+  accessibilityRowIndex: !0,
+  accessibilityRowSpan: !0,
+  accessibilitySelected: !0,
+  accessibilitySetSize: !0,
+  accessibilitySort: !0,
+  accessibilityValueMax: !0,
+  accessibilityValueMin: !0,
+  accessibilityValueNow: !0,
+  accessibilityValueText: !0,
+  dir: !0,
+  focusable: !0
+}, clickProps = {
+  onClick: !0,
+  onClickCapture: !0,
+  onContextMenu: !0
+}, focusProps = {
+  onBlur: !0,
+  onFocus: !0
+}, keyboardProps = {
+  onKeyDown: !0,
+  onKeyDownCapture: !0,
+  onKeyUp: !0,
+  onKeyUpCapture: !0
+}, mouseProps = {
+  onMouseDown: !0,
+  onMouseEnter: !0,
+  onMouseLeave: !0,
+  onMouseMove: !0,
+  onMouseOver: !0,
+  onMouseOut: !0,
+  onMouseUp: !0
+}, touchProps = {
+  onTouchCancel: !0,
+  onTouchCancelCapture: !0,
+  onTouchEnd: !0,
+  onTouchEndCapture: !0,
+  onTouchMove: !0,
+  onTouchMoveCapture: !0,
+  onTouchStart: !0,
+  onTouchStartCapture: !0
+}, styleProps = {
+  classList: !0,
+  style: !0
+}, forwardedProps = {
+  defaultProps,
+  accessibilityProps,
+  clickProps,
+  focusProps,
+  keyboardProps,
+  mouseProps,
+  touchProps,
+  styleProps
+}, forwardPropsListText = {
+  ...defaultProps,
+  ...accessibilityProps,
+  ...clickProps,
+  ...focusProps,
+  ...keyboardProps,
+  ...mouseProps,
+  ...touchProps,
+  ...styleProps,
+  href: !0,
+  lang: !0,
+  pointerEvents: !0
+}, forwardPropsListView = {
+  ...forwardPropsListText,
+  onScroll: !0,
+  onWheel: !0
+};
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/getBoundingClientRect/index.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var getBoundingClientRect_exports = {};
+__export(getBoundingClientRect_exports, {
+  default: () => getBoundingClientRect_default
+});
+module.exports = __toCommonJS(getBoundingClientRect_exports);
+const getBoundingClientRect = (node) => {
+  if (node != null && node.nodeType === 1 && typeof node.getBoundingClientRect == "function")
+    return node.getBoundingClientRect();
+};
+var getBoundingClientRect_default = getBoundingClientRect;
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/invariant.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var invariant_exports = {};
+__export(invariant_exports, {
+  invariant: () => invariant,
+  warning: () => warning
+});
+module.exports = __toCommonJS(invariant_exports);
+function invariant(condition, log, ...logVars) {
+  if (!condition)
+    throw new Error(
+      process.env.NODE_ENV === "development" ? log.split("%s").flatMap((chunk, i) => [chunk, logVars[i]]).join("") : log
+    );
+}
+function warning(condition, log, ...logVars) {
+  if (process.env.NODE_ENV === "development")
+    try {
+      invariant(condition, log, ...logVars);
+    } catch (err) {
+      console.warn(err);
+    }
+}
+//# sourceMappingURL=invariant.js.map

package/dist/cjs/modules/isSelectionValid/index.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var isSelectionValid_exports = {};
+__export(isSelectionValid_exports, {
+  default: () => isSelectionValid
+});
+module.exports = __toCommonJS(isSelectionValid_exports);
+function isSelectionValid() {
+  const selection = window.getSelection();
+  if (!selection) return !1;
+  const string = selection.toString(), anchorNode = selection.anchorNode, focusNode = selection.focusNode, isTextNode = anchorNode && anchorNode.nodeType === window.Node.TEXT_NODE || focusNode && focusNode.nodeType === window.Node.TEXT_NODE;
+  return string.length >= 1 && string !== `
+` && !!isTextNode;
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/isWebColor/index.js

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var isWebColor_exports = {};
+__export(isWebColor_exports, {
+  default: () => isWebColor_default
+});
+module.exports = __toCommonJS(isWebColor_exports);
+const isWebColor = (color) => color === "currentcolor" || color === "currentColor" || color === "inherit" || color.startsWith("var(");
+var isWebColor_default = isWebColor;
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/mergeRefs/__tests__/index-test.js

@@ -0,0 +1,34 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+));
+var import_react = require("@testing-library/react"), React = __toESM(require("react")), import__ = __toESM(require("..")), import_jsx_runtime = require("react/jsx-runtime");
+describe("modules/mergeRefs", () => {
+  test("merges refs of different types", () => {
+    const ref = React.createRef(null);
+    let functionRefValue = null, hookRef;
+    function Component() {
+      const functionRef = (x) => {
+        functionRefValue = x;
+      };
+      return hookRef = React.useRef(null), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: (0, import__.default)(ref, hookRef, functionRef) });
+    }
+    (0, import_react.render)(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {})), expect(ref.current).toBeInstanceOf(HTMLDivElement), expect(hookRef.current).toBeInstanceOf(HTMLDivElement), expect(functionRefValue).toBeInstanceOf(HTMLDivElement);
+  });
+});
+//# sourceMappingURL=index-test.js.map