@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/cjs/modules/useResponderEvents/ResponderTouchHistoryStore.js

@@ -0,0 +1,175 @@
+"use strict";
+
+exports.__esModule = true;
+exports.ResponderTouchHistoryStore = void 0;
+var _ResponderEventTypes = require("./ResponderEventTypes");
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+/**
+ * Tracks the position and time of each active touch by `touch.identifier`. We
+ * should typically only see IDs in the range of 1-20 because IDs get recycled
+ * when touches end and start again.
+ */
+
+var __DEV__ = process.env.NODE_ENV !== 'production';
+var MAX_TOUCH_BANK = 20;
+function timestampForTouch(touch) {
+  // The legacy internal implementation provides "timeStamp", which has been
+  // renamed to "timestamp".
+  return touch.timeStamp || touch.timestamp;
+}
+
+/**
+ * TODO: Instead of making gestures recompute filtered velocity, we could
+ * include a built in velocity computation that can be reused globally.
+ */
+function createTouchRecord(touch) {
+  return {
+    touchActive: true,
+    startPageX: touch.pageX,
+    startPageY: touch.pageY,
+    startTimeStamp: timestampForTouch(touch),
+    currentPageX: touch.pageX,
+    currentPageY: touch.pageY,
+    currentTimeStamp: timestampForTouch(touch),
+    previousPageX: touch.pageX,
+    previousPageY: touch.pageY,
+    previousTimeStamp: timestampForTouch(touch)
+  };
+}
+function resetTouchRecord(touchRecord, touch) {
+  touchRecord.touchActive = true;
+  touchRecord.startPageX = touch.pageX;
+  touchRecord.startPageY = touch.pageY;
+  touchRecord.startTimeStamp = timestampForTouch(touch);
+  touchRecord.currentPageX = touch.pageX;
+  touchRecord.currentPageY = touch.pageY;
+  touchRecord.currentTimeStamp = timestampForTouch(touch);
+  touchRecord.previousPageX = touch.pageX;
+  touchRecord.previousPageY = touch.pageY;
+  touchRecord.previousTimeStamp = timestampForTouch(touch);
+}
+function getTouchIdentifier(_ref) {
+  var identifier = _ref.identifier;
+  if (identifier == null) {
+    console.error('Touch object is missing identifier.');
+  }
+  if (__DEV__) {
+    if (identifier > MAX_TOUCH_BANK) {
+      console.error('Touch identifier %s is greater than maximum supported %s which causes ' + 'performance issues backfilling array locations for all of the indices.', identifier, MAX_TOUCH_BANK);
+    }
+  }
+  return identifier;
+}
+function recordTouchStart(touch, touchHistory) {
+  var identifier = getTouchIdentifier(touch);
+  var touchRecord = touchHistory.touchBank[identifier];
+  if (touchRecord) {
+    resetTouchRecord(touchRecord, touch);
+  } else {
+    touchHistory.touchBank[identifier] = createTouchRecord(touch);
+  }
+  touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+}
+function recordTouchMove(touch, touchHistory) {
+  var touchRecord = touchHistory.touchBank[getTouchIdentifier(touch)];
+  if (touchRecord) {
+    touchRecord.touchActive = true;
+    touchRecord.previousPageX = touchRecord.currentPageX;
+    touchRecord.previousPageY = touchRecord.currentPageY;
+    touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+    touchRecord.currentPageX = touch.pageX;
+    touchRecord.currentPageY = touch.pageY;
+    touchRecord.currentTimeStamp = timestampForTouch(touch);
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+  } else {
+    console.warn('Cannot record touch move without a touch start.\n', "Touch Move: " + printTouch(touch) + "\n", "Touch Bank: " + printTouchBank(touchHistory));
+  }
+}
+function recordTouchEnd(touch, touchHistory) {
+  var touchRecord = touchHistory.touchBank[getTouchIdentifier(touch)];
+  if (touchRecord) {
+    touchRecord.touchActive = false;
+    touchRecord.previousPageX = touchRecord.currentPageX;
+    touchRecord.previousPageY = touchRecord.currentPageY;
+    touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+    touchRecord.currentPageX = touch.pageX;
+    touchRecord.currentPageY = touch.pageY;
+    touchRecord.currentTimeStamp = timestampForTouch(touch);
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+  } else {
+    console.warn('Cannot record touch end without a touch start.\n', "Touch End: " + printTouch(touch) + "\n", "Touch Bank: " + printTouchBank(touchHistory));
+  }
+}
+function printTouch(touch) {
+  return JSON.stringify({
+    identifier: touch.identifier,
+    pageX: touch.pageX,
+    pageY: touch.pageY,
+    timestamp: timestampForTouch(touch)
+  });
+}
+function printTouchBank(touchHistory) {
+  var touchBank = touchHistory.touchBank;
+  var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+  if (touchBank.length > MAX_TOUCH_BANK) {
+    printed += ' (original size: ' + touchBank.length + ')';
+  }
+  return printed;
+}
+class ResponderTouchHistoryStore {
+  constructor() {
+    this._touchHistory = {
+      touchBank: [],
+      //Array<TouchRecord>
+      numberActiveTouches: 0,
+      // If there is only one active touch, we remember its location. This prevents
+      // us having to loop through all of the touches all the time in the most
+      // common case.
+      indexOfSingleActiveTouch: -1,
+      mostRecentTimeStamp: 0
+    };
+  }
+  recordTouchTrack(topLevelType, nativeEvent) {
+    var touchHistory = this._touchHistory;
+    if ((0, _ResponderEventTypes.isMoveish)(topLevelType)) {
+      nativeEvent.changedTouches.forEach(touch => recordTouchMove(touch, touchHistory));
+    } else if ((0, _ResponderEventTypes.isStartish)(topLevelType)) {
+      nativeEvent.changedTouches.forEach(touch => recordTouchStart(touch, touchHistory));
+      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      if (touchHistory.numberActiveTouches === 1) {
+        touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier;
+      }
+    } else if ((0, _ResponderEventTypes.isEndish)(topLevelType)) {
+      nativeEvent.changedTouches.forEach(touch => recordTouchEnd(touch, touchHistory));
+      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      if (touchHistory.numberActiveTouches === 1) {
+        var touchBank = touchHistory.touchBank;
+        for (var i = 0; i < touchBank.length; i++) {
+          var touchTrackToCheck = touchBank[i];
+          if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {
+            touchHistory.indexOfSingleActiveTouch = i;
+            break;
+          }
+        }
+        if (__DEV__) {
+          var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
+          if (!(activeRecord != null && activeRecord.touchActive)) {
+            console.error('Cannot find single active touch.');
+          }
+        }
+      }
+    }
+  }
+  get touchHistory() {
+    return this._touchHistory;
+  }
+}
+exports.ResponderTouchHistoryStore = ResponderTouchHistoryStore;

