You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7806 lines
207 KiB
JavaScript
7806 lines
207 KiB
JavaScript
(self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] = self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] || []).push([[9619],{
|
|
|
|
/***/ 93535:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'apathy',
|
|
author: 'jannik siebert (https://github.com/janniks)',
|
|
base00: '#031A16',
|
|
base01: '#0B342D',
|
|
base02: '#184E45',
|
|
base03: '#2B685E',
|
|
base04: '#5F9C92',
|
|
base05: '#81B5AC',
|
|
base06: '#A7CEC8',
|
|
base07: '#D2E7E4',
|
|
base08: '#3E9688',
|
|
base09: '#3E7996',
|
|
base0A: '#3E4C96',
|
|
base0B: '#883E96',
|
|
base0C: '#963E4C',
|
|
base0D: '#96883E',
|
|
base0E: '#4C963E',
|
|
base0F: '#3E965B'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 48000:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'ashes',
|
|
author: 'jannik siebert (https://github.com/janniks)',
|
|
base00: '#1C2023',
|
|
base01: '#393F45',
|
|
base02: '#565E65',
|
|
base03: '#747C84',
|
|
base04: '#ADB3BA',
|
|
base05: '#C7CCD1',
|
|
base06: '#DFE2E5',
|
|
base07: '#F3F4F5',
|
|
base08: '#C7AE95',
|
|
base09: '#C7C795',
|
|
base0A: '#AEC795',
|
|
base0B: '#95C7AE',
|
|
base0C: '#95AEC7',
|
|
base0D: '#AE95C7',
|
|
base0E: '#C795AE',
|
|
base0F: '#C79595'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 89575:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'atelier dune',
|
|
author: 'bram de haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/dune)',
|
|
base00: '#20201d',
|
|
base01: '#292824',
|
|
base02: '#6e6b5e',
|
|
base03: '#7d7a68',
|
|
base04: '#999580',
|
|
base05: '#a6a28c',
|
|
base06: '#e8e4cf',
|
|
base07: '#fefbec',
|
|
base08: '#d73737',
|
|
base09: '#b65611',
|
|
base0A: '#cfb017',
|
|
base0B: '#60ac39',
|
|
base0C: '#1fad83',
|
|
base0D: '#6684e1',
|
|
base0E: '#b854d4',
|
|
base0F: '#d43552'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 63295:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'atelier forest',
|
|
author: 'bram de haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/forest)',
|
|
base00: '#1b1918',
|
|
base01: '#2c2421',
|
|
base02: '#68615e',
|
|
base03: '#766e6b',
|
|
base04: '#9c9491',
|
|
base05: '#a8a19f',
|
|
base06: '#e6e2e0',
|
|
base07: '#f1efee',
|
|
base08: '#f22c40',
|
|
base09: '#df5320',
|
|
base0A: '#d5911a',
|
|
base0B: '#5ab738',
|
|
base0C: '#00ad9c',
|
|
base0D: '#407ee7',
|
|
base0E: '#6666ea',
|
|
base0F: '#c33ff3'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 68411:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'atelier heath',
|
|
author: 'bram de haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/heath)',
|
|
base00: '#1b181b',
|
|
base01: '#292329',
|
|
base02: '#695d69',
|
|
base03: '#776977',
|
|
base04: '#9e8f9e',
|
|
base05: '#ab9bab',
|
|
base06: '#d8cad8',
|
|
base07: '#f7f3f7',
|
|
base08: '#ca402b',
|
|
base09: '#a65926',
|
|
base0A: '#bb8a35',
|
|
base0B: '#379a37',
|
|
base0C: '#159393',
|
|
base0D: '#516aec',
|
|
base0E: '#7b59c0',
|
|
base0F: '#cc33cc'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 20209:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'atelier lakeside',
|
|
author: 'bram de haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/lakeside/)',
|
|
base00: '#161b1d',
|
|
base01: '#1f292e',
|
|
base02: '#516d7b',
|
|
base03: '#5a7b8c',
|
|
base04: '#7195a8',
|
|
base05: '#7ea2b4',
|
|
base06: '#c1e4f6',
|
|
base07: '#ebf8ff',
|
|
base08: '#d22d72',
|
|
base09: '#935c25',
|
|
base0A: '#8a8a0f',
|
|
base0B: '#568c3b',
|
|
base0C: '#2d8f6f',
|
|
base0D: '#257fad',
|
|
base0E: '#5d5db1',
|
|
base0F: '#b72dd2'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5968:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'atelier seaside',
|
|
author: 'bram de haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/seaside/)',
|
|
base00: '#131513',
|
|
base01: '#242924',
|
|
base02: '#5e6e5e',
|
|
base03: '#687d68',
|
|
base04: '#809980',
|
|
base05: '#8ca68c',
|
|
base06: '#cfe8cf',
|
|
base07: '#f0fff0',
|
|
base08: '#e6193c',
|
|
base09: '#87711d',
|
|
base0A: '#c3c322',
|
|
base0B: '#29a329',
|
|
base0C: '#1999b3',
|
|
base0D: '#3d62f5',
|
|
base0E: '#ad2bee',
|
|
base0F: '#e619c3'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 20904:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'bespin',
|
|
author: 'jan t. sott',
|
|
base00: '#28211c',
|
|
base01: '#36312e',
|
|
base02: '#5e5d5c',
|
|
base03: '#666666',
|
|
base04: '#797977',
|
|
base05: '#8a8986',
|
|
base06: '#9d9b97',
|
|
base07: '#baae9e',
|
|
base08: '#cf6a4c',
|
|
base09: '#cf7d34',
|
|
base0A: '#f9ee98',
|
|
base0B: '#54be0d',
|
|
base0C: '#afc4db',
|
|
base0D: '#5ea6ea',
|
|
base0E: '#9b859d',
|
|
base0F: '#937121'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 87002:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'brewer',
|
|
author: 'timothée poisot (http://github.com/tpoisot)',
|
|
base00: '#0c0d0e',
|
|
base01: '#2e2f30',
|
|
base02: '#515253',
|
|
base03: '#737475',
|
|
base04: '#959697',
|
|
base05: '#b7b8b9',
|
|
base06: '#dadbdc',
|
|
base07: '#fcfdfe',
|
|
base08: '#e31a1c',
|
|
base09: '#e6550d',
|
|
base0A: '#dca060',
|
|
base0B: '#31a354',
|
|
base0C: '#80b1d3',
|
|
base0D: '#3182bd',
|
|
base0E: '#756bb1',
|
|
base0F: '#b15928'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 74865:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'bright',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#000000',
|
|
base01: '#303030',
|
|
base02: '#505050',
|
|
base03: '#b0b0b0',
|
|
base04: '#d0d0d0',
|
|
base05: '#e0e0e0',
|
|
base06: '#f5f5f5',
|
|
base07: '#ffffff',
|
|
base08: '#fb0120',
|
|
base09: '#fc6d24',
|
|
base0A: '#fda331',
|
|
base0B: '#a1c659',
|
|
base0C: '#76c7b7',
|
|
base0D: '#6fb3d2',
|
|
base0E: '#d381c3',
|
|
base0F: '#be643c'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 89483:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'chalk',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#151515',
|
|
base01: '#202020',
|
|
base02: '#303030',
|
|
base03: '#505050',
|
|
base04: '#b0b0b0',
|
|
base05: '#d0d0d0',
|
|
base06: '#e0e0e0',
|
|
base07: '#f5f5f5',
|
|
base08: '#fb9fb1',
|
|
base09: '#eda987',
|
|
base0A: '#ddb26f',
|
|
base0B: '#acc267',
|
|
base0C: '#12cfc0',
|
|
base0D: '#6fc2ef',
|
|
base0E: '#e1a3ee',
|
|
base0F: '#deaf8f'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 15992:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'codeschool',
|
|
author: 'brettof86',
|
|
base00: '#232c31',
|
|
base01: '#1c3657',
|
|
base02: '#2a343a',
|
|
base03: '#3f4944',
|
|
base04: '#84898c',
|
|
base05: '#9ea7a6',
|
|
base06: '#a7cfa3',
|
|
base07: '#b5d8f6',
|
|
base08: '#2a5491',
|
|
base09: '#43820d',
|
|
base0A: '#a03b1e',
|
|
base0B: '#237986',
|
|
base0C: '#b02f30',
|
|
base0D: '#484d79',
|
|
base0E: '#c59820',
|
|
base0F: '#c98344'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 47340:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'colors',
|
|
author: 'mrmrs (http://clrs.cc)',
|
|
base00: '#111111',
|
|
base01: '#333333',
|
|
base02: '#555555',
|
|
base03: '#777777',
|
|
base04: '#999999',
|
|
base05: '#bbbbbb',
|
|
base06: '#dddddd',
|
|
base07: '#ffffff',
|
|
base08: '#ff4136',
|
|
base09: '#ff851b',
|
|
base0A: '#ffdc00',
|
|
base0B: '#2ecc40',
|
|
base0C: '#7fdbff',
|
|
base0D: '#0074d9',
|
|
base0E: '#b10dc9',
|
|
base0F: '#85144b'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 88968:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'default',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#181818',
|
|
base01: '#282828',
|
|
base02: '#383838',
|
|
base03: '#585858',
|
|
base04: '#b8b8b8',
|
|
base05: '#d8d8d8',
|
|
base06: '#e8e8e8',
|
|
base07: '#f8f8f8',
|
|
base08: '#ab4642',
|
|
base09: '#dc9656',
|
|
base0A: '#f7ca88',
|
|
base0B: '#a1b56c',
|
|
base0C: '#86c1b9',
|
|
base0D: '#7cafc2',
|
|
base0E: '#ba8baf',
|
|
base0F: '#a16946'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 33424:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'eighties',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#2d2d2d',
|
|
base01: '#393939',
|
|
base02: '#515151',
|
|
base03: '#747369',
|
|
base04: '#a09f93',
|
|
base05: '#d3d0c8',
|
|
base06: '#e8e6df',
|
|
base07: '#f2f0ec',
|
|
base08: '#f2777a',
|
|
base09: '#f99157',
|
|
base0A: '#ffcc66',
|
|
base0B: '#99cc99',
|
|
base0C: '#66cccc',
|
|
base0D: '#6699cc',
|
|
base0E: '#cc99cc',
|
|
base0F: '#d27b53'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 95326:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'embers',
|
|
author: 'jannik siebert (https://github.com/janniks)',
|
|
base00: '#16130F',
|
|
base01: '#2C2620',
|
|
base02: '#433B32',
|
|
base03: '#5A5047',
|
|
base04: '#8A8075',
|
|
base05: '#A39A90',
|
|
base06: '#BEB6AE',
|
|
base07: '#DBD6D1',
|
|
base08: '#826D57',
|
|
base09: '#828257',
|
|
base0A: '#6D8257',
|
|
base0B: '#57826D',
|
|
base0C: '#576D82',
|
|
base0D: '#6D5782',
|
|
base0E: '#82576D',
|
|
base0F: '#825757'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 91907:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'flat',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#2C3E50',
|
|
base01: '#34495E',
|
|
base02: '#7F8C8D',
|
|
base03: '#95A5A6',
|
|
base04: '#BDC3C7',
|
|
base05: '#e0e0e0',
|
|
base06: '#f5f5f5',
|
|
base07: '#ECF0F1',
|
|
base08: '#E74C3C',
|
|
base09: '#E67E22',
|
|
base0A: '#F1C40F',
|
|
base0B: '#2ECC71',
|
|
base0C: '#1ABC9C',
|
|
base0D: '#3498DB',
|
|
base0E: '#9B59B6',
|
|
base0F: '#be643c'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 44026:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'google',
|
|
author: 'seth wright (http://sethawright.com)',
|
|
base00: '#1d1f21',
|
|
base01: '#282a2e',
|
|
base02: '#373b41',
|
|
base03: '#969896',
|
|
base04: '#b4b7b4',
|
|
base05: '#c5c8c6',
|
|
base06: '#e0e0e0',
|
|
base07: '#ffffff',
|
|
base08: '#CC342B',
|
|
base09: '#F96A38',
|
|
base0A: '#FBA922',
|
|
base0B: '#198844',
|
|
base0C: '#3971ED',
|
|
base0D: '#3971ED',
|
|
base0E: '#A36AC7',
|
|
base0F: '#3971ED'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 93445:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'grayscale',
|
|
author: 'alexandre gavioli (https://github.com/alexx2/)',
|
|
base00: '#101010',
|
|
base01: '#252525',
|
|
base02: '#464646',
|
|
base03: '#525252',
|
|
base04: '#ababab',
|
|
base05: '#b9b9b9',
|
|
base06: '#e3e3e3',
|
|
base07: '#f7f7f7',
|
|
base08: '#7c7c7c',
|
|
base09: '#999999',
|
|
base0A: '#a0a0a0',
|
|
base0B: '#8e8e8e',
|
|
base0C: '#868686',
|
|
base0D: '#686868',
|
|
base0E: '#747474',
|
|
base0F: '#5e5e5e'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 62173:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'green screen',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#001100',
|
|
base01: '#003300',
|
|
base02: '#005500',
|
|
base03: '#007700',
|
|
base04: '#009900',
|
|
base05: '#00bb00',
|
|
base06: '#00dd00',
|
|
base07: '#00ff00',
|
|
base08: '#007700',
|
|
base09: '#009900',
|
|
base0A: '#007700',
|
|
base0B: '#00bb00',
|
|
base0C: '#005500',
|
|
base0D: '#009900',
|
|
base0E: '#00bb00',
|
|
base0F: '#005500'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 24978:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'harmonic16',
|
|
author: 'jannik siebert (https://github.com/janniks)',
|
|
base00: '#0b1c2c',
|
|
base01: '#223b54',
|
|
base02: '#405c79',
|
|
base03: '#627e99',
|
|
base04: '#aabcce',
|
|
base05: '#cbd6e2',
|
|
base06: '#e5ebf1',
|
|
base07: '#f7f9fb',
|
|
base08: '#bf8b56',
|
|
base09: '#bfbf56',
|
|
base0A: '#8bbf56',
|
|
base0B: '#56bf8b',
|
|
base0C: '#568bbf',
|
|
base0D: '#8b56bf',
|
|
base0E: '#bf568b',
|
|
base0F: '#bf5656'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 66732:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'hopscotch',
|
|
author: 'jan t. sott',
|
|
base00: '#322931',
|
|
base01: '#433b42',
|
|
base02: '#5c545b',
|
|
base03: '#797379',
|
|
base04: '#989498',
|
|
base05: '#b9b5b8',
|
|
base06: '#d5d3d5',
|
|
base07: '#ffffff',
|
|
base08: '#dd464c',
|
|
base09: '#fd8b19',
|
|
base0A: '#fdcc59',
|
|
base0B: '#8fc13e',
|
|
base0C: '#149b93',
|
|
base0D: '#1290bf',
|
|
base0E: '#c85e7c',
|
|
base0F: '#b33508'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 78052:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }
|
|
|
|
var _threezerotwofour = __webpack_require__(34104);
|
|
|
|
exports.threezerotwofour = _interopRequire(_threezerotwofour);
|
|
|
|
var _apathy = __webpack_require__(93535);
|
|
|
|
exports.apathy = _interopRequire(_apathy);
|
|
|
|
var _ashes = __webpack_require__(48000);
|
|
|
|
exports.ashes = _interopRequire(_ashes);
|
|
|
|
var _atelierDune = __webpack_require__(89575);
|
|
|
|
exports.atelierDune = _interopRequire(_atelierDune);
|
|
|
|
var _atelierForest = __webpack_require__(63295);
|
|
|
|
exports.atelierForest = _interopRequire(_atelierForest);
|
|
|
|
var _atelierHeath = __webpack_require__(68411);
|
|
|
|
exports.atelierHeath = _interopRequire(_atelierHeath);
|
|
|
|
var _atelierLakeside = __webpack_require__(20209);
|
|
|
|
exports.atelierLakeside = _interopRequire(_atelierLakeside);
|
|
|
|
var _atelierSeaside = __webpack_require__(5968);
|
|
|
|
exports.atelierSeaside = _interopRequire(_atelierSeaside);
|
|
|
|
var _bespin = __webpack_require__(20904);
|
|
|
|
exports.bespin = _interopRequire(_bespin);
|
|
|
|
var _brewer = __webpack_require__(87002);
|
|
|
|
exports.brewer = _interopRequire(_brewer);
|
|
|
|
var _bright = __webpack_require__(74865);
|
|
|
|
exports.bright = _interopRequire(_bright);
|
|
|
|
var _chalk = __webpack_require__(89483);
|
|
|
|
exports.chalk = _interopRequire(_chalk);
|
|
|
|
var _codeschool = __webpack_require__(15992);
|
|
|
|
exports.codeschool = _interopRequire(_codeschool);
|
|
|
|
var _colors = __webpack_require__(47340);
|
|
|
|
exports.colors = _interopRequire(_colors);
|
|
|
|
var _default = __webpack_require__(88968);
|
|
|
|
exports["default"] = _interopRequire(_default);
|
|
|
|
var _eighties = __webpack_require__(33424);
|
|
|
|
exports.eighties = _interopRequire(_eighties);
|
|
|
|
var _embers = __webpack_require__(95326);
|
|
|
|
exports.embers = _interopRequire(_embers);
|
|
|
|
var _flat = __webpack_require__(91907);
|
|
|
|
exports.flat = _interopRequire(_flat);
|
|
|
|
var _google = __webpack_require__(44026);
|
|
|
|
exports.google = _interopRequire(_google);
|
|
|
|
var _grayscale = __webpack_require__(93445);
|
|
|
|
exports.grayscale = _interopRequire(_grayscale);
|
|
|
|
var _greenscreen = __webpack_require__(62173);
|
|
|
|
exports.greenscreen = _interopRequire(_greenscreen);
|
|
|
|
var _harmonic = __webpack_require__(24978);
|
|
|
|
exports.harmonic = _interopRequire(_harmonic);
|
|
|
|
var _hopscotch = __webpack_require__(66732);
|
|
|
|
exports.hopscotch = _interopRequire(_hopscotch);
|
|
|
|
var _isotope = __webpack_require__(53614);
|
|
|
|
exports.isotope = _interopRequire(_isotope);
|
|
|
|
var _marrakesh = __webpack_require__(95650);
|
|
|
|
exports.marrakesh = _interopRequire(_marrakesh);
|
|
|
|
var _mocha = __webpack_require__(99699);
|
|
|
|
exports.mocha = _interopRequire(_mocha);
|
|
|
|
var _monokai = __webpack_require__(43756);
|
|
|
|
exports.monokai = _interopRequire(_monokai);
|
|
|
|
var _ocean = __webpack_require__(60889);
|
|
|
|
exports.ocean = _interopRequire(_ocean);
|
|
|
|
var _paraiso = __webpack_require__(27319);
|
|
|
|
exports.paraiso = _interopRequire(_paraiso);
|
|
|
|
var _pop = __webpack_require__(75030);
|
|
|
|
exports.pop = _interopRequire(_pop);
|
|
|
|
var _railscasts = __webpack_require__(89658);
|
|
|
|
exports.railscasts = _interopRequire(_railscasts);
|
|
|
|
var _shapeshifter = __webpack_require__(47900);
|
|
|
|
exports.shapeshifter = _interopRequire(_shapeshifter);
|
|
|
|
var _solarized = __webpack_require__(19077);
|
|
|
|
exports.solarized = _interopRequire(_solarized);
|
|
|
|
var _summerfruit = __webpack_require__(71126);
|
|
|
|
exports.summerfruit = _interopRequire(_summerfruit);
|
|
|
|
var _tomorrow = __webpack_require__(94107);
|
|
|
|
exports.tomorrow = _interopRequire(_tomorrow);
|
|
|
|
var _tube = __webpack_require__(52622);
|
|
|
|
exports.tube = _interopRequire(_tube);
|
|
|
|
var _twilight = __webpack_require__(25328);
|
|
|
|
exports.twilight = _interopRequire(_twilight);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 53614:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'isotope',
|
|
author: 'jan t. sott',
|
|
base00: '#000000',
|
|
base01: '#404040',
|
|
base02: '#606060',
|
|
base03: '#808080',
|
|
base04: '#c0c0c0',
|
|
base05: '#d0d0d0',
|
|
base06: '#e0e0e0',
|
|
base07: '#ffffff',
|
|
base08: '#ff0000',
|
|
base09: '#ff9900',
|
|
base0A: '#ff0099',
|
|
base0B: '#33ff00',
|
|
base0C: '#00ffff',
|
|
base0D: '#0066ff',
|
|
base0E: '#cc00ff',
|
|
base0F: '#3300ff'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 95650:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'marrakesh',
|
|
author: 'alexandre gavioli (http://github.com/alexx2/)',
|
|
base00: '#201602',
|
|
base01: '#302e00',
|
|
base02: '#5f5b17',
|
|
base03: '#6c6823',
|
|
base04: '#86813b',
|
|
base05: '#948e48',
|
|
base06: '#ccc37a',
|
|
base07: '#faf0a5',
|
|
base08: '#c35359',
|
|
base09: '#b36144',
|
|
base0A: '#a88339',
|
|
base0B: '#18974e',
|
|
base0C: '#75a738',
|
|
base0D: '#477ca1',
|
|
base0E: '#8868b3',
|
|
base0F: '#b3588e'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 99699:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'mocha',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#3B3228',
|
|
base01: '#534636',
|
|
base02: '#645240',
|
|
base03: '#7e705a',
|
|
base04: '#b8afad',
|
|
base05: '#d0c8c6',
|
|
base06: '#e9e1dd',
|
|
base07: '#f5eeeb',
|
|
base08: '#cb6077',
|
|
base09: '#d28b71',
|
|
base0A: '#f4bc87',
|
|
base0B: '#beb55b',
|
|
base0C: '#7bbda4',
|
|
base0D: '#8ab3b5',
|
|
base0E: '#a89bb9',
|
|
base0F: '#bb9584'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 43756:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'monokai',
|
|
author: 'wimer hazenberg (http://www.monokai.nl)',
|
|
base00: '#272822',
|
|
base01: '#383830',
|
|
base02: '#49483e',
|
|
base03: '#75715e',
|
|
base04: '#a59f85',
|
|
base05: '#f8f8f2',
|
|
base06: '#f5f4f1',
|
|
base07: '#f9f8f5',
|
|
base08: '#f92672',
|
|
base09: '#fd971f',
|
|
base0A: '#f4bf75',
|
|
base0B: '#a6e22e',
|
|
base0C: '#a1efe4',
|
|
base0D: '#66d9ef',
|
|
base0E: '#ae81ff',
|
|
base0F: '#cc6633'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 60889:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'ocean',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#2b303b',
|
|
base01: '#343d46',
|
|
base02: '#4f5b66',
|
|
base03: '#65737e',
|
|
base04: '#a7adba',
|
|
base05: '#c0c5ce',
|
|
base06: '#dfe1e8',
|
|
base07: '#eff1f5',
|
|
base08: '#bf616a',
|
|
base09: '#d08770',
|
|
base0A: '#ebcb8b',
|
|
base0B: '#a3be8c',
|
|
base0C: '#96b5b4',
|
|
base0D: '#8fa1b3',
|
|
base0E: '#b48ead',
|
|
base0F: '#ab7967'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 27319:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'paraiso',
|
|
author: 'jan t. sott',
|
|
base00: '#2f1e2e',
|
|
base01: '#41323f',
|
|
base02: '#4f424c',
|
|
base03: '#776e71',
|
|
base04: '#8d8687',
|
|
base05: '#a39e9b',
|
|
base06: '#b9b6b0',
|
|
base07: '#e7e9db',
|
|
base08: '#ef6155',
|
|
base09: '#f99b15',
|
|
base0A: '#fec418',
|
|
base0B: '#48b685',
|
|
base0C: '#5bc4bf',
|
|
base0D: '#06b6ef',
|
|
base0E: '#815ba4',
|
|
base0F: '#e96ba8'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 75030:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'pop',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#000000',
|
|
base01: '#202020',
|
|
base02: '#303030',
|
|
base03: '#505050',
|
|
base04: '#b0b0b0',
|
|
base05: '#d0d0d0',
|
|
base06: '#e0e0e0',
|
|
base07: '#ffffff',
|
|
base08: '#eb008a',
|
|
base09: '#f29333',
|
|
base0A: '#f8ca12',
|
|
base0B: '#37b349',
|
|
base0C: '#00aabb',
|
|
base0D: '#0e5a94',
|
|
base0E: '#b31e8d',
|
|
base0F: '#7a2d00'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 89658:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'railscasts',
|
|
author: 'ryan bates (http://railscasts.com)',
|
|
base00: '#2b2b2b',
|
|
base01: '#272935',
|
|
base02: '#3a4055',
|
|
base03: '#5a647e',
|
|
base04: '#d4cfc9',
|
|
base05: '#e6e1dc',
|
|
base06: '#f4f1ed',
|
|
base07: '#f9f7f3',
|
|
base08: '#da4939',
|
|
base09: '#cc7833',
|
|
base0A: '#ffc66d',
|
|
base0B: '#a5c261',
|
|
base0C: '#519f50',
|
|
base0D: '#6d9cbe',
|
|
base0E: '#b6b3eb',
|
|
base0F: '#bc9458'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 47900:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'shapeshifter',
|
|
author: 'tyler benziger (http://tybenz.com)',
|
|
base00: '#000000',
|
|
base01: '#040404',
|
|
base02: '#102015',
|
|
base03: '#343434',
|
|
base04: '#555555',
|
|
base05: '#ababab',
|
|
base06: '#e0e0e0',
|
|
base07: '#f9f9f9',
|
|
base08: '#e92f2f',
|
|
base09: '#e09448',
|
|
base0A: '#dddd13',
|
|
base0B: '#0ed839',
|
|
base0C: '#23edda',
|
|
base0D: '#3b48e3',
|
|
base0E: '#f996e2',
|
|
base0F: '#69542d'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 19077:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'solarized',
|
|
author: 'ethan schoonover (http://ethanschoonover.com/solarized)',
|
|
base00: '#002b36',
|
|
base01: '#073642',
|
|
base02: '#586e75',
|
|
base03: '#657b83',
|
|
base04: '#839496',
|
|
base05: '#93a1a1',
|
|
base06: '#eee8d5',
|
|
base07: '#fdf6e3',
|
|
base08: '#dc322f',
|
|
base09: '#cb4b16',
|
|
base0A: '#b58900',
|
|
base0B: '#859900',
|
|
base0C: '#2aa198',
|
|
base0D: '#268bd2',
|
|
base0E: '#6c71c4',
|
|
base0F: '#d33682'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 71126:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'summerfruit',
|
|
author: 'christopher corley (http://cscorley.github.io/)',
|
|
base00: '#151515',
|
|
base01: '#202020',
|
|
base02: '#303030',
|
|
base03: '#505050',
|
|
base04: '#B0B0B0',
|
|
base05: '#D0D0D0',
|
|
base06: '#E0E0E0',
|
|
base07: '#FFFFFF',
|
|
base08: '#FF0086',
|
|
base09: '#FD8900',
|
|
base0A: '#ABA800',
|
|
base0B: '#00C918',
|
|
base0C: '#1faaaa',
|
|
base0D: '#3777E6',
|
|
base0E: '#AD00A1',
|
|
base0F: '#cc6633'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 34104:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'threezerotwofour',
|
|
author: 'jan t. sott (http://github.com/idleberg)',
|
|
base00: '#090300',
|
|
base01: '#3a3432',
|
|
base02: '#4a4543',
|
|
base03: '#5c5855',
|
|
base04: '#807d7c',
|
|
base05: '#a5a2a2',
|
|
base06: '#d6d5d4',
|
|
base07: '#f7f7f7',
|
|
base08: '#db2d20',
|
|
base09: '#e8bbd0',
|
|
base0A: '#fded02',
|
|
base0B: '#01a252',
|
|
base0C: '#b5e4f4',
|
|
base0D: '#01a0e4',
|
|
base0E: '#a16a94',
|
|
base0F: '#cdab53'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 94107:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'tomorrow',
|
|
author: 'chris kempson (http://chriskempson.com)',
|
|
base00: '#1d1f21',
|
|
base01: '#282a2e',
|
|
base02: '#373b41',
|
|
base03: '#969896',
|
|
base04: '#b4b7b4',
|
|
base05: '#c5c8c6',
|
|
base06: '#e0e0e0',
|
|
base07: '#ffffff',
|
|
base08: '#cc6666',
|
|
base09: '#de935f',
|
|
base0A: '#f0c674',
|
|
base0B: '#b5bd68',
|
|
base0C: '#8abeb7',
|
|
base0D: '#81a2be',
|
|
base0E: '#b294bb',
|
|
base0F: '#a3685a'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 52622:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'london tube',
|
|
author: 'jan t. sott',
|
|
base00: '#231f20',
|
|
base01: '#1c3f95',
|
|
base02: '#5a5758',
|
|
base03: '#737171',
|
|
base04: '#959ca1',
|
|
base05: '#d9d8d8',
|
|
base06: '#e7e7e8',
|
|
base07: '#ffffff',
|
|
base08: '#ee2e24',
|
|
base09: '#f386a1',
|
|
base0A: '#ffd204',
|
|
base0B: '#00853e',
|
|
base0C: '#85cebc',
|
|
base0D: '#009ddc',
|
|
base0E: '#98005d',
|
|
base0F: '#b06110'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 25328:
|
|
/***/ ((module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
exports.__esModule = true;
|
|
exports["default"] = {
|
|
scheme: 'twilight',
|
|
author: 'david hart (http://hart-dev.com)',
|
|
base00: '#1e1e1e',
|
|
base01: '#323537',
|
|
base02: '#464b50',
|
|
base03: '#5f5a60',
|
|
base04: '#838184',
|
|
base05: '#a7a7a7',
|
|
base06: '#c3c3c3',
|
|
base07: '#ffffff',
|
|
base08: '#cf6a4c',
|
|
base09: '#cda869',
|
|
base0A: '#f9ee98',
|
|
base0B: '#8f9d6a',
|
|
base0C: '#afc4db',
|
|
base0D: '#7587a6',
|
|
base0E: '#9b859d',
|
|
base0F: '#9b703f'
|
|
};
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 47297:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
/* MIT license */
|
|
var cssKeywords = __webpack_require__(10626);
|
|
|
|
// NOTE: conversions should only return primitive values (i.e. arrays, or
|
|
// values that give correct `typeof` results).
|
|
// do not use box values types (i.e. Number(), String(), etc.)
|
|
|
|
var reverseKeywords = {};
|
|
for (var key in cssKeywords) {
|
|
if (cssKeywords.hasOwnProperty(key)) {
|
|
reverseKeywords[cssKeywords[key]] = key;
|
|
}
|
|
}
|
|
|
|
var convert = module.exports = {
|
|
rgb: {channels: 3, labels: 'rgb'},
|
|
hsl: {channels: 3, labels: 'hsl'},
|
|
hsv: {channels: 3, labels: 'hsv'},
|
|
hwb: {channels: 3, labels: 'hwb'},
|
|
cmyk: {channels: 4, labels: 'cmyk'},
|
|
xyz: {channels: 3, labels: 'xyz'},
|
|
lab: {channels: 3, labels: 'lab'},
|
|
lch: {channels: 3, labels: 'lch'},
|
|
hex: {channels: 1, labels: ['hex']},
|
|
keyword: {channels: 1, labels: ['keyword']},
|
|
ansi16: {channels: 1, labels: ['ansi16']},
|
|
ansi256: {channels: 1, labels: ['ansi256']},
|
|
hcg: {channels: 3, labels: ['h', 'c', 'g']},
|
|
apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
|
|
gray: {channels: 1, labels: ['gray']}
|
|
};
|
|
|
|
// hide .channels and .labels properties
|
|
for (var model in convert) {
|
|
if (convert.hasOwnProperty(model)) {
|
|
if (!('channels' in convert[model])) {
|
|
throw new Error('missing channels property: ' + model);
|
|
}
|
|
|
|
if (!('labels' in convert[model])) {
|
|
throw new Error('missing channel labels property: ' + model);
|
|
}
|
|
|
|
if (convert[model].labels.length !== convert[model].channels) {
|
|
throw new Error('channel and label counts mismatch: ' + model);
|
|
}
|
|
|
|
var channels = convert[model].channels;
|
|
var labels = convert[model].labels;
|
|
delete convert[model].channels;
|
|
delete convert[model].labels;
|
|
Object.defineProperty(convert[model], 'channels', {value: channels});
|
|
Object.defineProperty(convert[model], 'labels', {value: labels});
|
|
}
|
|
}
|
|
|
|
convert.rgb.hsl = function (rgb) {
|
|
var r = rgb[0] / 255;
|
|
var g = rgb[1] / 255;
|
|
var b = rgb[2] / 255;
|
|
var min = Math.min(r, g, b);
|
|
var max = Math.max(r, g, b);
|
|
var delta = max - min;
|
|
var h;
|
|
var s;
|
|
var l;
|
|
|
|
if (max === min) {
|
|
h = 0;
|
|
} else if (r === max) {
|
|
h = (g - b) / delta;
|
|
} else if (g === max) {
|
|
h = 2 + (b - r) / delta;
|
|
} else if (b === max) {
|
|
h = 4 + (r - g) / delta;
|
|
}
|
|
|
|
h = Math.min(h * 60, 360);
|
|
|
|
if (h < 0) {
|
|
h += 360;
|
|
}
|
|
|
|
l = (min + max) / 2;
|
|
|
|
if (max === min) {
|
|
s = 0;
|
|
} else if (l <= 0.5) {
|
|
s = delta / (max + min);
|
|
} else {
|
|
s = delta / (2 - max - min);
|
|
}
|
|
|
|
return [h, s * 100, l * 100];
|
|
};
|
|
|
|
convert.rgb.hsv = function (rgb) {
|
|
var rdif;
|
|
var gdif;
|
|
var bdif;
|
|
var h;
|
|
var s;
|
|
|
|
var r = rgb[0] / 255;
|
|
var g = rgb[1] / 255;
|
|
var b = rgb[2] / 255;
|
|
var v = Math.max(r, g, b);
|
|
var diff = v - Math.min(r, g, b);
|
|
var diffc = function (c) {
|
|
return (v - c) / 6 / diff + 1 / 2;
|
|
};
|
|
|
|
if (diff === 0) {
|
|
h = s = 0;
|
|
} else {
|
|
s = diff / v;
|
|
rdif = diffc(r);
|
|
gdif = diffc(g);
|
|
bdif = diffc(b);
|
|
|
|
if (r === v) {
|
|
h = bdif - gdif;
|
|
} else if (g === v) {
|
|
h = (1 / 3) + rdif - bdif;
|
|
} else if (b === v) {
|
|
h = (2 / 3) + gdif - rdif;
|
|
}
|
|
if (h < 0) {
|
|
h += 1;
|
|
} else if (h > 1) {
|
|
h -= 1;
|
|
}
|
|
}
|
|
|
|
return [
|
|
h * 360,
|
|
s * 100,
|
|
v * 100
|
|
];
|
|
};
|
|
|
|
convert.rgb.hwb = function (rgb) {
|
|
var r = rgb[0];
|
|
var g = rgb[1];
|
|
var b = rgb[2];
|
|
var h = convert.rgb.hsl(rgb)[0];
|
|
var w = 1 / 255 * Math.min(r, Math.min(g, b));
|
|
|
|
b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
|
|
|
|
return [h, w * 100, b * 100];
|
|
};
|
|
|
|
convert.rgb.cmyk = function (rgb) {
|
|
var r = rgb[0] / 255;
|
|
var g = rgb[1] / 255;
|
|
var b = rgb[2] / 255;
|
|
var c;
|
|
var m;
|
|
var y;
|
|
var k;
|
|
|
|
k = Math.min(1 - r, 1 - g, 1 - b);
|
|
c = (1 - r - k) / (1 - k) || 0;
|
|
m = (1 - g - k) / (1 - k) || 0;
|
|
y = (1 - b - k) / (1 - k) || 0;
|
|
|
|
return [c * 100, m * 100, y * 100, k * 100];
|
|
};
|
|
|
|
/**
|
|
* See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
|
|
* */
|
|
function comparativeDistance(x, y) {
|
|
return (
|
|
Math.pow(x[0] - y[0], 2) +
|
|
Math.pow(x[1] - y[1], 2) +
|
|
Math.pow(x[2] - y[2], 2)
|
|
);
|
|
}
|
|
|
|
convert.rgb.keyword = function (rgb) {
|
|
var reversed = reverseKeywords[rgb];
|
|
if (reversed) {
|
|
return reversed;
|
|
}
|
|
|
|
var currentClosestDistance = Infinity;
|
|
var currentClosestKeyword;
|
|
|
|
for (var keyword in cssKeywords) {
|
|
if (cssKeywords.hasOwnProperty(keyword)) {
|
|
var value = cssKeywords[keyword];
|
|
|
|
// Compute comparative distance
|
|
var distance = comparativeDistance(rgb, value);
|
|
|
|
// Check if its less, if so set as closest
|
|
if (distance < currentClosestDistance) {
|
|
currentClosestDistance = distance;
|
|
currentClosestKeyword = keyword;
|
|
}
|
|
}
|
|
}
|
|
|
|
return currentClosestKeyword;
|
|
};
|
|
|
|
convert.keyword.rgb = function (keyword) {
|
|
return cssKeywords[keyword];
|
|
};
|
|
|
|
convert.rgb.xyz = function (rgb) {
|
|
var r = rgb[0] / 255;
|
|
var g = rgb[1] / 255;
|
|
var b = rgb[2] / 255;
|
|
|
|
// assume sRGB
|
|
r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
|
|
g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
|
|
b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);
|
|
|
|
var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
|
|
var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
|
|
var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
|
|
|
|
return [x * 100, y * 100, z * 100];
|
|
};
|
|
|
|
convert.rgb.lab = function (rgb) {
|
|
var xyz = convert.rgb.xyz(rgb);
|
|
var x = xyz[0];
|
|
var y = xyz[1];
|
|
var z = xyz[2];
|
|
var l;
|
|
var a;
|
|
var b;
|
|
|
|
x /= 95.047;
|
|
y /= 100;
|
|
z /= 108.883;
|
|
|
|
x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
|
|
y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
|
|
z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
|
|
|
|
l = (116 * y) - 16;
|
|
a = 500 * (x - y);
|
|
b = 200 * (y - z);
|
|
|
|
return [l, a, b];
|
|
};
|
|
|
|
convert.hsl.rgb = function (hsl) {
|
|
var h = hsl[0] / 360;
|
|
var s = hsl[1] / 100;
|
|
var l = hsl[2] / 100;
|
|
var t1;
|
|
var t2;
|
|
var t3;
|
|
var rgb;
|
|
var val;
|
|
|
|
if (s === 0) {
|
|
val = l * 255;
|
|
return [val, val, val];
|
|
}
|
|
|
|
if (l < 0.5) {
|
|
t2 = l * (1 + s);
|
|
} else {
|
|
t2 = l + s - l * s;
|
|
}
|
|
|
|
t1 = 2 * l - t2;
|
|
|
|
rgb = [0, 0, 0];
|
|
for (var i = 0; i < 3; i++) {
|
|
t3 = h + 1 / 3 * -(i - 1);
|
|
if (t3 < 0) {
|
|
t3++;
|
|
}
|
|
if (t3 > 1) {
|
|
t3--;
|
|
}
|
|
|
|
if (6 * t3 < 1) {
|
|
val = t1 + (t2 - t1) * 6 * t3;
|
|
} else if (2 * t3 < 1) {
|
|
val = t2;
|
|
} else if (3 * t3 < 2) {
|
|
val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
|
|
} else {
|
|
val = t1;
|
|
}
|
|
|
|
rgb[i] = val * 255;
|
|
}
|
|
|
|
return rgb;
|
|
};
|
|
|
|
convert.hsl.hsv = function (hsl) {
|
|
var h = hsl[0];
|
|
var s = hsl[1] / 100;
|
|
var l = hsl[2] / 100;
|
|
var smin = s;
|
|
var lmin = Math.max(l, 0.01);
|
|
var sv;
|
|
var v;
|
|
|
|
l *= 2;
|
|
s *= (l <= 1) ? l : 2 - l;
|
|
smin *= lmin <= 1 ? lmin : 2 - lmin;
|
|
v = (l + s) / 2;
|
|
sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
|
|
|
|
return [h, sv * 100, v * 100];
|
|
};
|
|
|
|
convert.hsv.rgb = function (hsv) {
|
|
var h = hsv[0] / 60;
|
|
var s = hsv[1] / 100;
|
|
var v = hsv[2] / 100;
|
|
var hi = Math.floor(h) % 6;
|
|
|
|
var f = h - Math.floor(h);
|
|
var p = 255 * v * (1 - s);
|
|
var q = 255 * v * (1 - (s * f));
|
|
var t = 255 * v * (1 - (s * (1 - f)));
|
|
v *= 255;
|
|
|
|
switch (hi) {
|
|
case 0:
|
|
return [v, t, p];
|
|
case 1:
|
|
return [q, v, p];
|
|
case 2:
|
|
return [p, v, t];
|
|
case 3:
|
|
return [p, q, v];
|
|
case 4:
|
|
return [t, p, v];
|
|
case 5:
|
|
return [v, p, q];
|
|
}
|
|
};
|
|
|
|
convert.hsv.hsl = function (hsv) {
|
|
var h = hsv[0];
|
|
var s = hsv[1] / 100;
|
|
var v = hsv[2] / 100;
|
|
var vmin = Math.max(v, 0.01);
|
|
var lmin;
|
|
var sl;
|
|
var l;
|
|
|
|
l = (2 - s) * v;
|
|
lmin = (2 - s) * vmin;
|
|
sl = s * vmin;
|
|
sl /= (lmin <= 1) ? lmin : 2 - lmin;
|
|
sl = sl || 0;
|
|
l /= 2;
|
|
|
|
return [h, sl * 100, l * 100];
|
|
};
|
|
|
|
// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
|
|
convert.hwb.rgb = function (hwb) {
|
|
var h = hwb[0] / 360;
|
|
var wh = hwb[1] / 100;
|
|
var bl = hwb[2] / 100;
|
|
var ratio = wh + bl;
|
|
var i;
|
|
var v;
|
|
var f;
|
|
var n;
|
|
|
|
// wh + bl cant be > 1
|
|
if (ratio > 1) {
|
|
wh /= ratio;
|
|
bl /= ratio;
|
|
}
|
|
|
|
i = Math.floor(6 * h);
|
|
v = 1 - bl;
|
|
f = 6 * h - i;
|
|
|
|
if ((i & 0x01) !== 0) {
|
|
f = 1 - f;
|
|
}
|
|
|
|
n = wh + f * (v - wh); // linear interpolation
|
|
|
|
var r;
|
|
var g;
|
|
var b;
|
|
switch (i) {
|
|
default:
|
|
case 6:
|
|
case 0: r = v; g = n; b = wh; break;
|
|
case 1: r = n; g = v; b = wh; break;
|
|
case 2: r = wh; g = v; b = n; break;
|
|
case 3: r = wh; g = n; b = v; break;
|
|
case 4: r = n; g = wh; b = v; break;
|
|
case 5: r = v; g = wh; b = n; break;
|
|
}
|
|
|
|
return [r * 255, g * 255, b * 255];
|
|
};
|
|
|
|
convert.cmyk.rgb = function (cmyk) {
|
|
var c = cmyk[0] / 100;
|
|
var m = cmyk[1] / 100;
|
|
var y = cmyk[2] / 100;
|
|
var k = cmyk[3] / 100;
|
|
var r;
|
|
var g;
|
|
var b;
|
|
|
|
r = 1 - Math.min(1, c * (1 - k) + k);
|
|
g = 1 - Math.min(1, m * (1 - k) + k);
|
|
b = 1 - Math.min(1, y * (1 - k) + k);
|
|
|
|
return [r * 255, g * 255, b * 255];
|
|
};
|
|
|
|
convert.xyz.rgb = function (xyz) {
|
|
var x = xyz[0] / 100;
|
|
var y = xyz[1] / 100;
|
|
var z = xyz[2] / 100;
|
|
var r;
|
|
var g;
|
|
var b;
|
|
|
|
r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
|
|
g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
|
|
b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
|
|
|
|
// assume sRGB
|
|
r = r > 0.0031308
|
|
? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
|
|
: r * 12.92;
|
|
|
|
g = g > 0.0031308
|
|
? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
|
|
: g * 12.92;
|
|
|
|
b = b > 0.0031308
|
|
? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
|
|
: b * 12.92;
|
|
|
|
r = Math.min(Math.max(0, r), 1);
|
|
g = Math.min(Math.max(0, g), 1);
|
|
b = Math.min(Math.max(0, b), 1);
|
|
|
|
return [r * 255, g * 255, b * 255];
|
|
};
|
|
|
|
convert.xyz.lab = function (xyz) {
|
|
var x = xyz[0];
|
|
var y = xyz[1];
|
|
var z = xyz[2];
|
|
var l;
|
|
var a;
|
|
var b;
|
|
|
|
x /= 95.047;
|
|
y /= 100;
|
|
z /= 108.883;
|
|
|
|
x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
|
|
y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
|
|
z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
|
|
|
|
l = (116 * y) - 16;
|
|
a = 500 * (x - y);
|
|
b = 200 * (y - z);
|
|
|
|
return [l, a, b];
|
|
};
|
|
|
|
convert.lab.xyz = function (lab) {
|
|
var l = lab[0];
|
|
var a = lab[1];
|
|
var b = lab[2];
|
|
var x;
|
|
var y;
|
|
var z;
|
|
|
|
y = (l + 16) / 116;
|
|
x = a / 500 + y;
|
|
z = y - b / 200;
|
|
|
|
var y2 = Math.pow(y, 3);
|
|
var x2 = Math.pow(x, 3);
|
|
var z2 = Math.pow(z, 3);
|
|
y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
|
|
x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
|
|
z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
|
|
|
|
x *= 95.047;
|
|
y *= 100;
|
|
z *= 108.883;
|
|
|
|
return [x, y, z];
|
|
};
|
|
|
|
convert.lab.lch = function (lab) {
|
|
var l = lab[0];
|
|
var a = lab[1];
|
|
var b = lab[2];
|
|
var hr;
|
|
var h;
|
|
var c;
|
|
|
|
hr = Math.atan2(b, a);
|
|
h = hr * 360 / 2 / Math.PI;
|
|
|
|
if (h < 0) {
|
|
h += 360;
|
|
}
|
|
|
|
c = Math.sqrt(a * a + b * b);
|
|
|
|
return [l, c, h];
|
|
};
|
|
|
|
convert.lch.lab = function (lch) {
|
|
var l = lch[0];
|
|
var c = lch[1];
|
|
var h = lch[2];
|
|
var a;
|
|
var b;
|
|
var hr;
|
|
|
|
hr = h / 360 * 2 * Math.PI;
|
|
a = c * Math.cos(hr);
|
|
b = c * Math.sin(hr);
|
|
|
|
return [l, a, b];
|
|
};
|
|
|
|
convert.rgb.ansi16 = function (args) {
|
|
var r = args[0];
|
|
var g = args[1];
|
|
var b = args[2];
|
|
var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
|
|
|
|
value = Math.round(value / 50);
|
|
|
|
if (value === 0) {
|
|
return 30;
|
|
}
|
|
|
|
var ansi = 30
|
|
+ ((Math.round(b / 255) << 2)
|
|
| (Math.round(g / 255) << 1)
|
|
| Math.round(r / 255));
|
|
|
|
if (value === 2) {
|
|
ansi += 60;
|
|
}
|
|
|
|
return ansi;
|
|
};
|
|
|
|
convert.hsv.ansi16 = function (args) {
|
|
// optimization here; we already know the value and don't need to get
|
|
// it converted for us.
|
|
return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
|
|
};
|
|
|
|
convert.rgb.ansi256 = function (args) {
|
|
var r = args[0];
|
|
var g = args[1];
|
|
var b = args[2];
|
|
|
|
// we use the extended greyscale palette here, with the exception of
|
|
// black and white. normal palette only has 4 greyscale shades.
|
|
if (r === g && g === b) {
|
|
if (r < 8) {
|
|
return 16;
|
|
}
|
|
|
|
if (r > 248) {
|
|
return 231;
|
|
}
|
|
|
|
return Math.round(((r - 8) / 247) * 24) + 232;
|
|
}
|
|
|
|
var ansi = 16
|
|
+ (36 * Math.round(r / 255 * 5))
|
|
+ (6 * Math.round(g / 255 * 5))
|
|
+ Math.round(b / 255 * 5);
|
|
|
|
return ansi;
|
|
};
|
|
|
|
convert.ansi16.rgb = function (args) {
|
|
var color = args % 10;
|
|
|
|
// handle greyscale
|
|
if (color === 0 || color === 7) {
|
|
if (args > 50) {
|
|
color += 3.5;
|
|
}
|
|
|
|
color = color / 10.5 * 255;
|
|
|
|
return [color, color, color];
|
|
}
|
|
|
|
var mult = (~~(args > 50) + 1) * 0.5;
|
|
var r = ((color & 1) * mult) * 255;
|
|
var g = (((color >> 1) & 1) * mult) * 255;
|
|
var b = (((color >> 2) & 1) * mult) * 255;
|
|
|
|
return [r, g, b];
|
|
};
|
|
|
|
convert.ansi256.rgb = function (args) {
|
|
// handle greyscale
|
|
if (args >= 232) {
|
|
var c = (args - 232) * 10 + 8;
|
|
return [c, c, c];
|
|
}
|
|
|
|
args -= 16;
|
|
|
|
var rem;
|
|
var r = Math.floor(args / 36) / 5 * 255;
|
|
var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
|
|
var b = (rem % 6) / 5 * 255;
|
|
|
|
return [r, g, b];
|
|
};
|
|
|
|
convert.rgb.hex = function (args) {
|
|
var integer = ((Math.round(args[0]) & 0xFF) << 16)
|
|
+ ((Math.round(args[1]) & 0xFF) << 8)
|
|
+ (Math.round(args[2]) & 0xFF);
|
|
|
|
var string = integer.toString(16).toUpperCase();
|
|
return '000000'.substring(string.length) + string;
|
|
};
|
|
|
|
convert.hex.rgb = function (args) {
|
|
var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
|
|
if (!match) {
|
|
return [0, 0, 0];
|
|
}
|
|
|
|
var colorString = match[0];
|
|
|
|
if (match[0].length === 3) {
|
|
colorString = colorString.split('').map(function (char) {
|
|
return char + char;
|
|
}).join('');
|
|
}
|
|
|
|
var integer = parseInt(colorString, 16);
|
|
var r = (integer >> 16) & 0xFF;
|
|
var g = (integer >> 8) & 0xFF;
|
|
var b = integer & 0xFF;
|
|
|
|
return [r, g, b];
|
|
};
|
|
|
|
convert.rgb.hcg = function (rgb) {
|
|
var r = rgb[0] / 255;
|
|
var g = rgb[1] / 255;
|
|
var b = rgb[2] / 255;
|
|
var max = Math.max(Math.max(r, g), b);
|
|
var min = Math.min(Math.min(r, g), b);
|
|
var chroma = (max - min);
|
|
var grayscale;
|
|
var hue;
|
|
|
|
if (chroma < 1) {
|
|
grayscale = min / (1 - chroma);
|
|
} else {
|
|
grayscale = 0;
|
|
}
|
|
|
|
if (chroma <= 0) {
|
|
hue = 0;
|
|
} else
|
|
if (max === r) {
|
|
hue = ((g - b) / chroma) % 6;
|
|
} else
|
|
if (max === g) {
|
|
hue = 2 + (b - r) / chroma;
|
|
} else {
|
|
hue = 4 + (r - g) / chroma + 4;
|
|
}
|
|
|
|
hue /= 6;
|
|
hue %= 1;
|
|
|
|
return [hue * 360, chroma * 100, grayscale * 100];
|
|
};
|
|
|
|
convert.hsl.hcg = function (hsl) {
|
|
var s = hsl[1] / 100;
|
|
var l = hsl[2] / 100;
|
|
var c = 1;
|
|
var f = 0;
|
|
|
|
if (l < 0.5) {
|
|
c = 2.0 * s * l;
|
|
} else {
|
|
c = 2.0 * s * (1.0 - l);
|
|
}
|
|
|
|
if (c < 1.0) {
|
|
f = (l - 0.5 * c) / (1.0 - c);
|
|
}
|
|
|
|
return [hsl[0], c * 100, f * 100];
|
|
};
|
|
|
|
convert.hsv.hcg = function (hsv) {
|
|
var s = hsv[1] / 100;
|
|
var v = hsv[2] / 100;
|
|
|
|
var c = s * v;
|
|
var f = 0;
|
|
|
|
if (c < 1.0) {
|
|
f = (v - c) / (1 - c);
|
|
}
|
|
|
|
return [hsv[0], c * 100, f * 100];
|
|
};
|
|
|
|
convert.hcg.rgb = function (hcg) {
|
|
var h = hcg[0] / 360;
|
|
var c = hcg[1] / 100;
|
|
var g = hcg[2] / 100;
|
|
|
|
if (c === 0.0) {
|
|
return [g * 255, g * 255, g * 255];
|
|
}
|
|
|
|
var pure = [0, 0, 0];
|
|
var hi = (h % 1) * 6;
|
|
var v = hi % 1;
|
|
var w = 1 - v;
|
|
var mg = 0;
|
|
|
|
switch (Math.floor(hi)) {
|
|
case 0:
|
|
pure[0] = 1; pure[1] = v; pure[2] = 0; break;
|
|
case 1:
|
|
pure[0] = w; pure[1] = 1; pure[2] = 0; break;
|
|
case 2:
|
|
pure[0] = 0; pure[1] = 1; pure[2] = v; break;
|
|
case 3:
|
|
pure[0] = 0; pure[1] = w; pure[2] = 1; break;
|
|
case 4:
|
|
pure[0] = v; pure[1] = 0; pure[2] = 1; break;
|
|
default:
|
|
pure[0] = 1; pure[1] = 0; pure[2] = w;
|
|
}
|
|
|
|
mg = (1.0 - c) * g;
|
|
|
|
return [
|
|
(c * pure[0] + mg) * 255,
|
|
(c * pure[1] + mg) * 255,
|
|
(c * pure[2] + mg) * 255
|
|
];
|
|
};
|
|
|
|
convert.hcg.hsv = function (hcg) {
|
|
var c = hcg[1] / 100;
|
|
var g = hcg[2] / 100;
|
|
|
|
var v = c + g * (1.0 - c);
|
|
var f = 0;
|
|
|
|
if (v > 0.0) {
|
|
f = c / v;
|
|
}
|
|
|
|
return [hcg[0], f * 100, v * 100];
|
|
};
|
|
|
|
convert.hcg.hsl = function (hcg) {
|
|
var c = hcg[1] / 100;
|
|
var g = hcg[2] / 100;
|
|
|
|
var l = g * (1.0 - c) + 0.5 * c;
|
|
var s = 0;
|
|
|
|
if (l > 0.0 && l < 0.5) {
|
|
s = c / (2 * l);
|
|
} else
|
|
if (l >= 0.5 && l < 1.0) {
|
|
s = c / (2 * (1 - l));
|
|
}
|
|
|
|
return [hcg[0], s * 100, l * 100];
|
|
};
|
|
|
|
convert.hcg.hwb = function (hcg) {
|
|
var c = hcg[1] / 100;
|
|
var g = hcg[2] / 100;
|
|
var v = c + g * (1.0 - c);
|
|
return [hcg[0], (v - c) * 100, (1 - v) * 100];
|
|
};
|
|
|
|
convert.hwb.hcg = function (hwb) {
|
|
var w = hwb[1] / 100;
|
|
var b = hwb[2] / 100;
|
|
var v = 1 - b;
|
|
var c = v - w;
|
|
var g = 0;
|
|
|
|
if (c < 1) {
|
|
g = (v - c) / (1 - c);
|
|
}
|
|
|
|
return [hwb[0], c * 100, g * 100];
|
|
};
|
|
|
|
convert.apple.rgb = function (apple) {
|
|
return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
|
|
};
|
|
|
|
convert.rgb.apple = function (rgb) {
|
|
return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
|
|
};
|
|
|
|
convert.gray.rgb = function (args) {
|
|
return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
|
|
};
|
|
|
|
convert.gray.hsl = convert.gray.hsv = function (args) {
|
|
return [0, 0, args[0]];
|
|
};
|
|
|
|
convert.gray.hwb = function (gray) {
|
|
return [0, 100, gray[0]];
|
|
};
|
|
|
|
convert.gray.cmyk = function (gray) {
|
|
return [0, 0, 0, gray[0]];
|
|
};
|
|
|
|
convert.gray.lab = function (gray) {
|
|
return [gray[0], 0, 0];
|
|
};
|
|
|
|
convert.gray.hex = function (gray) {
|
|
var val = Math.round(gray[0] / 100 * 255) & 0xFF;
|
|
var integer = (val << 16) + (val << 8) + val;
|
|
|
|
var string = integer.toString(16).toUpperCase();
|
|
return '000000'.substring(string.length) + string;
|
|
};
|
|
|
|
convert.rgb.gray = function (rgb) {
|
|
var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
|
|
return [val / 255 * 100];
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 31642:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
var conversions = __webpack_require__(47297);
|
|
var route = __webpack_require__(77971);
|
|
|
|
var convert = {};
|
|
|
|
var models = Object.keys(conversions);
|
|
|
|
function wrapRaw(fn) {
|
|
var wrappedFn = function (args) {
|
|
if (args === undefined || args === null) {
|
|
return args;
|
|
}
|
|
|
|
if (arguments.length > 1) {
|
|
args = Array.prototype.slice.call(arguments);
|
|
}
|
|
|
|
return fn(args);
|
|
};
|
|
|
|
// preserve .conversion property if there is one
|
|
if ('conversion' in fn) {
|
|
wrappedFn.conversion = fn.conversion;
|
|
}
|
|
|
|
return wrappedFn;
|
|
}
|
|
|
|
function wrapRounded(fn) {
|
|
var wrappedFn = function (args) {
|
|
if (args === undefined || args === null) {
|
|
return args;
|
|
}
|
|
|
|
if (arguments.length > 1) {
|
|
args = Array.prototype.slice.call(arguments);
|
|
}
|
|
|
|
var result = fn(args);
|
|
|
|
// we're assuming the result is an array here.
|
|
// see notice in conversions.js; don't use box types
|
|
// in conversion functions.
|
|
if (typeof result === 'object') {
|
|
for (var len = result.length, i = 0; i < len; i++) {
|
|
result[i] = Math.round(result[i]);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
// preserve .conversion property if there is one
|
|
if ('conversion' in fn) {
|
|
wrappedFn.conversion = fn.conversion;
|
|
}
|
|
|
|
return wrappedFn;
|
|
}
|
|
|
|
models.forEach(function (fromModel) {
|
|
convert[fromModel] = {};
|
|
|
|
Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
|
|
Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
|
|
|
|
var routes = route(fromModel);
|
|
var routeModels = Object.keys(routes);
|
|
|
|
routeModels.forEach(function (toModel) {
|
|
var fn = routes[toModel];
|
|
|
|
convert[fromModel][toModel] = wrapRounded(fn);
|
|
convert[fromModel][toModel].raw = wrapRaw(fn);
|
|
});
|
|
});
|
|
|
|
module.exports = convert;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10626:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = {
|
|
"aliceblue": [240, 248, 255],
|
|
"antiquewhite": [250, 235, 215],
|
|
"aqua": [0, 255, 255],
|
|
"aquamarine": [127, 255, 212],
|
|
"azure": [240, 255, 255],
|
|
"beige": [245, 245, 220],
|
|
"bisque": [255, 228, 196],
|
|
"black": [0, 0, 0],
|
|
"blanchedalmond": [255, 235, 205],
|
|
"blue": [0, 0, 255],
|
|
"blueviolet": [138, 43, 226],
|
|
"brown": [165, 42, 42],
|
|
"burlywood": [222, 184, 135],
|
|
"cadetblue": [95, 158, 160],
|
|
"chartreuse": [127, 255, 0],
|
|
"chocolate": [210, 105, 30],
|
|
"coral": [255, 127, 80],
|
|
"cornflowerblue": [100, 149, 237],
|
|
"cornsilk": [255, 248, 220],
|
|
"crimson": [220, 20, 60],
|
|
"cyan": [0, 255, 255],
|
|
"darkblue": [0, 0, 139],
|
|
"darkcyan": [0, 139, 139],
|
|
"darkgoldenrod": [184, 134, 11],
|
|
"darkgray": [169, 169, 169],
|
|
"darkgreen": [0, 100, 0],
|
|
"darkgrey": [169, 169, 169],
|
|
"darkkhaki": [189, 183, 107],
|
|
"darkmagenta": [139, 0, 139],
|
|
"darkolivegreen": [85, 107, 47],
|
|
"darkorange": [255, 140, 0],
|
|
"darkorchid": [153, 50, 204],
|
|
"darkred": [139, 0, 0],
|
|
"darksalmon": [233, 150, 122],
|
|
"darkseagreen": [143, 188, 143],
|
|
"darkslateblue": [72, 61, 139],
|
|
"darkslategray": [47, 79, 79],
|
|
"darkslategrey": [47, 79, 79],
|
|
"darkturquoise": [0, 206, 209],
|
|
"darkviolet": [148, 0, 211],
|
|
"deeppink": [255, 20, 147],
|
|
"deepskyblue": [0, 191, 255],
|
|
"dimgray": [105, 105, 105],
|
|
"dimgrey": [105, 105, 105],
|
|
"dodgerblue": [30, 144, 255],
|
|
"firebrick": [178, 34, 34],
|
|
"floralwhite": [255, 250, 240],
|
|
"forestgreen": [34, 139, 34],
|
|
"fuchsia": [255, 0, 255],
|
|
"gainsboro": [220, 220, 220],
|
|
"ghostwhite": [248, 248, 255],
|
|
"gold": [255, 215, 0],
|
|
"goldenrod": [218, 165, 32],
|
|
"gray": [128, 128, 128],
|
|
"green": [0, 128, 0],
|
|
"greenyellow": [173, 255, 47],
|
|
"grey": [128, 128, 128],
|
|
"honeydew": [240, 255, 240],
|
|
"hotpink": [255, 105, 180],
|
|
"indianred": [205, 92, 92],
|
|
"indigo": [75, 0, 130],
|
|
"ivory": [255, 255, 240],
|
|
"khaki": [240, 230, 140],
|
|
"lavender": [230, 230, 250],
|
|
"lavenderblush": [255, 240, 245],
|
|
"lawngreen": [124, 252, 0],
|
|
"lemonchiffon": [255, 250, 205],
|
|
"lightblue": [173, 216, 230],
|
|
"lightcoral": [240, 128, 128],
|
|
"lightcyan": [224, 255, 255],
|
|
"lightgoldenrodyellow": [250, 250, 210],
|
|
"lightgray": [211, 211, 211],
|
|
"lightgreen": [144, 238, 144],
|
|
"lightgrey": [211, 211, 211],
|
|
"lightpink": [255, 182, 193],
|
|
"lightsalmon": [255, 160, 122],
|
|
"lightseagreen": [32, 178, 170],
|
|
"lightskyblue": [135, 206, 250],
|
|
"lightslategray": [119, 136, 153],
|
|
"lightslategrey": [119, 136, 153],
|
|
"lightsteelblue": [176, 196, 222],
|
|
"lightyellow": [255, 255, 224],
|
|
"lime": [0, 255, 0],
|
|
"limegreen": [50, 205, 50],
|
|
"linen": [250, 240, 230],
|
|
"magenta": [255, 0, 255],
|
|
"maroon": [128, 0, 0],
|
|
"mediumaquamarine": [102, 205, 170],
|
|
"mediumblue": [0, 0, 205],
|
|
"mediumorchid": [186, 85, 211],
|
|
"mediumpurple": [147, 112, 219],
|
|
"mediumseagreen": [60, 179, 113],
|
|
"mediumslateblue": [123, 104, 238],
|
|
"mediumspringgreen": [0, 250, 154],
|
|
"mediumturquoise": [72, 209, 204],
|
|
"mediumvioletred": [199, 21, 133],
|
|
"midnightblue": [25, 25, 112],
|
|
"mintcream": [245, 255, 250],
|
|
"mistyrose": [255, 228, 225],
|
|
"moccasin": [255, 228, 181],
|
|
"navajowhite": [255, 222, 173],
|
|
"navy": [0, 0, 128],
|
|
"oldlace": [253, 245, 230],
|
|
"olive": [128, 128, 0],
|
|
"olivedrab": [107, 142, 35],
|
|
"orange": [255, 165, 0],
|
|
"orangered": [255, 69, 0],
|
|
"orchid": [218, 112, 214],
|
|
"palegoldenrod": [238, 232, 170],
|
|
"palegreen": [152, 251, 152],
|
|
"paleturquoise": [175, 238, 238],
|
|
"palevioletred": [219, 112, 147],
|
|
"papayawhip": [255, 239, 213],
|
|
"peachpuff": [255, 218, 185],
|
|
"peru": [205, 133, 63],
|
|
"pink": [255, 192, 203],
|
|
"plum": [221, 160, 221],
|
|
"powderblue": [176, 224, 230],
|
|
"purple": [128, 0, 128],
|
|
"rebeccapurple": [102, 51, 153],
|
|
"red": [255, 0, 0],
|
|
"rosybrown": [188, 143, 143],
|
|
"royalblue": [65, 105, 225],
|
|
"saddlebrown": [139, 69, 19],
|
|
"salmon": [250, 128, 114],
|
|
"sandybrown": [244, 164, 96],
|
|
"seagreen": [46, 139, 87],
|
|
"seashell": [255, 245, 238],
|
|
"sienna": [160, 82, 45],
|
|
"silver": [192, 192, 192],
|
|
"skyblue": [135, 206, 235],
|
|
"slateblue": [106, 90, 205],
|
|
"slategray": [112, 128, 144],
|
|
"slategrey": [112, 128, 144],
|
|
"snow": [255, 250, 250],
|
|
"springgreen": [0, 255, 127],
|
|
"steelblue": [70, 130, 180],
|
|
"tan": [210, 180, 140],
|
|
"teal": [0, 128, 128],
|
|
"thistle": [216, 191, 216],
|
|
"tomato": [255, 99, 71],
|
|
"turquoise": [64, 224, 208],
|
|
"violet": [238, 130, 238],
|
|
"wheat": [245, 222, 179],
|
|
"white": [255, 255, 255],
|
|
"whitesmoke": [245, 245, 245],
|
|
"yellow": [255, 255, 0],
|
|
"yellowgreen": [154, 205, 50]
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 77971:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
var conversions = __webpack_require__(47297);
|
|
|
|
/*
|
|
this function routes a model to all other models.
|
|
|
|
all functions that are routed have a property `.conversion` attached
|
|
to the returned synthetic function. This property is an array
|
|
of strings, each with the steps in between the 'from' and 'to'
|
|
color models (inclusive).
|
|
|
|
conversions that are not possible simply are not included.
|
|
*/
|
|
|
|
function buildGraph() {
|
|
var graph = {};
|
|
// https://jsperf.com/object-keys-vs-for-in-with-closure/3
|
|
var models = Object.keys(conversions);
|
|
|
|
for (var len = models.length, i = 0; i < len; i++) {
|
|
graph[models[i]] = {
|
|
// http://jsperf.com/1-vs-infinity
|
|
// micro-opt, but this is simple.
|
|
distance: -1,
|
|
parent: null
|
|
};
|
|
}
|
|
|
|
return graph;
|
|
}
|
|
|
|
// https://en.wikipedia.org/wiki/Breadth-first_search
|
|
function deriveBFS(fromModel) {
|
|
var graph = buildGraph();
|
|
var queue = [fromModel]; // unshift -> queue -> pop
|
|
|
|
graph[fromModel].distance = 0;
|
|
|
|
while (queue.length) {
|
|
var current = queue.pop();
|
|
var adjacents = Object.keys(conversions[current]);
|
|
|
|
for (var len = adjacents.length, i = 0; i < len; i++) {
|
|
var adjacent = adjacents[i];
|
|
var node = graph[adjacent];
|
|
|
|
if (node.distance === -1) {
|
|
node.distance = graph[current].distance + 1;
|
|
node.parent = current;
|
|
queue.unshift(adjacent);
|
|
}
|
|
}
|
|
}
|
|
|
|
return graph;
|
|
}
|
|
|
|
function link(from, to) {
|
|
return function (args) {
|
|
return to(from(args));
|
|
};
|
|
}
|
|
|
|
function wrapConversion(toModel, graph) {
|
|
var path = [graph[toModel].parent, toModel];
|
|
var fn = conversions[graph[toModel].parent][toModel];
|
|
|
|
var cur = graph[toModel].parent;
|
|
while (graph[cur].parent) {
|
|
path.unshift(graph[cur].parent);
|
|
fn = link(conversions[graph[cur].parent][cur], fn);
|
|
cur = graph[cur].parent;
|
|
}
|
|
|
|
fn.conversion = path;
|
|
return fn;
|
|
}
|
|
|
|
module.exports = function (fromModel) {
|
|
var graph = deriveBFS(fromModel);
|
|
var conversion = {};
|
|
|
|
var models = Object.keys(graph);
|
|
for (var len = models.length, i = 0; i < len; i++) {
|
|
var toModel = models[i];
|
|
var node = graph[toModel];
|
|
|
|
if (node.parent === null) {
|
|
// no possible conversion, or this node is the source model.
|
|
continue;
|
|
}
|
|
|
|
conversion[toModel] = wrapConversion(toModel, graph);
|
|
}
|
|
|
|
return conversion;
|
|
};
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 49552:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = {
|
|
"aliceblue": [240, 248, 255],
|
|
"antiquewhite": [250, 235, 215],
|
|
"aqua": [0, 255, 255],
|
|
"aquamarine": [127, 255, 212],
|
|
"azure": [240, 255, 255],
|
|
"beige": [245, 245, 220],
|
|
"bisque": [255, 228, 196],
|
|
"black": [0, 0, 0],
|
|
"blanchedalmond": [255, 235, 205],
|
|
"blue": [0, 0, 255],
|
|
"blueviolet": [138, 43, 226],
|
|
"brown": [165, 42, 42],
|
|
"burlywood": [222, 184, 135],
|
|
"cadetblue": [95, 158, 160],
|
|
"chartreuse": [127, 255, 0],
|
|
"chocolate": [210, 105, 30],
|
|
"coral": [255, 127, 80],
|
|
"cornflowerblue": [100, 149, 237],
|
|
"cornsilk": [255, 248, 220],
|
|
"crimson": [220, 20, 60],
|
|
"cyan": [0, 255, 255],
|
|
"darkblue": [0, 0, 139],
|
|
"darkcyan": [0, 139, 139],
|
|
"darkgoldenrod": [184, 134, 11],
|
|
"darkgray": [169, 169, 169],
|
|
"darkgreen": [0, 100, 0],
|
|
"darkgrey": [169, 169, 169],
|
|
"darkkhaki": [189, 183, 107],
|
|
"darkmagenta": [139, 0, 139],
|
|
"darkolivegreen": [85, 107, 47],
|
|
"darkorange": [255, 140, 0],
|
|
"darkorchid": [153, 50, 204],
|
|
"darkred": [139, 0, 0],
|
|
"darksalmon": [233, 150, 122],
|
|
"darkseagreen": [143, 188, 143],
|
|
"darkslateblue": [72, 61, 139],
|
|
"darkslategray": [47, 79, 79],
|
|
"darkslategrey": [47, 79, 79],
|
|
"darkturquoise": [0, 206, 209],
|
|
"darkviolet": [148, 0, 211],
|
|
"deeppink": [255, 20, 147],
|
|
"deepskyblue": [0, 191, 255],
|
|
"dimgray": [105, 105, 105],
|
|
"dimgrey": [105, 105, 105],
|
|
"dodgerblue": [30, 144, 255],
|
|
"firebrick": [178, 34, 34],
|
|
"floralwhite": [255, 250, 240],
|
|
"forestgreen": [34, 139, 34],
|
|
"fuchsia": [255, 0, 255],
|
|
"gainsboro": [220, 220, 220],
|
|
"ghostwhite": [248, 248, 255],
|
|
"gold": [255, 215, 0],
|
|
"goldenrod": [218, 165, 32],
|
|
"gray": [128, 128, 128],
|
|
"green": [0, 128, 0],
|
|
"greenyellow": [173, 255, 47],
|
|
"grey": [128, 128, 128],
|
|
"honeydew": [240, 255, 240],
|
|
"hotpink": [255, 105, 180],
|
|
"indianred": [205, 92, 92],
|
|
"indigo": [75, 0, 130],
|
|
"ivory": [255, 255, 240],
|
|
"khaki": [240, 230, 140],
|
|
"lavender": [230, 230, 250],
|
|
"lavenderblush": [255, 240, 245],
|
|
"lawngreen": [124, 252, 0],
|
|
"lemonchiffon": [255, 250, 205],
|
|
"lightblue": [173, 216, 230],
|
|
"lightcoral": [240, 128, 128],
|
|
"lightcyan": [224, 255, 255],
|
|
"lightgoldenrodyellow": [250, 250, 210],
|
|
"lightgray": [211, 211, 211],
|
|
"lightgreen": [144, 238, 144],
|
|
"lightgrey": [211, 211, 211],
|
|
"lightpink": [255, 182, 193],
|
|
"lightsalmon": [255, 160, 122],
|
|
"lightseagreen": [32, 178, 170],
|
|
"lightskyblue": [135, 206, 250],
|
|
"lightslategray": [119, 136, 153],
|
|
"lightslategrey": [119, 136, 153],
|
|
"lightsteelblue": [176, 196, 222],
|
|
"lightyellow": [255, 255, 224],
|
|
"lime": [0, 255, 0],
|
|
"limegreen": [50, 205, 50],
|
|
"linen": [250, 240, 230],
|
|
"magenta": [255, 0, 255],
|
|
"maroon": [128, 0, 0],
|
|
"mediumaquamarine": [102, 205, 170],
|
|
"mediumblue": [0, 0, 205],
|
|
"mediumorchid": [186, 85, 211],
|
|
"mediumpurple": [147, 112, 219],
|
|
"mediumseagreen": [60, 179, 113],
|
|
"mediumslateblue": [123, 104, 238],
|
|
"mediumspringgreen": [0, 250, 154],
|
|
"mediumturquoise": [72, 209, 204],
|
|
"mediumvioletred": [199, 21, 133],
|
|
"midnightblue": [25, 25, 112],
|
|
"mintcream": [245, 255, 250],
|
|
"mistyrose": [255, 228, 225],
|
|
"moccasin": [255, 228, 181],
|
|
"navajowhite": [255, 222, 173],
|
|
"navy": [0, 0, 128],
|
|
"oldlace": [253, 245, 230],
|
|
"olive": [128, 128, 0],
|
|
"olivedrab": [107, 142, 35],
|
|
"orange": [255, 165, 0],
|
|
"orangered": [255, 69, 0],
|
|
"orchid": [218, 112, 214],
|
|
"palegoldenrod": [238, 232, 170],
|
|
"palegreen": [152, 251, 152],
|
|
"paleturquoise": [175, 238, 238],
|
|
"palevioletred": [219, 112, 147],
|
|
"papayawhip": [255, 239, 213],
|
|
"peachpuff": [255, 218, 185],
|
|
"peru": [205, 133, 63],
|
|
"pink": [255, 192, 203],
|
|
"plum": [221, 160, 221],
|
|
"powderblue": [176, 224, 230],
|
|
"purple": [128, 0, 128],
|
|
"rebeccapurple": [102, 51, 153],
|
|
"red": [255, 0, 0],
|
|
"rosybrown": [188, 143, 143],
|
|
"royalblue": [65, 105, 225],
|
|
"saddlebrown": [139, 69, 19],
|
|
"salmon": [250, 128, 114],
|
|
"sandybrown": [244, 164, 96],
|
|
"seagreen": [46, 139, 87],
|
|
"seashell": [255, 245, 238],
|
|
"sienna": [160, 82, 45],
|
|
"silver": [192, 192, 192],
|
|
"skyblue": [135, 206, 235],
|
|
"slateblue": [106, 90, 205],
|
|
"slategray": [112, 128, 144],
|
|
"slategrey": [112, 128, 144],
|
|
"snow": [255, 250, 250],
|
|
"springgreen": [0, 255, 127],
|
|
"steelblue": [70, 130, 180],
|
|
"tan": [210, 180, 140],
|
|
"teal": [0, 128, 128],
|
|
"thistle": [216, 191, 216],
|
|
"tomato": [255, 99, 71],
|
|
"turquoise": [64, 224, 208],
|
|
"violet": [238, 130, 238],
|
|
"wheat": [245, 222, 179],
|
|
"white": [255, 255, 255],
|
|
"whitesmoke": [245, 245, 245],
|
|
"yellow": [255, 255, 0],
|
|
"yellowgreen": [154, 205, 50]
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 96855:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
/* MIT license */
|
|
var colorNames = __webpack_require__(49552);
|
|
var swizzle = __webpack_require__(10521);
|
|
var hasOwnProperty = Object.hasOwnProperty;
|
|
|
|
var reverseNames = Object.create(null);
|
|
|
|
// create a list of reverse color names
|
|
for (var name in colorNames) {
|
|
if (hasOwnProperty.call(colorNames, name)) {
|
|
reverseNames[colorNames[name]] = name;
|
|
}
|
|
}
|
|
|
|
var cs = module.exports = {
|
|
to: {},
|
|
get: {}
|
|
};
|
|
|
|
cs.get = function (string) {
|
|
var prefix = string.substring(0, 3).toLowerCase();
|
|
var val;
|
|
var model;
|
|
switch (prefix) {
|
|
case 'hsl':
|
|
val = cs.get.hsl(string);
|
|
model = 'hsl';
|
|
break;
|
|
case 'hwb':
|
|
val = cs.get.hwb(string);
|
|
model = 'hwb';
|
|
break;
|
|
default:
|
|
val = cs.get.rgb(string);
|
|
model = 'rgb';
|
|
break;
|
|
}
|
|
|
|
if (!val) {
|
|
return null;
|
|
}
|
|
|
|
return {model: model, value: val};
|
|
};
|
|
|
|
cs.get.rgb = function (string) {
|
|
if (!string) {
|
|
return null;
|
|
}
|
|
|
|
var abbr = /^#([a-f0-9]{3,4})$/i;
|
|
var hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i;
|
|
var rgba = /^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/;
|
|
var per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/;
|
|
var keyword = /^(\w+)$/;
|
|
|
|
var rgb = [0, 0, 0, 1];
|
|
var match;
|
|
var i;
|
|
var hexAlpha;
|
|
|
|
if (match = string.match(hex)) {
|
|
hexAlpha = match[2];
|
|
match = match[1];
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
// https://jsperf.com/slice-vs-substr-vs-substring-methods-long-string/19
|
|
var i2 = i * 2;
|
|
rgb[i] = parseInt(match.slice(i2, i2 + 2), 16);
|
|
}
|
|
|
|
if (hexAlpha) {
|
|
rgb[3] = parseInt(hexAlpha, 16) / 255;
|
|
}
|
|
} else if (match = string.match(abbr)) {
|
|
match = match[1];
|
|
hexAlpha = match[3];
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
rgb[i] = parseInt(match[i] + match[i], 16);
|
|
}
|
|
|
|
if (hexAlpha) {
|
|
rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255;
|
|
}
|
|
} else if (match = string.match(rgba)) {
|
|
for (i = 0; i < 3; i++) {
|
|
rgb[i] = parseInt(match[i + 1], 0);
|
|
}
|
|
|
|
if (match[4]) {
|
|
if (match[5]) {
|
|
rgb[3] = parseFloat(match[4]) * 0.01;
|
|
} else {
|
|
rgb[3] = parseFloat(match[4]);
|
|
}
|
|
}
|
|
} else if (match = string.match(per)) {
|
|
for (i = 0; i < 3; i++) {
|
|
rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);
|
|
}
|
|
|
|
if (match[4]) {
|
|
if (match[5]) {
|
|
rgb[3] = parseFloat(match[4]) * 0.01;
|
|
} else {
|
|
rgb[3] = parseFloat(match[4]);
|
|
}
|
|
}
|
|
} else if (match = string.match(keyword)) {
|
|
if (match[1] === 'transparent') {
|
|
return [0, 0, 0, 0];
|
|
}
|
|
|
|
if (!hasOwnProperty.call(colorNames, match[1])) {
|
|
return null;
|
|
}
|
|
|
|
rgb = colorNames[match[1]];
|
|
rgb[3] = 1;
|
|
|
|
return rgb;
|
|
} else {
|
|
return null;
|
|
}
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
rgb[i] = clamp(rgb[i], 0, 255);
|
|
}
|
|
rgb[3] = clamp(rgb[3], 0, 1);
|
|
|
|
return rgb;
|
|
};
|
|
|
|
cs.get.hsl = function (string) {
|
|
if (!string) {
|
|
return null;
|
|
}
|
|
|
|
var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/;
|
|
var match = string.match(hsl);
|
|
|
|
if (match) {
|
|
var alpha = parseFloat(match[4]);
|
|
var h = ((parseFloat(match[1]) % 360) + 360) % 360;
|
|
var s = clamp(parseFloat(match[2]), 0, 100);
|
|
var l = clamp(parseFloat(match[3]), 0, 100);
|
|
var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);
|
|
|
|
return [h, s, l, a];
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
cs.get.hwb = function (string) {
|
|
if (!string) {
|
|
return null;
|
|
}
|
|
|
|
var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/;
|
|
var match = string.match(hwb);
|
|
|
|
if (match) {
|
|
var alpha = parseFloat(match[4]);
|
|
var h = ((parseFloat(match[1]) % 360) + 360) % 360;
|
|
var w = clamp(parseFloat(match[2]), 0, 100);
|
|
var b = clamp(parseFloat(match[3]), 0, 100);
|
|
var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);
|
|
return [h, w, b, a];
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
cs.to.hex = function () {
|
|
var rgba = swizzle(arguments);
|
|
|
|
return (
|
|
'#' +
|
|
hexDouble(rgba[0]) +
|
|
hexDouble(rgba[1]) +
|
|
hexDouble(rgba[2]) +
|
|
(rgba[3] < 1
|
|
? (hexDouble(Math.round(rgba[3] * 255)))
|
|
: '')
|
|
);
|
|
};
|
|
|
|
cs.to.rgb = function () {
|
|
var rgba = swizzle(arguments);
|
|
|
|
return rgba.length < 4 || rgba[3] === 1
|
|
? 'rgb(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ')'
|
|
: 'rgba(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ', ' + rgba[3] + ')';
|
|
};
|
|
|
|
cs.to.rgb.percent = function () {
|
|
var rgba = swizzle(arguments);
|
|
|
|
var r = Math.round(rgba[0] / 255 * 100);
|
|
var g = Math.round(rgba[1] / 255 * 100);
|
|
var b = Math.round(rgba[2] / 255 * 100);
|
|
|
|
return rgba.length < 4 || rgba[3] === 1
|
|
? 'rgb(' + r + '%, ' + g + '%, ' + b + '%)'
|
|
: 'rgba(' + r + '%, ' + g + '%, ' + b + '%, ' + rgba[3] + ')';
|
|
};
|
|
|
|
cs.to.hsl = function () {
|
|
var hsla = swizzle(arguments);
|
|
return hsla.length < 4 || hsla[3] === 1
|
|
? 'hsl(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%)'
|
|
: 'hsla(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%, ' + hsla[3] + ')';
|
|
};
|
|
|
|
// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax
|
|
// (hwb have alpha optional & 1 is default value)
|
|
cs.to.hwb = function () {
|
|
var hwba = swizzle(arguments);
|
|
|
|
var a = '';
|
|
if (hwba.length >= 4 && hwba[3] !== 1) {
|
|
a = ', ' + hwba[3];
|
|
}
|
|
|
|
return 'hwb(' + hwba[0] + ', ' + hwba[1] + '%, ' + hwba[2] + '%' + a + ')';
|
|
};
|
|
|
|
cs.to.keyword = function (rgb) {
|
|
return reverseNames[rgb.slice(0, 3)];
|
|
};
|
|
|
|
// helpers
|
|
function clamp(num, min, max) {
|
|
return Math.min(Math.max(min, num), max);
|
|
}
|
|
|
|
function hexDouble(num) {
|
|
var str = Math.round(num).toString(16).toUpperCase();
|
|
return (str.length < 2) ? '0' + str : str;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 27124:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var colorString = __webpack_require__(96855);
|
|
var convert = __webpack_require__(31642);
|
|
|
|
var _slice = [].slice;
|
|
|
|
var skippedModels = [
|
|
// to be honest, I don't really feel like keyword belongs in color convert, but eh.
|
|
'keyword',
|
|
|
|
// gray conflicts with some method names, and has its own method defined.
|
|
'gray',
|
|
|
|
// shouldn't really be in color-convert either...
|
|
'hex'
|
|
];
|
|
|
|
var hashedModelKeys = {};
|
|
Object.keys(convert).forEach(function (model) {
|
|
hashedModelKeys[_slice.call(convert[model].labels).sort().join('')] = model;
|
|
});
|
|
|
|
var limiters = {};
|
|
|
|
function Color(obj, model) {
|
|
if (!(this instanceof Color)) {
|
|
return new Color(obj, model);
|
|
}
|
|
|
|
if (model && model in skippedModels) {
|
|
model = null;
|
|
}
|
|
|
|
if (model && !(model in convert)) {
|
|
throw new Error('Unknown model: ' + model);
|
|
}
|
|
|
|
var i;
|
|
var channels;
|
|
|
|
if (obj == null) { // eslint-disable-line no-eq-null,eqeqeq
|
|
this.model = 'rgb';
|
|
this.color = [0, 0, 0];
|
|
this.valpha = 1;
|
|
} else if (obj instanceof Color) {
|
|
this.model = obj.model;
|
|
this.color = obj.color.slice();
|
|
this.valpha = obj.valpha;
|
|
} else if (typeof obj === 'string') {
|
|
var result = colorString.get(obj);
|
|
if (result === null) {
|
|
throw new Error('Unable to parse color from string: ' + obj);
|
|
}
|
|
|
|
this.model = result.model;
|
|
channels = convert[this.model].channels;
|
|
this.color = result.value.slice(0, channels);
|
|
this.valpha = typeof result.value[channels] === 'number' ? result.value[channels] : 1;
|
|
} else if (obj.length) {
|
|
this.model = model || 'rgb';
|
|
channels = convert[this.model].channels;
|
|
var newArr = _slice.call(obj, 0, channels);
|
|
this.color = zeroArray(newArr, channels);
|
|
this.valpha = typeof obj[channels] === 'number' ? obj[channels] : 1;
|
|
} else if (typeof obj === 'number') {
|
|
// this is always RGB - can be converted later on.
|
|
obj &= 0xFFFFFF;
|
|
this.model = 'rgb';
|
|
this.color = [
|
|
(obj >> 16) & 0xFF,
|
|
(obj >> 8) & 0xFF,
|
|
obj & 0xFF
|
|
];
|
|
this.valpha = 1;
|
|
} else {
|
|
this.valpha = 1;
|
|
|
|
var keys = Object.keys(obj);
|
|
if ('alpha' in obj) {
|
|
keys.splice(keys.indexOf('alpha'), 1);
|
|
this.valpha = typeof obj.alpha === 'number' ? obj.alpha : 0;
|
|
}
|
|
|
|
var hashedKeys = keys.sort().join('');
|
|
if (!(hashedKeys in hashedModelKeys)) {
|
|
throw new Error('Unable to parse color from object: ' + JSON.stringify(obj));
|
|
}
|
|
|
|
this.model = hashedModelKeys[hashedKeys];
|
|
|
|
var labels = convert[this.model].labels;
|
|
var color = [];
|
|
for (i = 0; i < labels.length; i++) {
|
|
color.push(obj[labels[i]]);
|
|
}
|
|
|
|
this.color = zeroArray(color);
|
|
}
|
|
|
|
// perform limitations (clamping, etc.)
|
|
if (limiters[this.model]) {
|
|
channels = convert[this.model].channels;
|
|
for (i = 0; i < channels; i++) {
|
|
var limit = limiters[this.model][i];
|
|
if (limit) {
|
|
this.color[i] = limit(this.color[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.valpha = Math.max(0, Math.min(1, this.valpha));
|
|
|
|
if (Object.freeze) {
|
|
Object.freeze(this);
|
|
}
|
|
}
|
|
|
|
Color.prototype = {
|
|
toString: function () {
|
|
return this.string();
|
|
},
|
|
|
|
toJSON: function () {
|
|
return this[this.model]();
|
|
},
|
|
|
|
string: function (places) {
|
|
var self = this.model in colorString.to ? this : this.rgb();
|
|
self = self.round(typeof places === 'number' ? places : 1);
|
|
var args = self.valpha === 1 ? self.color : self.color.concat(this.valpha);
|
|
return colorString.to[self.model](args);
|
|
},
|
|
|
|
percentString: function (places) {
|
|
var self = this.rgb().round(typeof places === 'number' ? places : 1);
|
|
var args = self.valpha === 1 ? self.color : self.color.concat(this.valpha);
|
|
return colorString.to.rgb.percent(args);
|
|
},
|
|
|
|
array: function () {
|
|
return this.valpha === 1 ? this.color.slice() : this.color.concat(this.valpha);
|
|
},
|
|
|
|
object: function () {
|
|
var result = {};
|
|
var channels = convert[this.model].channels;
|
|
var labels = convert[this.model].labels;
|
|
|
|
for (var i = 0; i < channels; i++) {
|
|
result[labels[i]] = this.color[i];
|
|
}
|
|
|
|
if (this.valpha !== 1) {
|
|
result.alpha = this.valpha;
|
|
}
|
|
|
|
return result;
|
|
},
|
|
|
|
unitArray: function () {
|
|
var rgb = this.rgb().color;
|
|
rgb[0] /= 255;
|
|
rgb[1] /= 255;
|
|
rgb[2] /= 255;
|
|
|
|
if (this.valpha !== 1) {
|
|
rgb.push(this.valpha);
|
|
}
|
|
|
|
return rgb;
|
|
},
|
|
|
|
unitObject: function () {
|
|
var rgb = this.rgb().object();
|
|
rgb.r /= 255;
|
|
rgb.g /= 255;
|
|
rgb.b /= 255;
|
|
|
|
if (this.valpha !== 1) {
|
|
rgb.alpha = this.valpha;
|
|
}
|
|
|
|
return rgb;
|
|
},
|
|
|
|
round: function (places) {
|
|
places = Math.max(places || 0, 0);
|
|
return new Color(this.color.map(roundToPlace(places)).concat(this.valpha), this.model);
|
|
},
|
|
|
|
alpha: function (val) {
|
|
if (arguments.length) {
|
|
return new Color(this.color.concat(Math.max(0, Math.min(1, val))), this.model);
|
|
}
|
|
|
|
return this.valpha;
|
|
},
|
|
|
|
// rgb
|
|
red: getset('rgb', 0, maxfn(255)),
|
|
green: getset('rgb', 1, maxfn(255)),
|
|
blue: getset('rgb', 2, maxfn(255)),
|
|
|
|
hue: getset(['hsl', 'hsv', 'hsl', 'hwb', 'hcg'], 0, function (val) { return ((val % 360) + 360) % 360; }), // eslint-disable-line brace-style
|
|
|
|
saturationl: getset('hsl', 1, maxfn(100)),
|
|
lightness: getset('hsl', 2, maxfn(100)),
|
|
|
|
saturationv: getset('hsv', 1, maxfn(100)),
|
|
value: getset('hsv', 2, maxfn(100)),
|
|
|
|
chroma: getset('hcg', 1, maxfn(100)),
|
|
gray: getset('hcg', 2, maxfn(100)),
|
|
|
|
white: getset('hwb', 1, maxfn(100)),
|
|
wblack: getset('hwb', 2, maxfn(100)),
|
|
|
|
cyan: getset('cmyk', 0, maxfn(100)),
|
|
magenta: getset('cmyk', 1, maxfn(100)),
|
|
yellow: getset('cmyk', 2, maxfn(100)),
|
|
black: getset('cmyk', 3, maxfn(100)),
|
|
|
|
x: getset('xyz', 0, maxfn(100)),
|
|
y: getset('xyz', 1, maxfn(100)),
|
|
z: getset('xyz', 2, maxfn(100)),
|
|
|
|
l: getset('lab', 0, maxfn(100)),
|
|
a: getset('lab', 1),
|
|
b: getset('lab', 2),
|
|
|
|
keyword: function (val) {
|
|
if (arguments.length) {
|
|
return new Color(val);
|
|
}
|
|
|
|
return convert[this.model].keyword(this.color);
|
|
},
|
|
|
|
hex: function (val) {
|
|
if (arguments.length) {
|
|
return new Color(val);
|
|
}
|
|
|
|
return colorString.to.hex(this.rgb().round().color);
|
|
},
|
|
|
|
rgbNumber: function () {
|
|
var rgb = this.rgb().color;
|
|
return ((rgb[0] & 0xFF) << 16) | ((rgb[1] & 0xFF) << 8) | (rgb[2] & 0xFF);
|
|
},
|
|
|
|
luminosity: function () {
|
|
// http://www.w3.org/TR/WCAG20/#relativeluminancedef
|
|
var rgb = this.rgb().color;
|
|
|
|
var lum = [];
|
|
for (var i = 0; i < rgb.length; i++) {
|
|
var chan = rgb[i] / 255;
|
|
lum[i] = (chan <= 0.03928) ? chan / 12.92 : Math.pow(((chan + 0.055) / 1.055), 2.4);
|
|
}
|
|
|
|
return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];
|
|
},
|
|
|
|
contrast: function (color2) {
|
|
// http://www.w3.org/TR/WCAG20/#contrast-ratiodef
|
|
var lum1 = this.luminosity();
|
|
var lum2 = color2.luminosity();
|
|
|
|
if (lum1 > lum2) {
|
|
return (lum1 + 0.05) / (lum2 + 0.05);
|
|
}
|
|
|
|
return (lum2 + 0.05) / (lum1 + 0.05);
|
|
},
|
|
|
|
level: function (color2) {
|
|
var contrastRatio = this.contrast(color2);
|
|
if (contrastRatio >= 7.1) {
|
|
return 'AAA';
|
|
}
|
|
|
|
return (contrastRatio >= 4.5) ? 'AA' : '';
|
|
},
|
|
|
|
isDark: function () {
|
|
// YIQ equation from http://24ways.org/2010/calculating-color-contrast
|
|
var rgb = this.rgb().color;
|
|
var yiq = (rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1000;
|
|
return yiq < 128;
|
|
},
|
|
|
|
isLight: function () {
|
|
return !this.isDark();
|
|
},
|
|
|
|
negate: function () {
|
|
var rgb = this.rgb();
|
|
for (var i = 0; i < 3; i++) {
|
|
rgb.color[i] = 255 - rgb.color[i];
|
|
}
|
|
return rgb;
|
|
},
|
|
|
|
lighten: function (ratio) {
|
|
var hsl = this.hsl();
|
|
hsl.color[2] += hsl.color[2] * ratio;
|
|
return hsl;
|
|
},
|
|
|
|
darken: function (ratio) {
|
|
var hsl = this.hsl();
|
|
hsl.color[2] -= hsl.color[2] * ratio;
|
|
return hsl;
|
|
},
|
|
|
|
saturate: function (ratio) {
|
|
var hsl = this.hsl();
|
|
hsl.color[1] += hsl.color[1] * ratio;
|
|
return hsl;
|
|
},
|
|
|
|
desaturate: function (ratio) {
|
|
var hsl = this.hsl();
|
|
hsl.color[1] -= hsl.color[1] * ratio;
|
|
return hsl;
|
|
},
|
|
|
|
whiten: function (ratio) {
|
|
var hwb = this.hwb();
|
|
hwb.color[1] += hwb.color[1] * ratio;
|
|
return hwb;
|
|
},
|
|
|
|
blacken: function (ratio) {
|
|
var hwb = this.hwb();
|
|
hwb.color[2] += hwb.color[2] * ratio;
|
|
return hwb;
|
|
},
|
|
|
|
grayscale: function () {
|
|
// http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale
|
|
var rgb = this.rgb().color;
|
|
var val = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
|
|
return Color.rgb(val, val, val);
|
|
},
|
|
|
|
fade: function (ratio) {
|
|
return this.alpha(this.valpha - (this.valpha * ratio));
|
|
},
|
|
|
|
opaquer: function (ratio) {
|
|
return this.alpha(this.valpha + (this.valpha * ratio));
|
|
},
|
|
|
|
rotate: function (degrees) {
|
|
var hsl = this.hsl();
|
|
var hue = hsl.color[0];
|
|
hue = (hue + degrees) % 360;
|
|
hue = hue < 0 ? 360 + hue : hue;
|
|
hsl.color[0] = hue;
|
|
return hsl;
|
|
},
|
|
|
|
mix: function (mixinColor, weight) {
|
|
// ported from sass implementation in C
|
|
// https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209
|
|
if (!mixinColor || !mixinColor.rgb) {
|
|
throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor);
|
|
}
|
|
var color1 = mixinColor.rgb();
|
|
var color2 = this.rgb();
|
|
var p = weight === undefined ? 0.5 : weight;
|
|
|
|
var w = 2 * p - 1;
|
|
var a = color1.alpha() - color2.alpha();
|
|
|
|
var w1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
|
|
var w2 = 1 - w1;
|
|
|
|
return Color.rgb(
|
|
w1 * color1.red() + w2 * color2.red(),
|
|
w1 * color1.green() + w2 * color2.green(),
|
|
w1 * color1.blue() + w2 * color2.blue(),
|
|
color1.alpha() * p + color2.alpha() * (1 - p));
|
|
}
|
|
};
|
|
|
|
// model conversion methods and static constructors
|
|
Object.keys(convert).forEach(function (model) {
|
|
if (skippedModels.indexOf(model) !== -1) {
|
|
return;
|
|
}
|
|
|
|
var channels = convert[model].channels;
|
|
|
|
// conversion methods
|
|
Color.prototype[model] = function () {
|
|
if (this.model === model) {
|
|
return new Color(this);
|
|
}
|
|
|
|
if (arguments.length) {
|
|
return new Color(arguments, model);
|
|
}
|
|
|
|
var newAlpha = typeof arguments[channels] === 'number' ? channels : this.valpha;
|
|
return new Color(assertArray(convert[this.model][model].raw(this.color)).concat(newAlpha), model);
|
|
};
|
|
|
|
// 'static' construction methods
|
|
Color[model] = function (color) {
|
|
if (typeof color === 'number') {
|
|
color = zeroArray(_slice.call(arguments), channels);
|
|
}
|
|
return new Color(color, model);
|
|
};
|
|
});
|
|
|
|
function roundTo(num, places) {
|
|
return Number(num.toFixed(places));
|
|
}
|
|
|
|
function roundToPlace(places) {
|
|
return function (num) {
|
|
return roundTo(num, places);
|
|
};
|
|
}
|
|
|
|
function getset(model, channel, modifier) {
|
|
model = Array.isArray(model) ? model : [model];
|
|
|
|
model.forEach(function (m) {
|
|
(limiters[m] || (limiters[m] = []))[channel] = modifier;
|
|
});
|
|
|
|
model = model[0];
|
|
|
|
return function (val) {
|
|
var result;
|
|
|
|
if (arguments.length) {
|
|
if (modifier) {
|
|
val = modifier(val);
|
|
}
|
|
|
|
result = this[model]();
|
|
result.color[channel] = val;
|
|
return result;
|
|
}
|
|
|
|
result = this[model]().color[channel];
|
|
if (modifier) {
|
|
result = modifier(result);
|
|
}
|
|
|
|
return result;
|
|
};
|
|
}
|
|
|
|
function maxfn(max) {
|
|
return function (v) {
|
|
return Math.max(0, Math.min(max, v));
|
|
};
|
|
}
|
|
|
|
function assertArray(val) {
|
|
return Array.isArray(val) ? val : [val];
|
|
}
|
|
|
|
function zeroArray(arr, length) {
|
|
for (var i = 0; i < length; i++) {
|
|
if (typeof arr[i] !== 'number') {
|
|
arr[i] = 0;
|
|
}
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
|
|
module.exports = Color;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 28401:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
/**
|
|
* lodash (Custom Build) <https://lodash.com/>
|
|
* Build: `lodash modularize exports="npm" -o ./`
|
|
* Copyright jQuery Foundation and other contributors <https://jquery.org/>
|
|
* Released under MIT license <https://lodash.com/license>
|
|
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
|
|
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
|
*/
|
|
|
|
/** Used as the `TypeError` message for "Functions" methods. */
|
|
var FUNC_ERROR_TEXT = 'Expected a function';
|
|
|
|
/** Used as the internal argument placeholder. */
|
|
var PLACEHOLDER = '__lodash_placeholder__';
|
|
|
|
/** Used to compose bitmasks for function metadata. */
|
|
var BIND_FLAG = 1,
|
|
BIND_KEY_FLAG = 2,
|
|
CURRY_BOUND_FLAG = 4,
|
|
CURRY_FLAG = 8,
|
|
CURRY_RIGHT_FLAG = 16,
|
|
PARTIAL_FLAG = 32,
|
|
PARTIAL_RIGHT_FLAG = 64,
|
|
ARY_FLAG = 128,
|
|
REARG_FLAG = 256,
|
|
FLIP_FLAG = 512;
|
|
|
|
/** Used as references for various `Number` constants. */
|
|
var INFINITY = 1 / 0,
|
|
MAX_SAFE_INTEGER = 9007199254740991,
|
|
MAX_INTEGER = 1.7976931348623157e+308,
|
|
NAN = 0 / 0;
|
|
|
|
/** Used to associate wrap methods with their bit flags. */
|
|
var wrapFlags = [
|
|
['ary', ARY_FLAG],
|
|
['bind', BIND_FLAG],
|
|
['bindKey', BIND_KEY_FLAG],
|
|
['curry', CURRY_FLAG],
|
|
['curryRight', CURRY_RIGHT_FLAG],
|
|
['flip', FLIP_FLAG],
|
|
['partial', PARTIAL_FLAG],
|
|
['partialRight', PARTIAL_RIGHT_FLAG],
|
|
['rearg', REARG_FLAG]
|
|
];
|
|
|
|
/** `Object#toString` result references. */
|
|
var funcTag = '[object Function]',
|
|
genTag = '[object GeneratorFunction]',
|
|
symbolTag = '[object Symbol]';
|
|
|
|
/**
|
|
* Used to match `RegExp`
|
|
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
|
|
*/
|
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
|
|
|
|
/** Used to match leading and trailing whitespace. */
|
|
var reTrim = /^\s+|\s+$/g;
|
|
|
|
/** Used to match wrap detail comments. */
|
|
var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
|
|
reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
|
|
reSplitDetails = /,? & /;
|
|
|
|
/** Used to detect bad signed hexadecimal string values. */
|
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
|
|
|
/** Used to detect binary string values. */
|
|
var reIsBinary = /^0b[01]+$/i;
|
|
|
|
/** Used to detect host constructors (Safari). */
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
|
|
/** Used to detect octal string values. */
|
|
var reIsOctal = /^0o[0-7]+$/i;
|
|
|
|
/** Used to detect unsigned integer values. */
|
|
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
|
|
|
/** Built-in method references without a dependency on `root`. */
|
|
var freeParseInt = parseInt;
|
|
|
|
/** Detect free variable `global` from Node.js. */
|
|
var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g;
|
|
|
|
/** Detect free variable `self`. */
|
|
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
|
|
|
|
/** Used as a reference to the global object. */
|
|
var root = freeGlobal || freeSelf || Function('return this')();
|
|
|
|
/**
|
|
* A faster alternative to `Function#apply`, this function invokes `func`
|
|
* with the `this` binding of `thisArg` and the arguments of `args`.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to invoke.
|
|
* @param {*} thisArg The `this` binding of `func`.
|
|
* @param {Array} args The arguments to invoke `func` with.
|
|
* @returns {*} Returns the result of `func`.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* A specialized version of `_.forEach` for arrays without support for
|
|
* iteratee shorthands.
|
|
*
|
|
* @private
|
|
* @param {Array} [array] The array to iterate over.
|
|
* @param {Function} iteratee The function invoked per iteration.
|
|
* @returns {Array} Returns `array`.
|
|
*/
|
|
function arrayEach(array, iteratee) {
|
|
var index = -1,
|
|
length = array ? array.length : 0;
|
|
|
|
while (++index < length) {
|
|
if (iteratee(array[index], index, array) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
/**
|
|
* A specialized version of `_.includes` for arrays without support for
|
|
* specifying an index to search from.
|
|
*
|
|
* @private
|
|
* @param {Array} [array] The array to inspect.
|
|
* @param {*} target The value to search for.
|
|
* @returns {boolean} Returns `true` if `target` is found, else `false`.
|
|
*/
|
|
function arrayIncludes(array, value) {
|
|
var length = array ? array.length : 0;
|
|
return !!length && baseIndexOf(array, value, 0) > -1;
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.findIndex` and `_.findLastIndex` without
|
|
* support for iteratee shorthands.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to inspect.
|
|
* @param {Function} predicate The function invoked per iteration.
|
|
* @param {number} fromIndex The index to search from.
|
|
* @param {boolean} [fromRight] Specify iterating from right to left.
|
|
* @returns {number} Returns the index of the matched value, else `-1`.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.indexOf` without `fromIndex` bounds checks.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to inspect.
|
|
* @param {*} value The value to search for.
|
|
* @param {number} fromIndex The index to search from.
|
|
* @returns {number} Returns the index of the matched value, else `-1`.
|
|
*/
|
|
function baseIndexOf(array, value, fromIndex) {
|
|
if (value !== value) {
|
|
return baseFindIndex(array, baseIsNaN, fromIndex);
|
|
}
|
|
var index = fromIndex - 1,
|
|
length = array.length;
|
|
|
|
while (++index < length) {
|
|
if (array[index] === value) {
|
|
return index;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.isNaN` without support for number objects.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
|
|
*/
|
|
function baseIsNaN(value) {
|
|
return value !== value;
|
|
}
|
|
|
|
/**
|
|
* Gets the number of `placeholder` occurrences in `array`.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to inspect.
|
|
* @param {*} placeholder The placeholder to search for.
|
|
* @returns {number} Returns the placeholder count.
|
|
*/
|
|
function countHolders(array, placeholder) {
|
|
var length = array.length,
|
|
result = 0;
|
|
|
|
while (length--) {
|
|
if (array[length] === placeholder) {
|
|
result++;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Gets the value at `key` of `object`.
|
|
*
|
|
* @private
|
|
* @param {Object} [object] The object to query.
|
|
* @param {string} key The key of the property to get.
|
|
* @returns {*} Returns the property value.
|
|
*/
|
|
function getValue(object, key) {
|
|
return object == null ? undefined : object[key];
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is a host object in IE < 9.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a host object, else `false`.
|
|
*/
|
|
function isHostObject(value) {
|
|
// Many host objects are `Object` objects that can coerce to strings
|
|
// despite having improperly defined `toString` methods.
|
|
var result = false;
|
|
if (value != null && typeof value.toString != 'function') {
|
|
try {
|
|
result = !!(value + '');
|
|
} catch (e) {}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Replaces all `placeholder` elements in `array` with an internal placeholder
|
|
* and returns an array of their indexes.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to modify.
|
|
* @param {*} placeholder The placeholder to replace.
|
|
* @returns {Array} Returns the new array of placeholder indexes.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/** Used for built-in method references. */
|
|
var funcProto = Function.prototype,
|
|
objectProto = Object.prototype;
|
|
|
|
/** Used to detect overreaching core-js shims. */
|
|
var coreJsData = root['__core-js_shared__'];
|
|
|
|
/** Used to detect methods masquerading as native. */
|
|
var maskSrcKey = (function() {
|
|
var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
|
|
return uid ? ('Symbol(src)_1.' + uid) : '';
|
|
}());
|
|
|
|
/** Used to resolve the decompiled source of functions. */
|
|
var funcToString = funcProto.toString;
|
|
|
|
/** Used to check objects for own properties. */
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
/**
|
|
* Used to resolve the
|
|
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
|
|
* of values.
|
|
*/
|
|
var objectToString = objectProto.toString;
|
|
|
|
/** Used to detect if a method is native. */
|
|
var reIsNative = RegExp('^' +
|
|
funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
|
|
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
|
|
);
|
|
|
|
/** Built-in value references. */
|
|
var objectCreate = Object.create;
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
var nativeMax = Math.max,
|
|
nativeMin = Math.min;
|
|
|
|
/* Used to set `toString` methods. */
|
|
var defineProperty = (function() {
|
|
var func = getNative(Object, 'defineProperty'),
|
|
name = getNative.name;
|
|
|
|
return (name && name.length > 2) ? func : undefined;
|
|
}());
|
|
|
|
/**
|
|
* The base implementation of `_.create` without support for assigning
|
|
* properties to the created object.
|
|
*
|
|
* @private
|
|
* @param {Object} prototype The object to inherit from.
|
|
* @returns {Object} Returns the new object.
|
|
*/
|
|
function baseCreate(proto) {
|
|
return isObject(proto) ? objectCreate(proto) : {};
|
|
}
|
|
|
|
/**
|
|
* The base implementation of `_.isNative` without bad shim checks.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a native function,
|
|
* else `false`.
|
|
*/
|
|
function baseIsNative(value) {
|
|
if (!isObject(value) || isMasked(value)) {
|
|
return false;
|
|
}
|
|
var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
|
|
return pattern.test(toSource(value));
|
|
}
|
|
|
|
/**
|
|
* Creates an array that is the composition of partially applied arguments,
|
|
* placeholders, and provided arguments into a single array of arguments.
|
|
*
|
|
* @private
|
|
* @param {Array} args The provided arguments.
|
|
* @param {Array} partials The arguments to prepend to those provided.
|
|
* @param {Array} holders The `partials` placeholder indexes.
|
|
* @params {boolean} [isCurried] Specify composing for a curried function.
|
|
* @returns {Array} Returns the new array of composed arguments.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* This function is like `composeArgs` except that the arguments composition
|
|
* is tailored for `_.partialRight`.
|
|
*
|
|
* @private
|
|
* @param {Array} args The provided arguments.
|
|
* @param {Array} partials The arguments to append to those provided.
|
|
* @param {Array} holders The `partials` placeholder indexes.
|
|
* @params {boolean} [isCurried] Specify composing for a curried function.
|
|
* @returns {Array} Returns the new array of composed arguments.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Copies the values of `source` to `array`.
|
|
*
|
|
* @private
|
|
* @param {Array} source The array to copy values from.
|
|
* @param {Array} [array=[]] The array to copy values to.
|
|
* @returns {Array} Returns `array`.
|
|
*/
|
|
function copyArray(source, array) {
|
|
var index = -1,
|
|
length = source.length;
|
|
|
|
array || (array = Array(length));
|
|
while (++index < length) {
|
|
array[index] = source[index];
|
|
}
|
|
return array;
|
|
}
|
|
|
|
/**
|
|
* Creates a function that wraps `func` to invoke it with the optional `this`
|
|
* binding of `thisArg`.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to wrap.
|
|
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
|
|
* @param {*} [thisArg] The `this` binding of `func`.
|
|
* @returns {Function} Returns the new wrapped function.
|
|
*/
|
|
function createBind(func, bitmask, thisArg) {
|
|
var isBind = bitmask & 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;
|
|
}
|
|
|
|
/**
|
|
* Creates a function that produces an instance of `Ctor` regardless of
|
|
* whether it was invoked as part of a `new` expression or by `call` or `apply`.
|
|
*
|
|
* @private
|
|
* @param {Function} Ctor The constructor to wrap.
|
|
* @returns {Function} Returns the new wrapped function.
|
|
*/
|
|
function createCtor(Ctor) {
|
|
return function() {
|
|
// Use a `switch` statement to work with class constructors. See
|
|
// http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
|
|
// for more details.
|
|
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);
|
|
|
|
// Mimic the constructor's `return` behavior.
|
|
// See https://es5.github.io/#x13.2.2 for more details.
|
|
return isObject(result) ? result : thisBinding;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Creates a function that wraps `func` to enable currying.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to wrap.
|
|
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
|
|
* @param {number} arity The arity of `func`.
|
|
* @returns {Function} Returns the new wrapped function.
|
|
*/
|
|
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, undefined,
|
|
args, holders, undefined, undefined, arity - length);
|
|
}
|
|
var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
|
|
return apply(fn, this, args);
|
|
}
|
|
return wrapper;
|
|
}
|
|
|
|
/**
|
|
* Creates a function that wraps `func` to invoke it with optional `this`
|
|
* binding of `thisArg`, partial application, and currying.
|
|
*
|
|
* @private
|
|
* @param {Function|string} func The function or method name to wrap.
|
|
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
|
|
* @param {*} [thisArg] The `this` binding of `func`.
|
|
* @param {Array} [partials] The arguments to prepend to those provided to
|
|
* the new function.
|
|
* @param {Array} [holders] The `partials` placeholder indexes.
|
|
* @param {Array} [partialsRight] The arguments to append to those provided
|
|
* to the new function.
|
|
* @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
|
|
* @param {Array} [argPos] The argument positions of the new function.
|
|
* @param {number} [ary] The arity cap of `func`.
|
|
* @param {number} [arity] The arity of `func`.
|
|
* @returns {Function} Returns the new wrapped function.
|
|
*/
|
|
function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
|
|
var isAry = bitmask & ARY_FLAG,
|
|
isBind = bitmask & BIND_FLAG,
|
|
isBindKey = bitmask & BIND_KEY_FLAG,
|
|
isCurried = bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG),
|
|
isFlip = bitmask & FLIP_FLAG,
|
|
Ctor = isBindKey ? undefined : 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;
|
|
}
|
|
|
|
/**
|
|
* Creates a function that wraps `func` to invoke it with the `this` binding
|
|
* of `thisArg` and `partials` prepended to the arguments it receives.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to wrap.
|
|
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
|
|
* @param {*} thisArg The `this` binding of `func`.
|
|
* @param {Array} partials The arguments to prepend to those provided to
|
|
* the new function.
|
|
* @returns {Function} Returns the new wrapped function.
|
|
*/
|
|
function createPartial(func, bitmask, thisArg, partials) {
|
|
var isBind = bitmask & 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;
|
|
}
|
|
|
|
/**
|
|
* Creates a function that wraps `func` to continue currying.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to wrap.
|
|
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
|
|
* @param {Function} wrapFunc The function to create the `func` wrapper.
|
|
* @param {*} placeholder The placeholder value.
|
|
* @param {*} [thisArg] The `this` binding of `func`.
|
|
* @param {Array} [partials] The arguments to prepend to those provided to
|
|
* the new function.
|
|
* @param {Array} [holders] The `partials` placeholder indexes.
|
|
* @param {Array} [argPos] The argument positions of the new function.
|
|
* @param {number} [ary] The arity cap of `func`.
|
|
* @param {number} [arity] The arity of `func`.
|
|
* @returns {Function} Returns the new wrapped function.
|
|
*/
|
|
function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
|
|
var isCurry = bitmask & CURRY_FLAG,
|
|
newHolders = isCurry ? holders : undefined,
|
|
newHoldersRight = isCurry ? undefined : holders,
|
|
newPartials = isCurry ? partials : undefined,
|
|
newPartialsRight = isCurry ? undefined : partials;
|
|
|
|
bitmask |= (isCurry ? PARTIAL_FLAG : PARTIAL_RIGHT_FLAG);
|
|
bitmask &= ~(isCurry ? PARTIAL_RIGHT_FLAG : PARTIAL_FLAG);
|
|
|
|
if (!(bitmask & CURRY_BOUND_FLAG)) {
|
|
bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
|
|
}
|
|
|
|
var result = wrapFunc(func, bitmask, thisArg, newPartials, newHolders, newPartialsRight, newHoldersRight, argPos, ary, arity);
|
|
result.placeholder = placeholder;
|
|
return setWrapToString(result, func, bitmask);
|
|
}
|
|
|
|
/**
|
|
* Creates a function that either curries or invokes `func` with optional
|
|
* `this` binding and partially applied arguments.
|
|
*
|
|
* @private
|
|
* @param {Function|string} func The function or method name to wrap.
|
|
* @param {number} bitmask The bitmask flags.
|
|
* The bitmask may be composed of the following flags:
|
|
* 1 - `_.bind`
|
|
* 2 - `_.bindKey`
|
|
* 4 - `_.curry` or `_.curryRight` of a bound function
|
|
* 8 - `_.curry`
|
|
* 16 - `_.curryRight`
|
|
* 32 - `_.partial`
|
|
* 64 - `_.partialRight`
|
|
* 128 - `_.rearg`
|
|
* 256 - `_.ary`
|
|
* 512 - `_.flip`
|
|
* @param {*} [thisArg] The `this` binding of `func`.
|
|
* @param {Array} [partials] The arguments to be partially applied.
|
|
* @param {Array} [holders] The `partials` placeholder indexes.
|
|
* @param {Array} [argPos] The argument positions of the new function.
|
|
* @param {number} [ary] The arity cap of `func`.
|
|
* @param {number} [arity] The arity of `func`.
|
|
* @returns {Function} Returns the new wrapped function.
|
|
*/
|
|
function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
|
|
var isBindKey = bitmask & BIND_KEY_FLAG;
|
|
if (!isBindKey && typeof func != 'function') {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
var length = partials ? partials.length : 0;
|
|
if (!length) {
|
|
bitmask &= ~(PARTIAL_FLAG | PARTIAL_RIGHT_FLAG);
|
|
partials = holders = undefined;
|
|
}
|
|
ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
|
|
arity = arity === undefined ? arity : toInteger(arity);
|
|
length -= holders ? holders.length : 0;
|
|
|
|
if (bitmask & PARTIAL_RIGHT_FLAG) {
|
|
var partialsRight = partials,
|
|
holdersRight = holders;
|
|
|
|
partials = holders = undefined;
|
|
}
|
|
|
|
var newData = [
|
|
func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
|
|
argPos, ary, arity
|
|
];
|
|
|
|
func = newData[0];
|
|
bitmask = newData[1];
|
|
thisArg = newData[2];
|
|
partials = newData[3];
|
|
holders = newData[4];
|
|
arity = newData[9] = newData[9] == null
|
|
? (isBindKey ? 0 : func.length)
|
|
: nativeMax(newData[9] - length, 0);
|
|
|
|
if (!arity && bitmask & (CURRY_FLAG | CURRY_RIGHT_FLAG)) {
|
|
bitmask &= ~(CURRY_FLAG | CURRY_RIGHT_FLAG);
|
|
}
|
|
if (!bitmask || bitmask == BIND_FLAG) {
|
|
var result = createBind(func, bitmask, thisArg);
|
|
} else if (bitmask == CURRY_FLAG || bitmask == CURRY_RIGHT_FLAG) {
|
|
result = createCurry(func, bitmask, arity);
|
|
} else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !holders.length) {
|
|
result = createPartial(func, bitmask, thisArg, partials);
|
|
} else {
|
|
result = createHybrid.apply(undefined, newData);
|
|
}
|
|
return setWrapToString(result, func, bitmask);
|
|
}
|
|
|
|
/**
|
|
* Gets the argument placeholder value for `func`.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to inspect.
|
|
* @returns {*} Returns the placeholder value.
|
|
*/
|
|
function getHolder(func) {
|
|
var object = func;
|
|
return object.placeholder;
|
|
}
|
|
|
|
/**
|
|
* Gets the native function at `key` of `object`.
|
|
*
|
|
* @private
|
|
* @param {Object} object The object to query.
|
|
* @param {string} key The key of the method to get.
|
|
* @returns {*} Returns the function if it's native, else `undefined`.
|
|
*/
|
|
function getNative(object, key) {
|
|
var value = getValue(object, key);
|
|
return baseIsNative(value) ? value : undefined;
|
|
}
|
|
|
|
/**
|
|
* Extracts wrapper details from the `source` body comment.
|
|
*
|
|
* @private
|
|
* @param {string} source The source to inspect.
|
|
* @returns {Array} Returns the wrapper details.
|
|
*/
|
|
function getWrapDetails(source) {
|
|
var match = source.match(reWrapDetails);
|
|
return match ? match[1].split(reSplitDetails) : [];
|
|
}
|
|
|
|
/**
|
|
* Inserts wrapper `details` in a comment at the top of the `source` body.
|
|
*
|
|
* @private
|
|
* @param {string} source The source to modify.
|
|
* @returns {Array} details The details to insert.
|
|
* @returns {string} Returns the modified source.
|
|
*/
|
|
function insertWrapDetails(source, details) {
|
|
var length = details.length,
|
|
lastIndex = length - 1;
|
|
|
|
details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
|
|
details = details.join(length > 2 ? ', ' : ' ');
|
|
return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is a valid array-like index.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
|
|
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
|
|
*/
|
|
function isIndex(value, length) {
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
|
return !!length &&
|
|
(typeof value == 'number' || reIsUint.test(value)) &&
|
|
(value > -1 && value % 1 == 0 && value < length);
|
|
}
|
|
|
|
/**
|
|
* Checks if `func` has its source masked.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to check.
|
|
* @returns {boolean} Returns `true` if `func` is masked, else `false`.
|
|
*/
|
|
function isMasked(func) {
|
|
return !!maskSrcKey && (maskSrcKey in func);
|
|
}
|
|
|
|
/**
|
|
* Reorder `array` according to the specified indexes where the element at
|
|
* the first index is assigned as the first element, the element at
|
|
* the second index is assigned as the second element, and so on.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to reorder.
|
|
* @param {Array} indexes The arranged array indexes.
|
|
* @returns {Array} Returns `array`.
|
|
*/
|
|
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] : undefined;
|
|
}
|
|
return array;
|
|
}
|
|
|
|
/**
|
|
* Sets the `toString` method of `wrapper` to mimic the source of `reference`
|
|
* with wrapper details in a comment at the top of the source body.
|
|
*
|
|
* @private
|
|
* @param {Function} wrapper The function to modify.
|
|
* @param {Function} reference The reference function.
|
|
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
|
|
* @returns {Function} Returns `wrapper`.
|
|
*/
|
|
var setWrapToString = !defineProperty ? identity : function(wrapper, reference, bitmask) {
|
|
var source = (reference + '');
|
|
return defineProperty(wrapper, 'toString', {
|
|
'configurable': true,
|
|
'enumerable': false,
|
|
'value': constant(insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)))
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Converts `func` to its source code.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to process.
|
|
* @returns {string} Returns the source code.
|
|
*/
|
|
function toSource(func) {
|
|
if (func != null) {
|
|
try {
|
|
return funcToString.call(func);
|
|
} catch (e) {}
|
|
try {
|
|
return (func + '');
|
|
} catch (e) {}
|
|
}
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Updates wrapper `details` based on `bitmask` flags.
|
|
*
|
|
* @private
|
|
* @returns {Array} details The details to modify.
|
|
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
|
|
* @returns {Array} Returns `details`.
|
|
*/
|
|
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();
|
|
}
|
|
|
|
/**
|
|
* Creates a function that accepts arguments of `func` and either invokes
|
|
* `func` returning its result, if at least `arity` number of arguments have
|
|
* been provided, or returns a function that accepts the remaining `func`
|
|
* arguments, and so on. The arity of `func` may be specified if `func.length`
|
|
* is not sufficient.
|
|
*
|
|
* The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
|
|
* may be used as a placeholder for provided arguments.
|
|
*
|
|
* **Note:** This method doesn't set the "length" property of curried functions.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 2.0.0
|
|
* @category Function
|
|
* @param {Function} func The function to curry.
|
|
* @param {number} [arity=func.length] The arity of `func`.
|
|
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
|
|
* @returns {Function} Returns the new curried function.
|
|
* @example
|
|
*
|
|
* var abc = function(a, b, c) {
|
|
* return [a, b, c];
|
|
* };
|
|
*
|
|
* var curried = _.curry(abc);
|
|
*
|
|
* curried(1)(2)(3);
|
|
* // => [1, 2, 3]
|
|
*
|
|
* curried(1, 2)(3);
|
|
* // => [1, 2, 3]
|
|
*
|
|
* curried(1, 2, 3);
|
|
* // => [1, 2, 3]
|
|
*
|
|
* // Curried with placeholders.
|
|
* curried(1)(_, 3)(2);
|
|
* // => [1, 2, 3]
|
|
*/
|
|
function curry(func, arity, guard) {
|
|
arity = guard ? undefined : arity;
|
|
var result = createWrap(func, CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
|
|
result.placeholder = curry.placeholder;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is classified as a `Function` object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 0.1.0
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a function, else `false`.
|
|
* @example
|
|
*
|
|
* _.isFunction(_);
|
|
* // => true
|
|
*
|
|
* _.isFunction(/abc/);
|
|
* // => false
|
|
*/
|
|
function isFunction(value) {
|
|
// The use of `Object#toString` avoids issues with the `typeof` operator
|
|
// in Safari 8-9 which returns 'object' for typed array and other constructors.
|
|
var tag = isObject(value) ? objectToString.call(value) : '';
|
|
return tag == funcTag || tag == genTag;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is the
|
|
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
|
|
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 0.1.0
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
|
* @example
|
|
*
|
|
* _.isObject({});
|
|
* // => true
|
|
*
|
|
* _.isObject([1, 2, 3]);
|
|
* // => true
|
|
*
|
|
* _.isObject(_.noop);
|
|
* // => true
|
|
*
|
|
* _.isObject(null);
|
|
* // => false
|
|
*/
|
|
function isObject(value) {
|
|
var type = typeof value;
|
|
return !!value && (type == 'object' || type == 'function');
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is object-like. A value is object-like if it's not `null`
|
|
* and has a `typeof` result of "object".
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.0.0
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
|
|
* @example
|
|
*
|
|
* _.isObjectLike({});
|
|
* // => true
|
|
*
|
|
* _.isObjectLike([1, 2, 3]);
|
|
* // => true
|
|
*
|
|
* _.isObjectLike(_.noop);
|
|
* // => false
|
|
*
|
|
* _.isObjectLike(null);
|
|
* // => false
|
|
*/
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == 'object';
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is classified as a `Symbol` primitive or object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.0.0
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
|
|
* @example
|
|
*
|
|
* _.isSymbol(Symbol.iterator);
|
|
* // => true
|
|
*
|
|
* _.isSymbol('abc');
|
|
* // => false
|
|
*/
|
|
function isSymbol(value) {
|
|
return typeof value == 'symbol' ||
|
|
(isObjectLike(value) && objectToString.call(value) == symbolTag);
|
|
}
|
|
|
|
/**
|
|
* Converts `value` to a finite number.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.12.0
|
|
* @category Lang
|
|
* @param {*} value The value to convert.
|
|
* @returns {number} Returns the converted number.
|
|
* @example
|
|
*
|
|
* _.toFinite(3.2);
|
|
* // => 3.2
|
|
*
|
|
* _.toFinite(Number.MIN_VALUE);
|
|
* // => 5e-324
|
|
*
|
|
* _.toFinite(Infinity);
|
|
* // => 1.7976931348623157e+308
|
|
*
|
|
* _.toFinite('3.2');
|
|
* // => 3.2
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Converts `value` to an integer.
|
|
*
|
|
* **Note:** This method is loosely based on
|
|
* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.0.0
|
|
* @category Lang
|
|
* @param {*} value The value to convert.
|
|
* @returns {number} Returns the converted integer.
|
|
* @example
|
|
*
|
|
* _.toInteger(3.2);
|
|
* // => 3
|
|
*
|
|
* _.toInteger(Number.MIN_VALUE);
|
|
* // => 0
|
|
*
|
|
* _.toInteger(Infinity);
|
|
* // => 1.7976931348623157e+308
|
|
*
|
|
* _.toInteger('3.2');
|
|
* // => 3
|
|
*/
|
|
function toInteger(value) {
|
|
var result = toFinite(value),
|
|
remainder = result % 1;
|
|
|
|
return result === result ? (remainder ? result - remainder : result) : 0;
|
|
}
|
|
|
|
/**
|
|
* Converts `value` to a number.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.0.0
|
|
* @category Lang
|
|
* @param {*} value The value to process.
|
|
* @returns {number} Returns the number.
|
|
* @example
|
|
*
|
|
* _.toNumber(3.2);
|
|
* // => 3.2
|
|
*
|
|
* _.toNumber(Number.MIN_VALUE);
|
|
* // => 5e-324
|
|
*
|
|
* _.toNumber(Infinity);
|
|
* // => Infinity
|
|
*
|
|
* _.toNumber('3.2');
|
|
* // => 3.2
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* Creates a function that returns `value`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 2.4.0
|
|
* @category Util
|
|
* @param {*} value The value to return from the new function.
|
|
* @returns {Function} Returns the new constant function.
|
|
* @example
|
|
*
|
|
* var objects = _.times(2, _.constant({ 'a': 1 }));
|
|
*
|
|
* console.log(objects);
|
|
* // => [{ 'a': 1 }, { 'a': 1 }]
|
|
*
|
|
* console.log(objects[0] === objects[1]);
|
|
* // => true
|
|
*/
|
|
function constant(value) {
|
|
return function() {
|
|
return value;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* This method returns the first argument it receives.
|
|
*
|
|
* @static
|
|
* @since 0.1.0
|
|
* @memberOf _
|
|
* @category Util
|
|
* @param {*} value Any value.
|
|
* @returns {*} Returns `value`.
|
|
* @example
|
|
*
|
|
* var object = { 'a': 1 };
|
|
*
|
|
* console.log(_.identity(object) === object);
|
|
* // => true
|
|
*/
|
|
function identity(value) {
|
|
return value;
|
|
}
|
|
|
|
// Assign default placeholders.
|
|
curry.placeholder = {};
|
|
|
|
module.exports = curry;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5464:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
module.exports =
|
|
/******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __nested_webpack_require_187__(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] = {
|
|
/******/ exports: {},
|
|
/******/ id: moduleId,
|
|
/******/ loaded: false
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __nested_webpack_require_187__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.loaded = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __nested_webpack_require_187__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __nested_webpack_require_187__.c = installedModules;
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __nested_webpack_require_187__.p = "";
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __nested_webpack_require_187__(0);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ (function(module, exports, __nested_webpack_require_1468__) {
|
|
|
|
module.exports = __nested_webpack_require_1468__(1);
|
|
|
|
|
|
/***/ }),
|
|
/* 1 */
|
|
/***/ (function(module, exports, __nested_webpack_require_1587__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _Highlighter = __nested_webpack_require_1587__(2);
|
|
|
|
var _Highlighter2 = _interopRequireDefault(_Highlighter);
|
|
|
|
exports['default'] = _Highlighter2['default'];
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
/* 2 */
|
|
/***/ (function(module, exports, __nested_webpack_require_2043__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
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; };
|
|
|
|
exports['default'] = Highlighter;
|
|
|
|
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; }
|
|
|
|
var _highlightWordsCore = __nested_webpack_require_2043__(3);
|
|
|
|
var _propTypes = __nested_webpack_require_2043__(4);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
var _react = __nested_webpack_require_2043__(14);
|
|
|
|
var _memoizeOne = __nested_webpack_require_2043__(15);
|
|
|
|
var _memoizeOne2 = _interopRequireDefault(_memoizeOne);
|
|
|
|
Highlighter.propTypes = {
|
|
activeClassName: _propTypes2['default'].string,
|
|
activeIndex: _propTypes2['default'].number,
|
|
activeStyle: _propTypes2['default'].object,
|
|
autoEscape: _propTypes2['default'].bool,
|
|
className: _propTypes2['default'].string,
|
|
findChunks: _propTypes2['default'].func,
|
|
highlightClassName: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].string]),
|
|
highlightStyle: _propTypes2['default'].object,
|
|
highlightTag: _propTypes2['default'].oneOfType([_propTypes2['default'].node, _propTypes2['default'].func, _propTypes2['default'].string]),
|
|
sanitize: _propTypes2['default'].func,
|
|
searchWords: _propTypes2['default'].arrayOf(_propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].instanceOf(RegExp)])).isRequired,
|
|
textToHighlight: _propTypes2['default'].string.isRequired,
|
|
unhighlightTag: _propTypes2['default'].oneOfType([_propTypes2['default'].node, _propTypes2['default'].func, _propTypes2['default'].string]),
|
|
unhighlightClassName: _propTypes2['default'].string,
|
|
unhighlightStyle: _propTypes2['default'].object
|
|
};
|
|
|
|
/**
|
|
* Highlights all occurrences of search terms (searchText) within a string (textToHighlight).
|
|
* This function returns an array of strings and <span>s (wrapping highlighted words).
|
|
*/
|
|
|
|
function Highlighter(_ref) {
|
|
var _ref$activeClassName = _ref.activeClassName;
|
|
var activeClassName = _ref$activeClassName === undefined ? '' : _ref$activeClassName;
|
|
var _ref$activeIndex = _ref.activeIndex;
|
|
var activeIndex = _ref$activeIndex === undefined ? -1 : _ref$activeIndex;
|
|
var activeStyle = _ref.activeStyle;
|
|
var autoEscape = _ref.autoEscape;
|
|
var _ref$caseSensitive = _ref.caseSensitive;
|
|
var caseSensitive = _ref$caseSensitive === undefined ? false : _ref$caseSensitive;
|
|
var className = _ref.className;
|
|
var findChunks = _ref.findChunks;
|
|
var _ref$highlightClassName = _ref.highlightClassName;
|
|
var highlightClassName = _ref$highlightClassName === undefined ? '' : _ref$highlightClassName;
|
|
var _ref$highlightStyle = _ref.highlightStyle;
|
|
var highlightStyle = _ref$highlightStyle === undefined ? {} : _ref$highlightStyle;
|
|
var _ref$highlightTag = _ref.highlightTag;
|
|
var highlightTag = _ref$highlightTag === undefined ? 'mark' : _ref$highlightTag;
|
|
var sanitize = _ref.sanitize;
|
|
var searchWords = _ref.searchWords;
|
|
var textToHighlight = _ref.textToHighlight;
|
|
var _ref$unhighlightTag = _ref.unhighlightTag;
|
|
var unhighlightTag = _ref$unhighlightTag === undefined ? 'span' : _ref$unhighlightTag;
|
|
var _ref$unhighlightClassName = _ref.unhighlightClassName;
|
|
var unhighlightClassName = _ref$unhighlightClassName === undefined ? '' : _ref$unhighlightClassName;
|
|
var unhighlightStyle = _ref.unhighlightStyle;
|
|
|
|
var rest = _objectWithoutProperties(_ref, ['activeClassName', 'activeIndex', 'activeStyle', 'autoEscape', 'caseSensitive', 'className', 'findChunks', 'highlightClassName', 'highlightStyle', 'highlightTag', 'sanitize', 'searchWords', 'textToHighlight', 'unhighlightTag', 'unhighlightClassName', 'unhighlightStyle']);
|
|
|
|
var chunks = (0, _highlightWordsCore.findAll)({
|
|
autoEscape: autoEscape,
|
|
caseSensitive: caseSensitive,
|
|
findChunks: findChunks,
|
|
sanitize: sanitize,
|
|
searchWords: searchWords,
|
|
textToHighlight: textToHighlight
|
|
});
|
|
var HighlightTag = highlightTag;
|
|
var highlightIndex = -1;
|
|
var highlightClassNames = '';
|
|
var highlightStyles = undefined;
|
|
|
|
var lowercaseProps = function lowercaseProps(object) {
|
|
var mapped = {};
|
|
for (var key in object) {
|
|
mapped[key.toLowerCase()] = object[key];
|
|
}
|
|
return mapped;
|
|
};
|
|
var memoizedLowercaseProps = (0, _memoizeOne2['default'])(lowercaseProps);
|
|
|
|
return (0, _react.createElement)('span', _extends({
|
|
className: className
|
|
}, rest, {
|
|
children: chunks.map(function (chunk, index) {
|
|
var text = textToHighlight.substr(chunk.start, chunk.end - chunk.start);
|
|
|
|
if (chunk.highlight) {
|
|
highlightIndex++;
|
|
|
|
var highlightClass = undefined;
|
|
if (typeof highlightClassName === 'object') {
|
|
if (!caseSensitive) {
|
|
highlightClassName = memoizedLowercaseProps(highlightClassName);
|
|
highlightClass = highlightClassName[text.toLowerCase()];
|
|
} else {
|
|
highlightClass = highlightClassName[text];
|
|
}
|
|
} else {
|
|
highlightClass = highlightClassName;
|
|
}
|
|
|
|
var isActive = highlightIndex === +activeIndex;
|
|
|
|
highlightClassNames = highlightClass + ' ' + (isActive ? activeClassName : '');
|
|
highlightStyles = isActive === true && activeStyle != null ? Object.assign({}, highlightStyle, activeStyle) : highlightStyle;
|
|
|
|
var props = {
|
|
children: text,
|
|
className: highlightClassNames,
|
|
key: index,
|
|
style: highlightStyles
|
|
};
|
|
|
|
// Don't attach arbitrary props to DOM elements; this triggers React DEV warnings (https://fb.me/react-unknown-prop)
|
|
// Only pass through the highlightIndex attribute for custom components.
|
|
if (typeof HighlightTag !== 'string') {
|
|
props.highlightIndex = highlightIndex;
|
|
}
|
|
|
|
return (0, _react.createElement)(HighlightTag, props);
|
|
} else {
|
|
return (0, _react.createElement)(unhighlightTag, {
|
|
children: text,
|
|
className: unhighlightClassName,
|
|
key: index,
|
|
style: unhighlightStyle
|
|
});
|
|
}
|
|
})
|
|
}));
|
|
}
|
|
|
|
module.exports = exports['default'];
|
|
|
|
/***/ }),
|
|
/* 3 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports =
|
|
/******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __nested_webpack_require_8969__(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] = {
|
|
/******/ exports: {},
|
|
/******/ id: moduleId,
|
|
/******/ loaded: false
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __nested_webpack_require_8969__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.loaded = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __nested_webpack_require_8969__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __nested_webpack_require_8969__.c = installedModules;
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __nested_webpack_require_8969__.p = "";
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __nested_webpack_require_8969__(0);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ (function(module, exports, __nested_webpack_require_10289__) {
|
|
|
|
module.exports = __nested_webpack_require_10289__(1);
|
|
|
|
|
|
/***/ }),
|
|
/* 1 */
|
|
/***/ (function(module, exports, __nested_webpack_require_10415__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _utils = __nested_webpack_require_10415__(2);
|
|
|
|
Object.defineProperty(exports, 'combineChunks', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _utils.combineChunks;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'fillInChunks', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _utils.fillInChunks;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'findAll', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _utils.findAll;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'findChunks', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _utils.findChunks;
|
|
}
|
|
});
|
|
|
|
/***/ }),
|
|
/* 2 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
/**
|
|
* Creates an array of chunk objects representing both higlightable and non highlightable pieces of text that match each search word.
|
|
* @return Array of "chunks" (where a Chunk is { start:number, end:number, highlight:boolean })
|
|
*/
|
|
var findAll = exports.findAll = function findAll(_ref) {
|
|
var autoEscape = _ref.autoEscape,
|
|
_ref$caseSensitive = _ref.caseSensitive,
|
|
caseSensitive = _ref$caseSensitive === undefined ? false : _ref$caseSensitive,
|
|
_ref$findChunks = _ref.findChunks,
|
|
findChunks = _ref$findChunks === undefined ? defaultFindChunks : _ref$findChunks,
|
|
sanitize = _ref.sanitize,
|
|
searchWords = _ref.searchWords,
|
|
textToHighlight = _ref.textToHighlight;
|
|
return fillInChunks({
|
|
chunksToHighlight: combineChunks({
|
|
chunks: findChunks({
|
|
autoEscape: autoEscape,
|
|
caseSensitive: caseSensitive,
|
|
sanitize: sanitize,
|
|
searchWords: searchWords,
|
|
textToHighlight: textToHighlight
|
|
})
|
|
}),
|
|
totalLength: textToHighlight ? textToHighlight.length : 0
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Takes an array of {start:number, end:number} objects and combines chunks that overlap into single chunks.
|
|
* @return {start:number, end:number}[]
|
|
*/
|
|
var combineChunks = exports.combineChunks = function combineChunks(_ref2) {
|
|
var chunks = _ref2.chunks;
|
|
|
|
chunks = chunks.sort(function (first, second) {
|
|
return first.start - second.start;
|
|
}).reduce(function (processedChunks, nextChunk) {
|
|
// First chunk just goes straight in the array...
|
|
if (processedChunks.length === 0) {
|
|
return [nextChunk];
|
|
} else {
|
|
// ... subsequent chunks get checked to see if they overlap...
|
|
var prevChunk = processedChunks.pop();
|
|
if (nextChunk.start <= prevChunk.end) {
|
|
// It may be the case that prevChunk completely surrounds nextChunk, so take the
|
|
// largest of the end indeces.
|
|
var endIndex = Math.max(prevChunk.end, nextChunk.end);
|
|
processedChunks.push({ start: prevChunk.start, end: endIndex });
|
|
} else {
|
|
processedChunks.push(prevChunk, nextChunk);
|
|
}
|
|
return processedChunks;
|
|
}
|
|
}, []);
|
|
|
|
return chunks;
|
|
};
|
|
|
|
/**
|
|
* Examine text for any matches.
|
|
* If we find matches, add them to the returned array as a "chunk" object ({start:number, end:number}).
|
|
* @return {start:number, end:number}[]
|
|
*/
|
|
var defaultFindChunks = function defaultFindChunks(_ref3) {
|
|
var autoEscape = _ref3.autoEscape,
|
|
caseSensitive = _ref3.caseSensitive,
|
|
_ref3$sanitize = _ref3.sanitize,
|
|
sanitize = _ref3$sanitize === undefined ? identity : _ref3$sanitize,
|
|
searchWords = _ref3.searchWords,
|
|
textToHighlight = _ref3.textToHighlight;
|
|
|
|
textToHighlight = sanitize(textToHighlight);
|
|
|
|
return searchWords.filter(function (searchWord) {
|
|
return searchWord;
|
|
}) // Remove empty words
|
|
.reduce(function (chunks, searchWord) {
|
|
searchWord = sanitize(searchWord);
|
|
|
|
if (autoEscape) {
|
|
searchWord = escapeRegExpFn(searchWord);
|
|
}
|
|
|
|
var regex = new RegExp(searchWord, caseSensitive ? 'g' : 'gi');
|
|
|
|
var match = void 0;
|
|
while (match = regex.exec(textToHighlight)) {
|
|
var start = match.index;
|
|
var end = regex.lastIndex;
|
|
// We do not return zero-length matches
|
|
if (end > start) {
|
|
chunks.push({ start: start, end: end });
|
|
}
|
|
|
|
// Prevent browsers like Firefox from getting stuck in an infinite loop
|
|
// See http://www.regexguru.com/2008/04/watch-out-for-zero-length-matches/
|
|
if (match.index == regex.lastIndex) {
|
|
regex.lastIndex++;
|
|
}
|
|
}
|
|
|
|
return chunks;
|
|
}, []);
|
|
};
|
|
// Allow the findChunks to be overridden in findAll,
|
|
// but for backwards compatibility we export as the old name
|
|
exports.findChunks = defaultFindChunks;
|
|
|
|
/**
|
|
* Given a set of chunks to highlight, create an additional set of chunks
|
|
* to represent the bits of text between the highlighted text.
|
|
* @param chunksToHighlight {start:number, end:number}[]
|
|
* @param totalLength number
|
|
* @return {start:number, end:number, highlight:boolean}[]
|
|
*/
|
|
|
|
var fillInChunks = exports.fillInChunks = function fillInChunks(_ref4) {
|
|
var chunksToHighlight = _ref4.chunksToHighlight,
|
|
totalLength = _ref4.totalLength;
|
|
|
|
var allChunks = [];
|
|
var append = function append(start, end, highlight) {
|
|
if (end - start > 0) {
|
|
allChunks.push({
|
|
start: start,
|
|
end: end,
|
|
highlight: highlight
|
|
});
|
|
}
|
|
};
|
|
|
|
if (chunksToHighlight.length === 0) {
|
|
append(0, totalLength, false);
|
|
} else {
|
|
var lastIndex = 0;
|
|
chunksToHighlight.forEach(function (chunk) {
|
|
append(lastIndex, chunk.start, false);
|
|
append(chunk.start, chunk.end, true);
|
|
lastIndex = chunk.end;
|
|
});
|
|
append(lastIndex, totalLength, false);
|
|
}
|
|
return allChunks;
|
|
};
|
|
|
|
function identity(value) {
|
|
return value;
|
|
}
|
|
|
|
function escapeRegExpFn(str) {
|
|
return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
|
|
}
|
|
|
|
/***/ })
|
|
/******/ ]);
|
|
//# sourceMappingURL=index.js.map
|
|
|
|
/***/ }),
|
|
/* 4 */
|
|
/***/ (function(module, exports, __nested_webpack_require_16653__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(process) {/**
|
|
* 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.
|
|
*/
|
|
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&
|
|
Symbol.for &&
|
|
Symbol.for('react.element')) ||
|
|
0xeac7;
|
|
|
|
var isValidElement = function(object) {
|
|
return typeof object === 'object' &&
|
|
object !== null &&
|
|
object.$$typeof === REACT_ELEMENT_TYPE;
|
|
};
|
|
|
|
// By explicitly using `prop-types` you are opting into new development behavior.
|
|
// http://fb.me/prop-types-in-prod
|
|
var throwOnDirectAccess = true;
|
|
module.exports = __nested_webpack_require_16653__(6)(isValidElement, throwOnDirectAccess);
|
|
} else {
|
|
// By explicitly using `prop-types` you are opting into new production behavior.
|
|
// http://fb.me/prop-types-in-prod
|
|
module.exports = __nested_webpack_require_16653__(13)();
|
|
}
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __nested_webpack_require_16653__(5)))
|
|
|
|
/***/ }),
|
|
/* 5 */
|
|
/***/ (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; };
|
|
|
|
|
|
/***/ }),
|
|
/* 6 */
|
|
/***/ (function(module, exports, __nested_webpack_require_23461__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(process) {/**
|
|
* 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.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var emptyFunction = __nested_webpack_require_23461__(7);
|
|
var invariant = __nested_webpack_require_23461__(8);
|
|
var warning = __nested_webpack_require_23461__(9);
|
|
var assign = __nested_webpack_require_23461__(10);
|
|
|
|
var ReactPropTypesSecret = __nested_webpack_require_23461__(11);
|
|
var checkPropTypes = __nested_webpack_require_23461__(12);
|
|
|
|
module.exports = function(isValidElement, throwOnDirectAccess) {
|
|
/* global Symbol */
|
|
var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
|
|
var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
|
|
|
|
/**
|
|
* Returns the iterator method function contained on the iterable object.
|
|
*
|
|
* Be sure to invoke the function with the iterable as context:
|
|
*
|
|
* var iteratorFn = getIteratorFn(myIterable);
|
|
* if (iteratorFn) {
|
|
* var iterator = iteratorFn.call(myIterable);
|
|
* ...
|
|
* }
|
|
*
|
|
* @param {?object} maybeIterable
|
|
* @return {?function}
|
|
*/
|
|
function getIteratorFn(maybeIterable) {
|
|
var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
|
|
if (typeof iteratorFn === 'function') {
|
|
return iteratorFn;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Collection of methods that allow declaration and validation of props that are
|
|
* supplied to React components. Example usage:
|
|
*
|
|
* var Props = require('ReactPropTypes');
|
|
* var MyArticle = React.createClass({
|
|
* propTypes: {
|
|
* // An optional string prop named "description".
|
|
* description: Props.string,
|
|
*
|
|
* // A required enum prop named "category".
|
|
* category: Props.oneOf(['News','Photos']).isRequired,
|
|
*
|
|
* // A prop named "dialog" that requires an instance of Dialog.
|
|
* dialog: Props.instanceOf(Dialog).isRequired
|
|
* },
|
|
* render: function() { ... }
|
|
* });
|
|
*
|
|
* A more formal specification of how these methods are used:
|
|
*
|
|
* type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
|
|
* decl := ReactPropTypes.{type}(.isRequired)?
|
|
*
|
|
* Each and every declaration produces a function with the same signature. This
|
|
* allows the creation of custom validation functions. For example:
|
|
*
|
|
* var MyLink = React.createClass({
|
|
* propTypes: {
|
|
* // An optional string or URI prop named "href".
|
|
* href: function(props, propName, componentName) {
|
|
* var propValue = props[propName];
|
|
* if (propValue != null && typeof propValue !== 'string' &&
|
|
* !(propValue instanceof URI)) {
|
|
* return new Error(
|
|
* 'Expected a string or an URI for ' + propName + ' in ' +
|
|
* componentName
|
|
* );
|
|
* }
|
|
* }
|
|
* },
|
|
* render: function() {...}
|
|
* });
|
|
*
|
|
* @internal
|
|
*/
|
|
|
|
var ANONYMOUS = '<<anonymous>>';
|
|
|
|
// Important!
|
|
// Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
|
|
var ReactPropTypes = {
|
|
array: createPrimitiveTypeChecker('array'),
|
|
bool: createPrimitiveTypeChecker('boolean'),
|
|
func: createPrimitiveTypeChecker('function'),
|
|
number: createPrimitiveTypeChecker('number'),
|
|
object: createPrimitiveTypeChecker('object'),
|
|
string: createPrimitiveTypeChecker('string'),
|
|
symbol: createPrimitiveTypeChecker('symbol'),
|
|
|
|
any: createAnyTypeChecker(),
|
|
arrayOf: createArrayOfTypeChecker,
|
|
element: createElementTypeChecker(),
|
|
instanceOf: createInstanceTypeChecker,
|
|
node: createNodeChecker(),
|
|
objectOf: createObjectOfTypeChecker,
|
|
oneOf: createEnumTypeChecker,
|
|
oneOfType: createUnionTypeChecker,
|
|
shape: createShapeTypeChecker,
|
|
exact: createStrictShapeTypeChecker,
|
|
};
|
|
|
|
/**
|
|
* inlined Object.is polyfill to avoid requiring consumers ship their own
|
|
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
|
|
*/
|
|
/*eslint-disable no-self-compare*/
|
|
function is(x, y) {
|
|
// SameValue algorithm
|
|
if (x === y) {
|
|
// Steps 1-5, 7-10
|
|
// Steps 6.b-6.e: +0 != -0
|
|
return x !== 0 || 1 / x === 1 / y;
|
|
} else {
|
|
// Step 6.a: NaN == NaN
|
|
return x !== x && y !== y;
|
|
}
|
|
}
|
|
/*eslint-enable no-self-compare*/
|
|
|
|
/**
|
|
* We use an Error-like object for backward compatibility as people may call
|
|
* PropTypes directly and inspect their output. However, we don't use real
|
|
* Errors anymore. We don't inspect their stack anyway, and creating them
|
|
* is prohibitively expensive if they are created too often, such as what
|
|
* happens in oneOfType() for any type before the one that matched.
|
|
*/
|
|
function PropTypeError(message) {
|
|
this.message = message;
|
|
this.stack = '';
|
|
}
|
|
// Make `instanceof Error` still work for returned errors.
|
|
PropTypeError.prototype = Error.prototype;
|
|
|
|
function createChainableTypeChecker(validate) {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
var manualPropTypeCallCache = {};
|
|
var manualPropTypeWarningCount = 0;
|
|
}
|
|
function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
|
|
componentName = componentName || ANONYMOUS;
|
|
propFullName = propFullName || propName;
|
|
|
|
if (secret !== ReactPropTypesSecret) {
|
|
if (throwOnDirectAccess) {
|
|
// New behavior only for users of `prop-types` package
|
|
invariant(
|
|
false,
|
|
'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
|
|
'Use `PropTypes.checkPropTypes()` to call them. ' +
|
|
'Read more at http://fb.me/use-check-prop-types'
|
|
);
|
|
} else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
|
|
// Old behavior for people using React.PropTypes
|
|
var cacheKey = componentName + ':' + propName;
|
|
if (
|
|
!manualPropTypeCallCache[cacheKey] &&
|
|
// Avoid spamming the console because they are often not actionable except for lib authors
|
|
manualPropTypeWarningCount < 3
|
|
) {
|
|
warning(
|
|
false,
|
|
'You are manually calling a React.PropTypes validation ' +
|
|
'function for the `%s` prop on `%s`. This is deprecated ' +
|
|
'and will throw in the standalone `prop-types` package. ' +
|
|
'You may be seeing this warning due to a third-party PropTypes ' +
|
|
'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',
|
|
propFullName,
|
|
componentName
|
|
);
|
|
manualPropTypeCallCache[cacheKey] = true;
|
|
manualPropTypeWarningCount++;
|
|
}
|
|
}
|
|
}
|
|
if (props[propName] == null) {
|
|
if (isRequired) {
|
|
if (props[propName] === null) {
|
|
return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
|
|
}
|
|
return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
|
|
}
|
|
return null;
|
|
} else {
|
|
return validate(props, propName, componentName, location, propFullName);
|
|
}
|
|
}
|
|
|
|
var chainedCheckType = checkType.bind(null, false);
|
|
chainedCheckType.isRequired = checkType.bind(null, true);
|
|
|
|
return chainedCheckType;
|
|
}
|
|
|
|
function createPrimitiveTypeChecker(expectedType) {
|
|
function validate(props, propName, componentName, location, propFullName, secret) {
|
|
var propValue = props[propName];
|
|
var propType = getPropType(propValue);
|
|
if (propType !== expectedType) {
|
|
// `propValue` being instance of, say, date/regexp, pass the 'object'
|
|
// check, but we can offer a more precise error message here rather than
|
|
// 'of type `object`'.
|
|
var preciseType = getPreciseType(propValue);
|
|
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createAnyTypeChecker() {
|
|
return createChainableTypeChecker(emptyFunction.thatReturnsNull);
|
|
}
|
|
|
|
function createArrayOfTypeChecker(typeChecker) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
if (typeof typeChecker !== 'function') {
|
|
return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
|
|
}
|
|
var propValue = props[propName];
|
|
if (!Array.isArray(propValue)) {
|
|
var propType = getPropType(propValue);
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
|
|
}
|
|
for (var i = 0; i < propValue.length; i++) {
|
|
var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
|
|
if (error instanceof Error) {
|
|
return error;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createElementTypeChecker() {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
var propValue = props[propName];
|
|
if (!isValidElement(propValue)) {
|
|
var propType = getPropType(propValue);
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createInstanceTypeChecker(expectedClass) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
if (!(props[propName] instanceof expectedClass)) {
|
|
var expectedClassName = expectedClass.name || ANONYMOUS;
|
|
var actualClassName = getClassName(props[propName]);
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createEnumTypeChecker(expectedValues) {
|
|
if (!Array.isArray(expectedValues)) {
|
|
process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
|
|
return emptyFunction.thatReturnsNull;
|
|
}
|
|
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
var propValue = props[propName];
|
|
for (var i = 0; i < expectedValues.length; i++) {
|
|
if (is(propValue, expectedValues[i])) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
var valuesString = JSON.stringify(expectedValues);
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createObjectOfTypeChecker(typeChecker) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
if (typeof typeChecker !== 'function') {
|
|
return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
|
|
}
|
|
var propValue = props[propName];
|
|
var propType = getPropType(propValue);
|
|
if (propType !== 'object') {
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
|
|
}
|
|
for (var key in propValue) {
|
|
if (propValue.hasOwnProperty(key)) {
|
|
var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
|
|
if (error instanceof Error) {
|
|
return error;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createUnionTypeChecker(arrayOfTypeCheckers) {
|
|
if (!Array.isArray(arrayOfTypeCheckers)) {
|
|
process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
|
|
return emptyFunction.thatReturnsNull;
|
|
}
|
|
|
|
for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
|
|
var checker = arrayOfTypeCheckers[i];
|
|
if (typeof checker !== 'function') {
|
|
warning(
|
|
false,
|
|
'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
|
|
'received %s at index %s.',
|
|
getPostfixForTypeWarning(checker),
|
|
i
|
|
);
|
|
return emptyFunction.thatReturnsNull;
|
|
}
|
|
}
|
|
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
|
|
var checker = arrayOfTypeCheckers[i];
|
|
if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createNodeChecker() {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
if (!isNode(props[propName])) {
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createShapeTypeChecker(shapeTypes) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
var propValue = props[propName];
|
|
var propType = getPropType(propValue);
|
|
if (propType !== 'object') {
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
|
|
}
|
|
for (var key in shapeTypes) {
|
|
var checker = shapeTypes[key];
|
|
if (!checker) {
|
|
continue;
|
|
}
|
|
var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
|
|
if (error) {
|
|
return error;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createStrictShapeTypeChecker(shapeTypes) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
var propValue = props[propName];
|
|
var propType = getPropType(propValue);
|
|
if (propType !== 'object') {
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
|
|
}
|
|
// We need to check all keys in case some are required but missing from
|
|
// props.
|
|
var allKeys = assign({}, props[propName], shapeTypes);
|
|
for (var key in allKeys) {
|
|
var checker = shapeTypes[key];
|
|
if (!checker) {
|
|
return new PropTypeError(
|
|
'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
|
|
'\nBad object: ' + JSON.stringify(props[propName], null, ' ') +
|
|
'\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ')
|
|
);
|
|
}
|
|
var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
|
|
if (error) {
|
|
return error;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function isNode(propValue) {
|
|
switch (typeof propValue) {
|
|
case 'number':
|
|
case 'string':
|
|
case 'undefined':
|
|
return true;
|
|
case 'boolean':
|
|
return !propValue;
|
|
case 'object':
|
|
if (Array.isArray(propValue)) {
|
|
return propValue.every(isNode);
|
|
}
|
|
if (propValue === null || isValidElement(propValue)) {
|
|
return true;
|
|
}
|
|
|
|
var iteratorFn = getIteratorFn(propValue);
|
|
if (iteratorFn) {
|
|
var iterator = iteratorFn.call(propValue);
|
|
var step;
|
|
if (iteratorFn !== propValue.entries) {
|
|
while (!(step = iterator.next()).done) {
|
|
if (!isNode(step.value)) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
// Iterator will provide entry [k,v] tuples rather than values.
|
|
while (!(step = iterator.next()).done) {
|
|
var entry = step.value;
|
|
if (entry) {
|
|
if (!isNode(entry[1])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function isSymbol(propType, propValue) {
|
|
// Native Symbol.
|
|
if (propType === 'symbol') {
|
|
return true;
|
|
}
|
|
|
|
// 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
|
|
if (propValue['@@toStringTag'] === 'Symbol') {
|
|
return true;
|
|
}
|
|
|
|
// Fallback for non-spec compliant Symbols which are polyfilled.
|
|
if (typeof Symbol === 'function' && propValue instanceof Symbol) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Equivalent of `typeof` but with special handling for array and regexp.
|
|
function getPropType(propValue) {
|
|
var propType = typeof propValue;
|
|
if (Array.isArray(propValue)) {
|
|
return 'array';
|
|
}
|
|
if (propValue instanceof RegExp) {
|
|
// Old webkits (at least until Android 4.0) return 'function' rather than
|
|
// 'object' for typeof a RegExp. We'll normalize this here so that /bla/
|
|
// passes PropTypes.object.
|
|
return 'object';
|
|
}
|
|
if (isSymbol(propType, propValue)) {
|
|
return 'symbol';
|
|
}
|
|
return propType;
|
|
}
|
|
|
|
// This handles more types than `getPropType`. Only used for error messages.
|
|
// See `createPrimitiveTypeChecker`.
|
|
function getPreciseType(propValue) {
|
|
if (typeof propValue === 'undefined' || propValue === null) {
|
|
return '' + propValue;
|
|
}
|
|
var propType = getPropType(propValue);
|
|
if (propType === 'object') {
|
|
if (propValue instanceof Date) {
|
|
return 'date';
|
|
} else if (propValue instanceof RegExp) {
|
|
return 'regexp';
|
|
}
|
|
}
|
|
return propType;
|
|
}
|
|
|
|
// Returns a string that is postfixed to a warning about an invalid type.
|
|
// For example, "undefined" or "of type array"
|
|
function getPostfixForTypeWarning(value) {
|
|
var type = getPreciseType(value);
|
|
switch (type) {
|
|
case 'array':
|
|
case 'object':
|
|
return 'an ' + type;
|
|
case 'boolean':
|
|
case 'date':
|
|
case 'regexp':
|
|
return 'a ' + type;
|
|
default:
|
|
return type;
|
|
}
|
|
}
|
|
|
|
// Returns class name of the object, if any.
|
|
function getClassName(propValue) {
|
|
if (!propValue.constructor || !propValue.constructor.name) {
|
|
return ANONYMOUS;
|
|
}
|
|
return propValue.constructor.name;
|
|
}
|
|
|
|
ReactPropTypes.checkPropTypes = checkPropTypes;
|
|
ReactPropTypes.PropTypes = ReactPropTypes;
|
|
|
|
return ReactPropTypes;
|
|
};
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __nested_webpack_require_23461__(5)))
|
|
|
|
/***/ }),
|
|
/* 7 */
|
|
/***/ (function(module, exports) {
|
|
|
|
"use strict";
|
|
|
|
/**
|
|
* 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 makeEmptyFunction(arg) {
|
|
return function () {
|
|
return arg;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* This function accepts and discards inputs; it has no side effects. This is
|
|
* primarily useful idiomatically for overridable function endpoints which
|
|
* always need to be callable, since JS lacks a null-call idiom ala Cocoa.
|
|
*/
|
|
var emptyFunction = function emptyFunction() {};
|
|
|
|
emptyFunction.thatReturns = makeEmptyFunction;
|
|
emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
|
|
emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
|
|
emptyFunction.thatReturnsNull = makeEmptyFunction(null);
|
|
emptyFunction.thatReturnsThis = function () {
|
|
return this;
|
|
};
|
|
emptyFunction.thatReturnsArgument = function (arg) {
|
|
return arg;
|
|
};
|
|
|
|
module.exports = emptyFunction;
|
|
|
|
/***/ }),
|
|
/* 8 */
|
|
/***/ (function(module, exports, __nested_webpack_require_45053__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(process) {/**
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/**
|
|
* Use invariant() to assert state which your program assumes to be true.
|
|
*
|
|
* Provide sprintf-style format (only %s is supported) and arguments
|
|
* to provide information about what broke and what you were
|
|
* expecting.
|
|
*
|
|
* The invariant message will be stripped in production, but the invariant
|
|
* will remain to ensure logic does not differ in production.
|
|
*/
|
|
|
|
var validateFormat = function validateFormat(format) {};
|
|
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
validateFormat = function validateFormat(format) {
|
|
if (format === undefined) {
|
|
throw new Error('invariant requires an error message argument');
|
|
}
|
|
};
|
|
}
|
|
|
|
function invariant(condition, format, a, b, c, d, e, f) {
|
|
validateFormat(format);
|
|
|
|
if (!condition) {
|
|
var error;
|
|
if (format === undefined) {
|
|
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; // we don't care about invariant's own frame
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
module.exports = invariant;
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __nested_webpack_require_45053__(5)))
|
|
|
|
/***/ }),
|
|
/* 9 */
|
|
/***/ (function(module, exports, __nested_webpack_require_46805__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(process) {/**
|
|
* Copyright (c) 2014-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.
|
|
*
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var emptyFunction = __nested_webpack_require_46805__(7);
|
|
|
|
/**
|
|
* Similar to invariant but only logs a warning if the condition is not met.
|
|
* This can be used to log issues in development environments in critical
|
|
* paths. Removing the logging code for production environments will keep the
|
|
* same logic and follow the same code paths.
|
|
*/
|
|
|
|
var warning = emptyFunction;
|
|
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
var printWarning = function printWarning(format) {
|
|
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
args[_key - 1] = arguments[_key];
|
|
}
|
|
|
|
var argIndex = 0;
|
|
var message = 'Warning: ' + format.replace(/%s/g, function () {
|
|
return args[argIndex++];
|
|
});
|
|
if (typeof console !== 'undefined') {
|
|
console.error(message);
|
|
}
|
|
try {
|
|
// --- Welcome to debugging React ---
|
|
// This error was thrown as a convenience so that you can use this stack
|
|
// to find the callsite that caused this warning to fire.
|
|
throw new Error(message);
|
|
} catch (x) {}
|
|
};
|
|
|
|
warning = function warning(condition, format) {
|
|
if (format === undefined) {
|
|
throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
|
|
}
|
|
|
|
if (format.indexOf('Failed Composite propType: ') === 0) {
|
|
return; // Ignore CompositeComponent proptype check.
|
|
}
|
|
|
|
if (!condition) {
|
|
for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
|
|
args[_key2 - 2] = arguments[_key2];
|
|
}
|
|
|
|
printWarning.apply(undefined, [format].concat(args));
|
|
}
|
|
};
|
|
}
|
|
|
|
module.exports = warning;
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __nested_webpack_require_46805__(5)))
|
|
|
|
/***/ }),
|
|
/* 10 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/*
|
|
object-assign
|
|
(c) Sindre Sorhus
|
|
@license MIT
|
|
*/
|
|
|
|
'use strict';
|
|
/* eslint-disable no-unused-vars */
|
|
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
|
|
|
|
function toObject(val) {
|
|
if (val === null || val === undefined) {
|
|
throw new TypeError('Object.assign cannot be called with null or undefined');
|
|
}
|
|
|
|
return Object(val);
|
|
}
|
|
|
|
function shouldUseNative() {
|
|
try {
|
|
if (!Object.assign) {
|
|
return false;
|
|
}
|
|
|
|
// Detect buggy property enumeration order in older V8 versions.
|
|
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=4118
|
|
var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
|
|
test1[5] = 'de';
|
|
if (Object.getOwnPropertyNames(test1)[0] === '5') {
|
|
return false;
|
|
}
|
|
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
|
|
var test2 = {};
|
|
for (var i = 0; i < 10; i++) {
|
|
test2['_' + String.fromCharCode(i)] = i;
|
|
}
|
|
var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
|
|
return test2[n];
|
|
});
|
|
if (order2.join('') !== '0123456789') {
|
|
return false;
|
|
}
|
|
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
|
|
var test3 = {};
|
|
'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
|
|
test3[letter] = letter;
|
|
});
|
|
if (Object.keys(Object.assign({}, test3)).join('') !==
|
|
'abcdefghijklmnopqrst') {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
} catch (err) {
|
|
// We don't expect any of the above to throw, but better to be safe.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
module.exports = shouldUseNative() ? Object.assign : function (target, source) {
|
|
var from;
|
|
var to = toObject(target);
|
|
var symbols;
|
|
|
|
for (var s = 1; s < arguments.length; s++) {
|
|
from = Object(arguments[s]);
|
|
|
|
for (var key in from) {
|
|
if (hasOwnProperty.call(from, key)) {
|
|
to[key] = from[key];
|
|
}
|
|
}
|
|
|
|
if (getOwnPropertySymbols) {
|
|
symbols = getOwnPropertySymbols(from);
|
|
for (var i = 0; i < symbols.length; i++) {
|
|
if (propIsEnumerable.call(from, symbols[i])) {
|
|
to[symbols[i]] = from[symbols[i]];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return to;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 11 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
|
|
|
|
module.exports = ReactPropTypesSecret;
|
|
|
|
|
|
/***/ }),
|
|
/* 12 */
|
|
/***/ (function(module, exports, __nested_webpack_require_51592__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(process) {/**
|
|
* 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.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
var invariant = __nested_webpack_require_51592__(8);
|
|
var warning = __nested_webpack_require_51592__(9);
|
|
var ReactPropTypesSecret = __nested_webpack_require_51592__(11);
|
|
var loggedTypeFailures = {};
|
|
}
|
|
|
|
/**
|
|
* Assert that the values match with the type specs.
|
|
* Error messages are memorized and will only be shown once.
|
|
*
|
|
* @param {object} typeSpecs Map of name to a ReactPropType
|
|
* @param {object} values Runtime values that need to be type-checked
|
|
* @param {string} location e.g. "prop", "context", "child context"
|
|
* @param {string} componentName Name of the component for error messages.
|
|
* @param {?Function} getStack Returns the component stack.
|
|
* @private
|
|
*/
|
|
function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
for (var typeSpecName in typeSpecs) {
|
|
if (typeSpecs.hasOwnProperty(typeSpecName)) {
|
|
var error;
|
|
// Prop type validation may throw. In case they do, we don't want to
|
|
// fail the render phase where it didn't fail before. So we log it.
|
|
// After these have been cleaned up, we'll let them throw.
|
|
try {
|
|
// This is intentionally an invariant that gets caught. It's the same
|
|
// behavior as without this statement except with a better message.
|
|
invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]);
|
|
error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
|
|
} catch (ex) {
|
|
error = ex;
|
|
}
|
|
warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);
|
|
if (error instanceof Error && !(error.message in loggedTypeFailures)) {
|
|
// Only monitor this failure once because there tends to be a lot of the
|
|
// same error.
|
|
loggedTypeFailures[error.message] = true;
|
|
|
|
var stack = getStack ? getStack() : '';
|
|
|
|
warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = checkPropTypes;
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __nested_webpack_require_51592__(5)))
|
|
|
|
/***/ }),
|
|
/* 13 */
|
|
/***/ (function(module, exports, __nested_webpack_require_54693__) {
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var emptyFunction = __nested_webpack_require_54693__(7);
|
|
var invariant = __nested_webpack_require_54693__(8);
|
|
var ReactPropTypesSecret = __nested_webpack_require_54693__(11);
|
|
|
|
module.exports = function() {
|
|
function shim(props, propName, componentName, location, propFullName, secret) {
|
|
if (secret === ReactPropTypesSecret) {
|
|
// It is still safe when called from React.
|
|
return;
|
|
}
|
|
invariant(
|
|
false,
|
|
'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
|
|
'Use PropTypes.checkPropTypes() to call them. ' +
|
|
'Read more at http://fb.me/use-check-prop-types'
|
|
);
|
|
};
|
|
shim.isRequired = shim;
|
|
function getShim() {
|
|
return shim;
|
|
};
|
|
// Important!
|
|
// Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
|
|
var ReactPropTypes = {
|
|
array: shim,
|
|
bool: shim,
|
|
func: shim,
|
|
number: shim,
|
|
object: shim,
|
|
string: shim,
|
|
symbol: shim,
|
|
|
|
any: shim,
|
|
arrayOf: getShim,
|
|
element: shim,
|
|
instanceOf: getShim,
|
|
node: shim,
|
|
objectOf: getShim,
|
|
oneOf: getShim,
|
|
oneOfType: getShim,
|
|
shape: getShim,
|
|
exact: getShim
|
|
};
|
|
|
|
ReactPropTypes.checkPropTypes = emptyFunction;
|
|
ReactPropTypes.PropTypes = ReactPropTypes;
|
|
|
|
return ReactPropTypes;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 14 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = __webpack_require__(78156);
|
|
|
|
/***/ }),
|
|
/* 15 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
var simpleIsEqual = function simpleIsEqual(a, b) {
|
|
return a === b;
|
|
};
|
|
|
|
function index (resultFn) {
|
|
var isEqual = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : simpleIsEqual;
|
|
|
|
var lastThis = void 0;
|
|
var lastArgs = [];
|
|
var lastResult = void 0;
|
|
var calledOnce = false;
|
|
|
|
var isNewArgEqualToLast = function isNewArgEqualToLast(newArg, index) {
|
|
return isEqual(newArg, lastArgs[index]);
|
|
};
|
|
|
|
var result = function result() {
|
|
for (var _len = arguments.length, newArgs = Array(_len), _key = 0; _key < _len; _key++) {
|
|
newArgs[_key] = arguments[_key];
|
|
}
|
|
|
|
if (calledOnce && lastThis === this && newArgs.length === lastArgs.length && newArgs.every(isNewArgEqualToLast)) {
|
|
return lastResult;
|
|
}
|
|
|
|
calledOnce = true;
|
|
lastThis = this;
|
|
lastArgs = newArgs;
|
|
lastResult = resultFn.apply(this, newArgs);
|
|
return lastResult;
|
|
};
|
|
|
|
return result;
|
|
}
|
|
|
|
module.exports = index;
|
|
|
|
|
|
/***/ })
|
|
/******/ ]);
|
|
//# sourceMappingURL=main.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 94478:
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
L: () => (/* binding */ JSONTree)
|
|
});
|
|
|
|
// EXTERNAL MODULE: consume shared module (default) react@~18.2.0 (singleton) (fallback: ../node_modules/react/index.js)
|
|
var index_js_ = __webpack_require__(78156);
|
|
var index_js_default = /*#__PURE__*/__webpack_require__.n(index_js_);
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/extends.js
|
|
function _extends() {
|
|
return _extends = Object.assign ? Object.assign.bind() : function (n) {
|
|
for (var e = 1; e < arguments.length; e++) {
|
|
var t = arguments[e];
|
|
for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
|
|
}
|
|
return n;
|
|
}, _extends.apply(null, arguments);
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/objType.js
|
|
function objType(obj) {
|
|
const type = Object.prototype.toString.call(obj).slice(8, -1);
|
|
if (type === 'Object' && typeof obj[Symbol.iterator] === 'function') {
|
|
return 'Iterable';
|
|
}
|
|
if (type === 'Custom' && obj.constructor !== Object && obj instanceof Object) {
|
|
// For projects implementing objects overriding `.prototype[Symbol.toStringTag]`
|
|
return 'Object';
|
|
}
|
|
return type;
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/JSONArrow.js
|
|
|
|
|
|
function JSONArrow(_ref) {
|
|
let {
|
|
styling,
|
|
arrowStyle = 'single',
|
|
expanded,
|
|
nodeType,
|
|
onClick
|
|
} = _ref;
|
|
return /*#__PURE__*/index_js_default().createElement("div", _extends({}, styling('arrowContainer', arrowStyle), {
|
|
onClick: onClick
|
|
}), /*#__PURE__*/index_js_default().createElement("div", styling(['arrow', 'arrowSign'], nodeType, expanded, arrowStyle), '\u25B6', arrowStyle === 'double' && /*#__PURE__*/index_js_default().createElement("div", styling(['arrowSign', 'arrowSignInner']), '\u25B6')));
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/getCollectionEntries.js
|
|
function getLength(type, collection) {
|
|
if (type === 'Object') {
|
|
// eslint-disable-next-line @typescript-eslint/ban-types
|
|
return Object.keys(collection).length;
|
|
} else if (type === 'Array') {
|
|
return collection.length;
|
|
}
|
|
return Infinity;
|
|
}
|
|
function isIterableMap(collection) {
|
|
return typeof collection.set === 'function';
|
|
}
|
|
function getEntries(type, collection, sortObjectKeys) {
|
|
let from = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
|
|
let to = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : Infinity;
|
|
let res;
|
|
if (type === 'Object') {
|
|
let keys = Object.getOwnPropertyNames(collection);
|
|
if (sortObjectKeys) {
|
|
keys.sort(sortObjectKeys === true ? undefined : sortObjectKeys);
|
|
}
|
|
keys = keys.slice(from, to + 1);
|
|
res = {
|
|
entries: keys.map(key => ({
|
|
key,
|
|
value: collection[key]
|
|
}))
|
|
};
|
|
} else if (type === 'Array') {
|
|
res = {
|
|
entries: collection.slice(from, to + 1).map((val, idx) => ({
|
|
key: idx + from,
|
|
value: val
|
|
}))
|
|
};
|
|
} else {
|
|
let idx = 0;
|
|
const entries = [];
|
|
let done = true;
|
|
const isMap = isIterableMap(collection);
|
|
for (const item of collection) {
|
|
if (idx > to) {
|
|
done = false;
|
|
break;
|
|
}
|
|
if (from <= idx) {
|
|
if (isMap && Array.isArray(item)) {
|
|
if (typeof item[0] === 'string' || typeof item[0] === 'number') {
|
|
entries.push({
|
|
key: item[0],
|
|
value: item[1]
|
|
});
|
|
} else {
|
|
entries.push({
|
|
key: `[entry ${idx}]`,
|
|
value: {
|
|
'[key]': item[0],
|
|
'[value]': item[1]
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
entries.push({
|
|
key: idx,
|
|
value: item
|
|
});
|
|
}
|
|
}
|
|
idx++;
|
|
}
|
|
res = {
|
|
hasMore: !done,
|
|
entries
|
|
};
|
|
}
|
|
return res;
|
|
}
|
|
function getRanges(from, to, limit) {
|
|
const ranges = [];
|
|
while (to - from > limit * limit) {
|
|
limit = limit * limit;
|
|
}
|
|
for (let i = from; i <= to; i += limit) {
|
|
ranges.push({
|
|
from: i,
|
|
to: Math.min(to, i + limit - 1)
|
|
});
|
|
}
|
|
return ranges;
|
|
}
|
|
function getCollectionEntries(type, collection, sortObjectKeys, limit) {
|
|
let from = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
|
|
let to = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : Infinity;
|
|
const getEntriesBound = getEntries.bind(null, type, collection, sortObjectKeys);
|
|
if (!limit) {
|
|
return getEntriesBound().entries;
|
|
}
|
|
const isSubset = to < Infinity;
|
|
const length = Math.min(to - from, getLength(type, collection));
|
|
if (type !== 'Iterable') {
|
|
if (length <= limit || limit < 7) {
|
|
return getEntriesBound(from, to).entries;
|
|
}
|
|
} else {
|
|
if (length <= limit && !isSubset) {
|
|
return getEntriesBound(from, to).entries;
|
|
}
|
|
}
|
|
let limitedEntries;
|
|
if (type === 'Iterable') {
|
|
const {
|
|
hasMore,
|
|
entries
|
|
} = getEntriesBound(from, from + limit - 1);
|
|
limitedEntries = hasMore ? [...entries, ...getRanges(from + limit, from + 2 * limit - 1, limit)] : entries;
|
|
} else {
|
|
limitedEntries = isSubset ? getRanges(from, to, limit) : [...getEntriesBound(0, limit - 5).entries, ...getRanges(limit - 4, length - 5, limit), ...getEntriesBound(length - 4, length - 1).entries];
|
|
}
|
|
return limitedEntries;
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/ItemRange.js
|
|
|
|
|
|
|
|
function ItemRange(props) {
|
|
const {
|
|
styling,
|
|
from,
|
|
to,
|
|
renderChildNodes,
|
|
nodeType
|
|
} = props;
|
|
const [expanded, setExpanded] = (0,index_js_.useState)(false);
|
|
const handleClick = (0,index_js_.useCallback)(() => {
|
|
setExpanded(!expanded);
|
|
}, [expanded]);
|
|
return expanded ? /*#__PURE__*/index_js_default().createElement("div", styling('itemRange', expanded), renderChildNodes(props, from, to)) : /*#__PURE__*/index_js_default().createElement("div", _extends({}, styling('itemRange', expanded), {
|
|
onClick: handleClick
|
|
}), /*#__PURE__*/index_js_default().createElement(JSONArrow, {
|
|
nodeType: nodeType,
|
|
styling: styling,
|
|
expanded: false,
|
|
onClick: handleClick,
|
|
arrowStyle: "double"
|
|
}), `${from} ... ${to}`);
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/JSONNestedNode.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function isRange(rangeOrEntry) {
|
|
return rangeOrEntry.to !== undefined;
|
|
}
|
|
function renderChildNodes(props, from, to) {
|
|
const {
|
|
nodeType,
|
|
data,
|
|
collectionLimit,
|
|
circularCache,
|
|
keyPath,
|
|
postprocessValue,
|
|
sortObjectKeys
|
|
} = props;
|
|
const childNodes = [];
|
|
getCollectionEntries(nodeType, data, sortObjectKeys, collectionLimit, from, to).forEach(entry => {
|
|
if (isRange(entry)) {
|
|
childNodes.push( /*#__PURE__*/index_js_default().createElement(ItemRange, _extends({}, props, {
|
|
key: `ItemRange--${entry.from}-${entry.to}`,
|
|
from: entry.from,
|
|
to: entry.to,
|
|
renderChildNodes: renderChildNodes
|
|
})));
|
|
} else {
|
|
const {
|
|
key,
|
|
value
|
|
} = entry;
|
|
const isCircular = circularCache.indexOf(value) !== -1;
|
|
childNodes.push( /*#__PURE__*/index_js_default().createElement(JSONNode, _extends({}, props, {
|
|
postprocessValue,
|
|
collectionLimit,
|
|
key: `Node--${key}`,
|
|
keyPath: [key, ...keyPath],
|
|
value: postprocessValue(value),
|
|
circularCache: [...circularCache, value],
|
|
isCircular: isCircular,
|
|
hideRoot: false
|
|
})));
|
|
}
|
|
});
|
|
return childNodes;
|
|
}
|
|
function JSONNestedNode(props) {
|
|
const {
|
|
circularCache = [],
|
|
collectionLimit,
|
|
createItemString,
|
|
data,
|
|
expandable,
|
|
getItemString,
|
|
hideRoot,
|
|
isCircular,
|
|
keyPath,
|
|
labelRenderer,
|
|
level = 0,
|
|
nodeType,
|
|
nodeTypeIndicator,
|
|
shouldExpandNodeInitially,
|
|
styling
|
|
} = props;
|
|
const [expanded, setExpanded] = (0,index_js_.useState)(
|
|
// calculate individual node expansion if necessary
|
|
isCircular ? false : shouldExpandNodeInitially(keyPath, data, level));
|
|
const handleClick = (0,index_js_.useCallback)(() => {
|
|
if (expandable) setExpanded(!expanded);
|
|
}, [expandable, expanded]);
|
|
const renderedChildren = expanded || hideRoot && level === 0 ? renderChildNodes({
|
|
...props,
|
|
circularCache,
|
|
level: level + 1
|
|
}) : null;
|
|
const itemType = /*#__PURE__*/index_js_default().createElement("span", styling('nestedNodeItemType', expanded), nodeTypeIndicator);
|
|
const renderedItemString = getItemString(nodeType, data, itemType, createItemString(data, collectionLimit), keyPath);
|
|
const stylingArgs = [keyPath, nodeType, expanded, expandable];
|
|
return hideRoot ? /*#__PURE__*/index_js_default().createElement("li", styling('rootNode', ...stylingArgs), /*#__PURE__*/index_js_default().createElement("ul", styling('rootNodeChildren', ...stylingArgs), renderedChildren)) : /*#__PURE__*/index_js_default().createElement("li", styling('nestedNode', ...stylingArgs), expandable && /*#__PURE__*/index_js_default().createElement(JSONArrow, {
|
|
styling: styling,
|
|
nodeType: nodeType,
|
|
expanded: expanded,
|
|
onClick: handleClick
|
|
}), /*#__PURE__*/index_js_default().createElement("label", _extends({}, styling(['label', 'nestedNodeLabel'], ...stylingArgs), {
|
|
onClick: handleClick
|
|
}), labelRenderer(...stylingArgs)), /*#__PURE__*/index_js_default().createElement("span", _extends({}, styling('nestedNodeItemString', ...stylingArgs), {
|
|
onClick: handleClick
|
|
}), renderedItemString), /*#__PURE__*/index_js_default().createElement("ul", styling('nestedNodeChildren', ...stylingArgs), renderedChildren));
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/JSONObjectNode.js
|
|
|
|
|
|
|
|
// Returns the "n Items" string for this node,
|
|
// generating and caching it if it hasn't been created yet.
|
|
function createItemString(data) {
|
|
const len = Object.getOwnPropertyNames(data).length;
|
|
return `${len} ${len !== 1 ? 'keys' : 'key'}`;
|
|
}
|
|
// Configures <JSONNestedNode> to render an Object
|
|
function JSONObjectNode(_ref) {
|
|
let {
|
|
data,
|
|
...props
|
|
} = _ref;
|
|
return /*#__PURE__*/index_js_default().createElement(JSONNestedNode, _extends({}, props, {
|
|
data: data,
|
|
nodeType: "Object",
|
|
nodeTypeIndicator: props.nodeType === 'Error' ? 'Error()' : '{}',
|
|
createItemString: createItemString,
|
|
expandable: Object.getOwnPropertyNames(data).length > 0
|
|
}));
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/JSONArrayNode.js
|
|
|
|
|
|
|
|
// Returns the "n Items" string for this node,
|
|
// generating and caching it if it hasn't been created yet.
|
|
function JSONArrayNode_createItemString(data) {
|
|
return `${data.length} ${data.length !== 1 ? 'items' : 'item'}`;
|
|
}
|
|
// Configures <JSONNestedNode> to render an Array
|
|
function JSONArrayNode(_ref) {
|
|
let {
|
|
data,
|
|
...props
|
|
} = _ref;
|
|
return /*#__PURE__*/index_js_default().createElement(JSONNestedNode, _extends({}, props, {
|
|
data: data,
|
|
nodeType: "Array",
|
|
nodeTypeIndicator: "[]",
|
|
createItemString: JSONArrayNode_createItemString,
|
|
expandable: data.length > 0
|
|
}));
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/JSONIterableNode.js
|
|
|
|
|
|
|
|
// Returns the "n Items" string for this node,
|
|
// generating and caching it if it hasn't been created yet.
|
|
function JSONIterableNode_createItemString(data, limit) {
|
|
let count = 0;
|
|
let hasMore = false;
|
|
if (Number.isSafeInteger(data.size)) {
|
|
count = data.size;
|
|
} else {
|
|
// eslint-disable-next-line no-unused-vars
|
|
for (const entry of data) {
|
|
if (limit && count + 1 > limit) {
|
|
hasMore = true;
|
|
break;
|
|
}
|
|
count += 1;
|
|
}
|
|
}
|
|
return `${hasMore ? '>' : ''}${count} ${count !== 1 ? 'entries' : 'entry'}`;
|
|
}
|
|
// Configures <JSONNestedNode> to render an iterable
|
|
function JSONIterableNode(props) {
|
|
return /*#__PURE__*/index_js_default().createElement(JSONNestedNode, _extends({}, props, {
|
|
nodeType: "Iterable",
|
|
nodeTypeIndicator: "()",
|
|
createItemString: JSONIterableNode_createItemString,
|
|
expandable: true
|
|
}));
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/JSONValueNode.js
|
|
|
|
function JSONValueNode(_ref) {
|
|
let {
|
|
nodeType,
|
|
styling,
|
|
labelRenderer,
|
|
keyPath,
|
|
valueRenderer,
|
|
value,
|
|
valueGetter = value => value
|
|
} = _ref;
|
|
return /*#__PURE__*/index_js_default().createElement("li", styling('value', nodeType, keyPath), /*#__PURE__*/index_js_default().createElement("label", styling(['label', 'valueLabel'], nodeType, keyPath), labelRenderer(keyPath, nodeType, false, false)), /*#__PURE__*/index_js_default().createElement("span", styling('valueText', nodeType, keyPath), valueRenderer(valueGetter(value), value, ...keyPath)));
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/JSONNode.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function JSONNode(_ref) {
|
|
let {
|
|
getItemString,
|
|
keyPath,
|
|
labelRenderer,
|
|
styling,
|
|
value,
|
|
valueRenderer,
|
|
isCustomNode,
|
|
...rest
|
|
} = _ref;
|
|
const nodeType = isCustomNode(value) ? 'Custom' : objType(value);
|
|
const simpleNodeProps = {
|
|
getItemString,
|
|
key: keyPath[0],
|
|
keyPath,
|
|
labelRenderer,
|
|
nodeType,
|
|
styling,
|
|
value,
|
|
valueRenderer
|
|
};
|
|
const nestedNodeProps = {
|
|
...rest,
|
|
...simpleNodeProps,
|
|
data: value,
|
|
isCustomNode
|
|
};
|
|
switch (nodeType) {
|
|
case 'Object':
|
|
case 'Error':
|
|
case 'WeakMap':
|
|
case 'WeakSet':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONObjectNode, nestedNodeProps);
|
|
case 'Array':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONArrayNode, nestedNodeProps);
|
|
case 'Iterable':
|
|
case 'Map':
|
|
case 'Set':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONIterableNode, nestedNodeProps);
|
|
case 'String':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONValueNode, _extends({}, simpleNodeProps, {
|
|
valueGetter: raw => `"${raw}"`
|
|
}));
|
|
case 'Number':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONValueNode, simpleNodeProps);
|
|
case 'Boolean':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONValueNode, _extends({}, simpleNodeProps, {
|
|
valueGetter: raw => raw ? 'true' : 'false'
|
|
}));
|
|
case 'Date':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONValueNode, _extends({}, simpleNodeProps, {
|
|
valueGetter: raw => raw.toISOString()
|
|
}));
|
|
case 'Null':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONValueNode, _extends({}, simpleNodeProps, {
|
|
valueGetter: () => 'null'
|
|
}));
|
|
case 'Undefined':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONValueNode, _extends({}, simpleNodeProps, {
|
|
valueGetter: () => 'undefined'
|
|
}));
|
|
case 'Function':
|
|
case 'Symbol':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONValueNode, _extends({}, simpleNodeProps, {
|
|
valueGetter: raw => raw.toString()
|
|
}));
|
|
case 'Custom':
|
|
return /*#__PURE__*/index_js_default().createElement(JSONValueNode, simpleNodeProps);
|
|
default:
|
|
return /*#__PURE__*/index_js_default().createElement(JSONValueNode, _extends({}, simpleNodeProps, {
|
|
valueGetter: () => `<${nodeType}>`
|
|
}));
|
|
}
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/typeof.js
|
|
function _typeof(o) {
|
|
"@babel/helpers - typeof";
|
|
|
|
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
|
|
return typeof o;
|
|
} : function (o) {
|
|
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
|
|
}, _typeof(o);
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
|
|
|
|
function toPrimitive(t, r) {
|
|
if ("object" != _typeof(t) || !t) return t;
|
|
var e = t[Symbol.toPrimitive];
|
|
if (void 0 !== e) {
|
|
var i = e.call(t, r || "default");
|
|
if ("object" != _typeof(i)) return i;
|
|
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
}
|
|
return ("string" === r ? String : Number)(t);
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
|
|
|
|
|
|
function toPropertyKey(t) {
|
|
var i = toPrimitive(t, "string");
|
|
return "symbol" == _typeof(i) ? i : i + "";
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
|
|
function _defineProperty(e, r, t) {
|
|
return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
|
|
value: t,
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
writable: !0
|
|
}) : e[r] = t, e;
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
|
|
function _arrayWithHoles(r) {
|
|
if (Array.isArray(r)) return r;
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
|
|
function _iterableToArrayLimit(r, l) {
|
|
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
|
|
if (null != t) {
|
|
var e,
|
|
n,
|
|
i,
|
|
u,
|
|
a = [],
|
|
f = !0,
|
|
o = !1;
|
|
try {
|
|
if (i = (t = t.call(r)).next, 0 === l) {
|
|
if (Object(t) !== t) return;
|
|
f = !1;
|
|
} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
|
|
} catch (r) {
|
|
o = !0, n = r;
|
|
} finally {
|
|
try {
|
|
if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
|
|
} finally {
|
|
if (o) throw n;
|
|
}
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
|
|
function _arrayLikeToArray(r, a) {
|
|
(null == a || a > r.length) && (a = r.length);
|
|
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
|
|
return n;
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
|
|
|
|
function _unsupportedIterableToArray(r, a) {
|
|
if (r) {
|
|
if ("string" == typeof r) return _arrayLikeToArray(r, a);
|
|
var t = {}.toString.call(r).slice(8, -1);
|
|
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
|
|
function _nonIterableRest() {
|
|
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/slicedToArray.js
|
|
|
|
|
|
|
|
|
|
function _slicedToArray(r, e) {
|
|
return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
|
|
}
|
|
|
|
// EXTERNAL MODULE: ../node_modules/base16/lib/index.js
|
|
var lib = __webpack_require__(78052);
|
|
// EXTERNAL MODULE: ../node_modules/color/index.js
|
|
var node_modules_color = __webpack_require__(27124);
|
|
var color_default = /*#__PURE__*/__webpack_require__.n(node_modules_color);
|
|
// EXTERNAL MODULE: ../node_modules/lodash.curry/index.js
|
|
var lodash_curry = __webpack_require__(28401);
|
|
var lodash_curry_default = /*#__PURE__*/__webpack_require__.n(lodash_curry);
|
|
;// CONCATENATED MODULE: ../node_modules/react-base16-styling/lib/esm/colorConverters.js
|
|
function yuv2rgb(yuv) {
|
|
var y = yuv[0],
|
|
u = yuv[1],
|
|
v = yuv[2];
|
|
var r, g, b;
|
|
r = y * 1 + u * 0 + v * 1.13983;
|
|
g = y * 1 + u * -0.39465 + v * -0.5806;
|
|
b = y * 1 + u * 2.02311 + v * 0;
|
|
r = Math.min(Math.max(0, r), 1);
|
|
g = Math.min(Math.max(0, g), 1);
|
|
b = Math.min(Math.max(0, b), 1);
|
|
return [r * 255, g * 255, b * 255];
|
|
}
|
|
function rgb2yuv(rgb) {
|
|
var r = rgb[0] / 255,
|
|
g = rgb[1] / 255,
|
|
b = rgb[2] / 255;
|
|
var y = r * 0.299 + g * 0.587 + b * 0.114;
|
|
var u = r * -0.14713 + g * -0.28886 + b * 0.436;
|
|
var v = r * 0.615 + g * -0.51499 + b * -0.10001;
|
|
return [y, u, v];
|
|
}
|
|
;// CONCATENATED MODULE: ../node_modules/react-base16-styling/lib/esm/index.js
|
|
|
|
|
|
|
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
|
|
|
|
|
|
|
|
var DEFAULT_BASE16 = lib["default"];
|
|
var BASE16_KEYS = Object.keys(DEFAULT_BASE16); // we need a correcting factor, so that a dark, but not black background color
|
|
// converts to bright enough inversed color
|
|
|
|
var flip = function flip(x) {
|
|
return x < 0.25 ? 1 : x < 0.5 ? 0.9 - x : 1.1 - x;
|
|
};
|
|
|
|
var invertColor = function invertColor(hexString) {
|
|
var color = color_default()(hexString);
|
|
|
|
var _rgb2yuv = rgb2yuv(color.array()),
|
|
_rgb2yuv2 = _slicedToArray(_rgb2yuv, 3),
|
|
y = _rgb2yuv2[0],
|
|
u = _rgb2yuv2[1],
|
|
v = _rgb2yuv2[2];
|
|
|
|
var flippedYuv = [flip(y), u, v];
|
|
var rgb = yuv2rgb(flippedYuv);
|
|
return color_default().rgb(rgb).hex();
|
|
};
|
|
|
|
var merger = function merger(styling) {
|
|
return function (prevStyling) {
|
|
return {
|
|
className: [prevStyling.className, styling.className].filter(Boolean).join(' '),
|
|
style: _objectSpread(_objectSpread({}, prevStyling.style || {}), styling.style || {})
|
|
};
|
|
};
|
|
};
|
|
|
|
var mergeStyling = function mergeStyling(customStyling, defaultStyling) {
|
|
if (customStyling === undefined) {
|
|
return defaultStyling;
|
|
}
|
|
|
|
if (defaultStyling === undefined) {
|
|
return customStyling;
|
|
}
|
|
|
|
var customType = _typeof(customStyling);
|
|
|
|
var defaultType = _typeof(defaultStyling);
|
|
|
|
switch (customType) {
|
|
case 'string':
|
|
switch (defaultType) {
|
|
case 'string':
|
|
return [defaultStyling, customStyling].filter(Boolean).join(' ');
|
|
|
|
case 'object':
|
|
return merger({
|
|
className: customStyling,
|
|
style: defaultStyling
|
|
});
|
|
|
|
case 'function':
|
|
return function (styling) {
|
|
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
args[_key - 1] = arguments[_key];
|
|
}
|
|
|
|
return merger({
|
|
className: customStyling
|
|
})(defaultStyling.apply(void 0, [styling].concat(args)));
|
|
};
|
|
}
|
|
|
|
break;
|
|
|
|
case 'object':
|
|
switch (defaultType) {
|
|
case 'string':
|
|
return merger({
|
|
className: defaultStyling,
|
|
style: customStyling
|
|
});
|
|
|
|
case 'object':
|
|
return _objectSpread(_objectSpread({}, defaultStyling), customStyling);
|
|
|
|
case 'function':
|
|
return function (styling) {
|
|
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
args[_key2 - 1] = arguments[_key2];
|
|
}
|
|
|
|
return merger({
|
|
style: customStyling
|
|
})(defaultStyling.apply(void 0, [styling].concat(args)));
|
|
};
|
|
}
|
|
|
|
break;
|
|
|
|
case 'function':
|
|
switch (defaultType) {
|
|
case 'string':
|
|
return function (styling) {
|
|
for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
|
|
args[_key3 - 1] = arguments[_key3];
|
|
}
|
|
|
|
return customStyling.apply(void 0, [merger(styling)({
|
|
className: defaultStyling
|
|
})].concat(args));
|
|
};
|
|
|
|
case 'object':
|
|
return function (styling) {
|
|
for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
|
|
args[_key4 - 1] = arguments[_key4];
|
|
}
|
|
|
|
return customStyling.apply(void 0, [merger(styling)({
|
|
style: defaultStyling
|
|
})].concat(args));
|
|
};
|
|
|
|
case 'function':
|
|
return function (styling) {
|
|
for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
|
|
args[_key5 - 1] = arguments[_key5];
|
|
}
|
|
|
|
return customStyling.apply(void 0, [defaultStyling.apply(void 0, [styling].concat(args))].concat(args));
|
|
};
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
var mergeStylings = function mergeStylings(customStylings, defaultStylings) {
|
|
var keys = Object.keys(defaultStylings);
|
|
|
|
for (var key in customStylings) {
|
|
if (keys.indexOf(key) === -1) keys.push(key);
|
|
}
|
|
|
|
return keys.reduce(function (mergedStyling, key) {
|
|
return mergedStyling[key] = mergeStyling(customStylings[key], defaultStylings[key]), mergedStyling;
|
|
}, {});
|
|
};
|
|
|
|
var getStylingByKeys = function getStylingByKeys(mergedStyling, keys) {
|
|
for (var _len6 = arguments.length, args = new Array(_len6 > 2 ? _len6 - 2 : 0), _key6 = 2; _key6 < _len6; _key6++) {
|
|
args[_key6 - 2] = arguments[_key6];
|
|
}
|
|
|
|
if (keys === null) {
|
|
return mergedStyling;
|
|
}
|
|
|
|
if (!Array.isArray(keys)) {
|
|
keys = [keys];
|
|
}
|
|
|
|
var styles = keys.map(function (key) {
|
|
return mergedStyling[key];
|
|
}).filter(Boolean);
|
|
var props = styles.reduce(function (obj, s) {
|
|
if (typeof s === 'string') {
|
|
obj.className = [obj.className, s].filter(Boolean).join(' ');
|
|
} else if (_typeof(s) === 'object') {
|
|
obj.style = _objectSpread(_objectSpread({}, obj.style), s);
|
|
} else if (typeof s === 'function') {
|
|
obj = _objectSpread(_objectSpread({}, obj), s.apply(void 0, [obj].concat(args)));
|
|
}
|
|
|
|
return obj;
|
|
}, {
|
|
className: '',
|
|
style: {}
|
|
});
|
|
|
|
if (!props.className) {
|
|
delete props.className;
|
|
}
|
|
|
|
if (Object.keys(props.style).length === 0) {
|
|
delete props.style;
|
|
}
|
|
|
|
return props;
|
|
};
|
|
|
|
var invertBase16Theme = function invertBase16Theme(base16Theme) {
|
|
return Object.keys(base16Theme).reduce(function (t, key) {
|
|
return t[key] = /^base/.test(key) ? invertColor(base16Theme[key]) : key === 'scheme' ? base16Theme[key] + ':inverted' : base16Theme[key], t;
|
|
}, {});
|
|
};
|
|
var createStyling = lodash_curry_default()(function (getStylingFromBase16) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var themeOrStyling = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
var _options$defaultBase = options.defaultBase16,
|
|
defaultBase16 = _options$defaultBase === void 0 ? DEFAULT_BASE16 : _options$defaultBase,
|
|
_options$base16Themes = options.base16Themes,
|
|
base16Themes = _options$base16Themes === void 0 ? null : _options$base16Themes;
|
|
var base16Theme = getBase16Theme(themeOrStyling, base16Themes);
|
|
|
|
if (base16Theme) {
|
|
themeOrStyling = _objectSpread(_objectSpread({}, base16Theme), themeOrStyling);
|
|
}
|
|
|
|
var theme = BASE16_KEYS.reduce(function (t, key) {
|
|
return t[key] = themeOrStyling[key] || defaultBase16[key], t;
|
|
}, {});
|
|
var customStyling = Object.keys(themeOrStyling).reduce(function (s, key) {
|
|
return BASE16_KEYS.indexOf(key) === -1 ? (s[key] = themeOrStyling[key], s) : s;
|
|
}, {});
|
|
var defaultStyling = getStylingFromBase16(theme);
|
|
var mergedStyling = mergeStylings(customStyling, defaultStyling);
|
|
|
|
for (var _len7 = arguments.length, args = new Array(_len7 > 3 ? _len7 - 3 : 0), _key7 = 3; _key7 < _len7; _key7++) {
|
|
args[_key7 - 3] = arguments[_key7];
|
|
}
|
|
|
|
return lodash_curry_default()(getStylingByKeys, 2).apply(void 0, [mergedStyling].concat(args));
|
|
}, 3);
|
|
|
|
var isStylingConfig = function isStylingConfig(theme) {
|
|
return !!theme.extend;
|
|
};
|
|
|
|
var getBase16Theme = function getBase16Theme(theme, base16Themes) {
|
|
if (theme && isStylingConfig(theme) && theme.extend) {
|
|
theme = theme.extend;
|
|
}
|
|
|
|
if (typeof theme === 'string') {
|
|
var _theme$split = theme.split(':'),
|
|
_theme$split2 = _slicedToArray(_theme$split, 2),
|
|
_themeName = _theme$split2[0],
|
|
modifier = _theme$split2[1];
|
|
|
|
if (base16Themes) {
|
|
theme = base16Themes[_themeName];
|
|
} else {
|
|
theme = lib[_themeName];
|
|
}
|
|
|
|
if (modifier === 'inverted') {
|
|
theme = invertBase16Theme(theme);
|
|
}
|
|
}
|
|
|
|
return theme && Object.prototype.hasOwnProperty.call(theme, 'base00') ? theme : undefined;
|
|
};
|
|
var invertTheme = function invertTheme(theme) {
|
|
if (typeof theme === 'string') {
|
|
return "".concat(theme, ":inverted");
|
|
}
|
|
|
|
if (theme && isStylingConfig(theme) && theme.extend) {
|
|
if (typeof theme.extend === 'string') {
|
|
return _objectSpread(_objectSpread({}, theme), {}, {
|
|
extend: "".concat(theme.extend, ":inverted")
|
|
});
|
|
}
|
|
|
|
return _objectSpread(_objectSpread({}, theme), {}, {
|
|
extend: invertBase16Theme(theme.extend)
|
|
});
|
|
}
|
|
|
|
if (theme) {
|
|
return invertBase16Theme(theme);
|
|
}
|
|
|
|
return theme;
|
|
};
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/themes/solarized.js
|
|
/* harmony default export */ const solarized = ({
|
|
scheme: 'solarized',
|
|
author: 'ethan schoonover (http://ethanschoonover.com/solarized)',
|
|
base00: '#002b36',
|
|
base01: '#073642',
|
|
base02: '#586e75',
|
|
base03: '#657b83',
|
|
base04: '#839496',
|
|
base05: '#93a1a1',
|
|
base06: '#eee8d5',
|
|
base07: '#fdf6e3',
|
|
base08: '#dc322f',
|
|
base09: '#cb4b16',
|
|
base0A: '#b58900',
|
|
base0B: '#859900',
|
|
base0C: '#2aa198',
|
|
base0D: '#268bd2',
|
|
base0E: '#6c71c4',
|
|
base0F: '#d33682'
|
|
});
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/createStylingFromTheme.js
|
|
|
|
|
|
const colorMap = theme => ({
|
|
BACKGROUND_COLOR: theme.base00,
|
|
TEXT_COLOR: theme.base07,
|
|
STRING_COLOR: theme.base0B,
|
|
DATE_COLOR: theme.base0B,
|
|
NUMBER_COLOR: theme.base09,
|
|
BOOLEAN_COLOR: theme.base09,
|
|
NULL_COLOR: theme.base08,
|
|
UNDEFINED_COLOR: theme.base08,
|
|
FUNCTION_COLOR: theme.base08,
|
|
SYMBOL_COLOR: theme.base08,
|
|
LABEL_COLOR: theme.base0D,
|
|
ARROW_COLOR: theme.base0D,
|
|
ITEM_STRING_COLOR: theme.base0B,
|
|
ITEM_STRING_EXPANDED_COLOR: theme.base03
|
|
});
|
|
const valueColorMap = colors => ({
|
|
String: colors.STRING_COLOR,
|
|
Date: colors.DATE_COLOR,
|
|
Number: colors.NUMBER_COLOR,
|
|
Boolean: colors.BOOLEAN_COLOR,
|
|
Null: colors.NULL_COLOR,
|
|
Undefined: colors.UNDEFINED_COLOR,
|
|
Function: colors.FUNCTION_COLOR,
|
|
Symbol: colors.SYMBOL_COLOR
|
|
});
|
|
const getDefaultThemeStyling = theme => {
|
|
const colors = colorMap(theme);
|
|
return {
|
|
tree: {
|
|
border: 0,
|
|
padding: 0,
|
|
marginTop: '0.5em',
|
|
marginBottom: '0.5em',
|
|
marginLeft: '0.125em',
|
|
marginRight: 0,
|
|
listStyle: 'none',
|
|
MozUserSelect: 'none',
|
|
WebkitUserSelect: 'none',
|
|
backgroundColor: colors.BACKGROUND_COLOR
|
|
},
|
|
value: (_ref, nodeType, keyPath) => {
|
|
let {
|
|
style
|
|
} = _ref;
|
|
return {
|
|
style: {
|
|
...style,
|
|
paddingTop: '0.25em',
|
|
paddingRight: 0,
|
|
marginLeft: '0.875em',
|
|
WebkitUserSelect: 'text',
|
|
MozUserSelect: 'text',
|
|
wordWrap: 'break-word',
|
|
paddingLeft: keyPath.length > 1 ? '2.125em' : '1.25em',
|
|
textIndent: '-0.5em',
|
|
wordBreak: 'break-all'
|
|
}
|
|
};
|
|
},
|
|
label: {
|
|
display: 'inline-block',
|
|
color: colors.LABEL_COLOR
|
|
},
|
|
valueLabel: {
|
|
margin: '0 0.5em 0 0'
|
|
},
|
|
valueText: (_ref2, nodeType) => {
|
|
let {
|
|
style
|
|
} = _ref2;
|
|
return {
|
|
style: {
|
|
...style,
|
|
color: valueColorMap(colors)[nodeType]
|
|
}
|
|
};
|
|
},
|
|
itemRange: (styling, expanded) => ({
|
|
style: {
|
|
paddingTop: expanded ? 0 : '0.25em',
|
|
cursor: 'pointer',
|
|
color: colors.LABEL_COLOR
|
|
}
|
|
}),
|
|
arrow: (_ref3, nodeType, expanded) => {
|
|
let {
|
|
style
|
|
} = _ref3;
|
|
return {
|
|
style: {
|
|
...style,
|
|
marginLeft: 0,
|
|
transition: '150ms',
|
|
WebkitTransition: '150ms',
|
|
MozTransition: '150ms',
|
|
WebkitTransform: expanded ? 'rotateZ(90deg)' : 'rotateZ(0deg)',
|
|
MozTransform: expanded ? 'rotateZ(90deg)' : 'rotateZ(0deg)',
|
|
transform: expanded ? 'rotateZ(90deg)' : 'rotateZ(0deg)',
|
|
transformOrigin: '45% 50%',
|
|
WebkitTransformOrigin: '45% 50%',
|
|
MozTransformOrigin: '45% 50%',
|
|
position: 'relative',
|
|
lineHeight: '1.1em',
|
|
fontSize: '0.75em'
|
|
}
|
|
};
|
|
},
|
|
arrowContainer: (_ref4, arrowStyle) => {
|
|
let {
|
|
style
|
|
} = _ref4;
|
|
return {
|
|
style: {
|
|
...style,
|
|
display: 'inline-block',
|
|
paddingRight: '0.5em',
|
|
paddingLeft: arrowStyle === 'double' ? '1em' : 0,
|
|
cursor: 'pointer'
|
|
}
|
|
};
|
|
},
|
|
arrowSign: {
|
|
color: colors.ARROW_COLOR
|
|
},
|
|
arrowSignInner: {
|
|
position: 'absolute',
|
|
top: 0,
|
|
left: '-0.4em'
|
|
},
|
|
nestedNode: (_ref5, keyPath, nodeType, expanded, expandable) => {
|
|
let {
|
|
style
|
|
} = _ref5;
|
|
return {
|
|
style: {
|
|
...style,
|
|
position: 'relative',
|
|
paddingTop: '0.25em',
|
|
marginLeft: keyPath.length > 1 ? '0.875em' : 0,
|
|
paddingLeft: !expandable ? '1.125em' : 0
|
|
}
|
|
};
|
|
},
|
|
rootNode: {
|
|
padding: 0,
|
|
margin: 0
|
|
},
|
|
nestedNodeLabel: (_ref6, keyPath, nodeType, expanded, expandable) => {
|
|
let {
|
|
style
|
|
} = _ref6;
|
|
return {
|
|
style: {
|
|
...style,
|
|
margin: 0,
|
|
padding: 0,
|
|
WebkitUserSelect: expandable ? 'inherit' : 'text',
|
|
MozUserSelect: expandable ? 'inherit' : 'text',
|
|
cursor: expandable ? 'pointer' : 'default'
|
|
}
|
|
};
|
|
},
|
|
nestedNodeItemString: (_ref7, keyPath, nodeType, expanded) => {
|
|
let {
|
|
style
|
|
} = _ref7;
|
|
return {
|
|
style: {
|
|
...style,
|
|
paddingLeft: '0.5em',
|
|
cursor: 'default',
|
|
color: expanded ? colors.ITEM_STRING_EXPANDED_COLOR : colors.ITEM_STRING_COLOR
|
|
}
|
|
};
|
|
},
|
|
nestedNodeItemType: {
|
|
marginLeft: '0.3em',
|
|
marginRight: '0.3em'
|
|
},
|
|
nestedNodeChildren: (_ref8, nodeType, expanded) => {
|
|
let {
|
|
style
|
|
} = _ref8;
|
|
return {
|
|
style: {
|
|
...style,
|
|
padding: 0,
|
|
margin: 0,
|
|
listStyle: 'none',
|
|
display: expanded ? 'block' : 'none'
|
|
}
|
|
};
|
|
},
|
|
rootNodeChildren: {
|
|
padding: 0,
|
|
margin: 0,
|
|
listStyle: 'none'
|
|
}
|
|
};
|
|
};
|
|
const createStylingFromTheme = createStyling(getDefaultThemeStyling, {
|
|
defaultBase16: solarized
|
|
});
|
|
/* harmony default export */ const esm_createStylingFromTheme = (createStylingFromTheme);
|
|
;// CONCATENATED MODULE: ../node_modules/react-json-tree/lib/esm/index.js
|
|
// ES6 + inline style port of JSONViewer https://bitbucket.org/davevedder/react-json-viewer/
|
|
// all credits and original code to the author
|
|
// Dave Vedder <veddermatic@gmail.com> http://www.eskimospy.com/
|
|
// port by Daniele Zannotti http://www.github.com/dzannotti <dzannotti@me.com>
|
|
|
|
|
|
|
|
|
|
|
|
const identity = value => value;
|
|
const expandRootNode = (keyPath, data, level) => level === 0;
|
|
const defaultItemString = (type, data, itemType, itemString) => /*#__PURE__*/index_js_default().createElement("span", null, itemType, " ", itemString);
|
|
const defaultLabelRenderer = _ref => {
|
|
let [label] = _ref;
|
|
return /*#__PURE__*/index_js_default().createElement("span", null, label, ":");
|
|
};
|
|
const noCustomNode = () => false;
|
|
function JSONTree(_ref2) {
|
|
let {
|
|
data: value,
|
|
theme,
|
|
invertTheme: shouldInvertTheme,
|
|
keyPath = ['root'],
|
|
labelRenderer = defaultLabelRenderer,
|
|
valueRenderer = identity,
|
|
shouldExpandNodeInitially = expandRootNode,
|
|
hideRoot = false,
|
|
getItemString = defaultItemString,
|
|
postprocessValue = identity,
|
|
isCustomNode = noCustomNode,
|
|
collectionLimit = 50,
|
|
sortObjectKeys = false
|
|
} = _ref2;
|
|
const styling = (0,index_js_.useMemo)(() => esm_createStylingFromTheme(shouldInvertTheme ? invertTheme(theme) : theme), [theme, shouldInvertTheme]);
|
|
return /*#__PURE__*/index_js_default().createElement("ul", styling('tree'), /*#__PURE__*/index_js_default().createElement(JSONNode, {
|
|
keyPath: hideRoot ? [] : keyPath,
|
|
value: postprocessValue(value),
|
|
isCustomNode: isCustomNode,
|
|
styling: styling,
|
|
labelRenderer: labelRenderer,
|
|
valueRenderer: valueRenderer,
|
|
shouldExpandNodeInitially: shouldExpandNodeInitially,
|
|
hideRoot: hideRoot,
|
|
getItemString: getItemString,
|
|
postprocessValue: postprocessValue,
|
|
collectionLimit: collectionLimit,
|
|
sortObjectKeys: sortObjectKeys
|
|
}));
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10521:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var isArrayish = __webpack_require__(31832);
|
|
|
|
var concat = Array.prototype.concat;
|
|
var slice = Array.prototype.slice;
|
|
|
|
var swizzle = module.exports = function swizzle(args) {
|
|
var results = [];
|
|
|
|
for (var i = 0, len = args.length; i < len; i++) {
|
|
var arg = args[i];
|
|
|
|
if (isArrayish(arg)) {
|
|
// http://jsperf.com/javascript-array-concat-vs-push/98
|
|
results = concat.call(results, slice.call(arg));
|
|
} else {
|
|
results.push(arg);
|
|
}
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
swizzle.wrap = function (fn) {
|
|
return function () {
|
|
return fn(swizzle(arguments));
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 31832:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = function isArrayish(obj) {
|
|
if (!obj || typeof obj === 'string') {
|
|
return false;
|
|
}
|
|
|
|
return obj instanceof Array || Array.isArray(obj) ||
|
|
(obj.length >= 0 && (obj.splice instanceof Function ||
|
|
(Object.getOwnPropertyDescriptor(obj, (obj.length - 1)) && obj.constructor.name !== 'String')));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4434:
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ V: () => (/* binding */ StyleModule)
|
|
/* harmony export */ });
|
|
const C = "\u037c"
|
|
const COUNT = typeof Symbol == "undefined" ? "__" + C : Symbol.for(C)
|
|
const SET = typeof Symbol == "undefined" ? "__styleSet" + Math.floor(Math.random() * 1e8) : Symbol("styleSet")
|
|
const top = typeof globalThis != "undefined" ? globalThis : typeof window != "undefined" ? window : {}
|
|
|
|
// :: - Style modules encapsulate a set of CSS rules defined from
|
|
// JavaScript. Their definitions are only available in a given DOM
|
|
// root after it has been _mounted_ there with `StyleModule.mount`.
|
|
//
|
|
// Style modules should be created once and stored somewhere, as
|
|
// opposed to re-creating them every time you need them. The amount of
|
|
// CSS rules generated for a given DOM root is bounded by the amount
|
|
// of style modules that were used. So to avoid leaking rules, don't
|
|
// create these dynamically, but treat them as one-time allocations.
|
|
class StyleModule {
|
|
// :: (Object<Style>, ?{finish: ?(string) → string})
|
|
// Create a style module from the given spec.
|
|
//
|
|
// When `finish` is given, it is called on regular (non-`@`)
|
|
// selectors (after `&` expansion) to compute the final selector.
|
|
constructor(spec, options) {
|
|
this.rules = []
|
|
let {finish} = options || {}
|
|
|
|
function splitSelector(selector) {
|
|
return /^@/.test(selector) ? [selector] : selector.split(/,\s*/)
|
|
}
|
|
|
|
function render(selectors, spec, target, isKeyframes) {
|
|
let local = [], isAt = /^@(\w+)\b/.exec(selectors[0]), keyframes = isAt && isAt[1] == "keyframes"
|
|
if (isAt && spec == null) return target.push(selectors[0] + ";")
|
|
for (let prop in spec) {
|
|
let value = spec[prop]
|
|
if (/&/.test(prop)) {
|
|
render(prop.split(/,\s*/).map(part => selectors.map(sel => part.replace(/&/, sel))).reduce((a, b) => a.concat(b)),
|
|
value, target)
|
|
} else if (value && typeof value == "object") {
|
|
if (!isAt) throw new RangeError("The value of a property (" + prop + ") should be a primitive value.")
|
|
render(splitSelector(prop), value, local, keyframes)
|
|
} else if (value != null) {
|
|
local.push(prop.replace(/_.*/, "").replace(/[A-Z]/g, l => "-" + l.toLowerCase()) + ": " + value + ";")
|
|
}
|
|
}
|
|
if (local.length || keyframes) {
|
|
target.push((finish && !isAt && !isKeyframes ? selectors.map(finish) : selectors).join(", ") +
|
|
" {" + local.join(" ") + "}")
|
|
}
|
|
}
|
|
|
|
for (let prop in spec) render(splitSelector(prop), spec[prop], this.rules)
|
|
}
|
|
|
|
// :: () → string
|
|
// Returns a string containing the module's CSS rules.
|
|
getRules() { return this.rules.join("\n") }
|
|
|
|
// :: () → string
|
|
// Generate a new unique CSS class name.
|
|
static newName() {
|
|
let id = top[COUNT] || 1
|
|
top[COUNT] = id + 1
|
|
return C + id.toString(36)
|
|
}
|
|
|
|
// :: (union<Document, ShadowRoot>, union<[StyleModule], StyleModule>, ?{nonce: ?string})
|
|
//
|
|
// Mount the given set of modules in the given DOM root, which ensures
|
|
// that the CSS rules defined by the module are available in that
|
|
// context.
|
|
//
|
|
// Rules are only added to the document once per root.
|
|
//
|
|
// Rule order will follow the order of the modules, so that rules from
|
|
// modules later in the array take precedence of those from earlier
|
|
// modules. If you call this function multiple times for the same root
|
|
// in a way that changes the order of already mounted modules, the old
|
|
// order will be changed.
|
|
//
|
|
// If a Content Security Policy nonce is provided, it is added to
|
|
// the `<style>` tag generated by the library.
|
|
static mount(root, modules, options) {
|
|
let set = root[SET], nonce = options && options.nonce
|
|
if (!set) set = new StyleSet(root, nonce)
|
|
else if (nonce) set.setNonce(nonce)
|
|
set.mount(Array.isArray(modules) ? modules : [modules])
|
|
}
|
|
}
|
|
|
|
let adoptedSet = new Map //<Document, StyleSet>
|
|
|
|
class StyleSet {
|
|
constructor(root, nonce) {
|
|
let doc = root.ownerDocument || root, win = doc.defaultView
|
|
if (!root.head && root.adoptedStyleSheets && win.CSSStyleSheet) {
|
|
let adopted = adoptedSet.get(doc)
|
|
if (adopted) {
|
|
root.adoptedStyleSheets = [adopted.sheet, ...root.adoptedStyleSheets]
|
|
return root[SET] = adopted
|
|
}
|
|
this.sheet = new win.CSSStyleSheet
|
|
root.adoptedStyleSheets = [this.sheet, ...root.adoptedStyleSheets]
|
|
adoptedSet.set(doc, this)
|
|
} else {
|
|
this.styleTag = doc.createElement("style")
|
|
if (nonce) this.styleTag.setAttribute("nonce", nonce)
|
|
let target = root.head || root
|
|
target.insertBefore(this.styleTag, target.firstChild)
|
|
}
|
|
this.modules = []
|
|
root[SET] = this
|
|
}
|
|
|
|
mount(modules) {
|
|
let sheet = this.sheet
|
|
let pos = 0 /* Current rule offset */, j = 0 /* Index into this.modules */
|
|
for (let i = 0; i < modules.length; i++) {
|
|
let mod = modules[i], index = this.modules.indexOf(mod)
|
|
if (index < j && index > -1) { // Ordering conflict
|
|
this.modules.splice(index, 1)
|
|
j--
|
|
index = -1
|
|
}
|
|
if (index == -1) {
|
|
this.modules.splice(j++, 0, mod)
|
|
if (sheet) for (let k = 0; k < mod.rules.length; k++)
|
|
sheet.insertRule(mod.rules[k], pos++)
|
|
} else {
|
|
while (j < index) pos += this.modules[j++].rules.length
|
|
pos += mod.rules.length
|
|
j++
|
|
}
|
|
}
|
|
|
|
if (!sheet) {
|
|
let text = ""
|
|
for (let i = 0; i < this.modules.length; i++)
|
|
text += this.modules[i].getRules() + "\n"
|
|
this.styleTag.textContent = text
|
|
}
|
|
}
|
|
|
|
setNonce(nonce) {
|
|
if (this.styleTag && this.styleTag.getAttribute("nonce") != nonce)
|
|
this.styleTag.setAttribute("nonce", nonce)
|
|
}
|
|
}
|
|
|
|
// Style::Object<union<Style,string>>
|
|
//
|
|
// A style is an object that, in the simple case, maps CSS property
|
|
// names to strings holding their values, as in `{color: "red",
|
|
// fontWeight: "bold"}`. The property names can be given in
|
|
// camel-case—the library will insert a dash before capital letters
|
|
// when converting them to CSS.
|
|
//
|
|
// If you include an underscore in a property name, it and everything
|
|
// after it will be removed from the output, which can be useful when
|
|
// providing a property multiple times, for browser compatibility
|
|
// reasons.
|
|
//
|
|
// A property in a style object can also be a sub-selector, which
|
|
// extends the current context to add a pseudo-selector or a child
|
|
// selector. Such a property should contain a `&` character, which
|
|
// will be replaced by the current selector. For example `{"&:before":
|
|
// {content: '"hi"'}}`. Sub-selectors and regular properties can
|
|
// freely be mixed in a given object. Any property containing a `&` is
|
|
// assumed to be a sub-selector.
|
|
//
|
|
// Finally, a property can specify an @-block to be wrapped around the
|
|
// styles defined inside the object that's the property's value. For
|
|
// example to create a media query you can do `{"@media screen and
|
|
// (min-width: 400px)": {...}}`.
|
|
|
|
|
|
/***/ })
|
|
|
|
}]);
|
|
//# sourceMappingURL=9619.72d0af35a1e6e3c624d7.js.map?v=72d0af35a1e6e3c624d7
|