@tamagui/react-native-web-internals 1.114.4 → 1.115.0

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

@@ -0,0 +1,344 @@
+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("../index.cjs")),
+  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);
+    });
+  });
+});

package/dist/cjs/modules/createEventHandle/{index.js → index.cjs}

@@ -1,46 +1,53 @@
 "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 __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;
-};
+    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);
+  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 = () => {
-};
+var import_canUseDOM = __toESM(require("../canUseDOM.cjs"));
+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 {
-    }
+  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();
@@ -58,17 +65,14 @@ function normalizeEvent(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.");
+  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() {
+      const compatListener = e => listener(normalizeEvent(e));
+      return element.addEventListener(type, compatListener, opts), function () {
         element?.removeEventListener(type, compatListener, opts);
       };
-    } else
-      return emptyFunction;
+    } else return emptyFunction;
   };
-}
-//# sourceMappingURL=index.js.map
+}

package/dist/cjs/modules/dismissKeyboard/{index.js → index.cjs}

@@ -2,32 +2,40 @@ 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 __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;
-};
+    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);
+  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"));
+var import_TextInputState = __toESM(require("../TextInputState/index.cjs"));
 const dismissKeyboard = () => {
   import_TextInputState.default.blurTextInput(import_TextInputState.default.currentlyFocusedField());
 };
-var dismissKeyboard_default = dismissKeyboard;
-//# sourceMappingURL=index.js.map
+var dismissKeyboard_default = dismissKeyboard;

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

@@ -0,0 +1,160 @@
+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
+  };