package/dist/cjs/modules/useResponderEvents/createResponderEvent.js

@@ -0,0 +1,152 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = createResponderEvent;
+var _getBoundingClientRect = _interopRequireDefault(require("../../modules/getBoundingClientRect"));
+/**
+ * Copyright (c) Nicolas Gallagher
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var emptyFunction = () => {};
+var emptyObject = {};
+var emptyArray = [];
+
+/**
+ * Safari produces very large identifiers that would cause the `touchBank` array
+ * length to be so large as to crash the browser, if not normalized like this.
+ * In the future the `touchBank` should use an object/map instead.
+ */
+function normalizeIdentifier(identifier) {
+  return identifier > 20 ? identifier % 20 : identifier;
+}
+
+/**
+ * Converts a native DOM event to a ResponderEvent.
+ * Mouse events are transformed into fake touch events.
+ */
+function createResponderEvent(domEvent, responderTouchHistoryStore) {
+  var rect;
+  var propagationWasStopped = false;
+  var changedTouches;
+  var touches;
+  var domEventChangedTouches = domEvent.changedTouches;
+  var domEventType = domEvent.type;
+  var metaKey = domEvent.metaKey === true;
+  var shiftKey = domEvent.shiftKey === true;
+  var force = domEventChangedTouches && domEventChangedTouches[0].force || 0;
+  var identifier = normalizeIdentifier(domEventChangedTouches && domEventChangedTouches[0].identifier || 0);
+  var clientX = domEventChangedTouches && domEventChangedTouches[0].clientX || domEvent.clientX;
+  var clientY = domEventChangedTouches && domEventChangedTouches[0].clientY || domEvent.clientY;
+  var pageX = domEventChangedTouches && domEventChangedTouches[0].pageX || domEvent.pageX;
+  var pageY = domEventChangedTouches && domEventChangedTouches[0].pageY || domEvent.pageY;
+  var preventDefault = typeof domEvent.preventDefault === 'function' ? domEvent.preventDefault.bind(domEvent) : emptyFunction;
+  var timestamp = domEvent.timeStamp;
+  function normalizeTouches(touches) {
+    return Array.prototype.slice.call(touches).map(touch => {
+      return {
+        force: touch.force,
+        identifier: normalizeIdentifier(touch.identifier),
+        get locationX() {
+          return locationX(touch.clientX);
+        },
+        get locationY() {
+          return locationY(touch.clientY);
+        },
+        pageX: touch.pageX,
+        pageY: touch.pageY,
+        target: touch.target,
+        timestamp
+      };
+    });
+  }
+  if (domEventChangedTouches != null) {
+    changedTouches = normalizeTouches(domEventChangedTouches);
+    touches = normalizeTouches(domEvent.touches);
+  } else {
+    var emulatedTouches = [{
+      force,
+      identifier,
+      get locationX() {
+        return locationX(clientX);
+      },
+      get locationY() {
+        return locationY(clientY);
+      },
+      pageX,
+      pageY,
+      target: domEvent.target,
+      timestamp
+    }];
+    changedTouches = emulatedTouches;
+    touches = domEventType === 'mouseup' || domEventType === 'dragstart' ? emptyArray : emulatedTouches;
+  }
+  var responderEvent = {
+    bubbles: true,
+    cancelable: true,
+    // `currentTarget` is set before dispatch
+    currentTarget: null,
+    defaultPrevented: domEvent.defaultPrevented,
+    dispatchConfig: emptyObject,
+    eventPhase: domEvent.eventPhase,
+    isDefaultPrevented() {
+      return domEvent.defaultPrevented;
+    },
+    isPropagationStopped() {
+      return propagationWasStopped;
+    },
+    isTrusted: domEvent.isTrusted,
+    nativeEvent: {
+      altKey: false,
+      ctrlKey: false,
+      metaKey,
+      shiftKey,
+      changedTouches,
+      force,
+      identifier,
+      get locationX() {
+        return locationX(clientX);
+      },
+      get locationY() {
+        return locationY(clientY);
+      },
+      pageX,
+      pageY,
+      target: domEvent.target,
+      timestamp,
+      touches,
+      type: domEventType
+    },
+    persist: emptyFunction,
+    preventDefault,
+    stopPropagation() {
+      propagationWasStopped = true;
+    },
+    target: domEvent.target,
+    timeStamp: timestamp,
+    touchHistory: responderTouchHistoryStore.touchHistory
+  };
+
+  // Using getters and functions serves two purposes:
+  // 1) The value of `currentTarget` is not initially available.
+  // 2) Measuring the clientRect may cause layout jank and should only be done on-demand.
+  function locationX(x) {
+    rect = rect || (0, _getBoundingClientRect.default)(responderEvent.currentTarget);
+    if (rect) {
+      return x - rect.left;
+    }
+  }
+  function locationY(y) {
+    rect = rect || (0, _getBoundingClientRect.default)(responderEvent.currentTarget);
+    if (rect) {
+      return y - rect.top;
+    }
+  }
+  return responderEvent;
+}
+module.exports = exports.default;

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

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = useResponderEvents;
+var React = _interopRequireWildcard(require("react"));
+var ResponderSystem = _interopRequireWildcard(require("./ResponderSystem"));
+/**
+ * Copyright (c) Nicolas Gallagher
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+/**
+ * Hook for integrating the Responder System into React
+ *
+ *   function SomeComponent({ onStartShouldSetResponder }) {
+ *     const ref = useRef(null);
+ *     useResponderEvents(ref, { onStartShouldSetResponder });
+ *     return <div ref={ref} />
+ *   }
+ */
+
+var emptyObject = {};
+var idCounter = 0;
+function useStable(getInitialValue) {
+  var ref = React.useRef(null);
+  if (ref.current == null) {
+    ref.current = getInitialValue();
+  }
+  return ref.current;
+}
+function useResponderEvents(hostRef, config) {
+  if (config === void 0) {
+    config = emptyObject;
+  }
+  var id = useStable(() => idCounter++);
+  var isAttachedRef = React.useRef(false);
+
+  // This is a separate effects so it doesn't run when the config changes.
+  // On initial mount, attach global listeners if needed.
+  // On unmount, remove node potentially attached to the Responder System.
+  React.useEffect(() => {
+    ResponderSystem.attachListeners();
+    return () => {
+      ResponderSystem.removeNode(id);
+    };
+  }, [id]);
+
+  // Register and unregister with the Responder System as necessary
+  React.useEffect(() => {
+    var _config = config,
+      onMoveShouldSetResponder = _config.onMoveShouldSetResponder,
+      onMoveShouldSetResponderCapture = _config.onMoveShouldSetResponderCapture,
+      onScrollShouldSetResponder = _config.onScrollShouldSetResponder,
+      onScrollShouldSetResponderCapture = _config.onScrollShouldSetResponderCapture,
+      onSelectionChangeShouldSetResponder = _config.onSelectionChangeShouldSetResponder,
+      onSelectionChangeShouldSetResponderCapture = _config.onSelectionChangeShouldSetResponderCapture,
+      onStartShouldSetResponder = _config.onStartShouldSetResponder,
+      onStartShouldSetResponderCapture = _config.onStartShouldSetResponderCapture;
+    var requiresResponderSystem = onMoveShouldSetResponder != null || onMoveShouldSetResponderCapture != null || onScrollShouldSetResponder != null || onScrollShouldSetResponderCapture != null || onSelectionChangeShouldSetResponder != null || onSelectionChangeShouldSetResponderCapture != null || onStartShouldSetResponder != null || onStartShouldSetResponderCapture != null;
+    var node = hostRef.current;
+    if (requiresResponderSystem) {
+      ResponderSystem.addNode(id, node, config);
+      isAttachedRef.current = true;
+    } else if (isAttachedRef.current) {
+      ResponderSystem.removeNode(id);
+      isAttachedRef.current = false;
+    }
+  }, [config, hostRef, id]);
+  React.useDebugValue({
+    isResponder: hostRef.current === ResponderSystem.getResponderNode()
+  });
+  React.useDebugValue(config);
+}
+module.exports = exports.default;

