feat(normalize-wheel): publish esm unbundled

.gitignore

@@ -0,0 +1 @@
+node_modules

lib/esm/src/ExecutionEnvironment.js

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2015, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ExecutionEnvironment
+ */
+/*jslint evil: true */
+'use strict';
+var canUseDOM = !!(typeof window !== 'undefined' &&
+    window.document &&
+    window.document.createElement);
+/**
+ * Simple, lightweight module assisting with the detection and context of
+ * Worker. Helps avoid circular dependencies and allows code to reason about
+ * whether or not they are in a Worker, even if they never include the main
+ * `ReactWorker` dependency.
+ */
+var ExecutionEnvironment = {
+    canUseDOM: canUseDOM,
+    canUseWorkers: typeof Worker !== 'undefined',
+    canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
+    canUseViewport: canUseDOM && !!window.screen,
+    isInWorker: !canUseDOM // For now, this is true - might change in the future.
+};
+export default ExecutionEnvironment;

lib/esm/src/UserAgent_DEPRECATED.js

@@ -0,0 +1,245 @@
+/**
+ * Copyright 2004-present Facebook. All Rights Reserved.
+ *
+ * @providesModule UserAgent_DEPRECATED
+ */
+/**
+ *  Provides entirely client-side User Agent and OS detection. You should prefer
+ *  the non-deprecated UserAgent module when possible, which exposes our
+ *  authoritative server-side PHP-based detection to the client.
+ *
+ *  Usage is straightforward:
+ *
+ *    if (UserAgent_DEPRECATED.ie()) {
+ *      //  IE
+ *    }
+ *
+ *  You can also do version checks:
+ *
+ *    if (UserAgent_DEPRECATED.ie() >= 7) {
+ *      //  IE7 or better
+ *    }
+ *
+ *  The browser functions will return NaN if the browser does not match, so
+ *  you can also do version compares the other way:
+ *
+ *    if (UserAgent_DEPRECATED.ie() < 7) {
+ *      //  IE6 or worse
+ *    }
+ *
+ *  Note that the version is a float and may include a minor version number,
+ *  so you should always use range operators to perform comparisons, not
+ *  strict equality.
+ *
+ *  **Note:** You should **strongly** prefer capability detection to browser
+ *  version detection where it's reasonable:
+ *
+ *    http://www.quirksmode.org/js/support.html
+ *
+ *  Further, we have a large number of mature wrapper functions and classes
+ *  which abstract away many browser irregularities. Check the documentation,
+ *  grep for things, or ask on [email protected] before writing yet
+ *  another copy of "event || window.event".
+ *
+ */
+var _populated = false;
+// Browsers
+var _ie, _firefox, _opera, _webkit, _chrome;
+// Actual IE browser for compatibility mode
+var _ie_real_version;
+// Platforms
+var _osx, _windows, _linux, _android;
+// Architectures
+var _win64;
+// Devices
+var _iphone, _ipad, _native;
+var _mobile;
+function _populate() {
+    if (_populated) {
+        return;
+    }
+    _populated = true;
+    // To work around buggy JS libraries that can't handle multi-digit
+    // version numbers, Opera 10's user agent string claims it's Opera
+    // 9, then later includes a Version/X.Y field:
+    //
+    // Opera/9.80 (foo) Presto/2.2.15 Version/10.10
+    var uas = navigator.userAgent;
+    var agent = /(?:MSIE.(\d+\.\d+))|(?:(?:Firefox|GranParadiso|Iceweasel).(\d+\.\d+))|(?:Opera(?:.+Version.|.)(\d+\.\d+))|(?:AppleWebKit.(\d+(?:\.\d+)?))|(?:Trident\/\d+\.\d+.*rv:(\d+\.\d+))/.exec(uas);
+    var os = /(Mac OS X)|(Windows)|(Linux)/.exec(uas);
+    _iphone = /\b(iPhone|iP[ao]d)/.exec(uas);
+    _ipad = /\b(iP[ao]d)/.exec(uas);
+    _android = /Android/i.exec(uas);
+    _native = /FBAN\/\w+;/i.exec(uas);
+    _mobile = /Mobile/i.exec(uas);
+    // Note that the IE team blog would have you believe you should be checking
+    // for 'Win64; x64'.  But MSDN then reveals that you can actually be coming
+    // from either x64 or ia64;  so ultimately, you should just check for Win64
+    // as in indicator of whether you're in 64-bit IE.  32-bit IE on 64-bit
+    // Windows will send 'WOW64' instead.
+    _win64 = !!(/Win64/.exec(uas));
+    if (agent) {
+        _ie = agent[1] ? parseFloat(agent[1]) : (agent[5] ? parseFloat(agent[5]) : NaN);
+        // IE compatibility mode
+        if (_ie && document && document.documentMode) {
+            _ie = document.documentMode;
+        }
+        // grab the "true" ie version from the trident token if available
+        var trident = /(?:Trident\/(\d+.\d+))/.exec(uas);
+        _ie_real_version = trident ? parseFloat(trident[1]) + 4 : _ie;
+        _firefox = agent[2] ? parseFloat(agent[2]) : NaN;
+        _opera = agent[3] ? parseFloat(agent[3]) : NaN;
+        _webkit = agent[4] ? parseFloat(agent[4]) : NaN;
+        if (_webkit) {
+            // We do not add the regexp to the above test, because it will always
+            // match 'safari' only since 'AppleWebKit' appears before 'Chrome' in
+            // the userAgent string.
+            agent = /(?:Chrome\/(\d+\.\d+))/.exec(uas);
+            _chrome = agent && agent[1] ? parseFloat(agent[1]) : NaN;
+        }
+        else {
+            _chrome = NaN;
+        }
+    }
+    else {
+        _ie = _firefox = _opera = _chrome = _webkit = NaN;
+    }
+    if (os) {
+        if (os[1]) {
+            // Detect OS X version.  If no version number matches, set _osx to true.
+            // Version examples:  10, 10_6_1, 10.7
+            // Parses version number as a float, taking only first two sets of
+            // digits.  If only one set of digits is found, returns just the major
+            // version number.
+            var ver = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(uas);
+            _osx = ver ? parseFloat(ver[1].replace('_', '.')) : true;
+        }
+        else {
+            _osx = false;
+        }
+        _windows = !!os[2];
+        _linux = !!os[3];
+    }
+    else {
+        _osx = _windows = _linux = false;
+    }
+}
+var UserAgent_DEPRECATED = {
+    /**
+     *  Check if the UA is Internet Explorer.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    ie: function () {
+        return _populate() || _ie;
+    },
+    /**
+     * Check if we're in Internet Explorer compatibility mode.
+     *
+     * @return bool true if in compatibility mode, false if
+     * not compatibility mode or not ie
+     */
+    ieCompatibilityMode: function () {
+        return _populate() || (_ie_real_version > _ie);
+    },
+    /**
+     * Whether the browser is 64-bit IE.  Really, this is kind of weak sauce;  we
+     * only need this because Skype can't handle 64-bit IE yet.  We need to remove
+     * this when we don't need it -- tracked by #601957.
+     */
+    ie64: function () {
+        return UserAgent_DEPRECATED.ie() && _win64;
+    },
+    /**
+     *  Check if the UA is Firefox.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    firefox: function () {
+        return _populate() || _firefox;
+    },
+    /**
+     *  Check if the UA is Opera.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    opera: function () {
+        return _populate() || _opera;
+    },
+    /**
+     *  Check if the UA is WebKit.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    webkit: function () {
+        return _populate() || _webkit;
+    },
+    /**
+     *  For Push
+     *  WILL BE REMOVED VERY SOON. Use UserAgent_DEPRECATED.webkit
+     */
+    safari: function () {
+        return UserAgent_DEPRECATED.webkit();
+    },
+    /**
+     *  Check if the UA is a Chrome browser.
+     *
+     *
+     *  @return float|NaN Version number (if match) or NaN.
+     */
+    chrome: function () {
+        return _populate() || _chrome;
+    },
+    /**
+     *  Check if the user is running Windows.
+     *
+     *  @return bool `true' if the user's OS is Windows.
+     */
+    windows: function () {
+        return _populate() || _windows;
+    },
+    /**
+     *  Check if the user is running Mac OS X.
+     *
+     *  @return float|bool   Returns a float if a version number is detected,
+     *                       otherwise true/false.
+     */
+    osx: function () {
+        return _populate() || _osx;
+    },
+    /**
+     * Check if the user is running Linux.
+     *
+     * @return bool `true' if the user's OS is some flavor of Linux.
+     */
+    linux: function () {
+        return _populate() || _linux;
+    },
+    /**
+     * Check if the user is running on an iPhone or iPod platform.
+     *
+     * @return bool `true' if the user is running some flavor of the
+     *    iPhone OS.
+     */
+    iphone: function () {
+        return _populate() || _iphone;
+    },
+    mobile: function () {
+        return _populate() || (_iphone || _ipad || _android || _mobile);
+    },
+    nativeApp: function () {
+        // webviews inside of the native apps
+        return _populate() || _native;
+    },
+    android: function () {
+        return _populate() || _android;
+    },
+    ipad: function () {
+        return _populate() || _ipad;
+    }
+};
+export default UserAgent_DEPRECATED;

