@hanzogui/react-native-web-internals 2.0.0-rc.41-hanzoai.5

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

@@ -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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var getBoundingClientRect_exports = {};
+__export(getBoundingClientRect_exports, {
+  getBoundingClientRect: () => getBoundingClientRect
+});
+module.exports = __toCommonJS(getBoundingClientRect_exports);
+const getBoundingClientRect = node => {
+  if (node != null) {
+    const isElement = node.nodeType === 1;
+    if (isElement && typeof node.getBoundingClientRect === "function") {
+      return node.getBoundingClientRect();
+    }
+  }
+};

package/dist/cjs/modules/invariant.cjs

@@ -0,0 +1,42 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), 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);
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var isSelectionValid_exports = {};
+__export(isSelectionValid_exports, {
+  isSelectionValid: () => isSelectionValid
+});
+module.exports = __toCommonJS(isSelectionValid_exports);
+function isSelectionValid() {
+  const selection = window.getSelection();
+  if (!selection) return false;
+  const string = selection.toString();
+  const anchorNode = selection.anchorNode;
+  const focusNode = selection.focusNode;
+  const isTextNode = anchorNode && anchorNode.nodeType === window.Node.TEXT_NODE || focusNode && focusNode.nodeType === window.Node.TEXT_NODE;
+  return string.length >= 1 && string !== "\n" && !!isTextNode;
+}

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

@@ -0,0 +1,28 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var isWebColor_exports = {};
+__export(isWebColor_exports, {
+  isWebColor: () => isWebColor
+});
+module.exports = __toCommonJS(isWebColor_exports);
+const isWebColor = color => color === "currentcolor" || color === "currentColor" || color === "inherit" || color.startsWith("var(");

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