package/dist/cjs/modules/useResponderEvents/utils.js

@@ -0,0 +1,175 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.getLowestCommonAncestor = getLowestCommonAncestor;
+exports.getResponderPaths = getResponderPaths;
+exports.hasTargetTouches = hasTargetTouches;
+exports.hasValidSelection = hasValidSelection;
+exports.isPrimaryPointerDown = isPrimaryPointerDown;
+exports.setResponderId = setResponderId;
+var _isSelectionValid = _interopRequireDefault(require("../../modules/isSelectionValid"));
+/**
+ * Copyright (c) Nicolas Gallagher
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var keyName = '__reactResponderId';
+function getEventPath(domEvent) {
+  // The 'selectionchange' event always has the 'document' as the target.
+  // Use the anchor node as the initial target to reconstruct a path.
+  // (We actually only need the first "responder" node in practice.)
+  if (domEvent.type === 'selectionchange') {
+    var target = window.getSelection().anchorNode;
+    return composedPathFallback(target);
+  } else {
+    var path = domEvent.composedPath != null ? domEvent.composedPath() : composedPathFallback(domEvent.target);
+    return path;
+  }
+}
+function composedPathFallback(target) {
+  var path = [];
+  while (target != null && target !== document.body) {
+    path.push(target);
+    target = target.parentNode;
+  }
+  return path;
+}
+
+/**
+ * Retrieve the responderId from a host node
+ */
+function getResponderId(node) {
+  if (node != null) {
+    return node[keyName];
+  }
+  return null;
+}
+
+/**
+ * Store the responderId on a host node
+ */
+function setResponderId(node, id) {
+  if (node != null) {
+    node[keyName] = id;
+  }
+}
+
+/**
+ * Filter the event path to contain only the nodes attached to the responder system
+ */
+function getResponderPaths(domEvent) {
+  var idPath = [];
+  var nodePath = [];
+  var eventPath = getEventPath(domEvent);
+  for (var i = 0; i < eventPath.length; i++) {
+    var node = eventPath[i];
+    var id = getResponderId(node);
+    if (id != null) {
+      idPath.push(id);
+      nodePath.push(node);
+    }
+  }
+  return {
+    idPath,
+    nodePath
+  };
+}
+
+/**
+ * Walk the paths and find the first common ancestor
+ */
+function getLowestCommonAncestor(pathA, pathB) {
+  var pathALength = pathA.length;
+  var pathBLength = pathB.length;
+  if (
+  // If either path is empty
+  pathALength === 0 || pathBLength === 0 ||
+  // If the last elements aren't the same there can't be a common ancestor
+  // that is connected to the responder system
+  pathA[pathALength - 1] !== pathB[pathBLength - 1]) {
+    return null;
+  }
+  var itemA = pathA[0];
+  var indexA = 0;
+  var itemB = pathB[0];
+  var indexB = 0;
+
+  // If A is deeper, skip indices that can't match.
+  if (pathALength - pathBLength > 0) {
+    indexA = pathALength - pathBLength;
+    itemA = pathA[indexA];
+    pathALength = pathBLength;
+  }
+
+  // If B is deeper, skip indices that can't match
+  if (pathBLength - pathALength > 0) {
+    indexB = pathBLength - pathALength;
+    itemB = pathB[indexB];
+    pathBLength = pathALength;
+  }
+
+  // Walk in lockstep until a match is found
+  var depth = pathALength;
+  while (depth--) {
+    if (itemA === itemB) {
+      return itemA;
+    }
+    itemA = pathA[indexA++];
+    itemB = pathB[indexB++];
+  }
+  return null;
+}
+
+/**
+ * Determine whether any of the active touches are within the current responder.
+ * This cannot rely on W3C `targetTouches`, as neither IE11 nor Safari implement it.
+ */
+function hasTargetTouches(target, touches) {
+  if (!touches || touches.length === 0) {
+    return false;
+  }
+  for (var i = 0; i < touches.length; i++) {
+    var node = touches[i].target;
+    if (node != null) {
+      if (target.contains(node)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Ignore 'selectionchange' events that don't correspond with a person's intent to
+ * select text.
+ */
+function hasValidSelection(domEvent) {
+  if (domEvent.type === 'selectionchange') {
+    return (0, _isSelectionValid.default)();
+  }
+  return domEvent.type === 'select';
+}
+
+/**
+ * Events are only valid if the primary button was used without specific modifier keys.
+ */
+function isPrimaryPointerDown(domEvent) {
+  var altKey = domEvent.altKey,
+    button = domEvent.button,
+    buttons = domEvent.buttons,
+    ctrlKey = domEvent.ctrlKey,
+    type = domEvent.type;
+  var isTouch = type === 'touchstart' || type === 'touchmove';
+  var isPrimaryMouseDown = type === 'mousedown' && (button === 0 || buttons === 1);
+  var isPrimaryMouseMove = type === 'mousemove' && buttons === 1;
+  var noModifiers = altKey === false && ctrlKey === false;
+  if (isTouch || isPrimaryMouseDown && noModifiers || isPrimaryMouseMove && noModifiers) {
+    return true;
+  }
+  return false;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = useStable;
+var React = _interopRequireWildcard(require("react"));
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var UNINITIALIZED = typeof Symbol === 'function' && typeof Symbol() === 'symbol' ? Symbol() : Object.freeze({});
+function useStable(getInitialValue) {
+  var ref = React.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) {
+    ref.current = getInitialValue();
+  }
+  // $FlowFixMe (#64650789) Trouble refining types where `Symbol` is concerned.
+  return ref.current;
+}
+module.exports = exports.default;

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

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports.warnOnce = warnOnce;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var warnedKeys = {};
+
+/**
+ * A simple function that prints a warning message once per session.
+ *
+ * @param {string} key - The key used to ensure the message is printed once.
+ *                       This should be unique to the callsite.
+ * @param {string} message - The message to print
+ */
+function warnOnce(key, message) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (warnedKeys[key]) {
+      return;
+    }
+    console.warn(message);
+    warnedKeys[key] = true;
+  }
+}

package/dist/cjs/types/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/types/styles.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/vendor/hash/index.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+/* eslint-disable */
+
+/**
+ * JS Implementation of MurmurHash2
+ *
+ * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
+ * @see http://github.com/garycourt/murmurhash-js
+ * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
+ * @see http://sites.google.com/site/murmurhash/
+ *
+ * @param {string} str ASCII only
+ * @param {number} seed Positive integer only
+ * @return {number} 32-bit positive integer hash
+ *
+ * 
+ */
+
+function murmurhash2_32_gc(str, seed) {
+  var l = str.length,
+    h = seed ^ l,
+    i = 0,
+    k;
+  while (l >= 4) {
+    k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
+    k = (k & 0xffff) * 0x5bd1e995 + (((k >>> 16) * 0x5bd1e995 & 0xffff) << 16);
+    k ^= k >>> 24;
+    k = (k & 0xffff) * 0x5bd1e995 + (((k >>> 16) * 0x5bd1e995 & 0xffff) << 16);
+    h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16) ^ k;
+    l -= 4;
+    ++i;
+  }
+  switch (l) {
+    case 3:
+      h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
+    case 2:
+      h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
+    case 1:
+      h ^= str.charCodeAt(i) & 0xff;
+      h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16);
+  }
+  h ^= h >>> 13;
+  h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16);
+  h ^= h >>> 15;
+  return h >>> 0;
+}
+var hash = str => murmurhash2_32_gc(str, 1).toString(36);
+var _default = exports.default = hash;
+module.exports = exports.default;