lib/esm/src/isEventSupported.js

@@ -0,0 +1,54 @@
+import ExecutionEnvironment from "./ExecutionEnvironment.js";
+/**
+ * Copyright 2013-2015, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule isEventSupported
+ */
+'use strict';
+var useHasFeature;
+if (ExecutionEnvironment.canUseDOM) {
+    useHasFeature =
+        document.implementation &&
+            document.implementation.hasFeature &&
+            // always returns true in newer browsers as per the standard.
+            // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
+            document.implementation.hasFeature('', '') !== true;
+}
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @param {?boolean} capture Check if the capture phase is supported.
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+function isEventSupported(eventNameSuffix, capture) {
+    if (!ExecutionEnvironment.canUseDOM ||
+        capture && !('addEventListener' in document)) {
+        return false;
+    }
+    var eventName = 'on' + eventNameSuffix;
+    var isSupported = eventName in document;
+    if (!isSupported) {
+        var element = document.createElement('div');
+        element.setAttribute(eventName, 'return;');
+        isSupported = typeof element[eventName] === 'function';
+    }
+    if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {
+        // This is the only way to test support for the `wheel` event in IE9+.
+        isSupported = document.implementation.hasFeature('Events.wheel', '3.0');
+    }
+    return isSupported;
+}
+export default isEventSupported;