diff --git a/Classes/GeoPoint.php b/Classes/GeoPoint.php index 76354db..8a0b134 100644 --- a/Classes/GeoPoint.php +++ b/Classes/GeoPoint.php @@ -1,34 +1,28 @@ latitude = $latitude; - $this->longitude = $longitude; } - public static function create(float $latitude, float $longitude): GeoPoint + public static function create(float $latitude, float $longitude): self { - return new static($latitude, $longitude); + return new self($latitude, $longitude); } - public static function createFromArray(array $point): GeoPoint + public static function createFromArray(array $point): self { $point = \array_values($point); - list($latitude, $longitude) = $point; - return new static($latitude, $longitude); + [$latitude, $longitude] = $point; + return new self($latitude, $longitude); } public function getLongitude(): float diff --git a/Classes/GeoPointToArrayConverter.php b/Classes/GeoPointToArrayConverter.php index 738b940..eda51d3 100644 --- a/Classes/GeoPointToArrayConverter.php +++ b/Classes/GeoPointToArrayConverter.php @@ -1,11 +1,14 @@ { + 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 __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; + }; + var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + var __decorateClass = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target; + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if (decorator = decorators[i]) + result = (kind ? decorator(target, key, result) : decorator(result)) || result; + if (kind && result) + __defProp(target, key, result); + return result; + }; + + // node_modules/@neos-project/neos-ui-extensibility/dist/manifest.js + var init_manifest = __esm({ + "node_modules/@neos-project/neos-ui-extensibility/dist/manifest.js"() { + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/createConsumerApi.js + var init_createConsumerApi = __esm({ + "node_modules/@neos-project/neos-ui-extensibility/dist/createConsumerApi.js"() { + init_manifest(); + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/readFromConsumerApi.js + function readFromConsumerApi(key) { + return (...args) => { + if (window["@Neos:HostPluginAPI"] && window["@Neos:HostPluginAPI"][`@${key}`]) { + return window["@Neos:HostPluginAPI"][`@${key}`](...args); + } + throw new Error("You are trying to read from a consumer api that hasn't been initialized yet!"); + }; + } + var init_readFromConsumerApi = __esm({ + "node_modules/@neos-project/neos-ui-extensibility/dist/readFromConsumerApi.js"() { + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/registry/AbstractRegistry.js + var init_AbstractRegistry = __esm({ + "node_modules/@neos-project/neos-ui-extensibility/dist/registry/AbstractRegistry.js"() { + } + }); + + // node_modules/@neos-project/positional-array-sorter/dist/positionalArraySorter.js + var init_positionalArraySorter = __esm({ + "node_modules/@neos-project/positional-array-sorter/dist/positionalArraySorter.js"() { + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/registry/SynchronousRegistry.js + var init_SynchronousRegistry = __esm({ + "node_modules/@neos-project/neos-ui-extensibility/dist/registry/SynchronousRegistry.js"() { + init_AbstractRegistry(); + init_positionalArraySorter(); + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/registry/SynchronousMetaRegistry.js + var init_SynchronousMetaRegistry = __esm({ + "node_modules/@neos-project/neos-ui-extensibility/dist/registry/SynchronousMetaRegistry.js"() { + init_SynchronousRegistry(); + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/registry/index.js + var init_registry = __esm({ + "node_modules/@neos-project/neos-ui-extensibility/dist/registry/index.js"() { + init_SynchronousRegistry(); + init_SynchronousMetaRegistry(); + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/index.js + var dist_default; + var init_dist = __esm({ + "node_modules/@neos-project/neos-ui-extensibility/dist/index.js"() { + init_createConsumerApi(); + init_readFromConsumerApi(); + init_registry(); + dist_default = readFromConsumerApi("manifest"); + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/shims/vendor/react/index.js + var require_react = __commonJS({ + "node_modules/@neos-project/neos-ui-extensibility/dist/shims/vendor/react/index.js"(exports, module) { + init_readFromConsumerApi(); + module.exports = readFromConsumerApi("vendor")().React; + } + }); + + // node_modules/toggle-selection/index.js + var require_toggle_selection = __commonJS({ + "node_modules/toggle-selection/index.js"(exports, module) { + module.exports = function() { + var selection = document.getSelection(); + if (!selection.rangeCount) { + return function() { + }; + } + var active = document.activeElement; + var ranges = []; + for (var i = 0; i < selection.rangeCount; i++) { + ranges.push(selection.getRangeAt(i)); + } + switch (active.tagName.toUpperCase()) { + case "INPUT": + case "TEXTAREA": + active.blur(); + break; + default: + active = null; + break; + } + selection.removeAllRanges(); + return function() { + selection.type === "Caret" && selection.removeAllRanges(); + if (!selection.rangeCount) { + ranges.forEach(function(range) { + selection.addRange(range); + }); + } + active && active.focus(); + }; + }; + } + }); + + // node_modules/copy-to-clipboard/index.js + var require_copy_to_clipboard = __commonJS({ + "node_modules/copy-to-clipboard/index.js"(exports, module) { + "use strict"; + var deselectCurrent = require_toggle_selection(); + var defaultMessage = "Copy to clipboard: #{key}, Enter"; + function format(message) { + var copyKey = (/mac os x/i.test(navigator.userAgent) ? "\u2318" : "Ctrl") + "+C"; + return message.replace(/#{\s*key\s*}/g, copyKey); + } + function copy(text, options) { + var debug, message, reselectPrevious, range, selection, mark, success = false; + if (!options) { + options = {}; + } + debug = options.debug || false; + try { + reselectPrevious = deselectCurrent(); + range = document.createRange(); + selection = document.getSelection(); + mark = document.createElement("span"); + mark.textContent = text; + mark.style.all = "unset"; + mark.style.position = "fixed"; + mark.style.top = 0; + mark.style.clip = "rect(0, 0, 0, 0)"; + mark.style.whiteSpace = "pre"; + mark.style.webkitUserSelect = "text"; + mark.style.MozUserSelect = "text"; + mark.style.msUserSelect = "text"; + mark.style.userSelect = "text"; + document.body.appendChild(mark); + range.selectNode(mark); + selection.addRange(range); + var successful = document.execCommand("copy"); + if (!successful) { + throw new Error("copy command was unsuccessful"); + } + success = true; + } catch (err) { + debug && console.error("unable to copy using execCommand: ", err); + debug && console.warn("trying IE specific stuff"); + try { + window.clipboardData.setData("text", text); + success = true; + } catch (err2) { + debug && console.error("unable to copy using clipboardData: ", err2); + debug && console.error("falling back to prompt"); + message = format("message" in options ? options.message : defaultMessage); + window.prompt(message, text); + } + } finally { + if (selection) { + if (typeof selection.removeRange == "function") { + selection.removeRange(range); + } else { + selection.removeAllRanges(); + } + } + if (mark) { + document.body.removeChild(mark); + } + reselectPrevious(); + } + return success; + } + module.exports = copy; + } + }); + + // node_modules/react-copy-to-clipboard/lib/Component.js + var require_Component = __commonJS({ + "node_modules/react-copy-to-clipboard/lib/Component.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.CopyToClipboard = void 0; + var _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + var _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + if (protoProps) + defineProperties(Constructor.prototype, protoProps); + if (staticProps) + defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + var _react = require_react(); + var _react2 = _interopRequireDefault(_react); + var _copyToClipboard = require_copy_to_clipboard(); + var _copyToClipboard2 = _interopRequireDefault(_copyToClipboard); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function _objectWithoutProperties(obj, keys) { + var target = {}; + for (var i in obj) { + if (keys.indexOf(i) >= 0) + continue; + if (!Object.prototype.hasOwnProperty.call(obj, i)) + continue; + target[i] = obj[i]; + } + return target; + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _possibleConstructorReturn(self2, call) { + if (!self2) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return call && (typeof call === "object" || typeof call === "function") ? call : self2; + } + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); + if (superClass) + Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + } + var CopyToClipboard2 = exports.CopyToClipboard = function(_React$PureComponent) { + _inherits(CopyToClipboard3, _React$PureComponent); + function CopyToClipboard3() { + var _ref; + var _temp, _this, _ret; + _classCallCheck(this, CopyToClipboard3); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = CopyToClipboard3.__proto__ || Object.getPrototypeOf(CopyToClipboard3)).call.apply(_ref, [this].concat(args))), _this), _this.onClick = function(event) { + var _this$props = _this.props, text = _this$props.text, onCopy = _this$props.onCopy, children = _this$props.children, options = _this$props.options; + var elem = _react2.default.Children.only(children); + var result = (0, _copyToClipboard2.default)(text, options); + if (onCopy) { + onCopy(text, result); + } + if (elem && elem.props && typeof elem.props.onClick === "function") { + elem.props.onClick(event); + } + }, _temp), _possibleConstructorReturn(_this, _ret); + } + _createClass(CopyToClipboard3, [{ + key: "render", + value: function render() { + var _props = this.props, _text = _props.text, _onCopy = _props.onCopy, _options = _props.options, children = _props.children, props = _objectWithoutProperties(_props, ["text", "onCopy", "options", "children"]); + var elem = _react2.default.Children.only(children); + return _react2.default.cloneElement(elem, _extends({}, props, { onClick: this.onClick })); + } + }]); + return CopyToClipboard3; + }(_react2.default.PureComponent); + CopyToClipboard2.defaultProps = { + onCopy: void 0, + options: void 0 + }; + } + }); + + // node_modules/react-copy-to-clipboard/lib/index.js + var require_lib = __commonJS({ + "node_modules/react-copy-to-clipboard/lib/index.js"(exports, module) { + "use strict"; + var _require = require_Component(); + var CopyToClipboard2 = _require.CopyToClipboard; + CopyToClipboard2.CopyToClipboard = CopyToClipboard2; + module.exports = CopyToClipboard2; + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/shims/vendor/prop-types/index.js + var require_prop_types = __commonJS({ + "node_modules/@neos-project/neos-ui-extensibility/dist/shims/vendor/prop-types/index.js"(exports, module) { + init_readFromConsumerApi(); + module.exports = readFromConsumerApi("vendor")().PropTypes; + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/shims/neosProjectPackages/neos-ui-decorators/index.js + var require_neos_ui_decorators = __commonJS({ + "node_modules/@neos-project/neos-ui-extensibility/dist/shims/neosProjectPackages/neos-ui-decorators/index.js"(exports, module) { + init_readFromConsumerApi(); + module.exports = readFromConsumerApi("NeosProjectPackages")().NeosUiDecorators; + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/shims/neosProjectPackages/react-ui-components/index.js + var require_react_ui_components = __commonJS({ + "node_modules/@neos-project/neos-ui-extensibility/dist/shims/neosProjectPackages/react-ui-components/index.js"(exports, module) { + init_readFromConsumerApi(); + module.exports = readFromConsumerApi("NeosProjectPackages")().ReactUiComponents; + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/shims/vendor/classnames/index.js + var require_classnames = __commonJS({ + "node_modules/@neos-project/neos-ui-extensibility/dist/shims/vendor/classnames/index.js"(exports, module) { + init_readFromConsumerApi(); + module.exports = readFromConsumerApi("vendor")().classnames; + } + }); + + // node_modules/geopoint/geopoint.js + var require_geopoint = __commonJS({ + "node_modules/geopoint/geopoint.js"(exports, module) { + (function() { + var toString = Object.prototype.toString, DEG2RAD = Math.PI / 180, RAD2DEG = 180 / Math.PI, MI2KM = 1.6093439999999999, KM2MI = 0.621371192237334, EARTH_RADIUS_KM = 6371.01, EARTH_RADIUS_MI = 3958.762079, MAX_LAT = Math.PI / 2, MIN_LAT = -MAX_LAT, MAX_LON = Math.PI, MIN_LON = -MAX_LON, FULL_CIRCLE_RAD = Math.PI * 2; + function isNumber(value) { + return toString.call(value) === "[object Number]" && value === +value; + } + function GeoPoint2(lat, lon, inRadians) { + if (!isNumber(lat)) { + throw new Error("Invalid latitude"); + } + if (!isNumber(lon)) { + throw new Error("Invalid longitude"); + } + if (inRadians === true) { + this._degLat = GeoPoint2.radiansToDegrees(lat); + this._degLon = GeoPoint2.radiansToDegrees(lon); + this._radLat = lat; + this._radLon = lon; + } else { + this._degLat = lat; + this._degLon = lon; + this._radLat = GeoPoint2.degreesToRadians(lat); + this._radLon = GeoPoint2.degreesToRadians(lon); + } + if (this._radLat < MIN_LAT || this._radLat > MAX_LAT) { + throw new Error("Latitude out of bounds"); + } else if (this._radLon < MIN_LON || this._radLon > MAX_LON) { + throw new Error("Longitude out of bounds"); + } + } + GeoPoint2.prototype.latitude = function(inRadians) { + if (inRadians === true) { + return this._radLat; + } + return this._degLat; + }; + GeoPoint2.prototype.longitude = function(inRadians) { + if (inRadians === true) { + return this._radLon; + } + return this._degLon; + }; + GeoPoint2.prototype.distanceTo = function(point2, inKilometers) { + if (!(point2 instanceof GeoPoint2)) { + throw new Error("Invalid GeoPoint"); + } + var radius = inKilometers === true ? EARTH_RADIUS_KM : EARTH_RADIUS_MI, lat1 = this.latitude(true), lat2 = point2.latitude(true), lon1 = this.longitude(true), lon2 = point2.longitude(true); + return Math.acos( + Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos(lon1 - lon2) + ) * radius; + }; + GeoPoint2.prototype.boundingCoordinates = function(distance, radius, inKilometers) { + if (!isNumber(distance) || distance <= 0) { + throw new Error("Invalid distance"); + } + if (radius === true || radius === false) { + inKilometers = radius; + radius = null; + } + if (!isNumber(radius) || radius <= 0) { + radius = inKilometers === true ? EARTH_RADIUS_KM : EARTH_RADIUS_MI; + } + var lat = this.latitude(true), lon = this.longitude(true), radDist = distance / radius, minLat = lat - radDist, maxLat = lat + radDist, minLon, maxLon, deltaLon; + if (minLat > MIN_LAT && maxLat < MAX_LAT) { + deltaLon = Math.asin(Math.sin(radDist) / Math.cos(lat)); + minLon = lon - deltaLon; + if (minLon < MIN_LON) { + minLon += FULL_CIRCLE_RAD; + } + maxLon = lon + deltaLon; + if (maxLon > MAX_LON) { + maxLon -= FULL_CIRCLE_RAD; + } + } else { + minLat = Math.max(minLat, MIN_LAT); + maxLat = Math.min(maxLat, MAX_LAT); + minLon = MIN_LON; + maxLon = MAX_LON; + } + return [new GeoPoint2(minLat, minLon, true), new GeoPoint2(maxLat, maxLon, true)]; + }; + GeoPoint2.degreesToRadians = function(value) { + if (!isNumber(value)) { + throw new Error("Invalid degree value"); + } + return value * DEG2RAD; + }; + GeoPoint2.radiansToDegrees = function(value) { + if (!isNumber(value)) { + throw new Error("Invalid radian value"); + } + return value * RAD2DEG; + }; + GeoPoint2.milesToKilometers = function(value) { + if (!isNumber(value)) { + throw new Error("Invalid mile value"); + } + return value * MI2KM; + }; + GeoPoint2.kilometersToMiles = function(value) { + if (!isNumber(value)) { + throw new Error("Invalid kilometer value"); + } + return value * KM2MI; + }; + if (typeof module !== "undefined" && typeof module.exports !== "undefined") { + module.exports = GeoPoint2; + } else { + this.GeoPoint = GeoPoint2; + } + }).call(exports); + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/shims/neosProjectPackages/neos-ui-i18n/index.js + var require_neos_ui_i18n = __commonJS({ + "node_modules/@neos-project/neos-ui-extensibility/dist/shims/neosProjectPackages/neos-ui-i18n/index.js"(exports, module) { + init_readFromConsumerApi(); + module.exports = readFromConsumerApi("NeosProjectPackages")().NeosUiI18n; + } + }); + + // node_modules/fbjs/lib/shallowEqual.js + var require_shallowEqual = __commonJS({ + "node_modules/fbjs/lib/shallowEqual.js"(exports, module) { + "use strict"; + var hasOwnProperty = Object.prototype.hasOwnProperty; + function is(x, y) { + if (x === y) { + return x !== 0 || y !== 0 || 1 / x === 1 / y; + } else { + return x !== x && y !== y; + } + } + function shallowEqual(objA, objB) { + if (is(objA, objB)) { + return true; + } + if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) { + return false; + } + var keysA = Object.keys(objA); + var keysB = Object.keys(objB); + if (keysA.length !== keysB.length) { + return false; + } + for (var i = 0; i < keysA.length; i++) { + if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) { + return false; + } + } + return true; + } + module.exports = shallowEqual; + } + }); + + // node_modules/hoist-non-react-statics/index.js + var require_hoist_non_react_statics = __commonJS({ + "node_modules/hoist-non-react-statics/index.js"(exports, module) { + "use strict"; + var REACT_STATICS = { + childContextTypes: true, + contextTypes: true, + defaultProps: true, + displayName: true, + getDefaultProps: true, + mixins: true, + propTypes: true, + type: true + }; + var KNOWN_STATICS = { + name: true, + length: true, + prototype: true, + caller: true, + callee: true, + arguments: true, + arity: true + }; + var defineProperty = Object.defineProperty; + var getOwnPropertyNames = Object.getOwnPropertyNames; + var getOwnPropertySymbols = Object.getOwnPropertySymbols; + var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var getPrototypeOf = Object.getPrototypeOf; + var objectPrototype = getPrototypeOf && getPrototypeOf(Object); + module.exports = function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) { + if (typeof sourceComponent !== "string") { + if (objectPrototype) { + var inheritedComponent = getPrototypeOf(sourceComponent); + if (inheritedComponent && inheritedComponent !== objectPrototype) { + hoistNonReactStatics(targetComponent, inheritedComponent, blacklist); + } + } + var keys = getOwnPropertyNames(sourceComponent); + if (getOwnPropertySymbols) { + keys = keys.concat(getOwnPropertySymbols(sourceComponent)); + } + for (var i = 0; i < keys.length; ++i) { + var key = keys[i]; + if (!REACT_STATICS[key] && !KNOWN_STATICS[key] && (!blacklist || !blacklist[key])) { + var descriptor = getOwnPropertyDescriptor(sourceComponent, key); + try { + defineProperty(targetComponent, key, descriptor); + } catch (e) { + } + } + } + return targetComponent; + } + return targetComponent; + }; + } + }); + + // node_modules/change-emitter/lib/index.js + var require_lib2 = __commonJS({ + "node_modules/change-emitter/lib/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + var createChangeEmitter = exports.createChangeEmitter = function createChangeEmitter2() { + var currentListeners = []; + var nextListeners = currentListeners; + function ensureCanMutateNextListeners() { + if (nextListeners === currentListeners) { + nextListeners = currentListeners.slice(); + } + } + function listen(listener) { + if (typeof listener !== "function") { + throw new Error("Expected listener to be a function."); + } + var isSubscribed = true; + ensureCanMutateNextListeners(); + nextListeners.push(listener); + return function() { + if (!isSubscribed) { + return; + } + isSubscribed = false; + ensureCanMutateNextListeners(); + var index = nextListeners.indexOf(listener); + nextListeners.splice(index, 1); + }; + } + function emit() { + currentListeners = nextListeners; + var listeners = currentListeners; + for (var i = 0; i < listeners.length; i++) { + listeners[i].apply(listeners, arguments); + } + } + return { + listen, + emit + }; + }; + } + }); + + // node_modules/symbol-observable/lib/ponyfill.js + var require_ponyfill = __commonJS({ + "node_modules/symbol-observable/lib/ponyfill.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports["default"] = symbolObservablePonyfill; + function symbolObservablePonyfill(root) { + var result; + var _Symbol = root.Symbol; + if (typeof _Symbol === "function") { + if (_Symbol.observable) { + result = _Symbol.observable; + } else { + result = _Symbol("observable"); + _Symbol.observable = result; + } + } else { + result = "@@observable"; + } + return result; + } + } + }); + + // node_modules/symbol-observable/lib/index.js + var require_lib3 = __commonJS({ + "node_modules/symbol-observable/lib/index.js"(exports, module) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + var _ponyfill = require_ponyfill(); + var _ponyfill2 = _interopRequireDefault(_ponyfill); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { "default": obj }; + } + var root; + if (typeof self !== "undefined") { + root = self; + } else if (typeof window !== "undefined") { + root = window; + } else if (typeof global !== "undefined") { + root = global; + } else if (typeof module !== "undefined") { + root = module; + } else { + root = Function("return this")(); + } + var result = (0, _ponyfill2["default"])(root); + exports["default"] = result; + } + }); + + // node_modules/symbol-observable/index.js + var require_symbol_observable = __commonJS({ + "node_modules/symbol-observable/index.js"(exports, module) { + module.exports = require_lib3(); + } + }); + + // node_modules/recompose/cjs/Recompose.js + var require_Recompose = __commonJS({ + "node_modules/recompose/cjs/Recompose.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + function _interopDefault(ex) { + return ex && typeof ex === "object" && "default" in ex ? ex["default"] : ex; + } + var React3 = require_react(); + var React__default = _interopDefault(React3); + var shallowEqual = _interopDefault(require_shallowEqual()); + var hoistNonReactStatics = _interopDefault(require_hoist_non_react_statics()); + var changeEmitter = require_lib2(); + var $$observable = _interopDefault(require_symbol_observable()); + var setStatic = function setStatic2(key, value) { + return function(BaseComponent) { + BaseComponent[key] = value; + return BaseComponent; + }; + }; + var setDisplayName = function setDisplayName2(displayName) { + return setStatic("displayName", displayName); + }; + var getDisplayName = function getDisplayName2(Component$$1) { + if (typeof Component$$1 === "string") { + return Component$$1; + } + if (!Component$$1) { + return void 0; + } + return Component$$1.displayName || Component$$1.name || "Component"; + }; + var wrapDisplayName = function wrapDisplayName2(BaseComponent, hocName) { + return hocName + "(" + getDisplayName(BaseComponent) + ")"; + }; + var mapProps = function mapProps2(propsMapper) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var MapProps = function MapProps2(props) { + return factory(propsMapper(props)); + }; + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "mapProps"))(MapProps); + } + return MapProps; + }; + }; + var classCallCheck = function(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + }; + var _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + var inherits = function(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) + Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; + }; + var objectWithoutProperties = function(obj, keys2) { + var target = {}; + for (var i in obj) { + if (keys2.indexOf(i) >= 0) + continue; + if (!Object.prototype.hasOwnProperty.call(obj, i)) + continue; + target[i] = obj[i]; + } + return target; + }; + var possibleConstructorReturn = function(self2, call) { + if (!self2) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return call && (typeof call === "object" || typeof call === "function") ? call : self2; + }; + var withProps2 = function withProps3(input) { + var hoc = mapProps(function(props) { + return _extends({}, props, typeof input === "function" ? input(props) : input); + }); + if (true) { + return function(BaseComponent) { + return setDisplayName(wrapDisplayName(BaseComponent, "withProps"))(hoc(BaseComponent)); + }; + } + return hoc; + }; + var pick = function pick2(obj, keys2) { + var result = {}; + for (var i = 0; i < keys2.length; i++) { + var key = keys2[i]; + if (obj.hasOwnProperty(key)) { + result[key] = obj[key]; + } + } + return result; + }; + var withPropsOnChange = function withPropsOnChange2(shouldMapOrKeys, propsMapper) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var shouldMap = typeof shouldMapOrKeys === "function" ? shouldMapOrKeys : function(props, nextProps) { + return !shallowEqual(pick(props, shouldMapOrKeys), pick(nextProps, shouldMapOrKeys)); + }; + var WithPropsOnChange = function(_Component) { + inherits(WithPropsOnChange2, _Component); + function WithPropsOnChange2() { + var _temp, _this, _ret; + classCallCheck(this, WithPropsOnChange2); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.computedProps = propsMapper(_this.props), _temp), possibleConstructorReturn(_this, _ret); + } + WithPropsOnChange2.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { + if (shouldMap(this.props, nextProps)) { + this.computedProps = propsMapper(nextProps); + } + }; + WithPropsOnChange2.prototype.render = function render() { + return factory(_extends({}, this.props, this.computedProps)); + }; + return WithPropsOnChange2; + }(React3.Component); + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "withPropsOnChange"))(WithPropsOnChange); + } + return WithPropsOnChange; + }; + }; + var mapValues = function mapValues2(obj, func) { + var result = {}; + for (var key in obj) { + if (obj.hasOwnProperty(key)) { + result[key] = func(obj[key], key); + } + } + return result; + }; + var withHandlers = function withHandlers2(handlers) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var WithHandlers = function(_Component) { + inherits(WithHandlers2, _Component); + function WithHandlers2() { + var _temp, _this, _ret; + classCallCheck(this, WithHandlers2); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _initialiseProps.call(_this), _temp), possibleConstructorReturn(_this, _ret); + } + WithHandlers2.prototype.componentWillReceiveProps = function componentWillReceiveProps() { + this.cachedHandlers = {}; + }; + WithHandlers2.prototype.render = function render() { + return factory(_extends({}, this.props, this.handlers)); + }; + return WithHandlers2; + }(React3.Component); + var _initialiseProps = function _initialiseProps2() { + var _this2 = this; + this.cachedHandlers = {}; + this.handlers = mapValues(typeof handlers === "function" ? handlers(this.props) : handlers, function(createHandler, handlerName) { + return function() { + var cachedHandler = _this2.cachedHandlers[handlerName]; + if (cachedHandler) { + return cachedHandler.apply(void 0, arguments); + } + var handler = createHandler(_this2.props); + _this2.cachedHandlers[handlerName] = handler; + if (typeof handler !== "function") { + console.error( + // eslint-disable-line no-console + "withHandlers(): Expected a map of higher-order functions. Refer to the docs for more info." + ); + } + return handler.apply(void 0, arguments); + }; + }); + }; + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "withHandlers"))(WithHandlers); + } + return WithHandlers; + }; + }; + var defaultProps = function defaultProps2(props) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var DefaultProps = function DefaultProps2(ownerProps) { + return factory(ownerProps); + }; + DefaultProps.defaultProps = props; + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "defaultProps"))(DefaultProps); + } + return DefaultProps; + }; + }; + var omit = function omit2(obj, keys2) { + var rest = objectWithoutProperties(obj, []); + for (var i = 0; i < keys2.length; i++) { + var key = keys2[i]; + if (rest.hasOwnProperty(key)) { + delete rest[key]; + } + } + return rest; + }; + var renameProp = function renameProp2(oldName, newName) { + var hoc = mapProps(function(props) { + var _babelHelpers$extends; + return _extends({}, omit(props, [oldName]), (_babelHelpers$extends = {}, _babelHelpers$extends[newName] = props[oldName], _babelHelpers$extends)); + }); + if (true) { + return function(BaseComponent) { + return setDisplayName(wrapDisplayName(BaseComponent, "renameProp"))(hoc(BaseComponent)); + }; + } + return hoc; + }; + var keys = Object.keys; + var mapKeys = function mapKeys2(obj, func) { + return keys(obj).reduce(function(result, key) { + var val = obj[key]; + result[func(val, key)] = val; + return result; + }, {}); + }; + var renameProps = function renameProps2(nameMap) { + var hoc = mapProps(function(props) { + return _extends({}, omit(props, keys(nameMap)), mapKeys(pick(props, keys(nameMap)), function(_, oldName) { + return nameMap[oldName]; + })); + }); + if (true) { + return function(BaseComponent) { + return setDisplayName(wrapDisplayName(BaseComponent, "renameProps"))(hoc(BaseComponent)); + }; + } + return hoc; + }; + var flattenProp = function flattenProp2(propName) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var FlattenProp = function FlattenProp2(props) { + return factory(_extends({}, props, props[propName])); + }; + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "flattenProp"))(FlattenProp); + } + return FlattenProp; + }; + }; + var withState = function withState2(stateName, stateUpdaterName, initialState) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var WithState = function(_Component) { + inherits(WithState2, _Component); + function WithState2() { + var _temp, _this, _ret; + classCallCheck(this, WithState2); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = { + stateValue: typeof initialState === "function" ? initialState(_this.props) : initialState + }, _this.updateStateValue = function(updateFn, callback) { + return _this.setState(function(_ref) { + var stateValue = _ref.stateValue; + return { + stateValue: typeof updateFn === "function" ? updateFn(stateValue) : updateFn + }; + }, callback); + }, _temp), possibleConstructorReturn(_this, _ret); + } + WithState2.prototype.render = function render() { + var _babelHelpers$extends; + return factory(_extends({}, this.props, (_babelHelpers$extends = {}, _babelHelpers$extends[stateName] = this.state.stateValue, _babelHelpers$extends[stateUpdaterName] = this.updateStateValue, _babelHelpers$extends))); + }; + return WithState2; + }(React3.Component); + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "withState"))(WithState); + } + return WithState; + }; + }; + var withStateHandlers = function withStateHandlers2(initialState, stateUpdaters) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var WithStateHandlers = function(_Component) { + inherits(WithStateHandlers2, _Component); + function WithStateHandlers2() { + var _temp, _this, _ret; + classCallCheck(this, WithStateHandlers2); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _initialiseProps.call(_this), _temp), possibleConstructorReturn(_this, _ret); + } + WithStateHandlers2.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) { + var propsChanged = nextProps !== this.props; + var stateChanged = !shallowEqual(nextState, this.state); + return propsChanged || stateChanged; + }; + WithStateHandlers2.prototype.render = function render() { + return factory(_extends({}, this.props, this.state, this.stateUpdaters)); + }; + return WithStateHandlers2; + }(React3.Component); + var _initialiseProps = function _initialiseProps2() { + var _this2 = this; + this.state = typeof initialState === "function" ? initialState(this.props) : initialState; + this.stateUpdaters = mapValues(stateUpdaters, function(handler) { + return function(mayBeEvent) { + for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + if (mayBeEvent && typeof mayBeEvent.persist === "function") { + mayBeEvent.persist(); + } + _this2.setState(function(state, props) { + return handler(state, props).apply(void 0, [mayBeEvent].concat(args)); + }); + }; + }); + }; + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "withStateHandlers"))(WithStateHandlers); + } + return WithStateHandlers; + }; + }; + var withReducer = function withReducer2(stateName, dispatchName, reducer, initialState) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var WithReducer = function(_Component) { + inherits(WithReducer2, _Component); + function WithReducer2() { + var _temp, _this, _ret; + classCallCheck(this, WithReducer2); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = { + stateValue: _this.initializeStateValue() + }, _this.dispatch = function(action) { + return _this.setState(function(_ref) { + var stateValue = _ref.stateValue; + return { + stateValue: reducer(stateValue, action) + }; + }); + }, _temp), possibleConstructorReturn(_this, _ret); + } + WithReducer2.prototype.initializeStateValue = function initializeStateValue() { + if (initialState !== void 0) { + return typeof initialState === "function" ? initialState(this.props) : initialState; + } + return reducer(void 0, { type: "@@recompose/INIT" }); + }; + WithReducer2.prototype.render = function render() { + var _babelHelpers$extends; + return factory(_extends({}, this.props, (_babelHelpers$extends = {}, _babelHelpers$extends[stateName] = this.state.stateValue, _babelHelpers$extends[dispatchName] = this.dispatch, _babelHelpers$extends))); + }; + return WithReducer2; + }(React3.Component); + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "withReducer"))(WithReducer); + } + return WithReducer; + }; + }; + var identity = function identity2(Component$$1) { + return Component$$1; + }; + var branch = function branch2(test, left) { + var right = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : identity; + return function(BaseComponent) { + var leftFactory = void 0; + var rightFactory = void 0; + var Branch = function Branch2(props) { + if (test(props)) { + leftFactory = leftFactory || React3.createFactory(left(BaseComponent)); + return leftFactory(props); + } + rightFactory = rightFactory || React3.createFactory(right(BaseComponent)); + return rightFactory(props); + }; + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "branch"))(Branch); + } + return Branch; + }; + }; + var renderComponent = function renderComponent2(Component$$1) { + return function(_) { + var factory = React3.createFactory(Component$$1); + var RenderComponent = function RenderComponent2(props) { + return factory(props); + }; + if (true) { + RenderComponent.displayName = wrapDisplayName(Component$$1, "renderComponent"); + } + return RenderComponent; + }; + }; + var Nothing = function(_Component) { + inherits(Nothing2, _Component); + function Nothing2() { + classCallCheck(this, Nothing2); + return possibleConstructorReturn(this, _Component.apply(this, arguments)); + } + Nothing2.prototype.render = function render() { + return null; + }; + return Nothing2; + }(React3.Component); + var renderNothing = function renderNothing2(_) { + return Nothing; + }; + var shouldUpdate = function shouldUpdate2(test) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var ShouldUpdate = function(_Component) { + inherits(ShouldUpdate2, _Component); + function ShouldUpdate2() { + classCallCheck(this, ShouldUpdate2); + return possibleConstructorReturn(this, _Component.apply(this, arguments)); + } + ShouldUpdate2.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) { + return test(this.props, nextProps); + }; + ShouldUpdate2.prototype.render = function render() { + return factory(this.props); + }; + return ShouldUpdate2; + }(React3.Component); + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "shouldUpdate"))(ShouldUpdate); + } + return ShouldUpdate; + }; + }; + var pure = function pure2(BaseComponent) { + var hoc = shouldUpdate(function(props, nextProps) { + return !shallowEqual(props, nextProps); + }); + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "pure"))(hoc(BaseComponent)); + } + return hoc(BaseComponent); + }; + var onlyUpdateForKeys = function onlyUpdateForKeys2(propKeys) { + var hoc = shouldUpdate(function(props, nextProps) { + return !shallowEqual(pick(nextProps, propKeys), pick(props, propKeys)); + }); + if (true) { + return function(BaseComponent) { + return setDisplayName(wrapDisplayName(BaseComponent, "onlyUpdateForKeys"))(hoc(BaseComponent)); + }; + } + return hoc; + }; + var onlyUpdateForPropTypes = function onlyUpdateForPropTypes2(BaseComponent) { + var propTypes = BaseComponent.propTypes; + if (true) { + if (!propTypes) { + console.error("A component without any `propTypes` was passed to `onlyUpdateForPropTypes()`. Check the implementation of the " + ('component with display name "' + getDisplayName(BaseComponent) + '".')); + } + } + var propKeys = Object.keys(propTypes || {}); + var OnlyUpdateForPropTypes = onlyUpdateForKeys(propKeys)(BaseComponent); + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "onlyUpdateForPropTypes"))(OnlyUpdateForPropTypes); + } + return OnlyUpdateForPropTypes; + }; + var withContext = function withContext2(childContextTypes, getChildContext) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var WithContext = function(_Component) { + inherits(WithContext2, _Component); + function WithContext2() { + var _temp, _this, _ret; + classCallCheck(this, WithContext2); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.getChildContext = function() { + return getChildContext(_this.props); + }, _temp), possibleConstructorReturn(_this, _ret); + } + WithContext2.prototype.render = function render() { + return factory(this.props); + }; + return WithContext2; + }(React3.Component); + WithContext.childContextTypes = childContextTypes; + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "withContext"))(WithContext); + } + return WithContext; + }; + }; + var getContext = function getContext2(contextTypes) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var GetContext = function GetContext2(ownerProps, context) { + return factory(_extends({}, ownerProps, context)); + }; + GetContext.contextTypes = contextTypes; + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "getContext"))(GetContext); + } + return GetContext; + }; + }; + var lifecycle2 = function lifecycle3(spec) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + if (spec.hasOwnProperty("render")) { + console.error("lifecycle() does not support the render method; its behavior is to pass all props and state to the base component."); + } + var Lifecycle = function(_Component) { + inherits(Lifecycle2, _Component); + function Lifecycle2() { + classCallCheck(this, Lifecycle2); + return possibleConstructorReturn(this, _Component.apply(this, arguments)); + } + Lifecycle2.prototype.render = function render() { + return factory(_extends({}, this.props, this.state)); + }; + return Lifecycle2; + }(React3.Component); + Object.keys(spec).forEach(function(hook) { + return Lifecycle.prototype[hook] = spec[hook]; + }); + if (true) { + return setDisplayName(wrapDisplayName(BaseComponent, "lifecycle"))(Lifecycle); + } + return Lifecycle; + }; + }; + var isClassComponent = function isClassComponent2(Component$$1) { + return Boolean(Component$$1 && Component$$1.prototype && typeof Component$$1.prototype.render === "function"); + }; + var toClass = function toClass2(baseComponent) { + if (isClassComponent(baseComponent)) { + return baseComponent; + } + var ToClass = function(_Component) { + inherits(ToClass2, _Component); + function ToClass2() { + classCallCheck(this, ToClass2); + return possibleConstructorReturn(this, _Component.apply(this, arguments)); + } + ToClass2.prototype.render = function render() { + if (typeof baseComponent === "string") { + return React__default.createElement(baseComponent, this.props); + } + return baseComponent(this.props, this.context); + }; + return ToClass2; + }(React3.Component); + ToClass.displayName = getDisplayName(baseComponent); + ToClass.propTypes = baseComponent.propTypes; + ToClass.contextTypes = baseComponent.contextTypes; + ToClass.defaultProps = baseComponent.defaultProps; + return ToClass; + }; + var setPropTypes = function setPropTypes2(propTypes) { + return setStatic("propTypes", propTypes); + }; + function compose2() { + for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) { + funcs[_key] = arguments[_key]; + } + if (funcs.length === 0) { + return function(arg) { + return arg; + }; + } + if (funcs.length === 1) { + return funcs[0]; + } + return funcs.reduce(function(a, b) { + return function() { + return a(b.apply(void 0, arguments)); + }; + }); + } + var createSink = function createSink2(callback) { + return function(_Component) { + inherits(Sink, _Component); + function Sink() { + classCallCheck(this, Sink); + return possibleConstructorReturn(this, _Component.apply(this, arguments)); + } + Sink.prototype.componentWillMount = function componentWillMount() { + callback(this.props); + }; + Sink.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { + callback(nextProps); + }; + Sink.prototype.render = function render() { + return null; + }; + return Sink; + }(React3.Component); + }; + var componentFromProp = function componentFromProp2(propName) { + var Component$$1 = function Component$$12(props) { + return React3.createElement(props[propName], omit(props, [propName])); + }; + Component$$1.displayName = "componentFromProp(" + propName + ")"; + return Component$$1; + }; + var nest = function nest2() { + for (var _len = arguments.length, Components = Array(_len), _key = 0; _key < _len; _key++) { + Components[_key] = arguments[_key]; + } + var factories = Components.map(React3.createFactory); + var Nest = function Nest2(_ref) { + var props = objectWithoutProperties(_ref, []), children = _ref.children; + return factories.reduceRight(function(child, factory) { + return factory(props, child); + }, children); + }; + if (true) { + var displayNames = Components.map(getDisplayName); + Nest.displayName = "nest(" + displayNames.join(", ") + ")"; + } + return Nest; + }; + var hoistStatics = function hoistStatics2(higherOrderComponent) { + return function(BaseComponent) { + var NewComponent = higherOrderComponent(BaseComponent); + hoistNonReactStatics(NewComponent, BaseComponent); + return NewComponent; + }; + }; + var _config = { + fromESObservable: null, + toESObservable: null + }; + var configureObservable = function configureObservable2(c) { + _config = c; + }; + var config = { + fromESObservable: function fromESObservable(observable) { + return typeof _config.fromESObservable === "function" ? _config.fromESObservable(observable) : observable; + }, + toESObservable: function toESObservable(stream) { + return typeof _config.toESObservable === "function" ? _config.toESObservable(stream) : stream; + } + }; + var componentFromStreamWithConfig = function componentFromStreamWithConfig2(config$$1) { + return function(propsToVdom) { + return function(_Component) { + inherits(ComponentFromStream, _Component); + function ComponentFromStream() { + var _config$fromESObserva; + var _temp, _this, _ret; + classCallCheck(this, ComponentFromStream); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = { vdom: null }, _this.propsEmitter = changeEmitter.createChangeEmitter(), _this.props$ = config$$1.fromESObservable((_config$fromESObserva = { + subscribe: function subscribe(observer) { + var unsubscribe = _this.propsEmitter.listen(function(props) { + if (props) { + observer.next(props); + } else { + observer.complete(); + } + }); + return { unsubscribe }; + } + }, _config$fromESObserva[$$observable] = function() { + return this; + }, _config$fromESObserva)), _this.vdom$ = config$$1.toESObservable(propsToVdom(_this.props$)), _temp), possibleConstructorReturn(_this, _ret); + } + ComponentFromStream.prototype.componentWillMount = function componentWillMount() { + var _this2 = this; + this.subscription = this.vdom$.subscribe({ + next: function next(vdom) { + _this2.setState({ vdom }); + } + }); + this.propsEmitter.emit(this.props); + }; + ComponentFromStream.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { + this.propsEmitter.emit(nextProps); + }; + ComponentFromStream.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) { + return nextState.vdom !== this.state.vdom; + }; + ComponentFromStream.prototype.componentWillUnmount = function componentWillUnmount() { + this.propsEmitter.emit(); + this.subscription.unsubscribe(); + }; + ComponentFromStream.prototype.render = function render() { + return this.state.vdom; + }; + return ComponentFromStream; + }(React3.Component); + }; + }; + var componentFromStream = function componentFromStream2(propsToVdom) { + return componentFromStreamWithConfig(config)(propsToVdom); + }; + var identity$1 = function identity2(t) { + return t; + }; + var mapPropsStreamWithConfig = function mapPropsStreamWithConfig2(config$$1) { + var componentFromStream2 = componentFromStreamWithConfig({ + fromESObservable: identity$1, + toESObservable: identity$1 + }); + return function(transform) { + return function(BaseComponent) { + var factory = React3.createFactory(BaseComponent); + var fromESObservable = config$$1.fromESObservable, toESObservable = config$$1.toESObservable; + return componentFromStream2(function(props$) { + var _ref; + return _ref = { + subscribe: function subscribe(observer) { + var subscription = toESObservable(transform(fromESObservable(props$))).subscribe({ + next: function next(childProps) { + return observer.next(factory(childProps)); + } + }); + return { + unsubscribe: function unsubscribe() { + return subscription.unsubscribe(); + } + }; + } + }, _ref[$$observable] = function() { + return this; + }, _ref; + }); + }; + }; + }; + var mapPropsStream = function mapPropsStream2(transform) { + var hoc = mapPropsStreamWithConfig(config)(transform); + if (true) { + return function(BaseComponent) { + return setDisplayName(wrapDisplayName(BaseComponent, "mapPropsStream"))(hoc(BaseComponent)); + }; + } + return hoc; + }; + var createEventHandlerWithConfig = function createEventHandlerWithConfig2(config$$1) { + return function() { + var _config$fromESObserva; + var emitter = changeEmitter.createChangeEmitter(); + var stream = config$$1.fromESObservable((_config$fromESObserva = { + subscribe: function subscribe(observer) { + var unsubscribe = emitter.listen(function(value) { + return observer.next(value); + }); + return { unsubscribe }; + } + }, _config$fromESObserva[$$observable] = function() { + return this; + }, _config$fromESObserva)); + return { + handler: emitter.emit, + stream + }; + }; + }; + var createEventHandler = createEventHandlerWithConfig(config); + exports.mapProps = mapProps; + exports.withProps = withProps2; + exports.withPropsOnChange = withPropsOnChange; + exports.withHandlers = withHandlers; + exports.defaultProps = defaultProps; + exports.renameProp = renameProp; + exports.renameProps = renameProps; + exports.flattenProp = flattenProp; + exports.withState = withState; + exports.withStateHandlers = withStateHandlers; + exports.withReducer = withReducer; + exports.branch = branch; + exports.renderComponent = renderComponent; + exports.renderNothing = renderNothing; + exports.shouldUpdate = shouldUpdate; + exports.pure = pure; + exports.onlyUpdateForKeys = onlyUpdateForKeys; + exports.onlyUpdateForPropTypes = onlyUpdateForPropTypes; + exports.withContext = withContext; + exports.getContext = getContext; + exports.lifecycle = lifecycle2; + exports.toClass = toClass; + exports.setStatic = setStatic; + exports.setPropTypes = setPropTypes; + exports.setDisplayName = setDisplayName; + exports.compose = compose2; + exports.getDisplayName = getDisplayName; + exports.wrapDisplayName = wrapDisplayName; + exports.shallowEqual = shallowEqual; + exports.isClassComponent = isClassComponent; + exports.createSink = createSink; + exports.componentFromProp = componentFromProp; + exports.nest = nest; + exports.hoistStatics = hoistStatics; + exports.componentFromStream = componentFromStream; + exports.componentFromStreamWithConfig = componentFromStreamWithConfig; + exports.mapPropsStream = mapPropsStream; + exports.mapPropsStreamWithConfig = mapPropsStreamWithConfig; + exports.createEventHandler = createEventHandler; + exports.createEventHandlerWithConfig = createEventHandlerWithConfig; + exports.setObservableConfig = configureObservable; + } + }); + + // node_modules/@neos-project/neos-ui-extensibility/dist/shims/vendor/plow-js/index.js + var require_plow_js = __commonJS({ + "node_modules/@neos-project/neos-ui-extensibility/dist/shims/vendor/plow-js/index.js"(exports, module) { + init_readFromConsumerApi(); + module.exports = readFromConsumerApi("vendor")().plow; + } + }); + + // node_modules/babel-runtime/helpers/objectWithoutProperties.js + var require_objectWithoutProperties = __commonJS({ + "node_modules/babel-runtime/helpers/objectWithoutProperties.js"(exports) { + "use strict"; + exports.__esModule = true; + exports.default = function(obj, keys) { + var target = {}; + for (var i in obj) { + if (keys.indexOf(i) >= 0) + continue; + if (!Object.prototype.hasOwnProperty.call(obj, i)) + continue; + target[i] = obj[i]; + } + return target; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_defined.js + var require_defined = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_defined.js"(exports, module) { + module.exports = function(it) { + if (it == void 0) + throw TypeError("Can't call method on " + it); + return it; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_to-object.js + var require_to_object = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_to-object.js"(exports, module) { + var defined = require_defined(); + module.exports = function(it) { + return Object(defined(it)); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_has.js + var require_has = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_has.js"(exports, module) { + var hasOwnProperty = {}.hasOwnProperty; + module.exports = function(it, key) { + return hasOwnProperty.call(it, key); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_global.js + var require_global = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_global.js"(exports, module) { + var global2 = module.exports = typeof window != "undefined" && window.Math == Math ? window : typeof self != "undefined" && self.Math == Math ? self : Function("return this")(); + if (typeof __g == "number") + __g = global2; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_shared.js + var require_shared = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_shared.js"(exports, module) { + var global2 = require_global(); + var SHARED = "__core-js_shared__"; + var store = global2[SHARED] || (global2[SHARED] = {}); + module.exports = function(key) { + return store[key] || (store[key] = {}); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_uid.js + var require_uid = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_uid.js"(exports, module) { + var id = 0; + var px = Math.random(); + module.exports = function(key) { + return "Symbol(".concat(key === void 0 ? "" : key, ")_", (++id + px).toString(36)); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_shared-key.js + var require_shared_key = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_shared-key.js"(exports, module) { + var shared = require_shared()("keys"); + var uid = require_uid(); + module.exports = function(key) { + return shared[key] || (shared[key] = uid(key)); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gpo.js + var require_object_gpo = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gpo.js"(exports, module) { + var has = require_has(); + var toObject = require_to_object(); + var IE_PROTO = require_shared_key()("IE_PROTO"); + var ObjectProto = Object.prototype; + module.exports = Object.getPrototypeOf || function(O) { + O = toObject(O); + if (has(O, IE_PROTO)) + return O[IE_PROTO]; + if (typeof O.constructor == "function" && O instanceof O.constructor) { + return O.constructor.prototype; + } + return O instanceof Object ? ObjectProto : null; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_core.js + var require_core = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_core.js"(exports, module) { + var core = module.exports = { version: "2.5.3" }; + if (typeof __e == "number") + __e = core; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_a-function.js + var require_a_function = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_a-function.js"(exports, module) { + module.exports = function(it) { + if (typeof it != "function") + throw TypeError(it + " is not a function!"); + return it; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_ctx.js + var require_ctx = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_ctx.js"(exports, module) { + var aFunction = require_a_function(); + module.exports = function(fn, that, length) { + aFunction(fn); + if (that === void 0) + return fn; + switch (length) { + case 1: + return function(a) { + return fn.call(that, a); + }; + case 2: + return function(a, b) { + return fn.call(that, a, b); + }; + case 3: + return function(a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function() { + return fn.apply(that, arguments); + }; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_is-object.js + var require_is_object = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_is-object.js"(exports, module) { + module.exports = function(it) { + return typeof it === "object" ? it !== null : typeof it === "function"; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_an-object.js + var require_an_object = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_an-object.js"(exports, module) { + var isObject = require_is_object(); + module.exports = function(it) { + if (!isObject(it)) + throw TypeError(it + " is not an object!"); + return it; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_fails.js + var require_fails = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_fails.js"(exports, module) { + module.exports = function(exec) { + try { + return !!exec(); + } catch (e) { + return true; + } + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_descriptors.js + var require_descriptors = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_descriptors.js"(exports, module) { + module.exports = !require_fails()(function() { + return Object.defineProperty({}, "a", { get: function() { + return 7; + } }).a != 7; + }); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_dom-create.js + var require_dom_create = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_dom-create.js"(exports, module) { + var isObject = require_is_object(); + var document2 = require_global().document; + var is = isObject(document2) && isObject(document2.createElement); + module.exports = function(it) { + return is ? document2.createElement(it) : {}; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_ie8-dom-define.js + var require_ie8_dom_define = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_ie8-dom-define.js"(exports, module) { + module.exports = !require_descriptors() && !require_fails()(function() { + return Object.defineProperty(require_dom_create()("div"), "a", { get: function() { + return 7; + } }).a != 7; + }); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_to-primitive.js + var require_to_primitive = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_to-primitive.js"(exports, module) { + var isObject = require_is_object(); + module.exports = function(it, S) { + if (!isObject(it)) + return it; + var fn, val; + if (S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it))) + return val; + if (typeof (fn = it.valueOf) == "function" && !isObject(val = fn.call(it))) + return val; + if (!S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it))) + return val; + throw TypeError("Can't convert object to primitive value"); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-dp.js + var require_object_dp = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-dp.js"(exports) { + var anObject = require_an_object(); + var IE8_DOM_DEFINE = require_ie8_dom_define(); + var toPrimitive = require_to_primitive(); + var dP = Object.defineProperty; + exports.f = require_descriptors() ? Object.defineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (IE8_DOM_DEFINE) + try { + return dP(O, P, Attributes); + } catch (e) { + } + if ("get" in Attributes || "set" in Attributes) + throw TypeError("Accessors not supported!"); + if ("value" in Attributes) + O[P] = Attributes.value; + return O; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_property-desc.js + var require_property_desc = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_property-desc.js"(exports, module) { + module.exports = function(bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value + }; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_hide.js + var require_hide = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_hide.js"(exports, module) { + var dP = require_object_dp(); + var createDesc = require_property_desc(); + module.exports = require_descriptors() ? function(object, key, value) { + return dP.f(object, key, createDesc(1, value)); + } : function(object, key, value) { + object[key] = value; + return object; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_export.js + var require_export = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_export.js"(exports, module) { + var global2 = require_global(); + var core = require_core(); + var ctx = require_ctx(); + var hide = require_hide(); + var PROTOTYPE = "prototype"; + var $export = function(type, name, source) { + var IS_FORCED = type & $export.F; + var IS_GLOBAL = type & $export.G; + var IS_STATIC = type & $export.S; + var IS_PROTO = type & $export.P; + var IS_BIND = type & $export.B; + var IS_WRAP = type & $export.W; + var exports2 = IS_GLOBAL ? core : core[name] || (core[name] = {}); + var expProto = exports2[PROTOTYPE]; + var target = IS_GLOBAL ? global2 : IS_STATIC ? global2[name] : (global2[name] || {})[PROTOTYPE]; + var key, own, out; + if (IS_GLOBAL) + source = name; + for (key in source) { + own = !IS_FORCED && target && target[key] !== void 0; + if (own && key in exports2) + continue; + out = own ? target[key] : source[key]; + exports2[key] = IS_GLOBAL && typeof target[key] != "function" ? source[key] : IS_BIND && own ? ctx(out, global2) : IS_WRAP && target[key] == out ? function(C) { + var F = function(a, b, c) { + if (this instanceof C) { + switch (arguments.length) { + case 0: + return new C(); + case 1: + return new C(a); + case 2: + return new C(a, b); + } + return new C(a, b, c); + } + return C.apply(this, arguments); + }; + F[PROTOTYPE] = C[PROTOTYPE]; + return F; + }(out) : IS_PROTO && typeof out == "function" ? ctx(Function.call, out) : out; + if (IS_PROTO) { + (exports2.virtual || (exports2.virtual = {}))[key] = out; + if (type & $export.R && expProto && !expProto[key]) + hide(expProto, key, out); + } + } + }; + $export.F = 1; + $export.G = 2; + $export.S = 4; + $export.P = 8; + $export.B = 16; + $export.W = 32; + $export.U = 64; + $export.R = 128; + module.exports = $export; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-sap.js + var require_object_sap = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-sap.js"(exports, module) { + var $export = require_export(); + var core = require_core(); + var fails = require_fails(); + module.exports = function(KEY, exec) { + var fn = (core.Object || {})[KEY] || Object[KEY]; + var exp = {}; + exp[KEY] = exec(fn); + $export($export.S + $export.F * fails(function() { + fn(1); + }), "Object", exp); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.get-prototype-of.js + var require_es6_object_get_prototype_of = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.get-prototype-of.js"() { + var toObject = require_to_object(); + var $getPrototypeOf = require_object_gpo(); + require_object_sap()("getPrototypeOf", function() { + return function getPrototypeOf(it) { + return $getPrototypeOf(toObject(it)); + }; + }); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/fn/object/get-prototype-of.js + var require_get_prototype_of = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/fn/object/get-prototype-of.js"(exports, module) { + require_es6_object_get_prototype_of(); + module.exports = require_core().Object.getPrototypeOf; + } + }); + + // node_modules/babel-runtime/core-js/object/get-prototype-of.js + var require_get_prototype_of2 = __commonJS({ + "node_modules/babel-runtime/core-js/object/get-prototype-of.js"(exports, module) { + module.exports = { "default": require_get_prototype_of(), __esModule: true }; + } + }); + + // node_modules/babel-runtime/helpers/classCallCheck.js + var require_classCallCheck = __commonJS({ + "node_modules/babel-runtime/helpers/classCallCheck.js"(exports) { + "use strict"; + exports.__esModule = true; + exports.default = function(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.define-property.js + var require_es6_object_define_property = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.define-property.js"() { + var $export = require_export(); + $export($export.S + $export.F * !require_descriptors(), "Object", { defineProperty: require_object_dp().f }); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/fn/object/define-property.js + var require_define_property = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/fn/object/define-property.js"(exports, module) { + require_es6_object_define_property(); + var $Object = require_core().Object; + module.exports = function defineProperty(it, key, desc) { + return $Object.defineProperty(it, key, desc); + }; + } + }); + + // node_modules/babel-runtime/core-js/object/define-property.js + var require_define_property2 = __commonJS({ + "node_modules/babel-runtime/core-js/object/define-property.js"(exports, module) { + module.exports = { "default": require_define_property(), __esModule: true }; + } + }); + + // node_modules/babel-runtime/helpers/createClass.js + var require_createClass = __commonJS({ + "node_modules/babel-runtime/helpers/createClass.js"(exports) { + "use strict"; + exports.__esModule = true; + var _defineProperty = require_define_property2(); + var _defineProperty2 = _interopRequireDefault(_defineProperty); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + exports.default = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + (0, _defineProperty2.default)(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + if (protoProps) + defineProperties(Constructor.prototype, protoProps); + if (staticProps) + defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_to-integer.js + var require_to_integer = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_to-integer.js"(exports, module) { + var ceil = Math.ceil; + var floor = Math.floor; + module.exports = function(it) { + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_string-at.js + var require_string_at = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_string-at.js"(exports, module) { + var toInteger = require_to_integer(); + var defined = require_defined(); + module.exports = function(TO_STRING) { + return function(that, pos) { + var s = String(defined(that)); + var i = toInteger(pos); + var l = s.length; + var a, b; + if (i < 0 || i >= l) + return TO_STRING ? "" : void 0; + a = s.charCodeAt(i); + return a < 55296 || a > 56319 || i + 1 === l || (b = s.charCodeAt(i + 1)) < 56320 || b > 57343 ? TO_STRING ? s.charAt(i) : a : TO_STRING ? s.slice(i, i + 2) : (a - 55296 << 10) + (b - 56320) + 65536; + }; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_library.js + var require_library = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_library.js"(exports, module) { + module.exports = true; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_redefine.js + var require_redefine = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_redefine.js"(exports, module) { + module.exports = require_hide(); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_iterators.js + var require_iterators = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_iterators.js"(exports, module) { + module.exports = {}; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_cof.js + var require_cof = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_cof.js"(exports, module) { + var toString = {}.toString; + module.exports = function(it) { + return toString.call(it).slice(8, -1); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_iobject.js + var require_iobject = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_iobject.js"(exports, module) { + var cof = require_cof(); + module.exports = Object("z").propertyIsEnumerable(0) ? Object : function(it) { + return cof(it) == "String" ? it.split("") : Object(it); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_to-iobject.js + var require_to_iobject = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_to-iobject.js"(exports, module) { + var IObject = require_iobject(); + var defined = require_defined(); + module.exports = function(it) { + return IObject(defined(it)); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_to-length.js + var require_to_length = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_to-length.js"(exports, module) { + var toInteger = require_to_integer(); + var min = Math.min; + module.exports = function(it) { + return it > 0 ? min(toInteger(it), 9007199254740991) : 0; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_to-absolute-index.js + var require_to_absolute_index = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_to-absolute-index.js"(exports, module) { + var toInteger = require_to_integer(); + var max = Math.max; + var min = Math.min; + module.exports = function(index, length) { + index = toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_array-includes.js + var require_array_includes = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_array-includes.js"(exports, module) { + var toIObject = require_to_iobject(); + var toLength = require_to_length(); + var toAbsoluteIndex = require_to_absolute_index(); + module.exports = function(IS_INCLUDES) { + return function($this, el, fromIndex) { + var O = toIObject($this); + var length = toLength(O.length); + var index = toAbsoluteIndex(fromIndex, length); + var value; + if (IS_INCLUDES && el != el) + while (length > index) { + value = O[index++]; + if (value != value) + return true; + } + else + for (; length > index; index++) + if (IS_INCLUDES || index in O) { + if (O[index] === el) + return IS_INCLUDES || index || 0; + } + return !IS_INCLUDES && -1; + }; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-keys-internal.js + var require_object_keys_internal = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-keys-internal.js"(exports, module) { + var has = require_has(); + var toIObject = require_to_iobject(); + var arrayIndexOf = require_array_includes()(false); + var IE_PROTO = require_shared_key()("IE_PROTO"); + module.exports = function(object, names) { + var O = toIObject(object); + var i = 0; + var result = []; + var key; + for (key in O) + if (key != IE_PROTO) + has(O, key) && result.push(key); + while (names.length > i) + if (has(O, key = names[i++])) { + ~arrayIndexOf(result, key) || result.push(key); + } + return result; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_enum-bug-keys.js + var require_enum_bug_keys = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_enum-bug-keys.js"(exports, module) { + module.exports = "constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(","); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-keys.js + var require_object_keys = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-keys.js"(exports, module) { + var $keys = require_object_keys_internal(); + var enumBugKeys = require_enum_bug_keys(); + module.exports = Object.keys || function keys(O) { + return $keys(O, enumBugKeys); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-dps.js + var require_object_dps = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-dps.js"(exports, module) { + var dP = require_object_dp(); + var anObject = require_an_object(); + var getKeys = require_object_keys(); + module.exports = require_descriptors() ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = getKeys(Properties); + var length = keys.length; + var i = 0; + var P; + while (length > i) + dP.f(O, P = keys[i++], Properties[P]); + return O; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_html.js + var require_html = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_html.js"(exports, module) { + var document2 = require_global().document; + module.exports = document2 && document2.documentElement; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-create.js + var require_object_create = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-create.js"(exports, module) { + var anObject = require_an_object(); + var dPs = require_object_dps(); + var enumBugKeys = require_enum_bug_keys(); + var IE_PROTO = require_shared_key()("IE_PROTO"); + var Empty = function() { + }; + var PROTOTYPE = "prototype"; + var createDict = function() { + var iframe = require_dom_create()("iframe"); + var i = enumBugKeys.length; + var lt = "<"; + var gt = ">"; + var iframeDocument; + iframe.style.display = "none"; + require_html().appendChild(iframe); + iframe.src = "javascript:"; + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(lt + "script" + gt + "document.F=Object" + lt + "/script" + gt); + iframeDocument.close(); + createDict = iframeDocument.F; + while (i--) + delete createDict[PROTOTYPE][enumBugKeys[i]]; + return createDict(); + }; + module.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + Empty[PROTOTYPE] = anObject(O); + result = new Empty(); + Empty[PROTOTYPE] = null; + result[IE_PROTO] = O; + } else + result = createDict(); + return Properties === void 0 ? result : dPs(result, Properties); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_wks.js + var require_wks = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_wks.js"(exports, module) { + var store = require_shared()("wks"); + var uid = require_uid(); + var Symbol2 = require_global().Symbol; + var USE_SYMBOL = typeof Symbol2 == "function"; + var $exports = module.exports = function(name) { + return store[name] || (store[name] = USE_SYMBOL && Symbol2[name] || (USE_SYMBOL ? Symbol2 : uid)("Symbol." + name)); + }; + $exports.store = store; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_set-to-string-tag.js + var require_set_to_string_tag = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_set-to-string-tag.js"(exports, module) { + var def = require_object_dp().f; + var has = require_has(); + var TAG = require_wks()("toStringTag"); + module.exports = function(it, tag, stat) { + if (it && !has(it = stat ? it : it.prototype, TAG)) + def(it, TAG, { configurable: true, value: tag }); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-create.js + var require_iter_create = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-create.js"(exports, module) { + "use strict"; + var create = require_object_create(); + var descriptor = require_property_desc(); + var setToStringTag = require_set_to_string_tag(); + var IteratorPrototype = {}; + require_hide()(IteratorPrototype, require_wks()("iterator"), function() { + return this; + }); + module.exports = function(Constructor, NAME, next) { + Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) }); + setToStringTag(Constructor, NAME + " Iterator"); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-define.js + var require_iter_define = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-define.js"(exports, module) { + "use strict"; + var LIBRARY = require_library(); + var $export = require_export(); + var redefine = require_redefine(); + var hide = require_hide(); + var has = require_has(); + var Iterators = require_iterators(); + var $iterCreate = require_iter_create(); + var setToStringTag = require_set_to_string_tag(); + var getPrototypeOf = require_object_gpo(); + var ITERATOR = require_wks()("iterator"); + var BUGGY = !([].keys && "next" in [].keys()); + var FF_ITERATOR = "@@iterator"; + var KEYS = "keys"; + var VALUES = "values"; + var returnThis = function() { + return this; + }; + module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) { + $iterCreate(Constructor, NAME, next); + var getMethod = function(kind) { + if (!BUGGY && kind in proto) + return proto[kind]; + switch (kind) { + case KEYS: + return function keys() { + return new Constructor(this, kind); + }; + case VALUES: + return function values() { + return new Constructor(this, kind); + }; + } + return function entries() { + return new Constructor(this, kind); + }; + }; + var TAG = NAME + " Iterator"; + var DEF_VALUES = DEFAULT == VALUES; + var VALUES_BUG = false; + var proto = Base.prototype; + var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]; + var $default = !BUGGY && $native || getMethod(DEFAULT); + var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod("entries") : void 0; + var $anyNative = NAME == "Array" ? proto.entries || $native : $native; + var methods, key, IteratorPrototype; + if ($anyNative) { + IteratorPrototype = getPrototypeOf($anyNative.call(new Base())); + if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) { + setToStringTag(IteratorPrototype, TAG, true); + if (!LIBRARY && !has(IteratorPrototype, ITERATOR)) + hide(IteratorPrototype, ITERATOR, returnThis); + } + } + if (DEF_VALUES && $native && $native.name !== VALUES) { + VALUES_BUG = true; + $default = function values() { + return $native.call(this); + }; + } + if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) { + hide(proto, ITERATOR, $default); + } + Iterators[NAME] = $default; + Iterators[TAG] = returnThis; + if (DEFAULT) { + methods = { + values: DEF_VALUES ? $default : getMethod(VALUES), + keys: IS_SET ? $default : getMethod(KEYS), + entries: $entries + }; + if (FORCED) + for (key in methods) { + if (!(key in proto)) + redefine(proto, key, methods[key]); + } + else + $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods); + } + return methods; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es6.string.iterator.js + var require_es6_string_iterator = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es6.string.iterator.js"() { + "use strict"; + var $at = require_string_at()(true); + require_iter_define()(String, "String", function(iterated) { + this._t = String(iterated); + this._i = 0; + }, function() { + var O = this._t; + var index = this._i; + var point2; + if (index >= O.length) + return { value: void 0, done: true }; + point2 = $at(O, index); + this._i += point2.length; + return { value: point2, done: false }; + }); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_add-to-unscopables.js + var require_add_to_unscopables = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_add-to-unscopables.js"(exports, module) { + module.exports = function() { + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-step.js + var require_iter_step = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_iter-step.js"(exports, module) { + module.exports = function(done, value) { + return { value, done: !!done }; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es6.array.iterator.js + var require_es6_array_iterator = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es6.array.iterator.js"(exports, module) { + "use strict"; + var addToUnscopables = require_add_to_unscopables(); + var step = require_iter_step(); + var Iterators = require_iterators(); + var toIObject = require_to_iobject(); + module.exports = require_iter_define()(Array, "Array", function(iterated, kind) { + this._t = toIObject(iterated); + this._i = 0; + this._k = kind; + }, function() { + var O = this._t; + var kind = this._k; + var index = this._i++; + if (!O || index >= O.length) { + this._t = void 0; + return step(1); + } + if (kind == "keys") + return step(0, index); + if (kind == "values") + return step(0, O[index]); + return step(0, [index, O[index]]); + }, "values"); + Iterators.Arguments = Iterators.Array; + addToUnscopables("keys"); + addToUnscopables("values"); + addToUnscopables("entries"); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/web.dom.iterable.js + var require_web_dom_iterable = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/web.dom.iterable.js"() { + require_es6_array_iterator(); + var global2 = require_global(); + var hide = require_hide(); + var Iterators = require_iterators(); + var TO_STRING_TAG = require_wks()("toStringTag"); + var DOMIterables = "CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,TextTrackList,TouchList".split(","); + for (i = 0; i < DOMIterables.length; i++) { + NAME = DOMIterables[i]; + Collection = global2[NAME]; + proto = Collection && Collection.prototype; + if (proto && !proto[TO_STRING_TAG]) + hide(proto, TO_STRING_TAG, NAME); + Iterators[NAME] = Iterators.Array; + } + var NAME; + var Collection; + var proto; + var i; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_wks-ext.js + var require_wks_ext = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_wks-ext.js"(exports) { + exports.f = require_wks(); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/fn/symbol/iterator.js + var require_iterator = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/fn/symbol/iterator.js"(exports, module) { + require_es6_string_iterator(); + require_web_dom_iterable(); + module.exports = require_wks_ext().f("iterator"); + } + }); + + // node_modules/babel-runtime/core-js/symbol/iterator.js + var require_iterator2 = __commonJS({ + "node_modules/babel-runtime/core-js/symbol/iterator.js"(exports, module) { + module.exports = { "default": require_iterator(), __esModule: true }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_meta.js + var require_meta = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_meta.js"(exports, module) { + var META = require_uid()("meta"); + var isObject = require_is_object(); + var has = require_has(); + var setDesc = require_object_dp().f; + var id = 0; + var isExtensible = Object.isExtensible || function() { + return true; + }; + var FREEZE = !require_fails()(function() { + return isExtensible(Object.preventExtensions({})); + }); + var setMeta = function(it) { + setDesc(it, META, { value: { + i: "O" + ++id, + // object ID + w: {} + // weak collections IDs + } }); + }; + var fastKey = function(it, create) { + if (!isObject(it)) + return typeof it == "symbol" ? it : (typeof it == "string" ? "S" : "P") + it; + if (!has(it, META)) { + if (!isExtensible(it)) + return "F"; + if (!create) + return "E"; + setMeta(it); + } + return it[META].i; + }; + var getWeak = function(it, create) { + if (!has(it, META)) { + if (!isExtensible(it)) + return true; + if (!create) + return false; + setMeta(it); + } + return it[META].w; + }; + var onFreeze = function(it) { + if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) + setMeta(it); + return it; + }; + var meta = module.exports = { + KEY: META, + NEED: false, + fastKey, + getWeak, + onFreeze + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_wks-define.js + var require_wks_define = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_wks-define.js"(exports, module) { + var global2 = require_global(); + var core = require_core(); + var LIBRARY = require_library(); + var wksExt = require_wks_ext(); + var defineProperty = require_object_dp().f; + module.exports = function(name) { + var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global2.Symbol || {}); + if (name.charAt(0) != "_" && !(name in $Symbol)) + defineProperty($Symbol, name, { value: wksExt.f(name) }); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gops.js + var require_object_gops = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gops.js"(exports) { + exports.f = Object.getOwnPropertySymbols; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-pie.js + var require_object_pie = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-pie.js"(exports) { + exports.f = {}.propertyIsEnumerable; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_enum-keys.js + var require_enum_keys = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_enum-keys.js"(exports, module) { + var getKeys = require_object_keys(); + var gOPS = require_object_gops(); + var pIE = require_object_pie(); + module.exports = function(it) { + var result = getKeys(it); + var getSymbols = gOPS.f; + if (getSymbols) { + var symbols = getSymbols(it); + var isEnum = pIE.f; + var i = 0; + var key; + while (symbols.length > i) + if (isEnum.call(it, key = symbols[i++])) + result.push(key); + } + return result; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_is-array.js + var require_is_array = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_is-array.js"(exports, module) { + var cof = require_cof(); + module.exports = Array.isArray || function isArray(arg) { + return cof(arg) == "Array"; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gopn.js + var require_object_gopn = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gopn.js"(exports) { + var $keys = require_object_keys_internal(); + var hiddenKeys = require_enum_bug_keys().concat("length", "prototype"); + exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return $keys(O, hiddenKeys); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gopn-ext.js + var require_object_gopn_ext = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gopn-ext.js"(exports, module) { + var toIObject = require_to_iobject(); + var gOPN = require_object_gopn().f; + var toString = {}.toString; + var windowNames = typeof window == "object" && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : []; + var getWindowNames = function(it) { + try { + return gOPN(it); + } catch (e) { + return windowNames.slice(); + } + }; + module.exports.f = function getOwnPropertyNames(it) { + return windowNames && toString.call(it) == "[object Window]" ? getWindowNames(it) : gOPN(toIObject(it)); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gopd.js + var require_object_gopd = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_object-gopd.js"(exports) { + var pIE = require_object_pie(); + var createDesc = require_property_desc(); + var toIObject = require_to_iobject(); + var toPrimitive = require_to_primitive(); + var has = require_has(); + var IE8_DOM_DEFINE = require_ie8_dom_define(); + var gOPD = Object.getOwnPropertyDescriptor; + exports.f = require_descriptors() ? gOPD : function getOwnPropertyDescriptor(O, P) { + O = toIObject(O); + P = toPrimitive(P, true); + if (IE8_DOM_DEFINE) + try { + return gOPD(O, P); + } catch (e) { + } + if (has(O, P)) + return createDesc(!pIE.f.call(O, P), O[P]); + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es6.symbol.js + var require_es6_symbol = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es6.symbol.js"() { + "use strict"; + var global2 = require_global(); + var has = require_has(); + var DESCRIPTORS = require_descriptors(); + var $export = require_export(); + var redefine = require_redefine(); + var META = require_meta().KEY; + var $fails = require_fails(); + var shared = require_shared(); + var setToStringTag = require_set_to_string_tag(); + var uid = require_uid(); + var wks = require_wks(); + var wksExt = require_wks_ext(); + var wksDefine = require_wks_define(); + var enumKeys = require_enum_keys(); + var isArray = require_is_array(); + var anObject = require_an_object(); + var isObject = require_is_object(); + var toIObject = require_to_iobject(); + var toPrimitive = require_to_primitive(); + var createDesc = require_property_desc(); + var _create = require_object_create(); + var gOPNExt = require_object_gopn_ext(); + var $GOPD = require_object_gopd(); + var $DP = require_object_dp(); + var $keys = require_object_keys(); + var gOPD = $GOPD.f; + var dP = $DP.f; + var gOPN = gOPNExt.f; + var $Symbol = global2.Symbol; + var $JSON = global2.JSON; + var _stringify = $JSON && $JSON.stringify; + var PROTOTYPE = "prototype"; + var HIDDEN = wks("_hidden"); + var TO_PRIMITIVE = wks("toPrimitive"); + var isEnum = {}.propertyIsEnumerable; + var SymbolRegistry = shared("symbol-registry"); + var AllSymbols = shared("symbols"); + var OPSymbols = shared("op-symbols"); + var ObjectProto = Object[PROTOTYPE]; + var USE_NATIVE = typeof $Symbol == "function"; + var QObject = global2.QObject; + var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; + var setSymbolDesc = DESCRIPTORS && $fails(function() { + return _create(dP({}, "a", { + get: function() { + return dP(this, "a", { value: 7 }).a; + } + })).a != 7; + }) ? function(it, key, D) { + var protoDesc = gOPD(ObjectProto, key); + if (protoDesc) + delete ObjectProto[key]; + dP(it, key, D); + if (protoDesc && it !== ObjectProto) + dP(ObjectProto, key, protoDesc); + } : dP; + var wrap = function(tag) { + var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]); + sym._k = tag; + return sym; + }; + var isSymbol = USE_NATIVE && typeof $Symbol.iterator == "symbol" ? function(it) { + return typeof it == "symbol"; + } : function(it) { + return it instanceof $Symbol; + }; + var $defineProperty = function defineProperty(it, key, D) { + if (it === ObjectProto) + $defineProperty(OPSymbols, key, D); + anObject(it); + key = toPrimitive(key, true); + anObject(D); + if (has(AllSymbols, key)) { + if (!D.enumerable) { + if (!has(it, HIDDEN)) + dP(it, HIDDEN, createDesc(1, {})); + it[HIDDEN][key] = true; + } else { + if (has(it, HIDDEN) && it[HIDDEN][key]) + it[HIDDEN][key] = false; + D = _create(D, { enumerable: createDesc(0, false) }); + } + return setSymbolDesc(it, key, D); + } + return dP(it, key, D); + }; + var $defineProperties = function defineProperties(it, P) { + anObject(it); + var keys = enumKeys(P = toIObject(P)); + var i = 0; + var l = keys.length; + var key; + while (l > i) + $defineProperty(it, key = keys[i++], P[key]); + return it; + }; + var $create = function create(it, P) { + return P === void 0 ? _create(it) : $defineProperties(_create(it), P); + }; + var $propertyIsEnumerable = function propertyIsEnumerable(key) { + var E = isEnum.call(this, key = toPrimitive(key, true)); + if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) + return false; + return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true; + }; + var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) { + it = toIObject(it); + key = toPrimitive(key, true); + if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) + return; + var D = gOPD(it, key); + if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) + D.enumerable = true; + return D; + }; + var $getOwnPropertyNames = function getOwnPropertyNames(it) { + var names = gOPN(toIObject(it)); + var result = []; + var i = 0; + var key; + while (names.length > i) { + if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) + result.push(key); + } + return result; + }; + var $getOwnPropertySymbols = function getOwnPropertySymbols(it) { + var IS_OP = it === ObjectProto; + var names = gOPN(IS_OP ? OPSymbols : toIObject(it)); + var result = []; + var i = 0; + var key; + while (names.length > i) { + if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) + result.push(AllSymbols[key]); + } + return result; + }; + if (!USE_NATIVE) { + $Symbol = function Symbol2() { + if (this instanceof $Symbol) + throw TypeError("Symbol is not a constructor!"); + var tag = uid(arguments.length > 0 ? arguments[0] : void 0); + var $set = function(value) { + if (this === ObjectProto) + $set.call(OPSymbols, value); + if (has(this, HIDDEN) && has(this[HIDDEN], tag)) + this[HIDDEN][tag] = false; + setSymbolDesc(this, tag, createDesc(1, value)); + }; + if (DESCRIPTORS && setter) + setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set }); + return wrap(tag); + }; + redefine($Symbol[PROTOTYPE], "toString", function toString() { + return this._k; + }); + $GOPD.f = $getOwnPropertyDescriptor; + $DP.f = $defineProperty; + require_object_gopn().f = gOPNExt.f = $getOwnPropertyNames; + require_object_pie().f = $propertyIsEnumerable; + require_object_gops().f = $getOwnPropertySymbols; + if (DESCRIPTORS && !require_library()) { + redefine(ObjectProto, "propertyIsEnumerable", $propertyIsEnumerable, true); + } + wksExt.f = function(name) { + return wrap(wks(name)); + }; + } + $export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol }); + for (es6Symbols = // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14 + "hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables".split(","), j = 0; es6Symbols.length > j; ) + wks(es6Symbols[j++]); + var es6Symbols; + var j; + for (wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k; ) + wksDefine(wellKnownSymbols[k++]); + var wellKnownSymbols; + var k; + $export($export.S + $export.F * !USE_NATIVE, "Symbol", { + // 19.4.2.1 Symbol.for(key) + "for": function(key) { + return has(SymbolRegistry, key += "") ? SymbolRegistry[key] : SymbolRegistry[key] = $Symbol(key); + }, + // 19.4.2.5 Symbol.keyFor(sym) + keyFor: function keyFor(sym) { + if (!isSymbol(sym)) + throw TypeError(sym + " is not a symbol!"); + for (var key in SymbolRegistry) + if (SymbolRegistry[key] === sym) + return key; + }, + useSetter: function() { + setter = true; + }, + useSimple: function() { + setter = false; + } + }); + $export($export.S + $export.F * !USE_NATIVE, "Object", { + // 19.1.2.2 Object.create(O [, Properties]) + create: $create, + // 19.1.2.4 Object.defineProperty(O, P, Attributes) + defineProperty: $defineProperty, + // 19.1.2.3 Object.defineProperties(O, Properties) + defineProperties: $defineProperties, + // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) + getOwnPropertyDescriptor: $getOwnPropertyDescriptor, + // 19.1.2.7 Object.getOwnPropertyNames(O) + getOwnPropertyNames: $getOwnPropertyNames, + // 19.1.2.8 Object.getOwnPropertySymbols(O) + getOwnPropertySymbols: $getOwnPropertySymbols + }); + $JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function() { + var S = $Symbol(); + return _stringify([S]) != "[null]" || _stringify({ a: S }) != "{}" || _stringify(Object(S)) != "{}"; + })), "JSON", { + stringify: function stringify(it) { + var args = [it]; + var i = 1; + var replacer, $replacer; + while (arguments.length > i) + args.push(arguments[i++]); + $replacer = replacer = args[1]; + if (!isObject(replacer) && it === void 0 || isSymbol(it)) + return; + if (!isArray(replacer)) + replacer = function(key, value) { + if (typeof $replacer == "function") + value = $replacer.call(this, key, value); + if (!isSymbol(value)) + return value; + }; + args[1] = replacer; + return _stringify.apply($JSON, args); + } + }); + $Symbol[PROTOTYPE][TO_PRIMITIVE] || require_hide()($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf); + setToStringTag($Symbol, "Symbol"); + setToStringTag(Math, "Math", true); + setToStringTag(global2.JSON, "JSON", true); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.to-string.js + var require_es6_object_to_string = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.to-string.js"() { + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es7.symbol.async-iterator.js + var require_es7_symbol_async_iterator = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es7.symbol.async-iterator.js"() { + require_wks_define()("asyncIterator"); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es7.symbol.observable.js + var require_es7_symbol_observable = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es7.symbol.observable.js"() { + require_wks_define()("observable"); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/fn/symbol/index.js + var require_symbol = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/fn/symbol/index.js"(exports, module) { + require_es6_symbol(); + require_es6_object_to_string(); + require_es7_symbol_async_iterator(); + require_es7_symbol_observable(); + module.exports = require_core().Symbol; + } + }); + + // node_modules/babel-runtime/core-js/symbol.js + var require_symbol2 = __commonJS({ + "node_modules/babel-runtime/core-js/symbol.js"(exports, module) { + module.exports = { "default": require_symbol(), __esModule: true }; + } + }); + + // node_modules/babel-runtime/helpers/typeof.js + var require_typeof = __commonJS({ + "node_modules/babel-runtime/helpers/typeof.js"(exports) { + "use strict"; + exports.__esModule = true; + var _iterator = require_iterator2(); + var _iterator2 = _interopRequireDefault(_iterator); + var _symbol = require_symbol2(); + var _symbol2 = _interopRequireDefault(_symbol); + var _typeof = typeof _symbol2.default === "function" && typeof _iterator2.default === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj; + }; + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + exports.default = typeof _symbol2.default === "function" && _typeof(_iterator2.default) === "symbol" ? function(obj) { + return typeof obj === "undefined" ? "undefined" : _typeof(obj); + } : function(obj) { + return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj); + }; + } + }); + + // node_modules/babel-runtime/helpers/possibleConstructorReturn.js + var require_possibleConstructorReturn = __commonJS({ + "node_modules/babel-runtime/helpers/possibleConstructorReturn.js"(exports) { + "use strict"; + exports.__esModule = true; + var _typeof2 = require_typeof(); + var _typeof3 = _interopRequireDefault(_typeof2); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + exports.default = function(self2, call) { + if (!self2) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return call && ((typeof call === "undefined" ? "undefined" : (0, _typeof3.default)(call)) === "object" || typeof call === "function") ? call : self2; + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/_set-proto.js + var require_set_proto = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/_set-proto.js"(exports, module) { + var isObject = require_is_object(); + var anObject = require_an_object(); + var check = function(O, proto) { + anObject(O); + if (!isObject(proto) && proto !== null) + throw TypeError(proto + ": can't set as prototype!"); + }; + module.exports = { + set: Object.setPrototypeOf || ("__proto__" in {} ? ( + // eslint-disable-line + function(test, buggy, set) { + try { + set = require_ctx()(Function.call, require_object_gopd().f(Object.prototype, "__proto__").set, 2); + set(test, []); + buggy = !(test instanceof Array); + } catch (e) { + buggy = true; + } + return function setPrototypeOf(O, proto) { + check(O, proto); + if (buggy) + O.__proto__ = proto; + else + set(O, proto); + return O; + }; + }({}, false) + ) : void 0), + check + }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.set-prototype-of.js + var require_es6_object_set_prototype_of = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.set-prototype-of.js"() { + var $export = require_export(); + $export($export.S, "Object", { setPrototypeOf: require_set_proto().set }); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/fn/object/set-prototype-of.js + var require_set_prototype_of = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/fn/object/set-prototype-of.js"(exports, module) { + require_es6_object_set_prototype_of(); + module.exports = require_core().Object.setPrototypeOf; + } + }); + + // node_modules/babel-runtime/core-js/object/set-prototype-of.js + var require_set_prototype_of2 = __commonJS({ + "node_modules/babel-runtime/core-js/object/set-prototype-of.js"(exports, module) { + module.exports = { "default": require_set_prototype_of(), __esModule: true }; + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.create.js + var require_es6_object_create = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/modules/es6.object.create.js"() { + var $export = require_export(); + $export($export.S, "Object", { create: require_object_create() }); + } + }); + + // node_modules/babel-runtime/node_modules/core-js/library/fn/object/create.js + var require_create = __commonJS({ + "node_modules/babel-runtime/node_modules/core-js/library/fn/object/create.js"(exports, module) { + require_es6_object_create(); + var $Object = require_core().Object; + module.exports = function create(P, D) { + return $Object.create(P, D); + }; + } + }); + + // node_modules/babel-runtime/core-js/object/create.js + var require_create2 = __commonJS({ + "node_modules/babel-runtime/core-js/object/create.js"(exports, module) { + module.exports = { "default": require_create(), __esModule: true }; + } + }); + + // node_modules/babel-runtime/helpers/inherits.js + var require_inherits = __commonJS({ + "node_modules/babel-runtime/helpers/inherits.js"(exports) { + "use strict"; + exports.__esModule = true; + var _setPrototypeOf = require_set_prototype_of2(); + var _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf); + var _create = require_create2(); + var _create2 = _interopRequireDefault(_create); + var _typeof2 = require_typeof(); + var _typeof3 = _interopRequireDefault(_typeof2); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + exports.default = function(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : (0, _typeof3.default)(superClass))); + } + subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) + _setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass; + }; + } + }); + + // node_modules/lodash/identity.js + var require_identity = __commonJS({ + "node_modules/lodash/identity.js"(exports, module) { + function identity(value) { + return value; + } + module.exports = identity; + } + }); + + // node_modules/lodash/_apply.js + var require_apply = __commonJS({ + "node_modules/lodash/_apply.js"(exports, module) { + function apply(func, thisArg, args) { + switch (args.length) { + case 0: + return func.call(thisArg); + case 1: + return func.call(thisArg, args[0]); + case 2: + return func.call(thisArg, args[0], args[1]); + case 3: + return func.call(thisArg, args[0], args[1], args[2]); + } + return func.apply(thisArg, args); + } + module.exports = apply; + } + }); + + // node_modules/lodash/_overRest.js + var require_overRest = __commonJS({ + "node_modules/lodash/_overRest.js"(exports, module) { + var apply = require_apply(); + var nativeMax = Math.max; + function overRest(func, start, transform) { + start = nativeMax(start === void 0 ? func.length - 1 : start, 0); + return function() { + var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length); + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = transform(array); + return apply(func, this, otherArgs); + }; + } + module.exports = overRest; + } + }); + + // node_modules/lodash/constant.js + var require_constant = __commonJS({ + "node_modules/lodash/constant.js"(exports, module) { + function constant(value) { + return function() { + return value; + }; + } + module.exports = constant; + } + }); + + // node_modules/lodash/_freeGlobal.js + var require_freeGlobal = __commonJS({ + "node_modules/lodash/_freeGlobal.js"(exports, module) { + var freeGlobal = typeof global == "object" && global && global.Object === Object && global; + module.exports = freeGlobal; + } + }); + + // node_modules/lodash/_root.js + var require_root = __commonJS({ + "node_modules/lodash/_root.js"(exports, module) { + var freeGlobal = require_freeGlobal(); + var freeSelf = typeof self == "object" && self && self.Object === Object && self; + var root = freeGlobal || freeSelf || Function("return this")(); + module.exports = root; + } + }); + + // node_modules/lodash/_Symbol.js + var require_Symbol = __commonJS({ + "node_modules/lodash/_Symbol.js"(exports, module) { + var root = require_root(); + var Symbol2 = root.Symbol; + module.exports = Symbol2; + } + }); + + // node_modules/lodash/_getRawTag.js + var require_getRawTag = __commonJS({ + "node_modules/lodash/_getRawTag.js"(exports, module) { + var Symbol2 = require_Symbol(); + var objectProto = Object.prototype; + var hasOwnProperty = objectProto.hasOwnProperty; + var nativeObjectToString = objectProto.toString; + var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0; + function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag]; + try { + value[symToStringTag] = void 0; + var unmasked = true; + } catch (e) { + } + var result = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + return result; + } + module.exports = getRawTag; + } + }); + + // node_modules/lodash/_objectToString.js + var require_objectToString = __commonJS({ + "node_modules/lodash/_objectToString.js"(exports, module) { + var objectProto = Object.prototype; + var nativeObjectToString = objectProto.toString; + function objectToString(value) { + return nativeObjectToString.call(value); + } + module.exports = objectToString; + } + }); + + // node_modules/lodash/_baseGetTag.js + var require_baseGetTag = __commonJS({ + "node_modules/lodash/_baseGetTag.js"(exports, module) { + var Symbol2 = require_Symbol(); + var getRawTag = require_getRawTag(); + var objectToString = require_objectToString(); + var nullTag = "[object Null]"; + var undefinedTag = "[object Undefined]"; + var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0; + function baseGetTag(value) { + if (value == null) { + return value === void 0 ? undefinedTag : nullTag; + } + return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value); + } + module.exports = baseGetTag; + } + }); + + // node_modules/lodash/isObject.js + var require_isObject = __commonJS({ + "node_modules/lodash/isObject.js"(exports, module) { + function isObject(value) { + var type = typeof value; + return value != null && (type == "object" || type == "function"); + } + module.exports = isObject; + } + }); + + // node_modules/lodash/isFunction.js + var require_isFunction = __commonJS({ + "node_modules/lodash/isFunction.js"(exports, module) { + var baseGetTag = require_baseGetTag(); + var isObject = require_isObject(); + var asyncTag = "[object AsyncFunction]"; + var funcTag = "[object Function]"; + var genTag = "[object GeneratorFunction]"; + var proxyTag = "[object Proxy]"; + function isFunction(value) { + if (!isObject(value)) { + return false; + } + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; + } + module.exports = isFunction; + } + }); + + // node_modules/lodash/_coreJsData.js + var require_coreJsData = __commonJS({ + "node_modules/lodash/_coreJsData.js"(exports, module) { + var root = require_root(); + var coreJsData = root["__core-js_shared__"]; + module.exports = coreJsData; + } + }); + + // node_modules/lodash/_isMasked.js + var require_isMasked = __commonJS({ + "node_modules/lodash/_isMasked.js"(exports, module) { + var coreJsData = require_coreJsData(); + var maskSrcKey = function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ""); + return uid ? "Symbol(src)_1." + uid : ""; + }(); + function isMasked(func) { + return !!maskSrcKey && maskSrcKey in func; + } + module.exports = isMasked; + } + }); + + // node_modules/lodash/_toSource.js + var require_toSource = __commonJS({ + "node_modules/lodash/_toSource.js"(exports, module) { + var funcProto = Function.prototype; + var funcToString = funcProto.toString; + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) { + } + try { + return func + ""; + } catch (e) { + } + } + return ""; + } + module.exports = toSource; + } + }); + + // node_modules/lodash/_baseIsNative.js + var require_baseIsNative = __commonJS({ + "node_modules/lodash/_baseIsNative.js"(exports, module) { + var isFunction = require_isFunction(); + var isMasked = require_isMasked(); + var isObject = require_isObject(); + var toSource = require_toSource(); + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + var reIsHostCtor = /^\[object .+?Constructor\]$/; + var funcProto = Function.prototype; + var objectProto = Object.prototype; + var funcToString = funcProto.toString; + var hasOwnProperty = objectProto.hasOwnProperty; + var reIsNative = RegExp( + "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$" + ); + function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + module.exports = baseIsNative; + } + }); + + // node_modules/lodash/_getValue.js + var require_getValue = __commonJS({ + "node_modules/lodash/_getValue.js"(exports, module) { + function getValue(object, key) { + return object == null ? void 0 : object[key]; + } + module.exports = getValue; + } + }); + + // node_modules/lodash/_getNative.js + var require_getNative = __commonJS({ + "node_modules/lodash/_getNative.js"(exports, module) { + var baseIsNative = require_baseIsNative(); + var getValue = require_getValue(); + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : void 0; + } + module.exports = getNative; + } + }); + + // node_modules/lodash/_defineProperty.js + var require_defineProperty = __commonJS({ + "node_modules/lodash/_defineProperty.js"(exports, module) { + var getNative = require_getNative(); + var defineProperty = function() { + try { + var func = getNative(Object, "defineProperty"); + func({}, "", {}); + return func; + } catch (e) { + } + }(); + module.exports = defineProperty; + } + }); + + // node_modules/lodash/_baseSetToString.js + var require_baseSetToString = __commonJS({ + "node_modules/lodash/_baseSetToString.js"(exports, module) { + var constant = require_constant(); + var defineProperty = require_defineProperty(); + var identity = require_identity(); + var baseSetToString = !defineProperty ? identity : function(func, string) { + return defineProperty(func, "toString", { + "configurable": true, + "enumerable": false, + "value": constant(string), + "writable": true + }); + }; + module.exports = baseSetToString; + } + }); + + // node_modules/lodash/_shortOut.js + var require_shortOut = __commonJS({ + "node_modules/lodash/_shortOut.js"(exports, module) { + var HOT_COUNT = 800; + var HOT_SPAN = 16; + var nativeNow = Date.now; + function shortOut(func) { + var count = 0, lastCalled = 0; + return function() { + var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled); + lastCalled = stamp; + if (remaining > 0) { + if (++count >= HOT_COUNT) { + return arguments[0]; + } + } else { + count = 0; + } + return func.apply(void 0, arguments); + }; + } + module.exports = shortOut; + } + }); + + // node_modules/lodash/_setToString.js + var require_setToString = __commonJS({ + "node_modules/lodash/_setToString.js"(exports, module) { + var baseSetToString = require_baseSetToString(); + var shortOut = require_shortOut(); + var setToString = shortOut(baseSetToString); + module.exports = setToString; + } + }); + + // node_modules/lodash/_baseRest.js + var require_baseRest = __commonJS({ + "node_modules/lodash/_baseRest.js"(exports, module) { + var identity = require_identity(); + var overRest = require_overRest(); + var setToString = require_setToString(); + function baseRest(func, start) { + return setToString(overRest(func, start, identity), func + ""); + } + module.exports = baseRest; + } + }); + + // node_modules/lodash/_WeakMap.js + var require_WeakMap = __commonJS({ + "node_modules/lodash/_WeakMap.js"(exports, module) { + var getNative = require_getNative(); + var root = require_root(); + var WeakMap = getNative(root, "WeakMap"); + module.exports = WeakMap; + } + }); + + // node_modules/lodash/_metaMap.js + var require_metaMap = __commonJS({ + "node_modules/lodash/_metaMap.js"(exports, module) { + var WeakMap = require_WeakMap(); + var metaMap = WeakMap && new WeakMap(); + module.exports = metaMap; + } + }); + + // node_modules/lodash/_baseSetData.js + var require_baseSetData = __commonJS({ + "node_modules/lodash/_baseSetData.js"(exports, module) { + var identity = require_identity(); + var metaMap = require_metaMap(); + var baseSetData = !metaMap ? identity : function(func, data) { + metaMap.set(func, data); + return func; + }; + module.exports = baseSetData; + } + }); + + // node_modules/lodash/_baseCreate.js + var require_baseCreate = __commonJS({ + "node_modules/lodash/_baseCreate.js"(exports, module) { + var isObject = require_isObject(); + var objectCreate = Object.create; + var baseCreate = function() { + function object() { + } + return function(proto) { + if (!isObject(proto)) { + return {}; + } + if (objectCreate) { + return objectCreate(proto); + } + object.prototype = proto; + var result = new object(); + object.prototype = void 0; + return result; + }; + }(); + module.exports = baseCreate; + } + }); + + // node_modules/lodash/_createCtor.js + var require_createCtor = __commonJS({ + "node_modules/lodash/_createCtor.js"(exports, module) { + var baseCreate = require_baseCreate(); + var isObject = require_isObject(); + function createCtor(Ctor) { + return function() { + var args = arguments; + switch (args.length) { + case 0: + return new Ctor(); + case 1: + return new Ctor(args[0]); + case 2: + return new Ctor(args[0], args[1]); + case 3: + return new Ctor(args[0], args[1], args[2]); + case 4: + return new Ctor(args[0], args[1], args[2], args[3]); + case 5: + return new Ctor(args[0], args[1], args[2], args[3], args[4]); + case 6: + return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]); + case 7: + return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); + } + var thisBinding = baseCreate(Ctor.prototype), result = Ctor.apply(thisBinding, args); + return isObject(result) ? result : thisBinding; + }; + } + module.exports = createCtor; + } + }); + + // node_modules/lodash/_createBind.js + var require_createBind = __commonJS({ + "node_modules/lodash/_createBind.js"(exports, module) { + var createCtor = require_createCtor(); + var root = require_root(); + var WRAP_BIND_FLAG = 1; + function createBind(func, bitmask, thisArg) { + var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func); + function wrapper() { + var fn = this && this !== root && this instanceof wrapper ? Ctor : func; + return fn.apply(isBind ? thisArg : this, arguments); + } + return wrapper; + } + module.exports = createBind; + } + }); + + // node_modules/lodash/_composeArgs.js + var require_composeArgs = __commonJS({ + "node_modules/lodash/_composeArgs.js"(exports, module) { + var nativeMax = Math.max; + function composeArgs(args, partials, holders, isCurried) { + var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result = Array(leftLength + rangeLength), isUncurried = !isCurried; + while (++leftIndex < leftLength) { + result[leftIndex] = partials[leftIndex]; + } + while (++argsIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[holders[argsIndex]] = args[argsIndex]; + } + } + while (rangeLength--) { + result[leftIndex++] = args[argsIndex++]; + } + return result; + } + module.exports = composeArgs; + } + }); + + // node_modules/lodash/_composeArgsRight.js + var require_composeArgsRight = __commonJS({ + "node_modules/lodash/_composeArgsRight.js"(exports, module) { + var nativeMax = Math.max; + function composeArgsRight(args, partials, holders, isCurried) { + var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result = Array(rangeLength + rightLength), isUncurried = !isCurried; + while (++argsIndex < rangeLength) { + result[argsIndex] = args[argsIndex]; + } + var offset = argsIndex; + while (++rightIndex < rightLength) { + result[offset + rightIndex] = partials[rightIndex]; + } + while (++holdersIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[offset + holders[holdersIndex]] = args[argsIndex++]; + } + } + return result; + } + module.exports = composeArgsRight; + } + }); + + // node_modules/lodash/_countHolders.js + var require_countHolders = __commonJS({ + "node_modules/lodash/_countHolders.js"(exports, module) { + function countHolders(array, placeholder) { + var length = array.length, result = 0; + while (length--) { + if (array[length] === placeholder) { + ++result; + } + } + return result; + } + module.exports = countHolders; + } + }); + + // node_modules/lodash/_baseLodash.js + var require_baseLodash = __commonJS({ + "node_modules/lodash/_baseLodash.js"(exports, module) { + function baseLodash() { + } + module.exports = baseLodash; + } + }); + + // node_modules/lodash/_LazyWrapper.js + var require_LazyWrapper = __commonJS({ + "node_modules/lodash/_LazyWrapper.js"(exports, module) { + var baseCreate = require_baseCreate(); + var baseLodash = require_baseLodash(); + var MAX_ARRAY_LENGTH = 4294967295; + function LazyWrapper(value) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__dir__ = 1; + this.__filtered__ = false; + this.__iteratees__ = []; + this.__takeCount__ = MAX_ARRAY_LENGTH; + this.__views__ = []; + } + LazyWrapper.prototype = baseCreate(baseLodash.prototype); + LazyWrapper.prototype.constructor = LazyWrapper; + module.exports = LazyWrapper; + } + }); + + // node_modules/lodash/noop.js + var require_noop = __commonJS({ + "node_modules/lodash/noop.js"(exports, module) { + function noop() { + } + module.exports = noop; + } + }); + + // node_modules/lodash/_getData.js + var require_getData = __commonJS({ + "node_modules/lodash/_getData.js"(exports, module) { + var metaMap = require_metaMap(); + var noop = require_noop(); + var getData = !metaMap ? noop : function(func) { + return metaMap.get(func); + }; + module.exports = getData; + } + }); + + // node_modules/lodash/_realNames.js + var require_realNames = __commonJS({ + "node_modules/lodash/_realNames.js"(exports, module) { + var realNames = {}; + module.exports = realNames; + } + }); + + // node_modules/lodash/_getFuncName.js + var require_getFuncName = __commonJS({ + "node_modules/lodash/_getFuncName.js"(exports, module) { + var realNames = require_realNames(); + var objectProto = Object.prototype; + var hasOwnProperty = objectProto.hasOwnProperty; + function getFuncName(func) { + var result = func.name + "", array = realNames[result], length = hasOwnProperty.call(realNames, result) ? array.length : 0; + while (length--) { + var data = array[length], otherFunc = data.func; + if (otherFunc == null || otherFunc == func) { + return data.name; + } + } + return result; + } + module.exports = getFuncName; + } + }); + + // node_modules/lodash/_LodashWrapper.js + var require_LodashWrapper = __commonJS({ + "node_modules/lodash/_LodashWrapper.js"(exports, module) { + var baseCreate = require_baseCreate(); + var baseLodash = require_baseLodash(); + function LodashWrapper(value, chainAll) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__chain__ = !!chainAll; + this.__index__ = 0; + this.__values__ = void 0; + } + LodashWrapper.prototype = baseCreate(baseLodash.prototype); + LodashWrapper.prototype.constructor = LodashWrapper; + module.exports = LodashWrapper; + } + }); + + // node_modules/lodash/isArray.js + var require_isArray = __commonJS({ + "node_modules/lodash/isArray.js"(exports, module) { + var isArray = Array.isArray; + module.exports = isArray; + } + }); + + // node_modules/lodash/isObjectLike.js + var require_isObjectLike = __commonJS({ + "node_modules/lodash/isObjectLike.js"(exports, module) { + function isObjectLike(value) { + return value != null && typeof value == "object"; + } + module.exports = isObjectLike; + } + }); + + // node_modules/lodash/_copyArray.js + var require_copyArray = __commonJS({ + "node_modules/lodash/_copyArray.js"(exports, module) { + function copyArray(source, array) { + var index = -1, length = source.length; + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; + } + module.exports = copyArray; + } + }); + + // node_modules/lodash/_wrapperClone.js + var require_wrapperClone = __commonJS({ + "node_modules/lodash/_wrapperClone.js"(exports, module) { + var LazyWrapper = require_LazyWrapper(); + var LodashWrapper = require_LodashWrapper(); + var copyArray = require_copyArray(); + function wrapperClone(wrapper) { + if (wrapper instanceof LazyWrapper) { + return wrapper.clone(); + } + var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__); + result.__actions__ = copyArray(wrapper.__actions__); + result.__index__ = wrapper.__index__; + result.__values__ = wrapper.__values__; + return result; + } + module.exports = wrapperClone; + } + }); + + // node_modules/lodash/wrapperLodash.js + var require_wrapperLodash = __commonJS({ + "node_modules/lodash/wrapperLodash.js"(exports, module) { + var LazyWrapper = require_LazyWrapper(); + var LodashWrapper = require_LodashWrapper(); + var baseLodash = require_baseLodash(); + var isArray = require_isArray(); + var isObjectLike = require_isObjectLike(); + var wrapperClone = require_wrapperClone(); + var objectProto = Object.prototype; + var hasOwnProperty = objectProto.hasOwnProperty; + function lodash(value) { + if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) { + if (value instanceof LodashWrapper) { + return value; + } + if (hasOwnProperty.call(value, "__wrapped__")) { + return wrapperClone(value); + } + } + return new LodashWrapper(value); + } + lodash.prototype = baseLodash.prototype; + lodash.prototype.constructor = lodash; + module.exports = lodash; + } + }); + + // node_modules/lodash/_isLaziable.js + var require_isLaziable = __commonJS({ + "node_modules/lodash/_isLaziable.js"(exports, module) { + var LazyWrapper = require_LazyWrapper(); + var getData = require_getData(); + var getFuncName = require_getFuncName(); + var lodash = require_wrapperLodash(); + function isLaziable(func) { + var funcName = getFuncName(func), other = lodash[funcName]; + if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) { + return false; + } + if (func === other) { + return true; + } + var data = getData(other); + return !!data && func === data[0]; + } + module.exports = isLaziable; + } + }); + + // node_modules/lodash/_setData.js + var require_setData = __commonJS({ + "node_modules/lodash/_setData.js"(exports, module) { + var baseSetData = require_baseSetData(); + var shortOut = require_shortOut(); + var setData = shortOut(baseSetData); + module.exports = setData; + } + }); + + // node_modules/lodash/_getWrapDetails.js + var require_getWrapDetails = __commonJS({ + "node_modules/lodash/_getWrapDetails.js"(exports, module) { + var reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/; + var reSplitDetails = /,? & /; + function getWrapDetails(source) { + var match = source.match(reWrapDetails); + return match ? match[1].split(reSplitDetails) : []; + } + module.exports = getWrapDetails; + } + }); + + // node_modules/lodash/_insertWrapDetails.js + var require_insertWrapDetails = __commonJS({ + "node_modules/lodash/_insertWrapDetails.js"(exports, module) { + var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/; + function insertWrapDetails(source, details) { + var length = details.length; + if (!length) { + return source; + } + var lastIndex = length - 1; + details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex]; + details = details.join(length > 2 ? ", " : " "); + return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n"); + } + module.exports = insertWrapDetails; + } + }); + + // node_modules/lodash/_arrayEach.js + var require_arrayEach = __commonJS({ + "node_modules/lodash/_arrayEach.js"(exports, module) { + function arrayEach(array, iteratee) { + var index = -1, length = array == null ? 0 : array.length; + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + return array; + } + module.exports = arrayEach; + } + }); + + // node_modules/lodash/_baseFindIndex.js + var require_baseFindIndex = __commonJS({ + "node_modules/lodash/_baseFindIndex.js"(exports, module) { + function baseFindIndex(array, predicate, fromIndex, fromRight) { + var length = array.length, index = fromIndex + (fromRight ? 1 : -1); + while (fromRight ? index-- : ++index < length) { + if (predicate(array[index], index, array)) { + return index; + } + } + return -1; + } + module.exports = baseFindIndex; + } + }); + + // node_modules/lodash/_baseIsNaN.js + var require_baseIsNaN = __commonJS({ + "node_modules/lodash/_baseIsNaN.js"(exports, module) { + function baseIsNaN(value) { + return value !== value; + } + module.exports = baseIsNaN; + } + }); + + // node_modules/lodash/_strictIndexOf.js + var require_strictIndexOf = __commonJS({ + "node_modules/lodash/_strictIndexOf.js"(exports, module) { + function strictIndexOf(array, value, fromIndex) { + var index = fromIndex - 1, length = array.length; + while (++index < length) { + if (array[index] === value) { + return index; + } + } + return -1; + } + module.exports = strictIndexOf; + } + }); + + // node_modules/lodash/_baseIndexOf.js + var require_baseIndexOf = __commonJS({ + "node_modules/lodash/_baseIndexOf.js"(exports, module) { + var baseFindIndex = require_baseFindIndex(); + var baseIsNaN = require_baseIsNaN(); + var strictIndexOf = require_strictIndexOf(); + function baseIndexOf(array, value, fromIndex) { + return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex); + } + module.exports = baseIndexOf; + } + }); + + // node_modules/lodash/_arrayIncludes.js + var require_arrayIncludes = __commonJS({ + "node_modules/lodash/_arrayIncludes.js"(exports, module) { + var baseIndexOf = require_baseIndexOf(); + function arrayIncludes(array, value) { + var length = array == null ? 0 : array.length; + return !!length && baseIndexOf(array, value, 0) > -1; + } + module.exports = arrayIncludes; + } + }); + + // node_modules/lodash/_updateWrapDetails.js + var require_updateWrapDetails = __commonJS({ + "node_modules/lodash/_updateWrapDetails.js"(exports, module) { + var arrayEach = require_arrayEach(); + var arrayIncludes = require_arrayIncludes(); + var WRAP_BIND_FLAG = 1; + var WRAP_BIND_KEY_FLAG = 2; + var WRAP_CURRY_FLAG = 8; + var WRAP_CURRY_RIGHT_FLAG = 16; + var WRAP_PARTIAL_FLAG = 32; + var WRAP_PARTIAL_RIGHT_FLAG = 64; + var WRAP_ARY_FLAG = 128; + var WRAP_REARG_FLAG = 256; + var WRAP_FLIP_FLAG = 512; + var wrapFlags = [ + ["ary", WRAP_ARY_FLAG], + ["bind", WRAP_BIND_FLAG], + ["bindKey", WRAP_BIND_KEY_FLAG], + ["curry", WRAP_CURRY_FLAG], + ["curryRight", WRAP_CURRY_RIGHT_FLAG], + ["flip", WRAP_FLIP_FLAG], + ["partial", WRAP_PARTIAL_FLAG], + ["partialRight", WRAP_PARTIAL_RIGHT_FLAG], + ["rearg", WRAP_REARG_FLAG] + ]; + function updateWrapDetails(details, bitmask) { + arrayEach(wrapFlags, function(pair) { + var value = "_." + pair[0]; + if (bitmask & pair[1] && !arrayIncludes(details, value)) { + details.push(value); + } + }); + return details.sort(); + } + module.exports = updateWrapDetails; + } + }); + + // node_modules/lodash/_setWrapToString.js + var require_setWrapToString = __commonJS({ + "node_modules/lodash/_setWrapToString.js"(exports, module) { + var getWrapDetails = require_getWrapDetails(); + var insertWrapDetails = require_insertWrapDetails(); + var setToString = require_setToString(); + var updateWrapDetails = require_updateWrapDetails(); + function setWrapToString(wrapper, reference, bitmask) { + var source = reference + ""; + return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask))); + } + module.exports = setWrapToString; + } + }); + + // node_modules/lodash/_createRecurry.js + var require_createRecurry = __commonJS({ + "node_modules/lodash/_createRecurry.js"(exports, module) { + var isLaziable = require_isLaziable(); + var setData = require_setData(); + var setWrapToString = require_setWrapToString(); + var WRAP_BIND_FLAG = 1; + var WRAP_BIND_KEY_FLAG = 2; + var WRAP_CURRY_BOUND_FLAG = 4; + var WRAP_CURRY_FLAG = 8; + var WRAP_PARTIAL_FLAG = 32; + var WRAP_PARTIAL_RIGHT_FLAG = 64; + function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) { + var isCurry = bitmask & WRAP_CURRY_FLAG, newHolders = isCurry ? holders : void 0, newHoldersRight = isCurry ? void 0 : holders, newPartials = isCurry ? partials : void 0, newPartialsRight = isCurry ? void 0 : partials; + bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG; + bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG); + if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { + bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG); + } + var newData = [ + func, + bitmask, + thisArg, + newPartials, + newHolders, + newPartialsRight, + newHoldersRight, + argPos, + ary, + arity + ]; + var result = wrapFunc.apply(void 0, newData); + if (isLaziable(func)) { + setData(result, newData); + } + result.placeholder = placeholder; + return setWrapToString(result, func, bitmask); + } + module.exports = createRecurry; + } + }); + + // node_modules/lodash/_getHolder.js + var require_getHolder = __commonJS({ + "node_modules/lodash/_getHolder.js"(exports, module) { + function getHolder(func) { + var object = func; + return object.placeholder; + } + module.exports = getHolder; + } + }); + + // node_modules/lodash/_isIndex.js + var require_isIndex = __commonJS({ + "node_modules/lodash/_isIndex.js"(exports, module) { + var MAX_SAFE_INTEGER = 9007199254740991; + var reIsUint = /^(?:0|[1-9]\d*)$/; + function isIndex(value, length) { + var type = typeof value; + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length); + } + module.exports = isIndex; + } + }); + + // node_modules/lodash/_reorder.js + var require_reorder = __commonJS({ + "node_modules/lodash/_reorder.js"(exports, module) { + var copyArray = require_copyArray(); + var isIndex = require_isIndex(); + var nativeMin = Math.min; + function reorder(array, indexes) { + var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array); + while (length--) { + var index = indexes[length]; + array[length] = isIndex(index, arrLength) ? oldArray[index] : void 0; + } + return array; + } + module.exports = reorder; + } + }); + + // node_modules/lodash/_replaceHolders.js + var require_replaceHolders = __commonJS({ + "node_modules/lodash/_replaceHolders.js"(exports, module) { + var PLACEHOLDER = "__lodash_placeholder__"; + function replaceHolders(array, placeholder) { + var index = -1, length = array.length, resIndex = 0, result = []; + while (++index < length) { + var value = array[index]; + if (value === placeholder || value === PLACEHOLDER) { + array[index] = PLACEHOLDER; + result[resIndex++] = index; + } + } + return result; + } + module.exports = replaceHolders; + } + }); + + // node_modules/lodash/_createHybrid.js + var require_createHybrid = __commonJS({ + "node_modules/lodash/_createHybrid.js"(exports, module) { + var composeArgs = require_composeArgs(); + var composeArgsRight = require_composeArgsRight(); + var countHolders = require_countHolders(); + var createCtor = require_createCtor(); + var createRecurry = require_createRecurry(); + var getHolder = require_getHolder(); + var reorder = require_reorder(); + var replaceHolders = require_replaceHolders(); + var root = require_root(); + var WRAP_BIND_FLAG = 1; + var WRAP_BIND_KEY_FLAG = 2; + var WRAP_CURRY_FLAG = 8; + var WRAP_CURRY_RIGHT_FLAG = 16; + var WRAP_ARY_FLAG = 128; + var WRAP_FLIP_FLAG = 512; + function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) { + var isAry = bitmask & WRAP_ARY_FLAG, isBind = bitmask & WRAP_BIND_FLAG, isBindKey = bitmask & WRAP_BIND_KEY_FLAG, isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? void 0 : createCtor(func); + function wrapper() { + var length = arguments.length, args = Array(length), index = length; + while (index--) { + args[index] = arguments[index]; + } + if (isCurried) { + var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder); + } + if (partials) { + args = composeArgs(args, partials, holders, isCurried); + } + if (partialsRight) { + args = composeArgsRight(args, partialsRight, holdersRight, isCurried); + } + length -= holdersCount; + if (isCurried && length < arity) { + var newHolders = replaceHolders(args, placeholder); + return createRecurry( + func, + bitmask, + createHybrid, + wrapper.placeholder, + thisArg, + args, + newHolders, + argPos, + ary, + arity - length + ); + } + var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func; + length = args.length; + if (argPos) { + args = reorder(args, argPos); + } else if (isFlip && length > 1) { + args.reverse(); + } + if (isAry && ary < length) { + args.length = ary; + } + if (this && this !== root && this instanceof wrapper) { + fn = Ctor || createCtor(fn); + } + return fn.apply(thisBinding, args); + } + return wrapper; + } + module.exports = createHybrid; + } + }); + + // node_modules/lodash/_createCurry.js + var require_createCurry = __commonJS({ + "node_modules/lodash/_createCurry.js"(exports, module) { + var apply = require_apply(); + var createCtor = require_createCtor(); + var createHybrid = require_createHybrid(); + var createRecurry = require_createRecurry(); + var getHolder = require_getHolder(); + var replaceHolders = require_replaceHolders(); + var root = require_root(); + function createCurry(func, bitmask, arity) { + var Ctor = createCtor(func); + function wrapper() { + var length = arguments.length, args = Array(length), index = length, placeholder = getHolder(wrapper); + while (index--) { + args[index] = arguments[index]; + } + var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder); + length -= holders.length; + if (length < arity) { + return createRecurry( + func, + bitmask, + createHybrid, + wrapper.placeholder, + void 0, + args, + holders, + void 0, + void 0, + arity - length + ); + } + var fn = this && this !== root && this instanceof wrapper ? Ctor : func; + return apply(fn, this, args); + } + return wrapper; + } + module.exports = createCurry; + } + }); + + // node_modules/lodash/_createPartial.js + var require_createPartial = __commonJS({ + "node_modules/lodash/_createPartial.js"(exports, module) { + var apply = require_apply(); + var createCtor = require_createCtor(); + var root = require_root(); + var WRAP_BIND_FLAG = 1; + function createPartial(func, bitmask, thisArg, partials) { + var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func); + function wrapper() { + var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array(leftLength + argsLength), fn = this && this !== root && this instanceof wrapper ? Ctor : func; + while (++leftIndex < leftLength) { + args[leftIndex] = partials[leftIndex]; + } + while (argsLength--) { + args[leftIndex++] = arguments[++argsIndex]; + } + return apply(fn, isBind ? thisArg : this, args); + } + return wrapper; + } + module.exports = createPartial; + } + }); + + // node_modules/lodash/_mergeData.js + var require_mergeData = __commonJS({ + "node_modules/lodash/_mergeData.js"(exports, module) { + var composeArgs = require_composeArgs(); + var composeArgsRight = require_composeArgsRight(); + var replaceHolders = require_replaceHolders(); + var PLACEHOLDER = "__lodash_placeholder__"; + var WRAP_BIND_FLAG = 1; + var WRAP_BIND_KEY_FLAG = 2; + var WRAP_CURRY_BOUND_FLAG = 4; + var WRAP_CURRY_FLAG = 8; + var WRAP_ARY_FLAG = 128; + var WRAP_REARG_FLAG = 256; + var nativeMin = Math.min; + function mergeData(data, source) { + var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG); + var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG; + if (!(isCommon || isCombo)) { + return data; + } + if (srcBitmask & WRAP_BIND_FLAG) { + data[2] = source[2]; + newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG; + } + var value = source[3]; + if (value) { + var partials = data[3]; + data[3] = partials ? composeArgs(partials, value, source[4]) : value; + data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4]; + } + value = source[5]; + if (value) { + partials = data[5]; + data[5] = partials ? composeArgsRight(partials, value, source[6]) : value; + data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6]; + } + value = source[7]; + if (value) { + data[7] = value; + } + if (srcBitmask & WRAP_ARY_FLAG) { + data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]); + } + if (data[9] == null) { + data[9] = source[9]; + } + data[0] = source[0]; + data[1] = newBitmask; + return data; + } + module.exports = mergeData; + } + }); + + // node_modules/lodash/isSymbol.js + var require_isSymbol = __commonJS({ + "node_modules/lodash/isSymbol.js"(exports, module) { + var baseGetTag = require_baseGetTag(); + var isObjectLike = require_isObjectLike(); + var symbolTag = "[object Symbol]"; + function isSymbol(value) { + return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag; + } + module.exports = isSymbol; + } + }); + + // node_modules/lodash/toNumber.js + var require_toNumber = __commonJS({ + "node_modules/lodash/toNumber.js"(exports, module) { + var isObject = require_isObject(); + var isSymbol = require_isSymbol(); + var NAN = 0 / 0; + var reTrim = /^\s+|\s+$/g; + var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + var reIsBinary = /^0b[01]+$/i; + var reIsOctal = /^0o[0-7]+$/i; + var freeParseInt = parseInt; + function toNumber(value) { + if (typeof value == "number") { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == "function" ? value.valueOf() : value; + value = isObject(other) ? other + "" : other; + } + if (typeof value != "string") { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ""); + var isBinary = reIsBinary.test(value); + return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value; + } + module.exports = toNumber; + } + }); + + // node_modules/lodash/toFinite.js + var require_toFinite = __commonJS({ + "node_modules/lodash/toFinite.js"(exports, module) { + var toNumber = require_toNumber(); + var INFINITY = 1 / 0; + var MAX_INTEGER = 17976931348623157e292; + function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber(value); + if (value === INFINITY || value === -INFINITY) { + var sign = value < 0 ? -1 : 1; + return sign * MAX_INTEGER; + } + return value === value ? value : 0; + } + module.exports = toFinite; + } + }); + + // node_modules/lodash/toInteger.js + var require_toInteger = __commonJS({ + "node_modules/lodash/toInteger.js"(exports, module) { + var toFinite = require_toFinite(); + function toInteger(value) { + var result = toFinite(value), remainder = result % 1; + return result === result ? remainder ? result - remainder : result : 0; + } + module.exports = toInteger; + } + }); + + // node_modules/lodash/_createWrap.js + var require_createWrap = __commonJS({ + "node_modules/lodash/_createWrap.js"(exports, module) { + var baseSetData = require_baseSetData(); + var createBind = require_createBind(); + var createCurry = require_createCurry(); + var createHybrid = require_createHybrid(); + var createPartial = require_createPartial(); + var getData = require_getData(); + var mergeData = require_mergeData(); + var setData = require_setData(); + var setWrapToString = require_setWrapToString(); + var toInteger = require_toInteger(); + var FUNC_ERROR_TEXT = "Expected a function"; + var WRAP_BIND_FLAG = 1; + var WRAP_BIND_KEY_FLAG = 2; + var WRAP_CURRY_FLAG = 8; + var WRAP_CURRY_RIGHT_FLAG = 16; + var WRAP_PARTIAL_FLAG = 32; + var WRAP_PARTIAL_RIGHT_FLAG = 64; + var nativeMax = Math.max; + function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) { + var isBindKey = bitmask & WRAP_BIND_KEY_FLAG; + if (!isBindKey && typeof func != "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + var length = partials ? partials.length : 0; + if (!length) { + bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG); + partials = holders = void 0; + } + ary = ary === void 0 ? ary : nativeMax(toInteger(ary), 0); + arity = arity === void 0 ? arity : toInteger(arity); + length -= holders ? holders.length : 0; + if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { + var partialsRight = partials, holdersRight = holders; + partials = holders = void 0; + } + var data = isBindKey ? void 0 : getData(func); + var newData = [ + func, + bitmask, + thisArg, + partials, + holders, + partialsRight, + holdersRight, + argPos, + ary, + arity + ]; + if (data) { + mergeData(newData, data); + } + func = newData[0]; + bitmask = newData[1]; + thisArg = newData[2]; + partials = newData[3]; + holders = newData[4]; + arity = newData[9] = newData[9] === void 0 ? isBindKey ? 0 : func.length : nativeMax(newData[9] - length, 0); + if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) { + bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG); + } + if (!bitmask || bitmask == WRAP_BIND_FLAG) { + var result = createBind(func, bitmask, thisArg); + } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) { + result = createCurry(func, bitmask, arity); + } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) { + result = createPartial(func, bitmask, thisArg, partials); + } else { + result = createHybrid.apply(void 0, newData); + } + var setter = data ? baseSetData : setData; + return setWrapToString(setter(result, newData), func, bitmask); + } + module.exports = createWrap; + } + }); + + // node_modules/lodash/bind.js + var require_bind = __commonJS({ + "node_modules/lodash/bind.js"(exports, module) { + var baseRest = require_baseRest(); + var createWrap = require_createWrap(); + var getHolder = require_getHolder(); + var replaceHolders = require_replaceHolders(); + var WRAP_BIND_FLAG = 1; + var WRAP_PARTIAL_FLAG = 32; + var bind = baseRest(function(func, thisArg, partials) { + var bitmask = WRAP_BIND_FLAG; + if (partials.length) { + var holders = replaceHolders(partials, getHolder(bind)); + bitmask |= WRAP_PARTIAL_FLAG; + } + return createWrap(func, bitmask, thisArg, partials, holders); + }); + bind.placeholder = {}; + module.exports = bind; + } + }); + + // node_modules/invariant/browser.js + var require_browser = __commonJS({ + "node_modules/invariant/browser.js"(exports, module) { + "use strict"; + var invariant = function(condition, format, a, b, c, d, e, f) { + if (true) { + if (format === void 0) { + throw new Error("invariant requires an error message argument"); + } + } + if (!condition) { + var error; + if (format === void 0) { + error = new Error( + "Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings." + ); + } else { + var args = [a, b, c, d, e, f]; + var argIndex = 0; + error = new Error( + format.replace(/%s/g, function() { + return args[argIndex++]; + }) + ); + error.name = "Invariant Violation"; + } + error.framesToPop = 1; + throw error; + } + }; + module.exports = invariant; + } + }); + + // node_modules/can-use-dom/index.js + var require_can_use_dom = __commonJS({ + "node_modules/can-use-dom/index.js"(exports, module) { + var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement); + module.exports = canUseDOM; + } + }); + + // node_modules/scriptjs/dist/script.js + var require_script = __commonJS({ + "node_modules/scriptjs/dist/script.js"(exports, module) { + (function(name, definition) { + if (typeof module != "undefined" && module.exports) + module.exports = definition(); + else if (typeof define == "function" && define.amd) + define(definition); + else + this[name] = definition(); + })("$script", function() { + var doc = document, head = doc.getElementsByTagName("head")[0], s = "string", f = false, push = "push", readyState = "readyState", onreadystatechange = "onreadystatechange", list = {}, ids = {}, delay = {}, scripts = {}, scriptpath, urlArgs; + function every(ar, fn) { + for (var i = 0, j = ar.length; i < j; ++i) + if (!fn(ar[i])) + return f; + return 1; + } + function each(ar, fn) { + every(ar, function(el) { + return !fn(el); + }); + } + function $script(paths, idOrDone, optDone) { + paths = paths[push] ? paths : [paths]; + var idOrDoneIsDone = idOrDone && idOrDone.call, done = idOrDoneIsDone ? idOrDone : optDone, id = idOrDoneIsDone ? paths.join("") : idOrDone, queue = paths.length; + function loopFn(item) { + return item.call ? item() : list[item]; + } + function callback() { + if (!--queue) { + list[id] = 1; + done && done(); + for (var dset in delay) { + every(dset.split("|"), loopFn) && !each(delay[dset], loopFn) && (delay[dset] = []); + } + } + } + setTimeout(function() { + each(paths, function loading(path, force) { + if (path === null) + return callback(); + if (!force && !/^https?:\/\//.test(path) && scriptpath) { + path = path.indexOf(".js") === -1 ? scriptpath + path + ".js" : scriptpath + path; + } + if (scripts[path]) { + if (id) + ids[id] = 1; + return scripts[path] == 2 ? callback() : setTimeout(function() { + loading(path, true); + }, 0); + } + scripts[path] = 1; + if (id) + ids[id] = 1; + create(path, callback); + }); + }, 0); + return $script; + } + function create(path, fn) { + var el = doc.createElement("script"), loaded; + el.onload = el.onerror = el[onreadystatechange] = function() { + if (el[readyState] && !/^c|loade/.test(el[readyState]) || loaded) + return; + el.onload = el[onreadystatechange] = null; + loaded = 1; + scripts[path] = 2; + fn(); + }; + el.async = 1; + el.src = urlArgs ? path + (path.indexOf("?") === -1 ? "?" : "&") + urlArgs : path; + head.insertBefore(el, head.lastChild); + } + $script.get = create; + $script.order = function(scripts2, id, done) { + (function callback(s2) { + s2 = scripts2.shift(); + !scripts2.length ? $script(s2, id, done) : $script(s2, callback); + })(); + }; + $script.path = function(p) { + scriptpath = p; + }; + $script.urlArgs = function(str) { + urlArgs = str; + }; + $script.ready = function(deps, ready, req) { + deps = deps[push] ? deps : [deps]; + var missing = []; + !each(deps, function(dep) { + list[dep] || missing[push](dep); + }) && every(deps, function(dep) { + return list[dep]; + }) ? ready() : !function(key) { + delay[key] = delay[key] || []; + delay[key][push](ready); + req && req(missing); + }(deps.join("|")); + return $script; + }; + $script.done = function(idOrDone) { + $script([null], idOrDone); + }; + return $script; + }); + } + }); + + // node_modules/react-google-maps/lib/withScriptjs.js + var require_withScriptjs = __commonJS({ + "node_modules/react-google-maps/lib/withScriptjs.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + var _objectWithoutProperties2 = require_objectWithoutProperties(); + var _objectWithoutProperties3 = _interopRequireDefault( + _objectWithoutProperties2 + ); + var _getPrototypeOf = require_get_prototype_of2(); + var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + var _classCallCheck2 = require_classCallCheck(); + var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + var _createClass2 = require_createClass(); + var _createClass3 = _interopRequireDefault(_createClass2); + var _possibleConstructorReturn2 = require_possibleConstructorReturn(); + var _possibleConstructorReturn3 = _interopRequireDefault( + _possibleConstructorReturn2 + ); + var _inherits2 = require_inherits(); + var _inherits3 = _interopRequireDefault(_inherits2); + var _bind2 = require_bind(); + var _bind3 = _interopRequireDefault(_bind2); + exports.withScriptjs = withScriptjs2; + var _invariant = require_browser(); + var _invariant2 = _interopRequireDefault(_invariant); + var _canUseDom = require_can_use_dom(); + var _canUseDom2 = _interopRequireDefault(_canUseDom); + var _recompose = require_Recompose(); + var _propTypes = require_prop_types(); + var _propTypes2 = _interopRequireDefault(_propTypes); + var _react = require_react(); + var _react2 = _interopRequireDefault(_react); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + var LOADING_STATE_NONE = "NONE"; + var LOADING_STATE_BEGIN = "BEGIN"; + var LOADING_STATE_LOADED = "LOADED"; + function withScriptjs2(BaseComponent) { + var factory = _react2.default.createFactory(BaseComponent); + var Container = function(_React$PureComponent) { + ; + (0, _inherits3.default)(Container2, _React$PureComponent); + function Container2() { + var _ref; + var _temp, _this, _ret; + (0, _classCallCheck3.default)(this, Container2); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = (0, _possibleConstructorReturn3.default)( + this, + (_ref = Container2.__proto__ || (0, _getPrototypeOf2.default)(Container2)).call.apply( + _ref, + [this].concat(args) + ) + ), _this), _this.state = { + loadingState: LOADING_STATE_NONE + }, _this.isUnmounted = false, _this.handleLoaded = (0, _bind3.default)(_this.handleLoaded, _this), _temp), (0, _possibleConstructorReturn3.default)(_this, _ret); + } + ; + (0, _createClass3.default)(Container2, [ + { + key: "handleLoaded", + value: function handleLoaded() { + if (this.isUnmounted) { + return; + } + this.setState({ + loadingState: LOADING_STATE_LOADED + }); + } + }, + { + key: "componentWillMount", + value: function componentWillMount() { + var _props = this.props, loadingElement = _props.loadingElement, googleMapURL = _props.googleMapURL; + (0, _invariant2.default)( + !!loadingElement && !!googleMapURL, + "Required props loadingElement or googleMapURL is missing. You need to provide both of them." + ); + } + }, + { + key: "componentDidMount", + value: function componentDidMount() { + var loadingState = this.state.loadingState; + if (loadingState !== LOADING_STATE_NONE || !_canUseDom2.default) { + return; + } + this.setState({ + loadingState: LOADING_STATE_BEGIN + }); + var scriptjs = require_script(); + var googleMapURL = this.props.googleMapURL; + scriptjs(googleMapURL, this.handleLoaded); + } + }, + { + key: "componentWillUnmount", + value: function componentWillUnmount() { + this.isUnmounted = true; + } + }, + { + key: "render", + value: function render() { + var _props2 = this.props, loadingElement = _props2.loadingElement, googleMapURL = _props2.googleMapURL, restProps = (0, _objectWithoutProperties3.default)(_props2, [ + "loadingElement", + "googleMapURL" + ]); + var loadingState = this.state.loadingState; + if (loadingState === LOADING_STATE_LOADED) { + return factory(restProps); + } else { + return loadingElement; + } + } + } + ]); + return Container2; + }(_react2.default.PureComponent); + Container.displayName = "withScriptjs(" + (0, _recompose.getDisplayName)(BaseComponent) + ")"; + Container.propTypes = { + loadingElement: _propTypes2.default.node.isRequired, + googleMapURL: _propTypes2.default.string.isRequired + }; + return Container; + } + exports.default = withScriptjs2; + } + }); + + // node_modules/babel-runtime/helpers/defineProperty.js + var require_defineProperty2 = __commonJS({ + "node_modules/babel-runtime/helpers/defineProperty.js"(exports) { + "use strict"; + exports.__esModule = true; + var _defineProperty = require_define_property2(); + var _defineProperty2 = _interopRequireDefault(_defineProperty); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + exports.default = function(obj, key, value) { + if (key in obj) { + (0, _defineProperty2.default)(obj, key, { + value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; + }; + } + }); + + // node_modules/warning/browser.js + var require_browser2 = __commonJS({ + "node_modules/warning/browser.js"(exports, module) { + "use strict"; + var warning = function() { + }; + if (true) { + warning = function(condition, format, args) { + var len = arguments.length; + args = new Array(len > 2 ? len - 2 : 0); + for (var key = 2; key < len; key++) { + args[key - 2] = arguments[key]; + } + if (format === void 0) { + throw new Error( + "`warning(condition, format, ...args)` requires a warning message argument" + ); + } + if (format.length < 10 || /^[s\W]*$/.test(format)) { + throw new Error( + "The warning format should be able to uniquely identify this warning. Please, use a more descriptive format than: " + format + ); + } + if (!condition) { + var argIndex = 0; + var message = "Warning: " + format.replace(/%s/g, function() { + return args[argIndex++]; + }); + if (typeof console !== "undefined") { + console.error(message); + } + try { + throw new Error(message); + } catch (x) { + } + } + }; + } + module.exports = warning; + } + }); + + // node_modules/react-google-maps/lib/constants.js + var require_constants = __commonJS({ + "node_modules/react-google-maps/lib/constants.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + var MAP = exports.MAP = "__SECRET_MAP_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var MARKER = exports.MARKER = "__SECRET_MARKER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var MARKER_WITH_LABEL = exports.MARKER_WITH_LABEL = "__SECRET_MARKER_WITH_LABEL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var RECTANGLE = exports.RECTANGLE = "__SECRET_RECTANGLE_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var POLYLINE = exports.POLYLINE = "__SECRET_POLYLINE_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var POLYGON = exports.POLYGON = "__SECRET_POLYGON_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var CIRCLE = exports.CIRCLE = "__SECRET_CIRCLE_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var KML_LAYER = exports.KML_LAYER = "__SECRET_KML_LAYER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var DIRECTIONS_RENDERER = exports.DIRECTIONS_RENDERER = "__SECRET_DIRECTIONS_RENDERER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var HEATMAP_LAYER = exports.HEATMAP_LAYER = "__SECRET_HEATMAP_LAYER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var FUSION_TABLES_LAYER = exports.FUSION_TABLES_LAYER = "__SECRET_FUSION_TABLES_LAYER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var ANCHOR = exports.ANCHOR = "__SECRET_ANCHOR_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var INFO_WINDOW = exports.INFO_WINDOW = "__SECRET_INFO_WINDOW_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var OVERLAY_VIEW = exports.OVERLAY_VIEW = "__SECRET_OVERLAY_VIEW_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var GROUND_LAYER = exports.GROUND_LAYER = "__SECRET_GROUND_LAYER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var DRAWING_MANAGER = exports.DRAWING_MANAGER = "__SECRET_DRAWING_MANAGER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var SEARCH_BOX = exports.SEARCH_BOX = "__SECRET_SEARCH_BOX_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var MARKER_CLUSTERER = exports.MARKER_CLUSTERER = "__SECRET_MARKER_CLUSTERER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var INFO_BOX = exports.INFO_BOX = "__SECRET_INFO_BOX_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var TRAFFIC_LAYER = exports.TRAFFIC_LAYER = "__SECRET_TRAFFIC_LAYER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var STREET_VIEW_PANORAMA = exports.STREET_VIEW_PANORAMA = "__SECRET_STREET_VIEW_PANORAMA_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + var BICYCLING_LAYER = exports.BICYCLING_LAYER = "__SECRET_BICYCLING_LAYER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"; + } + }); + + // node_modules/react-google-maps/lib/withGoogleMap.js + var require_withGoogleMap = __commonJS({ + "node_modules/react-google-maps/lib/withGoogleMap.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + var _objectWithoutProperties2 = require_objectWithoutProperties(); + var _objectWithoutProperties3 = _interopRequireDefault( + _objectWithoutProperties2 + ); + var _defineProperty2 = require_defineProperty2(); + var _defineProperty3 = _interopRequireDefault(_defineProperty2); + var _getPrototypeOf = require_get_prototype_of2(); + var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + var _classCallCheck2 = require_classCallCheck(); + var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + var _createClass2 = require_createClass(); + var _createClass3 = _interopRequireDefault(_createClass2); + var _possibleConstructorReturn2 = require_possibleConstructorReturn(); + var _possibleConstructorReturn3 = _interopRequireDefault( + _possibleConstructorReturn2 + ); + var _inherits2 = require_inherits(); + var _inherits3 = _interopRequireDefault(_inherits2); + var _bind2 = require_bind(); + var _bind3 = _interopRequireDefault(_bind2); + exports.withGoogleMap = withGoogleMap2; + var _warning = require_browser2(); + var _warning2 = _interopRequireDefault(_warning); + var _invariant = require_browser(); + var _invariant2 = _interopRequireDefault(_invariant); + var _recompose = require_Recompose(); + var _propTypes = require_prop_types(); + var _propTypes2 = _interopRequireDefault(_propTypes); + var _react = require_react(); + var _react2 = _interopRequireDefault(_react); + var _constants = require_constants(); + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { default: obj }; + } + function withGoogleMap2(BaseComponent) { + var factory = _react2.default.createFactory(BaseComponent); + var Container = function(_React$PureComponent) { + ; + (0, _inherits3.default)(Container2, _React$PureComponent); + function Container2() { + var _ref; + var _temp, _this, _ret; + (0, _classCallCheck3.default)(this, Container2); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return _ret = (_temp = (_this = (0, _possibleConstructorReturn3.default)( + this, + (_ref = Container2.__proto__ || (0, _getPrototypeOf2.default)(Container2)).call.apply( + _ref, + [this].concat(args) + ) + ), _this), _this.state = { + map: null + }, _this.handleComponentMount = (0, _bind3.default)( + _this.handleComponentMount, + _this + ), _temp), (0, _possibleConstructorReturn3.default)(_this, _ret); + } + ; + (0, _createClass3.default)(Container2, [ + { + key: "getChildContext", + value: function getChildContext() { + return (0, _defineProperty3.default)( + {}, + _constants.MAP, + this.state.map + ); + } + }, + { + key: "componentWillMount", + value: function componentWillMount() { + var _props = this.props, containerElement = _props.containerElement, mapElement = _props.mapElement; + (0, _invariant2.default)( + !!containerElement && !!mapElement, + "Required props containerElement or mapElement is missing. You need to provide both of them.\n The `google.maps.Map` instance will be initialized on mapElement and it's wrapped by containerElement.\nYou need to provide both of them since Google Map requires the DOM to have height when initialized." + ); + } + }, + { + key: "handleComponentMount", + value: function handleComponentMount(node) { + if (this.state.map || node === null) { + return; + } + ; + (0, _warning2.default)( + "undefined" !== typeof google, + `Make sure you've put a