diff options
Diffstat (limited to 'devtools/client/debugger/dist/vendors.js')
| -rw-r--r-- | devtools/client/debugger/dist/vendors.js | 2496 |
1 files changed, 2496 insertions, 0 deletions
diff --git a/devtools/client/debugger/dist/vendors.js b/devtools/client/debugger/dist/vendors.js new file mode 100644 index 0000000000..02bc0fca14 --- /dev/null +++ b/devtools/client/debugger/dist/vendors.js @@ -0,0 +1,2496 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("devtools/client/shared/vendor/react-prop-types"), require("devtools/client/shared/vendor/react"), require("devtools/client/shared/vendor/react-dom")); + else if(typeof define === 'function' && define.amd) + define(["devtools/client/shared/vendor/react-prop-types", "devtools/client/shared/vendor/react", "devtools/client/shared/vendor/react-dom"], factory); + else { + var a = typeof exports === 'object' ? factory(require("devtools/client/shared/vendor/react-prop-types"), require("devtools/client/shared/vendor/react"), require("devtools/client/shared/vendor/react-dom")) : factory(root["devtools/client/shared/vendor/react-prop-types"], root["devtools/client/shared/vendor/react"], root["devtools/client/shared/vendor/react-dom"]); + for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i]; + } +})(typeof self !== 'undefined' ? self : this, function(__WEBPACK_EXTERNAL_MODULE_0__, __WEBPACK_EXTERNAL_MODULE_6__, __WEBPACK_EXTERNAL_MODULE_112__) { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { +/******/ configurable: false, +/******/ enumerable: true, +/******/ get: getter +/******/ }); +/******/ } +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = "/assets/build"; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 929); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 0: +/***/ (function(module, exports) { + +module.exports = __WEBPACK_EXTERNAL_MODULE_0__; + +/***/ }), + +/***/ 112: +/***/ (function(module, exports) { + +module.exports = __WEBPACK_EXTERNAL_MODULE_112__; + +/***/ }), + +/***/ 6: +/***/ (function(module, exports) { + +module.exports = __WEBPACK_EXTERNAL_MODULE_6__; + +/***/ }), + +/***/ 607: +/***/ (function(module, exports) { + +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + + +/***/ }), + +/***/ 611: +/***/ (function(module, exports) { + +(function() { + var AcronymResult, computeScore, emptyAcronymResult, isAcronymFullWord, isMatch, isSeparator, isWordEnd, isWordStart, miss_coeff, pos_bonus, scoreAcronyms, scoreCharacter, scoreConsecutives, scoreExact, scoreExactMatch, scorePattern, scorePosition, scoreSize, tau_size, wm; + + wm = 150; + + pos_bonus = 20; + + tau_size = 150; + + miss_coeff = 0.75; + + exports.score = function(string, query, options) { + var allowErrors, preparedQuery, score, string_lw; + preparedQuery = options.preparedQuery, allowErrors = options.allowErrors; + if (!(allowErrors || isMatch(string, preparedQuery.core_lw, preparedQuery.core_up))) { + return 0; + } + string_lw = string.toLowerCase(); + score = computeScore(string, string_lw, preparedQuery); + return Math.ceil(score); + }; + + exports.isMatch = isMatch = function(subject, query_lw, query_up) { + var i, j, m, n, qj_lw, qj_up, si; + m = subject.length; + n = query_lw.length; + if (!m || n > m) { + return false; + } + i = -1; + j = -1; + while (++j < n) { + qj_lw = query_lw.charCodeAt(j); + qj_up = query_up.charCodeAt(j); + while (++i < m) { + si = subject.charCodeAt(i); + if (si === qj_lw || si === qj_up) { + break; + } + } + if (i === m) { + return false; + } + } + return true; + }; + + exports.computeScore = computeScore = function(subject, subject_lw, preparedQuery) { + var acro, acro_score, align, csc_diag, csc_row, csc_score, csc_should_rebuild, i, j, m, miss_budget, miss_left, n, pos, query, query_lw, record_miss, score, score_diag, score_row, score_up, si_lw, start, sz; + query = preparedQuery.query; + query_lw = preparedQuery.query_lw; + m = subject.length; + n = query.length; + acro = scoreAcronyms(subject, subject_lw, query, query_lw); + acro_score = acro.score; + if (acro.count === n) { + return scoreExact(n, m, acro_score, acro.pos); + } + pos = subject_lw.indexOf(query_lw); + if (pos > -1) { + return scoreExactMatch(subject, subject_lw, query, query_lw, pos, n, m); + } + score_row = new Array(n); + csc_row = new Array(n); + sz = scoreSize(n, m); + miss_budget = Math.ceil(miss_coeff * n) + 5; + miss_left = miss_budget; + csc_should_rebuild = true; + j = -1; + while (++j < n) { + score_row[j] = 0; + csc_row[j] = 0; + } + i = -1; + while (++i < m) { + si_lw = subject_lw[i]; + if (!si_lw.charCodeAt(0) in preparedQuery.charCodes) { + if (csc_should_rebuild) { + j = -1; + while (++j < n) { + csc_row[j] = 0; + } + csc_should_rebuild = false; + } + continue; + } + score = 0; + score_diag = 0; + csc_diag = 0; + record_miss = true; + csc_should_rebuild = true; + j = -1; + while (++j < n) { + score_up = score_row[j]; + if (score_up > score) { + score = score_up; + } + csc_score = 0; + if (query_lw[j] === si_lw) { + start = isWordStart(i, subject, subject_lw); + csc_score = csc_diag > 0 ? csc_diag : scoreConsecutives(subject, subject_lw, query, query_lw, i, j, start); + align = score_diag + scoreCharacter(i, j, start, acro_score, csc_score); + if (align > score) { + score = align; + miss_left = miss_budget; + } else { + if (record_miss && --miss_left <= 0) { + return Math.max(score, score_row[n - 1]) * sz; + } + record_miss = false; + } + } + score_diag = score_up; + csc_diag = csc_row[j]; + csc_row[j] = csc_score; + score_row[j] = score; + } + } + score = score_row[n - 1]; + return score * sz; + }; + + exports.isWordStart = isWordStart = function(pos, subject, subject_lw) { + var curr_s, prev_s; + if (pos === 0) { + return true; + } + curr_s = subject[pos]; + prev_s = subject[pos - 1]; + return isSeparator(prev_s) || (curr_s !== subject_lw[pos] && prev_s === subject_lw[pos - 1]); + }; + + exports.isWordEnd = isWordEnd = function(pos, subject, subject_lw, len) { + var curr_s, next_s; + if (pos === len - 1) { + return true; + } + curr_s = subject[pos]; + next_s = subject[pos + 1]; + return isSeparator(next_s) || (curr_s === subject_lw[pos] && next_s !== subject_lw[pos + 1]); + }; + + isSeparator = function(c) { + return c === ' ' || c === '.' || c === '-' || c === '_' || c === '/' || c === '\\'; + }; + + scorePosition = function(pos) { + var sc; + if (pos < pos_bonus) { + sc = pos_bonus - pos; + return 100 + sc * sc; + } else { + return Math.max(100 + pos_bonus - pos, 0); + } + }; + + exports.scoreSize = scoreSize = function(n, m) { + return tau_size / (tau_size + Math.abs(m - n)); + }; + + scoreExact = function(n, m, quality, pos) { + return 2 * n * (wm * quality + scorePosition(pos)) * scoreSize(n, m); + }; + + exports.scorePattern = scorePattern = function(count, len, sameCase, start, end) { + var bonus, sz; + sz = count; + bonus = 6; + if (sameCase === count) { + bonus += 2; + } + if (start) { + bonus += 3; + } + if (end) { + bonus += 1; + } + if (count === len) { + if (start) { + if (sameCase === len) { + sz += 2; + } else { + sz += 1; + } + } + if (end) { + bonus += 1; + } + } + return sameCase + sz * (sz + bonus); + }; + + exports.scoreCharacter = scoreCharacter = function(i, j, start, acro_score, csc_score) { + var posBonus; + posBonus = scorePosition(i); + if (start) { + return posBonus + wm * ((acro_score > csc_score ? acro_score : csc_score) + 10); + } + return posBonus + wm * csc_score; + }; + + exports.scoreConsecutives = scoreConsecutives = function(subject, subject_lw, query, query_lw, i, j, startOfWord) { + var k, m, mi, n, nj, sameCase, sz; + m = subject.length; + n = query.length; + mi = m - i; + nj = n - j; + k = mi < nj ? mi : nj; + sameCase = 0; + sz = 0; + if (query[j] === subject[i]) { + sameCase++; + } + while (++sz < k && query_lw[++j] === subject_lw[++i]) { + if (query[j] === subject[i]) { + sameCase++; + } + } + if (sz < k) { + i--; + } + if (sz === 1) { + return 1 + 2 * sameCase; + } + return scorePattern(sz, n, sameCase, startOfWord, isWordEnd(i, subject, subject_lw, m)); + }; + + exports.scoreExactMatch = scoreExactMatch = function(subject, subject_lw, query, query_lw, pos, n, m) { + var end, i, pos2, sameCase, start; + start = isWordStart(pos, subject, subject_lw); + if (!start) { + pos2 = subject_lw.indexOf(query_lw, pos + 1); + if (pos2 > -1) { + start = isWordStart(pos2, subject, subject_lw); + if (start) { + pos = pos2; + } + } + } + i = -1; + sameCase = 0; + while (++i < n) { + if (query[pos + i] === subject[i]) { + sameCase++; + } + } + end = isWordEnd(pos + n - 1, subject, subject_lw, m); + return scoreExact(n, m, scorePattern(n, n, sameCase, start, end), pos); + }; + + AcronymResult = (function() { + function AcronymResult(score, pos, count) { + this.score = score; + this.pos = pos; + this.count = count; + } + + return AcronymResult; + + })(); + + emptyAcronymResult = new AcronymResult(0, 0.1, 0); + + exports.scoreAcronyms = scoreAcronyms = function(subject, subject_lw, query, query_lw) { + var count, fullWord, i, j, m, n, qj_lw, sameCase, score, sepCount, sumPos; + m = subject.length; + n = query.length; + if (!(m > 1 && n > 1)) { + return emptyAcronymResult; + } + count = 0; + sepCount = 0; + sumPos = 0; + sameCase = 0; + i = -1; + j = -1; + while (++j < n) { + qj_lw = query_lw[j]; + if (isSeparator(qj_lw)) { + i = subject_lw.indexOf(qj_lw, i + 1); + if (i > -1) { + sepCount++; + continue; + } else { + break; + } + } + while (++i < m) { + if (qj_lw === subject_lw[i] && isWordStart(i, subject, subject_lw)) { + if (query[j] === subject[i]) { + sameCase++; + } + sumPos += i; + count++; + break; + } + } + if (i === m) { + break; + } + } + if (count < 2) { + return emptyAcronymResult; + } + fullWord = count === n ? isAcronymFullWord(subject, subject_lw, query, count) : false; + score = scorePattern(count, n, sameCase, true, fullWord); + return new AcronymResult(score, sumPos / count, count + sepCount); + }; + + isAcronymFullWord = function(subject, subject_lw, query, nbAcronymInQuery) { + var count, i, m, n; + m = subject.length; + n = query.length; + count = 0; + if (m > 12 * n) { + return false; + } + i = -1; + while (++i < m) { + if (isWordStart(i, subject, subject_lw) && ++count > nbAcronymInQuery) { + return false; + } + } + return true; + }; + +}).call(this); + + +/***/ }), + +/***/ 647: +/***/ (function(module, exports, __webpack_require__) { + +(function() { + var computeScore, countDir, file_coeff, getExtension, getExtensionScore, isMatch, scorePath, scoreSize, tau_depth, _ref; + + _ref = __webpack_require__(611), isMatch = _ref.isMatch, computeScore = _ref.computeScore, scoreSize = _ref.scoreSize; + + tau_depth = 20; + + file_coeff = 2.5; + + exports.score = function(string, query, options) { + var allowErrors, preparedQuery, score, string_lw; + preparedQuery = options.preparedQuery, allowErrors = options.allowErrors; + if (!(allowErrors || isMatch(string, preparedQuery.core_lw, preparedQuery.core_up))) { + return 0; + } + string_lw = string.toLowerCase(); + score = computeScore(string, string_lw, preparedQuery); + score = scorePath(string, string_lw, score, options); + return Math.ceil(score); + }; + + scorePath = function(subject, subject_lw, fullPathScore, options) { + var alpha, basePathScore, basePos, depth, end, extAdjust, fileLength, pathSeparator, preparedQuery, useExtensionBonus; + if (fullPathScore === 0) { + return 0; + } + preparedQuery = options.preparedQuery, useExtensionBonus = options.useExtensionBonus, pathSeparator = options.pathSeparator; + end = subject.length - 1; + while (subject[end] === pathSeparator) { + end--; + } + basePos = subject.lastIndexOf(pathSeparator, end); + fileLength = end - basePos; + extAdjust = 1.0; + if (useExtensionBonus) { + extAdjust += getExtensionScore(subject_lw, preparedQuery.ext, basePos, end, 2); + fullPathScore *= extAdjust; + } + if (basePos === -1) { + return fullPathScore; + } + depth = preparedQuery.depth; + while (basePos > -1 && depth-- > 0) { + basePos = subject.lastIndexOf(pathSeparator, basePos - 1); + } + basePathScore = basePos === -1 ? fullPathScore : extAdjust * computeScore(subject.slice(basePos + 1, end + 1), subject_lw.slice(basePos + 1, end + 1), preparedQuery); + alpha = 0.5 * tau_depth / (tau_depth + countDir(subject, end + 1, pathSeparator)); + return alpha * basePathScore + (1 - alpha) * fullPathScore * scoreSize(0, file_coeff * fileLength); + }; + + exports.countDir = countDir = function(path, end, pathSeparator) { + var count, i; + if (end < 1) { + return 0; + } + count = 0; + i = -1; + while (++i < end && path[i] === pathSeparator) { + continue; + } + while (++i < end) { + if (path[i] === pathSeparator) { + count++; + while (++i < end && path[i] === pathSeparator) { + continue; + } + } + } + return count; + }; + + exports.getExtension = getExtension = function(str) { + var pos; + pos = str.lastIndexOf("."); + if (pos < 0) { + return ""; + } else { + return str.substr(pos + 1); + } + }; + + getExtensionScore = function(candidate, ext, startPos, endPos, maxDepth) { + var m, matched, n, pos; + if (!ext.length) { + return 0; + } + pos = candidate.lastIndexOf(".", endPos); + if (!(pos > startPos)) { + return 0; + } + n = ext.length; + m = endPos - pos; + if (m < n) { + n = m; + m = ext.length; + } + pos++; + matched = -1; + while (++matched < n) { + if (candidate[pos + matched] !== ext[matched]) { + break; + } + } + if (matched === 0 && maxDepth > 0) { + return 0.9 * getExtensionScore(candidate, ext, startPos, pos - 2, maxDepth - 1); + } + return matched / m; + }; + +}).call(this); + + +/***/ }), + +/***/ 709: +/***/ (function(module, exports, __webpack_require__) { + +(function() { + var Query, coreChars, countDir, getCharCodes, getExtension, opt_char_re, truncatedUpperCase, _ref; + + _ref = __webpack_require__(647), countDir = _ref.countDir, getExtension = _ref.getExtension; + + module.exports = Query = (function() { + function Query(query, _arg) { + var optCharRegEx, pathSeparator, _ref1; + _ref1 = _arg != null ? _arg : {}, optCharRegEx = _ref1.optCharRegEx, pathSeparator = _ref1.pathSeparator; + if (!(query && query.length)) { + return null; + } + this.query = query; + this.query_lw = query.toLowerCase(); + this.core = coreChars(query, optCharRegEx); + this.core_lw = this.core.toLowerCase(); + this.core_up = truncatedUpperCase(this.core); + this.depth = countDir(query, query.length, pathSeparator); + this.ext = getExtension(this.query_lw); + this.charCodes = getCharCodes(this.query_lw); + } + + return Query; + + })(); + + opt_char_re = /[ _\-:\/\\]/g; + + coreChars = function(query, optCharRegEx) { + if (optCharRegEx == null) { + optCharRegEx = opt_char_re; + } + return query.replace(optCharRegEx, ''); + }; + + truncatedUpperCase = function(str) { + var char, upper, _i, _len; + upper = ""; + for (_i = 0, _len = str.length; _i < _len; _i++) { + char = str[_i]; + upper += char.toUpperCase()[0]; + } + return upper; + }; + + getCharCodes = function(str) { + var charCodes, i, len; + len = str.length; + i = -1; + charCodes = []; + while (++i < len) { + charCodes[str.charCodeAt(i)] = true; + } + return charCodes; + }; + +}).call(this); + + +/***/ }), + +/***/ 710: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _propTypes = _interopRequireDefault(__webpack_require__(0)); + +var _react = _interopRequireDefault(__webpack_require__(6)); + +var _tab = _interopRequireDefault(__webpack_require__(711)); + +var _tabList = _interopRequireDefault(__webpack_require__(958)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class TabList extends _react.default.Component { + constructor(props) { + super(props); + + const childrenCount = _react.default.Children.count(props.children); + + this.handleKeyPress = this.handleKeyPress.bind(this); + this.tabRefs = new Array(childrenCount).fill(0).map(() => /*#__PURE__*/_react.default.createRef()); + this.handlers = this.getHandlers(props.vertical); + } + + componentDidUpdate(prevProps) { + if (prevProps.activeIndex !== this.props.activeIndex) { + this.tabRefs[this.props.activeIndex].current.focus(); + } + } + + getHandlers(vertical) { + if (vertical) { + return { + ArrowDown: this.next.bind(this), + ArrowUp: this.previous.bind(this) + }; + } + + return { + ArrowLeft: this.previous.bind(this), + ArrowRight: this.next.bind(this) + }; + } + + wrapIndex(index) { + const count = _react.default.Children.count(this.props.children); + + return (index + count) % count; + } + + handleKeyPress(event) { + const handler = this.handlers[event.key]; + + if (handler) { + handler(); + } + } + + previous() { + const newIndex = this.wrapIndex(this.props.activeIndex - 1); + this.props.onActivateTab(newIndex); + } + + next() { + const newIndex = this.wrapIndex(this.props.activeIndex + 1); + this.props.onActivateTab(newIndex); + } + + render() { + const { + accessibleId, + activeIndex, + children, + className, + onActivateTab + } = this.props; + return /*#__PURE__*/_react.default.createElement("ul", { + className: className, + onKeyUp: this.handleKeyPress, + role: "tablist" + }, _react.default.Children.map(children, (child, index) => { + if (child.type !== _tab.default) { + throw new Error('Direct children of a <TabList> must be a <Tab>'); + } + + const active = index === activeIndex; + const tabRef = this.tabRefs[index]; + return /*#__PURE__*/_react.default.cloneElement(child, { + accessibleId: active ? accessibleId : undefined, + active, + tabRef, + onActivate: () => onActivateTab(index) + }); + })); + } + +} + +exports.default = TabList; +TabList.propTypes = { + accessibleId: _propTypes.default.string, + activeIndex: _propTypes.default.number, + children: _propTypes.default.node, + className: _propTypes.default.string, + onActivateTab: _propTypes.default.func, + vertical: _propTypes.default.bool +}; +TabList.defaultProps = { + accessibleId: undefined, + activeIndex: 0, + children: null, + className: _tabList.default.container, + onActivateTab: () => {}, + vertical: false +}; + +/***/ }), + +/***/ 711: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = Tab; + +var _propTypes = _interopRequireDefault(__webpack_require__(0)); + +var _react = _interopRequireDefault(__webpack_require__(6)); + +var _ref = _interopRequireDefault(__webpack_require__(938)); + +var _tab = _interopRequireDefault(__webpack_require__(957)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function Tab({ + accessibleId, + active, + children, + className, + onActivate, + tabRef +}) { + return /*#__PURE__*/_react.default.createElement("li", { + "aria-selected": active, + className: className, + id: accessibleId, + onClick: onActivate, + onKeyDown: () => {}, + ref: tabRef, + role: "tab", + tabIndex: active ? 0 : undefined + }, children); +} + +Tab.propTypes = { + accessibleId: _propTypes.default.string, + active: _propTypes.default.bool, + children: _propTypes.default.node.isRequired, + className: _propTypes.default.string, + onActivate: _propTypes.default.func, + tabRef: _ref.default +}; +Tab.defaultProps = { + accessibleId: undefined, + active: false, + className: _tab.default.container, + onActivate: undefined, + tabRef: undefined +}; + +/***/ }), + +/***/ 712: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = TabPanels; + +var _propTypes = _interopRequireDefault(__webpack_require__(0)); + +var _react = _interopRequireDefault(__webpack_require__(6)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function TabPanels({ + accessibleId, + activeIndex, + children, + className, + hasFocusableContent +}) { + return /*#__PURE__*/_react.default.createElement("div", { + "aria-labelledby": accessibleId, + role: "tabpanel", + className: className, + tabIndex: hasFocusableContent ? undefined : 0 + }, _react.default.Children.toArray(children)[activeIndex]); +} + +TabPanels.propTypes = { + accessibleId: _propTypes.default.string, + activeIndex: _propTypes.default.number, + children: _propTypes.default.node.isRequired, + className: _propTypes.default.string, + hasFocusableContent: _propTypes.default.bool.isRequired +}; +TabPanels.defaultProps = { + accessibleId: undefined, + activeIndex: 0, + className: null +}; + +/***/ }), + +/***/ 929: +/***/ (function(module, exports, __webpack_require__) { + +module.exports = __webpack_require__(930); + + +/***/ }), + +/***/ 930: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.vendored = void 0; + +var fuzzaldrinPlus = _interopRequireWildcard(__webpack_require__(931)); + +var transition = _interopRequireWildcard(__webpack_require__(934)); + +var reactAriaComponentsTabs = _interopRequireWildcard(__webpack_require__(937)); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */ + +/** + * Vendors.js is a file used to bundle and expose all dependencies needed to run + * the transpiled debugger modules when running in Firefox. + * + * To make transpilation easier, a vendored module should always be imported in + * same way: + * - always with destructuring (import { a } from "modA";) + * - always without destructuring (import modB from "modB") + * + * Both are fine, but cannot be mixed for the same module. + */ +// We cannot directly export literals containing special characters +// (eg. "my-module/Test") which is why they are nested in "vendored". +// The keys of the vendored object should match the module names +// !!! Should remain synchronized with .babel/transform-mc.js !!! +const vendored = { + "fuzzaldrin-plus": fuzzaldrinPlus, + "react-aria-components/src/tabs": reactAriaComponentsTabs, + "react-transition-group/Transition": transition +}; +exports.vendored = vendored; + +/***/ }), + +/***/ 931: +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(process) {(function() { + var Query, defaultPathSeparator, filter, matcher, parseOptions, pathScorer, preparedQueryCache, scorer; + + filter = __webpack_require__(932); + + matcher = __webpack_require__(933); + + scorer = __webpack_require__(611); + + pathScorer = __webpack_require__(647); + + Query = __webpack_require__(709); + + preparedQueryCache = null; + + defaultPathSeparator = (typeof process !== "undefined" && process !== null ? process.platform : void 0) === "win32" ? '\\' : '/'; + + module.exports = { + filter: function(candidates, query, options) { + if (options == null) { + options = {}; + } + if (!((query != null ? query.length : void 0) && (candidates != null ? candidates.length : void 0))) { + return []; + } + options = parseOptions(options, query); + return filter(candidates, query, options); + }, + score: function(string, query, options) { + if (options == null) { + options = {}; + } + if (!((string != null ? string.length : void 0) && (query != null ? query.length : void 0))) { + return 0; + } + options = parseOptions(options, query); + if (options.usePathScoring) { + return pathScorer.score(string, query, options); + } else { + return scorer.score(string, query, options); + } + }, + match: function(string, query, options) { + var _i, _ref, _results; + if (options == null) { + options = {}; + } + if (!string) { + return []; + } + if (!query) { + return []; + } + if (string === query) { + return (function() { + _results = []; + for (var _i = 0, _ref = string.length; 0 <= _ref ? _i < _ref : _i > _ref; 0 <= _ref ? _i++ : _i--){ _results.push(_i); } + return _results; + }).apply(this); + } + options = parseOptions(options, query); + return matcher.match(string, query, options); + }, + wrap: function(string, query, options) { + if (options == null) { + options = {}; + } + if (!string) { + return []; + } + if (!query) { + return []; + } + options = parseOptions(options, query); + return matcher.wrap(string, query, options); + }, + prepareQuery: function(query, options) { + if (options == null) { + options = {}; + } + options = parseOptions(options, query); + return options.preparedQuery; + } + }; + + parseOptions = function(options, query) { + if (options.allowErrors == null) { + options.allowErrors = false; + } + if (options.usePathScoring == null) { + options.usePathScoring = true; + } + if (options.useExtensionBonus == null) { + options.useExtensionBonus = false; + } + if (options.pathSeparator == null) { + options.pathSeparator = defaultPathSeparator; + } + if (options.optCharRegEx == null) { + options.optCharRegEx = null; + } + if (options.wrap == null) { + options.wrap = null; + } + if (options.preparedQuery == null) { + options.preparedQuery = preparedQueryCache && preparedQueryCache.query === query ? preparedQueryCache : (preparedQueryCache = new Query(query, options)); + } + return options; + }; + +}).call(this); + +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(607))) + +/***/ }), + +/***/ 932: +/***/ (function(module, exports, __webpack_require__) { + +(function() { + var Query, pathScorer, pluckCandidates, scorer, sortCandidates; + + scorer = __webpack_require__(611); + + pathScorer = __webpack_require__(647); + + Query = __webpack_require__(709); + + pluckCandidates = function(a) { + return a.candidate; + }; + + sortCandidates = function(a, b) { + return b.score - a.score; + }; + + module.exports = function(candidates, query, options) { + var bKey, candidate, key, maxInners, maxResults, score, scoreProvider, scoredCandidates, spotLeft, string, usePathScoring, _i, _len; + scoredCandidates = []; + key = options.key, maxResults = options.maxResults, maxInners = options.maxInners, usePathScoring = options.usePathScoring; + spotLeft = (maxInners != null) && maxInners > 0 ? maxInners : candidates.length + 1; + bKey = key != null; + scoreProvider = usePathScoring ? pathScorer : scorer; + for (_i = 0, _len = candidates.length; _i < _len; _i++) { + candidate = candidates[_i]; + string = bKey ? candidate[key] : candidate; + if (!string) { + continue; + } + score = scoreProvider.score(string, query, options); + if (score > 0) { + scoredCandidates.push({ + candidate: candidate, + score: score + }); + if (!--spotLeft) { + break; + } + } + } + scoredCandidates.sort(sortCandidates); + candidates = scoredCandidates.map(pluckCandidates); + if (maxResults != null) { + candidates = candidates.slice(0, maxResults); + } + return candidates; + }; + +}).call(this); + + +/***/ }), + +/***/ 933: +/***/ (function(module, exports, __webpack_require__) { + +(function() { + var basenameMatch, computeMatch, isMatch, isWordStart, match, mergeMatches, scoreAcronyms, scoreCharacter, scoreConsecutives, _ref; + + _ref = __webpack_require__(611), isMatch = _ref.isMatch, isWordStart = _ref.isWordStart, scoreConsecutives = _ref.scoreConsecutives, scoreCharacter = _ref.scoreCharacter, scoreAcronyms = _ref.scoreAcronyms; + + exports.match = match = function(string, query, options) { + var allowErrors, baseMatches, matches, pathSeparator, preparedQuery, string_lw; + allowErrors = options.allowErrors, preparedQuery = options.preparedQuery, pathSeparator = options.pathSeparator; + if (!(allowErrors || isMatch(string, preparedQuery.core_lw, preparedQuery.core_up))) { + return []; + } + string_lw = string.toLowerCase(); + matches = computeMatch(string, string_lw, preparedQuery); + if (matches.length === 0) { + return matches; + } + if (string.indexOf(pathSeparator) > -1) { + baseMatches = basenameMatch(string, string_lw, preparedQuery, pathSeparator); + matches = mergeMatches(matches, baseMatches); + } + return matches; + }; + + exports.wrap = function(string, query, options) { + var matchIndex, matchPos, matchPositions, output, strPos, tagClass, tagClose, tagOpen, _ref1; + if ((options.wrap != null)) { + _ref1 = options.wrap, tagClass = _ref1.tagClass, tagOpen = _ref1.tagOpen, tagClose = _ref1.tagClose; + } + if (tagClass == null) { + tagClass = 'highlight'; + } + if (tagOpen == null) { + tagOpen = '<strong class="' + tagClass + '">'; + } + if (tagClose == null) { + tagClose = '</strong>'; + } + if (string === query) { + return tagOpen + string + tagClose; + } + matchPositions = match(string, query, options); + if (matchPositions.length === 0) { + return string; + } + output = ''; + matchIndex = -1; + strPos = 0; + while (++matchIndex < matchPositions.length) { + matchPos = matchPositions[matchIndex]; + if (matchPos > strPos) { + output += string.substring(strPos, matchPos); + strPos = matchPos; + } + while (++matchIndex < matchPositions.length) { + if (matchPositions[matchIndex] === matchPos + 1) { + matchPos++; + } else { + matchIndex--; + break; + } + } + matchPos++; + if (matchPos > strPos) { + output += tagOpen; + output += string.substring(strPos, matchPos); + output += tagClose; + strPos = matchPos; + } + } + if (strPos <= string.length - 1) { + output += string.substring(strPos); + } + return output; + }; + + basenameMatch = function(subject, subject_lw, preparedQuery, pathSeparator) { + var basePos, depth, end; + end = subject.length - 1; + while (subject[end] === pathSeparator) { + end--; + } + basePos = subject.lastIndexOf(pathSeparator, end); + if (basePos === -1) { + return []; + } + depth = preparedQuery.depth; + while (depth-- > 0) { + basePos = subject.lastIndexOf(pathSeparator, basePos - 1); + if (basePos === -1) { + return []; + } + } + basePos++; + end++; + return computeMatch(subject.slice(basePos, end), subject_lw.slice(basePos, end), preparedQuery, basePos); + }; + + mergeMatches = function(a, b) { + var ai, bj, i, j, m, n, out; + m = a.length; + n = b.length; + if (n === 0) { + return a.slice(); + } + if (m === 0) { + return b.slice(); + } + i = -1; + j = 0; + bj = b[j]; + out = []; + while (++i < m) { + ai = a[i]; + while (bj <= ai && ++j < n) { + if (bj < ai) { + out.push(bj); + } + bj = b[j]; + } + out.push(ai); + } + while (j < n) { + out.push(b[j++]); + } + return out; + }; + + computeMatch = function(subject, subject_lw, preparedQuery, offset) { + var DIAGONAL, LEFT, STOP, UP, acro_score, align, backtrack, csc_diag, csc_row, csc_score, i, j, m, matches, move, n, pos, query, query_lw, score, score_diag, score_row, score_up, si_lw, start, trace; + if (offset == null) { + offset = 0; + } + query = preparedQuery.query; + query_lw = preparedQuery.query_lw; + m = subject.length; + n = query.length; + acro_score = scoreAcronyms(subject, subject_lw, query, query_lw).score; + score_row = new Array(n); + csc_row = new Array(n); + STOP = 0; + UP = 1; + LEFT = 2; + DIAGONAL = 3; + trace = new Array(m * n); + pos = -1; + j = -1; + while (++j < n) { + score_row[j] = 0; + csc_row[j] = 0; + } + i = -1; + while (++i < m) { + score = 0; + score_up = 0; + csc_diag = 0; + si_lw = subject_lw[i]; + j = -1; + while (++j < n) { + csc_score = 0; + align = 0; + score_diag = score_up; + if (query_lw[j] === si_lw) { + start = isWordStart(i, subject, subject_lw); + csc_score = csc_diag > 0 ? csc_diag : scoreConsecutives(subject, subject_lw, query, query_lw, i, j, start); + align = score_diag + scoreCharacter(i, j, start, acro_score, csc_score); + } + score_up = score_row[j]; + csc_diag = csc_row[j]; + if (score > score_up) { + move = LEFT; + } else { + score = score_up; + move = UP; + } + if (align > score) { + score = align; + move = DIAGONAL; + } else { + csc_score = 0; + } + score_row[j] = score; + csc_row[j] = csc_score; + trace[++pos] = score > 0 ? move : STOP; + } + } + i = m - 1; + j = n - 1; + pos = i * n + j; + backtrack = true; + matches = []; + while (backtrack && i >= 0 && j >= 0) { + switch (trace[pos]) { + case UP: + i--; + pos -= n; + break; + case LEFT: + j--; + pos--; + break; + case DIAGONAL: + matches.push(i + offset); + j--; + i--; + pos -= n + 1; + break; + default: + backtrack = false; + } + } + matches.reverse(); + return matches; + }; + +}).call(this); + + +/***/ }), + +/***/ 934: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +exports.__esModule = true; +exports.default = exports.EXITING = exports.ENTERED = exports.ENTERING = exports.EXITED = exports.UNMOUNTED = void 0; + +var PropTypes = _interopRequireWildcard(__webpack_require__(0)); + +var _react = _interopRequireDefault(__webpack_require__(6)); + +var _reactDom = _interopRequireDefault(__webpack_require__(112)); + +var _reactLifecyclesCompat = __webpack_require__(935); + +var _PropTypes = __webpack_require__(936); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } + +var UNMOUNTED = 'unmounted'; +exports.UNMOUNTED = UNMOUNTED; +var EXITED = 'exited'; +exports.EXITED = EXITED; +var ENTERING = 'entering'; +exports.ENTERING = ENTERING; +var ENTERED = 'entered'; +exports.ENTERED = ENTERED; +var EXITING = 'exiting'; +/** + * The Transition component lets you describe a transition from one component + * state to another _over time_ with a simple declarative API. Most commonly + * it's used to animate the mounting and unmounting of a component, but can also + * be used to describe in-place transition states as well. + * + * --- + * + * **Note**: `Transition` is a platform-agnostic base component. If you're using + * transitions in CSS, you'll probably want to use + * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition) + * instead. It inherits all the features of `Transition`, but contains + * additional features necessary to play nice with CSS transitions (hence the + * name of the component). + * + * --- + * + * By default the `Transition` component does not alter the behavior of the + * component it renders, it only tracks "enter" and "exit" states for the + * components. It's up to you to give meaning and effect to those states. For + * example we can add styles to a component when it enters or exits: + * + * ```jsx + * import { Transition } from 'react-transition-group'; + * + * const duration = 300; + * + * const defaultStyle = { + * transition: `opacity ${duration}ms ease-in-out`, + * opacity: 0, + * } + * + * const transitionStyles = { + * entering: { opacity: 0 }, + * entered: { opacity: 1 }, + * }; + * + * const Fade = ({ in: inProp }) => ( + * <Transition in={inProp} timeout={duration}> + * {state => ( + * <div style={{ + * ...defaultStyle, + * ...transitionStyles[state] + * }}> + * I'm a fade Transition! + * </div> + * )} + * </Transition> + * ); + * ``` + * + * There are 4 main states a Transition can be in: + * - `'entering'` + * - `'entered'` + * - `'exiting'` + * - `'exited'` + * + * Transition state is toggled via the `in` prop. When `true` the component + * begins the "Enter" stage. During this stage, the component will shift from + * its current transition state, to `'entering'` for the duration of the + * transition and then to the `'entered'` stage once it's complete. Let's take + * the following example (we'll use the + * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook): + * + * ```jsx + * function App() { + * const [inProp, setInProp] = useState(false); + * return ( + * <div> + * <Transition in={inProp} timeout={500}> + * {state => ( + * // ... + * )} + * </Transition> + * <button onClick={() => setInProp(true)}> + * Click to Enter + * </button> + * </div> + * ); + * } + * ``` + * + * When the button is clicked the component will shift to the `'entering'` state + * and stay there for 500ms (the value of `timeout`) before it finally switches + * to `'entered'`. + * + * When `in` is `false` the same thing happens except the state moves from + * `'exiting'` to `'exited'`. + */ + +exports.EXITING = EXITING; + +var Transition = +/*#__PURE__*/ +function (_React$Component) { + _inheritsLoose(Transition, _React$Component); + + function Transition(props, context) { + var _this; + + _this = _React$Component.call(this, props, context) || this; + var parentGroup = context.transitionGroup; // In the context of a TransitionGroup all enters are really appears + + var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear; + var initialStatus; + _this.appearStatus = null; + + if (props.in) { + if (appear) { + initialStatus = EXITED; + _this.appearStatus = ENTERING; + } else { + initialStatus = ENTERED; + } + } else { + if (props.unmountOnExit || props.mountOnEnter) { + initialStatus = UNMOUNTED; + } else { + initialStatus = EXITED; + } + } + + _this.state = { + status: initialStatus + }; + _this.nextCallback = null; + return _this; + } + + var _proto = Transition.prototype; + + _proto.getChildContext = function getChildContext() { + return { + transitionGroup: null // allows for nested Transitions + + }; + }; + + Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) { + var nextIn = _ref.in; + + if (nextIn && prevState.status === UNMOUNTED) { + return { + status: EXITED + }; + } + + return null; + }; // getSnapshotBeforeUpdate(prevProps) { + // let nextStatus = null + // if (prevProps !== this.props) { + // const { status } = this.state + // if (this.props.in) { + // if (status !== ENTERING && status !== ENTERED) { + // nextStatus = ENTERING + // } + // } else { + // if (status === ENTERING || status === ENTERED) { + // nextStatus = EXITING + // } + // } + // } + // return { nextStatus } + // } + + + _proto.componentDidMount = function componentDidMount() { + this.updateStatus(true, this.appearStatus); + }; + + _proto.componentDidUpdate = function componentDidUpdate(prevProps) { + var nextStatus = null; + + if (prevProps !== this.props) { + var status = this.state.status; + + if (this.props.in) { + if (status !== ENTERING && status !== ENTERED) { + nextStatus = ENTERING; + } + } else { + if (status === ENTERING || status === ENTERED) { + nextStatus = EXITING; + } + } + } + + this.updateStatus(false, nextStatus); + }; + + _proto.componentWillUnmount = function componentWillUnmount() { + this.cancelNextCallback(); + }; + + _proto.getTimeouts = function getTimeouts() { + var timeout = this.props.timeout; + var exit, enter, appear; + exit = enter = appear = timeout; + + if (timeout != null && typeof timeout !== 'number') { + exit = timeout.exit; + enter = timeout.enter; // TODO: remove fallback for next major + + appear = timeout.appear !== undefined ? timeout.appear : enter; + } + + return { + exit: exit, + enter: enter, + appear: appear + }; + }; + + _proto.updateStatus = function updateStatus(mounting, nextStatus) { + if (mounting === void 0) { + mounting = false; + } + + if (nextStatus !== null) { + // nextStatus will always be ENTERING or EXITING. + this.cancelNextCallback(); + + var node = _reactDom.default.findDOMNode(this); + + if (nextStatus === ENTERING) { + this.performEnter(node, mounting); + } else { + this.performExit(node); + } + } else if (this.props.unmountOnExit && this.state.status === EXITED) { + this.setState({ + status: UNMOUNTED + }); + } + }; + + _proto.performEnter = function performEnter(node, mounting) { + var _this2 = this; + + var enter = this.props.enter; + var appearing = this.context.transitionGroup ? this.context.transitionGroup.isMounting : mounting; + var timeouts = this.getTimeouts(); + var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED + // if we are mounting and running this it means appear _must_ be set + + if (!mounting && !enter) { + this.safeSetState({ + status: ENTERED + }, function () { + _this2.props.onEntered(node); + }); + return; + } + + this.props.onEnter(node, appearing); + this.safeSetState({ + status: ENTERING + }, function () { + _this2.props.onEntering(node, appearing); + + _this2.onTransitionEnd(node, enterTimeout, function () { + _this2.safeSetState({ + status: ENTERED + }, function () { + _this2.props.onEntered(node, appearing); + }); + }); + }); + }; + + _proto.performExit = function performExit(node) { + var _this3 = this; + + var exit = this.props.exit; + var timeouts = this.getTimeouts(); // no exit animation skip right to EXITED + + if (!exit) { + this.safeSetState({ + status: EXITED + }, function () { + _this3.props.onExited(node); + }); + return; + } + + this.props.onExit(node); + this.safeSetState({ + status: EXITING + }, function () { + _this3.props.onExiting(node); + + _this3.onTransitionEnd(node, timeouts.exit, function () { + _this3.safeSetState({ + status: EXITED + }, function () { + _this3.props.onExited(node); + }); + }); + }); + }; + + _proto.cancelNextCallback = function cancelNextCallback() { + if (this.nextCallback !== null) { + this.nextCallback.cancel(); + this.nextCallback = null; + } + }; + + _proto.safeSetState = function safeSetState(nextState, callback) { + // This shouldn't be necessary, but there are weird race conditions with + // setState callbacks and unmounting in testing, so always make sure that + // we can cancel any pending setState callbacks after we unmount. + callback = this.setNextCallback(callback); + this.setState(nextState, callback); + }; + + _proto.setNextCallback = function setNextCallback(callback) { + var _this4 = this; + + var active = true; + + this.nextCallback = function (event) { + if (active) { + active = false; + _this4.nextCallback = null; + callback(event); + } + }; + + this.nextCallback.cancel = function () { + active = false; + }; + + return this.nextCallback; + }; + + _proto.onTransitionEnd = function onTransitionEnd(node, timeout, handler) { + this.setNextCallback(handler); + var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener; + + if (!node || doesNotHaveTimeoutOrListener) { + setTimeout(this.nextCallback, 0); + return; + } + + if (this.props.addEndListener) { + this.props.addEndListener(node, this.nextCallback); + } + + if (timeout != null) { + setTimeout(this.nextCallback, timeout); + } + }; + + _proto.render = function render() { + var status = this.state.status; + + if (status === UNMOUNTED) { + return null; + } + + var _this$props = this.props, + children = _this$props.children, + childProps = _objectWithoutPropertiesLoose(_this$props, ["children"]); // filter props for Transtition + + + delete childProps.in; + delete childProps.mountOnEnter; + delete childProps.unmountOnExit; + delete childProps.appear; + delete childProps.enter; + delete childProps.exit; + delete childProps.timeout; + delete childProps.addEndListener; + delete childProps.onEnter; + delete childProps.onEntering; + delete childProps.onEntered; + delete childProps.onExit; + delete childProps.onExiting; + delete childProps.onExited; + + if (typeof children === 'function') { + return children(status, childProps); + } + + var child = _react.default.Children.only(children); + + return _react.default.cloneElement(child, childProps); + }; + + return Transition; +}(_react.default.Component); + +Transition.contextTypes = { + transitionGroup: PropTypes.object +}; +Transition.childContextTypes = { + transitionGroup: function transitionGroup() {} +}; +Transition.propTypes = false ? { + /** + * A `function` child can be used instead of a React element. This function is + * called with the current transition status (`'entering'`, `'entered'`, + * `'exiting'`, `'exited'`, `'unmounted'`), which can be used to apply context + * specific props to a component. + * + * ```jsx + * <Transition in={this.state.in} timeout={150}> + * {state => ( + * <MyComponent className={`fade fade-${state}`} /> + * )} + * </Transition> + * ``` + */ + children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired, + + /** + * Show the component; triggers the enter or exit states + */ + in: PropTypes.bool, + + /** + * By default the child component is mounted immediately along with + * the parent `Transition` component. If you want to "lazy mount" the component on the + * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay + * mounted, even on "exited", unless you also specify `unmountOnExit`. + */ + mountOnEnter: PropTypes.bool, + + /** + * By default the child component stays mounted after it reaches the `'exited'` state. + * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting. + */ + unmountOnExit: PropTypes.bool, + + /** + * Normally a component is not transitioned if it is shown when the `<Transition>` component mounts. + * If you want to transition on the first mount set `appear` to `true`, and the + * component will transition in as soon as the `<Transition>` mounts. + * + * > Note: there are no specific "appear" states. `appear` only adds an additional `enter` transition. + */ + appear: PropTypes.bool, + + /** + * Enable or disable enter transitions. + */ + enter: PropTypes.bool, + + /** + * Enable or disable exit transitions. + */ + exit: PropTypes.bool, + + /** + * The duration of the transition, in milliseconds. + * Required unless `addEndListener` is provided. + * + * You may specify a single timeout for all transitions: + * + * ```jsx + * timeout={500} + * ``` + * + * or individually: + * + * ```jsx + * timeout={{ + * appear: 500, + * enter: 300, + * exit: 500, + * }} + * ``` + * + * - `appear` defaults to the value of `enter` + * - `enter` defaults to `0` + * - `exit` defaults to `0` + * + * @type {number | { enter?: number, exit?: number, appear?: number }} + */ + timeout: function timeout(props) { + var pt = _PropTypes.timeoutsShape; + if (!props.addEndListener) pt = pt.isRequired; + + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return pt.apply(void 0, [props].concat(args)); + }, + + /** + * Add a custom transition end trigger. Called with the transitioning + * DOM node and a `done` callback. Allows for more fine grained transition end + * logic. **Note:** Timeouts are still used as a fallback if provided. + * + * ```jsx + * addEndListener={(node, done) => { + * // use the css transitionend event to mark the finish of a transition + * node.addEventListener('transitionend', done, false); + * }} + * ``` + */ + addEndListener: PropTypes.func, + + /** + * Callback fired before the "entering" status is applied. An extra parameter + * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount + * + * @type Function(node: HtmlElement, isAppearing: bool) -> void + */ + onEnter: PropTypes.func, + + /** + * Callback fired after the "entering" status is applied. An extra parameter + * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount + * + * @type Function(node: HtmlElement, isAppearing: bool) + */ + onEntering: PropTypes.func, + + /** + * Callback fired after the "entered" status is applied. An extra parameter + * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount + * + * @type Function(node: HtmlElement, isAppearing: bool) -> void + */ + onEntered: PropTypes.func, + + /** + * Callback fired before the "exiting" status is applied. + * + * @type Function(node: HtmlElement) -> void + */ + onExit: PropTypes.func, + + /** + * Callback fired after the "exiting" status is applied. + * + * @type Function(node: HtmlElement) -> void + */ + onExiting: PropTypes.func, + + /** + * Callback fired after the "exited" status is applied. + * + * @type Function(node: HtmlElement) -> void + */ + onExited: PropTypes.func // Name the function so it is clearer in the documentation + +} : {}; + +function noop() {} + +Transition.defaultProps = { + in: false, + mountOnEnter: false, + unmountOnExit: false, + appear: false, + enter: true, + exit: true, + onEnter: noop, + onEntering: noop, + onEntered: noop, + onExit: noop, + onExiting: noop, + onExited: noop +}; +Transition.UNMOUNTED = 0; +Transition.EXITED = 1; +Transition.ENTERING = 2; +Transition.ENTERED = 3; +Transition.EXITING = 4; + +var _default = (0, _reactLifecyclesCompat.polyfill)(Transition); + +exports.default = _default; + +/***/ }), + +/***/ 935: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +Object.defineProperty(__webpack_exports__, "__esModule", { value: true }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "polyfill", function() { return polyfill; }); +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function componentWillMount() { + // Call this.constructor.gDSFP to support sub-classes. + var state = this.constructor.getDerivedStateFromProps(this.props, this.state); + if (state !== null && state !== undefined) { + this.setState(state); + } +} + +function componentWillReceiveProps(nextProps) { + // Call this.constructor.gDSFP to support sub-classes. + // Use the setState() updater to ensure state isn't stale in certain edge cases. + function updater(prevState) { + var state = this.constructor.getDerivedStateFromProps(nextProps, prevState); + return state !== null && state !== undefined ? state : null; + } + // Binding "this" is important for shallow renderer support. + this.setState(updater.bind(this)); +} + +function componentWillUpdate(nextProps, nextState) { + try { + var prevProps = this.props; + var prevState = this.state; + this.props = nextProps; + this.state = nextState; + this.__reactInternalSnapshotFlag = true; + this.__reactInternalSnapshot = this.getSnapshotBeforeUpdate( + prevProps, + prevState + ); + } finally { + this.props = prevProps; + this.state = prevState; + } +} + +// React may warn about cWM/cWRP/cWU methods being deprecated. +// Add a flag to suppress these warnings for this special case. +componentWillMount.__suppressDeprecationWarning = true; +componentWillReceiveProps.__suppressDeprecationWarning = true; +componentWillUpdate.__suppressDeprecationWarning = true; + +function polyfill(Component) { + var prototype = Component.prototype; + + if (!prototype || !prototype.isReactComponent) { + throw new Error('Can only polyfill class components'); + } + + if ( + typeof Component.getDerivedStateFromProps !== 'function' && + typeof prototype.getSnapshotBeforeUpdate !== 'function' + ) { + return Component; + } + + // If new component APIs are defined, "unsafe" lifecycles won't be called. + // Error if any of these lifecycles are present, + // Because they would work differently between older and newer (16.3+) versions of React. + var foundWillMountName = null; + var foundWillReceivePropsName = null; + var foundWillUpdateName = null; + if (typeof prototype.componentWillMount === 'function') { + foundWillMountName = 'componentWillMount'; + } else if (typeof prototype.UNSAFE_componentWillMount === 'function') { + foundWillMountName = 'UNSAFE_componentWillMount'; + } + if (typeof prototype.componentWillReceiveProps === 'function') { + foundWillReceivePropsName = 'componentWillReceiveProps'; + } else if (typeof prototype.UNSAFE_componentWillReceiveProps === 'function') { + foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps'; + } + if (typeof prototype.componentWillUpdate === 'function') { + foundWillUpdateName = 'componentWillUpdate'; + } else if (typeof prototype.UNSAFE_componentWillUpdate === 'function') { + foundWillUpdateName = 'UNSAFE_componentWillUpdate'; + } + if ( + foundWillMountName !== null || + foundWillReceivePropsName !== null || + foundWillUpdateName !== null + ) { + var componentName = Component.displayName || Component.name; + var newApiName = + typeof Component.getDerivedStateFromProps === 'function' + ? 'getDerivedStateFromProps()' + : 'getSnapshotBeforeUpdate()'; + + throw Error( + 'Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n' + + componentName + + ' uses ' + + newApiName + + ' but also contains the following legacy lifecycles:' + + (foundWillMountName !== null ? '\n ' + foundWillMountName : '') + + (foundWillReceivePropsName !== null + ? '\n ' + foundWillReceivePropsName + : '') + + (foundWillUpdateName !== null ? '\n ' + foundWillUpdateName : '') + + '\n\nThe above lifecycles should be removed. Learn more about this warning here:\n' + + 'https://fb.me/react-async-component-lifecycle-hooks' + ); + } + + // React <= 16.2 does not support static getDerivedStateFromProps. + // As a workaround, use cWM and cWRP to invoke the new static lifecycle. + // Newer versions of React will ignore these lifecycles if gDSFP exists. + if (typeof Component.getDerivedStateFromProps === 'function') { + prototype.componentWillMount = componentWillMount; + prototype.componentWillReceiveProps = componentWillReceiveProps; + } + + // React <= 16.2 does not support getSnapshotBeforeUpdate. + // As a workaround, use cWU to invoke the new lifecycle. + // Newer versions of React will ignore that lifecycle if gSBU exists. + if (typeof prototype.getSnapshotBeforeUpdate === 'function') { + if (typeof prototype.componentDidUpdate !== 'function') { + throw new Error( + 'Cannot polyfill getSnapshotBeforeUpdate() for components that do not define componentDidUpdate() on the prototype' + ); + } + + prototype.componentWillUpdate = componentWillUpdate; + + var componentDidUpdate = prototype.componentDidUpdate; + + prototype.componentDidUpdate = function componentDidUpdatePolyfill( + prevProps, + prevState, + maybeSnapshot + ) { + // 16.3+ will not execute our will-update method; + // It will pass a snapshot value to did-update though. + // Older versions will require our polyfilled will-update value. + // We need to handle both cases, but can't just check for the presence of "maybeSnapshot", + // Because for <= 15.x versions this might be a "prevContext" object. + // We also can't just check "__reactInternalSnapshot", + // Because get-snapshot might return a falsy value. + // So check for the explicit __reactInternalSnapshotFlag flag to determine behavior. + var snapshot = this.__reactInternalSnapshotFlag + ? this.__reactInternalSnapshot + : maybeSnapshot; + + componentDidUpdate.call(this, prevProps, prevState, snapshot); + }; + } + + return Component; +} + + + + +/***/ }), + +/***/ 936: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +exports.__esModule = true; +exports.classNamesShape = exports.timeoutsShape = void 0; + +var _propTypes = _interopRequireDefault(__webpack_require__(0)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var timeoutsShape = false ? _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.shape({ + enter: _propTypes.default.number, + exit: _propTypes.default.number, + appear: _propTypes.default.number +}).isRequired]) : null; +exports.timeoutsShape = timeoutsShape; +var classNamesShape = false ? _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.shape({ + enter: _propTypes.default.string, + exit: _propTypes.default.string, + active: _propTypes.default.string +}), _propTypes.default.shape({ + enter: _propTypes.default.string, + enterDone: _propTypes.default.string, + enterActive: _propTypes.default.string, + exit: _propTypes.default.string, + exitDone: _propTypes.default.string, + exitActive: _propTypes.default.string +})]) : null; +exports.classNamesShape = classNamesShape; + +/***/ }), + +/***/ 937: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "TabList", { + enumerable: true, + get: function () { + return _tabList.default; + } +}); +Object.defineProperty(exports, "TabPanels", { + enumerable: true, + get: function () { + return _tabPanels.default; + } +}); +Object.defineProperty(exports, "Tab", { + enumerable: true, + get: function () { + return _tab.default; + } +}); +Object.defineProperty(exports, "Tabs", { + enumerable: true, + get: function () { + return _tabs.default; + } +}); + +var _tabList = _interopRequireDefault(__webpack_require__(710)); + +var _tabPanels = _interopRequireDefault(__webpack_require__(712)); + +var _tab = _interopRequireDefault(__webpack_require__(711)); + +var _tabs = _interopRequireDefault(__webpack_require__(941)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/***/ }), + +/***/ 938: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _propTypes = _interopRequireDefault(__webpack_require__(0)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var _default = _propTypes.default.object; +exports.default = _default; + +/***/ }), + +/***/ 941: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _propTypes = _interopRequireDefault(__webpack_require__(0)); + +var _react = _interopRequireDefault(__webpack_require__(6)); + +var _uniqueId = _interopRequireDefault(__webpack_require__(942)); + +var _tabList = _interopRequireDefault(__webpack_require__(710)); + +var _tabPanels = _interopRequireDefault(__webpack_require__(712)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +class Tabs extends _react.default.Component { + constructor() { + super(); + this.accessibleId = (0, _uniqueId.default)(); + } + + render() { + const { + activeIndex, + children, + className, + onActivateTab + } = this.props; + const accessibleId = this.accessibleId; + return /*#__PURE__*/_react.default.createElement("div", { + className: className + }, _react.default.Children.map(children, child => { + if (!child) { + return child; + } + + switch (child.type) { + case _tabList.default: + return /*#__PURE__*/_react.default.cloneElement(child, { + accessibleId, + activeIndex, + onActivateTab + }); + + case _tabPanels.default: + return /*#__PURE__*/_react.default.cloneElement(child, { + accessibleId, + activeIndex + }); + + default: + return child; + } + })); + } + +} + +exports.default = Tabs; +Tabs.propTypes = { + activeIndex: _propTypes.default.number.isRequired, + children: _propTypes.default.node, + className: _propTypes.default.string, + onActivateTab: _propTypes.default.func +}; +Tabs.defaultProps = { + children: null, + className: undefined, + onActivateTab: () => {} +}; + +/***/ }), + +/***/ 942: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = uniqueId; +let counter = 0; + +function uniqueId() { + counter += 1; + return `$rac$${counter}`; +} + +/***/ }), + +/***/ 957: +/***/ (function(module, exports) { + +// removed by extract-text-webpack-plugin + +/***/ }), + +/***/ 958: +/***/ (function(module, exports) { + +// removed by extract-text-webpack-plugin + +/***/ }) + +/******/ }); +});
\ No newline at end of file |