@@ -0,0 +1,48 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}) : target, mod));
+var import_react = require("@testing-library/react");
+var React = __toESM(require("react"), 1);
+var import__ = __toESM(require("../index.cjs"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+describe("modules/mergeRefs", () => {
+  test("merges refs of different types", () => {
+    const ref = React.createRef(null);
+    let functionRefValue = null;
+    let hookRef;
+    function Component() {
+      const functionRef = x => {
+        functionRefValue = x;
+      };
+      hookRef = React.useRef(null);
+      return /* @__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);
+  });
+});

package/dist/cjs/modules/mergeRefs/index.cjs

@@ -0,0 +1,45 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var mergeRefs_exports = {};
+__export(mergeRefs_exports, {
+  mergeRefs: () => mergeRefs
+});
+module.exports = __toCommonJS(mergeRefs_exports);
+function mergeRefs(...args) {
+  return function forwardRef(node) {
+    args.forEach(ref => {
+      if (ref == null) {
+        return;
+      }
+      if (typeof ref === "function") {
+        ref(node);
+        return;
+      }
+      if (typeof ref === "object") {
+        ref.current = node;
+        return;
+      }
+      console.error(`mergeRefs cannot handle Refs of type boolean, number or string, received ref ${String(ref)}`);
+    });
+  };
+}

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

@@ -0,0 +1,59 @@
+var import_dom_event_testing_library = require("dom-event-testing-library");
+var import__ = require("../index.cjs");
+(0, import_dom_event_testing_library.describeWithPointerEvent)("modules/modality", hasPointerEvent => {
+  let rootNode;
+  beforeEach(() => {
+    (0, import_dom_event_testing_library.setPointerEvent)(hasPointerEvent);
+    rootNode = document.createElement("div");
+    document.body.appendChild(rootNode);
+  });
+  afterEach(() => {
+    document.body.removeChild(rootNode);
+    rootNode = null;
+    (0, import_dom_event_testing_library.clearPointers)();
+    (0, import__.testOnly_resetActiveModality)();
+  });
+  describe("getModality", () => {
+    (0, import_dom_event_testing_library.testWithPointerType)("reflects currently-in-use modality", pointerType => {
+      const target = (0, import_dom_event_testing_library.createEventTarget)(rootNode);
+      expect((0, import__.getModality)()).toBe("keyboard");
+      target.pointerdown({
+        pointerType
+      });
+      expect((0, import__.getModality)()).toBe(pointerType);
+      target.pointerup({
+        pointerType
+      });
+      target.keydown();
+      expect((0, import__.getModality)()).toBe("keyboard");
+      if (pointerType !== "touch") {
+        target.pointermove({
+          pointerType
+        });
+        expect((0, import__.getModality)()).toBe(pointerType);
+        target.keydown();
+        expect((0, import__.getModality)()).toBe("keyboard");
+      }
+    });
+  });
+  describe("getActiveModality", () => {
+    (0, import_dom_event_testing_library.testWithPointerType)("reflects last actively used modality", pointerType => {
+      const target = (0, import_dom_event_testing_library.createEventTarget)(rootNode);
+      expect((0, import__.getActiveModality)()).toBe("keyboard");
+      target.pointerdown({
+        pointerType
+      });
+      expect((0, import__.getActiveModality)()).toBe(pointerType);
+      target.pointerup({
+        pointerType
+      });
+      target.keydown();
+      if (pointerType !== "touch") {
+        target.pointermove({
+          pointerType
+        });
+        expect((0, import__.getActiveModality)()).toBe("keyboard");
+      }
+    });
+  });
+});

package/dist/cjs/modules/modality/index.cjs

@@ -0,0 +1,212 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var modality_exports = {};
+__export(modality_exports, {
+  addModalityListener: () => addModalityListener,
+  getActiveModality: () => getActiveModality,
+  getModality: () => getModality,
+  testOnly_resetActiveModality: () => testOnly_resetActiveModality
+});
+module.exports = __toCommonJS(modality_exports);
+var import_canUseDOM = require("../canUseDOM.cjs");
+var import_createEventHandle = require("../createEventHandle/index.cjs");
+const supportsPointerEvent = () => !!(typeof window !== "undefined" && window.PointerEvent != null);
+let activeModality = "keyboard";
+let modality = "keyboard";
+let previousModality;
+let previousActiveModality;
+let isEmulatingMouseEvents = false;
+const listeners = /* @__PURE__ */new Set();
+const KEYBOARD = "keyboard";
+const MOUSE = "mouse";
+const TOUCH = "touch";
+const BLUR = "blur";
+const CONTEXTMENU = "contextmenu";
+const FOCUS = "focus";
+const KEYDOWN = "keydown";
+const MOUSEDOWN = "mousedown";
+const MOUSEMOVE = "mousemove";
+const MOUSEUP = "mouseup";
+const POINTERDOWN = "pointerdown";
+const POINTERMOVE = "pointermove";
+const SCROLL = "scroll";
+const SELECTIONCHANGE = "selectionchange";
+const TOUCHCANCEL = "touchcancel";
+const TOUCHMOVE = "touchmove";
+const TOUCHSTART = "touchstart";
+const VISIBILITYCHANGE = "visibilitychange";
+const bubbleOptions = {
+  passive: true
+};
+const captureOptions = {
+  capture: true,
+  passive: true
+};
+const addBlurListener = (0, import_createEventHandle.createEventHandle)(BLUR, bubbleOptions);
+const addFocusListener = (0, import_createEventHandle.createEventHandle)(FOCUS, bubbleOptions);
+const addVisibilityChangeListener = (0, import_createEventHandle.createEventHandle)(VISIBILITYCHANGE, captureOptions);
+const addKeyDownListener = (0, import_createEventHandle.createEventHandle)(KEYDOWN, captureOptions);
+const addPointerDownListener = (0, import_createEventHandle.createEventHandle)(POINTERDOWN, captureOptions);
+const addPointerMoveListener = (0, import_createEventHandle.createEventHandle)(POINTERMOVE, captureOptions);
+const addContextMenuListener = (0, import_createEventHandle.createEventHandle)(CONTEXTMENU, captureOptions);
+const addMouseDownListener = (0, import_createEventHandle.createEventHandle)(MOUSEDOWN, captureOptions);
+const addMouseMoveListener = (0, import_createEventHandle.createEventHandle)(MOUSEMOVE, captureOptions);
+const addMouseUpListener = (0, import_createEventHandle.createEventHandle)(MOUSEUP, captureOptions);
+const addScrollListener = (0, import_createEventHandle.createEventHandle)(SCROLL, captureOptions);
+const addSelectiomChangeListener = (0, import_createEventHandle.createEventHandle)(SELECTIONCHANGE, captureOptions);
+const addTouchCancelListener = (0, import_createEventHandle.createEventHandle)(TOUCHCANCEL, captureOptions);
+const addTouchMoveListener = (0, import_createEventHandle.createEventHandle)(TOUCHMOVE, captureOptions);
+const addTouchStartListener = (0, import_createEventHandle.createEventHandle)(TOUCHSTART, captureOptions);
+function restoreModality() {
+  if (previousModality != null || previousActiveModality != null) {
+    if (previousModality != null) {
+      modality = previousModality;
+      previousModality = null;
+    }
+    if (previousActiveModality != null) {
+      activeModality = previousActiveModality;
+      previousActiveModality = null;
+    }
+    callListeners();
+  }
+}
+function onBlurWindow() {
+  previousModality = modality;
+  previousActiveModality = activeModality;
+  activeModality = KEYBOARD;
+  modality = KEYBOARD;
+  callListeners();
+  isEmulatingMouseEvents = false;
+}
+function onFocusWindow() {
+  restoreModality();
+}
+function onKeyDown(event) {
+  if (event.metaKey || event.altKey || event.ctrlKey) {
+    return;
+  }
+  if (modality !== KEYBOARD) {
+    modality = KEYBOARD;
+    activeModality = KEYBOARD;
+    callListeners();
+  }
+}
+function onVisibilityChange() {
+  if (document.visibilityState !== "hidden") {
+    restoreModality();
+  }
+}
+function onPointerish(event) {
+  const eventType = event.type;
+  if (supportsPointerEvent()) {
+    if (eventType === POINTERDOWN) {
+      if (activeModality !== event.pointerType) {
+        modality = event.pointerType;
+        activeModality = event.pointerType;
+        callListeners();
+      }
+      return;
+    }
+    if (eventType === POINTERMOVE) {
+      if (modality !== event.pointerType) {
+        modality = event.pointerType;
+        callListeners();
+      }
+      return;
+    }
+  } else {
+    if (!isEmulatingMouseEvents) {
+      if (eventType === MOUSEDOWN) {
+        if (activeModality !== MOUSE) {
+          modality = MOUSE;
+          activeModality = MOUSE;
+          callListeners();
+        }
+      }
+      if (eventType === MOUSEMOVE) {
+        if (modality !== MOUSE) {
+          modality = MOUSE;
+          callListeners();
+        }
+      }
+    }
+    if (eventType === TOUCHSTART) {
+      isEmulatingMouseEvents = true;
+      if (event.touches && event.touches.length > 1) {
+        isEmulatingMouseEvents = false;
+      }
+      if (activeModality !== TOUCH) {
+        modality = TOUCH;
+        activeModality = TOUCH;
+        callListeners();
+      }
+      return;
+    }
+    if (eventType === CONTEXTMENU || eventType === MOUSEUP || eventType === SELECTIONCHANGE || eventType === SCROLL || eventType === TOUCHCANCEL || eventType === TOUCHMOVE) {
+      isEmulatingMouseEvents = false;
+    }
+  }
+}
+if (import_canUseDOM.canUseDOM) {
+  addBlurListener(window, onBlurWindow);
+  addFocusListener(window, onFocusWindow);
+  addKeyDownListener(document, onKeyDown);
+  addPointerDownListener(document, onPointerish);
+  addPointerMoveListener(document, onPointerish);
+  addVisibilityChangeListener(document, onVisibilityChange);
+  addContextMenuListener(document, onPointerish);
+  addMouseDownListener(document, onPointerish);
+  addMouseMoveListener(document, onPointerish);
+  addMouseUpListener(document, onPointerish);
+  addTouchCancelListener(document, onPointerish);
+  addTouchMoveListener(document, onPointerish);
+  addTouchStartListener(document, onPointerish);
+  addSelectiomChangeListener(document, onPointerish);
+  addScrollListener(document, onPointerish);
+}
+function callListeners() {
+  const value = {
+    activeModality,
+    modality
+  };
+  listeners.forEach(listener => {
+    listener(value);
+  });
+}
+function getActiveModality() {
+  return activeModality;
+}
+function getModality() {
+  return modality;
+}
+function addModalityListener(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function testOnly_resetActiveModality() {
+  isEmulatingMouseEvents = false;
+  activeModality = KEYBOARD;
+  modality = KEYBOARD;
+}

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

@@ -0,0 +1,38 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}) : target, mod));
+var import__ = __toESM(require("../index.cjs"), 1);
+describe("modules/multiplyStyleLengthValue", () => {
+  test("number", () => {
+    expect((0, import__.default)(2, -1)).toEqual(-2);
+    expect((0, import__.default)(2, 2)).toEqual(4);
+    expect((0, import__.default)(2.5, 2)).toEqual(5);
+  });
+  test("length", () => {
+    expect((0, import__.default)("2rem", -1)).toEqual("-2rem");
+    expect((0, import__.default)("2px", 2)).toEqual("4px");
+    expect((0, import__.default)("2.5em", 2)).toEqual("5em");
+    expect((0, import__.default)("2e3px", 2)).toEqual("4000px");
+  });
+});

package/dist/cjs/modules/multiplyStyleLengthValue/index.cjs

@@ -0,0 +1,41 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var multiplyStyleLengthValue_exports = {};
+__export(multiplyStyleLengthValue_exports, {
+  multiplyStyleLengthValue: () => multiplyStyleLengthValue
+});
+module.exports = __toCommonJS(multiplyStyleLengthValue_exports);
+const CSS_UNIT_RE = /^[+-]?\d*(?:\.\d+)?(?:[Ee][+-]?\d+)?(%|\w*)/;
+const getUnit = str => str.match(CSS_UNIT_RE)[1];
+const isNumeric = n => {
+  return !isNaN(parseFloat(n)) && isFinite(n);
+};
+const multiplyStyleLengthValue = (value, multiple) => {
+  if (typeof value === "string") {
+    const number = parseFloat(value) * multiple;
+    const unit = getUnit(value);
+    return `${number}${unit}`;
+  } else if (isNumeric(value)) {
+    return value * multiple;
+  }
+};

package/dist/cjs/modules/normalizeColor/index.cjs

@@ -0,0 +1,44 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var normalizeColor_exports = {};
+__export(normalizeColor_exports, {
+  normalizeColor: () => normalizeColor
+});
+module.exports = __toCommonJS(normalizeColor_exports);
+var import_isWebColor = require("../isWebColor/index.cjs");
+var import_processColor = require("../processColor/index.cjs");
+const normalizeColor = (color, opacity = 1) => {
+  if (color == null) return;
+  if (typeof color === "string" && (0, import_isWebColor.isWebColor)(color)) {
+    return color;
+  }
+  const colorInt = (0, import_processColor.processColor)(color);
+  if (colorInt != null) {
+    const r = colorInt >> 16 & 255;
+    const g = colorInt >> 8 & 255;
+    const b = colorInt & 255;
+    const a = (colorInt >> 24 & 255) / 255;
+    const alpha = (a * opacity).toFixed(2);
+    return `rgba(${r},${g},${b},${alpha})`;
+  }
+};

package/dist/cjs/modules/pick/index.cjs

@@ -0,0 +1,38 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var pick_exports = {};
+__export(pick_exports, {
+  pick: () => pick
+});
+module.exports = __toCommonJS(pick_exports);
+function pick(obj, list) {
+  const nextObj = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      if (list[key] === true) {
+        nextObj[key] = obj[key];
+      }
+    }
+  }
+  return nextObj;
+}