diff --git a/client/src/components/course/course-card-item.tsx b/client/src/components/course/course-card-item.tsx index 1f5ab1f..3c225d3 100644 --- a/client/src/components/course/course-card-item.tsx +++ b/client/src/components/course/course-card-item.tsx @@ -18,12 +18,13 @@ const CourseCardItem: FC = ({ item }) => { sx={{ px: 1, py: 4, + }} > theme.transitions.create(['box-shadow']), '&:hover': { @@ -34,6 +35,9 @@ const CourseCardItem: FC = ({ item }) => { boxShadow: 2, }, }, + backgroundColor:'var(--color-background)', + color: 'var(--color-text)', + // transition: 'background-color 0.3s, color 0.3s', }} > { return ( diff --git a/client/src/components/header/header.tsx b/client/src/components/header/header.tsx index 24f9c98..0e98edd 100644 --- a/client/src/components/header/header.tsx +++ b/client/src/components/header/header.tsx @@ -16,7 +16,13 @@ const Header: FC = () => { setVisibleMenu(visibleMenu => !visibleMenu); }; return ( - + diff --git a/client/src/components/home/feature.tsx b/client/src/components/home/feature.tsx index 0a7b230..d18d5d7 100644 --- a/client/src/components/home/feature.tsx +++ b/client/src/components/home/feature.tsx @@ -37,7 +37,13 @@ const BorderLinearProgress = styled(LinearProgress, { const HomeFeature: FC = () => { return ( - + diff --git a/client/src/components/home/hero.tsx b/client/src/components/home/hero.tsx index 91d535a..e3334c5 100644 --- a/client/src/components/home/hero.tsx +++ b/client/src/components/home/hero.tsx @@ -49,7 +49,12 @@ const ExpItem: FC = ({ item }) => { const HomeHero: FC = () => { return ( - + diff --git a/client/src/components/home/mentors.tsx b/client/src/components/home/mentors.tsx index 8f98328..efe2947 100644 --- a/client/src/components/home/mentors.tsx +++ b/client/src/components/home/mentors.tsx @@ -87,7 +87,10 @@ const HomeOurMentors: FC = () => { xs: 8, md: 12, }, - backgroundColor: '#ecf3f3', + // backgroundColor: '#ecf3f3', + backgroundColor:'var(--color-background-paper)', + color: 'var(--color-text)', + transition: 'background-color 0.3s, color 0.3s', }} > diff --git a/client/src/components/home/newsletter.tsx b/client/src/components/home/newsletter.tsx index bd9468b..d7595d8 100644 --- a/client/src/components/home/newsletter.tsx +++ b/client/src/components/home/newsletter.tsx @@ -7,7 +7,12 @@ import { StyledButton } from '../styled-button' const HomeNewsLetter: FC = () => { return ( - + { md: 8, }, pb: 14, - backgroundColor: 'background.default', + // backgroundColor: 'background.default', + backgroundColor:'var(--color-background-paper)', + color: 'var(--color-text)', + transition: 'background-color 0.3s, color 0.3s', }} > diff --git a/client/src/components/home/testimonial.tsx b/client/src/components/home/testimonial.tsx index 3f5a22b..73a95e0 100644 --- a/client/src/components/home/testimonial.tsx +++ b/client/src/components/home/testimonial.tsx @@ -63,7 +63,12 @@ const HomeTestimonial: FC = () => { } return ( - + diff --git a/client/src/components/logo/logo.tsx b/client/src/components/logo/logo.tsx index 4e46318..c5ed3c7 100644 --- a/client/src/components/logo/logo.tsx +++ b/client/src/components/logo/logo.tsx @@ -1,4 +1,5 @@ import React, { FC } from 'react' +import Link from 'next/link' import { Box, Typography } from '@mui/material' interface Props { @@ -8,15 +9,19 @@ interface Props { const Logo: FC = ({ onClick, variant }) => { return ( - - - BigOhhh - - + + + + BigOhhh + + + ) } diff --git a/client/src/components/mentor/mentor-card-item.tsx b/client/src/components/mentor/mentor-card-item.tsx index b31e659..b97a233 100644 --- a/client/src/components/mentor/mentor-card-item.tsx +++ b/client/src/components/mentor/mentor-card-item.tsx @@ -21,7 +21,16 @@ const MentorCardItem: FC = ({ item }) => { my:2, borderRadius: 8, boxShadow: 6, - backgroundColor: 'white', + // backgroundColor: 'white', + // transition: 'transform 0.3s, box-shadow 0.3s', + '&:hover': { + transform: 'scale(1.05)', + boxShadow: 4, + }, + + backgroundColor:'var(--color-background)', + color: 'var(--color-text)', + transition: 'background-color 0.3s, color 0.3s', }} > void; // Function to toggle the visibility of the navigation box } const Navigation: FC = ({toggleMenu}) => { + + const [isDayMode, setIsDayMode] = useState(true); + + const handleToggleMode = () => { + setIsDayMode((prevMode) => !prevMode); + }; + + useEffect(() => { + if (isDayMode) { + document.body.classList.remove('night-mode'); + } else { + document.body.classList.add('night-mode'); + } + }, [isDayMode]); + return ( - + + {navigations.map(({ path: destination, label }) => ( = ({toggleMenu}) => { duration={350} sx={{ position: 'relative', - color: 'text.disabled', + color: 'inherit', cursor: 'pointer', fontWeight: 600, display: 'inline-flex', @@ -30,7 +55,7 @@ const Navigation: FC = ({toggleMenu}) => { mb: { xs: 3, md: 0 }, fontSize: { xs: '1.2rem', md: 'inherit' }, ...(destination === '/' && { - color: 'primary.main', + color: isDayMode ? 'primary.main' : 'primary.light', // Adjust color for active link based on mode, }), '& > div': { display: 'none' }, @@ -60,6 +85,9 @@ const Navigation: FC = ({toggleMenu}) => { {label} ))} + + {isDayMode ? : } + ) } diff --git a/client/src/pages/_app.tsx b/client/src/pages/_app.tsx index afc783a..0a73c70 100644 --- a/client/src/pages/_app.tsx +++ b/client/src/pages/_app.tsx @@ -11,6 +11,8 @@ import '@/styles/globals.css' import '@/styles/react-slick.css' import { NextPageWithLayout } from '@/interfaces/layout' import Script from 'next/script' + +import '../styles/globals.css' // import 'slick-carousel/slick/slick-theme.css' // Client-side cache, shared for the whole session of the user in the browser. diff --git a/client/src/styles/globals.css b/client/src/styles/globals.css index b73f1c9..d045b42 100644 --- a/client/src/styles/globals.css +++ b/client/src/styles/globals.css @@ -1,7 +1,30 @@ +/* styles/globals.css */ :root { - --color-background: #f5f5f9; + --color-background: #ffffff; + --color-text: #000000; --color-scrollbar: rgb(224, 224, 224); --color-scrollbar-hover: #bbb; + --color-icon: #ffcc00; + + --color-background-paper:#f5f5f9; + --color-background-footer: +} + +body { + background-color: var(--color-background); + color: var(--color-text); + transition: background-color 0.3s, color 0.3s; +} + +/* Night mode */ +body.night-mode { + --color-background: #000000; + --color-text: #ffffff; + --color-scrollbar: #333; + --color-scrollbar-hover: #666; + --color-icon: #ffffff; + + --color-background-paper:#a0a0a0; } ::-webkit-scrollbar { @@ -23,10 +46,11 @@ border-radius: 10px; } -body { - /* background-color: var(--color-background); */ +/* body { + background-color: var(--color-background); background-color: '#fff'; -} +} */ + html { scroll-behavior: smooth; } diff --git a/node_modules/.bin/loose-envify b/node_modules/.bin/loose-envify new file mode 100644 index 0000000..60598cb --- /dev/null +++ b/node_modules/.bin/loose-envify @@ -0,0 +1,12 @@ +#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") + +case `uname` in + *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;; +esac + +if [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir/../loose-envify/cli.js" "$@" +else + exec node "$basedir/../loose-envify/cli.js" "$@" +fi diff --git a/node_modules/.bin/loose-envify.cmd b/node_modules/.bin/loose-envify.cmd new file mode 100644 index 0000000..599576f --- /dev/null +++ b/node_modules/.bin/loose-envify.cmd @@ -0,0 +1,17 @@ +@ECHO off +GOTO start +:find_dp0 +SET dp0=%~dp0 +EXIT /b +:start +SETLOCAL +CALL :find_dp0 + +IF EXIST "%dp0%\node.exe" ( + SET "_prog=%dp0%\node.exe" +) ELSE ( + SET "_prog=node" + SET PATHEXT=%PATHEXT:;.JS;=;% +) + +endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\loose-envify\cli.js" %* diff --git a/node_modules/.bin/loose-envify.ps1 b/node_modules/.bin/loose-envify.ps1 new file mode 100644 index 0000000..eb866fc --- /dev/null +++ b/node_modules/.bin/loose-envify.ps1 @@ -0,0 +1,28 @@ +#!/usr/bin/env pwsh +$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent + +$exe="" +if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { + # Fix case when both the Windows and Linux builds of Node + # are installed in the same directory + $exe=".exe" +} +$ret=0 +if (Test-Path "$basedir/node$exe") { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "$basedir/node$exe" "$basedir/../loose-envify/cli.js" $args + } else { + & "$basedir/node$exe" "$basedir/../loose-envify/cli.js" $args + } + $ret=$LASTEXITCODE +} else { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "node$exe" "$basedir/../loose-envify/cli.js" $args + } else { + & "node$exe" "$basedir/../loose-envify/cli.js" $args + } + $ret=$LASTEXITCODE +} +exit $ret diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json new file mode 100644 index 0000000..aae95a1 --- /dev/null +++ b/node_modules/.package-lock.json @@ -0,0 +1,69 @@ +{ + "name": "bigohhh.com", + "lockfileVersion": 3, + "requires": true, + "packages": { + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/react": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz", + "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==", + "peer": true, + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-feather": { + "version": "2.0.10", + "resolved": "https://registry.npmjs.org/react-feather/-/react-feather-2.0.10.tgz", + "integrity": "sha512-BLhukwJ+Z92Nmdcs+EMw6dy1Z/VLiJTzEQACDUEnWMClhYnFykJCGWQx+NmwP/qQHGX/5CzQ+TGi8ofg2+HzVQ==", + "dependencies": { + "prop-types": "^15.7.2" + }, + "peerDependencies": { + "react": ">=16.8.6" + } + }, + "node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==" + } + } +} diff --git a/node_modules/js-tokens/CHANGELOG.md b/node_modules/js-tokens/CHANGELOG.md new file mode 100644 index 0000000..755e6f6 --- /dev/null +++ b/node_modules/js-tokens/CHANGELOG.md @@ -0,0 +1,151 @@ +### Version 4.0.0 (2018-01-28) ### + +- Added: Support for ES2018. The only change needed was recognizing the `s` + regex flag. +- Changed: _All_ tokens returned by the `matchToToken` function now have a + `closed` property. It is set to `undefined` for the tokens where “closed” + doesn’t make sense. This means that all tokens objects have the same shape, + which might improve performance. + +These are the breaking changes: + +- `'/a/s'.match(jsTokens)` no longer returns `['/', 'a', '/', 's']`, but + `['/a/s']`. (There are of course other variations of this.) +- Code that rely on some token objects not having the `closed` property could + now behave differently. + + +### Version 3.0.2 (2017-06-28) ### + +- No code changes. Just updates to the readme. + + +### Version 3.0.1 (2017-01-30) ### + +- Fixed: ES2015 unicode escapes with more than 6 hex digits are now matched + correctly. + + +### Version 3.0.0 (2017-01-11) ### + +This release contains one breaking change, that should [improve performance in +V8][v8-perf]: + +> So how can you, as a JavaScript developer, ensure that your RegExps are fast? +> If you are not interested in hooking into RegExp internals, make sure that +> neither the RegExp instance, nor its prototype is modified in order to get the +> best performance: +> +> ```js +> var re = /./g; +> re.exec(''); // Fast path. +> re.new_property = 'slow'; +> ``` + +This module used to export a single regex, with `.matchToToken` bolted +on, just like in the above example. This release changes the exports of +the module to avoid this issue. + +Before: + +```js +import jsTokens from "js-tokens" +// or: +var jsTokens = require("js-tokens") +var matchToToken = jsTokens.matchToToken +``` + +After: + +```js +import jsTokens, {matchToToken} from "js-tokens" +// or: +var jsTokens = require("js-tokens").default +var matchToToken = require("js-tokens").matchToToken +``` + +[v8-perf]: http://v8project.blogspot.se/2017/01/speeding-up-v8-regular-expressions.html + + +### Version 2.0.0 (2016-06-19) ### + +- Added: Support for ES2016. In other words, support for the `**` exponentiation + operator. + +These are the breaking changes: + +- `'**'.match(jsTokens)` no longer returns `['*', '*']`, but `['**']`. +- `'**='.match(jsTokens)` no longer returns `['*', '*=']`, but `['**=']`. + + +### Version 1.0.3 (2016-03-27) ### + +- Improved: Made the regex ever so slightly smaller. +- Updated: The readme. + + +### Version 1.0.2 (2015-10-18) ### + +- Improved: Limited npm package contents for a smaller download. Thanks to + @zertosh! + + +### Version 1.0.1 (2015-06-20) ### + +- Fixed: Declared an undeclared variable. + + +### Version 1.0.0 (2015-02-26) ### + +- Changed: Merged the 'operator' and 'punctuation' types into 'punctuator'. That + type is now equivalent to the Punctuator token in the ECMAScript + specification. (Backwards-incompatible change.) +- Fixed: A `-` followed by a number is now correctly matched as a punctuator + followed by a number. It used to be matched as just a number, but there is no + such thing as negative number literals. (Possibly backwards-incompatible + change.) + + +### Version 0.4.1 (2015-02-21) ### + +- Added: Support for the regex `u` flag. + + +### Version 0.4.0 (2015-02-21) ### + +- Improved: `jsTokens.matchToToken` performance. +- Added: Support for octal and binary number literals. +- Added: Support for template strings. + + +### Version 0.3.1 (2015-01-06) ### + +- Fixed: Support for unicode spaces. They used to be allowed in names (which is + very confusing), and some unicode newlines were wrongly allowed in strings and + regexes. + + +### Version 0.3.0 (2014-12-19) ### + +- Changed: The `jsTokens.names` array has been replaced with the + `jsTokens.matchToToken` function. The capturing groups of `jsTokens` are no + longer part of the public API; instead use said function. See this [gist] for + an example. (Backwards-incompatible change.) +- Changed: The empty string is now considered an “invalid” token, instead an + “empty” token (its own group). (Backwards-incompatible change.) +- Removed: component support. (Backwards-incompatible change.) + +[gist]: https://gist.github.com/lydell/be49dbf80c382c473004 + + +### Version 0.2.0 (2014-06-19) ### + +- Changed: Match ES6 function arrows (`=>`) as an operator, instead of its own + category (“functionArrow”), for simplicity. (Backwards-incompatible change.) +- Added: ES6 splats (`...`) are now matched as an operator (instead of three + punctuations). (Backwards-incompatible change.) + + +### Version 0.1.0 (2014-03-08) ### + +- Initial release. diff --git a/node_modules/js-tokens/LICENSE b/node_modules/js-tokens/LICENSE new file mode 100644 index 0000000..54aef52 --- /dev/null +++ b/node_modules/js-tokens/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014, 2015, 2016, 2017, 2018 Simon Lydell + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/js-tokens/README.md b/node_modules/js-tokens/README.md new file mode 100644 index 0000000..00cdf16 --- /dev/null +++ b/node_modules/js-tokens/README.md @@ -0,0 +1,240 @@ +Overview [![Build Status](https://travis-ci.org/lydell/js-tokens.svg?branch=master)](https://travis-ci.org/lydell/js-tokens) +======== + +A regex that tokenizes JavaScript. + +```js +var jsTokens = require("js-tokens").default + +var jsString = "var foo=opts.foo;\n..." + +jsString.match(jsTokens) +// ["var", " ", "foo", "=", "opts", ".", "foo", ";", "\n", ...] +``` + + +Installation +============ + +`npm install js-tokens` + +```js +import jsTokens from "js-tokens" +// or: +var jsTokens = require("js-tokens").default +``` + + +Usage +===== + +### `jsTokens` ### + +A regex with the `g` flag that matches JavaScript tokens. + +The regex _always_ matches, even invalid JavaScript and the empty string. + +The next match is always directly after the previous. + +### `var token = matchToToken(match)` ### + +```js +import {matchToToken} from "js-tokens" +// or: +var matchToToken = require("js-tokens").matchToToken +``` + +Takes a `match` returned by `jsTokens.exec(string)`, and returns a `{type: +String, value: String}` object. The following types are available: + +- string +- comment +- regex +- number +- name +- punctuator +- whitespace +- invalid + +Multi-line comments and strings also have a `closed` property indicating if the +token was closed or not (see below). + +Comments and strings both come in several flavors. To distinguish them, check if +the token starts with `//`, `/*`, `'`, `"` or `` ` ``. + +Names are ECMAScript IdentifierNames, that is, including both identifiers and +keywords. You may use [is-keyword-js] to tell them apart. + +Whitespace includes both line terminators and other whitespace. + +[is-keyword-js]: https://github.com/crissdev/is-keyword-js + + +ECMAScript support +================== + +The intention is to always support the latest ECMAScript version whose feature +set has been finalized. + +If adding support for a newer version requires changes, a new version with a +major verion bump will be released. + +Currently, ECMAScript 2018 is supported. + + +Invalid code handling +===================== + +Unterminated strings are still matched as strings. JavaScript strings cannot +contain (unescaped) newlines, so unterminated strings simply end at the end of +the line. Unterminated template strings can contain unescaped newlines, though, +so they go on to the end of input. + +Unterminated multi-line comments are also still matched as comments. They +simply go on to the end of the input. + +Unterminated regex literals are likely matched as division and whatever is +inside the regex. + +Invalid ASCII characters have their own capturing group. + +Invalid non-ASCII characters are treated as names, to simplify the matching of +names (except unicode spaces which are treated as whitespace). Note: See also +the [ES2018](#es2018) section. + +Regex literals may contain invalid regex syntax. They are still matched as +regex literals. They may also contain repeated regex flags, to keep the regex +simple. + +Strings may contain invalid escape sequences. + + +Limitations +=========== + +Tokenizing JavaScript using regexes—in fact, _one single regex_—won’t be +perfect. But that’s not the point either. + +You may compare jsTokens with [esprima] by using `esprima-compare.js`. +See `npm run esprima-compare`! + +[esprima]: http://esprima.org/ + +### Template string interpolation ### + +Template strings are matched as single tokens, from the starting `` ` `` to the +ending `` ` ``, including interpolations (whose tokens are not matched +individually). + +Matching template string interpolations requires recursive balancing of `{` and +`}`—something that JavaScript regexes cannot do. Only one level of nesting is +supported. + +### Division and regex literals collision ### + +Consider this example: + +```js +var g = 9.82 +var number = bar / 2/g + +var regex = / 2/g +``` + +A human can easily understand that in the `number` line we’re dealing with +division, and in the `regex` line we’re dealing with a regex literal. How come? +Because humans can look at the whole code to put the `/` characters in context. +A JavaScript regex cannot. It only sees forwards. (Well, ES2018 regexes can also +look backwards. See the [ES2018](#es2018) section). + +When the `jsTokens` regex scans throught the above, it will see the following +at the end of both the `number` and `regex` rows: + +```js +/ 2/g +``` + +It is then impossible to know if that is a regex literal, or part of an +expression dealing with division. + +Here is a similar case: + +```js +foo /= 2/g +foo(/= 2/g) +``` + +The first line divides the `foo` variable with `2/g`. The second line calls the +`foo` function with the regex literal `/= 2/g`. Again, since `jsTokens` only +sees forwards, it cannot tell the two cases apart. + +There are some cases where we _can_ tell division and regex literals apart, +though. + +First off, we have the simple cases where there’s only one slash in the line: + +```js +var foo = 2/g +foo /= 2 +``` + +Regex literals cannot contain newlines, so the above cases are correctly +identified as division. Things are only problematic when there are more than +one non-comment slash in a single line. + +Secondly, not every character is a valid regex flag. + +```js +var number = bar / 2/e +``` + +The above example is also correctly identified as division, because `e` is not a +valid regex flag. I initially wanted to future-proof by allowing `[a-zA-Z]*` +(any letter) as flags, but it is not worth it since it increases the amount of +ambigous cases. So only the standard `g`, `m`, `i`, `y` and `u` flags are +allowed. This means that the above example will be identified as division as +long as you don’t rename the `e` variable to some permutation of `gmiyus` 1 to 6 +characters long. + +Lastly, we can look _forward_ for information. + +- If the token following what looks like a regex literal is not valid after a + regex literal, but is valid in a division expression, then the regex literal + is treated as division instead. For example, a flagless regex cannot be + followed by a string, number or name, but all of those three can be the + denominator of a division. +- Generally, if what looks like a regex literal is followed by an operator, the + regex literal is treated as division instead. This is because regexes are + seldomly used with operators (such as `+`, `*`, `&&` and `==`), but division + could likely be part of such an expression. + +Please consult the regex source and the test cases for precise information on +when regex or division is matched (should you need to know). In short, you +could sum it up as: + +If the end of a statement looks like a regex literal (even if it isn’t), it +will be treated as one. Otherwise it should work as expected (if you write sane +code). + +### ES2018 ### + +ES2018 added some nice regex improvements to the language. + +- [Unicode property escapes] should allow telling names and invalid non-ASCII + characters apart without blowing up the regex size. +- [Lookbehind assertions] should allow matching telling division and regex + literals apart in more cases. +- [Named capture groups] might simplify some things. + +These things would be nice to do, but are not critical. They probably have to +wait until the oldest maintained Node.js LTS release supports those features. + +[Unicode property escapes]: http://2ality.com/2017/07/regexp-unicode-property-escapes.html +[Lookbehind assertions]: http://2ality.com/2017/05/regexp-lookbehind-assertions.html +[Named capture groups]: http://2ality.com/2017/05/regexp-named-capture-groups.html + + +License +======= + +[MIT](LICENSE). diff --git a/node_modules/js-tokens/index.js b/node_modules/js-tokens/index.js new file mode 100644 index 0000000..b23a4a0 --- /dev/null +++ b/node_modules/js-tokens/index.js @@ -0,0 +1,23 @@ +// Copyright 2014, 2015, 2016, 2017, 2018 Simon Lydell +// License: MIT. (See LICENSE.) + +Object.defineProperty(exports, "__esModule", { + value: true +}) + +// This regex comes from regex.coffee, and is inserted here by generate-index.js +// (run `npm run build`). +exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g + +exports.matchToToken = function(match) { + var token = {type: "invalid", value: match[0], closed: undefined} + if (match[ 1]) token.type = "string" , token.closed = !!(match[3] || match[4]) + else if (match[ 5]) token.type = "comment" + else if (match[ 6]) token.type = "comment", token.closed = !!match[7] + else if (match[ 8]) token.type = "regex" + else if (match[ 9]) token.type = "number" + else if (match[10]) token.type = "name" + else if (match[11]) token.type = "punctuator" + else if (match[12]) token.type = "whitespace" + return token +} diff --git a/node_modules/js-tokens/package.json b/node_modules/js-tokens/package.json new file mode 100644 index 0000000..66752fa --- /dev/null +++ b/node_modules/js-tokens/package.json @@ -0,0 +1,30 @@ +{ + "name": "js-tokens", + "version": "4.0.0", + "author": "Simon Lydell", + "license": "MIT", + "description": "A regex that tokenizes JavaScript.", + "keywords": [ + "JavaScript", + "js", + "token", + "tokenize", + "regex" + ], + "files": [ + "index.js" + ], + "repository": "lydell/js-tokens", + "scripts": { + "test": "mocha --ui tdd", + "esprima-compare": "node esprima-compare ./index.js everything.js/es5.js", + "build": "node generate-index.js", + "dev": "npm run build && npm test" + }, + "devDependencies": { + "coffeescript": "2.1.1", + "esprima": "4.0.0", + "everything.js": "1.0.3", + "mocha": "5.0.0" + } +} diff --git a/node_modules/loose-envify/LICENSE b/node_modules/loose-envify/LICENSE new file mode 100644 index 0000000..fbafb48 --- /dev/null +++ b/node_modules/loose-envify/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 Andres Suarez + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/loose-envify/README.md b/node_modules/loose-envify/README.md new file mode 100644 index 0000000..7f4e07b --- /dev/null +++ b/node_modules/loose-envify/README.md @@ -0,0 +1,45 @@ +# loose-envify + +[![Build Status](https://travis-ci.org/zertosh/loose-envify.svg?branch=master)](https://travis-ci.org/zertosh/loose-envify) + +Fast (and loose) selective `process.env` replacer using [js-tokens](https://github.com/lydell/js-tokens) instead of an AST. Works just like [envify](https://github.com/hughsk/envify) but much faster. + +## Gotchas + +* Doesn't handle broken syntax. +* Doesn't look inside embedded expressions in template strings. + - **this won't work:** + ```js + console.log(`the current env is ${process.env.NODE_ENV}`); + ``` +* Doesn't replace oddly-spaced or oddly-commented expressions. + - **this won't work:** + ```js + console.log(process./*won't*/env./*work*/NODE_ENV); + ``` + +## Usage/Options + +loose-envify has the exact same interface as [envify](https://github.com/hughsk/envify), including the CLI. + +## Benchmark + +``` +envify: + + $ for i in {1..5}; do node bench/bench.js 'envify'; done + 708ms + 727ms + 791ms + 719ms + 720ms + +loose-envify: + + $ for i in {1..5}; do node bench/bench.js '../'; done + 51ms + 52ms + 52ms + 52ms + 52ms +``` diff --git a/node_modules/loose-envify/cli.js b/node_modules/loose-envify/cli.js new file mode 100644 index 0000000..c0b63cb --- /dev/null +++ b/node_modules/loose-envify/cli.js @@ -0,0 +1,16 @@ +#!/usr/bin/env node +'use strict'; + +var looseEnvify = require('./'); +var fs = require('fs'); + +if (process.argv[2]) { + fs.createReadStream(process.argv[2], {encoding: 'utf8'}) + .pipe(looseEnvify(process.argv[2])) + .pipe(process.stdout); +} else { + process.stdin.resume() + process.stdin + .pipe(looseEnvify(__filename)) + .pipe(process.stdout); +} diff --git a/node_modules/loose-envify/custom.js b/node_modules/loose-envify/custom.js new file mode 100644 index 0000000..6389bfa --- /dev/null +++ b/node_modules/loose-envify/custom.js @@ -0,0 +1,4 @@ +// envify compatibility +'use strict'; + +module.exports = require('./loose-envify'); diff --git a/node_modules/loose-envify/index.js b/node_modules/loose-envify/index.js new file mode 100644 index 0000000..8cd8305 --- /dev/null +++ b/node_modules/loose-envify/index.js @@ -0,0 +1,3 @@ +'use strict'; + +module.exports = require('./loose-envify')(process.env); diff --git a/node_modules/loose-envify/loose-envify.js b/node_modules/loose-envify/loose-envify.js new file mode 100644 index 0000000..b5a5be2 --- /dev/null +++ b/node_modules/loose-envify/loose-envify.js @@ -0,0 +1,36 @@ +'use strict'; + +var stream = require('stream'); +var util = require('util'); +var replace = require('./replace'); + +var jsonExtRe = /\.json$/; + +module.exports = function(rootEnv) { + rootEnv = rootEnv || process.env; + return function (file, trOpts) { + if (jsonExtRe.test(file)) { + return stream.PassThrough(); + } + var envs = trOpts ? [rootEnv, trOpts] : [rootEnv]; + return new LooseEnvify(envs); + }; +}; + +function LooseEnvify(envs) { + stream.Transform.call(this); + this._data = ''; + this._envs = envs; +} +util.inherits(LooseEnvify, stream.Transform); + +LooseEnvify.prototype._transform = function(buf, enc, cb) { + this._data += buf; + cb(); +}; + +LooseEnvify.prototype._flush = function(cb) { + var replaced = replace(this._data, this._envs); + this.push(replaced); + cb(); +}; diff --git a/node_modules/loose-envify/package.json b/node_modules/loose-envify/package.json new file mode 100644 index 0000000..5e3d0e2 --- /dev/null +++ b/node_modules/loose-envify/package.json @@ -0,0 +1,36 @@ +{ + "name": "loose-envify", + "version": "1.4.0", + "description": "Fast (and loose) selective `process.env` replacer using js-tokens instead of an AST", + "keywords": [ + "environment", + "variables", + "browserify", + "browserify-transform", + "transform", + "source", + "configuration" + ], + "homepage": "https://github.com/zertosh/loose-envify", + "license": "MIT", + "author": "Andres Suarez ", + "main": "index.js", + "bin": { + "loose-envify": "cli.js" + }, + "repository": { + "type": "git", + "url": "git://github.com/zertosh/loose-envify.git" + }, + "scripts": { + "test": "tap test/*.js" + }, + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "devDependencies": { + "browserify": "^13.1.1", + "envify": "^3.4.0", + "tap": "^8.0.0" + } +} diff --git a/node_modules/loose-envify/replace.js b/node_modules/loose-envify/replace.js new file mode 100644 index 0000000..ec15e81 --- /dev/null +++ b/node_modules/loose-envify/replace.js @@ -0,0 +1,65 @@ +'use strict'; + +var jsTokens = require('js-tokens').default; + +var processEnvRe = /\bprocess\.env\.[_$a-zA-Z][$\w]+\b/; +var spaceOrCommentRe = /^(?:\s|\/[/*])/; + +function replace(src, envs) { + if (!processEnvRe.test(src)) { + return src; + } + + var out = []; + var purge = envs.some(function(env) { + return env._ && env._.indexOf('purge') !== -1; + }); + + jsTokens.lastIndex = 0 + var parts = src.match(jsTokens); + + for (var i = 0; i < parts.length; i++) { + if (parts[i ] === 'process' && + parts[i + 1] === '.' && + parts[i + 2] === 'env' && + parts[i + 3] === '.') { + var prevCodeToken = getAdjacentCodeToken(-1, parts, i); + var nextCodeToken = getAdjacentCodeToken(1, parts, i + 4); + var replacement = getReplacementString(envs, parts[i + 4], purge); + if (prevCodeToken !== '.' && + nextCodeToken !== '.' && + nextCodeToken !== '=' && + typeof replacement === 'string') { + out.push(replacement); + i += 4; + continue; + } + } + out.push(parts[i]); + } + + return out.join(''); +} + +function getAdjacentCodeToken(dir, parts, i) { + while (true) { + var part = parts[i += dir]; + if (!spaceOrCommentRe.test(part)) { + return part; + } + } +} + +function getReplacementString(envs, name, purge) { + for (var j = 0; j < envs.length; j++) { + var env = envs[j]; + if (typeof env[name] !== 'undefined') { + return JSON.stringify(env[name]); + } + } + if (purge) { + return 'undefined'; + } +} + +module.exports = replace; diff --git a/node_modules/object-assign/index.js b/node_modules/object-assign/index.js new file mode 100644 index 0000000..0930cf8 --- /dev/null +++ b/node_modules/object-assign/index.js @@ -0,0 +1,90 @@ +/* +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; +}; diff --git a/node_modules/object-assign/license b/node_modules/object-assign/license new file mode 100644 index 0000000..654d0bf --- /dev/null +++ b/node_modules/object-assign/license @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) Sindre Sorhus (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/object-assign/package.json b/node_modules/object-assign/package.json new file mode 100644 index 0000000..503eb1e --- /dev/null +++ b/node_modules/object-assign/package.json @@ -0,0 +1,42 @@ +{ + "name": "object-assign", + "version": "4.1.1", + "description": "ES2015 `Object.assign()` ponyfill", + "license": "MIT", + "repository": "sindresorhus/object-assign", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "sindresorhus.com" + }, + "engines": { + "node": ">=0.10.0" + }, + "scripts": { + "test": "xo && ava", + "bench": "matcha bench.js" + }, + "files": [ + "index.js" + ], + "keywords": [ + "object", + "assign", + "extend", + "properties", + "es2015", + "ecmascript", + "harmony", + "ponyfill", + "prollyfill", + "polyfill", + "shim", + "browser" + ], + "devDependencies": { + "ava": "^0.16.0", + "lodash": "^4.16.4", + "matcha": "^0.7.0", + "xo": "^0.16.0" + } +} diff --git a/node_modules/object-assign/readme.md b/node_modules/object-assign/readme.md new file mode 100644 index 0000000..1be09d3 --- /dev/null +++ b/node_modules/object-assign/readme.md @@ -0,0 +1,61 @@ +# object-assign [![Build Status](https://travis-ci.org/sindresorhus/object-assign.svg?branch=master)](https://travis-ci.org/sindresorhus/object-assign) + +> ES2015 [`Object.assign()`](http://www.2ality.com/2014/01/object-assign.html) [ponyfill](https://ponyfill.com) + + +## Use the built-in + +Node.js 4 and up, as well as every evergreen browser (Chrome, Edge, Firefox, Opera, Safari), +support `Object.assign()` :tada:. If you target only those environments, then by all +means, use `Object.assign()` instead of this package. + + +## Install + +``` +$ npm install --save object-assign +``` + + +## Usage + +```js +const objectAssign = require('object-assign'); + +objectAssign({foo: 0}, {bar: 1}); +//=> {foo: 0, bar: 1} + +// multiple sources +objectAssign({foo: 0}, {bar: 1}, {baz: 2}); +//=> {foo: 0, bar: 1, baz: 2} + +// overwrites equal keys +objectAssign({foo: 0}, {foo: 1}, {foo: 2}); +//=> {foo: 2} + +// ignores null and undefined sources +objectAssign({foo: 0}, null, {bar: 1}, undefined); +//=> {foo: 0, bar: 1} +``` + + +## API + +### objectAssign(target, [source, ...]) + +Assigns enumerable own properties of `source` objects to the `target` object and returns the `target` object. Additional `source` objects will overwrite previous ones. + + +## Resources + +- [ES2015 spec - Object.assign](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign) + + +## Related + +- [deep-assign](https://github.com/sindresorhus/deep-assign) - Recursive `Object.assign()` + + +## License + +MIT © [Sindre Sorhus](https://sindresorhus.com) diff --git a/node_modules/prop-types/LICENSE b/node_modules/prop-types/LICENSE new file mode 100644 index 0000000..188fb2b --- /dev/null +++ b/node_modules/prop-types/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2013-present, Facebook, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/prop-types/README.md b/node_modules/prop-types/README.md new file mode 100644 index 0000000..e54d435 --- /dev/null +++ b/node_modules/prop-types/README.md @@ -0,0 +1,302 @@ +# prop-types [![Build Status](https://travis-ci.com/facebook/prop-types.svg?branch=main)](https://travis-ci.org/facebook/prop-types) + +Runtime type checking for React props and similar objects. + +You can use prop-types to document the intended types of properties passed to +components. React (and potentially other libraries—see the `checkPropTypes()` +reference below) will check props passed to your components against those +definitions, and warn in development if they don’t match. + +## Installation + +```shell +npm install --save prop-types +``` + +## Importing + +```js +import PropTypes from 'prop-types'; // ES6 +var PropTypes = require('prop-types'); // ES5 with npm +``` + +### CDN + +If you prefer to exclude `prop-types` from your application and use it +globally via `window.PropTypes`, the `prop-types` package provides +single-file distributions, which are hosted on the following CDNs: + +* [**unpkg**](https://unpkg.com/prop-types/) +```html + + + + + +``` + +* [**cdnjs**](https://cdnjs.com/libraries/prop-types) +```html + + + + + +``` + +To load a specific version of `prop-types` replace `15.6.0` with the version number. + +## Usage + +PropTypes was originally exposed as part of the React core module, and is +commonly used with React components. +Here is an example of using PropTypes with a React component, which also +documents the different validators provided: + +```js +import React from 'react'; +import PropTypes from 'prop-types'; + +class MyComponent extends React.Component { + render() { + // ... do things with the props + } +} + +MyComponent.propTypes = { + // You can declare that a prop is a specific JS primitive. By default, these + // are all optional. + optionalArray: PropTypes.array, + optionalBigInt: PropTypes.bigint, + optionalBool: PropTypes.bool, + optionalFunc: PropTypes.func, + optionalNumber: PropTypes.number, + optionalObject: PropTypes.object, + optionalString: PropTypes.string, + optionalSymbol: PropTypes.symbol, + + // Anything that can be rendered: numbers, strings, elements or an array + // (or fragment) containing these types. + // see https://reactjs.org/docs/rendering-elements.html for more info + optionalNode: PropTypes.node, + + // A React element (ie. ). + optionalElement: PropTypes.element, + + // A React element type (eg. MyComponent). + // a function, string, or "element-like" object (eg. React.Fragment, Suspense, etc.) + // see https://github.com/facebook/react/blob/HEAD/packages/shared/isValidElementType.js + optionalElementType: PropTypes.elementType, + + // You can also declare that a prop is an instance of a class. This uses + // JS's instanceof operator. + optionalMessage: PropTypes.instanceOf(Message), + + // You can ensure that your prop is limited to specific values by treating + // it as an enum. + optionalEnum: PropTypes.oneOf(['News', 'Photos']), + + // An object that could be one of many types + optionalUnion: PropTypes.oneOfType([ + PropTypes.string, + PropTypes.number, + PropTypes.instanceOf(Message) + ]), + + // An array of a certain type + optionalArrayOf: PropTypes.arrayOf(PropTypes.number), + + // An object with property values of a certain type + optionalObjectOf: PropTypes.objectOf(PropTypes.number), + + // You can chain any of the above with `isRequired` to make sure a warning + // is shown if the prop isn't provided. + + // An object taking on a particular shape + optionalObjectWithShape: PropTypes.shape({ + optionalProperty: PropTypes.string, + requiredProperty: PropTypes.number.isRequired + }), + + // An object with warnings on extra properties + optionalObjectWithStrictShape: PropTypes.exact({ + optionalProperty: PropTypes.string, + requiredProperty: PropTypes.number.isRequired + }), + + requiredFunc: PropTypes.func.isRequired, + + // A value of any data type + requiredAny: PropTypes.any.isRequired, + + // You can also specify a custom validator. It should return an Error + // object if the validation fails. Don't `console.warn` or throw, as this + // won't work inside `oneOfType`. + customProp: function(props, propName, componentName) { + if (!/matchme/.test(props[propName])) { + return new Error( + 'Invalid prop `' + propName + '` supplied to' + + ' `' + componentName + '`. Validation failed.' + ); + } + }, + + // You can also supply a custom validator to `arrayOf` and `objectOf`. + // It should return an Error object if the validation fails. The validator + // will be called for each key in the array or object. The first two + // arguments of the validator are the array or object itself, and the + // current item's key. + customArrayProp: PropTypes.arrayOf(function(propValue, key, componentName, location, propFullName) { + if (!/matchme/.test(propValue[key])) { + return new Error( + 'Invalid prop `' + propFullName + '` supplied to' + + ' `' + componentName + '`. Validation failed.' + ); + } + }) +}; +``` + +Refer to the [React documentation](https://facebook.github.io/react/docs/typechecking-with-proptypes.html) for more information. + +## Migrating from React.PropTypes + +Check out [Migrating from React.PropTypes](https://facebook.github.io/react/blog/2017/04/07/react-v15.5.0.html#migrating-from-react.proptypes) for details on how to migrate to `prop-types` from `React.PropTypes`. + +Note that this blog posts **mentions a codemod script that performs the conversion automatically**. + +There are also important notes below. + +## How to Depend on This Package? + +For apps, we recommend putting it in `dependencies` with a caret range. +For example: + +```js + "dependencies": { + "prop-types": "^15.5.7" + } +``` + +For libraries, we *also* recommend leaving it in `dependencies`: + +```js + "dependencies": { + "prop-types": "^15.5.7" + }, + "peerDependencies": { + "react": "^15.5.0" + } +``` + +**Note:** there are known issues in versions before 15.5.7 so we recommend using it as the minimal version. + +Make sure that the version range uses a caret (`^`) and thus is broad enough for npm to efficiently deduplicate packages. + +For UMD bundles of your components, make sure you **don’t** include `PropTypes` in the build. Usually this is done by marking it as an external (the specifics depend on your bundler), just like you do with React. + +## Compatibility + +### React 0.14 + +This package is compatible with **React 0.14.9**. Compared to 0.14.8 (which was released in March of 2016), there are no other changes in 0.14.9, so it should be a painless upgrade. + +```shell +# ATTENTION: Only run this if you still use React 0.14! +npm install --save react@^0.14.9 react-dom@^0.14.9 +``` + +### React 15+ + +This package is compatible with **React 15.3.0** and higher. + +``` +npm install --save react@^15.3.0 react-dom@^15.3.0 +``` + +### What happens on other React versions? + +It outputs warnings with the message below even though the developer doesn’t do anything wrong. Unfortunately there is no solution for this other than updating React to either 15.3.0 or higher, or 0.14.9 if you’re using React 0.14. + +## Difference from `React.PropTypes`: Don’t Call Validator Functions + +First of all, **which version of React are you using**? You might be seeing this message because a component library has updated to use `prop-types` package, but your version of React is incompatible with it. See the [above section](#compatibility) for more details. + +Are you using either React 0.14.9 or a version higher than React 15.3.0? Read on. + +When you migrate components to use the standalone `prop-types`, **all validator functions will start throwing an error if you call them directly**. This makes sure that nobody relies on them in production code, and it is safe to strip their implementations to optimize the bundle size. + +Code like this is still fine: + +```js +MyComponent.propTypes = { + myProp: PropTypes.bool +}; +``` + +However, code like this will not work with the `prop-types` package: + +```js +// Will not work with `prop-types` package! +var errorOrNull = PropTypes.bool(42, 'myProp', 'MyComponent', 'prop'); +``` + +It will throw an error: + +``` +Calling PropTypes validators directly is not supported by the `prop-types` package. +Use PropTypes.checkPropTypes() to call them. +``` + +(If you see **a warning** rather than an error with this message, please check the [above section about compatibility](#compatibility).) + +This is new behavior, and you will only encounter it when you migrate from `React.PropTypes` to the `prop-types` package. For the vast majority of components, this doesn’t matter, and if you didn’t see [this warning](https://facebook.github.io/react/warnings/dont-call-proptypes.html) in your components, your code is safe to migrate. This is not a breaking change in React because you are only opting into this change for a component by explicitly changing your imports to use `prop-types`. If you temporarily need the old behavior, you can keep using `React.PropTypes` until React 16. + +**If you absolutely need to trigger the validation manually**, call `PropTypes.checkPropTypes()`. Unlike the validators themselves, this function is safe to call in production, as it will be replaced by an empty function: + +```js +// Works with standalone PropTypes +PropTypes.checkPropTypes(MyComponent.propTypes, props, 'prop', 'MyComponent'); +``` +See below for more info. + +**If you DO want to use validation in production**, you can choose to use the **development version** by importing/requiring `prop-types/prop-types` instead of `prop-types`. + +**You might also see this error** if you’re calling a `PropTypes` validator from your own custom `PropTypes` validator. In this case, the fix is to make sure that you are passing *all* of the arguments to the inner function. There is a more in-depth explanation of how to fix it [on this page](https://facebook.github.io/react/warnings/dont-call-proptypes.html#fixing-the-false-positive-in-third-party-proptypes). Alternatively, you can temporarily keep using `React.PropTypes` until React 16, as it would still only warn in this case. + +If you use a bundler like Browserify or Webpack, don’t forget to [follow these instructions](https://reactjs.org/docs/optimizing-performance.html#use-the-production-build) to correctly bundle your application in development or production mode. Otherwise you’ll ship unnecessary code to your users. + +## PropTypes.checkPropTypes + +React will automatically check the propTypes you set on the component, but if +you are using PropTypes without React then you may want to manually call +`PropTypes.checkPropTypes`, like so: + +```js +const myPropTypes = { + name: PropTypes.string, + age: PropTypes.number, + // ... define your prop validations +}; + +const props = { + name: 'hello', // is valid + age: 'world', // not valid +}; + +// Let's say your component is called 'MyComponent' + +// Works with standalone PropTypes +PropTypes.checkPropTypes(myPropTypes, props, 'prop', 'MyComponent'); +// This will warn as follows: +// Warning: Failed prop type: Invalid prop `age` of type `string` supplied to +// `MyComponent`, expected `number`. +``` + +## PropTypes.resetWarningCache() + +`PropTypes.checkPropTypes(...)` only `console.error`s a given message once. To reset the error warning cache in tests, call `PropTypes.resetWarningCache()` + +### License + +prop-types is [MIT licensed](./LICENSE). diff --git a/node_modules/prop-types/checkPropTypes.js b/node_modules/prop-types/checkPropTypes.js new file mode 100644 index 0000000..481f2cf --- /dev/null +++ b/node_modules/prop-types/checkPropTypes.js @@ -0,0 +1,103 @@ +/** + * 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 printWarning = function() {}; + +if (process.env.NODE_ENV !== 'production') { + var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret'); + var loggedTypeFailures = {}; + var has = require('./lib/has'); + + printWarning = function(text) { + var message = 'Warning: ' + text; + 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) { /**/ } + }; +} + +/** + * 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 (has(typeSpecs, 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. + if (typeof typeSpecs[typeSpecName] !== 'function') { + var err = Error( + (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.' + ); + err.name = 'Invariant Violation'; + throw err; + } + error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); + } catch (ex) { + error = ex; + } + if (error && !(error instanceof Error)) { + printWarning( + (componentName || 'React class') + ': type specification of ' + + location + ' `' + typeSpecName + '` is invalid; the type checker ' + + 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' + + 'You may have forgotten to pass an argument to the type checker ' + + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + + 'shape all require an argument).' + ); + } + 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() : ''; + + printWarning( + 'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '') + ); + } + } + } + } +} + +/** + * Resets warning cache when testing. + * + * @private + */ +checkPropTypes.resetWarningCache = function() { + if (process.env.NODE_ENV !== 'production') { + loggedTypeFailures = {}; + } +} + +module.exports = checkPropTypes; diff --git a/node_modules/prop-types/factory.js b/node_modules/prop-types/factory.js new file mode 100644 index 0000000..abdf8e6 --- /dev/null +++ b/node_modules/prop-types/factory.js @@ -0,0 +1,19 @@ +/** + * 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'; + +// React 15.5 references this module, and assumes PropTypes are still callable in production. +// Therefore we re-export development-only version with all the PropTypes checks here. +// However if one is migrating to the `prop-types` npm library, they will go through the +// `index.js` entry point, and it will branch depending on the environment. +var factory = require('./factoryWithTypeCheckers'); +module.exports = function(isValidElement) { + // It is still allowed in 15.5. + var throwOnDirectAccess = false; + return factory(isValidElement, throwOnDirectAccess); +}; diff --git a/node_modules/prop-types/factoryWithThrowingShims.js b/node_modules/prop-types/factoryWithThrowingShims.js new file mode 100644 index 0000000..ac88267 --- /dev/null +++ b/node_modules/prop-types/factoryWithThrowingShims.js @@ -0,0 +1,65 @@ +/** + * 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 = require('./lib/ReactPropTypesSecret'); + +function emptyFunction() {} +function emptyFunctionWithReset() {} +emptyFunctionWithReset.resetWarningCache = emptyFunction; + +module.exports = function() { + function shim(props, propName, componentName, location, propFullName, secret) { + if (secret === ReactPropTypesSecret) { + // It is still safe when called from React. + return; + } + var err = new Error( + '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' + ); + err.name = 'Invariant Violation'; + throw err; + }; + shim.isRequired = shim; + function getShim() { + return shim; + }; + // Important! + // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. + var ReactPropTypes = { + array: shim, + bigint: shim, + bool: shim, + func: shim, + number: shim, + object: shim, + string: shim, + symbol: shim, + + any: shim, + arrayOf: getShim, + element: shim, + elementType: shim, + instanceOf: getShim, + node: shim, + objectOf: getShim, + oneOf: getShim, + oneOfType: getShim, + shape: getShim, + exact: getShim, + + checkPropTypes: emptyFunctionWithReset, + resetWarningCache: emptyFunction + }; + + ReactPropTypes.PropTypes = ReactPropTypes; + + return ReactPropTypes; +}; diff --git a/node_modules/prop-types/factoryWithTypeCheckers.js b/node_modules/prop-types/factoryWithTypeCheckers.js new file mode 100644 index 0000000..a88068e --- /dev/null +++ b/node_modules/prop-types/factoryWithTypeCheckers.js @@ -0,0 +1,610 @@ +/** + * 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 ReactIs = require('react-is'); +var assign = require('object-assign'); + +var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret'); +var has = require('./lib/has'); +var checkPropTypes = require('./checkPropTypes'); + +var printWarning = function() {}; + +if (process.env.NODE_ENV !== 'production') { + printWarning = function(text) { + var message = 'Warning: ' + text; + 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) {} + }; +} + +function emptyFunctionThatReturnsNull() { + return null; +} + +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 = '<>'; + + // Important! + // Keep this list in sync with production version in `./factoryWithThrowingShims.js`. + var ReactPropTypes = { + array: createPrimitiveTypeChecker('array'), + bigint: createPrimitiveTypeChecker('bigint'), + bool: createPrimitiveTypeChecker('boolean'), + func: createPrimitiveTypeChecker('function'), + number: createPrimitiveTypeChecker('number'), + object: createPrimitiveTypeChecker('object'), + string: createPrimitiveTypeChecker('string'), + symbol: createPrimitiveTypeChecker('symbol'), + + any: createAnyTypeChecker(), + arrayOf: createArrayOfTypeChecker, + element: createElementTypeChecker(), + elementType: createElementTypeTypeChecker(), + 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, data) { + this.message = message; + this.data = data && typeof data === 'object' ? data: {}; + 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 + var err = new Error( + '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' + ); + err.name = 'Invariant Violation'; + throw err; + } 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 + ) { + printWarning( + 'You are manually calling a React.PropTypes validation ' + + 'function for the `' + propFullName + '` prop on `' + componentName + '`. 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.' + ); + 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 + '`.'), + {expectedType: expectedType} + ); + } + return null; + } + return createChainableTypeChecker(validate); + } + + function createAnyTypeChecker() { + return createChainableTypeChecker(emptyFunctionThatReturnsNull); + } + + 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 createElementTypeTypeChecker() { + function validate(props, propName, componentName, location, propFullName) { + var propValue = props[propName]; + if (!ReactIs.isValidElementType(propValue)) { + var propType = getPropType(propValue); + return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.')); + } + 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)) { + if (process.env.NODE_ENV !== 'production') { + if (arguments.length > 1) { + printWarning( + 'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' + + 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).' + ); + } else { + printWarning('Invalid argument supplied to oneOf, expected an array.'); + } + } + return emptyFunctionThatReturnsNull; + } + + 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, function replacer(key, value) { + var type = getPreciseType(value); + if (type === 'symbol') { + return String(value); + } + return value; + }); + return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(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 (has(propValue, 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' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0; + return emptyFunctionThatReturnsNull; + } + + for (var i = 0; i < arrayOfTypeCheckers.length; i++) { + var checker = arrayOfTypeCheckers[i]; + if (typeof checker !== 'function') { + printWarning( + 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.' + ); + return emptyFunctionThatReturnsNull; + } + } + + function validate(props, propName, componentName, location, propFullName) { + var expectedTypes = []; + for (var i = 0; i < arrayOfTypeCheckers.length; i++) { + var checker = arrayOfTypeCheckers[i]; + var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret); + if (checkerResult == null) { + return null; + } + if (checkerResult.data && has(checkerResult.data, 'expectedType')) { + expectedTypes.push(checkerResult.data.expectedType); + } + } + var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': ''; + return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.')); + } + 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 invalidValidatorError(componentName, location, propFullName, key, type) { + return new PropTypeError( + (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' + + 'it must be a function, usually from the `prop-types` package, but received `' + type + '`.' + ); + } + + 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 (typeof checker !== 'function') { + return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker)); + } + 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 (has(shapeTypes, key) && typeof checker !== 'function') { + return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker)); + } + 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; + } + + // falsy value can't be a Symbol + if (!propValue) { + return false; + } + + // 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.resetWarningCache = checkPropTypes.resetWarningCache; + ReactPropTypes.PropTypes = ReactPropTypes; + + return ReactPropTypes; +}; diff --git a/node_modules/prop-types/index.js b/node_modules/prop-types/index.js new file mode 100644 index 0000000..e9ef51d --- /dev/null +++ b/node_modules/prop-types/index.js @@ -0,0 +1,19 @@ +/** + * 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 ReactIs = require('react-is'); + + // By explicitly using `prop-types` you are opting into new development behavior. + // http://fb.me/prop-types-in-prod + var throwOnDirectAccess = true; + module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess); +} else { + // By explicitly using `prop-types` you are opting into new production behavior. + // http://fb.me/prop-types-in-prod + module.exports = require('./factoryWithThrowingShims')(); +} diff --git a/node_modules/prop-types/lib/ReactPropTypesSecret.js b/node_modules/prop-types/lib/ReactPropTypesSecret.js new file mode 100644 index 0000000..f54525e --- /dev/null +++ b/node_modules/prop-types/lib/ReactPropTypesSecret.js @@ -0,0 +1,12 @@ +/** + * 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; diff --git a/node_modules/prop-types/lib/has.js b/node_modules/prop-types/lib/has.js new file mode 100644 index 0000000..007bae3 --- /dev/null +++ b/node_modules/prop-types/lib/has.js @@ -0,0 +1 @@ +module.exports = Function.call.bind(Object.prototype.hasOwnProperty); diff --git a/node_modules/prop-types/package.json b/node_modules/prop-types/package.json new file mode 100644 index 0000000..63daf70 --- /dev/null +++ b/node_modules/prop-types/package.json @@ -0,0 +1,60 @@ +{ + "name": "prop-types", + "version": "15.8.1", + "description": "Runtime type checking for React props and similar objects.", + "sideEffects": false, + "main": "index.js", + "license": "MIT", + "files": [ + "LICENSE", + "README.md", + "checkPropTypes.js", + "factory.js", + "factoryWithThrowingShims.js", + "factoryWithTypeCheckers.js", + "index.js", + "prop-types.js", + "prop-types.min.js", + "lib" + ], + "repository": "facebook/prop-types", + "keywords": [ + "react" + ], + "bugs": { + "url": "https://github.com/facebook/prop-types/issues" + }, + "homepage": "https://facebook.github.io/react/", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + }, + "scripts": { + "pretest": "npm run lint", + "lint": "eslint .", + "test": "npm run tests-only", + "tests-only": "jest", + "umd": "NODE_ENV=development browserify index.js -t loose-envify --standalone PropTypes -o prop-types.js", + "umd-min": "NODE_ENV=production browserify index.js -t loose-envify -t uglifyify --standalone PropTypes -p bundle-collapser/plugin -o | uglifyjs --compress unused,dead_code -o prop-types.min.js", + "build": "yarn umd && yarn umd-min", + "prepublish": "not-in-publish || yarn build" + }, + "devDependencies": { + "babel-jest": "^19.0.0", + "babel-preset-react": "^6.24.1", + "browserify": "^16.5.0", + "bundle-collapser": "^1.4.0", + "eslint": "^8.6.0", + "in-publish": "^2.0.1", + "jest": "^19.0.2", + "react": "^15.7.0", + "uglifyify": "^5.0.2", + "uglifyjs": "^2.4.11" + }, + "browserify": { + "transform": [ + "loose-envify" + ] + } +} diff --git a/node_modules/prop-types/prop-types.js b/node_modules/prop-types/prop-types.js new file mode 100644 index 0000000..a5a15dd --- /dev/null +++ b/node_modules/prop-types/prop-types.js @@ -0,0 +1,1315 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.PropTypes = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i 1) { + printWarning( + 'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' + + 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).' + ); + } else { + printWarning('Invalid argument supplied to oneOf, expected an array.'); + } + } + return emptyFunctionThatReturnsNull; + } + + 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, function replacer(key, value) { + var type = getPreciseType(value); + if (type === 'symbol') { + return String(value); + } + return value; + }); + return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(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 (has(propValue, 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)) { + "development" !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0; + return emptyFunctionThatReturnsNull; + } + + for (var i = 0; i < arrayOfTypeCheckers.length; i++) { + var checker = arrayOfTypeCheckers[i]; + if (typeof checker !== 'function') { + printWarning( + 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.' + ); + return emptyFunctionThatReturnsNull; + } + } + + function validate(props, propName, componentName, location, propFullName) { + var expectedTypes = []; + for (var i = 0; i < arrayOfTypeCheckers.length; i++) { + var checker = arrayOfTypeCheckers[i]; + var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret); + if (checkerResult == null) { + return null; + } + if (checkerResult.data.hasOwnProperty('expectedType')) { + expectedTypes.push(checkerResult.data.expectedType); + } + } + var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': ''; + return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.')); + } + 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 invalidValidatorError(componentName, location, propFullName, key, type) { + return new PropTypeError( + (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' + + 'it must be a function, usually from the `prop-types` package, but received `' + type + '`.' + ); + } + + 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 (typeof checker !== 'function') { + return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker)); + } + 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 (has(shapeTypes, key) && typeof checker !== 'function') { + return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker)); + } + 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; + } + + // falsy value can't be a Symbol + if (!propValue) { + return false; + } + + // 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.resetWarningCache = checkPropTypes.resetWarningCache; + ReactPropTypes.PropTypes = ReactPropTypes; + + return ReactPropTypes; +}; + +},{"./checkPropTypes":1,"./lib/ReactPropTypesSecret":5,"./lib/has":6,"object-assign":7,"react-is":11}],4:[function(require,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. + */ + +if ("development" !== 'production') { + var ReactIs = require('react-is'); + + // By explicitly using `prop-types` you are opting into new development behavior. + // http://fb.me/prop-types-in-prod + var throwOnDirectAccess = true; + module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess); +} else { + // By explicitly using `prop-types` you are opting into new production behavior. + // http://fb.me/prop-types-in-prod + module.exports = require('./factoryWithThrowingShims')(); +} + +},{"./factoryWithThrowingShims":2,"./factoryWithTypeCheckers":3,"react-is":11}],5:[function(require,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; + +},{}],6:[function(require,module,exports){ +module.exports = Function.call.bind(Object.prototype.hasOwnProperty); + +},{}],7:[function(require,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; +}; + +},{}],8:[function(require,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; }; + +},{}],9:[function(require,module,exports){ +(function (process){(function (){ +/** @license React v16.13.1 + * react-is.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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") { + (function() { +'use strict'; + +// The Symbol used to tag the ReactElement-like types. If there is no native Symbol +// nor polyfill, then a plain number is used for performance. +var hasSymbol = typeof Symbol === 'function' && Symbol.for; +var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7; +var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca; +var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb; +var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc; +var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2; +var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd; +var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary +// (unstable) APIs that have been removed. Can we remove the symbols? + +var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf; +var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf; +var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0; +var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1; +var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8; +var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3; +var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4; +var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9; +var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5; +var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6; +var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7; + +function isValidElementType(type) { + return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill. + type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE); +} + +function typeOf(object) { + if (typeof object === 'object' && object !== null) { + var $$typeof = object.$$typeof; + + switch ($$typeof) { + case REACT_ELEMENT_TYPE: + var type = object.type; + + switch (type) { + case REACT_ASYNC_MODE_TYPE: + case REACT_CONCURRENT_MODE_TYPE: + case REACT_FRAGMENT_TYPE: + case REACT_PROFILER_TYPE: + case REACT_STRICT_MODE_TYPE: + case REACT_SUSPENSE_TYPE: + return type; + + default: + var $$typeofType = type && type.$$typeof; + + switch ($$typeofType) { + case REACT_CONTEXT_TYPE: + case REACT_FORWARD_REF_TYPE: + case REACT_LAZY_TYPE: + case REACT_MEMO_TYPE: + case REACT_PROVIDER_TYPE: + return $$typeofType; + + default: + return $$typeof; + } + + } + + case REACT_PORTAL_TYPE: + return $$typeof; + } + } + + return undefined; +} // AsyncMode is deprecated along with isAsyncMode + +var AsyncMode = REACT_ASYNC_MODE_TYPE; +var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE; +var ContextConsumer = REACT_CONTEXT_TYPE; +var ContextProvider = REACT_PROVIDER_TYPE; +var Element = REACT_ELEMENT_TYPE; +var ForwardRef = REACT_FORWARD_REF_TYPE; +var Fragment = REACT_FRAGMENT_TYPE; +var Lazy = REACT_LAZY_TYPE; +var Memo = REACT_MEMO_TYPE; +var Portal = REACT_PORTAL_TYPE; +var Profiler = REACT_PROFILER_TYPE; +var StrictMode = REACT_STRICT_MODE_TYPE; +var Suspense = REACT_SUSPENSE_TYPE; +var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated + +function isAsyncMode(object) { + { + if (!hasWarnedAboutDeprecatedIsAsyncMode) { + hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint + + console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.'); + } + } + + return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE; +} +function isConcurrentMode(object) { + return typeOf(object) === REACT_CONCURRENT_MODE_TYPE; +} +function isContextConsumer(object) { + return typeOf(object) === REACT_CONTEXT_TYPE; +} +function isContextProvider(object) { + return typeOf(object) === REACT_PROVIDER_TYPE; +} +function isElement(object) { + return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; +} +function isForwardRef(object) { + return typeOf(object) === REACT_FORWARD_REF_TYPE; +} +function isFragment(object) { + return typeOf(object) === REACT_FRAGMENT_TYPE; +} +function isLazy(object) { + return typeOf(object) === REACT_LAZY_TYPE; +} +function isMemo(object) { + return typeOf(object) === REACT_MEMO_TYPE; +} +function isPortal(object) { + return typeOf(object) === REACT_PORTAL_TYPE; +} +function isProfiler(object) { + return typeOf(object) === REACT_PROFILER_TYPE; +} +function isStrictMode(object) { + return typeOf(object) === REACT_STRICT_MODE_TYPE; +} +function isSuspense(object) { + return typeOf(object) === REACT_SUSPENSE_TYPE; +} + +exports.AsyncMode = AsyncMode; +exports.ConcurrentMode = ConcurrentMode; +exports.ContextConsumer = ContextConsumer; +exports.ContextProvider = ContextProvider; +exports.Element = Element; +exports.ForwardRef = ForwardRef; +exports.Fragment = Fragment; +exports.Lazy = Lazy; +exports.Memo = Memo; +exports.Portal = Portal; +exports.Profiler = Profiler; +exports.StrictMode = StrictMode; +exports.Suspense = Suspense; +exports.isAsyncMode = isAsyncMode; +exports.isConcurrentMode = isConcurrentMode; +exports.isContextConsumer = isContextConsumer; +exports.isContextProvider = isContextProvider; +exports.isElement = isElement; +exports.isForwardRef = isForwardRef; +exports.isFragment = isFragment; +exports.isLazy = isLazy; +exports.isMemo = isMemo; +exports.isPortal = isPortal; +exports.isProfiler = isProfiler; +exports.isStrictMode = isStrictMode; +exports.isSuspense = isSuspense; +exports.isValidElementType = isValidElementType; +exports.typeOf = typeOf; + })(); +} + +}).call(this)}).call(this,require('_process')) +},{"_process":8}],10:[function(require,module,exports){ +/** @license React v16.13.1 + * react-is.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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 b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b? +Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119; +function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d; +exports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t}; +exports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p}; +exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z; + +},{}],11:[function(require,module,exports){ +(function (process){(function (){ +'use strict'; + +if (process.env.NODE_ENV === 'production') { + module.exports = require('./cjs/react-is.production.min.js'); +} else { + module.exports = require('./cjs/react-is.development.js'); +} + +}).call(this)}).call(this,require('_process')) +},{"./cjs/react-is.development.js":9,"./cjs/react-is.production.min.js":10,"_process":8}]},{},[4])(4) +}); diff --git a/node_modules/prop-types/prop-types.min.js b/node_modules/prop-types/prop-types.min.js new file mode 100644 index 0000000..7a746e1 --- /dev/null +++ b/node_modules/prop-types/prop-types.min.js @@ -0,0 +1 @@ +!function(f){"object"==typeof exports&&"undefined"!=typeof module?module.exports=f():"function"==typeof define&&define.amd?define([],f):("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).PropTypes=f()}(function(){return function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var p="function"==typeof require&&require;if(!f&&p)return p(i,!0);if(u)return u(i,!0);throw(p=new Error("Cannot find module '"+i+"'")).code="MODULE_NOT_FOUND",p}p=n[i]={exports:{}},e[i][0].call(p.exports,function(r){return o(e[i][1][r]||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i { + return +}; + +export default App; +``` + +Icons can be configured with inline props: +```javascript + +``` + +If you can't use ES6 imports, it's possible to include icons from the compiled folder ./dist. +```javascript +var Camera = require('react-feather/dist/icons/camera').default; + +var MyComponent = React.createClass({ + render: function () { + return ( + + ); + } +}); +``` +You can also include the whole icon pack: + +```javascript +import React from 'react'; +import * as Icon from 'react-feather'; + +const App = () => { + return +}; + +export default App; +``` diff --git a/node_modules/react-feather/build/index.js b/node_modules/react-feather/build/index.js new file mode 100644 index 0000000..cd435b7 --- /dev/null +++ b/node_modules/react-feather/build/index.js @@ -0,0 +1,10672 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var React = require('react'); +var React__default = _interopDefault(React); +var PropTypes = _interopDefault(require('prop-types')); + +function _extends() { + _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; + }; + + return _extends.apply(this, arguments); +} + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +var Activity = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "22 12 18 12 15 21 9 3 6 12 2 12" + })); +}); +Activity.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Activity.displayName = 'Activity'; + +var Airplay = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M5 17H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-1" + }), /*#__PURE__*/React__default.createElement("polygon", { + points: "12 15 17 21 7 21 12 15" + })); +}); +Airplay.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Airplay.displayName = 'Airplay'; + +var AlertCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "16", + x2: "12.01", + y2: "16" + })); +}); +AlertCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlertCircle.displayName = 'AlertCircle'; + +var AlertOctagon = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "16", + x2: "12.01", + y2: "16" + })); +}); +AlertOctagon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlertOctagon.displayName = 'AlertOctagon'; + +var AlertTriangle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "9", + x2: "12", + y2: "13" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "17", + x2: "12.01", + y2: "17" + })); +}); +AlertTriangle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlertTriangle.displayName = 'AlertTriangle'; + +var AlignCenter = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "18", + y1: "10", + x2: "6", + y2: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "6", + x2: "3", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "14", + x2: "3", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "18", + y1: "18", + x2: "6", + y2: "18" + })); +}); +AlignCenter.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlignCenter.displayName = 'AlignCenter'; + +var AlignJustify = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "10", + x2: "3", + y2: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "6", + x2: "3", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "14", + x2: "3", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "18", + x2: "3", + y2: "18" + })); +}); +AlignJustify.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlignJustify.displayName = 'AlignJustify'; + +var AlignLeft = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "10", + x2: "3", + y2: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "6", + x2: "3", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "14", + x2: "3", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "18", + x2: "3", + y2: "18" + })); +}); +AlignLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlignLeft.displayName = 'AlignLeft'; + +var AlignRight = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "10", + x2: "7", + y2: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "6", + x2: "3", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "14", + x2: "3", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "18", + x2: "7", + y2: "18" + })); +}); +AlignRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlignRight.displayName = 'AlignRight'; + +var Anchor = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "5", + r: "3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "22", + x2: "12", + y2: "8" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M5 12H2a10 10 0 0 0 20 0h-3" + })); +}); +Anchor.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Anchor.displayName = 'Anchor'; + +var Aperture = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14.31", + y1: "8", + x2: "20.05", + y2: "17.94" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9.69", + y1: "8", + x2: "21.17", + y2: "8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "7.38", + y1: "12", + x2: "13.12", + y2: "2.06" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9.69", + y1: "16", + x2: "3.95", + y2: "6.06" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14.31", + y1: "16", + x2: "2.83", + y2: "16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16.62", + y1: "12", + x2: "10.88", + y2: "21.94" + })); +}); +Aperture.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Aperture.displayName = 'Aperture'; + +var Archive = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "21 8 21 21 3 21 3 8" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "1", + y: "3", + width: "22", + height: "5" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "10", + y1: "12", + x2: "14", + y2: "12" + })); +}); +Archive.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Archive.displayName = 'Archive'; + +var ArrowDownCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "8 12 12 16 16 12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "16" + })); +}); +ArrowDownCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowDownCircle.displayName = 'ArrowDownCircle'; + +var ArrowDownLeft = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "7", + x2: "7", + y2: "17" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 17 7 17 7 7" + })); +}); +ArrowDownLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowDownLeft.displayName = 'ArrowDownLeft'; + +var ArrowDownRight = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "7", + y1: "7", + x2: "17", + y2: "17" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 7 17 17 7 17" + })); +}); +ArrowDownRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowDownRight.displayName = 'ArrowDownRight'; + +var ArrowDown = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "5", + x2: "12", + y2: "19" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "19 12 12 19 5 12" + })); +}); +ArrowDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowDown.displayName = 'ArrowDown'; + +var ArrowLeftCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "12 8 8 12 12 16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "12", + x2: "8", + y2: "12" + })); +}); +ArrowLeftCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowLeftCircle.displayName = 'ArrowLeftCircle'; + +var ArrowLeft = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "19", + y1: "12", + x2: "5", + y2: "12" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "12 19 5 12 12 5" + })); +}); +ArrowLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowLeft.displayName = 'ArrowLeft'; + +var ArrowRightCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "12 16 16 12 12 8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +ArrowRightCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowRightCircle.displayName = 'ArrowRightCircle'; + +var ArrowRight = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "5", + y1: "12", + x2: "19", + y2: "12" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "12 5 19 12 12 19" + })); +}); +ArrowRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowRight.displayName = 'ArrowRight'; + +var ArrowUpCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "16 12 12 8 8 12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "16", + x2: "12", + y2: "8" + })); +}); +ArrowUpCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowUpCircle.displayName = 'ArrowUpCircle'; + +var ArrowUpLeft = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "17", + x2: "7", + y2: "7" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "7 17 7 7 17 7" + })); +}); +ArrowUpLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowUpLeft.displayName = 'ArrowUpLeft'; + +var ArrowUpRight = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "7", + y1: "17", + x2: "17", + y2: "7" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "7 7 17 7 17 17" + })); +}); +ArrowUpRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowUpRight.displayName = 'ArrowUpRight'; + +var ArrowUp = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "19", + x2: "12", + y2: "5" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "5 12 12 5 19 12" + })); +}); +ArrowUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowUp.displayName = 'ArrowUp'; + +var AtSign = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "4" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16 8v5a3 3 0 0 0 6 0v-1a10 10 0 1 0-3.92 7.94" + })); +}); +AtSign.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AtSign.displayName = 'AtSign'; + +var Award = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "8", + r: "7" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "8.21 13.89 7 23 12 20 17 23 15.79 13.88" + })); +}); +Award.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Award.displayName = 'Award'; + +var BarChart2 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "18", + y1: "20", + x2: "18", + y2: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "20", + x2: "12", + y2: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "20", + x2: "6", + y2: "14" + })); +}); +BarChart2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BarChart2.displayName = 'BarChart2'; + +var BarChart = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "20", + x2: "12", + y2: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "18", + y1: "20", + x2: "18", + y2: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "20", + x2: "6", + y2: "16" + })); +}); +BarChart.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BarChart.displayName = 'BarChart'; + +var BatteryCharging = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M5 18H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3.19M15 6h2a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-3.19" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "13", + x2: "23", + y2: "11" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "11 6 7 12 13 12 9 18" + })); +}); +BatteryCharging.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BatteryCharging.displayName = 'BatteryCharging'; + +var Battery = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "1", + y: "6", + width: "18", + height: "12", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "13", + x2: "23", + y2: "11" + })); +}); +Battery.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Battery.displayName = 'Battery'; + +var BellOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M13.73 21a2 2 0 0 1-3.46 0" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M18.63 13A17.89 17.89 0 0 1 18 8" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M6.26 6.26A5.86 5.86 0 0 0 6 8c0 7-3 9-3 9h14" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M18 8a6 6 0 0 0-9.33-5" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +BellOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BellOff.displayName = 'BellOff'; + +var Bell = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M13.73 21a2 2 0 0 1-3.46 0" + })); +}); +Bell.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Bell.displayName = 'Bell'; + +var Bluetooth = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "6.5 6.5 17.5 17.5 12 23 12 1 17.5 6.5 6.5 17.5" + })); +}); +Bluetooth.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Bluetooth.displayName = 'Bluetooth'; + +var Bold = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M6 4h8a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M6 12h9a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z" + })); +}); +Bold.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Bold.displayName = 'Bold'; + +var BookOpen = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z" + })); +}); +BookOpen.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BookOpen.displayName = 'BookOpen'; + +var Book = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M4 19.5A2.5 2.5 0 0 1 6.5 17H20" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z" + })); +}); +Book.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Book.displayName = 'Book'; + +var Bookmark = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z" + })); +}); +Bookmark.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Bookmark.displayName = 'Bookmark'; + +var Box = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "3.27 6.96 12 12.01 20.73 6.96" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "22.08", + x2: "12", + y2: "12" + })); +}); +Box.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Box.displayName = 'Box'; + +var Briefcase = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "2", + y: "7", + width: "20", + height: "14", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16 21V5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16" + })); +}); +Briefcase.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Briefcase.displayName = 'Briefcase'; + +var Calendar = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "4", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "2", + x2: "16", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "2", + x2: "8", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "10", + x2: "21", + y2: "10" + })); +}); +Calendar.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Calendar.displayName = 'Calendar'; + +var CameraOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M21 21H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3m3-3h6l2 3h4a2 2 0 0 1 2 2v9.34m-7.72-2.06a4 4 0 1 1-5.56-5.56" + })); +}); +CameraOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CameraOff.displayName = 'CameraOff'; + +var Camera = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M23 19a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h4l2-3h6l2 3h4a2 2 0 0 1 2 2z" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "13", + r: "4" + })); +}); +Camera.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Camera.displayName = 'Camera'; + +var Cast = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M2 16.1A5 5 0 0 1 5.9 20M2 12.05A9 9 0 0 1 9.95 20M2 8V6a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "2", + y1: "20", + x2: "2.01", + y2: "20" + })); +}); +Cast.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Cast.displayName = 'Cast'; + +var CheckCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M22 11.08V12a10 10 0 1 1-5.93-9.14" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "22 4 12 14.01 9 11.01" + })); +}); +CheckCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CheckCircle.displayName = 'CheckCircle'; + +var CheckSquare = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "9 11 12 14 22 4" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11" + })); +}); +CheckSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CheckSquare.displayName = 'CheckSquare'; + +var Check = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "20 6 9 17 4 12" + })); +}); +Check.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Check.displayName = 'Check'; + +var ChevronDown = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "6 9 12 15 18 9" + })); +}); +ChevronDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronDown.displayName = 'ChevronDown'; + +var ChevronLeft = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "15 18 9 12 15 6" + })); +}); +ChevronLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronLeft.displayName = 'ChevronLeft'; + +var ChevronRight = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "9 18 15 12 9 6" + })); +}); +ChevronRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronRight.displayName = 'ChevronRight'; + +var ChevronUp = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "18 15 12 9 6 15" + })); +}); +ChevronUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronUp.displayName = 'ChevronUp'; + +var ChevronsDown = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "7 13 12 18 17 13" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "7 6 12 11 17 6" + })); +}); +ChevronsDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronsDown.displayName = 'ChevronsDown'; + +var ChevronsLeft = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "11 17 6 12 11 7" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "18 17 13 12 18 7" + })); +}); +ChevronsLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronsLeft.displayName = 'ChevronsLeft'; + +var ChevronsRight = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "13 17 18 12 13 7" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "6 17 11 12 6 7" + })); +}); +ChevronsRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronsRight.displayName = 'ChevronsRight'; + +var ChevronsUp = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 11 12 6 7 11" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 18 12 13 7 18" + })); +}); +ChevronsUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronsUp.displayName = 'ChevronsUp'; + +var Chrome = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21.17", + y1: "8", + x2: "12", + y2: "8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3.95", + y1: "6.06", + x2: "8.54", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "10.88", + y1: "21.94", + x2: "15.46", + y2: "14" + })); +}); +Chrome.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Chrome.displayName = 'Chrome'; + +var Circle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + })); +}); +Circle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Circle.displayName = 'Circle'; + +var Clipboard = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "8", + y: "2", + width: "8", + height: "4", + rx: "1", + ry: "1" + })); +}); +Clipboard.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Clipboard.displayName = 'Clipboard'; + +var Clock = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "12 6 12 12 16 14" + })); +}); +Clock.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Clock.displayName = 'Clock'; + +var CloudDrizzle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "19", + x2: "8", + y2: "21" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "13", + x2: "8", + y2: "15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "19", + x2: "16", + y2: "21" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "13", + x2: "16", + y2: "15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "21", + x2: "12", + y2: "23" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "15", + x2: "12", + y2: "17" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25" + })); +}); +CloudDrizzle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudDrizzle.displayName = 'CloudDrizzle'; + +var CloudLightning = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M19 16.9A5 5 0 0 0 18 7h-1.26a8 8 0 1 0-11.62 9" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "13 11 9 17 15 17 11 23" + })); +}); +CloudLightning.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudLightning.displayName = 'CloudLightning'; + +var CloudOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M22.61 16.95A5 5 0 0 0 18 10h-1.26a8 8 0 0 0-7.05-6M5 5a8 8 0 0 0 4 15h9a5 5 0 0 0 1.7-.3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +CloudOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudOff.displayName = 'CloudOff'; + +var CloudRain = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "13", + x2: "16", + y2: "21" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "13", + x2: "8", + y2: "21" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "15", + x2: "12", + y2: "23" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25" + })); +}); +CloudRain.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudRain.displayName = 'CloudRain'; + +var CloudSnow = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M20 17.58A5 5 0 0 0 18 8h-1.26A8 8 0 1 0 4 16.25" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "16", + x2: "8.01", + y2: "16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "20", + x2: "8.01", + y2: "20" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "18", + x2: "12.01", + y2: "18" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "22", + x2: "12.01", + y2: "22" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "16", + x2: "16.01", + y2: "16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "20", + x2: "16.01", + y2: "20" + })); +}); +CloudSnow.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudSnow.displayName = 'CloudSnow'; + +var Cloud = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M18 10h-1.26A8 8 0 1 0 9 20h9a5 5 0 0 0 0-10z" + })); +}); +Cloud.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Cloud.displayName = 'Cloud'; + +var Code = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "16 18 22 12 16 6" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "8 6 2 12 8 18" + })); +}); +Code.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Code.displayName = 'Code'; + +var Codepen = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "12 2 22 8.5 22 15.5 12 22 2 15.5 2 8.5 12 2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "22", + x2: "12", + y2: "15.5" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "22 8.5 12 15.5 2 8.5" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "2 15.5 12 8.5 22 15.5" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "8.5" + })); +}); +Codepen.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Codepen.displayName = 'Codepen'; + +var Codesandbox = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "7.5 4.21 12 6.81 16.5 4.21" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "7.5 19.79 7.5 14.6 3 12" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "21 12 16.5 14.6 16.5 19.79" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "3.27 6.96 12 12.01 20.73 6.96" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "22.08", + x2: "12", + y2: "12" + })); +}); +Codesandbox.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Codesandbox.displayName = 'Codesandbox'; + +var Coffee = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M18 8h1a4 4 0 0 1 0 8h-1" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M2 8h16v9a4 4 0 0 1-4 4H6a4 4 0 0 1-4-4V8z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "1", + x2: "6", + y2: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "10", + y1: "1", + x2: "10", + y2: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14", + y1: "1", + x2: "14", + y2: "4" + })); +}); +Coffee.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Coffee.displayName = 'Coffee'; + +var Columns = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M12 3h7a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-7m0-18H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7m0-18v18" + })); +}); +Columns.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Columns.displayName = 'Columns'; + +var Command = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M18 3a3 3 0 0 0-3 3v12a3 3 0 0 0 3 3 3 3 0 0 0 3-3 3 3 0 0 0-3-3H6a3 3 0 0 0-3 3 3 3 0 0 0 3 3 3 3 0 0 0 3-3V6a3 3 0 0 0-3-3 3 3 0 0 0-3 3 3 3 0 0 0 3 3h12a3 3 0 0 0 3-3 3 3 0 0 0-3-3z" + })); +}); +Command.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Command.displayName = 'Command'; + +var Compass = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("polygon", { + points: "16.24 7.76 14.12 14.12 7.76 16.24 9.88 9.88 16.24 7.76" + })); +}); +Compass.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Compass.displayName = 'Compass'; + +var Copy = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "9", + y: "9", + width: "13", + height: "13", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" + })); +}); +Copy.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Copy.displayName = 'Copy'; + +var CornerDownLeft = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "9 10 4 15 9 20" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20 4v7a4 4 0 0 1-4 4H4" + })); +}); +CornerDownLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerDownLeft.displayName = 'CornerDownLeft'; + +var CornerDownRight = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "15 10 20 15 15 20" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M4 4v7a4 4 0 0 0 4 4h12" + })); +}); +CornerDownRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerDownRight.displayName = 'CornerDownRight'; + +var CornerLeftDown = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "14 15 9 20 4 15" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20 4h-7a4 4 0 0 0-4 4v12" + })); +}); +CornerLeftDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerLeftDown.displayName = 'CornerLeftDown'; + +var CornerLeftUp = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "14 9 9 4 4 9" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20 20h-7a4 4 0 0 1-4-4V4" + })); +}); +CornerLeftUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerLeftUp.displayName = 'CornerLeftUp'; + +var CornerRightDown = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "10 15 15 20 20 15" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M4 4h7a4 4 0 0 1 4 4v12" + })); +}); +CornerRightDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerRightDown.displayName = 'CornerRightDown'; + +var CornerRightUp = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "10 9 15 4 20 9" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M4 20h7a4 4 0 0 0 4-4V4" + })); +}); +CornerRightUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerRightUp.displayName = 'CornerRightUp'; + +var CornerUpLeft = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "9 14 4 9 9 4" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20 20v-7a4 4 0 0 0-4-4H4" + })); +}); +CornerUpLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerUpLeft.displayName = 'CornerUpLeft'; + +var CornerUpRight = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "15 14 20 9 15 4" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M4 20v-7a4 4 0 0 1 4-4h12" + })); +}); +CornerUpRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerUpRight.displayName = 'CornerUpRight'; + +var Cpu = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "4", + y: "4", + width: "16", + height: "16", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "9", + y: "9", + width: "6", + height: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "1", + x2: "9", + y2: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "1", + x2: "15", + y2: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "20", + x2: "9", + y2: "23" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "20", + x2: "15", + y2: "23" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "20", + y1: "9", + x2: "23", + y2: "9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "20", + y1: "14", + x2: "23", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "9", + x2: "4", + y2: "9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "14", + x2: "4", + y2: "14" + })); +}); +Cpu.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Cpu.displayName = 'Cpu'; + +var CreditCard = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "1", + y: "4", + width: "22", + height: "16", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "10", + x2: "23", + y2: "10" + })); +}); +CreditCard.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CreditCard.displayName = 'CreditCard'; + +var Crop = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M6.13 1L6 16a2 2 0 0 0 2 2h15" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M1 6.13L16 6a2 2 0 0 1 2 2v15" + })); +}); +Crop.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Crop.displayName = 'Crop'; + +var Crosshair = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "22", + y1: "12", + x2: "18", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "12", + x2: "2", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "6", + x2: "12", + y2: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "22", + x2: "12", + y2: "18" + })); +}); +Crosshair.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Crosshair.displayName = 'Crosshair'; + +var Database = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("ellipse", { + cx: "12", + cy: "5", + rx: "9", + ry: "3" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M21 12c0 1.66-4 3-9 3s-9-1.34-9-3" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5" + })); +}); +Database.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Database.displayName = 'Database'; + +var Delete = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 4H8l-7 8 7 8h13a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "18", + y1: "9", + x2: "12", + y2: "15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "9", + x2: "18", + y2: "15" + })); +}); +Delete.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Delete.displayName = 'Delete'; + +var Disc = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "3" + })); +}); +Disc.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Disc.displayName = 'Disc'; + +var DivideCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "16", + x2: "12", + y2: "16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "8" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + })); +}); +DivideCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +DivideCircle.displayName = 'DivideCircle'; + +var DivideSquare = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "16", + x2: "12", + y2: "16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "8" + })); +}); +DivideSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +DivideSquare.displayName = 'DivideSquare'; + +var Divide = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "6", + r: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "5", + y1: "12", + x2: "19", + y2: "12" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "18", + r: "2" + })); +}); +Divide.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Divide.displayName = 'Divide'; + +var DollarSign = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "1", + x2: "12", + y2: "23" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6" + })); +}); +DollarSign.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +DollarSign.displayName = 'DollarSign'; + +var DownloadCloud = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "8 17 12 21 16 17" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "12", + x2: "12", + y2: "21" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20.88 18.09A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.29" + })); +}); +DownloadCloud.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +DownloadCloud.displayName = 'DownloadCloud'; + +var Download = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "7 10 12 15 17 10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "15", + x2: "12", + y2: "3" + })); +}); +Download.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Download.displayName = 'Download'; + +var Dribbble = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M8.56 2.75c4.37 6.03 6.02 9.42 8.03 17.72m2.54-15.38c-3.72 4.35-8.94 5.66-16.88 5.85m19.5 1.9c-3.5-.93-6.63-.82-8.94 0-2.58.92-5.01 2.86-7.44 6.32" + })); +}); +Dribbble.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Dribbble.displayName = 'Dribbble'; + +var Droplet = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M12 2.69l5.66 5.66a8 8 0 1 1-11.31 0z" + })); +}); +Droplet.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Droplet.displayName = 'Droplet'; + +var Edit2 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z" + })); +}); +Edit2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Edit2.displayName = 'Edit2'; + +var Edit3 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M12 20h9" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16.5 3.5a2.121 2.121 0 0 1 3 3L7 19l-4 1 1-4L16.5 3.5z" + })); +}); +Edit3.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Edit3.displayName = 'Edit3'; + +var Edit = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z" + })); +}); +Edit.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Edit.displayName = 'Edit'; + +var ExternalLink = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "15 3 21 3 21 9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "10", + y1: "14", + x2: "21", + y2: "3" + })); +}); +ExternalLink.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ExternalLink.displayName = 'ExternalLink'; + +var EyeOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M17.94 17.94A10.07 10.07 0 0 1 12 20c-7 0-11-8-11-8a18.45 18.45 0 0 1 5.06-5.94M9.9 4.24A9.12 9.12 0 0 1 12 4c7 0 11 8 11 8a18.5 18.5 0 0 1-2.16 3.19m-6.72-1.07a3 3 0 1 1-4.24-4.24" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +EyeOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +EyeOff.displayName = 'EyeOff'; + +var Eye = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "3" + })); +}); +Eye.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Eye.displayName = 'Eye'; + +var Facebook = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M18 2h-3a5 5 0 0 0-5 5v3H7v4h3v8h4v-8h3l1-4h-4V7a1 1 0 0 1 1-1h3z" + })); +}); +Facebook.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Facebook.displayName = 'Facebook'; + +var FastForward = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "13 19 22 12 13 5 13 19" + }), /*#__PURE__*/React__default.createElement("polygon", { + points: "2 19 11 12 2 5 2 19" + })); +}); +FastForward.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FastForward.displayName = 'FastForward'; + +var Feather = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M20.24 12.24a6 6 0 0 0-8.49-8.49L5 10.5V19h8.5z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "8", + x2: "2", + y2: "22" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17.5", + y1: "15", + x2: "9", + y2: "15" + })); +}); +Feather.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Feather.displayName = 'Feather'; + +var Figma = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M5 5.5A3.5 3.5 0 0 1 8.5 2H12v7H8.5A3.5 3.5 0 0 1 5 5.5z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M12 2h3.5a3.5 3.5 0 1 1 0 7H12V2z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M12 12.5a3.5 3.5 0 1 1 7 0 3.5 3.5 0 1 1-7 0z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M5 19.5A3.5 3.5 0 0 1 8.5 16H12v3.5a3.5 3.5 0 1 1-7 0z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M5 12.5A3.5 3.5 0 0 1 8.5 9H12v7H8.5A3.5 3.5 0 0 1 5 12.5z" + })); +}); +Figma.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Figma.displayName = 'Figma'; + +var FileMinus = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "14 2 14 8 20 8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "15", + x2: "15", + y2: "15" + })); +}); +FileMinus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FileMinus.displayName = 'FileMinus'; + +var FilePlus = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "14 2 14 8 20 8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "18", + x2: "12", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "15", + x2: "15", + y2: "15" + })); +}); +FilePlus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FilePlus.displayName = 'FilePlus'; + +var FileText = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "14 2 14 8 20 8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "13", + x2: "8", + y2: "13" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "17", + x2: "8", + y2: "17" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "10 9 9 9 8 9" + })); +}); +FileText.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FileText.displayName = 'FileText'; + +var File = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M13 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "13 2 13 9 20 9" + })); +}); +File.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +File.displayName = 'File'; + +var Film = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "2", + y: "2", + width: "20", + height: "20", + rx: "2.18", + ry: "2.18" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "7", + y1: "2", + x2: "7", + y2: "22" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "2", + x2: "17", + y2: "22" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "2", + y1: "12", + x2: "22", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "2", + y1: "7", + x2: "7", + y2: "7" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "2", + y1: "17", + x2: "7", + y2: "17" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "17", + x2: "22", + y2: "17" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "7", + x2: "22", + y2: "7" + })); +}); +Film.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Film.displayName = 'Film'; + +var Filter = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3" + })); +}); +Filter.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Filter.displayName = 'Filter'; + +var Flag = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M4 15s1-1 4-1 5 2 8 2 4-1 4-1V3s-1 1-4 1-5-2-8-2-4 1-4 1z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4", + y1: "22", + x2: "4", + y2: "15" + })); +}); +Flag.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Flag.displayName = 'Flag'; + +var FolderMinus = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "14", + x2: "15", + y2: "14" + })); +}); +FolderMinus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FolderMinus.displayName = 'FolderMinus'; + +var FolderPlus = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "11", + x2: "12", + y2: "17" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "14", + x2: "15", + y2: "14" + })); +}); +FolderPlus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FolderPlus.displayName = 'FolderPlus'; + +var Folder = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z" + })); +}); +Folder.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Folder.displayName = 'Folder'; + +var Framer = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M5 16V9h14V2H5l14 14h-7m-7 0l7 7v-7m-7 0h7" + })); +}); +Framer.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Framer.displayName = 'Framer'; + +var Frown = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16 16s-1.5-2-4-2-4 2-4 2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "9", + x2: "9.01", + y2: "9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "9", + x2: "15.01", + y2: "9" + })); +}); +Frown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Frown.displayName = 'Frown'; + +var Gift = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "20 12 20 22 4 22 4 12" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "2", + y: "7", + width: "20", + height: "5" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "22", + x2: "12", + y2: "7" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M12 7H7.5a2.5 2.5 0 0 1 0-5C11 2 12 7 12 7z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M12 7h4.5a2.5 2.5 0 0 0 0-5C13 2 12 7 12 7z" + })); +}); +Gift.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Gift.displayName = 'Gift'; + +var GitBranch = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "3", + x2: "6", + y2: "15" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "18", + cy: "6", + r: "3" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "6", + cy: "18", + r: "3" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M18 9a9 9 0 0 1-9 9" + })); +}); +GitBranch.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitBranch.displayName = 'GitBranch'; + +var GitCommit = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1.05", + y1: "12", + x2: "7", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17.01", + y1: "12", + x2: "22.96", + y2: "12" + })); +}); +GitCommit.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitCommit.displayName = 'GitCommit'; + +var GitMerge = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "18", + cy: "18", + r: "3" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "6", + cy: "6", + r: "3" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M6 21V9a9 9 0 0 0 9 9" + })); +}); +GitMerge.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitMerge.displayName = 'GitMerge'; + +var GitPullRequest = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "18", + cy: "18", + r: "3" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "6", + cy: "6", + r: "3" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M13 6h3a2 2 0 0 1 2 2v7" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "9", + x2: "6", + y2: "21" + })); +}); +GitPullRequest.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitPullRequest.displayName = 'GitPullRequest'; + +var GitHub = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M9 19c-5 1.5-5-2.5-7-3m14 6v-3.87a3.37 3.37 0 0 0-.94-2.61c3.14-.35 6.44-1.54 6.44-7A5.44 5.44 0 0 0 20 4.77 5.07 5.07 0 0 0 19.91 1S18.73.65 16 2.48a13.38 13.38 0 0 0-7 0C6.27.65 5.09 1 5.09 1A5.07 5.07 0 0 0 5 4.77a5.44 5.44 0 0 0-1.5 3.78c0 5.42 3.3 6.61 6.44 7A3.37 3.37 0 0 0 9 18.13V22" + })); +}); +GitHub.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitHub.displayName = 'GitHub'; + +var Gitlab = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M22.65 14.39L12 22.13 1.35 14.39a.84.84 0 0 1-.3-.94l1.22-3.78 2.44-7.51A.42.42 0 0 1 4.82 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.49h8.1l2.44-7.51A.42.42 0 0 1 18.6 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.51L23 13.45a.84.84 0 0 1-.35.94z" + })); +}); +Gitlab.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Gitlab.displayName = 'Gitlab'; + +var Globe = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "2", + y1: "12", + x2: "22", + y2: "12" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z" + })); +}); +Globe.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Globe.displayName = 'Globe'; + +var Grid = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "7", + height: "7" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "14", + y: "3", + width: "7", + height: "7" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "14", + y: "14", + width: "7", + height: "7" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "14", + width: "7", + height: "7" + })); +}); +Grid.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Grid.displayName = 'Grid'; + +var HardDrive = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "22", + y1: "12", + x2: "2", + y2: "12" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M5.45 5.11L2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "16", + x2: "6.01", + y2: "16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "10", + y1: "16", + x2: "10.01", + y2: "16" + })); +}); +HardDrive.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +HardDrive.displayName = 'HardDrive'; + +var Hash = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "4", + y1: "9", + x2: "20", + y2: "9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4", + y1: "15", + x2: "20", + y2: "15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "10", + y1: "3", + x2: "8", + y2: "21" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "3", + x2: "14", + y2: "21" + })); +}); +Hash.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Hash.displayName = 'Hash'; + +var Headphones = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M3 18v-6a9 9 0 0 1 18 0v6" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M21 19a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3zM3 19a2 2 0 0 0 2 2h1a2 2 0 0 0 2-2v-3a2 2 0 0 0-2-2H3z" + })); +}); +Headphones.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Headphones.displayName = 'Headphones'; + +var Heart = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z" + })); +}); +Heart.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Heart.displayName = 'Heart'; + +var HelpCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "17", + x2: "12.01", + y2: "17" + })); +}); +HelpCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +HelpCircle.displayName = 'HelpCircle'; + +var Hexagon = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" + })); +}); +Hexagon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Hexagon.displayName = 'Hexagon'; + +var Home = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "9 22 9 12 15 12 15 22" + })); +}); +Home.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Home.displayName = 'Home'; + +var Image = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "8.5", + cy: "8.5", + r: "1.5" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "21 15 16 10 5 21" + })); +}); +Image.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Image.displayName = 'Image'; + +var Inbox = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "22 12 16 12 14 15 10 15 8 12 2 12" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M5.45 5.11L2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z" + })); +}); +Inbox.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Inbox.displayName = 'Inbox'; + +var Info = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "16", + x2: "12", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "8", + x2: "12.01", + y2: "8" + })); +}); +Info.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Info.displayName = 'Info'; + +var Instagram = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "2", + y: "2", + width: "20", + height: "20", + rx: "5", + ry: "5" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17.5", + y1: "6.5", + x2: "17.51", + y2: "6.5" + })); +}); +Instagram.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Instagram.displayName = 'Instagram'; + +var Italic = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "19", + y1: "4", + x2: "10", + y2: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14", + y1: "20", + x2: "5", + y2: "20" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "4", + x2: "9", + y2: "20" + })); +}); +Italic.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Italic.displayName = 'Italic'; + +var Key = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 2l-2 2m-7.61 7.61a5.5 5.5 0 1 1-7.778 7.778 5.5 5.5 0 0 1 7.777-7.777zm0 0L15.5 7.5m0 0l3 3L22 7l-3-3m-3.5 3.5L19 4" + })); +}); +Key.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Key.displayName = 'Key'; + +var Layers = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "12 2 2 7 12 12 22 7 12 2" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "2 17 12 22 22 17" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "2 12 12 17 22 12" + })); +}); +Layers.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Layers.displayName = 'Layers'; + +var Layout = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "9", + x2: "21", + y2: "9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "21", + x2: "9", + y2: "9" + })); +}); +Layout.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Layout.displayName = 'Layout'; + +var LifeBuoy = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4.93", + y1: "4.93", + x2: "9.17", + y2: "9.17" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14.83", + y1: "14.83", + x2: "19.07", + y2: "19.07" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14.83", + y1: "9.17", + x2: "19.07", + y2: "4.93" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14.83", + y1: "9.17", + x2: "18.36", + y2: "5.64" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4.93", + y1: "19.07", + x2: "9.17", + y2: "14.83" + })); +}); +LifeBuoy.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +LifeBuoy.displayName = 'LifeBuoy'; + +var Link2 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +Link2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Link2.displayName = 'Link2'; + +var Link = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71" + })); +}); +Link.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Link.displayName = 'Link'; + +var Linkedin = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M16 8a6 6 0 0 1 6 6v7h-4v-7a2 2 0 0 0-2-2 2 2 0 0 0-2 2v7h-4v-7a6 6 0 0 1 6-6z" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "2", + y: "9", + width: "4", + height: "12" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "4", + cy: "4", + r: "2" + })); +}); +Linkedin.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Linkedin.displayName = 'Linkedin'; + +var List = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "6", + x2: "21", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "12", + x2: "21", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "18", + x2: "21", + y2: "18" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "6", + x2: "3.01", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "12", + x2: "3.01", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "18", + x2: "3.01", + y2: "18" + })); +}); +List.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +List.displayName = 'List'; + +var Loader = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "18", + x2: "12", + y2: "22" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4.93", + y1: "4.93", + x2: "7.76", + y2: "7.76" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16.24", + y1: "16.24", + x2: "19.07", + y2: "19.07" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "2", + y1: "12", + x2: "6", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "18", + y1: "12", + x2: "22", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4.93", + y1: "19.07", + x2: "7.76", + y2: "16.24" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16.24", + y1: "7.76", + x2: "19.07", + y2: "4.93" + })); +}); +Loader.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Loader.displayName = 'Loader'; + +var Lock = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "11", + width: "18", + height: "11", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M7 11V7a5 5 0 0 1 10 0v4" + })); +}); +Lock.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Lock.displayName = 'Lock'; + +var LogIn = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "10 17 15 12 10 7" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "12", + x2: "3", + y2: "12" + })); +}); +LogIn.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +LogIn.displayName = 'LogIn'; + +var LogOut = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "16 17 21 12 16 7" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "12", + x2: "9", + y2: "12" + })); +}); +LogOut.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +LogOut.displayName = 'LogOut'; + +var Mail = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "22,6 12,13 2,6" + })); +}); +Mail.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Mail.displayName = 'Mail'; + +var MapPin = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 10c0 7-9 13-9 13s-9-6-9-13a9 9 0 0 1 18 0z" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "10", + r: "3" + })); +}); +MapPin.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MapPin.displayName = 'MapPin'; + +var Map = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "2", + x2: "8", + y2: "18" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "6", + x2: "16", + y2: "22" + })); +}); +Map.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Map.displayName = 'Map'; + +var Maximize2 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "15 3 21 3 21 9" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "9 21 3 21 3 15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "3", + x2: "14", + y2: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "21", + x2: "10", + y2: "14" + })); +}); +Maximize2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Maximize2.displayName = 'Maximize2'; + +var Maximize = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3" + })); +}); +Maximize.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Maximize.displayName = 'Maximize'; + +var Meh = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "15", + x2: "16", + y2: "15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "9", + x2: "9.01", + y2: "9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "9", + x2: "15.01", + y2: "9" + })); +}); +Meh.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Meh.displayName = 'Meh'; + +var Menu = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "12", + x2: "21", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "6", + x2: "21", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "18", + x2: "21", + y2: "18" + })); +}); +Menu.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Menu.displayName = 'Menu'; + +var MessageCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z" + })); +}); +MessageCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MessageCircle.displayName = 'MessageCircle'; + +var MessageSquare = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" + })); +}); +MessageSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MessageSquare.displayName = 'MessageSquare'; + +var MicOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M9 9v3a3 3 0 0 0 5.12 2.12M15 9.34V4a3 3 0 0 0-5.94-.6" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M17 16.95A7 7 0 0 1 5 12v-2m14 0v2a7 7 0 0 1-.11 1.23" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "19", + x2: "12", + y2: "23" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "23", + x2: "16", + y2: "23" + })); +}); +MicOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MicOff.displayName = 'MicOff'; + +var Mic = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M19 10v2a7 7 0 0 1-14 0v-2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "19", + x2: "12", + y2: "23" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "23", + x2: "16", + y2: "23" + })); +}); +Mic.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Mic.displayName = 'Mic'; + +var Minimize2 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "4 14 10 14 10 20" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "20 10 14 10 14 4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14", + y1: "10", + x2: "21", + y2: "3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "21", + x2: "10", + y2: "14" + })); +}); +Minimize2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Minimize2.displayName = 'Minimize2'; + +var Minimize = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M8 3v3a2 2 0 0 1-2 2H3m18 0h-3a2 2 0 0 1-2-2V3m0 18v-3a2 2 0 0 1 2-2h3M3 16h3a2 2 0 0 1 2 2v3" + })); +}); +Minimize.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Minimize.displayName = 'Minimize'; + +var MinusCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +MinusCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MinusCircle.displayName = 'MinusCircle'; + +var MinusSquare = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +MinusSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MinusSquare.displayName = 'MinusSquare'; + +var Minus = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "5", + y1: "12", + x2: "19", + y2: "12" + })); +}); +Minus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Minus.displayName = 'Minus'; + +var Monitor = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "2", + y: "3", + width: "20", + height: "14", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "21", + x2: "16", + y2: "21" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "17", + x2: "12", + y2: "21" + })); +}); +Monitor.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Monitor.displayName = 'Monitor'; + +var Moon = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z" + })); +}); +Moon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Moon.displayName = 'Moon'; + +var MoreHorizontal = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "1" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "19", + cy: "12", + r: "1" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "5", + cy: "12", + r: "1" + })); +}); +MoreHorizontal.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MoreHorizontal.displayName = 'MoreHorizontal'; + +var MoreVertical = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "1" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "5", + r: "1" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "19", + r: "1" + })); +}); +MoreVertical.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MoreVertical.displayName = 'MoreVertical'; + +var MousePointer = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M3 3l7.07 16.97 2.51-7.39 7.39-2.51L3 3z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M13 13l6 6" + })); +}); +MousePointer.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MousePointer.displayName = 'MousePointer'; + +var Move = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "5 9 2 12 5 15" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "9 5 12 2 15 5" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "15 19 12 22 9 19" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "19 9 22 12 19 15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "2", + y1: "12", + x2: "22", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "22" + })); +}); +Move.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Move.displayName = 'Move'; + +var Music = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M9 18V5l12-2v13" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "6", + cy: "18", + r: "3" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "18", + cy: "16", + r: "3" + })); +}); +Music.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Music.displayName = 'Music'; + +var Navigation2 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "12 2 19 21 12 17 5 21 12 2" + })); +}); +Navigation2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Navigation2.displayName = 'Navigation2'; + +var Navigation = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "3 11 22 2 13 21 11 13 3 11" + })); +}); +Navigation.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Navigation.displayName = 'Navigation'; + +var Octagon = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2" + })); +}); +Octagon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Octagon.displayName = 'Octagon'; + +var Package = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "16.5", + y1: "9.4", + x2: "7.5", + y2: "4.21" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "3.27 6.96 12 12.01 20.73 6.96" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "22.08", + x2: "12", + y2: "12" + })); +}); +Package.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Package.displayName = 'Package'; + +var Paperclip = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48" + })); +}); +Paperclip.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Paperclip.displayName = 'Paperclip'; + +var PauseCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "10", + y1: "15", + x2: "10", + y2: "9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14", + y1: "15", + x2: "14", + y2: "9" + })); +}); +PauseCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PauseCircle.displayName = 'PauseCircle'; + +var Pause = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "6", + y: "4", + width: "4", + height: "16" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "14", + y: "4", + width: "4", + height: "16" + })); +}); +Pause.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Pause.displayName = 'Pause'; + +var PenTool = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M12 19l7-7 3 3-7 7-3-3z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M18 13l-1.5-7.5L2 2l3.5 14.5L13 18l5-5z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M2 2l7.586 7.586" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "11", + cy: "11", + r: "2" + })); +}); +PenTool.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PenTool.displayName = 'PenTool'; + +var Percent = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "19", + y1: "5", + x2: "5", + y2: "19" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "6.5", + cy: "6.5", + r: "2.5" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "17.5", + cy: "17.5", + r: "2.5" + })); +}); +Percent.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Percent.displayName = 'Percent'; + +var PhoneCall = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M15.05 5A5 5 0 0 1 19 8.95M15.05 1A9 9 0 0 1 23 8.94m-1 7.98v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneCall.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneCall.displayName = 'PhoneCall'; + +var PhoneForwarded = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "19 1 23 5 19 9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "5", + x2: "23", + y2: "5" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneForwarded.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneForwarded.displayName = 'PhoneForwarded'; + +var PhoneIncoming = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "16 2 16 8 22 8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "1", + x2: "16", + y2: "8" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneIncoming.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneIncoming.displayName = 'PhoneIncoming'; + +var PhoneMissed = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "1", + x2: "17", + y2: "7" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "1", + x2: "23", + y2: "7" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneMissed.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneMissed.displayName = 'PhoneMissed'; + +var PhoneOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M10.68 13.31a16 16 0 0 0 3.41 2.6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7 2 2 0 0 1 1.72 2v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.42 19.42 0 0 1-3.33-2.67m-2.67-3.34a19.79 19.79 0 0 1-3.07-8.63A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "1", + x2: "1", + y2: "23" + })); +}); +PhoneOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneOff.displayName = 'PhoneOff'; + +var PhoneOutgoing = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "23 7 23 1 17 1" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "16", + y1: "8", + x2: "23", + y2: "1" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneOutgoing.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneOutgoing.displayName = 'PhoneOutgoing'; + +var Phone = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +Phone.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Phone.displayName = 'Phone'; + +var PieChart = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21.21 15.89A10 10 0 1 1 8 2.83" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M22 12A10 10 0 0 0 12 2v10z" + })); +}); +PieChart.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PieChart.displayName = 'PieChart'; + +var PlayCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("polygon", { + points: "10 8 16 12 10 16 10 8" + })); +}); +PlayCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PlayCircle.displayName = 'PlayCircle'; + +var Play = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "5 3 19 12 5 21 5 3" + })); +}); +Play.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Play.displayName = 'Play'; + +var PlusCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +PlusCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PlusCircle.displayName = 'PlusCircle'; + +var PlusSquare = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +PlusSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PlusSquare.displayName = 'PlusSquare'; + +var Plus = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "5", + x2: "12", + y2: "19" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "5", + y1: "12", + x2: "19", + y2: "12" + })); +}); +Plus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Plus.displayName = 'Plus'; + +var Pocket = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M4 3h16a2 2 0 0 1 2 2v6a10 10 0 0 1-10 10A10 10 0 0 1 2 11V5a2 2 0 0 1 2-2z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "8 10 12 14 16 10" + })); +}); +Pocket.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Pocket.displayName = 'Pocket'; + +var Power = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M18.36 6.64a9 9 0 1 1-12.73 0" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "12" + })); +}); +Power.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Power.displayName = 'Power'; + +var Printer = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "6 9 6 2 18 2 18 9" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "6", + y: "14", + width: "12", + height: "8" + })); +}); +Printer.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Printer.displayName = 'Printer'; + +var Radio = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "2" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16.24 7.76a6 6 0 0 1 0 8.49m-8.48-.01a6 6 0 0 1 0-8.49m11.31-2.82a10 10 0 0 1 0 14.14m-14.14 0a10 10 0 0 1 0-14.14" + })); +}); +Radio.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Radio.displayName = 'Radio'; + +var RefreshCcw = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "1 4 1 10 7 10" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "23 20 23 14 17 14" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20.49 9A9 9 0 0 0 5.64 5.64L1 10m22 4l-4.64 4.36A9 9 0 0 1 3.51 15" + })); +}); +RefreshCcw.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +RefreshCcw.displayName = 'RefreshCcw'; + +var RefreshCw = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "23 4 23 10 17 10" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "1 20 1 14 7 14" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15" + })); +}); +RefreshCw.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +RefreshCw.displayName = 'RefreshCw'; + +var Repeat = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 1 21 5 17 9" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M3 11V9a4 4 0 0 1 4-4h14" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "7 23 3 19 7 15" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M21 13v2a4 4 0 0 1-4 4H3" + })); +}); +Repeat.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Repeat.displayName = 'Repeat'; + +var Rewind = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "11 19 2 12 11 5 11 19" + }), /*#__PURE__*/React__default.createElement("polygon", { + points: "22 19 13 12 22 5 22 19" + })); +}); +Rewind.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Rewind.displayName = 'Rewind'; + +var RotateCcw = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "1 4 1 10 7 10" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M3.51 15a9 9 0 1 0 2.13-9.36L1 10" + })); +}); +RotateCcw.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +RotateCcw.displayName = 'RotateCcw'; + +var RotateCw = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "23 4 23 10 17 10" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20.49 15a9 9 0 1 1-2.12-9.36L23 10" + })); +}); +RotateCw.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +RotateCw.displayName = 'RotateCw'; + +var Rss = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M4 11a9 9 0 0 1 9 9" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M4 4a16 16 0 0 1 16 16" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "5", + cy: "19", + r: "1" + })); +}); +Rss.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Rss.displayName = 'Rss'; + +var Save = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 21 17 13 7 13 7 21" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "7 3 7 8 15 8" + })); +}); +Save.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Save.displayName = 'Save'; + +var Scissors = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "6", + cy: "6", + r: "3" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "6", + cy: "18", + r: "3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "20", + y1: "4", + x2: "8.12", + y2: "15.88" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14.47", + y1: "14.48", + x2: "20", + y2: "20" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8.12", + y1: "8.12", + x2: "12", + y2: "12" + })); +}); +Scissors.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Scissors.displayName = 'Scissors'; + +var Search = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "11", + cy: "11", + r: "8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "21", + x2: "16.65", + y2: "16.65" + })); +}); +Search.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Search.displayName = 'Search'; + +var Send = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "22", + y1: "2", + x2: "11", + y2: "13" + }), /*#__PURE__*/React__default.createElement("polygon", { + points: "22 2 15 22 11 13 2 9 22 2" + })); +}); +Send.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Send.displayName = 'Send'; + +var Server = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "2", + y: "2", + width: "20", + height: "8", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "2", + y: "14", + width: "20", + height: "8", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "6", + x2: "6.01", + y2: "6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "18", + x2: "6.01", + y2: "18" + })); +}); +Server.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Server.displayName = 'Server'; + +var Settings = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "3" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z" + })); +}); +Settings.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Settings.displayName = 'Settings'; + +var Share2 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "18", + cy: "5", + r: "3" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "6", + cy: "12", + r: "3" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "18", + cy: "19", + r: "3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8.59", + y1: "13.51", + x2: "15.42", + y2: "17.49" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15.41", + y1: "6.51", + x2: "8.59", + y2: "10.49" + })); +}); +Share2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Share2.displayName = 'Share2'; + +var Share = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "16 6 12 2 8 6" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "15" + })); +}); +Share.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Share.displayName = 'Share'; + +var ShieldOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M19.69 14a6.9 6.9 0 0 0 .31-2V5l-8-3-3.16 1.18" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M4.73 4.73L4 5v7c0 6 8 10 8 10a20.29 20.29 0 0 0 5.62-4.38" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +ShieldOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ShieldOff.displayName = 'ShieldOff'; + +var Shield = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" + })); +}); +Shield.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Shield.displayName = 'Shield'; + +var ShoppingBag = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M6 2L3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "3", + y1: "6", + x2: "21", + y2: "6" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16 10a4 4 0 0 1-8 0" + })); +}); +ShoppingBag.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ShoppingBag.displayName = 'ShoppingBag'; + +var ShoppingCart = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "9", + cy: "21", + r: "1" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "20", + cy: "21", + r: "1" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M1 1h4l2.68 13.39a2 2 0 0 0 2 1.61h9.72a2 2 0 0 0 2-1.61L23 6H6" + })); +}); +ShoppingCart.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ShoppingCart.displayName = 'ShoppingCart'; + +var Shuffle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "16 3 21 3 21 8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4", + y1: "20", + x2: "21", + y2: "3" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "21 16 21 21 16 21" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "15", + x2: "21", + y2: "21" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4", + y1: "4", + x2: "9", + y2: "9" + })); +}); +Shuffle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Shuffle.displayName = 'Shuffle'; + +var Sidebar = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "3", + x2: "9", + y2: "21" + })); +}); +Sidebar.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sidebar.displayName = 'Sidebar'; + +var SkipBack = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "19 20 9 12 19 4 19 20" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "5", + y1: "19", + x2: "5", + y2: "5" + })); +}); +SkipBack.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +SkipBack.displayName = 'SkipBack'; + +var SkipForward = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "5 4 15 12 5 20 5 4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "19", + y1: "5", + x2: "19", + y2: "19" + })); +}); +SkipForward.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +SkipForward.displayName = 'SkipForward'; + +var Slack = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M14.5 10c-.83 0-1.5-.67-1.5-1.5v-5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20.5 10H19V8.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M9.5 14c.83 0 1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5S8 21.33 8 20.5v-5c0-.83.67-1.5 1.5-1.5z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M3.5 14H5v1.5c0 .83-.67 1.5-1.5 1.5S2 16.33 2 15.5 2.67 14 3.5 14z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M14 14.5c0-.83.67-1.5 1.5-1.5h5c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5h-5c-.83 0-1.5-.67-1.5-1.5z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M15.5 19H14v1.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M10 9.5C10 8.67 9.33 8 8.5 8h-5C2.67 8 2 8.67 2 9.5S2.67 11 3.5 11h5c.83 0 1.5-.67 1.5-1.5z" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M8.5 5H10V3.5C10 2.67 9.33 2 8.5 2S7 2.67 7 3.5 7.67 5 8.5 5z" + })); +}); +Slack.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Slack.displayName = 'Slack'; + +var Slash = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4.93", + y1: "4.93", + x2: "19.07", + y2: "19.07" + })); +}); +Slash.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Slash.displayName = 'Slash'; + +var Sliders = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "4", + y1: "21", + x2: "4", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4", + y1: "10", + x2: "4", + y2: "3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "21", + x2: "12", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "20", + y1: "21", + x2: "20", + y2: "16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "20", + y1: "12", + x2: "20", + y2: "3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "14", + x2: "7", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "8", + x2: "15", + y2: "8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "16", + x2: "23", + y2: "16" + })); +}); +Sliders.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sliders.displayName = 'Sliders'; + +var Smartphone = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "5", + y: "2", + width: "14", + height: "20", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "18", + x2: "12.01", + y2: "18" + })); +}); +Smartphone.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Smartphone.displayName = 'Smartphone'; + +var Smile = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M8 14s1.5 2 4 2 4-2 4-2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "9", + x2: "9.01", + y2: "9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "9", + x2: "15.01", + y2: "9" + })); +}); +Smile.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Smile.displayName = 'Smile'; + +var Speaker = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "4", + y: "2", + width: "16", + height: "20", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "14", + r: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "6", + x2: "12.01", + y2: "6" + })); +}); +Speaker.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Speaker.displayName = 'Speaker'; + +var Square = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + })); +}); +Square.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Square.displayName = 'Square'; + +var Star = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2" + })); +}); +Star.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Star.displayName = 'Star'; + +var StopCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "9", + y: "9", + width: "6", + height: "6" + })); +}); +StopCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +StopCircle.displayName = 'StopCircle'; + +var Sun = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "5" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "1", + x2: "12", + y2: "3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "21", + x2: "12", + y2: "23" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4.22", + y1: "4.22", + x2: "5.64", + y2: "5.64" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "18.36", + y1: "18.36", + x2: "19.78", + y2: "19.78" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "12", + x2: "3", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "12", + x2: "23", + y2: "12" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4.22", + y1: "19.78", + x2: "5.64", + y2: "18.36" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "18.36", + y1: "5.64", + x2: "19.78", + y2: "4.22" + })); +}); +Sun.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sun.displayName = 'Sun'; + +var Sunrise = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M17 18a5 5 0 0 0-10 0" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "9" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4.22", + y1: "10.22", + x2: "5.64", + y2: "11.64" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "18", + x2: "3", + y2: "18" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "18", + x2: "23", + y2: "18" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "18.36", + y1: "11.64", + x2: "19.78", + y2: "10.22" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "22", + x2: "1", + y2: "22" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "8 6 12 2 16 6" + })); +}); +Sunrise.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sunrise.displayName = 'Sunrise'; + +var Sunset = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M17 18a5 5 0 0 0-10 0" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "9", + x2: "12", + y2: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4.22", + y1: "10.22", + x2: "5.64", + y2: "11.64" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "18", + x2: "3", + y2: "18" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "18", + x2: "23", + y2: "18" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "18.36", + y1: "11.64", + x2: "19.78", + y2: "10.22" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "22", + x2: "1", + y2: "22" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "16 5 12 9 8 5" + })); +}); +Sunset.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sunset.displayName = 'Sunset'; + +var Table = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M9 3H5a2 2 0 0 0-2 2v4m6-6h10a2 2 0 0 1 2 2v4M9 3v18m0 0h10a2 2 0 0 0 2-2V9M9 21H5a2 2 0 0 1-2-2V9m0 0h18" + })); +}); +Table.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Table.displayName = 'Table'; + +var Tablet = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "4", + y: "2", + width: "16", + height: "20", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "18", + x2: "12.01", + y2: "18" + })); +}); +Tablet.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Tablet.displayName = 'Tablet'; + +var Tag = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "7", + y1: "7", + x2: "7.01", + y2: "7" + })); +}); +Tag.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Tag.displayName = 'Tag'; + +var Target = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "6" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "2" + })); +}); +Target.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Target.displayName = 'Target'; + +var Terminal = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "4 17 10 11 4 5" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "19", + x2: "20", + y2: "19" + })); +}); +Terminal.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Terminal.displayName = 'Terminal'; + +var Thermometer = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M14 14.76V3.5a2.5 2.5 0 0 0-5 0v11.26a4.5 4.5 0 1 0 5 0z" + })); +}); +Thermometer.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Thermometer.displayName = 'Thermometer'; + +var ThumbsDown = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M10 15v4a3 3 0 0 0 3 3l4-9V2H5.72a2 2 0 0 0-2 1.7l-1.38 9a2 2 0 0 0 2 2.3zm7-13h2.67A2.31 2.31 0 0 1 22 4v7a2.31 2.31 0 0 1-2.33 2H17" + })); +}); +ThumbsDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ThumbsDown.displayName = 'ThumbsDown'; + +var ThumbsUp = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M14 9V5a3 3 0 0 0-3-3l-4 9v11h11.28a2 2 0 0 0 2-1.7l1.38-9a2 2 0 0 0-2-2.3zM7 22H4a2 2 0 0 1-2-2v-7a2 2 0 0 1 2-2h3" + })); +}); +ThumbsUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ThumbsUp.displayName = 'ThumbsUp'; + +var ToggleLeft = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "1", + y: "5", + width: "22", + height: "14", + rx: "7", + ry: "7" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "8", + cy: "12", + r: "3" + })); +}); +ToggleLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ToggleLeft.displayName = 'ToggleLeft'; + +var ToggleRight = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "1", + y: "5", + width: "22", + height: "14", + rx: "7", + ry: "7" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "16", + cy: "12", + r: "3" + })); +}); +ToggleRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ToggleRight.displayName = 'ToggleRight'; + +var Tool = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z" + })); +}); +Tool.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Tool.displayName = 'Tool'; + +var Trash2 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "3 6 5 6 21 6" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "10", + y1: "11", + x2: "10", + y2: "17" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "14", + y1: "11", + x2: "14", + y2: "17" + })); +}); +Trash2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Trash2.displayName = 'Trash2'; + +var Trash = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "3 6 5 6 21 6" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" + })); +}); +Trash.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Trash.displayName = 'Trash'; + +var Trello = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "7", + y: "7", + width: "3", + height: "9" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "14", + y: "7", + width: "3", + height: "5" + })); +}); +Trello.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Trello.displayName = 'Trello'; + +var TrendingDown = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "23 18 13.5 8.5 8.5 13.5 1 6" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 18 23 18 23 12" + })); +}); +TrendingDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +TrendingDown.displayName = 'TrendingDown'; + +var TrendingUp = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "23 6 13.5 15.5 8.5 10.5 1 18" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 6 23 6 23 12" + })); +}); +TrendingUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +TrendingUp.displayName = 'TrendingUp'; + +var Triangle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" + })); +}); +Triangle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Triangle.displayName = 'Triangle'; + +var Truck = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "1", + y: "3", + width: "15", + height: "13" + }), /*#__PURE__*/React__default.createElement("polygon", { + points: "16 8 20 8 23 11 23 16 16 16 16 8" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "5.5", + cy: "18.5", + r: "2.5" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "18.5", + cy: "18.5", + r: "2.5" + })); +}); +Truck.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Truck.displayName = 'Truck'; + +var Tv = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "2", + y: "7", + width: "20", + height: "15", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 2 12 7 7 2" + })); +}); +Tv.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Tv.displayName = 'Tv'; + +var Twitch = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 2H3v16h5v4l4-4h5l4-4V2zm-10 9V7m5 4V7" + })); +}); +Twitch.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Twitch.displayName = 'Twitch'; + +var Twitter = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M23 3a10.9 10.9 0 0 1-3.14 1.53 4.48 4.48 0 0 0-7.86 3v1A10.66 10.66 0 0 1 3 4s-4 9 5 13a11.64 11.64 0 0 1-7 2c9 5 20 0 20-11.5a4.5 4.5 0 0 0-.08-.83A7.72 7.72 0 0 0 23 3z" + })); +}); +Twitter.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Twitter.displayName = 'Twitter'; + +var Type = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "4 7 4 4 20 4 20 7" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "20", + x2: "15", + y2: "20" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "4", + x2: "12", + y2: "20" + })); +}); +Type.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Type.displayName = 'Type'; + +var Umbrella = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M23 12a11.05 11.05 0 0 0-22 0zm-5 7a3 3 0 0 1-6 0v-7" + })); +}); +Umbrella.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Umbrella.displayName = 'Umbrella'; + +var Underline = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M6 3v7a6 6 0 0 0 6 6 6 6 0 0 0 6-6V3" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "4", + y1: "21", + x2: "20", + y2: "21" + })); +}); +Underline.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Underline.displayName = 'Underline'; + +var Unlock = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "11", + width: "18", + height: "11", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M7 11V7a5 5 0 0 1 9.9-1" + })); +}); +Unlock.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Unlock.displayName = 'Unlock'; + +var UploadCloud = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "16 16 12 12 8 16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "12", + x2: "12", + y2: "21" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M20.39 18.39A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.3" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "16 16 12 12 8 16" + })); +}); +UploadCloud.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UploadCloud.displayName = 'UploadCloud'; + +var Upload = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 8 12 3 7 8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "3", + x2: "12", + y2: "15" + })); +}); +Upload.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Upload.displayName = 'Upload'; + +var UserCheck = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "8.5", + cy: "7", + r: "4" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "17 11 19 13 23 9" + })); +}); +UserCheck.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UserCheck.displayName = 'UserCheck'; + +var UserMinus = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "8.5", + cy: "7", + r: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "11", + x2: "17", + y2: "11" + })); +}); +UserMinus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UserMinus.displayName = 'UserMinus'; + +var UserPlus = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "8.5", + cy: "7", + r: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "20", + y1: "8", + x2: "20", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "11", + x2: "17", + y2: "11" + })); +}); +UserPlus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UserPlus.displayName = 'UserPlus'; + +var UserX = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "8.5", + cy: "7", + r: "4" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "18", + y1: "8", + x2: "23", + y2: "13" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "8", + x2: "18", + y2: "13" + })); +}); +UserX.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UserX.displayName = 'UserX'; + +var User = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "7", + r: "4" + })); +}); +User.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +User.displayName = 'User'; + +var Users = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "9", + cy: "7", + r: "4" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M23 21v-2a4 4 0 0 0-3-3.87" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16 3.13a4 4 0 0 1 0 7.75" + })); +}); +Users.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Users.displayName = 'Users'; + +var VideoOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M16 16v1a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h2m5.66 0H14a2 2 0 0 1 2 2v3.34l1 1L23 7v10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +VideoOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +VideoOff.displayName = 'VideoOff'; + +var Video = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "23 7 16 12 23 17 23 7" + }), /*#__PURE__*/React__default.createElement("rect", { + x: "1", + y: "5", + width: "15", + height: "14", + rx: "2", + ry: "2" + })); +}); +Video.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Video.displayName = 'Video'; + +var Voicemail = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "5.5", + cy: "11.5", + r: "4.5" + }), /*#__PURE__*/React__default.createElement("circle", { + cx: "18.5", + cy: "11.5", + r: "4.5" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "5.5", + y1: "16", + x2: "18.5", + y2: "16" + })); +}); +Voicemail.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Voicemail.displayName = 'Voicemail'; + +var Volume1 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M15.54 8.46a5 5 0 0 1 0 7.07" + })); +}); +Volume1.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Volume1.displayName = 'Volume1'; + +var Volume2 = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M19.07 4.93a10 10 0 0 1 0 14.14M15.54 8.46a5 5 0 0 1 0 7.07" + })); +}); +Volume2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Volume2.displayName = 'Volume2'; + +var VolumeX = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "23", + y1: "9", + x2: "17", + y2: "15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "17", + y1: "9", + x2: "23", + y2: "15" + })); +}); +VolumeX.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +VolumeX.displayName = 'VolumeX'; + +var Volume = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5" + })); +}); +Volume.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Volume.displayName = 'Volume'; + +var Watch = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "7" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "12 9 12 12 13.5 13.5" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16.51 17.35l-.35 3.83a2 2 0 0 1-2 1.82H9.83a2 2 0 0 1-2-1.82l-.35-3.83m.01-10.7l.35-3.83A2 2 0 0 1 9.83 1h4.35a2 2 0 0 1 2 1.82l.35 3.83" + })); +}); +Watch.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Watch.displayName = 'Watch'; + +var WifiOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M16.72 11.06A10.94 10.94 0 0 1 19 12.55" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M5 12.55a10.94 10.94 0 0 1 5.17-2.39" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M10.71 5.05A16 16 0 0 1 22.58 9" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M1.42 9a15.91 15.91 0 0 1 4.7-2.88" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M8.53 16.11a6 6 0 0 1 6.95 0" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "20", + x2: "12.01", + y2: "20" + })); +}); +WifiOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +WifiOff.displayName = 'WifiOff'; + +var Wifi = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M5 12.55a11 11 0 0 1 14.08 0" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M1.42 9a16 16 0 0 1 21.16 0" + }), /*#__PURE__*/React__default.createElement("path", { + d: "M8.53 16.11a6 6 0 0 1 6.95 0" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "12", + y1: "20", + x2: "12.01", + y2: "20" + })); +}); +Wifi.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Wifi.displayName = 'Wifi'; + +var Wind = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M9.59 4.59A2 2 0 1 1 11 8H2m10.59 11.41A2 2 0 1 0 14 16H2m15.73-8.27A2.5 2.5 0 1 1 19.5 12H2" + })); +}); +Wind.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Wind.displayName = 'Wind'; + +var XCircle = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "9", + x2: "9", + y2: "15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "9", + x2: "15", + y2: "15" + })); +}); +XCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +XCircle.displayName = 'XCircle'; + +var XOctagon = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "9", + x2: "9", + y2: "15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "9", + x2: "15", + y2: "15" + })); +}); +XOctagon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +XOctagon.displayName = 'XOctagon'; + +var XSquare = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "9", + y1: "9", + x2: "15", + y2: "15" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "15", + y1: "9", + x2: "9", + y2: "15" + })); +}); +XSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +XSquare.displayName = 'XSquare'; + +var X = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("line", { + x1: "18", + y1: "6", + x2: "6", + y2: "18" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "6", + y1: "6", + x2: "18", + y2: "18" + })); +}); +X.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +X.displayName = 'X'; + +var Youtube = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("path", { + d: "M22.54 6.42a2.78 2.78 0 0 0-1.94-2C18.88 4 12 4 12 4s-6.88 0-8.6.46a2.78 2.78 0 0 0-1.94 2A29 29 0 0 0 1 11.75a29 29 0 0 0 .46 5.33A2.78 2.78 0 0 0 3.4 19c1.72.46 8.6.46 8.6.46s6.88 0 8.6-.46a2.78 2.78 0 0 0 1.94-2 29 29 0 0 0 .46-5.25 29 29 0 0 0-.46-5.33z" + }), /*#__PURE__*/React__default.createElement("polygon", { + points: "9.75 15.02 15.5 11.75 9.75 8.48 9.75 15.02" + })); +}); +Youtube.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Youtube.displayName = 'Youtube'; + +var ZapOff = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polyline", { + points: "12.41 6.75 13 2 10.57 4.92" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "18.57 12.91 21 10 15.66 10" + }), /*#__PURE__*/React__default.createElement("polyline", { + points: "8 8 3 14 12 14 11 22 16 16" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +ZapOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ZapOff.displayName = 'ZapOff'; + +var Zap = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("polygon", { + points: "13 2 3 14 12 14 11 22 21 10 12 10 13 2" + })); +}); +Zap.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Zap.displayName = 'Zap'; + +var ZoomIn = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "11", + cy: "11", + r: "8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "21", + x2: "16.65", + y2: "16.65" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "11", + y1: "8", + x2: "11", + y2: "14" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "11", + x2: "14", + y2: "11" + })); +}); +ZoomIn.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ZoomIn.displayName = 'ZoomIn'; + +var ZoomOut = React.forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React__default.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React__default.createElement("circle", { + cx: "11", + cy: "11", + r: "8" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "21", + y1: "21", + x2: "16.65", + y2: "16.65" + }), /*#__PURE__*/React__default.createElement("line", { + x1: "8", + y1: "11", + x2: "14", + y2: "11" + })); +}); +ZoomOut.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ZoomOut.displayName = 'ZoomOut'; + +exports.Activity = Activity; +exports.Airplay = Airplay; +exports.AlertCircle = AlertCircle; +exports.AlertOctagon = AlertOctagon; +exports.AlertTriangle = AlertTriangle; +exports.AlignCenter = AlignCenter; +exports.AlignJustify = AlignJustify; +exports.AlignLeft = AlignLeft; +exports.AlignRight = AlignRight; +exports.Anchor = Anchor; +exports.Aperture = Aperture; +exports.Archive = Archive; +exports.ArrowDown = ArrowDown; +exports.ArrowDownCircle = ArrowDownCircle; +exports.ArrowDownLeft = ArrowDownLeft; +exports.ArrowDownRight = ArrowDownRight; +exports.ArrowLeft = ArrowLeft; +exports.ArrowLeftCircle = ArrowLeftCircle; +exports.ArrowRight = ArrowRight; +exports.ArrowRightCircle = ArrowRightCircle; +exports.ArrowUp = ArrowUp; +exports.ArrowUpCircle = ArrowUpCircle; +exports.ArrowUpLeft = ArrowUpLeft; +exports.ArrowUpRight = ArrowUpRight; +exports.AtSign = AtSign; +exports.Award = Award; +exports.BarChart = BarChart; +exports.BarChart2 = BarChart2; +exports.Battery = Battery; +exports.BatteryCharging = BatteryCharging; +exports.Bell = Bell; +exports.BellOff = BellOff; +exports.Bluetooth = Bluetooth; +exports.Bold = Bold; +exports.Book = Book; +exports.BookOpen = BookOpen; +exports.Bookmark = Bookmark; +exports.Box = Box; +exports.Briefcase = Briefcase; +exports.Calendar = Calendar; +exports.Camera = Camera; +exports.CameraOff = CameraOff; +exports.Cast = Cast; +exports.Check = Check; +exports.CheckCircle = CheckCircle; +exports.CheckSquare = CheckSquare; +exports.ChevronDown = ChevronDown; +exports.ChevronLeft = ChevronLeft; +exports.ChevronRight = ChevronRight; +exports.ChevronUp = ChevronUp; +exports.ChevronsDown = ChevronsDown; +exports.ChevronsLeft = ChevronsLeft; +exports.ChevronsRight = ChevronsRight; +exports.ChevronsUp = ChevronsUp; +exports.Chrome = Chrome; +exports.Circle = Circle; +exports.Clipboard = Clipboard; +exports.Clock = Clock; +exports.Cloud = Cloud; +exports.CloudDrizzle = CloudDrizzle; +exports.CloudLightning = CloudLightning; +exports.CloudOff = CloudOff; +exports.CloudRain = CloudRain; +exports.CloudSnow = CloudSnow; +exports.Code = Code; +exports.Codepen = Codepen; +exports.Codesandbox = Codesandbox; +exports.Coffee = Coffee; +exports.Columns = Columns; +exports.Command = Command; +exports.Compass = Compass; +exports.Copy = Copy; +exports.CornerDownLeft = CornerDownLeft; +exports.CornerDownRight = CornerDownRight; +exports.CornerLeftDown = CornerLeftDown; +exports.CornerLeftUp = CornerLeftUp; +exports.CornerRightDown = CornerRightDown; +exports.CornerRightUp = CornerRightUp; +exports.CornerUpLeft = CornerUpLeft; +exports.CornerUpRight = CornerUpRight; +exports.Cpu = Cpu; +exports.CreditCard = CreditCard; +exports.Crop = Crop; +exports.Crosshair = Crosshair; +exports.Database = Database; +exports.Delete = Delete; +exports.Disc = Disc; +exports.Divide = Divide; +exports.DivideCircle = DivideCircle; +exports.DivideSquare = DivideSquare; +exports.DollarSign = DollarSign; +exports.Download = Download; +exports.DownloadCloud = DownloadCloud; +exports.Dribbble = Dribbble; +exports.Droplet = Droplet; +exports.Edit = Edit; +exports.Edit2 = Edit2; +exports.Edit3 = Edit3; +exports.ExternalLink = ExternalLink; +exports.Eye = Eye; +exports.EyeOff = EyeOff; +exports.Facebook = Facebook; +exports.FastForward = FastForward; +exports.Feather = Feather; +exports.Figma = Figma; +exports.File = File; +exports.FileMinus = FileMinus; +exports.FilePlus = FilePlus; +exports.FileText = FileText; +exports.Film = Film; +exports.Filter = Filter; +exports.Flag = Flag; +exports.Folder = Folder; +exports.FolderMinus = FolderMinus; +exports.FolderPlus = FolderPlus; +exports.Framer = Framer; +exports.Frown = Frown; +exports.Gift = Gift; +exports.GitBranch = GitBranch; +exports.GitCommit = GitCommit; +exports.GitHub = GitHub; +exports.GitMerge = GitMerge; +exports.GitPullRequest = GitPullRequest; +exports.Gitlab = Gitlab; +exports.Globe = Globe; +exports.Grid = Grid; +exports.HardDrive = HardDrive; +exports.Hash = Hash; +exports.Headphones = Headphones; +exports.Heart = Heart; +exports.HelpCircle = HelpCircle; +exports.Hexagon = Hexagon; +exports.Home = Home; +exports.Image = Image; +exports.Inbox = Inbox; +exports.Info = Info; +exports.Instagram = Instagram; +exports.Italic = Italic; +exports.Key = Key; +exports.Layers = Layers; +exports.Layout = Layout; +exports.LifeBuoy = LifeBuoy; +exports.Link = Link; +exports.Link2 = Link2; +exports.Linkedin = Linkedin; +exports.List = List; +exports.Loader = Loader; +exports.Lock = Lock; +exports.LogIn = LogIn; +exports.LogOut = LogOut; +exports.Mail = Mail; +exports.Map = Map; +exports.MapPin = MapPin; +exports.Maximize = Maximize; +exports.Maximize2 = Maximize2; +exports.Meh = Meh; +exports.Menu = Menu; +exports.MessageCircle = MessageCircle; +exports.MessageSquare = MessageSquare; +exports.Mic = Mic; +exports.MicOff = MicOff; +exports.Minimize = Minimize; +exports.Minimize2 = Minimize2; +exports.Minus = Minus; +exports.MinusCircle = MinusCircle; +exports.MinusSquare = MinusSquare; +exports.Monitor = Monitor; +exports.Moon = Moon; +exports.MoreHorizontal = MoreHorizontal; +exports.MoreVertical = MoreVertical; +exports.MousePointer = MousePointer; +exports.Move = Move; +exports.Music = Music; +exports.Navigation = Navigation; +exports.Navigation2 = Navigation2; +exports.Octagon = Octagon; +exports.Package = Package; +exports.Paperclip = Paperclip; +exports.Pause = Pause; +exports.PauseCircle = PauseCircle; +exports.PenTool = PenTool; +exports.Percent = Percent; +exports.Phone = Phone; +exports.PhoneCall = PhoneCall; +exports.PhoneForwarded = PhoneForwarded; +exports.PhoneIncoming = PhoneIncoming; +exports.PhoneMissed = PhoneMissed; +exports.PhoneOff = PhoneOff; +exports.PhoneOutgoing = PhoneOutgoing; +exports.PieChart = PieChart; +exports.Play = Play; +exports.PlayCircle = PlayCircle; +exports.Plus = Plus; +exports.PlusCircle = PlusCircle; +exports.PlusSquare = PlusSquare; +exports.Pocket = Pocket; +exports.Power = Power; +exports.Printer = Printer; +exports.Radio = Radio; +exports.RefreshCcw = RefreshCcw; +exports.RefreshCw = RefreshCw; +exports.Repeat = Repeat; +exports.Rewind = Rewind; +exports.RotateCcw = RotateCcw; +exports.RotateCw = RotateCw; +exports.Rss = Rss; +exports.Save = Save; +exports.Scissors = Scissors; +exports.Search = Search; +exports.Send = Send; +exports.Server = Server; +exports.Settings = Settings; +exports.Share = Share; +exports.Share2 = Share2; +exports.Shield = Shield; +exports.ShieldOff = ShieldOff; +exports.ShoppingBag = ShoppingBag; +exports.ShoppingCart = ShoppingCart; +exports.Shuffle = Shuffle; +exports.Sidebar = Sidebar; +exports.SkipBack = SkipBack; +exports.SkipForward = SkipForward; +exports.Slack = Slack; +exports.Slash = Slash; +exports.Sliders = Sliders; +exports.Smartphone = Smartphone; +exports.Smile = Smile; +exports.Speaker = Speaker; +exports.Square = Square; +exports.Star = Star; +exports.StopCircle = StopCircle; +exports.Sun = Sun; +exports.Sunrise = Sunrise; +exports.Sunset = Sunset; +exports.Table = Table; +exports.Tablet = Tablet; +exports.Tag = Tag; +exports.Target = Target; +exports.Terminal = Terminal; +exports.Thermometer = Thermometer; +exports.ThumbsDown = ThumbsDown; +exports.ThumbsUp = ThumbsUp; +exports.ToggleLeft = ToggleLeft; +exports.ToggleRight = ToggleRight; +exports.Tool = Tool; +exports.Trash = Trash; +exports.Trash2 = Trash2; +exports.Trello = Trello; +exports.TrendingDown = TrendingDown; +exports.TrendingUp = TrendingUp; +exports.Triangle = Triangle; +exports.Truck = Truck; +exports.Tv = Tv; +exports.Twitch = Twitch; +exports.Twitter = Twitter; +exports.Type = Type; +exports.Umbrella = Umbrella; +exports.Underline = Underline; +exports.Unlock = Unlock; +exports.Upload = Upload; +exports.UploadCloud = UploadCloud; +exports.User = User; +exports.UserCheck = UserCheck; +exports.UserMinus = UserMinus; +exports.UserPlus = UserPlus; +exports.UserX = UserX; +exports.Users = Users; +exports.Video = Video; +exports.VideoOff = VideoOff; +exports.Voicemail = Voicemail; +exports.Volume = Volume; +exports.Volume1 = Volume1; +exports.Volume2 = Volume2; +exports.VolumeX = VolumeX; +exports.Watch = Watch; +exports.Wifi = Wifi; +exports.WifiOff = WifiOff; +exports.Wind = Wind; +exports.X = X; +exports.XCircle = XCircle; +exports.XOctagon = XOctagon; +exports.XSquare = XSquare; +exports.Youtube = Youtube; +exports.Zap = Zap; +exports.ZapOff = ZapOff; +exports.ZoomIn = ZoomIn; +exports.ZoomOut = ZoomOut; diff --git a/node_modules/react-feather/dist/icons/activity.js b/node_modules/react-feather/dist/icons/activity.js new file mode 100644 index 0000000..7e0e1c2 --- /dev/null +++ b/node_modules/react-feather/dist/icons/activity.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Activity = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "22 12 18 12 15 21 9 3 6 12 2 12" + })); +}); +Activity.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Activity.displayName = 'Activity'; +export default Activity; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/airplay.js b/node_modules/react-feather/dist/icons/airplay.js new file mode 100644 index 0000000..6aedfc6 --- /dev/null +++ b/node_modules/react-feather/dist/icons/airplay.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Airplay = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M5 17H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-1" + }), /*#__PURE__*/React.createElement("polygon", { + points: "12 15 17 21 7 21 12 15" + })); +}); +Airplay.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Airplay.displayName = 'Airplay'; +export default Airplay; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/alert-circle.js b/node_modules/react-feather/dist/icons/alert-circle.js new file mode 100644 index 0000000..6712992 --- /dev/null +++ b/node_modules/react-feather/dist/icons/alert-circle.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var AlertCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "16", + x2: "12.01", + y2: "16" + })); +}); +AlertCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlertCircle.displayName = 'AlertCircle'; +export default AlertCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/alert-octagon.js b/node_modules/react-feather/dist/icons/alert-octagon.js new file mode 100644 index 0000000..12f0531 --- /dev/null +++ b/node_modules/react-feather/dist/icons/alert-octagon.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var AlertOctagon = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "16", + x2: "12.01", + y2: "16" + })); +}); +AlertOctagon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlertOctagon.displayName = 'AlertOctagon'; +export default AlertOctagon; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/alert-triangle.js b/node_modules/react-feather/dist/icons/alert-triangle.js new file mode 100644 index 0000000..43718b1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/alert-triangle.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var AlertTriangle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "9", + x2: "12", + y2: "13" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "17", + x2: "12.01", + y2: "17" + })); +}); +AlertTriangle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlertTriangle.displayName = 'AlertTriangle'; +export default AlertTriangle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/align-center.js b/node_modules/react-feather/dist/icons/align-center.js new file mode 100644 index 0000000..ba3818f --- /dev/null +++ b/node_modules/react-feather/dist/icons/align-center.js @@ -0,0 +1,54 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var AlignCenter = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "18", + y1: "10", + x2: "6", + y2: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "6", + x2: "3", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "14", + x2: "3", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "18", + y1: "18", + x2: "6", + y2: "18" + })); +}); +AlignCenter.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlignCenter.displayName = 'AlignCenter'; +export default AlignCenter; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/align-justify.js b/node_modules/react-feather/dist/icons/align-justify.js new file mode 100644 index 0000000..94220b5 --- /dev/null +++ b/node_modules/react-feather/dist/icons/align-justify.js @@ -0,0 +1,54 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var AlignJustify = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "10", + x2: "3", + y2: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "6", + x2: "3", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "14", + x2: "3", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "18", + x2: "3", + y2: "18" + })); +}); +AlignJustify.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlignJustify.displayName = 'AlignJustify'; +export default AlignJustify; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/align-left.js b/node_modules/react-feather/dist/icons/align-left.js new file mode 100644 index 0000000..5bb335b --- /dev/null +++ b/node_modules/react-feather/dist/icons/align-left.js @@ -0,0 +1,54 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var AlignLeft = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "10", + x2: "3", + y2: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "6", + x2: "3", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "14", + x2: "3", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "18", + x2: "3", + y2: "18" + })); +}); +AlignLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlignLeft.displayName = 'AlignLeft'; +export default AlignLeft; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/align-right.js b/node_modules/react-feather/dist/icons/align-right.js new file mode 100644 index 0000000..9328256 --- /dev/null +++ b/node_modules/react-feather/dist/icons/align-right.js @@ -0,0 +1,54 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var AlignRight = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "10", + x2: "7", + y2: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "6", + x2: "3", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "14", + x2: "3", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "18", + x2: "7", + y2: "18" + })); +}); +AlignRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AlignRight.displayName = 'AlignRight'; +export default AlignRight; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/anchor.js b/node_modules/react-feather/dist/icons/anchor.js new file mode 100644 index 0000000..8b0b847 --- /dev/null +++ b/node_modules/react-feather/dist/icons/anchor.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Anchor = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "5", + r: "3" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "22", + x2: "12", + y2: "8" + }), /*#__PURE__*/React.createElement("path", { + d: "M5 12H2a10 10 0 0 0 20 0h-3" + })); +}); +Anchor.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Anchor.displayName = 'Anchor'; +export default Anchor; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/aperture.js b/node_modules/react-feather/dist/icons/aperture.js new file mode 100644 index 0000000..3040457 --- /dev/null +++ b/node_modules/react-feather/dist/icons/aperture.js @@ -0,0 +1,68 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Aperture = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "14.31", + y1: "8", + x2: "20.05", + y2: "17.94" + }), /*#__PURE__*/React.createElement("line", { + x1: "9.69", + y1: "8", + x2: "21.17", + y2: "8" + }), /*#__PURE__*/React.createElement("line", { + x1: "7.38", + y1: "12", + x2: "13.12", + y2: "2.06" + }), /*#__PURE__*/React.createElement("line", { + x1: "9.69", + y1: "16", + x2: "3.95", + y2: "6.06" + }), /*#__PURE__*/React.createElement("line", { + x1: "14.31", + y1: "16", + x2: "2.83", + y2: "16" + }), /*#__PURE__*/React.createElement("line", { + x1: "16.62", + y1: "12", + x2: "10.88", + y2: "21.94" + })); +}); +Aperture.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Aperture.displayName = 'Aperture'; +export default Aperture; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/archive.js b/node_modules/react-feather/dist/icons/archive.js new file mode 100644 index 0000000..ab8f0c4 --- /dev/null +++ b/node_modules/react-feather/dist/icons/archive.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Archive = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "21 8 21 21 3 21 3 8" + }), /*#__PURE__*/React.createElement("rect", { + x: "1", + y: "3", + width: "22", + height: "5" + }), /*#__PURE__*/React.createElement("line", { + x1: "10", + y1: "12", + x2: "14", + y2: "12" + })); +}); +Archive.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Archive.displayName = 'Archive'; +export default Archive; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-down-circle.js b/node_modules/react-feather/dist/icons/arrow-down-circle.js new file mode 100644 index 0000000..9415200 --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-down-circle.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowDownCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("polyline", { + points: "8 12 12 16 16 12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "16" + })); +}); +ArrowDownCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowDownCircle.displayName = 'ArrowDownCircle'; +export default ArrowDownCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-down-left.js b/node_modules/react-feather/dist/icons/arrow-down-left.js new file mode 100644 index 0000000..7f166e7 --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-down-left.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowDownLeft = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "7", + x2: "7", + y2: "17" + }), /*#__PURE__*/React.createElement("polyline", { + points: "17 17 7 17 7 7" + })); +}); +ArrowDownLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowDownLeft.displayName = 'ArrowDownLeft'; +export default ArrowDownLeft; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-down-right.js b/node_modules/react-feather/dist/icons/arrow-down-right.js new file mode 100644 index 0000000..b7e7235 --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-down-right.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowDownRight = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "7", + y1: "7", + x2: "17", + y2: "17" + }), /*#__PURE__*/React.createElement("polyline", { + points: "17 7 17 17 7 17" + })); +}); +ArrowDownRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowDownRight.displayName = 'ArrowDownRight'; +export default ArrowDownRight; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-down.js b/node_modules/react-feather/dist/icons/arrow-down.js new file mode 100644 index 0000000..2ccf9db --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-down.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowDown = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "5", + x2: "12", + y2: "19" + }), /*#__PURE__*/React.createElement("polyline", { + points: "19 12 12 19 5 12" + })); +}); +ArrowDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowDown.displayName = 'ArrowDown'; +export default ArrowDown; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-left-circle.js b/node_modules/react-feather/dist/icons/arrow-left-circle.js new file mode 100644 index 0000000..40df56e --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-left-circle.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowLeftCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("polyline", { + points: "12 8 8 12 12 16" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "12", + x2: "8", + y2: "12" + })); +}); +ArrowLeftCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowLeftCircle.displayName = 'ArrowLeftCircle'; +export default ArrowLeftCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-left.js b/node_modules/react-feather/dist/icons/arrow-left.js new file mode 100644 index 0000000..732715e --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-left.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowLeft = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "19", + y1: "12", + x2: "5", + y2: "12" + }), /*#__PURE__*/React.createElement("polyline", { + points: "12 19 5 12 12 5" + })); +}); +ArrowLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowLeft.displayName = 'ArrowLeft'; +export default ArrowLeft; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-right-circle.js b/node_modules/react-feather/dist/icons/arrow-right-circle.js new file mode 100644 index 0000000..e5f9a81 --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-right-circle.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowRightCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("polyline", { + points: "12 16 16 12 12 8" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +ArrowRightCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowRightCircle.displayName = 'ArrowRightCircle'; +export default ArrowRightCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-right.js b/node_modules/react-feather/dist/icons/arrow-right.js new file mode 100644 index 0000000..7bac977 --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-right.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowRight = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "5", + y1: "12", + x2: "19", + y2: "12" + }), /*#__PURE__*/React.createElement("polyline", { + points: "12 5 19 12 12 19" + })); +}); +ArrowRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowRight.displayName = 'ArrowRight'; +export default ArrowRight; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-up-circle.js b/node_modules/react-feather/dist/icons/arrow-up-circle.js new file mode 100644 index 0000000..d4dae45 --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-up-circle.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowUpCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("polyline", { + points: "16 12 12 8 8 12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "16", + x2: "12", + y2: "8" + })); +}); +ArrowUpCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowUpCircle.displayName = 'ArrowUpCircle'; +export default ArrowUpCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-up-left.js b/node_modules/react-feather/dist/icons/arrow-up-left.js new file mode 100644 index 0000000..bb08cd1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-up-left.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowUpLeft = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "17", + x2: "7", + y2: "7" + }), /*#__PURE__*/React.createElement("polyline", { + points: "7 17 7 7 17 7" + })); +}); +ArrowUpLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowUpLeft.displayName = 'ArrowUpLeft'; +export default ArrowUpLeft; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-up-right.js b/node_modules/react-feather/dist/icons/arrow-up-right.js new file mode 100644 index 0000000..1261a55 --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-up-right.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowUpRight = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "7", + y1: "17", + x2: "17", + y2: "7" + }), /*#__PURE__*/React.createElement("polyline", { + points: "7 7 17 7 17 17" + })); +}); +ArrowUpRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowUpRight.displayName = 'ArrowUpRight'; +export default ArrowUpRight; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/arrow-up.js b/node_modules/react-feather/dist/icons/arrow-up.js new file mode 100644 index 0000000..f55f00c --- /dev/null +++ b/node_modules/react-feather/dist/icons/arrow-up.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ArrowUp = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "19", + x2: "12", + y2: "5" + }), /*#__PURE__*/React.createElement("polyline", { + points: "5 12 12 5 19 12" + })); +}); +ArrowUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ArrowUp.displayName = 'ArrowUp'; +export default ArrowUp; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/at-sign.js b/node_modules/react-feather/dist/icons/at-sign.js new file mode 100644 index 0000000..d3978a8 --- /dev/null +++ b/node_modules/react-feather/dist/icons/at-sign.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var AtSign = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "4" + }), /*#__PURE__*/React.createElement("path", { + d: "M16 8v5a3 3 0 0 0 6 0v-1a10 10 0 1 0-3.92 7.94" + })); +}); +AtSign.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +AtSign.displayName = 'AtSign'; +export default AtSign; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/award.js b/node_modules/react-feather/dist/icons/award.js new file mode 100644 index 0000000..5f0ddb7 --- /dev/null +++ b/node_modules/react-feather/dist/icons/award.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Award = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "8", + r: "7" + }), /*#__PURE__*/React.createElement("polyline", { + points: "8.21 13.89 7 23 12 20 17 23 15.79 13.88" + })); +}); +Award.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Award.displayName = 'Award'; +export default Award; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/bar-chart-2.js b/node_modules/react-feather/dist/icons/bar-chart-2.js new file mode 100644 index 0000000..d9a2987 --- /dev/null +++ b/node_modules/react-feather/dist/icons/bar-chart-2.js @@ -0,0 +1,49 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var BarChart2 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "18", + y1: "20", + x2: "18", + y2: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "20", + x2: "12", + y2: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "20", + x2: "6", + y2: "14" + })); +}); +BarChart2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BarChart2.displayName = 'BarChart2'; +export default BarChart2; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/bar-chart.js b/node_modules/react-feather/dist/icons/bar-chart.js new file mode 100644 index 0000000..edf6075 --- /dev/null +++ b/node_modules/react-feather/dist/icons/bar-chart.js @@ -0,0 +1,49 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var BarChart = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "20", + x2: "12", + y2: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "18", + y1: "20", + x2: "18", + y2: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "20", + x2: "6", + y2: "16" + })); +}); +BarChart.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BarChart.displayName = 'BarChart'; +export default BarChart; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/battery-charging.js b/node_modules/react-feather/dist/icons/battery-charging.js new file mode 100644 index 0000000..536bd8e --- /dev/null +++ b/node_modules/react-feather/dist/icons/battery-charging.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var BatteryCharging = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M5 18H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3.19M15 6h2a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-3.19" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "13", + x2: "23", + y2: "11" + }), /*#__PURE__*/React.createElement("polyline", { + points: "11 6 7 12 13 12 9 18" + })); +}); +BatteryCharging.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BatteryCharging.displayName = 'BatteryCharging'; +export default BatteryCharging; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/battery.js b/node_modules/react-feather/dist/icons/battery.js new file mode 100644 index 0000000..a7d987b --- /dev/null +++ b/node_modules/react-feather/dist/icons/battery.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Battery = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "1", + y: "6", + width: "18", + height: "12", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "13", + x2: "23", + y2: "11" + })); +}); +Battery.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Battery.displayName = 'Battery'; +export default Battery; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/bell-off.js b/node_modules/react-feather/dist/icons/bell-off.js new file mode 100644 index 0000000..c0ccfaf --- /dev/null +++ b/node_modules/react-feather/dist/icons/bell-off.js @@ -0,0 +1,47 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var BellOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M13.73 21a2 2 0 0 1-3.46 0" + }), /*#__PURE__*/React.createElement("path", { + d: "M18.63 13A17.89 17.89 0 0 1 18 8" + }), /*#__PURE__*/React.createElement("path", { + d: "M6.26 6.26A5.86 5.86 0 0 0 6 8c0 7-3 9-3 9h14" + }), /*#__PURE__*/React.createElement("path", { + d: "M18 8a6 6 0 0 0-9.33-5" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +BellOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BellOff.displayName = 'BellOff'; +export default BellOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/bell.js b/node_modules/react-feather/dist/icons/bell.js new file mode 100644 index 0000000..5f3c367 --- /dev/null +++ b/node_modules/react-feather/dist/icons/bell.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Bell = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9" + }), /*#__PURE__*/React.createElement("path", { + d: "M13.73 21a2 2 0 0 1-3.46 0" + })); +}); +Bell.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Bell.displayName = 'Bell'; +export default Bell; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/bluetooth.js b/node_modules/react-feather/dist/icons/bluetooth.js new file mode 100644 index 0000000..df1bbcc --- /dev/null +++ b/node_modules/react-feather/dist/icons/bluetooth.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Bluetooth = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "6.5 6.5 17.5 17.5 12 23 12 1 17.5 6.5 6.5 17.5" + })); +}); +Bluetooth.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Bluetooth.displayName = 'Bluetooth'; +export default Bluetooth; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/bold.js b/node_modules/react-feather/dist/icons/bold.js new file mode 100644 index 0000000..1f8da2b --- /dev/null +++ b/node_modules/react-feather/dist/icons/bold.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Bold = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M6 4h8a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z" + }), /*#__PURE__*/React.createElement("path", { + d: "M6 12h9a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z" + })); +}); +Bold.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Bold.displayName = 'Bold'; +export default Bold; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/book-open.js b/node_modules/react-feather/dist/icons/book-open.js new file mode 100644 index 0000000..19038b7 --- /dev/null +++ b/node_modules/react-feather/dist/icons/book-open.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var BookOpen = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z" + }), /*#__PURE__*/React.createElement("path", { + d: "M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z" + })); +}); +BookOpen.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +BookOpen.displayName = 'BookOpen'; +export default BookOpen; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/book.js b/node_modules/react-feather/dist/icons/book.js new file mode 100644 index 0000000..d6da7a9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/book.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Book = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M4 19.5A2.5 2.5 0 0 1 6.5 17H20" + }), /*#__PURE__*/React.createElement("path", { + d: "M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z" + })); +}); +Book.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Book.displayName = 'Book'; +export default Book; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/bookmark.js b/node_modules/react-feather/dist/icons/bookmark.js new file mode 100644 index 0000000..81d557e --- /dev/null +++ b/node_modules/react-feather/dist/icons/bookmark.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Bookmark = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z" + })); +}); +Bookmark.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Bookmark.displayName = 'Bookmark'; +export default Bookmark; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/box.js b/node_modules/react-feather/dist/icons/box.js new file mode 100644 index 0000000..9e740ce --- /dev/null +++ b/node_modules/react-feather/dist/icons/box.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Box = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "3.27 6.96 12 12.01 20.73 6.96" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "22.08", + x2: "12", + y2: "12" + })); +}); +Box.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Box.displayName = 'Box'; +export default Box; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/briefcase.js b/node_modules/react-feather/dist/icons/briefcase.js new file mode 100644 index 0000000..12c27ad --- /dev/null +++ b/node_modules/react-feather/dist/icons/briefcase.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Briefcase = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "2", + y: "7", + width: "20", + height: "14", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("path", { + d: "M16 21V5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16" + })); +}); +Briefcase.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Briefcase.displayName = 'Briefcase'; +export default Briefcase; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/calendar.js b/node_modules/react-feather/dist/icons/calendar.js new file mode 100644 index 0000000..26c14b7 --- /dev/null +++ b/node_modules/react-feather/dist/icons/calendar.js @@ -0,0 +1,56 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Calendar = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "4", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "2", + x2: "16", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "2", + x2: "8", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "10", + x2: "21", + y2: "10" + })); +}); +Calendar.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Calendar.displayName = 'Calendar'; +export default Calendar; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/camera-off.js b/node_modules/react-feather/dist/icons/camera-off.js new file mode 100644 index 0000000..cf476ce --- /dev/null +++ b/node_modules/react-feather/dist/icons/camera-off.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CameraOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + }), /*#__PURE__*/React.createElement("path", { + d: "M21 21H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3m3-3h6l2 3h4a2 2 0 0 1 2 2v9.34m-7.72-2.06a4 4 0 1 1-5.56-5.56" + })); +}); +CameraOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CameraOff.displayName = 'CameraOff'; +export default CameraOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/camera.js b/node_modules/react-feather/dist/icons/camera.js new file mode 100644 index 0000000..f17d2b1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/camera.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Camera = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M23 19a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h4l2-3h6l2 3h4a2 2 0 0 1 2 2z" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "13", + r: "4" + })); +}); +Camera.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Camera.displayName = 'Camera'; +export default Camera; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/cast.js b/node_modules/react-feather/dist/icons/cast.js new file mode 100644 index 0000000..8d6b7b5 --- /dev/null +++ b/node_modules/react-feather/dist/icons/cast.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Cast = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M2 16.1A5 5 0 0 1 5.9 20M2 12.05A9 9 0 0 1 9.95 20M2 8V6a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-6" + }), /*#__PURE__*/React.createElement("line", { + x1: "2", + y1: "20", + x2: "2.01", + y2: "20" + })); +}); +Cast.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Cast.displayName = 'Cast'; +export default Cast; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/check-circle.js b/node_modules/react-feather/dist/icons/check-circle.js new file mode 100644 index 0000000..cf3baec --- /dev/null +++ b/node_modules/react-feather/dist/icons/check-circle.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CheckCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M22 11.08V12a10 10 0 1 1-5.93-9.14" + }), /*#__PURE__*/React.createElement("polyline", { + points: "22 4 12 14.01 9 11.01" + })); +}); +CheckCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CheckCircle.displayName = 'CheckCircle'; +export default CheckCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/check-square.js b/node_modules/react-feather/dist/icons/check-square.js new file mode 100644 index 0000000..bb8a2b0 --- /dev/null +++ b/node_modules/react-feather/dist/icons/check-square.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CheckSquare = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "9 11 12 14 22 4" + }), /*#__PURE__*/React.createElement("path", { + d: "M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11" + })); +}); +CheckSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CheckSquare.displayName = 'CheckSquare'; +export default CheckSquare; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/check.js b/node_modules/react-feather/dist/icons/check.js new file mode 100644 index 0000000..c8e8d73 --- /dev/null +++ b/node_modules/react-feather/dist/icons/check.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Check = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "20 6 9 17 4 12" + })); +}); +Check.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Check.displayName = 'Check'; +export default Check; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/chevron-down.js b/node_modules/react-feather/dist/icons/chevron-down.js new file mode 100644 index 0000000..b9405a6 --- /dev/null +++ b/node_modules/react-feather/dist/icons/chevron-down.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ChevronDown = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "6 9 12 15 18 9" + })); +}); +ChevronDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronDown.displayName = 'ChevronDown'; +export default ChevronDown; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/chevron-left.js b/node_modules/react-feather/dist/icons/chevron-left.js new file mode 100644 index 0000000..f220253 --- /dev/null +++ b/node_modules/react-feather/dist/icons/chevron-left.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ChevronLeft = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "15 18 9 12 15 6" + })); +}); +ChevronLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronLeft.displayName = 'ChevronLeft'; +export default ChevronLeft; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/chevron-right.js b/node_modules/react-feather/dist/icons/chevron-right.js new file mode 100644 index 0000000..3781bb1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/chevron-right.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ChevronRight = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "9 18 15 12 9 6" + })); +}); +ChevronRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronRight.displayName = 'ChevronRight'; +export default ChevronRight; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/chevron-up.js b/node_modules/react-feather/dist/icons/chevron-up.js new file mode 100644 index 0000000..7f8b3e9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/chevron-up.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ChevronUp = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "18 15 12 9 6 15" + })); +}); +ChevronUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronUp.displayName = 'ChevronUp'; +export default ChevronUp; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/chevrons-down.js b/node_modules/react-feather/dist/icons/chevrons-down.js new file mode 100644 index 0000000..ad9f1a5 --- /dev/null +++ b/node_modules/react-feather/dist/icons/chevrons-down.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ChevronsDown = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "7 13 12 18 17 13" + }), /*#__PURE__*/React.createElement("polyline", { + points: "7 6 12 11 17 6" + })); +}); +ChevronsDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronsDown.displayName = 'ChevronsDown'; +export default ChevronsDown; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/chevrons-left.js b/node_modules/react-feather/dist/icons/chevrons-left.js new file mode 100644 index 0000000..992d083 --- /dev/null +++ b/node_modules/react-feather/dist/icons/chevrons-left.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ChevronsLeft = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "11 17 6 12 11 7" + }), /*#__PURE__*/React.createElement("polyline", { + points: "18 17 13 12 18 7" + })); +}); +ChevronsLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronsLeft.displayName = 'ChevronsLeft'; +export default ChevronsLeft; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/chevrons-right.js b/node_modules/react-feather/dist/icons/chevrons-right.js new file mode 100644 index 0000000..36007c4 --- /dev/null +++ b/node_modules/react-feather/dist/icons/chevrons-right.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ChevronsRight = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "13 17 18 12 13 7" + }), /*#__PURE__*/React.createElement("polyline", { + points: "6 17 11 12 6 7" + })); +}); +ChevronsRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronsRight.displayName = 'ChevronsRight'; +export default ChevronsRight; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/chevrons-up.js b/node_modules/react-feather/dist/icons/chevrons-up.js new file mode 100644 index 0000000..9b879bd --- /dev/null +++ b/node_modules/react-feather/dist/icons/chevrons-up.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ChevronsUp = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "17 11 12 6 7 11" + }), /*#__PURE__*/React.createElement("polyline", { + points: "17 18 12 13 7 18" + })); +}); +ChevronsUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ChevronsUp.displayName = 'ChevronsUp'; +export default ChevronsUp; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/chrome.js b/node_modules/react-feather/dist/icons/chrome.js new file mode 100644 index 0000000..e1defc0 --- /dev/null +++ b/node_modules/react-feather/dist/icons/chrome.js @@ -0,0 +1,57 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Chrome = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "21.17", + y1: "8", + x2: "12", + y2: "8" + }), /*#__PURE__*/React.createElement("line", { + x1: "3.95", + y1: "6.06", + x2: "8.54", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "10.88", + y1: "21.94", + x2: "15.46", + y2: "14" + })); +}); +Chrome.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Chrome.displayName = 'Chrome'; +export default Chrome; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/circle.js b/node_modules/react-feather/dist/icons/circle.js new file mode 100644 index 0000000..db10fe7 --- /dev/null +++ b/node_modules/react-feather/dist/icons/circle.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Circle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + })); +}); +Circle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Circle.displayName = 'Circle'; +export default Circle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/clipboard.js b/node_modules/react-feather/dist/icons/clipboard.js new file mode 100644 index 0000000..a4a5870 --- /dev/null +++ b/node_modules/react-feather/dist/icons/clipboard.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Clipboard = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" + }), /*#__PURE__*/React.createElement("rect", { + x: "8", + y: "2", + width: "8", + height: "4", + rx: "1", + ry: "1" + })); +}); +Clipboard.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Clipboard.displayName = 'Clipboard'; +export default Clipboard; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/clock.js b/node_modules/react-feather/dist/icons/clock.js new file mode 100644 index 0000000..9408202 --- /dev/null +++ b/node_modules/react-feather/dist/icons/clock.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Clock = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("polyline", { + points: "12 6 12 12 16 14" + })); +}); +Clock.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Clock.displayName = 'Clock'; +export default Clock; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/cloud-drizzle.js b/node_modules/react-feather/dist/icons/cloud-drizzle.js new file mode 100644 index 0000000..59047b9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/cloud-drizzle.js @@ -0,0 +1,66 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CloudDrizzle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "19", + x2: "8", + y2: "21" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "13", + x2: "8", + y2: "15" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "19", + x2: "16", + y2: "21" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "13", + x2: "16", + y2: "15" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "21", + x2: "12", + y2: "23" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "15", + x2: "12", + y2: "17" + }), /*#__PURE__*/React.createElement("path", { + d: "M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25" + })); +}); +CloudDrizzle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudDrizzle.displayName = 'CloudDrizzle'; +export default CloudDrizzle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/cloud-lightning.js b/node_modules/react-feather/dist/icons/cloud-lightning.js new file mode 100644 index 0000000..f749b84 --- /dev/null +++ b/node_modules/react-feather/dist/icons/cloud-lightning.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CloudLightning = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M19 16.9A5 5 0 0 0 18 7h-1.26a8 8 0 1 0-11.62 9" + }), /*#__PURE__*/React.createElement("polyline", { + points: "13 11 9 17 15 17 11 23" + })); +}); +CloudLightning.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudLightning.displayName = 'CloudLightning'; +export default CloudLightning; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/cloud-off.js b/node_modules/react-feather/dist/icons/cloud-off.js new file mode 100644 index 0000000..990ef80 --- /dev/null +++ b/node_modules/react-feather/dist/icons/cloud-off.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CloudOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M22.61 16.95A5 5 0 0 0 18 10h-1.26a8 8 0 0 0-7.05-6M5 5a8 8 0 0 0 4 15h9a5 5 0 0 0 1.7-.3" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +CloudOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudOff.displayName = 'CloudOff'; +export default CloudOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/cloud-rain.js b/node_modules/react-feather/dist/icons/cloud-rain.js new file mode 100644 index 0000000..3ba33a1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/cloud-rain.js @@ -0,0 +1,51 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CloudRain = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "13", + x2: "16", + y2: "21" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "13", + x2: "8", + y2: "21" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "15", + x2: "12", + y2: "23" + }), /*#__PURE__*/React.createElement("path", { + d: "M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25" + })); +}); +CloudRain.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudRain.displayName = 'CloudRain'; +export default CloudRain; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/cloud-snow.js b/node_modules/react-feather/dist/icons/cloud-snow.js new file mode 100644 index 0000000..f7a97ad --- /dev/null +++ b/node_modules/react-feather/dist/icons/cloud-snow.js @@ -0,0 +1,66 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CloudSnow = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M20 17.58A5 5 0 0 0 18 8h-1.26A8 8 0 1 0 4 16.25" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "16", + x2: "8.01", + y2: "16" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "20", + x2: "8.01", + y2: "20" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "18", + x2: "12.01", + y2: "18" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "22", + x2: "12.01", + y2: "22" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "16", + x2: "16.01", + y2: "16" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "20", + x2: "16.01", + y2: "20" + })); +}); +CloudSnow.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CloudSnow.displayName = 'CloudSnow'; +export default CloudSnow; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/cloud.js b/node_modules/react-feather/dist/icons/cloud.js new file mode 100644 index 0000000..26747ca --- /dev/null +++ b/node_modules/react-feather/dist/icons/cloud.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Cloud = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M18 10h-1.26A8 8 0 1 0 9 20h9a5 5 0 0 0 0-10z" + })); +}); +Cloud.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Cloud.displayName = 'Cloud'; +export default Cloud; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/code.js b/node_modules/react-feather/dist/icons/code.js new file mode 100644 index 0000000..fd0590e --- /dev/null +++ b/node_modules/react-feather/dist/icons/code.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Code = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "16 18 22 12 16 6" + }), /*#__PURE__*/React.createElement("polyline", { + points: "8 6 2 12 8 18" + })); +}); +Code.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Code.displayName = 'Code'; +export default Code; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/codepen.js b/node_modules/react-feather/dist/icons/codepen.js new file mode 100644 index 0000000..601fe31 --- /dev/null +++ b/node_modules/react-feather/dist/icons/codepen.js @@ -0,0 +1,50 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Codepen = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "12 2 22 8.5 22 15.5 12 22 2 15.5 2 8.5 12 2" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "22", + x2: "12", + y2: "15.5" + }), /*#__PURE__*/React.createElement("polyline", { + points: "22 8.5 12 15.5 2 8.5" + }), /*#__PURE__*/React.createElement("polyline", { + points: "2 15.5 12 8.5 22 15.5" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "8.5" + })); +}); +Codepen.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Codepen.displayName = 'Codepen'; +export default Codepen; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/codesandbox.js b/node_modules/react-feather/dist/icons/codesandbox.js new file mode 100644 index 0000000..d240b58 --- /dev/null +++ b/node_modules/react-feather/dist/icons/codesandbox.js @@ -0,0 +1,49 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Codesandbox = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "7.5 4.21 12 6.81 16.5 4.21" + }), /*#__PURE__*/React.createElement("polyline", { + points: "7.5 19.79 7.5 14.6 3 12" + }), /*#__PURE__*/React.createElement("polyline", { + points: "21 12 16.5 14.6 16.5 19.79" + }), /*#__PURE__*/React.createElement("polyline", { + points: "3.27 6.96 12 12.01 20.73 6.96" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "22.08", + x2: "12", + y2: "12" + })); +}); +Codesandbox.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Codesandbox.displayName = 'Codesandbox'; +export default Codesandbox; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/coffee.js b/node_modules/react-feather/dist/icons/coffee.js new file mode 100644 index 0000000..cb5822c --- /dev/null +++ b/node_modules/react-feather/dist/icons/coffee.js @@ -0,0 +1,53 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Coffee = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M18 8h1a4 4 0 0 1 0 8h-1" + }), /*#__PURE__*/React.createElement("path", { + d: "M2 8h16v9a4 4 0 0 1-4 4H6a4 4 0 0 1-4-4V8z" + }), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "1", + x2: "6", + y2: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "10", + y1: "1", + x2: "10", + y2: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "14", + y1: "1", + x2: "14", + y2: "4" + })); +}); +Coffee.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Coffee.displayName = 'Coffee'; +export default Coffee; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/columns.js b/node_modules/react-feather/dist/icons/columns.js new file mode 100644 index 0000000..ab96518 --- /dev/null +++ b/node_modules/react-feather/dist/icons/columns.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Columns = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M12 3h7a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-7m0-18H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7m0-18v18" + })); +}); +Columns.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Columns.displayName = 'Columns'; +export default Columns; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/command.js b/node_modules/react-feather/dist/icons/command.js new file mode 100644 index 0000000..c7501ac --- /dev/null +++ b/node_modules/react-feather/dist/icons/command.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Command = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M18 3a3 3 0 0 0-3 3v12a3 3 0 0 0 3 3 3 3 0 0 0 3-3 3 3 0 0 0-3-3H6a3 3 0 0 0-3 3 3 3 0 0 0 3 3 3 3 0 0 0 3-3V6a3 3 0 0 0-3-3 3 3 0 0 0-3 3 3 3 0 0 0 3 3h12a3 3 0 0 0 3-3 3 3 0 0 0-3-3z" + })); +}); +Command.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Command.displayName = 'Command'; +export default Command; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/compass.js b/node_modules/react-feather/dist/icons/compass.js new file mode 100644 index 0000000..89e3f18 --- /dev/null +++ b/node_modules/react-feather/dist/icons/compass.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Compass = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("polygon", { + points: "16.24 7.76 14.12 14.12 7.76 16.24 9.88 9.88 16.24 7.76" + })); +}); +Compass.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Compass.displayName = 'Compass'; +export default Compass; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/copy.js b/node_modules/react-feather/dist/icons/copy.js new file mode 100644 index 0000000..1dff55b --- /dev/null +++ b/node_modules/react-feather/dist/icons/copy.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Copy = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "9", + y: "9", + width: "13", + height: "13", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("path", { + d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" + })); +}); +Copy.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Copy.displayName = 'Copy'; +export default Copy; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/corner-down-left.js b/node_modules/react-feather/dist/icons/corner-down-left.js new file mode 100644 index 0000000..0d77c2c --- /dev/null +++ b/node_modules/react-feather/dist/icons/corner-down-left.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CornerDownLeft = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "9 10 4 15 9 20" + }), /*#__PURE__*/React.createElement("path", { + d: "M20 4v7a4 4 0 0 1-4 4H4" + })); +}); +CornerDownLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerDownLeft.displayName = 'CornerDownLeft'; +export default CornerDownLeft; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/corner-down-right.js b/node_modules/react-feather/dist/icons/corner-down-right.js new file mode 100644 index 0000000..5cb9778 --- /dev/null +++ b/node_modules/react-feather/dist/icons/corner-down-right.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CornerDownRight = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "15 10 20 15 15 20" + }), /*#__PURE__*/React.createElement("path", { + d: "M4 4v7a4 4 0 0 0 4 4h12" + })); +}); +CornerDownRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerDownRight.displayName = 'CornerDownRight'; +export default CornerDownRight; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/corner-left-down.js b/node_modules/react-feather/dist/icons/corner-left-down.js new file mode 100644 index 0000000..4501457 --- /dev/null +++ b/node_modules/react-feather/dist/icons/corner-left-down.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CornerLeftDown = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "14 15 9 20 4 15" + }), /*#__PURE__*/React.createElement("path", { + d: "M20 4h-7a4 4 0 0 0-4 4v12" + })); +}); +CornerLeftDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerLeftDown.displayName = 'CornerLeftDown'; +export default CornerLeftDown; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/corner-left-up.js b/node_modules/react-feather/dist/icons/corner-left-up.js new file mode 100644 index 0000000..f4d7010 --- /dev/null +++ b/node_modules/react-feather/dist/icons/corner-left-up.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CornerLeftUp = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "14 9 9 4 4 9" + }), /*#__PURE__*/React.createElement("path", { + d: "M20 20h-7a4 4 0 0 1-4-4V4" + })); +}); +CornerLeftUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerLeftUp.displayName = 'CornerLeftUp'; +export default CornerLeftUp; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/corner-right-down.js b/node_modules/react-feather/dist/icons/corner-right-down.js new file mode 100644 index 0000000..bbd0c8f --- /dev/null +++ b/node_modules/react-feather/dist/icons/corner-right-down.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CornerRightDown = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "10 15 15 20 20 15" + }), /*#__PURE__*/React.createElement("path", { + d: "M4 4h7a4 4 0 0 1 4 4v12" + })); +}); +CornerRightDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerRightDown.displayName = 'CornerRightDown'; +export default CornerRightDown; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/corner-right-up.js b/node_modules/react-feather/dist/icons/corner-right-up.js new file mode 100644 index 0000000..00bba46 --- /dev/null +++ b/node_modules/react-feather/dist/icons/corner-right-up.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CornerRightUp = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "10 9 15 4 20 9" + }), /*#__PURE__*/React.createElement("path", { + d: "M4 20h7a4 4 0 0 0 4-4V4" + })); +}); +CornerRightUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerRightUp.displayName = 'CornerRightUp'; +export default CornerRightUp; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/corner-up-left.js b/node_modules/react-feather/dist/icons/corner-up-left.js new file mode 100644 index 0000000..138e5cc --- /dev/null +++ b/node_modules/react-feather/dist/icons/corner-up-left.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CornerUpLeft = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "9 14 4 9 9 4" + }), /*#__PURE__*/React.createElement("path", { + d: "M20 20v-7a4 4 0 0 0-4-4H4" + })); +}); +CornerUpLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerUpLeft.displayName = 'CornerUpLeft'; +export default CornerUpLeft; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/corner-up-right.js b/node_modules/react-feather/dist/icons/corner-up-right.js new file mode 100644 index 0000000..d0fd9d5 --- /dev/null +++ b/node_modules/react-feather/dist/icons/corner-up-right.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CornerUpRight = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "15 14 20 9 15 4" + }), /*#__PURE__*/React.createElement("path", { + d: "M4 20v-7a4 4 0 0 1 4-4h12" + })); +}); +CornerUpRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CornerUpRight.displayName = 'CornerUpRight'; +export default CornerUpRight; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/cpu.js b/node_modules/react-feather/dist/icons/cpu.js new file mode 100644 index 0000000..d77847a --- /dev/null +++ b/node_modules/react-feather/dist/icons/cpu.js @@ -0,0 +1,86 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Cpu = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "4", + y: "4", + width: "16", + height: "16", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("rect", { + x: "9", + y: "9", + width: "6", + height: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "1", + x2: "9", + y2: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "1", + x2: "15", + y2: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "20", + x2: "9", + y2: "23" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "20", + x2: "15", + y2: "23" + }), /*#__PURE__*/React.createElement("line", { + x1: "20", + y1: "9", + x2: "23", + y2: "9" + }), /*#__PURE__*/React.createElement("line", { + x1: "20", + y1: "14", + x2: "23", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "9", + x2: "4", + y2: "9" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "14", + x2: "4", + y2: "14" + })); +}); +Cpu.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Cpu.displayName = 'Cpu'; +export default Cpu; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/credit-card.js b/node_modules/react-feather/dist/icons/credit-card.js new file mode 100644 index 0000000..8aced45 --- /dev/null +++ b/node_modules/react-feather/dist/icons/credit-card.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var CreditCard = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "1", + y: "4", + width: "22", + height: "16", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "10", + x2: "23", + y2: "10" + })); +}); +CreditCard.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +CreditCard.displayName = 'CreditCard'; +export default CreditCard; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/crop.js b/node_modules/react-feather/dist/icons/crop.js new file mode 100644 index 0000000..eb56bac --- /dev/null +++ b/node_modules/react-feather/dist/icons/crop.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Crop = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M6.13 1L6 16a2 2 0 0 0 2 2h15" + }), /*#__PURE__*/React.createElement("path", { + d: "M1 6.13L16 6a2 2 0 0 1 2 2v15" + })); +}); +Crop.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Crop.displayName = 'Crop'; +export default Crop; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/crosshair.js b/node_modules/react-feather/dist/icons/crosshair.js new file mode 100644 index 0000000..b14572c --- /dev/null +++ b/node_modules/react-feather/dist/icons/crosshair.js @@ -0,0 +1,58 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Crosshair = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "22", + y1: "12", + x2: "18", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "12", + x2: "2", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "6", + x2: "12", + y2: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "22", + x2: "12", + y2: "18" + })); +}); +Crosshair.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Crosshair.displayName = 'Crosshair'; +export default Crosshair; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/database.js b/node_modules/react-feather/dist/icons/database.js new file mode 100644 index 0000000..102fb49 --- /dev/null +++ b/node_modules/react-feather/dist/icons/database.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Database = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("ellipse", { + cx: "12", + cy: "5", + rx: "9", + ry: "3" + }), /*#__PURE__*/React.createElement("path", { + d: "M21 12c0 1.66-4 3-9 3s-9-1.34-9-3" + }), /*#__PURE__*/React.createElement("path", { + d: "M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5" + })); +}); +Database.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Database.displayName = 'Database'; +export default Database; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/delete.js b/node_modules/react-feather/dist/icons/delete.js new file mode 100644 index 0000000..1c64be2 --- /dev/null +++ b/node_modules/react-feather/dist/icons/delete.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Delete = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 4H8l-7 8 7 8h13a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2z" + }), /*#__PURE__*/React.createElement("line", { + x1: "18", + y1: "9", + x2: "12", + y2: "15" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "9", + x2: "18", + y2: "15" + })); +}); +Delete.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Delete.displayName = 'Delete'; +export default Delete; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/disc.js b/node_modules/react-feather/dist/icons/disc.js new file mode 100644 index 0000000..2bfd138 --- /dev/null +++ b/node_modules/react-feather/dist/icons/disc.js @@ -0,0 +1,42 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Disc = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "3" + })); +}); +Disc.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Disc.displayName = 'Disc'; +export default Disc; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/divide-circle.js b/node_modules/react-feather/dist/icons/divide-circle.js new file mode 100644 index 0000000..bb8b0ff --- /dev/null +++ b/node_modules/react-feather/dist/icons/divide-circle.js @@ -0,0 +1,53 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var DivideCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "16", + x2: "12", + y2: "16" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "8" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + })); +}); +DivideCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +DivideCircle.displayName = 'DivideCircle'; +export default DivideCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/divide-square.js b/node_modules/react-feather/dist/icons/divide-square.js new file mode 100644 index 0000000..44b90de --- /dev/null +++ b/node_modules/react-feather/dist/icons/divide-square.js @@ -0,0 +1,56 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var DivideSquare = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "16", + x2: "12", + y2: "16" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "8" + })); +}); +DivideSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +DivideSquare.displayName = 'DivideSquare'; +export default DivideSquare; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/divide.js b/node_modules/react-feather/dist/icons/divide.js new file mode 100644 index 0000000..f504756 --- /dev/null +++ b/node_modules/react-feather/dist/icons/divide.js @@ -0,0 +1,47 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Divide = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "6", + r: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "5", + y1: "12", + x2: "19", + y2: "12" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "18", + r: "2" + })); +}); +Divide.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Divide.displayName = 'Divide'; +export default Divide; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/dollar-sign.js b/node_modules/react-feather/dist/icons/dollar-sign.js new file mode 100644 index 0000000..4d9561c --- /dev/null +++ b/node_modules/react-feather/dist/icons/dollar-sign.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var DollarSign = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "1", + x2: "12", + y2: "23" + }), /*#__PURE__*/React.createElement("path", { + d: "M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6" + })); +}); +DollarSign.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +DollarSign.displayName = 'DollarSign'; +export default DollarSign; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/download-cloud.js b/node_modules/react-feather/dist/icons/download-cloud.js new file mode 100644 index 0000000..3f5ff0c --- /dev/null +++ b/node_modules/react-feather/dist/icons/download-cloud.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var DownloadCloud = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "8 17 12 21 16 17" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "12", + x2: "12", + y2: "21" + }), /*#__PURE__*/React.createElement("path", { + d: "M20.88 18.09A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.29" + })); +}); +DownloadCloud.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +DownloadCloud.displayName = 'DownloadCloud'; +export default DownloadCloud; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/download.js b/node_modules/react-feather/dist/icons/download.js new file mode 100644 index 0000000..ca36168 --- /dev/null +++ b/node_modules/react-feather/dist/icons/download.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Download = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" + }), /*#__PURE__*/React.createElement("polyline", { + points: "7 10 12 15 17 10" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "15", + x2: "12", + y2: "3" + })); +}); +Download.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Download.displayName = 'Download'; +export default Download; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/dribbble.js b/node_modules/react-feather/dist/icons/dribbble.js new file mode 100644 index 0000000..48856fe --- /dev/null +++ b/node_modules/react-feather/dist/icons/dribbble.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Dribbble = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("path", { + d: "M8.56 2.75c4.37 6.03 6.02 9.42 8.03 17.72m2.54-15.38c-3.72 4.35-8.94 5.66-16.88 5.85m19.5 1.9c-3.5-.93-6.63-.82-8.94 0-2.58.92-5.01 2.86-7.44 6.32" + })); +}); +Dribbble.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Dribbble.displayName = 'Dribbble'; +export default Dribbble; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/droplet.js b/node_modules/react-feather/dist/icons/droplet.js new file mode 100644 index 0000000..347e989 --- /dev/null +++ b/node_modules/react-feather/dist/icons/droplet.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Droplet = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M12 2.69l5.66 5.66a8 8 0 1 1-11.31 0z" + })); +}); +Droplet.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Droplet.displayName = 'Droplet'; +export default Droplet; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/edit-2.js b/node_modules/react-feather/dist/icons/edit-2.js new file mode 100644 index 0000000..568ebb6 --- /dev/null +++ b/node_modules/react-feather/dist/icons/edit-2.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Edit2 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z" + })); +}); +Edit2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Edit2.displayName = 'Edit2'; +export default Edit2; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/edit-3.js b/node_modules/react-feather/dist/icons/edit-3.js new file mode 100644 index 0000000..13d4720 --- /dev/null +++ b/node_modules/react-feather/dist/icons/edit-3.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Edit3 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M12 20h9" + }), /*#__PURE__*/React.createElement("path", { + d: "M16.5 3.5a2.121 2.121 0 0 1 3 3L7 19l-4 1 1-4L16.5 3.5z" + })); +}); +Edit3.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Edit3.displayName = 'Edit3'; +export default Edit3; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/edit.js b/node_modules/react-feather/dist/icons/edit.js new file mode 100644 index 0000000..bcac94e --- /dev/null +++ b/node_modules/react-feather/dist/icons/edit.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Edit = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" + }), /*#__PURE__*/React.createElement("path", { + d: "M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z" + })); +}); +Edit.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Edit.displayName = 'Edit'; +export default Edit; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/external-link.js b/node_modules/react-feather/dist/icons/external-link.js new file mode 100644 index 0000000..d313ca6 --- /dev/null +++ b/node_modules/react-feather/dist/icons/external-link.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ExternalLink = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" + }), /*#__PURE__*/React.createElement("polyline", { + points: "15 3 21 3 21 9" + }), /*#__PURE__*/React.createElement("line", { + x1: "10", + y1: "14", + x2: "21", + y2: "3" + })); +}); +ExternalLink.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ExternalLink.displayName = 'ExternalLink'; +export default ExternalLink; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/eye-off.js b/node_modules/react-feather/dist/icons/eye-off.js new file mode 100644 index 0000000..7678eb9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/eye-off.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var EyeOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M17.94 17.94A10.07 10.07 0 0 1 12 20c-7 0-11-8-11-8a18.45 18.45 0 0 1 5.06-5.94M9.9 4.24A9.12 9.12 0 0 1 12 4c7 0 11 8 11 8a18.5 18.5 0 0 1-2.16 3.19m-6.72-1.07a3 3 0 1 1-4.24-4.24" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +EyeOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +EyeOff.displayName = 'EyeOff'; +export default EyeOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/eye.js b/node_modules/react-feather/dist/icons/eye.js new file mode 100644 index 0000000..356c289 --- /dev/null +++ b/node_modules/react-feather/dist/icons/eye.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Eye = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "3" + })); +}); +Eye.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Eye.displayName = 'Eye'; +export default Eye; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/facebook.js b/node_modules/react-feather/dist/icons/facebook.js new file mode 100644 index 0000000..f7e7ab4 --- /dev/null +++ b/node_modules/react-feather/dist/icons/facebook.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Facebook = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M18 2h-3a5 5 0 0 0-5 5v3H7v4h3v8h4v-8h3l1-4h-4V7a1 1 0 0 1 1-1h3z" + })); +}); +Facebook.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Facebook.displayName = 'Facebook'; +export default Facebook; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/fast-forward.js b/node_modules/react-feather/dist/icons/fast-forward.js new file mode 100644 index 0000000..9632fad --- /dev/null +++ b/node_modules/react-feather/dist/icons/fast-forward.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var FastForward = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "13 19 22 12 13 5 13 19" + }), /*#__PURE__*/React.createElement("polygon", { + points: "2 19 11 12 2 5 2 19" + })); +}); +FastForward.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FastForward.displayName = 'FastForward'; +export default FastForward; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/feather.js b/node_modules/react-feather/dist/icons/feather.js new file mode 100644 index 0000000..684d01b --- /dev/null +++ b/node_modules/react-feather/dist/icons/feather.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Feather = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M20.24 12.24a6 6 0 0 0-8.49-8.49L5 10.5V19h8.5z" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "8", + x2: "2", + y2: "22" + }), /*#__PURE__*/React.createElement("line", { + x1: "17.5", + y1: "15", + x2: "9", + y2: "15" + })); +}); +Feather.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Feather.displayName = 'Feather'; +export default Feather; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/figma.js b/node_modules/react-feather/dist/icons/figma.js new file mode 100644 index 0000000..d843b6d --- /dev/null +++ b/node_modules/react-feather/dist/icons/figma.js @@ -0,0 +1,44 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Figma = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M5 5.5A3.5 3.5 0 0 1 8.5 2H12v7H8.5A3.5 3.5 0 0 1 5 5.5z" + }), /*#__PURE__*/React.createElement("path", { + d: "M12 2h3.5a3.5 3.5 0 1 1 0 7H12V2z" + }), /*#__PURE__*/React.createElement("path", { + d: "M12 12.5a3.5 3.5 0 1 1 7 0 3.5 3.5 0 1 1-7 0z" + }), /*#__PURE__*/React.createElement("path", { + d: "M5 19.5A3.5 3.5 0 0 1 8.5 16H12v3.5a3.5 3.5 0 1 1-7 0z" + }), /*#__PURE__*/React.createElement("path", { + d: "M5 12.5A3.5 3.5 0 0 1 8.5 9H12v7H8.5A3.5 3.5 0 0 1 5 12.5z" + })); +}); +Figma.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Figma.displayName = 'Figma'; +export default Figma; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/file-minus.js b/node_modules/react-feather/dist/icons/file-minus.js new file mode 100644 index 0000000..3b6fdeb --- /dev/null +++ b/node_modules/react-feather/dist/icons/file-minus.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var FileMinus = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "14 2 14 8 20 8" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "15", + x2: "15", + y2: "15" + })); +}); +FileMinus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FileMinus.displayName = 'FileMinus'; +export default FileMinus; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/file-plus.js b/node_modules/react-feather/dist/icons/file-plus.js new file mode 100644 index 0000000..2b84a29 --- /dev/null +++ b/node_modules/react-feather/dist/icons/file-plus.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var FilePlus = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "14 2 14 8 20 8" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "18", + x2: "12", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "15", + x2: "15", + y2: "15" + })); +}); +FilePlus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FilePlus.displayName = 'FilePlus'; +export default FilePlus; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/file-text.js b/node_modules/react-feather/dist/icons/file-text.js new file mode 100644 index 0000000..a8ddc47 --- /dev/null +++ b/node_modules/react-feather/dist/icons/file-text.js @@ -0,0 +1,50 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var FileText = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "14 2 14 8 20 8" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "13", + x2: "8", + y2: "13" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "17", + x2: "8", + y2: "17" + }), /*#__PURE__*/React.createElement("polyline", { + points: "10 9 9 9 8 9" + })); +}); +FileText.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FileText.displayName = 'FileText'; +export default FileText; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/file.js b/node_modules/react-feather/dist/icons/file.js new file mode 100644 index 0000000..b328704 --- /dev/null +++ b/node_modules/react-feather/dist/icons/file.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var File = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M13 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "13 2 13 9 20 9" + })); +}); +File.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +File.displayName = 'File'; +export default File; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/film.js b/node_modules/react-feather/dist/icons/film.js new file mode 100644 index 0000000..3733789 --- /dev/null +++ b/node_modules/react-feather/dist/icons/film.js @@ -0,0 +1,76 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Film = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "2", + y: "2", + width: "20", + height: "20", + rx: "2.18", + ry: "2.18" + }), /*#__PURE__*/React.createElement("line", { + x1: "7", + y1: "2", + x2: "7", + y2: "22" + }), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "2", + x2: "17", + y2: "22" + }), /*#__PURE__*/React.createElement("line", { + x1: "2", + y1: "12", + x2: "22", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "2", + y1: "7", + x2: "7", + y2: "7" + }), /*#__PURE__*/React.createElement("line", { + x1: "2", + y1: "17", + x2: "7", + y2: "17" + }), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "17", + x2: "22", + y2: "17" + }), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "7", + x2: "22", + y2: "7" + })); +}); +Film.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Film.displayName = 'Film'; +export default Film; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/filter.js b/node_modules/react-feather/dist/icons/filter.js new file mode 100644 index 0000000..14acc34 --- /dev/null +++ b/node_modules/react-feather/dist/icons/filter.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Filter = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3" + })); +}); +Filter.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Filter.displayName = 'Filter'; +export default Filter; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/flag.js b/node_modules/react-feather/dist/icons/flag.js new file mode 100644 index 0000000..ebffe5a --- /dev/null +++ b/node_modules/react-feather/dist/icons/flag.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Flag = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M4 15s1-1 4-1 5 2 8 2 4-1 4-1V3s-1 1-4 1-5-2-8-2-4 1-4 1z" + }), /*#__PURE__*/React.createElement("line", { + x1: "4", + y1: "22", + x2: "4", + y2: "15" + })); +}); +Flag.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Flag.displayName = 'Flag'; +export default Flag; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/folder-minus.js b/node_modules/react-feather/dist/icons/folder-minus.js new file mode 100644 index 0000000..99c22f6 --- /dev/null +++ b/node_modules/react-feather/dist/icons/folder-minus.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var FolderMinus = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "14", + x2: "15", + y2: "14" + })); +}); +FolderMinus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FolderMinus.displayName = 'FolderMinus'; +export default FolderMinus; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/folder-plus.js b/node_modules/react-feather/dist/icons/folder-plus.js new file mode 100644 index 0000000..dbb37b9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/folder-plus.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var FolderPlus = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "11", + x2: "12", + y2: "17" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "14", + x2: "15", + y2: "14" + })); +}); +FolderPlus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +FolderPlus.displayName = 'FolderPlus'; +export default FolderPlus; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/folder.js b/node_modules/react-feather/dist/icons/folder.js new file mode 100644 index 0000000..0c7b493 --- /dev/null +++ b/node_modules/react-feather/dist/icons/folder.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Folder = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z" + })); +}); +Folder.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Folder.displayName = 'Folder'; +export default Folder; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/framer.js b/node_modules/react-feather/dist/icons/framer.js new file mode 100644 index 0000000..1553b56 --- /dev/null +++ b/node_modules/react-feather/dist/icons/framer.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Framer = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M5 16V9h14V2H5l14 14h-7m-7 0l7 7v-7m-7 0h7" + })); +}); +Framer.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Framer.displayName = 'Framer'; +export default Framer; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/frown.js b/node_modules/react-feather/dist/icons/frown.js new file mode 100644 index 0000000..0498e12 --- /dev/null +++ b/node_modules/react-feather/dist/icons/frown.js @@ -0,0 +1,50 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Frown = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("path", { + d: "M16 16s-1.5-2-4-2-4 2-4 2" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "9", + x2: "9.01", + y2: "9" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "9", + x2: "15.01", + y2: "9" + })); +}); +Frown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Frown.displayName = 'Frown'; +export default Frown; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/gift.js b/node_modules/react-feather/dist/icons/gift.js new file mode 100644 index 0000000..78feced --- /dev/null +++ b/node_modules/react-feather/dist/icons/gift.js @@ -0,0 +1,50 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Gift = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "20 12 20 22 4 22 4 12" + }), /*#__PURE__*/React.createElement("rect", { + x: "2", + y: "7", + width: "20", + height: "5" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "22", + x2: "12", + y2: "7" + }), /*#__PURE__*/React.createElement("path", { + d: "M12 7H7.5a2.5 2.5 0 0 1 0-5C11 2 12 7 12 7z" + }), /*#__PURE__*/React.createElement("path", { + d: "M12 7h4.5a2.5 2.5 0 0 0 0-5C13 2 12 7 12 7z" + })); +}); +Gift.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Gift.displayName = 'Gift'; +export default Gift; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/git-branch.js b/node_modules/react-feather/dist/icons/git-branch.js new file mode 100644 index 0000000..dde3196 --- /dev/null +++ b/node_modules/react-feather/dist/icons/git-branch.js @@ -0,0 +1,49 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var GitBranch = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "3", + x2: "6", + y2: "15" + }), /*#__PURE__*/React.createElement("circle", { + cx: "18", + cy: "6", + r: "3" + }), /*#__PURE__*/React.createElement("circle", { + cx: "6", + cy: "18", + r: "3" + }), /*#__PURE__*/React.createElement("path", { + d: "M18 9a9 9 0 0 1-9 9" + })); +}); +GitBranch.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitBranch.displayName = 'GitBranch'; +export default GitBranch; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/git-commit.js b/node_modules/react-feather/dist/icons/git-commit.js new file mode 100644 index 0000000..70f27bd --- /dev/null +++ b/node_modules/react-feather/dist/icons/git-commit.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var GitCommit = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "1.05", + y1: "12", + x2: "7", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "17.01", + y1: "12", + x2: "22.96", + y2: "12" + })); +}); +GitCommit.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitCommit.displayName = 'GitCommit'; +export default GitCommit; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/git-merge.js b/node_modules/react-feather/dist/icons/git-merge.js new file mode 100644 index 0000000..639762e --- /dev/null +++ b/node_modules/react-feather/dist/icons/git-merge.js @@ -0,0 +1,44 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var GitMerge = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "18", + cy: "18", + r: "3" + }), /*#__PURE__*/React.createElement("circle", { + cx: "6", + cy: "6", + r: "3" + }), /*#__PURE__*/React.createElement("path", { + d: "M6 21V9a9 9 0 0 0 9 9" + })); +}); +GitMerge.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitMerge.displayName = 'GitMerge'; +export default GitMerge; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/git-pull-request.js b/node_modules/react-feather/dist/icons/git-pull-request.js new file mode 100644 index 0000000..1b2f152 --- /dev/null +++ b/node_modules/react-feather/dist/icons/git-pull-request.js @@ -0,0 +1,49 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var GitPullRequest = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "18", + cy: "18", + r: "3" + }), /*#__PURE__*/React.createElement("circle", { + cx: "6", + cy: "6", + r: "3" + }), /*#__PURE__*/React.createElement("path", { + d: "M13 6h3a2 2 0 0 1 2 2v7" + }), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "9", + x2: "6", + y2: "21" + })); +}); +GitPullRequest.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitPullRequest.displayName = 'GitPullRequest'; +export default GitPullRequest; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/github.js b/node_modules/react-feather/dist/icons/github.js new file mode 100644 index 0000000..f20e0aa --- /dev/null +++ b/node_modules/react-feather/dist/icons/github.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var GitHub = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M9 19c-5 1.5-5-2.5-7-3m14 6v-3.87a3.37 3.37 0 0 0-.94-2.61c3.14-.35 6.44-1.54 6.44-7A5.44 5.44 0 0 0 20 4.77 5.07 5.07 0 0 0 19.91 1S18.73.65 16 2.48a13.38 13.38 0 0 0-7 0C6.27.65 5.09 1 5.09 1A5.07 5.07 0 0 0 5 4.77a5.44 5.44 0 0 0-1.5 3.78c0 5.42 3.3 6.61 6.44 7A3.37 3.37 0 0 0 9 18.13V22" + })); +}); +GitHub.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +GitHub.displayName = 'GitHub'; +export default GitHub; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/gitlab.js b/node_modules/react-feather/dist/icons/gitlab.js new file mode 100644 index 0000000..0cdfea6 --- /dev/null +++ b/node_modules/react-feather/dist/icons/gitlab.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Gitlab = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M22.65 14.39L12 22.13 1.35 14.39a.84.84 0 0 1-.3-.94l1.22-3.78 2.44-7.51A.42.42 0 0 1 4.82 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.49h8.1l2.44-7.51A.42.42 0 0 1 18.6 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.51L23 13.45a.84.84 0 0 1-.35.94z" + })); +}); +Gitlab.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Gitlab.displayName = 'Gitlab'; +export default Gitlab; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/globe.js b/node_modules/react-feather/dist/icons/globe.js new file mode 100644 index 0000000..d0599ee --- /dev/null +++ b/node_modules/react-feather/dist/icons/globe.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Globe = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "2", + y1: "12", + x2: "22", + y2: "12" + }), /*#__PURE__*/React.createElement("path", { + d: "M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z" + })); +}); +Globe.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Globe.displayName = 'Globe'; +export default Globe; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/grid.js b/node_modules/react-feather/dist/icons/grid.js new file mode 100644 index 0000000..e556ade --- /dev/null +++ b/node_modules/react-feather/dist/icons/grid.js @@ -0,0 +1,54 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Grid = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "7", + height: "7" + }), /*#__PURE__*/React.createElement("rect", { + x: "14", + y: "3", + width: "7", + height: "7" + }), /*#__PURE__*/React.createElement("rect", { + x: "14", + y: "14", + width: "7", + height: "7" + }), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "14", + width: "7", + height: "7" + })); +}); +Grid.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Grid.displayName = 'Grid'; +export default Grid; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/hard-drive.js b/node_modules/react-feather/dist/icons/hard-drive.js new file mode 100644 index 0000000..0b56ad9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/hard-drive.js @@ -0,0 +1,51 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var HardDrive = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "22", + y1: "12", + x2: "2", + y2: "12" + }), /*#__PURE__*/React.createElement("path", { + d: "M5.45 5.11L2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z" + }), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "16", + x2: "6.01", + y2: "16" + }), /*#__PURE__*/React.createElement("line", { + x1: "10", + y1: "16", + x2: "10.01", + y2: "16" + })); +}); +HardDrive.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +HardDrive.displayName = 'HardDrive'; +export default HardDrive; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/hash.js b/node_modules/react-feather/dist/icons/hash.js new file mode 100644 index 0000000..0539736 --- /dev/null +++ b/node_modules/react-feather/dist/icons/hash.js @@ -0,0 +1,54 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Hash = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "4", + y1: "9", + x2: "20", + y2: "9" + }), /*#__PURE__*/React.createElement("line", { + x1: "4", + y1: "15", + x2: "20", + y2: "15" + }), /*#__PURE__*/React.createElement("line", { + x1: "10", + y1: "3", + x2: "8", + y2: "21" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "3", + x2: "14", + y2: "21" + })); +}); +Hash.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Hash.displayName = 'Hash'; +export default Hash; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/headphones.js b/node_modules/react-feather/dist/icons/headphones.js new file mode 100644 index 0000000..6862431 --- /dev/null +++ b/node_modules/react-feather/dist/icons/headphones.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Headphones = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M3 18v-6a9 9 0 0 1 18 0v6" + }), /*#__PURE__*/React.createElement("path", { + d: "M21 19a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3zM3 19a2 2 0 0 0 2 2h1a2 2 0 0 0 2-2v-3a2 2 0 0 0-2-2H3z" + })); +}); +Headphones.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Headphones.displayName = 'Headphones'; +export default Headphones; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/heart.js b/node_modules/react-feather/dist/icons/heart.js new file mode 100644 index 0000000..b687ab5 --- /dev/null +++ b/node_modules/react-feather/dist/icons/heart.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Heart = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z" + })); +}); +Heart.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Heart.displayName = 'Heart'; +export default Heart; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/help-circle.js b/node_modules/react-feather/dist/icons/help-circle.js new file mode 100644 index 0000000..6f4ddb8 --- /dev/null +++ b/node_modules/react-feather/dist/icons/help-circle.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var HelpCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("path", { + d: "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "17", + x2: "12.01", + y2: "17" + })); +}); +HelpCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +HelpCircle.displayName = 'HelpCircle'; +export default HelpCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/hexagon.js b/node_modules/react-feather/dist/icons/hexagon.js new file mode 100644 index 0000000..882454a --- /dev/null +++ b/node_modules/react-feather/dist/icons/hexagon.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Hexagon = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" + })); +}); +Hexagon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Hexagon.displayName = 'Hexagon'; +export default Hexagon; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/home.js b/node_modules/react-feather/dist/icons/home.js new file mode 100644 index 0000000..ca32953 --- /dev/null +++ b/node_modules/react-feather/dist/icons/home.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Home = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "9 22 9 12 15 12 15 22" + })); +}); +Home.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Home.displayName = 'Home'; +export default Home; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/image.js b/node_modules/react-feather/dist/icons/image.js new file mode 100644 index 0000000..4089b7e --- /dev/null +++ b/node_modules/react-feather/dist/icons/image.js @@ -0,0 +1,47 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Image = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("circle", { + cx: "8.5", + cy: "8.5", + r: "1.5" + }), /*#__PURE__*/React.createElement("polyline", { + points: "21 15 16 10 5 21" + })); +}); +Image.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Image.displayName = 'Image'; +export default Image; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/inbox.js b/node_modules/react-feather/dist/icons/inbox.js new file mode 100644 index 0000000..267ae99 --- /dev/null +++ b/node_modules/react-feather/dist/icons/inbox.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Inbox = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "22 12 16 12 14 15 10 15 8 12 2 12" + }), /*#__PURE__*/React.createElement("path", { + d: "M5.45 5.11L2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z" + })); +}); +Inbox.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Inbox.displayName = 'Inbox'; +export default Inbox; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/info.js b/node_modules/react-feather/dist/icons/info.js new file mode 100644 index 0000000..9f783e9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/info.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Info = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "16", + x2: "12", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "8", + x2: "12.01", + y2: "8" + })); +}); +Info.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Info.displayName = 'Info'; +export default Info; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/instagram.js b/node_modules/react-feather/dist/icons/instagram.js new file mode 100644 index 0000000..6cc2763 --- /dev/null +++ b/node_modules/react-feather/dist/icons/instagram.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Instagram = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "2", + y: "2", + width: "20", + height: "20", + rx: "5", + ry: "5" + }), /*#__PURE__*/React.createElement("path", { + d: "M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z" + }), /*#__PURE__*/React.createElement("line", { + x1: "17.5", + y1: "6.5", + x2: "17.51", + y2: "6.5" + })); +}); +Instagram.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Instagram.displayName = 'Instagram'; +export default Instagram; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/italic.js b/node_modules/react-feather/dist/icons/italic.js new file mode 100644 index 0000000..f356b7a --- /dev/null +++ b/node_modules/react-feather/dist/icons/italic.js @@ -0,0 +1,49 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Italic = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "19", + y1: "4", + x2: "10", + y2: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "14", + y1: "20", + x2: "5", + y2: "20" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "4", + x2: "9", + y2: "20" + })); +}); +Italic.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Italic.displayName = 'Italic'; +export default Italic; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/key.js b/node_modules/react-feather/dist/icons/key.js new file mode 100644 index 0000000..6ee680d --- /dev/null +++ b/node_modules/react-feather/dist/icons/key.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Key = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 2l-2 2m-7.61 7.61a5.5 5.5 0 1 1-7.778 7.778 5.5 5.5 0 0 1 7.777-7.777zm0 0L15.5 7.5m0 0l3 3L22 7l-3-3m-3.5 3.5L19 4" + })); +}); +Key.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Key.displayName = 'Key'; +export default Key; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/layers.js b/node_modules/react-feather/dist/icons/layers.js new file mode 100644 index 0000000..ba827d3 --- /dev/null +++ b/node_modules/react-feather/dist/icons/layers.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Layers = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "12 2 2 7 12 12 22 7 12 2" + }), /*#__PURE__*/React.createElement("polyline", { + points: "2 17 12 22 22 17" + }), /*#__PURE__*/React.createElement("polyline", { + points: "2 12 12 17 22 12" + })); +}); +Layers.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Layers.displayName = 'Layers'; +export default Layers; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/layout.js b/node_modules/react-feather/dist/icons/layout.js new file mode 100644 index 0000000..cf72abe --- /dev/null +++ b/node_modules/react-feather/dist/icons/layout.js @@ -0,0 +1,51 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Layout = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "9", + x2: "21", + y2: "9" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "21", + x2: "9", + y2: "9" + })); +}); +Layout.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Layout.displayName = 'Layout'; +export default Layout; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/life-buoy.js b/node_modules/react-feather/dist/icons/life-buoy.js new file mode 100644 index 0000000..5accd05 --- /dev/null +++ b/node_modules/react-feather/dist/icons/life-buoy.js @@ -0,0 +1,67 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var LifeBuoy = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "4.93", + y1: "4.93", + x2: "9.17", + y2: "9.17" + }), /*#__PURE__*/React.createElement("line", { + x1: "14.83", + y1: "14.83", + x2: "19.07", + y2: "19.07" + }), /*#__PURE__*/React.createElement("line", { + x1: "14.83", + y1: "9.17", + x2: "19.07", + y2: "4.93" + }), /*#__PURE__*/React.createElement("line", { + x1: "14.83", + y1: "9.17", + x2: "18.36", + y2: "5.64" + }), /*#__PURE__*/React.createElement("line", { + x1: "4.93", + y1: "19.07", + x2: "9.17", + y2: "14.83" + })); +}); +LifeBuoy.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +LifeBuoy.displayName = 'LifeBuoy'; +export default LifeBuoy; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/link-2.js b/node_modules/react-feather/dist/icons/link-2.js new file mode 100644 index 0000000..dd15a0c --- /dev/null +++ b/node_modules/react-feather/dist/icons/link-2.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Link2 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +Link2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Link2.displayName = 'Link2'; +export default Link2; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/link.js b/node_modules/react-feather/dist/icons/link.js new file mode 100644 index 0000000..b338ce0 --- /dev/null +++ b/node_modules/react-feather/dist/icons/link.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Link = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71" + }), /*#__PURE__*/React.createElement("path", { + d: "M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71" + })); +}); +Link.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Link.displayName = 'Link'; +export default Link; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/linkedin.js b/node_modules/react-feather/dist/icons/linkedin.js new file mode 100644 index 0000000..087a060 --- /dev/null +++ b/node_modules/react-feather/dist/icons/linkedin.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Linkedin = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M16 8a6 6 0 0 1 6 6v7h-4v-7a2 2 0 0 0-2-2 2 2 0 0 0-2 2v7h-4v-7a6 6 0 0 1 6-6z" + }), /*#__PURE__*/React.createElement("rect", { + x: "2", + y: "9", + width: "4", + height: "12" + }), /*#__PURE__*/React.createElement("circle", { + cx: "4", + cy: "4", + r: "2" + })); +}); +Linkedin.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Linkedin.displayName = 'Linkedin'; +export default Linkedin; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/list.js b/node_modules/react-feather/dist/icons/list.js new file mode 100644 index 0000000..d37eeb0 --- /dev/null +++ b/node_modules/react-feather/dist/icons/list.js @@ -0,0 +1,64 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var List = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "6", + x2: "21", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "12", + x2: "21", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "18", + x2: "21", + y2: "18" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "6", + x2: "3.01", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "12", + x2: "3.01", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "18", + x2: "3.01", + y2: "18" + })); +}); +List.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +List.displayName = 'List'; +export default List; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/loader.js b/node_modules/react-feather/dist/icons/loader.js new file mode 100644 index 0000000..46d23d3 --- /dev/null +++ b/node_modules/react-feather/dist/icons/loader.js @@ -0,0 +1,74 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Loader = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "18", + x2: "12", + y2: "22" + }), /*#__PURE__*/React.createElement("line", { + x1: "4.93", + y1: "4.93", + x2: "7.76", + y2: "7.76" + }), /*#__PURE__*/React.createElement("line", { + x1: "16.24", + y1: "16.24", + x2: "19.07", + y2: "19.07" + }), /*#__PURE__*/React.createElement("line", { + x1: "2", + y1: "12", + x2: "6", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "18", + y1: "12", + x2: "22", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "4.93", + y1: "19.07", + x2: "7.76", + y2: "16.24" + }), /*#__PURE__*/React.createElement("line", { + x1: "16.24", + y1: "7.76", + x2: "19.07", + y2: "4.93" + })); +}); +Loader.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Loader.displayName = 'Loader'; +export default Loader; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/lock.js b/node_modules/react-feather/dist/icons/lock.js new file mode 100644 index 0000000..b886f14 --- /dev/null +++ b/node_modules/react-feather/dist/icons/lock.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Lock = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "11", + width: "18", + height: "11", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("path", { + d: "M7 11V7a5 5 0 0 1 10 0v4" + })); +}); +Lock.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Lock.displayName = 'Lock'; +export default Lock; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/log-in.js b/node_modules/react-feather/dist/icons/log-in.js new file mode 100644 index 0000000..15f1ae2 --- /dev/null +++ b/node_modules/react-feather/dist/icons/log-in.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var LogIn = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4" + }), /*#__PURE__*/React.createElement("polyline", { + points: "10 17 15 12 10 7" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "12", + x2: "3", + y2: "12" + })); +}); +LogIn.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +LogIn.displayName = 'LogIn'; +export default LogIn; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/log-out.js b/node_modules/react-feather/dist/icons/log-out.js new file mode 100644 index 0000000..f0518ab --- /dev/null +++ b/node_modules/react-feather/dist/icons/log-out.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var LogOut = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4" + }), /*#__PURE__*/React.createElement("polyline", { + points: "16 17 21 12 16 7" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "12", + x2: "9", + y2: "12" + })); +}); +LogOut.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +LogOut.displayName = 'LogOut'; +export default LogOut; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/mail.js b/node_modules/react-feather/dist/icons/mail.js new file mode 100644 index 0000000..780e5fd --- /dev/null +++ b/node_modules/react-feather/dist/icons/mail.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Mail = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "22,6 12,13 2,6" + })); +}); +Mail.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Mail.displayName = 'Mail'; +export default Mail; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/map-pin.js b/node_modules/react-feather/dist/icons/map-pin.js new file mode 100644 index 0000000..d3199d9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/map-pin.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var MapPin = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 10c0 7-9 13-9 13s-9-6-9-13a9 9 0 0 1 18 0z" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "10", + r: "3" + })); +}); +MapPin.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MapPin.displayName = 'MapPin'; +export default MapPin; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/map.js b/node_modules/react-feather/dist/icons/map.js new file mode 100644 index 0000000..cdf6beb --- /dev/null +++ b/node_modules/react-feather/dist/icons/map.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Map = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "2", + x2: "8", + y2: "18" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "6", + x2: "16", + y2: "22" + })); +}); +Map.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Map.displayName = 'Map'; +export default Map; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/maximize-2.js b/node_modules/react-feather/dist/icons/maximize-2.js new file mode 100644 index 0000000..b408115 --- /dev/null +++ b/node_modules/react-feather/dist/icons/maximize-2.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Maximize2 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "15 3 21 3 21 9" + }), /*#__PURE__*/React.createElement("polyline", { + points: "9 21 3 21 3 15" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "3", + x2: "14", + y2: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "21", + x2: "10", + y2: "14" + })); +}); +Maximize2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Maximize2.displayName = 'Maximize2'; +export default Maximize2; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/maximize.js b/node_modules/react-feather/dist/icons/maximize.js new file mode 100644 index 0000000..3e51996 --- /dev/null +++ b/node_modules/react-feather/dist/icons/maximize.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Maximize = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3" + })); +}); +Maximize.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Maximize.displayName = 'Maximize'; +export default Maximize; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/meh.js b/node_modules/react-feather/dist/icons/meh.js new file mode 100644 index 0000000..c3d253e --- /dev/null +++ b/node_modules/react-feather/dist/icons/meh.js @@ -0,0 +1,53 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Meh = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "15", + x2: "16", + y2: "15" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "9", + x2: "9.01", + y2: "9" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "9", + x2: "15.01", + y2: "9" + })); +}); +Meh.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Meh.displayName = 'Meh'; +export default Meh; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/menu.js b/node_modules/react-feather/dist/icons/menu.js new file mode 100644 index 0000000..6f52df0 --- /dev/null +++ b/node_modules/react-feather/dist/icons/menu.js @@ -0,0 +1,49 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Menu = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "12", + x2: "21", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "6", + x2: "21", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "18", + x2: "21", + y2: "18" + })); +}); +Menu.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Menu.displayName = 'Menu'; +export default Menu; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/message-circle.js b/node_modules/react-feather/dist/icons/message-circle.js new file mode 100644 index 0000000..27d4d43 --- /dev/null +++ b/node_modules/react-feather/dist/icons/message-circle.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var MessageCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z" + })); +}); +MessageCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MessageCircle.displayName = 'MessageCircle'; +export default MessageCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/message-square.js b/node_modules/react-feather/dist/icons/message-square.js new file mode 100644 index 0000000..2702bd6 --- /dev/null +++ b/node_modules/react-feather/dist/icons/message-square.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var MessageSquare = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" + })); +}); +MessageSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MessageSquare.displayName = 'MessageSquare'; +export default MessageSquare; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/mic-off.js b/node_modules/react-feather/dist/icons/mic-off.js new file mode 100644 index 0000000..3852e5a --- /dev/null +++ b/node_modules/react-feather/dist/icons/mic-off.js @@ -0,0 +1,53 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var MicOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + }), /*#__PURE__*/React.createElement("path", { + d: "M9 9v3a3 3 0 0 0 5.12 2.12M15 9.34V4a3 3 0 0 0-5.94-.6" + }), /*#__PURE__*/React.createElement("path", { + d: "M17 16.95A7 7 0 0 1 5 12v-2m14 0v2a7 7 0 0 1-.11 1.23" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "19", + x2: "12", + y2: "23" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "23", + x2: "16", + y2: "23" + })); +}); +MicOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MicOff.displayName = 'MicOff'; +export default MicOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/mic.js b/node_modules/react-feather/dist/icons/mic.js new file mode 100644 index 0000000..5025049 --- /dev/null +++ b/node_modules/react-feather/dist/icons/mic.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Mic = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z" + }), /*#__PURE__*/React.createElement("path", { + d: "M19 10v2a7 7 0 0 1-14 0v-2" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "19", + x2: "12", + y2: "23" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "23", + x2: "16", + y2: "23" + })); +}); +Mic.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Mic.displayName = 'Mic'; +export default Mic; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/minimize-2.js b/node_modules/react-feather/dist/icons/minimize-2.js new file mode 100644 index 0000000..1c68bbd --- /dev/null +++ b/node_modules/react-feather/dist/icons/minimize-2.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Minimize2 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "4 14 10 14 10 20" + }), /*#__PURE__*/React.createElement("polyline", { + points: "20 10 14 10 14 4" + }), /*#__PURE__*/React.createElement("line", { + x1: "14", + y1: "10", + x2: "21", + y2: "3" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "21", + x2: "10", + y2: "14" + })); +}); +Minimize2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Minimize2.displayName = 'Minimize2'; +export default Minimize2; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/minimize.js b/node_modules/react-feather/dist/icons/minimize.js new file mode 100644 index 0000000..7eca0cd --- /dev/null +++ b/node_modules/react-feather/dist/icons/minimize.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Minimize = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M8 3v3a2 2 0 0 1-2 2H3m18 0h-3a2 2 0 0 1-2-2V3m0 18v-3a2 2 0 0 1 2-2h3M3 16h3a2 2 0 0 1 2 2v3" + })); +}); +Minimize.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Minimize.displayName = 'Minimize'; +export default Minimize; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/minus-circle.js b/node_modules/react-feather/dist/icons/minus-circle.js new file mode 100644 index 0000000..9375693 --- /dev/null +++ b/node_modules/react-feather/dist/icons/minus-circle.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var MinusCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +MinusCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MinusCircle.displayName = 'MinusCircle'; +export default MinusCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/minus-square.js b/node_modules/react-feather/dist/icons/minus-square.js new file mode 100644 index 0000000..f42bf02 --- /dev/null +++ b/node_modules/react-feather/dist/icons/minus-square.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var MinusSquare = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +MinusSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MinusSquare.displayName = 'MinusSquare'; +export default MinusSquare; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/minus.js b/node_modules/react-feather/dist/icons/minus.js new file mode 100644 index 0000000..a8f6a04 --- /dev/null +++ b/node_modules/react-feather/dist/icons/minus.js @@ -0,0 +1,39 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Minus = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "5", + y1: "12", + x2: "19", + y2: "12" + })); +}); +Minus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Minus.displayName = 'Minus'; +export default Minus; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/monitor.js b/node_modules/react-feather/dist/icons/monitor.js new file mode 100644 index 0000000..857680b --- /dev/null +++ b/node_modules/react-feather/dist/icons/monitor.js @@ -0,0 +1,51 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Monitor = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "2", + y: "3", + width: "20", + height: "14", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "21", + x2: "16", + y2: "21" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "17", + x2: "12", + y2: "21" + })); +}); +Monitor.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Monitor.displayName = 'Monitor'; +export default Monitor; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/moon.js b/node_modules/react-feather/dist/icons/moon.js new file mode 100644 index 0000000..0d9dfc9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/moon.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Moon = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z" + })); +}); +Moon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Moon.displayName = 'Moon'; +export default Moon; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/more-horizontal.js b/node_modules/react-feather/dist/icons/more-horizontal.js new file mode 100644 index 0000000..06ecb18 --- /dev/null +++ b/node_modules/react-feather/dist/icons/more-horizontal.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var MoreHorizontal = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "1" + }), /*#__PURE__*/React.createElement("circle", { + cx: "19", + cy: "12", + r: "1" + }), /*#__PURE__*/React.createElement("circle", { + cx: "5", + cy: "12", + r: "1" + })); +}); +MoreHorizontal.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MoreHorizontal.displayName = 'MoreHorizontal'; +export default MoreHorizontal; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/more-vertical.js b/node_modules/react-feather/dist/icons/more-vertical.js new file mode 100644 index 0000000..ba6892e --- /dev/null +++ b/node_modules/react-feather/dist/icons/more-vertical.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var MoreVertical = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "1" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "5", + r: "1" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "19", + r: "1" + })); +}); +MoreVertical.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MoreVertical.displayName = 'MoreVertical'; +export default MoreVertical; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/mouse-pointer.js b/node_modules/react-feather/dist/icons/mouse-pointer.js new file mode 100644 index 0000000..921897c --- /dev/null +++ b/node_modules/react-feather/dist/icons/mouse-pointer.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var MousePointer = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M3 3l7.07 16.97 2.51-7.39 7.39-2.51L3 3z" + }), /*#__PURE__*/React.createElement("path", { + d: "M13 13l6 6" + })); +}); +MousePointer.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +MousePointer.displayName = 'MousePointer'; +export default MousePointer; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/move.js b/node_modules/react-feather/dist/icons/move.js new file mode 100644 index 0000000..5fcdf1d --- /dev/null +++ b/node_modules/react-feather/dist/icons/move.js @@ -0,0 +1,52 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Move = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "5 9 2 12 5 15" + }), /*#__PURE__*/React.createElement("polyline", { + points: "9 5 12 2 15 5" + }), /*#__PURE__*/React.createElement("polyline", { + points: "15 19 12 22 9 19" + }), /*#__PURE__*/React.createElement("polyline", { + points: "19 9 22 12 19 15" + }), /*#__PURE__*/React.createElement("line", { + x1: "2", + y1: "12", + x2: "22", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "22" + })); +}); +Move.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Move.displayName = 'Move'; +export default Move; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/music.js b/node_modules/react-feather/dist/icons/music.js new file mode 100644 index 0000000..76f53f8 --- /dev/null +++ b/node_modules/react-feather/dist/icons/music.js @@ -0,0 +1,44 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Music = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M9 18V5l12-2v13" + }), /*#__PURE__*/React.createElement("circle", { + cx: "6", + cy: "18", + r: "3" + }), /*#__PURE__*/React.createElement("circle", { + cx: "18", + cy: "16", + r: "3" + })); +}); +Music.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Music.displayName = 'Music'; +export default Music; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/navigation-2.js b/node_modules/react-feather/dist/icons/navigation-2.js new file mode 100644 index 0000000..f37eb27 --- /dev/null +++ b/node_modules/react-feather/dist/icons/navigation-2.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Navigation2 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "12 2 19 21 12 17 5 21 12 2" + })); +}); +Navigation2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Navigation2.displayName = 'Navigation2'; +export default Navigation2; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/navigation.js b/node_modules/react-feather/dist/icons/navigation.js new file mode 100644 index 0000000..4111fd1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/navigation.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Navigation = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "3 11 22 2 13 21 11 13 3 11" + })); +}); +Navigation.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Navigation.displayName = 'Navigation'; +export default Navigation; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/octagon.js b/node_modules/react-feather/dist/icons/octagon.js new file mode 100644 index 0000000..33bd6d1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/octagon.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Octagon = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2" + })); +}); +Octagon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Octagon.displayName = 'Octagon'; +export default Octagon; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/package.js b/node_modules/react-feather/dist/icons/package.js new file mode 100644 index 0000000..a50ddef --- /dev/null +++ b/node_modules/react-feather/dist/icons/package.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Package = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "16.5", + y1: "9.4", + x2: "7.5", + y2: "4.21" + }), /*#__PURE__*/React.createElement("path", { + d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "3.27 6.96 12 12.01 20.73 6.96" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "22.08", + x2: "12", + y2: "12" + })); +}); +Package.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Package.displayName = 'Package'; +export default Package; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/paperclip.js b/node_modules/react-feather/dist/icons/paperclip.js new file mode 100644 index 0000000..008f70a --- /dev/null +++ b/node_modules/react-feather/dist/icons/paperclip.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Paperclip = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48" + })); +}); +Paperclip.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Paperclip.displayName = 'Paperclip'; +export default Paperclip; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/pause-circle.js b/node_modules/react-feather/dist/icons/pause-circle.js new file mode 100644 index 0000000..f3d6b67 --- /dev/null +++ b/node_modules/react-feather/dist/icons/pause-circle.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PauseCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "10", + y1: "15", + x2: "10", + y2: "9" + }), /*#__PURE__*/React.createElement("line", { + x1: "14", + y1: "15", + x2: "14", + y2: "9" + })); +}); +PauseCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PauseCircle.displayName = 'PauseCircle'; +export default PauseCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/pause.js b/node_modules/react-feather/dist/icons/pause.js new file mode 100644 index 0000000..fd49de4 --- /dev/null +++ b/node_modules/react-feather/dist/icons/pause.js @@ -0,0 +1,44 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Pause = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "6", + y: "4", + width: "4", + height: "16" + }), /*#__PURE__*/React.createElement("rect", { + x: "14", + y: "4", + width: "4", + height: "16" + })); +}); +Pause.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Pause.displayName = 'Pause'; +export default Pause; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/pen-tool.js b/node_modules/react-feather/dist/icons/pen-tool.js new file mode 100644 index 0000000..a4d2ba7 --- /dev/null +++ b/node_modules/react-feather/dist/icons/pen-tool.js @@ -0,0 +1,44 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PenTool = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M12 19l7-7 3 3-7 7-3-3z" + }), /*#__PURE__*/React.createElement("path", { + d: "M18 13l-1.5-7.5L2 2l3.5 14.5L13 18l5-5z" + }), /*#__PURE__*/React.createElement("path", { + d: "M2 2l7.586 7.586" + }), /*#__PURE__*/React.createElement("circle", { + cx: "11", + cy: "11", + r: "2" + })); +}); +PenTool.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PenTool.displayName = 'PenTool'; +export default PenTool; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/percent.js b/node_modules/react-feather/dist/icons/percent.js new file mode 100644 index 0000000..652885a --- /dev/null +++ b/node_modules/react-feather/dist/icons/percent.js @@ -0,0 +1,47 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Percent = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "19", + y1: "5", + x2: "5", + y2: "19" + }), /*#__PURE__*/React.createElement("circle", { + cx: "6.5", + cy: "6.5", + r: "2.5" + }), /*#__PURE__*/React.createElement("circle", { + cx: "17.5", + cy: "17.5", + r: "2.5" + })); +}); +Percent.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Percent.displayName = 'Percent'; +export default Percent; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/phone-call.js b/node_modules/react-feather/dist/icons/phone-call.js new file mode 100644 index 0000000..33146f3 --- /dev/null +++ b/node_modules/react-feather/dist/icons/phone-call.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PhoneCall = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M15.05 5A5 5 0 0 1 19 8.95M15.05 1A9 9 0 0 1 23 8.94m-1 7.98v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneCall.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneCall.displayName = 'PhoneCall'; +export default PhoneCall; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/phone-forwarded.js b/node_modules/react-feather/dist/icons/phone-forwarded.js new file mode 100644 index 0000000..c0fad28 --- /dev/null +++ b/node_modules/react-feather/dist/icons/phone-forwarded.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PhoneForwarded = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "19 1 23 5 19 9" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "5", + x2: "23", + y2: "5" + }), /*#__PURE__*/React.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneForwarded.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneForwarded.displayName = 'PhoneForwarded'; +export default PhoneForwarded; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/phone-incoming.js b/node_modules/react-feather/dist/icons/phone-incoming.js new file mode 100644 index 0000000..f135d71 --- /dev/null +++ b/node_modules/react-feather/dist/icons/phone-incoming.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PhoneIncoming = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "16 2 16 8 22 8" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "1", + x2: "16", + y2: "8" + }), /*#__PURE__*/React.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneIncoming.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneIncoming.displayName = 'PhoneIncoming'; +export default PhoneIncoming; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/phone-missed.js b/node_modules/react-feather/dist/icons/phone-missed.js new file mode 100644 index 0000000..be6082c --- /dev/null +++ b/node_modules/react-feather/dist/icons/phone-missed.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PhoneMissed = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "1", + x2: "17", + y2: "7" + }), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "1", + x2: "23", + y2: "7" + }), /*#__PURE__*/React.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneMissed.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneMissed.displayName = 'PhoneMissed'; +export default PhoneMissed; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/phone-off.js b/node_modules/react-feather/dist/icons/phone-off.js new file mode 100644 index 0000000..dba8881 --- /dev/null +++ b/node_modules/react-feather/dist/icons/phone-off.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PhoneOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M10.68 13.31a16 16 0 0 0 3.41 2.6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7 2 2 0 0 1 1.72 2v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.42 19.42 0 0 1-3.33-2.67m-2.67-3.34a19.79 19.79 0 0 1-3.07-8.63A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "1", + x2: "1", + y2: "23" + })); +}); +PhoneOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneOff.displayName = 'PhoneOff'; +export default PhoneOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/phone-outgoing.js b/node_modules/react-feather/dist/icons/phone-outgoing.js new file mode 100644 index 0000000..b0a8478 --- /dev/null +++ b/node_modules/react-feather/dist/icons/phone-outgoing.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PhoneOutgoing = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "23 7 23 1 17 1" + }), /*#__PURE__*/React.createElement("line", { + x1: "16", + y1: "8", + x2: "23", + y2: "1" + }), /*#__PURE__*/React.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +PhoneOutgoing.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PhoneOutgoing.displayName = 'PhoneOutgoing'; +export default PhoneOutgoing; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/phone.js b/node_modules/react-feather/dist/icons/phone.js new file mode 100644 index 0000000..4075f8d --- /dev/null +++ b/node_modules/react-feather/dist/icons/phone.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Phone = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z" + })); +}); +Phone.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Phone.displayName = 'Phone'; +export default Phone; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/pie-chart.js b/node_modules/react-feather/dist/icons/pie-chart.js new file mode 100644 index 0000000..15d57fa --- /dev/null +++ b/node_modules/react-feather/dist/icons/pie-chart.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PieChart = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21.21 15.89A10 10 0 1 1 8 2.83" + }), /*#__PURE__*/React.createElement("path", { + d: "M22 12A10 10 0 0 0 12 2v10z" + })); +}); +PieChart.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PieChart.displayName = 'PieChart'; +export default PieChart; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/play-circle.js b/node_modules/react-feather/dist/icons/play-circle.js new file mode 100644 index 0000000..a5255a1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/play-circle.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PlayCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("polygon", { + points: "10 8 16 12 10 16 10 8" + })); +}); +PlayCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PlayCircle.displayName = 'PlayCircle'; +export default PlayCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/play.js b/node_modules/react-feather/dist/icons/play.js new file mode 100644 index 0000000..5f8f96c --- /dev/null +++ b/node_modules/react-feather/dist/icons/play.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Play = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "5 3 19 12 5 21 5 3" + })); +}); +Play.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Play.displayName = 'Play'; +export default Play; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/plus-circle.js b/node_modules/react-feather/dist/icons/plus-circle.js new file mode 100644 index 0000000..17e4ba2 --- /dev/null +++ b/node_modules/react-feather/dist/icons/plus-circle.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PlusCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "16" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +PlusCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PlusCircle.displayName = 'PlusCircle'; +export default PlusCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/plus-square.js b/node_modules/react-feather/dist/icons/plus-square.js new file mode 100644 index 0000000..43fb623 --- /dev/null +++ b/node_modules/react-feather/dist/icons/plus-square.js @@ -0,0 +1,51 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var PlusSquare = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "16" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "12", + x2: "16", + y2: "12" + })); +}); +PlusSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +PlusSquare.displayName = 'PlusSquare'; +export default PlusSquare; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/plus.js b/node_modules/react-feather/dist/icons/plus.js new file mode 100644 index 0000000..5d13e9d --- /dev/null +++ b/node_modules/react-feather/dist/icons/plus.js @@ -0,0 +1,44 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Plus = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "5", + x2: "12", + y2: "19" + }), /*#__PURE__*/React.createElement("line", { + x1: "5", + y1: "12", + x2: "19", + y2: "12" + })); +}); +Plus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Plus.displayName = 'Plus'; +export default Plus; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/pocket.js b/node_modules/react-feather/dist/icons/pocket.js new file mode 100644 index 0000000..d097c25 --- /dev/null +++ b/node_modules/react-feather/dist/icons/pocket.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Pocket = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M4 3h16a2 2 0 0 1 2 2v6a10 10 0 0 1-10 10A10 10 0 0 1 2 11V5a2 2 0 0 1 2-2z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "8 10 12 14 16 10" + })); +}); +Pocket.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Pocket.displayName = 'Pocket'; +export default Pocket; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/power.js b/node_modules/react-feather/dist/icons/power.js new file mode 100644 index 0000000..d554a3d --- /dev/null +++ b/node_modules/react-feather/dist/icons/power.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Power = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M18.36 6.64a9 9 0 1 1-12.73 0" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "12" + })); +}); +Power.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Power.displayName = 'Power'; +export default Power; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/printer.js b/node_modules/react-feather/dist/icons/printer.js new file mode 100644 index 0000000..fc34f9d --- /dev/null +++ b/node_modules/react-feather/dist/icons/printer.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Printer = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "6 9 6 2 18 2 18 9" + }), /*#__PURE__*/React.createElement("path", { + d: "M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2" + }), /*#__PURE__*/React.createElement("rect", { + x: "6", + y: "14", + width: "12", + height: "8" + })); +}); +Printer.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Printer.displayName = 'Printer'; +export default Printer; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/radio.js b/node_modules/react-feather/dist/icons/radio.js new file mode 100644 index 0000000..b760326 --- /dev/null +++ b/node_modules/react-feather/dist/icons/radio.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Radio = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "2" + }), /*#__PURE__*/React.createElement("path", { + d: "M16.24 7.76a6 6 0 0 1 0 8.49m-8.48-.01a6 6 0 0 1 0-8.49m11.31-2.82a10 10 0 0 1 0 14.14m-14.14 0a10 10 0 0 1 0-14.14" + })); +}); +Radio.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Radio.displayName = 'Radio'; +export default Radio; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/refresh-ccw.js b/node_modules/react-feather/dist/icons/refresh-ccw.js new file mode 100644 index 0000000..be5b727 --- /dev/null +++ b/node_modules/react-feather/dist/icons/refresh-ccw.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var RefreshCcw = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "1 4 1 10 7 10" + }), /*#__PURE__*/React.createElement("polyline", { + points: "23 20 23 14 17 14" + }), /*#__PURE__*/React.createElement("path", { + d: "M20.49 9A9 9 0 0 0 5.64 5.64L1 10m22 4l-4.64 4.36A9 9 0 0 1 3.51 15" + })); +}); +RefreshCcw.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +RefreshCcw.displayName = 'RefreshCcw'; +export default RefreshCcw; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/refresh-cw.js b/node_modules/react-feather/dist/icons/refresh-cw.js new file mode 100644 index 0000000..f9e2095 --- /dev/null +++ b/node_modules/react-feather/dist/icons/refresh-cw.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var RefreshCw = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "23 4 23 10 17 10" + }), /*#__PURE__*/React.createElement("polyline", { + points: "1 20 1 14 7 14" + }), /*#__PURE__*/React.createElement("path", { + d: "M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15" + })); +}); +RefreshCw.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +RefreshCw.displayName = 'RefreshCw'; +export default RefreshCw; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/repeat.js b/node_modules/react-feather/dist/icons/repeat.js new file mode 100644 index 0000000..99a76da --- /dev/null +++ b/node_modules/react-feather/dist/icons/repeat.js @@ -0,0 +1,42 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Repeat = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "17 1 21 5 17 9" + }), /*#__PURE__*/React.createElement("path", { + d: "M3 11V9a4 4 0 0 1 4-4h14" + }), /*#__PURE__*/React.createElement("polyline", { + points: "7 23 3 19 7 15" + }), /*#__PURE__*/React.createElement("path", { + d: "M21 13v2a4 4 0 0 1-4 4H3" + })); +}); +Repeat.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Repeat.displayName = 'Repeat'; +export default Repeat; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/rewind.js b/node_modules/react-feather/dist/icons/rewind.js new file mode 100644 index 0000000..b754c43 --- /dev/null +++ b/node_modules/react-feather/dist/icons/rewind.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Rewind = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "11 19 2 12 11 5 11 19" + }), /*#__PURE__*/React.createElement("polygon", { + points: "22 19 13 12 22 5 22 19" + })); +}); +Rewind.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Rewind.displayName = 'Rewind'; +export default Rewind; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/rotate-ccw.js b/node_modules/react-feather/dist/icons/rotate-ccw.js new file mode 100644 index 0000000..c70adc1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/rotate-ccw.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var RotateCcw = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "1 4 1 10 7 10" + }), /*#__PURE__*/React.createElement("path", { + d: "M3.51 15a9 9 0 1 0 2.13-9.36L1 10" + })); +}); +RotateCcw.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +RotateCcw.displayName = 'RotateCcw'; +export default RotateCcw; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/rotate-cw.js b/node_modules/react-feather/dist/icons/rotate-cw.js new file mode 100644 index 0000000..bb471bc --- /dev/null +++ b/node_modules/react-feather/dist/icons/rotate-cw.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var RotateCw = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "23 4 23 10 17 10" + }), /*#__PURE__*/React.createElement("path", { + d: "M20.49 15a9 9 0 1 1-2.12-9.36L23 10" + })); +}); +RotateCw.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +RotateCw.displayName = 'RotateCw'; +export default RotateCw; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/rss.js b/node_modules/react-feather/dist/icons/rss.js new file mode 100644 index 0000000..741f18d --- /dev/null +++ b/node_modules/react-feather/dist/icons/rss.js @@ -0,0 +1,42 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Rss = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M4 11a9 9 0 0 1 9 9" + }), /*#__PURE__*/React.createElement("path", { + d: "M4 4a16 16 0 0 1 16 16" + }), /*#__PURE__*/React.createElement("circle", { + cx: "5", + cy: "19", + r: "1" + })); +}); +Rss.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Rss.displayName = 'Rss'; +export default Rss; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/save.js b/node_modules/react-feather/dist/icons/save.js new file mode 100644 index 0000000..c68417e --- /dev/null +++ b/node_modules/react-feather/dist/icons/save.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Save = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z" + }), /*#__PURE__*/React.createElement("polyline", { + points: "17 21 17 13 7 13 7 21" + }), /*#__PURE__*/React.createElement("polyline", { + points: "7 3 7 8 15 8" + })); +}); +Save.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Save.displayName = 'Save'; +export default Save; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/scissors.js b/node_modules/react-feather/dist/icons/scissors.js new file mode 100644 index 0000000..b6b4e3e --- /dev/null +++ b/node_modules/react-feather/dist/icons/scissors.js @@ -0,0 +1,57 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Scissors = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "6", + cy: "6", + r: "3" + }), /*#__PURE__*/React.createElement("circle", { + cx: "6", + cy: "18", + r: "3" + }), /*#__PURE__*/React.createElement("line", { + x1: "20", + y1: "4", + x2: "8.12", + y2: "15.88" + }), /*#__PURE__*/React.createElement("line", { + x1: "14.47", + y1: "14.48", + x2: "20", + y2: "20" + }), /*#__PURE__*/React.createElement("line", { + x1: "8.12", + y1: "8.12", + x2: "12", + y2: "12" + })); +}); +Scissors.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Scissors.displayName = 'Scissors'; +export default Scissors; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/search.js b/node_modules/react-feather/dist/icons/search.js new file mode 100644 index 0000000..92ee679 --- /dev/null +++ b/node_modules/react-feather/dist/icons/search.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Search = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "11", + cy: "11", + r: "8" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "21", + x2: "16.65", + y2: "16.65" + })); +}); +Search.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Search.displayName = 'Search'; +export default Search; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/send.js b/node_modules/react-feather/dist/icons/send.js new file mode 100644 index 0000000..96d81d3 --- /dev/null +++ b/node_modules/react-feather/dist/icons/send.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Send = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "22", + y1: "2", + x2: "11", + y2: "13" + }), /*#__PURE__*/React.createElement("polygon", { + points: "22 2 15 22 11 13 2 9 22 2" + })); +}); +Send.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Send.displayName = 'Send'; +export default Send; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/server.js b/node_modules/react-feather/dist/icons/server.js new file mode 100644 index 0000000..c660942 --- /dev/null +++ b/node_modules/react-feather/dist/icons/server.js @@ -0,0 +1,58 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Server = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "2", + y: "2", + width: "20", + height: "8", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("rect", { + x: "2", + y: "14", + width: "20", + height: "8", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "6", + x2: "6.01", + y2: "6" + }), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "18", + x2: "6.01", + y2: "18" + })); +}); +Server.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Server.displayName = 'Server'; +export default Server; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/settings.js b/node_modules/react-feather/dist/icons/settings.js new file mode 100644 index 0000000..aaaa88f --- /dev/null +++ b/node_modules/react-feather/dist/icons/settings.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Settings = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "3" + }), /*#__PURE__*/React.createElement("path", { + d: "M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z" + })); +}); +Settings.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Settings.displayName = 'Settings'; +export default Settings; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/share-2.js b/node_modules/react-feather/dist/icons/share-2.js new file mode 100644 index 0000000..306f40e --- /dev/null +++ b/node_modules/react-feather/dist/icons/share-2.js @@ -0,0 +1,56 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Share2 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "18", + cy: "5", + r: "3" + }), /*#__PURE__*/React.createElement("circle", { + cx: "6", + cy: "12", + r: "3" + }), /*#__PURE__*/React.createElement("circle", { + cx: "18", + cy: "19", + r: "3" + }), /*#__PURE__*/React.createElement("line", { + x1: "8.59", + y1: "13.51", + x2: "15.42", + y2: "17.49" + }), /*#__PURE__*/React.createElement("line", { + x1: "15.41", + y1: "6.51", + x2: "8.59", + y2: "10.49" + })); +}); +Share2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Share2.displayName = 'Share2'; +export default Share2; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/share.js b/node_modules/react-feather/dist/icons/share.js new file mode 100644 index 0000000..76c30d9 --- /dev/null +++ b/node_modules/react-feather/dist/icons/share.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Share = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8" + }), /*#__PURE__*/React.createElement("polyline", { + points: "16 6 12 2 8 6" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "15" + })); +}); +Share.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Share.displayName = 'Share'; +export default Share; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/shield-off.js b/node_modules/react-feather/dist/icons/shield-off.js new file mode 100644 index 0000000..abb7d0a --- /dev/null +++ b/node_modules/react-feather/dist/icons/shield-off.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ShieldOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M19.69 14a6.9 6.9 0 0 0 .31-2V5l-8-3-3.16 1.18" + }), /*#__PURE__*/React.createElement("path", { + d: "M4.73 4.73L4 5v7c0 6 8 10 8 10a20.29 20.29 0 0 0 5.62-4.38" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +ShieldOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ShieldOff.displayName = 'ShieldOff'; +export default ShieldOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/shield.js b/node_modules/react-feather/dist/icons/shield.js new file mode 100644 index 0000000..d66ec0c --- /dev/null +++ b/node_modules/react-feather/dist/icons/shield.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Shield = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" + })); +}); +Shield.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Shield.displayName = 'Shield'; +export default Shield; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/shopping-bag.js b/node_modules/react-feather/dist/icons/shopping-bag.js new file mode 100644 index 0000000..11f25e5 --- /dev/null +++ b/node_modules/react-feather/dist/icons/shopping-bag.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ShoppingBag = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M6 2L3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4z" + }), /*#__PURE__*/React.createElement("line", { + x1: "3", + y1: "6", + x2: "21", + y2: "6" + }), /*#__PURE__*/React.createElement("path", { + d: "M16 10a4 4 0 0 1-8 0" + })); +}); +ShoppingBag.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ShoppingBag.displayName = 'ShoppingBag'; +export default ShoppingBag; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/shopping-cart.js b/node_modules/react-feather/dist/icons/shopping-cart.js new file mode 100644 index 0000000..fc439fc --- /dev/null +++ b/node_modules/react-feather/dist/icons/shopping-cart.js @@ -0,0 +1,44 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ShoppingCart = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "9", + cy: "21", + r: "1" + }), /*#__PURE__*/React.createElement("circle", { + cx: "20", + cy: "21", + r: "1" + }), /*#__PURE__*/React.createElement("path", { + d: "M1 1h4l2.68 13.39a2 2 0 0 0 2 1.61h9.72a2 2 0 0 0 2-1.61L23 6H6" + })); +}); +ShoppingCart.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ShoppingCart.displayName = 'ShoppingCart'; +export default ShoppingCart; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/shuffle.js b/node_modules/react-feather/dist/icons/shuffle.js new file mode 100644 index 0000000..445a00e --- /dev/null +++ b/node_modules/react-feather/dist/icons/shuffle.js @@ -0,0 +1,53 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Shuffle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "16 3 21 3 21 8" + }), /*#__PURE__*/React.createElement("line", { + x1: "4", + y1: "20", + x2: "21", + y2: "3" + }), /*#__PURE__*/React.createElement("polyline", { + points: "21 16 21 21 16 21" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "15", + x2: "21", + y2: "21" + }), /*#__PURE__*/React.createElement("line", { + x1: "4", + y1: "4", + x2: "9", + y2: "9" + })); +}); +Shuffle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Shuffle.displayName = 'Shuffle'; +export default Shuffle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/sidebar.js b/node_modules/react-feather/dist/icons/sidebar.js new file mode 100644 index 0000000..8b90ca4 --- /dev/null +++ b/node_modules/react-feather/dist/icons/sidebar.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Sidebar = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "3", + x2: "9", + y2: "21" + })); +}); +Sidebar.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sidebar.displayName = 'Sidebar'; +export default Sidebar; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/skip-back.js b/node_modules/react-feather/dist/icons/skip-back.js new file mode 100644 index 0000000..0ee0f94 --- /dev/null +++ b/node_modules/react-feather/dist/icons/skip-back.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var SkipBack = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "19 20 9 12 19 4 19 20" + }), /*#__PURE__*/React.createElement("line", { + x1: "5", + y1: "19", + x2: "5", + y2: "5" + })); +}); +SkipBack.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +SkipBack.displayName = 'SkipBack'; +export default SkipBack; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/skip-forward.js b/node_modules/react-feather/dist/icons/skip-forward.js new file mode 100644 index 0000000..1c52848 --- /dev/null +++ b/node_modules/react-feather/dist/icons/skip-forward.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var SkipForward = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "5 4 15 12 5 20 5 4" + }), /*#__PURE__*/React.createElement("line", { + x1: "19", + y1: "5", + x2: "19", + y2: "19" + })); +}); +SkipForward.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +SkipForward.displayName = 'SkipForward'; +export default SkipForward; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/slack.js b/node_modules/react-feather/dist/icons/slack.js new file mode 100644 index 0000000..949cb91 --- /dev/null +++ b/node_modules/react-feather/dist/icons/slack.js @@ -0,0 +1,50 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Slack = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M14.5 10c-.83 0-1.5-.67-1.5-1.5v-5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5z" + }), /*#__PURE__*/React.createElement("path", { + d: "M20.5 10H19V8.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z" + }), /*#__PURE__*/React.createElement("path", { + d: "M9.5 14c.83 0 1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5S8 21.33 8 20.5v-5c0-.83.67-1.5 1.5-1.5z" + }), /*#__PURE__*/React.createElement("path", { + d: "M3.5 14H5v1.5c0 .83-.67 1.5-1.5 1.5S2 16.33 2 15.5 2.67 14 3.5 14z" + }), /*#__PURE__*/React.createElement("path", { + d: "M14 14.5c0-.83.67-1.5 1.5-1.5h5c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5h-5c-.83 0-1.5-.67-1.5-1.5z" + }), /*#__PURE__*/React.createElement("path", { + d: "M15.5 19H14v1.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z" + }), /*#__PURE__*/React.createElement("path", { + d: "M10 9.5C10 8.67 9.33 8 8.5 8h-5C2.67 8 2 8.67 2 9.5S2.67 11 3.5 11h5c.83 0 1.5-.67 1.5-1.5z" + }), /*#__PURE__*/React.createElement("path", { + d: "M8.5 5H10V3.5C10 2.67 9.33 2 8.5 2S7 2.67 7 3.5 7.67 5 8.5 5z" + })); +}); +Slack.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Slack.displayName = 'Slack'; +export default Slack; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/slash.js b/node_modules/react-feather/dist/icons/slash.js new file mode 100644 index 0000000..21da52f --- /dev/null +++ b/node_modules/react-feather/dist/icons/slash.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Slash = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "4.93", + y1: "4.93", + x2: "19.07", + y2: "19.07" + })); +}); +Slash.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Slash.displayName = 'Slash'; +export default Slash; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/sliders.js b/node_modules/react-feather/dist/icons/sliders.js new file mode 100644 index 0000000..21df65f --- /dev/null +++ b/node_modules/react-feather/dist/icons/sliders.js @@ -0,0 +1,79 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Sliders = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "4", + y1: "21", + x2: "4", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "4", + y1: "10", + x2: "4", + y2: "3" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "21", + x2: "12", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "8", + x2: "12", + y2: "3" + }), /*#__PURE__*/React.createElement("line", { + x1: "20", + y1: "21", + x2: "20", + y2: "16" + }), /*#__PURE__*/React.createElement("line", { + x1: "20", + y1: "12", + x2: "20", + y2: "3" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "14", + x2: "7", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "8", + x2: "15", + y2: "8" + }), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "16", + x2: "23", + y2: "16" + })); +}); +Sliders.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sliders.displayName = 'Sliders'; +export default Sliders; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/smartphone.js b/node_modules/react-feather/dist/icons/smartphone.js new file mode 100644 index 0000000..218019a --- /dev/null +++ b/node_modules/react-feather/dist/icons/smartphone.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Smartphone = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "5", + y: "2", + width: "14", + height: "20", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "18", + x2: "12.01", + y2: "18" + })); +}); +Smartphone.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Smartphone.displayName = 'Smartphone'; +export default Smartphone; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/smile.js b/node_modules/react-feather/dist/icons/smile.js new file mode 100644 index 0000000..2f9d91f --- /dev/null +++ b/node_modules/react-feather/dist/icons/smile.js @@ -0,0 +1,50 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Smile = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("path", { + d: "M8 14s1.5 2 4 2 4-2 4-2" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "9", + x2: "9.01", + y2: "9" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "9", + x2: "15.01", + y2: "9" + })); +}); +Smile.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Smile.displayName = 'Smile'; +export default Smile; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/speaker.js b/node_modules/react-feather/dist/icons/speaker.js new file mode 100644 index 0000000..f9e170b --- /dev/null +++ b/node_modules/react-feather/dist/icons/speaker.js @@ -0,0 +1,50 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Speaker = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "4", + y: "2", + width: "16", + height: "20", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "14", + r: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "6", + x2: "12.01", + y2: "6" + })); +}); +Speaker.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Speaker.displayName = 'Speaker'; +export default Speaker; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/square.js b/node_modules/react-feather/dist/icons/square.js new file mode 100644 index 0000000..6a9c98c --- /dev/null +++ b/node_modules/react-feather/dist/icons/square.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Square = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + })); +}); +Square.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Square.displayName = 'Square'; +export default Square; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/star.js b/node_modules/react-feather/dist/icons/star.js new file mode 100644 index 0000000..c95b193 --- /dev/null +++ b/node_modules/react-feather/dist/icons/star.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Star = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2" + })); +}); +Star.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Star.displayName = 'Star'; +export default Star; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/stop-circle.js b/node_modules/react-feather/dist/icons/stop-circle.js new file mode 100644 index 0000000..1ab6830 --- /dev/null +++ b/node_modules/react-feather/dist/icons/stop-circle.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var StopCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("rect", { + x: "9", + y: "9", + width: "6", + height: "6" + })); +}); +StopCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +StopCircle.displayName = 'StopCircle'; +export default StopCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/sun.js b/node_modules/react-feather/dist/icons/sun.js new file mode 100644 index 0000000..42c0c51 --- /dev/null +++ b/node_modules/react-feather/dist/icons/sun.js @@ -0,0 +1,78 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Sun = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "5" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "1", + x2: "12", + y2: "3" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "21", + x2: "12", + y2: "23" + }), /*#__PURE__*/React.createElement("line", { + x1: "4.22", + y1: "4.22", + x2: "5.64", + y2: "5.64" + }), /*#__PURE__*/React.createElement("line", { + x1: "18.36", + y1: "18.36", + x2: "19.78", + y2: "19.78" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "12", + x2: "3", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "12", + x2: "23", + y2: "12" + }), /*#__PURE__*/React.createElement("line", { + x1: "4.22", + y1: "19.78", + x2: "5.64", + y2: "18.36" + }), /*#__PURE__*/React.createElement("line", { + x1: "18.36", + y1: "5.64", + x2: "19.78", + y2: "4.22" + })); +}); +Sun.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sun.displayName = 'Sun'; +export default Sun; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/sunrise.js b/node_modules/react-feather/dist/icons/sunrise.js new file mode 100644 index 0000000..e77ac13 --- /dev/null +++ b/node_modules/react-feather/dist/icons/sunrise.js @@ -0,0 +1,68 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Sunrise = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M17 18a5 5 0 0 0-10 0" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "2", + x2: "12", + y2: "9" + }), /*#__PURE__*/React.createElement("line", { + x1: "4.22", + y1: "10.22", + x2: "5.64", + y2: "11.64" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "18", + x2: "3", + y2: "18" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "18", + x2: "23", + y2: "18" + }), /*#__PURE__*/React.createElement("line", { + x1: "18.36", + y1: "11.64", + x2: "19.78", + y2: "10.22" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "22", + x2: "1", + y2: "22" + }), /*#__PURE__*/React.createElement("polyline", { + points: "8 6 12 2 16 6" + })); +}); +Sunrise.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sunrise.displayName = 'Sunrise'; +export default Sunrise; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/sunset.js b/node_modules/react-feather/dist/icons/sunset.js new file mode 100644 index 0000000..ed3deb0 --- /dev/null +++ b/node_modules/react-feather/dist/icons/sunset.js @@ -0,0 +1,68 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Sunset = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M17 18a5 5 0 0 0-10 0" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "9", + x2: "12", + y2: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "4.22", + y1: "10.22", + x2: "5.64", + y2: "11.64" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "18", + x2: "3", + y2: "18" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "18", + x2: "23", + y2: "18" + }), /*#__PURE__*/React.createElement("line", { + x1: "18.36", + y1: "11.64", + x2: "19.78", + y2: "10.22" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "22", + x2: "1", + y2: "22" + }), /*#__PURE__*/React.createElement("polyline", { + points: "16 5 12 9 8 5" + })); +}); +Sunset.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Sunset.displayName = 'Sunset'; +export default Sunset; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/table.js b/node_modules/react-feather/dist/icons/table.js new file mode 100644 index 0000000..837eaa4 --- /dev/null +++ b/node_modules/react-feather/dist/icons/table.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Table = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M9 3H5a2 2 0 0 0-2 2v4m6-6h10a2 2 0 0 1 2 2v4M9 3v18m0 0h10a2 2 0 0 0 2-2V9M9 21H5a2 2 0 0 1-2-2V9m0 0h18" + })); +}); +Table.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Table.displayName = 'Table'; +export default Table; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/tablet.js b/node_modules/react-feather/dist/icons/tablet.js new file mode 100644 index 0000000..dde5772 --- /dev/null +++ b/node_modules/react-feather/dist/icons/tablet.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Tablet = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "4", + y: "2", + width: "16", + height: "20", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "18", + x2: "12.01", + y2: "18" + })); +}); +Tablet.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Tablet.displayName = 'Tablet'; +export default Tablet; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/tag.js b/node_modules/react-feather/dist/icons/tag.js new file mode 100644 index 0000000..fd32a30 --- /dev/null +++ b/node_modules/react-feather/dist/icons/tag.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Tag = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z" + }), /*#__PURE__*/React.createElement("line", { + x1: "7", + y1: "7", + x2: "7.01", + y2: "7" + })); +}); +Tag.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Tag.displayName = 'Tag'; +export default Tag; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/target.js b/node_modules/react-feather/dist/icons/target.js new file mode 100644 index 0000000..a538694 --- /dev/null +++ b/node_modules/react-feather/dist/icons/target.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Target = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "6" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "2" + })); +}); +Target.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Target.displayName = 'Target'; +export default Target; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/terminal.js b/node_modules/react-feather/dist/icons/terminal.js new file mode 100644 index 0000000..42407a4 --- /dev/null +++ b/node_modules/react-feather/dist/icons/terminal.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Terminal = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "4 17 10 11 4 5" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "19", + x2: "20", + y2: "19" + })); +}); +Terminal.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Terminal.displayName = 'Terminal'; +export default Terminal; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/thermometer.js b/node_modules/react-feather/dist/icons/thermometer.js new file mode 100644 index 0000000..a4dd399 --- /dev/null +++ b/node_modules/react-feather/dist/icons/thermometer.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Thermometer = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M14 14.76V3.5a2.5 2.5 0 0 0-5 0v11.26a4.5 4.5 0 1 0 5 0z" + })); +}); +Thermometer.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Thermometer.displayName = 'Thermometer'; +export default Thermometer; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/thumbs-down.js b/node_modules/react-feather/dist/icons/thumbs-down.js new file mode 100644 index 0000000..f59d836 --- /dev/null +++ b/node_modules/react-feather/dist/icons/thumbs-down.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ThumbsDown = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M10 15v4a3 3 0 0 0 3 3l4-9V2H5.72a2 2 0 0 0-2 1.7l-1.38 9a2 2 0 0 0 2 2.3zm7-13h2.67A2.31 2.31 0 0 1 22 4v7a2.31 2.31 0 0 1-2.33 2H17" + })); +}); +ThumbsDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ThumbsDown.displayName = 'ThumbsDown'; +export default ThumbsDown; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/thumbs-up.js b/node_modules/react-feather/dist/icons/thumbs-up.js new file mode 100644 index 0000000..ad076c6 --- /dev/null +++ b/node_modules/react-feather/dist/icons/thumbs-up.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ThumbsUp = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M14 9V5a3 3 0 0 0-3-3l-4 9v11h11.28a2 2 0 0 0 2-1.7l1.38-9a2 2 0 0 0-2-2.3zM7 22H4a2 2 0 0 1-2-2v-7a2 2 0 0 1 2-2h3" + })); +}); +ThumbsUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ThumbsUp.displayName = 'ThumbsUp'; +export default ThumbsUp; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/toggle-left.js b/node_modules/react-feather/dist/icons/toggle-left.js new file mode 100644 index 0000000..0d27233 --- /dev/null +++ b/node_modules/react-feather/dist/icons/toggle-left.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ToggleLeft = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "1", + y: "5", + width: "22", + height: "14", + rx: "7", + ry: "7" + }), /*#__PURE__*/React.createElement("circle", { + cx: "8", + cy: "12", + r: "3" + })); +}); +ToggleLeft.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ToggleLeft.displayName = 'ToggleLeft'; +export default ToggleLeft; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/toggle-right.js b/node_modules/react-feather/dist/icons/toggle-right.js new file mode 100644 index 0000000..8f483fc --- /dev/null +++ b/node_modules/react-feather/dist/icons/toggle-right.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ToggleRight = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "1", + y: "5", + width: "22", + height: "14", + rx: "7", + ry: "7" + }), /*#__PURE__*/React.createElement("circle", { + cx: "16", + cy: "12", + r: "3" + })); +}); +ToggleRight.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ToggleRight.displayName = 'ToggleRight'; +export default ToggleRight; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/tool.js b/node_modules/react-feather/dist/icons/tool.js new file mode 100644 index 0000000..e9d85fe --- /dev/null +++ b/node_modules/react-feather/dist/icons/tool.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Tool = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z" + })); +}); +Tool.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Tool.displayName = 'Tool'; +export default Tool; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/trash-2.js b/node_modules/react-feather/dist/icons/trash-2.js new file mode 100644 index 0000000..4f4270e --- /dev/null +++ b/node_modules/react-feather/dist/icons/trash-2.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Trash2 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "3 6 5 6 21 6" + }), /*#__PURE__*/React.createElement("path", { + d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" + }), /*#__PURE__*/React.createElement("line", { + x1: "10", + y1: "11", + x2: "10", + y2: "17" + }), /*#__PURE__*/React.createElement("line", { + x1: "14", + y1: "11", + x2: "14", + y2: "17" + })); +}); +Trash2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Trash2.displayName = 'Trash2'; +export default Trash2; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/trash.js b/node_modules/react-feather/dist/icons/trash.js new file mode 100644 index 0000000..6108a01 --- /dev/null +++ b/node_modules/react-feather/dist/icons/trash.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Trash = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "3 6 5 6 21 6" + }), /*#__PURE__*/React.createElement("path", { + d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" + })); +}); +Trash.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Trash.displayName = 'Trash'; +export default Trash; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/trello.js b/node_modules/react-feather/dist/icons/trello.js new file mode 100644 index 0000000..dfb3678 --- /dev/null +++ b/node_modules/react-feather/dist/icons/trello.js @@ -0,0 +1,51 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Trello = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("rect", { + x: "7", + y: "7", + width: "3", + height: "9" + }), /*#__PURE__*/React.createElement("rect", { + x: "14", + y: "7", + width: "3", + height: "5" + })); +}); +Trello.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Trello.displayName = 'Trello'; +export default Trello; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/trending-down.js b/node_modules/react-feather/dist/icons/trending-down.js new file mode 100644 index 0000000..dcf4610 --- /dev/null +++ b/node_modules/react-feather/dist/icons/trending-down.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var TrendingDown = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "23 18 13.5 8.5 8.5 13.5 1 6" + }), /*#__PURE__*/React.createElement("polyline", { + points: "17 18 23 18 23 12" + })); +}); +TrendingDown.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +TrendingDown.displayName = 'TrendingDown'; +export default TrendingDown; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/trending-up.js b/node_modules/react-feather/dist/icons/trending-up.js new file mode 100644 index 0000000..be8e9ea --- /dev/null +++ b/node_modules/react-feather/dist/icons/trending-up.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var TrendingUp = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "23 6 13.5 15.5 8.5 10.5 1 18" + }), /*#__PURE__*/React.createElement("polyline", { + points: "17 6 23 6 23 12" + })); +}); +TrendingUp.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +TrendingUp.displayName = 'TrendingUp'; +export default TrendingUp; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/triangle.js b/node_modules/react-feather/dist/icons/triangle.js new file mode 100644 index 0000000..a157db0 --- /dev/null +++ b/node_modules/react-feather/dist/icons/triangle.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Triangle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" + })); +}); +Triangle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Triangle.displayName = 'Triangle'; +export default Triangle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/truck.js b/node_modules/react-feather/dist/icons/truck.js new file mode 100644 index 0000000..01edb76 --- /dev/null +++ b/node_modules/react-feather/dist/icons/truck.js @@ -0,0 +1,49 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Truck = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "1", + y: "3", + width: "15", + height: "13" + }), /*#__PURE__*/React.createElement("polygon", { + points: "16 8 20 8 23 11 23 16 16 16 16 8" + }), /*#__PURE__*/React.createElement("circle", { + cx: "5.5", + cy: "18.5", + r: "2.5" + }), /*#__PURE__*/React.createElement("circle", { + cx: "18.5", + cy: "18.5", + r: "2.5" + })); +}); +Truck.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Truck.displayName = 'Truck'; +export default Truck; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/tv.js b/node_modules/react-feather/dist/icons/tv.js new file mode 100644 index 0000000..6710fe8 --- /dev/null +++ b/node_modules/react-feather/dist/icons/tv.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Tv = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "2", + y: "7", + width: "20", + height: "15", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("polyline", { + points: "17 2 12 7 7 2" + })); +}); +Tv.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Tv.displayName = 'Tv'; +export default Tv; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/twitch.js b/node_modules/react-feather/dist/icons/twitch.js new file mode 100644 index 0000000..3707b5e --- /dev/null +++ b/node_modules/react-feather/dist/icons/twitch.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Twitch = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 2H3v16h5v4l4-4h5l4-4V2zm-10 9V7m5 4V7" + })); +}); +Twitch.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Twitch.displayName = 'Twitch'; +export default Twitch; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/twitter.js b/node_modules/react-feather/dist/icons/twitter.js new file mode 100644 index 0000000..4fc97bc --- /dev/null +++ b/node_modules/react-feather/dist/icons/twitter.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Twitter = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M23 3a10.9 10.9 0 0 1-3.14 1.53 4.48 4.48 0 0 0-7.86 3v1A10.66 10.66 0 0 1 3 4s-4 9 5 13a11.64 11.64 0 0 1-7 2c9 5 20 0 20-11.5a4.5 4.5 0 0 0-.08-.83A7.72 7.72 0 0 0 23 3z" + })); +}); +Twitter.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Twitter.displayName = 'Twitter'; +export default Twitter; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/type.js b/node_modules/react-feather/dist/icons/type.js new file mode 100644 index 0000000..7fa05f1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/type.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Type = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "4 7 4 4 20 4 20 7" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "20", + x2: "15", + y2: "20" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "4", + x2: "12", + y2: "20" + })); +}); +Type.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Type.displayName = 'Type'; +export default Type; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/umbrella.js b/node_modules/react-feather/dist/icons/umbrella.js new file mode 100644 index 0000000..3758ecf --- /dev/null +++ b/node_modules/react-feather/dist/icons/umbrella.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Umbrella = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M23 12a11.05 11.05 0 0 0-22 0zm-5 7a3 3 0 0 1-6 0v-7" + })); +}); +Umbrella.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Umbrella.displayName = 'Umbrella'; +export default Umbrella; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/underline.js b/node_modules/react-feather/dist/icons/underline.js new file mode 100644 index 0000000..d8f54cb --- /dev/null +++ b/node_modules/react-feather/dist/icons/underline.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Underline = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M6 3v7a6 6 0 0 0 6 6 6 6 0 0 0 6-6V3" + }), /*#__PURE__*/React.createElement("line", { + x1: "4", + y1: "21", + x2: "20", + y2: "21" + })); +}); +Underline.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Underline.displayName = 'Underline'; +export default Underline; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/unlock.js b/node_modules/react-feather/dist/icons/unlock.js new file mode 100644 index 0000000..da5ea04 --- /dev/null +++ b/node_modules/react-feather/dist/icons/unlock.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Unlock = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "11", + width: "18", + height: "11", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("path", { + d: "M7 11V7a5 5 0 0 1 9.9-1" + })); +}); +Unlock.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Unlock.displayName = 'Unlock'; +export default Unlock; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/upload-cloud.js b/node_modules/react-feather/dist/icons/upload-cloud.js new file mode 100644 index 0000000..fe09b0d --- /dev/null +++ b/node_modules/react-feather/dist/icons/upload-cloud.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var UploadCloud = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "16 16 12 12 8 16" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "12", + x2: "12", + y2: "21" + }), /*#__PURE__*/React.createElement("path", { + d: "M20.39 18.39A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.3" + }), /*#__PURE__*/React.createElement("polyline", { + points: "16 16 12 12 8 16" + })); +}); +UploadCloud.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UploadCloud.displayName = 'UploadCloud'; +export default UploadCloud; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/upload.js b/node_modules/react-feather/dist/icons/upload.js new file mode 100644 index 0000000..0593605 --- /dev/null +++ b/node_modules/react-feather/dist/icons/upload.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Upload = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" + }), /*#__PURE__*/React.createElement("polyline", { + points: "17 8 12 3 7 8" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "3", + x2: "12", + y2: "15" + })); +}); +Upload.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Upload.displayName = 'Upload'; +export default Upload; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/user-check.js b/node_modules/react-feather/dist/icons/user-check.js new file mode 100644 index 0000000..9c607fa --- /dev/null +++ b/node_modules/react-feather/dist/icons/user-check.js @@ -0,0 +1,42 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var UserCheck = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React.createElement("circle", { + cx: "8.5", + cy: "7", + r: "4" + }), /*#__PURE__*/React.createElement("polyline", { + points: "17 11 19 13 23 9" + })); +}); +UserCheck.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UserCheck.displayName = 'UserCheck'; +export default UserCheck; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/user-minus.js b/node_modules/react-feather/dist/icons/user-minus.js new file mode 100644 index 0000000..94034e1 --- /dev/null +++ b/node_modules/react-feather/dist/icons/user-minus.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var UserMinus = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React.createElement("circle", { + cx: "8.5", + cy: "7", + r: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "11", + x2: "17", + y2: "11" + })); +}); +UserMinus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UserMinus.displayName = 'UserMinus'; +export default UserMinus; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/user-plus.js b/node_modules/react-feather/dist/icons/user-plus.js new file mode 100644 index 0000000..bf7afae --- /dev/null +++ b/node_modules/react-feather/dist/icons/user-plus.js @@ -0,0 +1,50 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var UserPlus = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React.createElement("circle", { + cx: "8.5", + cy: "7", + r: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "20", + y1: "8", + x2: "20", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "11", + x2: "17", + y2: "11" + })); +}); +UserPlus.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UserPlus.displayName = 'UserPlus'; +export default UserPlus; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/user-x.js b/node_modules/react-feather/dist/icons/user-x.js new file mode 100644 index 0000000..dc69105 --- /dev/null +++ b/node_modules/react-feather/dist/icons/user-x.js @@ -0,0 +1,50 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var UserX = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React.createElement("circle", { + cx: "8.5", + cy: "7", + r: "4" + }), /*#__PURE__*/React.createElement("line", { + x1: "18", + y1: "8", + x2: "23", + y2: "13" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "8", + x2: "18", + y2: "13" + })); +}); +UserX.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +UserX.displayName = 'UserX'; +export default UserX; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/user.js b/node_modules/react-feather/dist/icons/user.js new file mode 100644 index 0000000..fa6a078 --- /dev/null +++ b/node_modules/react-feather/dist/icons/user.js @@ -0,0 +1,40 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var User = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "7", + r: "4" + })); +}); +User.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +User.displayName = 'User'; +export default User; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/users.js b/node_modules/react-feather/dist/icons/users.js new file mode 100644 index 0000000..cb74e1b --- /dev/null +++ b/node_modules/react-feather/dist/icons/users.js @@ -0,0 +1,44 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Users = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" + }), /*#__PURE__*/React.createElement("circle", { + cx: "9", + cy: "7", + r: "4" + }), /*#__PURE__*/React.createElement("path", { + d: "M23 21v-2a4 4 0 0 0-3-3.87" + }), /*#__PURE__*/React.createElement("path", { + d: "M16 3.13a4 4 0 0 1 0 7.75" + })); +}); +Users.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Users.displayName = 'Users'; +export default Users; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/video-off.js b/node_modules/react-feather/dist/icons/video-off.js new file mode 100644 index 0000000..37d6306 --- /dev/null +++ b/node_modules/react-feather/dist/icons/video-off.js @@ -0,0 +1,41 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var VideoOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M16 16v1a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h2m5.66 0H14a2 2 0 0 1 2 2v3.34l1 1L23 7v10" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +VideoOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +VideoOff.displayName = 'VideoOff'; +export default VideoOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/video.js b/node_modules/react-feather/dist/icons/video.js new file mode 100644 index 0000000..3b80bc2 --- /dev/null +++ b/node_modules/react-feather/dist/icons/video.js @@ -0,0 +1,43 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Video = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "23 7 16 12 23 17 23 7" + }), /*#__PURE__*/React.createElement("rect", { + x: "1", + y: "5", + width: "15", + height: "14", + rx: "2", + ry: "2" + })); +}); +Video.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Video.displayName = 'Video'; +export default Video; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/voicemail.js b/node_modules/react-feather/dist/icons/voicemail.js new file mode 100644 index 0000000..afad39e --- /dev/null +++ b/node_modules/react-feather/dist/icons/voicemail.js @@ -0,0 +1,47 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Voicemail = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "5.5", + cy: "11.5", + r: "4.5" + }), /*#__PURE__*/React.createElement("circle", { + cx: "18.5", + cy: "11.5", + r: "4.5" + }), /*#__PURE__*/React.createElement("line", { + x1: "5.5", + y1: "16", + x2: "18.5", + y2: "16" + })); +}); +Voicemail.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Voicemail.displayName = 'Voicemail'; +export default Voicemail; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/volume-1.js b/node_modules/react-feather/dist/icons/volume-1.js new file mode 100644 index 0000000..445e185 --- /dev/null +++ b/node_modules/react-feather/dist/icons/volume-1.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Volume1 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5" + }), /*#__PURE__*/React.createElement("path", { + d: "M15.54 8.46a5 5 0 0 1 0 7.07" + })); +}); +Volume1.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Volume1.displayName = 'Volume1'; +export default Volume1; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/volume-2.js b/node_modules/react-feather/dist/icons/volume-2.js new file mode 100644 index 0000000..818ae58 --- /dev/null +++ b/node_modules/react-feather/dist/icons/volume-2.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Volume2 = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5" + }), /*#__PURE__*/React.createElement("path", { + d: "M19.07 4.93a10 10 0 0 1 0 14.14M15.54 8.46a5 5 0 0 1 0 7.07" + })); +}); +Volume2.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Volume2.displayName = 'Volume2'; +export default Volume2; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/volume-x.js b/node_modules/react-feather/dist/icons/volume-x.js new file mode 100644 index 0000000..202f365 --- /dev/null +++ b/node_modules/react-feather/dist/icons/volume-x.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var VolumeX = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5" + }), /*#__PURE__*/React.createElement("line", { + x1: "23", + y1: "9", + x2: "17", + y2: "15" + }), /*#__PURE__*/React.createElement("line", { + x1: "17", + y1: "9", + x2: "23", + y2: "15" + })); +}); +VolumeX.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +VolumeX.displayName = 'VolumeX'; +export default VolumeX; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/volume.js b/node_modules/react-feather/dist/icons/volume.js new file mode 100644 index 0000000..ba22001 --- /dev/null +++ b/node_modules/react-feather/dist/icons/volume.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Volume = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5" + })); +}); +Volume.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Volume.displayName = 'Volume'; +export default Volume; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/watch.js b/node_modules/react-feather/dist/icons/watch.js new file mode 100644 index 0000000..dec672e --- /dev/null +++ b/node_modules/react-feather/dist/icons/watch.js @@ -0,0 +1,42 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Watch = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "7" + }), /*#__PURE__*/React.createElement("polyline", { + points: "12 9 12 12 13.5 13.5" + }), /*#__PURE__*/React.createElement("path", { + d: "M16.51 17.35l-.35 3.83a2 2 0 0 1-2 1.82H9.83a2 2 0 0 1-2-1.82l-.35-3.83m.01-10.7l.35-3.83A2 2 0 0 1 9.83 1h4.35a2 2 0 0 1 2 1.82l.35 3.83" + })); +}); +Watch.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Watch.displayName = 'Watch'; +export default Watch; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/wifi-off.js b/node_modules/react-feather/dist/icons/wifi-off.js new file mode 100644 index 0000000..0ef973a --- /dev/null +++ b/node_modules/react-feather/dist/icons/wifi-off.js @@ -0,0 +1,54 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var WifiOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + }), /*#__PURE__*/React.createElement("path", { + d: "M16.72 11.06A10.94 10.94 0 0 1 19 12.55" + }), /*#__PURE__*/React.createElement("path", { + d: "M5 12.55a10.94 10.94 0 0 1 5.17-2.39" + }), /*#__PURE__*/React.createElement("path", { + d: "M10.71 5.05A16 16 0 0 1 22.58 9" + }), /*#__PURE__*/React.createElement("path", { + d: "M1.42 9a15.91 15.91 0 0 1 4.7-2.88" + }), /*#__PURE__*/React.createElement("path", { + d: "M8.53 16.11a6 6 0 0 1 6.95 0" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "20", + x2: "12.01", + y2: "20" + })); +}); +WifiOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +WifiOff.displayName = 'WifiOff'; +export default WifiOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/wifi.js b/node_modules/react-feather/dist/icons/wifi.js new file mode 100644 index 0000000..6c97378 --- /dev/null +++ b/node_modules/react-feather/dist/icons/wifi.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Wifi = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M5 12.55a11 11 0 0 1 14.08 0" + }), /*#__PURE__*/React.createElement("path", { + d: "M1.42 9a16 16 0 0 1 21.16 0" + }), /*#__PURE__*/React.createElement("path", { + d: "M8.53 16.11a6 6 0 0 1 6.95 0" + }), /*#__PURE__*/React.createElement("line", { + x1: "12", + y1: "20", + x2: "12.01", + y2: "20" + })); +}); +Wifi.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Wifi.displayName = 'Wifi'; +export default Wifi; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/wind.js b/node_modules/react-feather/dist/icons/wind.js new file mode 100644 index 0000000..02c89cf --- /dev/null +++ b/node_modules/react-feather/dist/icons/wind.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Wind = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M9.59 4.59A2 2 0 1 1 11 8H2m10.59 11.41A2 2 0 1 0 14 16H2m15.73-8.27A2.5 2.5 0 1 1 19.5 12H2" + })); +}); +Wind.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Wind.displayName = 'Wind'; +export default Wind; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/x-circle.js b/node_modules/react-feather/dist/icons/x-circle.js new file mode 100644 index 0000000..6d03248 --- /dev/null +++ b/node_modules/react-feather/dist/icons/x-circle.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var XCircle = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "12", + cy: "12", + r: "10" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "9", + x2: "9", + y2: "15" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "9", + x2: "15", + y2: "15" + })); +}); +XCircle.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +XCircle.displayName = 'XCircle'; +export default XCircle; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/x-octagon.js b/node_modules/react-feather/dist/icons/x-octagon.js new file mode 100644 index 0000000..bcb112b --- /dev/null +++ b/node_modules/react-feather/dist/icons/x-octagon.js @@ -0,0 +1,46 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var XOctagon = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "9", + x2: "9", + y2: "15" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "9", + x2: "15", + y2: "15" + })); +}); +XOctagon.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +XOctagon.displayName = 'XOctagon'; +export default XOctagon; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/x-square.js b/node_modules/react-feather/dist/icons/x-square.js new file mode 100644 index 0000000..12f5c7c --- /dev/null +++ b/node_modules/react-feather/dist/icons/x-square.js @@ -0,0 +1,51 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var XSquare = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("rect", { + x: "3", + y: "3", + width: "18", + height: "18", + rx: "2", + ry: "2" + }), /*#__PURE__*/React.createElement("line", { + x1: "9", + y1: "9", + x2: "15", + y2: "15" + }), /*#__PURE__*/React.createElement("line", { + x1: "15", + y1: "9", + x2: "9", + y2: "15" + })); +}); +XSquare.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +XSquare.displayName = 'XSquare'; +export default XSquare; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/x.js b/node_modules/react-feather/dist/icons/x.js new file mode 100644 index 0000000..83d58a0 --- /dev/null +++ b/node_modules/react-feather/dist/icons/x.js @@ -0,0 +1,44 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var X = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("line", { + x1: "18", + y1: "6", + x2: "6", + y2: "18" + }), /*#__PURE__*/React.createElement("line", { + x1: "6", + y1: "6", + x2: "18", + y2: "18" + })); +}); +X.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +X.displayName = 'X'; +export default X; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/youtube.js b/node_modules/react-feather/dist/icons/youtube.js new file mode 100644 index 0000000..cdb7659 --- /dev/null +++ b/node_modules/react-feather/dist/icons/youtube.js @@ -0,0 +1,38 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Youtube = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("path", { + d: "M22.54 6.42a2.78 2.78 0 0 0-1.94-2C18.88 4 12 4 12 4s-6.88 0-8.6.46a2.78 2.78 0 0 0-1.94 2A29 29 0 0 0 1 11.75a29 29 0 0 0 .46 5.33A2.78 2.78 0 0 0 3.4 19c1.72.46 8.6.46 8.6.46s6.88 0 8.6-.46a2.78 2.78 0 0 0 1.94-2 29 29 0 0 0 .46-5.25 29 29 0 0 0-.46-5.33z" + }), /*#__PURE__*/React.createElement("polygon", { + points: "9.75 15.02 15.5 11.75 9.75 8.48 9.75 15.02" + })); +}); +Youtube.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Youtube.displayName = 'Youtube'; +export default Youtube; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/zap-off.js b/node_modules/react-feather/dist/icons/zap-off.js new file mode 100644 index 0000000..a3344ef --- /dev/null +++ b/node_modules/react-feather/dist/icons/zap-off.js @@ -0,0 +1,45 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ZapOff = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polyline", { + points: "12.41 6.75 13 2 10.57 4.92" + }), /*#__PURE__*/React.createElement("polyline", { + points: "18.57 12.91 21 10 15.66 10" + }), /*#__PURE__*/React.createElement("polyline", { + points: "8 8 3 14 12 14 11 22 16 16" + }), /*#__PURE__*/React.createElement("line", { + x1: "1", + y1: "1", + x2: "23", + y2: "23" + })); +}); +ZapOff.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ZapOff.displayName = 'ZapOff'; +export default ZapOff; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/zap.js b/node_modules/react-feather/dist/icons/zap.js new file mode 100644 index 0000000..0ee6a6d --- /dev/null +++ b/node_modules/react-feather/dist/icons/zap.js @@ -0,0 +1,36 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var Zap = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("polygon", { + points: "13 2 3 14 12 14 11 22 21 10 12 10 13 2" + })); +}); +Zap.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +Zap.displayName = 'Zap'; +export default Zap; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/zoom-in.js b/node_modules/react-feather/dist/icons/zoom-in.js new file mode 100644 index 0000000..f612815 --- /dev/null +++ b/node_modules/react-feather/dist/icons/zoom-in.js @@ -0,0 +1,53 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ZoomIn = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "11", + cy: "11", + r: "8" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "21", + x2: "16.65", + y2: "16.65" + }), /*#__PURE__*/React.createElement("line", { + x1: "11", + y1: "8", + x2: "11", + y2: "14" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "11", + x2: "14", + y2: "11" + })); +}); +ZoomIn.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ZoomIn.displayName = 'ZoomIn'; +export default ZoomIn; \ No newline at end of file diff --git a/node_modules/react-feather/dist/icons/zoom-out.js b/node_modules/react-feather/dist/icons/zoom-out.js new file mode 100644 index 0000000..84f46d0 --- /dev/null +++ b/node_modules/react-feather/dist/icons/zoom-out.js @@ -0,0 +1,48 @@ +function _extends() { _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; }; return _extends.apply(this, arguments); } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +import React, { forwardRef } from 'react'; +import PropTypes from 'prop-types'; +var ZoomOut = forwardRef(function (_ref, ref) { + var _ref$color = _ref.color, + color = _ref$color === void 0 ? 'currentColor' : _ref$color, + _ref$size = _ref.size, + size = _ref$size === void 0 ? 24 : _ref$size, + rest = _objectWithoutProperties(_ref, ["color", "size"]); + + return /*#__PURE__*/React.createElement("svg", _extends({ + ref: ref, + xmlns: "http://www.w3.org/2000/svg", + width: size, + height: size, + viewBox: "0 0 24 24", + fill: "none", + stroke: color, + strokeWidth: "2", + strokeLinecap: "round", + strokeLinejoin: "round" + }, rest), /*#__PURE__*/React.createElement("circle", { + cx: "11", + cy: "11", + r: "8" + }), /*#__PURE__*/React.createElement("line", { + x1: "21", + y1: "21", + x2: "16.65", + y2: "16.65" + }), /*#__PURE__*/React.createElement("line", { + x1: "8", + y1: "11", + x2: "14", + y2: "11" + })); +}); +ZoomOut.propTypes = { + color: PropTypes.string, + size: PropTypes.oneOfType([PropTypes.string, PropTypes.number]) +}; +ZoomOut.displayName = 'ZoomOut'; +export default ZoomOut; \ No newline at end of file diff --git a/node_modules/react-feather/dist/index.d.ts b/node_modules/react-feather/dist/index.d.ts new file mode 100644 index 0000000..04886e1 --- /dev/null +++ b/node_modules/react-feather/dist/index.d.ts @@ -0,0 +1,296 @@ +/// +import { FC, SVGAttributes } from 'react'; + +export interface IconProps extends SVGAttributes { + color?: string; + size?: string | number; +} + +export type Icon = FC; +export const Activity: Icon; +export const Airplay: Icon; +export const AlertCircle: Icon; +export const AlertOctagon: Icon; +export const AlertTriangle: Icon; +export const AlignCenter: Icon; +export const AlignJustify: Icon; +export const AlignLeft: Icon; +export const AlignRight: Icon; +export const Anchor: Icon; +export const Aperture: Icon; +export const Archive: Icon; +export const ArrowDownCircle: Icon; +export const ArrowDownLeft: Icon; +export const ArrowDownRight: Icon; +export const ArrowDown: Icon; +export const ArrowLeftCircle: Icon; +export const ArrowLeft: Icon; +export const ArrowRightCircle: Icon; +export const ArrowRight: Icon; +export const ArrowUpCircle: Icon; +export const ArrowUpLeft: Icon; +export const ArrowUpRight: Icon; +export const ArrowUp: Icon; +export const AtSign: Icon; +export const Award: Icon; +export const BarChart2: Icon; +export const BarChart: Icon; +export const BatteryCharging: Icon; +export const Battery: Icon; +export const BellOff: Icon; +export const Bell: Icon; +export const Bluetooth: Icon; +export const Bold: Icon; +export const BookOpen: Icon; +export const Book: Icon; +export const Bookmark: Icon; +export const Box: Icon; +export const Briefcase: Icon; +export const Calendar: Icon; +export const CameraOff: Icon; +export const Camera: Icon; +export const Cast: Icon; +export const CheckCircle: Icon; +export const CheckSquare: Icon; +export const Check: Icon; +export const ChevronDown: Icon; +export const ChevronLeft: Icon; +export const ChevronRight: Icon; +export const ChevronUp: Icon; +export const ChevronsDown: Icon; +export const ChevronsLeft: Icon; +export const ChevronsRight: Icon; +export const ChevronsUp: Icon; +export const Chrome: Icon; +export const Circle: Icon; +export const Clipboard: Icon; +export const Clock: Icon; +export const CloudDrizzle: Icon; +export const CloudLightning: Icon; +export const CloudOff: Icon; +export const CloudRain: Icon; +export const CloudSnow: Icon; +export const Cloud: Icon; +export const Code: Icon; +export const Codepen: Icon; +export const Codesandbox: Icon; +export const Coffee: Icon; +export const Columns: Icon; +export const Command: Icon; +export const Compass: Icon; +export const Copy: Icon; +export const CornerDownLeft: Icon; +export const CornerDownRight: Icon; +export const CornerLeftDown: Icon; +export const CornerLeftUp: Icon; +export const CornerRightDown: Icon; +export const CornerRightUp: Icon; +export const CornerUpLeft: Icon; +export const CornerUpRight: Icon; +export const Cpu: Icon; +export const CreditCard: Icon; +export const Crop: Icon; +export const Crosshair: Icon; +export const Database: Icon; +export const Delete: Icon; +export const Disc: Icon; +export const DivideCircle: Icon; +export const DivideSquare: Icon; +export const Divide: Icon; +export const DollarSign: Icon; +export const DownloadCloud: Icon; +export const Download: Icon; +export const Dribbble: Icon; +export const Droplet: Icon; +export const Edit2: Icon; +export const Edit3: Icon; +export const Edit: Icon; +export const ExternalLink: Icon; +export const EyeOff: Icon; +export const Eye: Icon; +export const Facebook: Icon; +export const FastForward: Icon; +export const Feather: Icon; +export const Figma: Icon; +export const FileMinus: Icon; +export const FilePlus: Icon; +export const FileText: Icon; +export const File: Icon; +export const Film: Icon; +export const Filter: Icon; +export const Flag: Icon; +export const FolderMinus: Icon; +export const FolderPlus: Icon; +export const Folder: Icon; +export const Framer: Icon; +export const Frown: Icon; +export const Gift: Icon; +export const GitBranch: Icon; +export const GitCommit: Icon; +export const GitMerge: Icon; +export const GitPullRequest: Icon; +export const GitHub: Icon; +export const Gitlab: Icon; +export const Globe: Icon; +export const Grid: Icon; +export const HardDrive: Icon; +export const Hash: Icon; +export const Headphones: Icon; +export const Heart: Icon; +export const HelpCircle: Icon; +export const Hexagon: Icon; +export const Home: Icon; +export const Image: Icon; +export const Inbox: Icon; +export const Info: Icon; +export const Instagram: Icon; +export const Italic: Icon; +export const Key: Icon; +export const Layers: Icon; +export const Layout: Icon; +export const LifeBuoy: Icon; +export const Link2: Icon; +export const Link: Icon; +export const Linkedin: Icon; +export const List: Icon; +export const Loader: Icon; +export const Lock: Icon; +export const LogIn: Icon; +export const LogOut: Icon; +export const Mail: Icon; +export const MapPin: Icon; +export const Map: Icon; +export const Maximize2: Icon; +export const Maximize: Icon; +export const Meh: Icon; +export const Menu: Icon; +export const MessageCircle: Icon; +export const MessageSquare: Icon; +export const MicOff: Icon; +export const Mic: Icon; +export const Minimize2: Icon; +export const Minimize: Icon; +export const MinusCircle: Icon; +export const MinusSquare: Icon; +export const Minus: Icon; +export const Monitor: Icon; +export const Moon: Icon; +export const MoreHorizontal: Icon; +export const MoreVertical: Icon; +export const MousePointer: Icon; +export const Move: Icon; +export const Music: Icon; +export const Navigation2: Icon; +export const Navigation: Icon; +export const Octagon: Icon; +export const Package: Icon; +export const Paperclip: Icon; +export const PauseCircle: Icon; +export const Pause: Icon; +export const PenTool: Icon; +export const Percent: Icon; +export const PhoneCall: Icon; +export const PhoneForwarded: Icon; +export const PhoneIncoming: Icon; +export const PhoneMissed: Icon; +export const PhoneOff: Icon; +export const PhoneOutgoing: Icon; +export const Phone: Icon; +export const PieChart: Icon; +export const PlayCircle: Icon; +export const Play: Icon; +export const PlusCircle: Icon; +export const PlusSquare: Icon; +export const Plus: Icon; +export const Pocket: Icon; +export const Power: Icon; +export const Printer: Icon; +export const Radio: Icon; +export const RefreshCcw: Icon; +export const RefreshCw: Icon; +export const Repeat: Icon; +export const Rewind: Icon; +export const RotateCcw: Icon; +export const RotateCw: Icon; +export const Rss: Icon; +export const Save: Icon; +export const Scissors: Icon; +export const Search: Icon; +export const Send: Icon; +export const Server: Icon; +export const Settings: Icon; +export const Share2: Icon; +export const Share: Icon; +export const ShieldOff: Icon; +export const Shield: Icon; +export const ShoppingBag: Icon; +export const ShoppingCart: Icon; +export const Shuffle: Icon; +export const Sidebar: Icon; +export const SkipBack: Icon; +export const SkipForward: Icon; +export const Slack: Icon; +export const Slash: Icon; +export const Sliders: Icon; +export const Smartphone: Icon; +export const Smile: Icon; +export const Speaker: Icon; +export const Square: Icon; +export const Star: Icon; +export const StopCircle: Icon; +export const Sun: Icon; +export const Sunrise: Icon; +export const Sunset: Icon; +export const Table: Icon; +export const Tablet: Icon; +export const Tag: Icon; +export const Target: Icon; +export const Terminal: Icon; +export const Thermometer: Icon; +export const ThumbsDown: Icon; +export const ThumbsUp: Icon; +export const ToggleLeft: Icon; +export const ToggleRight: Icon; +export const Tool: Icon; +export const Trash2: Icon; +export const Trash: Icon; +export const Trello: Icon; +export const TrendingDown: Icon; +export const TrendingUp: Icon; +export const Triangle: Icon; +export const Truck: Icon; +export const Tv: Icon; +export const Twitch: Icon; +export const Twitter: Icon; +export const Type: Icon; +export const Umbrella: Icon; +export const Underline: Icon; +export const Unlock: Icon; +export const UploadCloud: Icon; +export const Upload: Icon; +export const UserCheck: Icon; +export const UserMinus: Icon; +export const UserPlus: Icon; +export const UserX: Icon; +export const User: Icon; +export const Users: Icon; +export const VideoOff: Icon; +export const Video: Icon; +export const Voicemail: Icon; +export const Volume1: Icon; +export const Volume2: Icon; +export const VolumeX: Icon; +export const Volume: Icon; +export const Watch: Icon; +export const WifiOff: Icon; +export const Wifi: Icon; +export const Wind: Icon; +export const XCircle: Icon; +export const XOctagon: Icon; +export const XSquare: Icon; +export const X: Icon; +export const Youtube: Icon; +export const ZapOff: Icon; +export const Zap: Icon; +export const ZoomIn: Icon; +export const ZoomOut: Icon; diff --git a/node_modules/react-feather/dist/index.js b/node_modules/react-feather/dist/index.js new file mode 100644 index 0000000..fbc7270 --- /dev/null +++ b/node_modules/react-feather/dist/index.js @@ -0,0 +1,287 @@ +export { default as Activity } from './icons/activity'; +export { default as Airplay } from './icons/airplay'; +export { default as AlertCircle } from './icons/alert-circle'; +export { default as AlertOctagon } from './icons/alert-octagon'; +export { default as AlertTriangle } from './icons/alert-triangle'; +export { default as AlignCenter } from './icons/align-center'; +export { default as AlignJustify } from './icons/align-justify'; +export { default as AlignLeft } from './icons/align-left'; +export { default as AlignRight } from './icons/align-right'; +export { default as Anchor } from './icons/anchor'; +export { default as Aperture } from './icons/aperture'; +export { default as Archive } from './icons/archive'; +export { default as ArrowDownCircle } from './icons/arrow-down-circle'; +export { default as ArrowDownLeft } from './icons/arrow-down-left'; +export { default as ArrowDownRight } from './icons/arrow-down-right'; +export { default as ArrowDown } from './icons/arrow-down'; +export { default as ArrowLeftCircle } from './icons/arrow-left-circle'; +export { default as ArrowLeft } from './icons/arrow-left'; +export { default as ArrowRightCircle } from './icons/arrow-right-circle'; +export { default as ArrowRight } from './icons/arrow-right'; +export { default as ArrowUpCircle } from './icons/arrow-up-circle'; +export { default as ArrowUpLeft } from './icons/arrow-up-left'; +export { default as ArrowUpRight } from './icons/arrow-up-right'; +export { default as ArrowUp } from './icons/arrow-up'; +export { default as AtSign } from './icons/at-sign'; +export { default as Award } from './icons/award'; +export { default as BarChart2 } from './icons/bar-chart-2'; +export { default as BarChart } from './icons/bar-chart'; +export { default as BatteryCharging } from './icons/battery-charging'; +export { default as Battery } from './icons/battery'; +export { default as BellOff } from './icons/bell-off'; +export { default as Bell } from './icons/bell'; +export { default as Bluetooth } from './icons/bluetooth'; +export { default as Bold } from './icons/bold'; +export { default as BookOpen } from './icons/book-open'; +export { default as Book } from './icons/book'; +export { default as Bookmark } from './icons/bookmark'; +export { default as Box } from './icons/box'; +export { default as Briefcase } from './icons/briefcase'; +export { default as Calendar } from './icons/calendar'; +export { default as CameraOff } from './icons/camera-off'; +export { default as Camera } from './icons/camera'; +export { default as Cast } from './icons/cast'; +export { default as CheckCircle } from './icons/check-circle'; +export { default as CheckSquare } from './icons/check-square'; +export { default as Check } from './icons/check'; +export { default as ChevronDown } from './icons/chevron-down'; +export { default as ChevronLeft } from './icons/chevron-left'; +export { default as ChevronRight } from './icons/chevron-right'; +export { default as ChevronUp } from './icons/chevron-up'; +export { default as ChevronsDown } from './icons/chevrons-down'; +export { default as ChevronsLeft } from './icons/chevrons-left'; +export { default as ChevronsRight } from './icons/chevrons-right'; +export { default as ChevronsUp } from './icons/chevrons-up'; +export { default as Chrome } from './icons/chrome'; +export { default as Circle } from './icons/circle'; +export { default as Clipboard } from './icons/clipboard'; +export { default as Clock } from './icons/clock'; +export { default as CloudDrizzle } from './icons/cloud-drizzle'; +export { default as CloudLightning } from './icons/cloud-lightning'; +export { default as CloudOff } from './icons/cloud-off'; +export { default as CloudRain } from './icons/cloud-rain'; +export { default as CloudSnow } from './icons/cloud-snow'; +export { default as Cloud } from './icons/cloud'; +export { default as Code } from './icons/code'; +export { default as Codepen } from './icons/codepen'; +export { default as Codesandbox } from './icons/codesandbox'; +export { default as Coffee } from './icons/coffee'; +export { default as Columns } from './icons/columns'; +export { default as Command } from './icons/command'; +export { default as Compass } from './icons/compass'; +export { default as Copy } from './icons/copy'; +export { default as CornerDownLeft } from './icons/corner-down-left'; +export { default as CornerDownRight } from './icons/corner-down-right'; +export { default as CornerLeftDown } from './icons/corner-left-down'; +export { default as CornerLeftUp } from './icons/corner-left-up'; +export { default as CornerRightDown } from './icons/corner-right-down'; +export { default as CornerRightUp } from './icons/corner-right-up'; +export { default as CornerUpLeft } from './icons/corner-up-left'; +export { default as CornerUpRight } from './icons/corner-up-right'; +export { default as Cpu } from './icons/cpu'; +export { default as CreditCard } from './icons/credit-card'; +export { default as Crop } from './icons/crop'; +export { default as Crosshair } from './icons/crosshair'; +export { default as Database } from './icons/database'; +export { default as Delete } from './icons/delete'; +export { default as Disc } from './icons/disc'; +export { default as DivideCircle } from './icons/divide-circle'; +export { default as DivideSquare } from './icons/divide-square'; +export { default as Divide } from './icons/divide'; +export { default as DollarSign } from './icons/dollar-sign'; +export { default as DownloadCloud } from './icons/download-cloud'; +export { default as Download } from './icons/download'; +export { default as Dribbble } from './icons/dribbble'; +export { default as Droplet } from './icons/droplet'; +export { default as Edit2 } from './icons/edit-2'; +export { default as Edit3 } from './icons/edit-3'; +export { default as Edit } from './icons/edit'; +export { default as ExternalLink } from './icons/external-link'; +export { default as EyeOff } from './icons/eye-off'; +export { default as Eye } from './icons/eye'; +export { default as Facebook } from './icons/facebook'; +export { default as FastForward } from './icons/fast-forward'; +export { default as Feather } from './icons/feather'; +export { default as Figma } from './icons/figma'; +export { default as FileMinus } from './icons/file-minus'; +export { default as FilePlus } from './icons/file-plus'; +export { default as FileText } from './icons/file-text'; +export { default as File } from './icons/file'; +export { default as Film } from './icons/film'; +export { default as Filter } from './icons/filter'; +export { default as Flag } from './icons/flag'; +export { default as FolderMinus } from './icons/folder-minus'; +export { default as FolderPlus } from './icons/folder-plus'; +export { default as Folder } from './icons/folder'; +export { default as Framer } from './icons/framer'; +export { default as Frown } from './icons/frown'; +export { default as Gift } from './icons/gift'; +export { default as GitBranch } from './icons/git-branch'; +export { default as GitCommit } from './icons/git-commit'; +export { default as GitMerge } from './icons/git-merge'; +export { default as GitPullRequest } from './icons/git-pull-request'; +export { default as GitHub } from './icons/github'; +export { default as Gitlab } from './icons/gitlab'; +export { default as Globe } from './icons/globe'; +export { default as Grid } from './icons/grid'; +export { default as HardDrive } from './icons/hard-drive'; +export { default as Hash } from './icons/hash'; +export { default as Headphones } from './icons/headphones'; +export { default as Heart } from './icons/heart'; +export { default as HelpCircle } from './icons/help-circle'; +export { default as Hexagon } from './icons/hexagon'; +export { default as Home } from './icons/home'; +export { default as Image } from './icons/image'; +export { default as Inbox } from './icons/inbox'; +export { default as Info } from './icons/info'; +export { default as Instagram } from './icons/instagram'; +export { default as Italic } from './icons/italic'; +export { default as Key } from './icons/key'; +export { default as Layers } from './icons/layers'; +export { default as Layout } from './icons/layout'; +export { default as LifeBuoy } from './icons/life-buoy'; +export { default as Link2 } from './icons/link-2'; +export { default as Link } from './icons/link'; +export { default as Linkedin } from './icons/linkedin'; +export { default as List } from './icons/list'; +export { default as Loader } from './icons/loader'; +export { default as Lock } from './icons/lock'; +export { default as LogIn } from './icons/log-in'; +export { default as LogOut } from './icons/log-out'; +export { default as Mail } from './icons/mail'; +export { default as MapPin } from './icons/map-pin'; +export { default as Map } from './icons/map'; +export { default as Maximize2 } from './icons/maximize-2'; +export { default as Maximize } from './icons/maximize'; +export { default as Meh } from './icons/meh'; +export { default as Menu } from './icons/menu'; +export { default as MessageCircle } from './icons/message-circle'; +export { default as MessageSquare } from './icons/message-square'; +export { default as MicOff } from './icons/mic-off'; +export { default as Mic } from './icons/mic'; +export { default as Minimize2 } from './icons/minimize-2'; +export { default as Minimize } from './icons/minimize'; +export { default as MinusCircle } from './icons/minus-circle'; +export { default as MinusSquare } from './icons/minus-square'; +export { default as Minus } from './icons/minus'; +export { default as Monitor } from './icons/monitor'; +export { default as Moon } from './icons/moon'; +export { default as MoreHorizontal } from './icons/more-horizontal'; +export { default as MoreVertical } from './icons/more-vertical'; +export { default as MousePointer } from './icons/mouse-pointer'; +export { default as Move } from './icons/move'; +export { default as Music } from './icons/music'; +export { default as Navigation2 } from './icons/navigation-2'; +export { default as Navigation } from './icons/navigation'; +export { default as Octagon } from './icons/octagon'; +export { default as Package } from './icons/package'; +export { default as Paperclip } from './icons/paperclip'; +export { default as PauseCircle } from './icons/pause-circle'; +export { default as Pause } from './icons/pause'; +export { default as PenTool } from './icons/pen-tool'; +export { default as Percent } from './icons/percent'; +export { default as PhoneCall } from './icons/phone-call'; +export { default as PhoneForwarded } from './icons/phone-forwarded'; +export { default as PhoneIncoming } from './icons/phone-incoming'; +export { default as PhoneMissed } from './icons/phone-missed'; +export { default as PhoneOff } from './icons/phone-off'; +export { default as PhoneOutgoing } from './icons/phone-outgoing'; +export { default as Phone } from './icons/phone'; +export { default as PieChart } from './icons/pie-chart'; +export { default as PlayCircle } from './icons/play-circle'; +export { default as Play } from './icons/play'; +export { default as PlusCircle } from './icons/plus-circle'; +export { default as PlusSquare } from './icons/plus-square'; +export { default as Plus } from './icons/plus'; +export { default as Pocket } from './icons/pocket'; +export { default as Power } from './icons/power'; +export { default as Printer } from './icons/printer'; +export { default as Radio } from './icons/radio'; +export { default as RefreshCcw } from './icons/refresh-ccw'; +export { default as RefreshCw } from './icons/refresh-cw'; +export { default as Repeat } from './icons/repeat'; +export { default as Rewind } from './icons/rewind'; +export { default as RotateCcw } from './icons/rotate-ccw'; +export { default as RotateCw } from './icons/rotate-cw'; +export { default as Rss } from './icons/rss'; +export { default as Save } from './icons/save'; +export { default as Scissors } from './icons/scissors'; +export { default as Search } from './icons/search'; +export { default as Send } from './icons/send'; +export { default as Server } from './icons/server'; +export { default as Settings } from './icons/settings'; +export { default as Share2 } from './icons/share-2'; +export { default as Share } from './icons/share'; +export { default as ShieldOff } from './icons/shield-off'; +export { default as Shield } from './icons/shield'; +export { default as ShoppingBag } from './icons/shopping-bag'; +export { default as ShoppingCart } from './icons/shopping-cart'; +export { default as Shuffle } from './icons/shuffle'; +export { default as Sidebar } from './icons/sidebar'; +export { default as SkipBack } from './icons/skip-back'; +export { default as SkipForward } from './icons/skip-forward'; +export { default as Slack } from './icons/slack'; +export { default as Slash } from './icons/slash'; +export { default as Sliders } from './icons/sliders'; +export { default as Smartphone } from './icons/smartphone'; +export { default as Smile } from './icons/smile'; +export { default as Speaker } from './icons/speaker'; +export { default as Square } from './icons/square'; +export { default as Star } from './icons/star'; +export { default as StopCircle } from './icons/stop-circle'; +export { default as Sun } from './icons/sun'; +export { default as Sunrise } from './icons/sunrise'; +export { default as Sunset } from './icons/sunset'; +export { default as Table } from './icons/table'; +export { default as Tablet } from './icons/tablet'; +export { default as Tag } from './icons/tag'; +export { default as Target } from './icons/target'; +export { default as Terminal } from './icons/terminal'; +export { default as Thermometer } from './icons/thermometer'; +export { default as ThumbsDown } from './icons/thumbs-down'; +export { default as ThumbsUp } from './icons/thumbs-up'; +export { default as ToggleLeft } from './icons/toggle-left'; +export { default as ToggleRight } from './icons/toggle-right'; +export { default as Tool } from './icons/tool'; +export { default as Trash2 } from './icons/trash-2'; +export { default as Trash } from './icons/trash'; +export { default as Trello } from './icons/trello'; +export { default as TrendingDown } from './icons/trending-down'; +export { default as TrendingUp } from './icons/trending-up'; +export { default as Triangle } from './icons/triangle'; +export { default as Truck } from './icons/truck'; +export { default as Tv } from './icons/tv'; +export { default as Twitch } from './icons/twitch'; +export { default as Twitter } from './icons/twitter'; +export { default as Type } from './icons/type'; +export { default as Umbrella } from './icons/umbrella'; +export { default as Underline } from './icons/underline'; +export { default as Unlock } from './icons/unlock'; +export { default as UploadCloud } from './icons/upload-cloud'; +export { default as Upload } from './icons/upload'; +export { default as UserCheck } from './icons/user-check'; +export { default as UserMinus } from './icons/user-minus'; +export { default as UserPlus } from './icons/user-plus'; +export { default as UserX } from './icons/user-x'; +export { default as User } from './icons/user'; +export { default as Users } from './icons/users'; +export { default as VideoOff } from './icons/video-off'; +export { default as Video } from './icons/video'; +export { default as Voicemail } from './icons/voicemail'; +export { default as Volume1 } from './icons/volume-1'; +export { default as Volume2 } from './icons/volume-2'; +export { default as VolumeX } from './icons/volume-x'; +export { default as Volume } from './icons/volume'; +export { default as Watch } from './icons/watch'; +export { default as WifiOff } from './icons/wifi-off'; +export { default as Wifi } from './icons/wifi'; +export { default as Wind } from './icons/wind'; +export { default as XCircle } from './icons/x-circle'; +export { default as XOctagon } from './icons/x-octagon'; +export { default as XSquare } from './icons/x-square'; +export { default as X } from './icons/x'; +export { default as Youtube } from './icons/youtube'; +export { default as ZapOff } from './icons/zap-off'; +export { default as Zap } from './icons/zap'; +export { default as ZoomIn } from './icons/zoom-in'; +export { default as ZoomOut } from './icons/zoom-out'; \ No newline at end of file diff --git a/node_modules/react-feather/package.json b/node_modules/react-feather/package.json new file mode 100644 index 0000000..728ec79 --- /dev/null +++ b/node_modules/react-feather/package.json @@ -0,0 +1,64 @@ +{ + "name": "react-feather", + "version": "2.0.10", + "description": "React component for Feather icons", + "main": "build/index.js", + "module": "dist/index.js", + "sideEffects": false, + "typings": "dist/index.d.ts", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1", + "compile": "rm -rf src/icons && node bin/build.js", + "build:bundle": "rm -rf build && rollup --config rollup.config.js", + "build:es": "rm -rf dist && babel src --out-dir dist --copy-files", + "build": "concurrently \"npm:build:*\"" + }, + "files": [ + "dist", + "es" + ], + "repository": { + "type": "git", + "url": "git+https://github.com/feathericons/react-feather.git" + }, + "keywords": [ + "react", + "icons", + "svg", + "inline", + "feather", + "design" + ], + "author": "Carmelo Pullara", + "license": "MIT", + "bugs": { + "url": "https://github.com/feathericons/react-feather/issues" + }, + "homepage": "https://github.com/feathericons/react-feather#readme", + "devDependencies": { + "@babel/cli": "^7.4.4", + "@babel/core": "^7.4.5", + "@babel/plugin-proposal-object-rest-spread": "^7.4.4", + "@babel/preset-env": "^7.4.5", + "@babel/preset-react": "^7.0.0", + "babel-plugin-transform-object-rest-spread": "^6.26.0", + "babel-preset-env": "^1.7.0", + "concurrently": "^5.1.0", + "eslint": "^6.8.0", + "eslint-config-airbnb": "^18.1.0", + "eslint-plugin-import": "^2.18.0", + "eslint-plugin-jsx-a11y": "^6.2.3", + "eslint-plugin-react": "^7.14.2", + "feather-icons": "^4.29.0", + "prettier-eslint": "^9.0.0", + "rollup": "^2.3.3", + "rollup-plugin-babel": "^4.3.3", + "uppercamelcase": "^3.0.0" + }, + "peerDependencies": { + "react": ">=16.8.6" + }, + "dependencies": { + "prop-types": "^15.7.2" + } +} diff --git a/node_modules/react-is/LICENSE b/node_modules/react-is/LICENSE new file mode 100644 index 0000000..b96dcb0 --- /dev/null +++ b/node_modules/react-is/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Facebook, Inc. and its affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/react-is/README.md b/node_modules/react-is/README.md new file mode 100644 index 0000000..d255977 --- /dev/null +++ b/node_modules/react-is/README.md @@ -0,0 +1,104 @@ +# `react-is` + +This package allows you to test arbitrary values and see if they're a particular React element type. + +## Installation + +```sh +# Yarn +yarn add react-is + +# NPM +npm install react-is +``` + +## Usage + +### Determining if a Component is Valid + +```js +import React from "react"; +import * as ReactIs from "react-is"; + +class ClassComponent extends React.Component { + render() { + return React.createElement("div"); + } +} + +const FunctionComponent = () => React.createElement("div"); + +const ForwardRefComponent = React.forwardRef((props, ref) => + React.createElement(Component, { forwardedRef: ref, ...props }) +); + +const Context = React.createContext(false); + +ReactIs.isValidElementType("div"); // true +ReactIs.isValidElementType(ClassComponent); // true +ReactIs.isValidElementType(FunctionComponent); // true +ReactIs.isValidElementType(ForwardRefComponent); // true +ReactIs.isValidElementType(Context.Provider); // true +ReactIs.isValidElementType(Context.Consumer); // true +ReactIs.isValidElementType(React.createFactory("div")); // true +``` + +### Determining an Element's Type + +#### Context + +```js +import React from "react"; +import * as ReactIs from 'react-is'; + +const ThemeContext = React.createContext("blue"); + +ReactIs.isContextConsumer(); // true +ReactIs.isContextProvider(); // true +ReactIs.typeOf() === ReactIs.ContextProvider; // true +ReactIs.typeOf() === ReactIs.ContextConsumer; // true +``` + +#### Element + +```js +import React from "react"; +import * as ReactIs from 'react-is'; + +ReactIs.isElement(
); // true +ReactIs.typeOf(
) === ReactIs.Element; // true +``` + +#### Fragment + +```js +import React from "react"; +import * as ReactIs from 'react-is'; + +ReactIs.isFragment(<>); // true +ReactIs.typeOf(<>) === ReactIs.Fragment; // true +``` + +#### Portal + +```js +import React from "react"; +import ReactDOM from "react-dom"; +import * as ReactIs from 'react-is'; + +const div = document.createElement("div"); +const portal = ReactDOM.createPortal(
, div); + +ReactIs.isPortal(portal); // true +ReactIs.typeOf(portal) === ReactIs.Portal; // true +``` + +#### StrictMode + +```js +import React from "react"; +import * as ReactIs from 'react-is'; + +ReactIs.isStrictMode(); // true +ReactIs.typeOf() === ReactIs.StrictMode; // true +``` diff --git a/node_modules/react-is/build-info.json b/node_modules/react-is/build-info.json new file mode 100644 index 0000000..4094da6 --- /dev/null +++ b/node_modules/react-is/build-info.json @@ -0,0 +1,8 @@ +{ + "branch": "pull/18344", + "buildNumber": "106499", + "checksum": "7fe5a2e", + "commit": "da834083c", + "environment": "ci", + "reactVersion": "16.12.0-da834083c" +} diff --git a/node_modules/react-is/cjs/react-is.development.js b/node_modules/react-is/cjs/react-is.development.js new file mode 100644 index 0000000..8a80b76 --- /dev/null +++ b/node_modules/react-is/cjs/react-is.development.js @@ -0,0 +1,181 @@ +/** @license React v16.13.1 + * react-is.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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") { + (function() { +'use strict'; + +// The Symbol used to tag the ReactElement-like types. If there is no native Symbol +// nor polyfill, then a plain number is used for performance. +var hasSymbol = typeof Symbol === 'function' && Symbol.for; +var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7; +var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca; +var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb; +var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc; +var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2; +var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd; +var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary +// (unstable) APIs that have been removed. Can we remove the symbols? + +var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf; +var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf; +var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0; +var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1; +var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8; +var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3; +var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4; +var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9; +var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5; +var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6; +var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7; + +function isValidElementType(type) { + return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill. + type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE); +} + +function typeOf(object) { + if (typeof object === 'object' && object !== null) { + var $$typeof = object.$$typeof; + + switch ($$typeof) { + case REACT_ELEMENT_TYPE: + var type = object.type; + + switch (type) { + case REACT_ASYNC_MODE_TYPE: + case REACT_CONCURRENT_MODE_TYPE: + case REACT_FRAGMENT_TYPE: + case REACT_PROFILER_TYPE: + case REACT_STRICT_MODE_TYPE: + case REACT_SUSPENSE_TYPE: + return type; + + default: + var $$typeofType = type && type.$$typeof; + + switch ($$typeofType) { + case REACT_CONTEXT_TYPE: + case REACT_FORWARD_REF_TYPE: + case REACT_LAZY_TYPE: + case REACT_MEMO_TYPE: + case REACT_PROVIDER_TYPE: + return $$typeofType; + + default: + return $$typeof; + } + + } + + case REACT_PORTAL_TYPE: + return $$typeof; + } + } + + return undefined; +} // AsyncMode is deprecated along with isAsyncMode + +var AsyncMode = REACT_ASYNC_MODE_TYPE; +var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE; +var ContextConsumer = REACT_CONTEXT_TYPE; +var ContextProvider = REACT_PROVIDER_TYPE; +var Element = REACT_ELEMENT_TYPE; +var ForwardRef = REACT_FORWARD_REF_TYPE; +var Fragment = REACT_FRAGMENT_TYPE; +var Lazy = REACT_LAZY_TYPE; +var Memo = REACT_MEMO_TYPE; +var Portal = REACT_PORTAL_TYPE; +var Profiler = REACT_PROFILER_TYPE; +var StrictMode = REACT_STRICT_MODE_TYPE; +var Suspense = REACT_SUSPENSE_TYPE; +var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated + +function isAsyncMode(object) { + { + if (!hasWarnedAboutDeprecatedIsAsyncMode) { + hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint + + console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.'); + } + } + + return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE; +} +function isConcurrentMode(object) { + return typeOf(object) === REACT_CONCURRENT_MODE_TYPE; +} +function isContextConsumer(object) { + return typeOf(object) === REACT_CONTEXT_TYPE; +} +function isContextProvider(object) { + return typeOf(object) === REACT_PROVIDER_TYPE; +} +function isElement(object) { + return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; +} +function isForwardRef(object) { + return typeOf(object) === REACT_FORWARD_REF_TYPE; +} +function isFragment(object) { + return typeOf(object) === REACT_FRAGMENT_TYPE; +} +function isLazy(object) { + return typeOf(object) === REACT_LAZY_TYPE; +} +function isMemo(object) { + return typeOf(object) === REACT_MEMO_TYPE; +} +function isPortal(object) { + return typeOf(object) === REACT_PORTAL_TYPE; +} +function isProfiler(object) { + return typeOf(object) === REACT_PROFILER_TYPE; +} +function isStrictMode(object) { + return typeOf(object) === REACT_STRICT_MODE_TYPE; +} +function isSuspense(object) { + return typeOf(object) === REACT_SUSPENSE_TYPE; +} + +exports.AsyncMode = AsyncMode; +exports.ConcurrentMode = ConcurrentMode; +exports.ContextConsumer = ContextConsumer; +exports.ContextProvider = ContextProvider; +exports.Element = Element; +exports.ForwardRef = ForwardRef; +exports.Fragment = Fragment; +exports.Lazy = Lazy; +exports.Memo = Memo; +exports.Portal = Portal; +exports.Profiler = Profiler; +exports.StrictMode = StrictMode; +exports.Suspense = Suspense; +exports.isAsyncMode = isAsyncMode; +exports.isConcurrentMode = isConcurrentMode; +exports.isContextConsumer = isContextConsumer; +exports.isContextProvider = isContextProvider; +exports.isElement = isElement; +exports.isForwardRef = isForwardRef; +exports.isFragment = isFragment; +exports.isLazy = isLazy; +exports.isMemo = isMemo; +exports.isPortal = isPortal; +exports.isProfiler = isProfiler; +exports.isStrictMode = isStrictMode; +exports.isSuspense = isSuspense; +exports.isValidElementType = isValidElementType; +exports.typeOf = typeOf; + })(); +} diff --git a/node_modules/react-is/cjs/react-is.production.min.js b/node_modules/react-is/cjs/react-is.production.min.js new file mode 100644 index 0000000..3e83c7a --- /dev/null +++ b/node_modules/react-is/cjs/react-is.production.min.js @@ -0,0 +1,15 @@ +/** @license React v16.13.1 + * react-is.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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 b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b? +Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119; +function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d; +exports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t}; +exports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p}; +exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z; diff --git a/node_modules/react-is/index.js b/node_modules/react-is/index.js new file mode 100644 index 0000000..3ae098d --- /dev/null +++ b/node_modules/react-is/index.js @@ -0,0 +1,7 @@ +'use strict'; + +if (process.env.NODE_ENV === 'production') { + module.exports = require('./cjs/react-is.production.min.js'); +} else { + module.exports = require('./cjs/react-is.development.js'); +} diff --git a/node_modules/react-is/package.json b/node_modules/react-is/package.json new file mode 100644 index 0000000..5f32de2 --- /dev/null +++ b/node_modules/react-is/package.json @@ -0,0 +1,27 @@ +{ + "name": "react-is", + "version": "16.13.1", + "description": "Brand checking of React Elements.", + "main": "index.js", + "repository": { + "type": "git", + "url": "https://github.com/facebook/react.git", + "directory": "packages/react-is" + }, + "keywords": [ + "react" + ], + "license": "MIT", + "bugs": { + "url": "https://github.com/facebook/react/issues" + }, + "homepage": "https://reactjs.org/", + "files": [ + "LICENSE", + "README.md", + "build-info.json", + "index.js", + "cjs/", + "umd/" + ] +} diff --git a/node_modules/react-is/umd/react-is.development.js b/node_modules/react-is/umd/react-is.development.js new file mode 100644 index 0000000..a6bc018 --- /dev/null +++ b/node_modules/react-is/umd/react-is.development.js @@ -0,0 +1,181 @@ +/** @license React v16.13.1 + * react-is.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +'use strict'; + +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = global || self, factory(global.ReactIs = {})); +}(this, (function (exports) { 'use strict'; + + // The Symbol used to tag the ReactElement-like types. If there is no native Symbol + // nor polyfill, then a plain number is used for performance. + var hasSymbol = typeof Symbol === 'function' && Symbol.for; + var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7; + var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca; + var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb; + var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc; + var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2; + var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd; + var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary + // (unstable) APIs that have been removed. Can we remove the symbols? + + var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf; + var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf; + var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0; + var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1; + var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8; + var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3; + var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4; + var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9; + var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5; + var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6; + var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7; + + function isValidElementType(type) { + return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill. + type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE); + } + + function typeOf(object) { + if (typeof object === 'object' && object !== null) { + var $$typeof = object.$$typeof; + + switch ($$typeof) { + case REACT_ELEMENT_TYPE: + var type = object.type; + + switch (type) { + case REACT_ASYNC_MODE_TYPE: + case REACT_CONCURRENT_MODE_TYPE: + case REACT_FRAGMENT_TYPE: + case REACT_PROFILER_TYPE: + case REACT_STRICT_MODE_TYPE: + case REACT_SUSPENSE_TYPE: + return type; + + default: + var $$typeofType = type && type.$$typeof; + + switch ($$typeofType) { + case REACT_CONTEXT_TYPE: + case REACT_FORWARD_REF_TYPE: + case REACT_LAZY_TYPE: + case REACT_MEMO_TYPE: + case REACT_PROVIDER_TYPE: + return $$typeofType; + + default: + return $$typeof; + } + + } + + case REACT_PORTAL_TYPE: + return $$typeof; + } + } + + return undefined; + } // AsyncMode is deprecated along with isAsyncMode + + var AsyncMode = REACT_ASYNC_MODE_TYPE; + var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE; + var ContextConsumer = REACT_CONTEXT_TYPE; + var ContextProvider = REACT_PROVIDER_TYPE; + var Element = REACT_ELEMENT_TYPE; + var ForwardRef = REACT_FORWARD_REF_TYPE; + var Fragment = REACT_FRAGMENT_TYPE; + var Lazy = REACT_LAZY_TYPE; + var Memo = REACT_MEMO_TYPE; + var Portal = REACT_PORTAL_TYPE; + var Profiler = REACT_PROFILER_TYPE; + var StrictMode = REACT_STRICT_MODE_TYPE; + var Suspense = REACT_SUSPENSE_TYPE; + var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated + + function isAsyncMode(object) { + { + if (!hasWarnedAboutDeprecatedIsAsyncMode) { + hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint + + console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.'); + } + } + + return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE; + } + function isConcurrentMode(object) { + return typeOf(object) === REACT_CONCURRENT_MODE_TYPE; + } + function isContextConsumer(object) { + return typeOf(object) === REACT_CONTEXT_TYPE; + } + function isContextProvider(object) { + return typeOf(object) === REACT_PROVIDER_TYPE; + } + function isElement(object) { + return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; + } + function isForwardRef(object) { + return typeOf(object) === REACT_FORWARD_REF_TYPE; + } + function isFragment(object) { + return typeOf(object) === REACT_FRAGMENT_TYPE; + } + function isLazy(object) { + return typeOf(object) === REACT_LAZY_TYPE; + } + function isMemo(object) { + return typeOf(object) === REACT_MEMO_TYPE; + } + function isPortal(object) { + return typeOf(object) === REACT_PORTAL_TYPE; + } + function isProfiler(object) { + return typeOf(object) === REACT_PROFILER_TYPE; + } + function isStrictMode(object) { + return typeOf(object) === REACT_STRICT_MODE_TYPE; + } + function isSuspense(object) { + return typeOf(object) === REACT_SUSPENSE_TYPE; + } + + exports.AsyncMode = AsyncMode; + exports.ConcurrentMode = ConcurrentMode; + exports.ContextConsumer = ContextConsumer; + exports.ContextProvider = ContextProvider; + exports.Element = Element; + exports.ForwardRef = ForwardRef; + exports.Fragment = Fragment; + exports.Lazy = Lazy; + exports.Memo = Memo; + exports.Portal = Portal; + exports.Profiler = Profiler; + exports.StrictMode = StrictMode; + exports.Suspense = Suspense; + exports.isAsyncMode = isAsyncMode; + exports.isConcurrentMode = isConcurrentMode; + exports.isContextConsumer = isContextConsumer; + exports.isContextProvider = isContextProvider; + exports.isElement = isElement; + exports.isForwardRef = isForwardRef; + exports.isFragment = isFragment; + exports.isLazy = isLazy; + exports.isMemo = isMemo; + exports.isPortal = isPortal; + exports.isProfiler = isProfiler; + exports.isStrictMode = isStrictMode; + exports.isSuspense = isSuspense; + exports.isValidElementType = isValidElementType; + exports.typeOf = typeOf; + +}))); diff --git a/node_modules/react-is/umd/react-is.production.min.js b/node_modules/react-is/umd/react-is.production.min.js new file mode 100644 index 0000000..62fe6b2 --- /dev/null +++ b/node_modules/react-is/umd/react-is.production.min.js @@ -0,0 +1,13 @@ +/** @license React v16.13.1 + * react-is.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +'use strict';(function(b,d){"object"===typeof exports&&"undefined"!==typeof module?d(exports):"function"===typeof define&&define.amd?define(["exports"],d):(b=b||self,d(b.ReactIs={}))})(this,function(b){function d(a){if("object"===typeof a&&null!==a){var b=a.$$typeof;switch(b){case r:switch(a=a.type,a){case t:case e:case f:case g:case h:case k:return a;default:switch(a=a&&a.$$typeof,a){case l:case m:case n:case p:case q:return a;default:return b}}case u:return b}}}function v(a){return d(a)===e}var c= +"function"===typeof Symbol&&Symbol.for,r=c?Symbol.for("react.element"):60103,u=c?Symbol.for("react.portal"):60106,f=c?Symbol.for("react.fragment"):60107,h=c?Symbol.for("react.strict_mode"):60108,g=c?Symbol.for("react.profiler"):60114,q=c?Symbol.for("react.provider"):60109,l=c?Symbol.for("react.context"):60110,t=c?Symbol.for("react.async_mode"):60111,e=c?Symbol.for("react.concurrent_mode"):60111,m=c?Symbol.for("react.forward_ref"):60112,k=c?Symbol.for("react.suspense"):60113,w=c?Symbol.for("react.suspense_list"): +60120,p=c?Symbol.for("react.memo"):60115,n=c?Symbol.for("react.lazy"):60116,x=c?Symbol.for("react.block"):60121,y=c?Symbol.for("react.fundamental"):60117,z=c?Symbol.for("react.responder"):60118,A=c?Symbol.for("react.scope"):60119;b.AsyncMode=t;b.ConcurrentMode=e;b.ContextConsumer=l;b.ContextProvider=q;b.Element=r;b.ForwardRef=m;b.Fragment=f;b.Lazy=n;b.Memo=p;b.Portal=u;b.Profiler=g;b.StrictMode=h;b.Suspense=k;b.isAsyncMode=function(a){return v(a)||d(a)===t};b.isConcurrentMode=v;b.isContextConsumer= +function(a){return d(a)===l};b.isContextProvider=function(a){return d(a)===q};b.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===r};b.isForwardRef=function(a){return d(a)===m};b.isFragment=function(a){return d(a)===f};b.isLazy=function(a){return d(a)===n};b.isMemo=function(a){return d(a)===p};b.isPortal=function(a){return d(a)===u};b.isProfiler=function(a){return d(a)===g};b.isStrictMode=function(a){return d(a)===h};b.isSuspense=function(a){return d(a)===k};b.isValidElementType= +function(a){return"string"===typeof a||"function"===typeof a||a===f||a===e||a===g||a===h||a===k||a===w||"object"===typeof a&&null!==a&&(a.$$typeof===n||a.$$typeof===p||a.$$typeof===q||a.$$typeof===l||a.$$typeof===m||a.$$typeof===y||a.$$typeof===z||a.$$typeof===A||a.$$typeof===x)};b.typeOf=d}); diff --git a/node_modules/react/LICENSE b/node_modules/react/LICENSE new file mode 100644 index 0000000..b96dcb0 --- /dev/null +++ b/node_modules/react/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Facebook, Inc. and its affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/react/README.md b/node_modules/react/README.md new file mode 100644 index 0000000..826563e --- /dev/null +++ b/node_modules/react/README.md @@ -0,0 +1,37 @@ +# `react` + +React is a JavaScript library for creating user interfaces. + +The `react` package contains only the functionality necessary to define React components. It is typically used together with a React renderer like `react-dom` for the web, or `react-native` for the native environments. + +**Note:** by default, React will be in development mode. The development version includes extra warnings about common mistakes, whereas the production version includes extra performance optimizations and strips all error messages. Don't forget to use the [production build](https://reactjs.org/docs/optimizing-performance.html#use-the-production-build) when deploying your application. + +## Usage + +```js +import { useState } from 'react'; +import { createRoot } from 'react-dom/client'; + +function Counter() { + const [count, setCount] = useState(0); + return ( + <> +

{count}

+ + + ); +} + +const root = createRoot(document.getElementById('root')); +root.render(); +``` + +## Documentation + +See https://reactjs.org/ + +## API + +See https://reactjs.org/docs/react-api.html diff --git a/node_modules/react/cjs/react-jsx-dev-runtime.development.js b/node_modules/react/cjs/react-jsx-dev-runtime.development.js new file mode 100644 index 0000000..f47788b --- /dev/null +++ b/node_modules/react/cjs/react-jsx-dev-runtime.development.js @@ -0,0 +1,1315 @@ +/** + * @license React + * react-jsx-dev-runtime.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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") { + (function() { +'use strict'; + +var React = require('react'); + +// ATTENTION +// When adding new symbols to this file, +// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols' +// The Symbol used to tag the ReactElement-like types. +var REACT_ELEMENT_TYPE = Symbol.for('react.element'); +var REACT_PORTAL_TYPE = Symbol.for('react.portal'); +var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment'); +var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode'); +var REACT_PROFILER_TYPE = Symbol.for('react.profiler'); +var REACT_PROVIDER_TYPE = Symbol.for('react.provider'); +var REACT_CONTEXT_TYPE = Symbol.for('react.context'); +var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref'); +var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense'); +var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list'); +var REACT_MEMO_TYPE = Symbol.for('react.memo'); +var REACT_LAZY_TYPE = Symbol.for('react.lazy'); +var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen'); +var MAYBE_ITERATOR_SYMBOL = Symbol.iterator; +var FAUX_ITERATOR_SYMBOL = '@@iterator'; +function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable !== 'object') { + return null; + } + + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + + if (typeof maybeIterator === 'function') { + return maybeIterator; + } + + return null; +} + +var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; + +function error(format) { + { + { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + + printWarning('error', format, args); + } + } +} + +function printWarning(level, format, args) { + // When changing this logic, you might want to also + // update consoleWithStackDev.www.js as well. + { + var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame.getStackAddendum(); + + if (stack !== '') { + format += '%s'; + args = args.concat([stack]); + } // eslint-disable-next-line react-internal/safe-string-coercion + + + var argsWithFormat = args.map(function (item) { + return String(item); + }); // Careful: RN currently depends on this prefix + + argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it + // breaks IE9: https://github.com/facebook/react/issues/13610 + // eslint-disable-next-line react-internal/no-production-logging + + Function.prototype.apply.call(console[level], console, argsWithFormat); + } +} + +// ----------------------------------------------------------------------------- + +var enableScopeAPI = false; // Experimental Create Event Handle API. +var enableCacheElement = false; +var enableTransitionTracing = false; // No known bugs, but needs performance testing + +var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber +// stuff. Intended to enable React core members to more easily debug scheduling +// issues in DEV builds. + +var enableDebugTracing = false; // Track which Fiber(s) schedule render work. + +var REACT_MODULE_REFERENCE; + +{ + REACT_MODULE_REFERENCE = Symbol.for('react.module.reference'); +} + +function isValidElementType(type) { + if (typeof type === 'string' || typeof type === 'function') { + return true; + } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill). + + + if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing ) { + return true; + } + + if (typeof type === 'object' && type !== null) { + if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object + // types supported by any Flight configuration anywhere since + // we don't know which Flight build this will end up being used + // with. + type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) { + return true; + } + } + + return false; +} + +function getWrappedName(outerType, innerType, wrapperName) { + var displayName = outerType.displayName; + + if (displayName) { + return displayName; + } + + var functionName = innerType.displayName || innerType.name || ''; + return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName; +} // Keep in sync with react-reconciler/getComponentNameFromFiber + + +function getContextName(type) { + return type.displayName || 'Context'; +} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead. + + +function getComponentNameFromType(type) { + if (type == null) { + // Host root, text node or just invalid type. + return null; + } + + { + if (typeof type.tag === 'number') { + error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.'); + } + } + + if (typeof type === 'function') { + return type.displayName || type.name || null; + } + + if (typeof type === 'string') { + return type; + } + + switch (type) { + case REACT_FRAGMENT_TYPE: + return 'Fragment'; + + case REACT_PORTAL_TYPE: + return 'Portal'; + + case REACT_PROFILER_TYPE: + return 'Profiler'; + + case REACT_STRICT_MODE_TYPE: + return 'StrictMode'; + + case REACT_SUSPENSE_TYPE: + return 'Suspense'; + + case REACT_SUSPENSE_LIST_TYPE: + return 'SuspenseList'; + + } + + if (typeof type === 'object') { + switch (type.$$typeof) { + case REACT_CONTEXT_TYPE: + var context = type; + return getContextName(context) + '.Consumer'; + + case REACT_PROVIDER_TYPE: + var provider = type; + return getContextName(provider._context) + '.Provider'; + + case REACT_FORWARD_REF_TYPE: + return getWrappedName(type, type.render, 'ForwardRef'); + + case REACT_MEMO_TYPE: + var outerName = type.displayName || null; + + if (outerName !== null) { + return outerName; + } + + return getComponentNameFromType(type.type) || 'Memo'; + + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + + try { + return getComponentNameFromType(init(payload)); + } catch (x) { + return null; + } + } + + // eslint-disable-next-line no-fallthrough + } + } + + return null; +} + +var assign = Object.assign; + +// Helpers to patch console.logs to avoid logging during side-effect free +// replaying on render function. This currently only patches the object +// lazily which won't cover if the log function was extracted eagerly. +// We could also eagerly patch the method. +var disabledDepth = 0; +var prevLog; +var prevInfo; +var prevWarn; +var prevError; +var prevGroup; +var prevGroupCollapsed; +var prevGroupEnd; + +function disabledLog() {} + +disabledLog.__reactDisabledLog = true; +function disableLogs() { + { + if (disabledDepth === 0) { + /* eslint-disable react-internal/no-production-logging */ + prevLog = console.log; + prevInfo = console.info; + prevWarn = console.warn; + prevError = console.error; + prevGroup = console.group; + prevGroupCollapsed = console.groupCollapsed; + prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099 + + var props = { + configurable: true, + enumerable: true, + value: disabledLog, + writable: true + }; // $FlowFixMe Flow thinks console is immutable. + + Object.defineProperties(console, { + info: props, + log: props, + warn: props, + error: props, + group: props, + groupCollapsed: props, + groupEnd: props + }); + /* eslint-enable react-internal/no-production-logging */ + } + + disabledDepth++; + } +} +function reenableLogs() { + { + disabledDepth--; + + if (disabledDepth === 0) { + /* eslint-disable react-internal/no-production-logging */ + var props = { + configurable: true, + enumerable: true, + writable: true + }; // $FlowFixMe Flow thinks console is immutable. + + Object.defineProperties(console, { + log: assign({}, props, { + value: prevLog + }), + info: assign({}, props, { + value: prevInfo + }), + warn: assign({}, props, { + value: prevWarn + }), + error: assign({}, props, { + value: prevError + }), + group: assign({}, props, { + value: prevGroup + }), + groupCollapsed: assign({}, props, { + value: prevGroupCollapsed + }), + groupEnd: assign({}, props, { + value: prevGroupEnd + }) + }); + /* eslint-enable react-internal/no-production-logging */ + } + + if (disabledDepth < 0) { + error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.'); + } + } +} + +var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher; +var prefix; +function describeBuiltInComponentFrame(name, source, ownerFn) { + { + if (prefix === undefined) { + // Extract the VM specific prefix used by each line. + try { + throw Error(); + } catch (x) { + var match = x.stack.trim().match(/\n( *(at )?)/); + prefix = match && match[1] || ''; + } + } // We use the prefix to ensure our stacks line up with native stack frames. + + + return '\n' + prefix + name; + } +} +var reentry = false; +var componentFrameCache; + +{ + var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; + componentFrameCache = new PossiblyWeakMap(); +} + +function describeNativeComponentFrame(fn, construct) { + // If something asked for a stack inside a fake render, it should get ignored. + if ( !fn || reentry) { + return ''; + } + + { + var frame = componentFrameCache.get(fn); + + if (frame !== undefined) { + return frame; + } + } + + var control; + reentry = true; + var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined. + + Error.prepareStackTrace = undefined; + var previousDispatcher; + + { + previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function + // for warnings. + + ReactCurrentDispatcher.current = null; + disableLogs(); + } + + try { + // This should throw. + if (construct) { + // Something should be setting the props in the constructor. + var Fake = function () { + throw Error(); + }; // $FlowFixMe + + + Object.defineProperty(Fake.prototype, 'props', { + set: function () { + // We use a throwing setter instead of frozen or non-writable props + // because that won't throw in a non-strict mode function. + throw Error(); + } + }); + + if (typeof Reflect === 'object' && Reflect.construct) { + // We construct a different control for this case to include any extra + // frames added by the construct call. + try { + Reflect.construct(Fake, []); + } catch (x) { + control = x; + } + + Reflect.construct(fn, [], Fake); + } else { + try { + Fake.call(); + } catch (x) { + control = x; + } + + fn.call(Fake.prototype); + } + } else { + try { + throw Error(); + } catch (x) { + control = x; + } + + fn(); + } + } catch (sample) { + // This is inlined manually because closure doesn't do it for us. + if (sample && control && typeof sample.stack === 'string') { + // This extracts the first frame from the sample that isn't also in the control. + // Skipping one frame that we assume is the frame that calls the two. + var sampleLines = sample.stack.split('\n'); + var controlLines = control.stack.split('\n'); + var s = sampleLines.length - 1; + var c = controlLines.length - 1; + + while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) { + // We expect at least one stack frame to be shared. + // Typically this will be the root most one. However, stack frames may be + // cut off due to maximum stack limits. In this case, one maybe cut off + // earlier than the other. We assume that the sample is longer or the same + // and there for cut off earlier. So we should find the root most frame in + // the sample somewhere in the control. + c--; + } + + for (; s >= 1 && c >= 0; s--, c--) { + // Next we find the first one that isn't the same which should be the + // frame that called our sample function and the control. + if (sampleLines[s] !== controlLines[c]) { + // In V8, the first line is describing the message but other VMs don't. + // If we're about to return the first line, and the control is also on the same + // line, that's a pretty good indicator that our sample threw at same line as + // the control. I.e. before we entered the sample frame. So we ignore this result. + // This can happen if you passed a class to function component, or non-function. + if (s !== 1 || c !== 1) { + do { + s--; + c--; // We may still have similar intermediate frames from the construct call. + // The next one that isn't the same should be our match though. + + if (c < 0 || sampleLines[s] !== controlLines[c]) { + // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier. + var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "" + // but we have a user-provided "displayName" + // splice it in to make the stack more readable. + + + if (fn.displayName && _frame.includes('')) { + _frame = _frame.replace('', fn.displayName); + } + + { + if (typeof fn === 'function') { + componentFrameCache.set(fn, _frame); + } + } // Return the line we found. + + + return _frame; + } + } while (s >= 1 && c >= 0); + } + + break; + } + } + } + } finally { + reentry = false; + + { + ReactCurrentDispatcher.current = previousDispatcher; + reenableLogs(); + } + + Error.prepareStackTrace = previousPrepareStackTrace; + } // Fallback to just using the name if we couldn't make it throw. + + + var name = fn ? fn.displayName || fn.name : ''; + var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ''; + + { + if (typeof fn === 'function') { + componentFrameCache.set(fn, syntheticFrame); + } + } + + return syntheticFrame; +} +function describeFunctionComponentFrame(fn, source, ownerFn) { + { + return describeNativeComponentFrame(fn, false); + } +} + +function shouldConstruct(Component) { + var prototype = Component.prototype; + return !!(prototype && prototype.isReactComponent); +} + +function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { + + if (type == null) { + return ''; + } + + if (typeof type === 'function') { + { + return describeNativeComponentFrame(type, shouldConstruct(type)); + } + } + + if (typeof type === 'string') { + return describeBuiltInComponentFrame(type); + } + + switch (type) { + case REACT_SUSPENSE_TYPE: + return describeBuiltInComponentFrame('Suspense'); + + case REACT_SUSPENSE_LIST_TYPE: + return describeBuiltInComponentFrame('SuspenseList'); + } + + if (typeof type === 'object') { + switch (type.$$typeof) { + case REACT_FORWARD_REF_TYPE: + return describeFunctionComponentFrame(type.render); + + case REACT_MEMO_TYPE: + // Memo may contain any component type so we recursively resolve it. + return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn); + + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + + try { + // Lazy may contain any component type so we recursively resolve it. + return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn); + } catch (x) {} + } + } + } + + return ''; +} + +var hasOwnProperty = Object.prototype.hasOwnProperty; + +var loggedTypeFailures = {}; +var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; + +function setCurrentlyValidatingElement(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + ReactDebugCurrentFrame.setExtraStackFrame(stack); + } else { + ReactDebugCurrentFrame.setExtraStackFrame(null); + } + } +} + +function checkPropTypes(typeSpecs, values, location, componentName, element) { + { + // $FlowFixMe This is okay but Flow doesn't know it. + var has = Function.call.bind(hasOwnProperty); + + for (var typeSpecName in typeSpecs) { + if (has(typeSpecs, typeSpecName)) { + var error$1 = void 0; // 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. + if (typeof typeSpecs[typeSpecName] !== 'function') { + // eslint-disable-next-line react-internal/prod-error-codes + var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'); + err.name = 'Invariant Violation'; + throw err; + } + + error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'); + } catch (ex) { + error$1 = ex; + } + + if (error$1 && !(error$1 instanceof Error)) { + setCurrentlyValidatingElement(element); + + 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$1); + + setCurrentlyValidatingElement(null); + } + + if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) { + // Only monitor this failure once because there tends to be a lot of the + // same error. + loggedTypeFailures[error$1.message] = true; + setCurrentlyValidatingElement(element); + + error('Failed %s type: %s', location, error$1.message); + + setCurrentlyValidatingElement(null); + } + } + } + } +} + +var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare + +function isArray(a) { + return isArrayImpl(a); +} + +/* + * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol + * and Temporal.* types. See https://github.com/facebook/react/pull/22064. + * + * The functions in this module will throw an easier-to-understand, + * easier-to-debug exception with a clear errors message message explaining the + * problem. (Instead of a confusing exception thrown inside the implementation + * of the `value` object). + */ +// $FlowFixMe only called in DEV, so void return is not possible. +function typeName(value) { + { + // toStringTag is needed for namespaced types like Temporal.Instant + var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag; + var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; + return type; + } +} // $FlowFixMe only called in DEV, so void return is not possible. + + +function willCoercionThrow(value) { + { + try { + testStringCoercion(value); + return false; + } catch (e) { + return true; + } + } +} + +function testStringCoercion(value) { + // If you ended up here by following an exception call stack, here's what's + // happened: you supplied an object or symbol value to React (as a prop, key, + // DOM attribute, CSS property, string ref, etc.) and when React tried to + // coerce it to a string using `'' + value`, an exception was thrown. + // + // The most common types that will cause this exception are `Symbol` instances + // and Temporal objects like `Temporal.Instant`. But any object that has a + // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this + // exception. (Library authors do this to prevent users from using built-in + // numeric operators like `+` or comparison operators like `>=` because custom + // methods are needed to perform accurate arithmetic or comparison.) + // + // To fix the problem, coerce this object or symbol value to a string before + // passing it to React. The most reliable way is usually `String(value)`. + // + // To find which value is throwing, check the browser or debugger console. + // Before this exception was thrown, there should be `console.error` output + // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the + // problem and how that type was used: key, atrribute, input value prop, etc. + // In most cases, this console output also shows the component and its + // ancestor components where the exception happened. + // + // eslint-disable-next-line react-internal/safe-string-coercion + return '' + value; +} +function checkKeyStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value)); + + return testStringCoercion(value); // throw (to help callers find troubleshooting comments) + } + } +} + +var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner; +var RESERVED_PROPS = { + key: true, + ref: true, + __self: true, + __source: true +}; +var specialPropKeyWarningShown; +var specialPropRefWarningShown; +var didWarnAboutStringRefs; + +{ + didWarnAboutStringRefs = {}; +} + +function hasValidRef(config) { + { + if (hasOwnProperty.call(config, 'ref')) { + var getter = Object.getOwnPropertyDescriptor(config, 'ref').get; + + if (getter && getter.isReactWarning) { + return false; + } + } + } + + return config.ref !== undefined; +} + +function hasValidKey(config) { + { + if (hasOwnProperty.call(config, 'key')) { + var getter = Object.getOwnPropertyDescriptor(config, 'key').get; + + if (getter && getter.isReactWarning) { + return false; + } + } + } + + return config.key !== undefined; +} + +function warnIfStringRefCannotBeAutoConverted(config, self) { + { + if (typeof config.ref === 'string' && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) { + var componentName = getComponentNameFromType(ReactCurrentOwner.current.type); + + if (!didWarnAboutStringRefs[componentName]) { + error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', getComponentNameFromType(ReactCurrentOwner.current.type), config.ref); + + didWarnAboutStringRefs[componentName] = true; + } + } + } +} + +function defineKeyPropWarningGetter(props, displayName) { + { + var warnAboutAccessingKey = function () { + if (!specialPropKeyWarningShown) { + specialPropKeyWarningShown = true; + + error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName); + } + }; + + warnAboutAccessingKey.isReactWarning = true; + Object.defineProperty(props, 'key', { + get: warnAboutAccessingKey, + configurable: true + }); + } +} + +function defineRefPropWarningGetter(props, displayName) { + { + var warnAboutAccessingRef = function () { + if (!specialPropRefWarningShown) { + specialPropRefWarningShown = true; + + error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName); + } + }; + + warnAboutAccessingRef.isReactWarning = true; + Object.defineProperty(props, 'ref', { + get: warnAboutAccessingRef, + configurable: true + }); + } +} +/** + * Factory method to create a new React element. This no longer adheres to + * the class pattern, so do not use new to call it. Also, instanceof check + * will not work. Instead test $$typeof field against Symbol.for('react.element') to check + * if something is a React Element. + * + * @param {*} type + * @param {*} props + * @param {*} key + * @param {string|object} ref + * @param {*} owner + * @param {*} self A *temporary* helper to detect places where `this` is + * different from the `owner` when React.createElement is called, so that we + * can warn. We want to get rid of owner and replace string `ref`s with arrow + * functions, and as long as `this` and owner are the same, there will be no + * change in behavior. + * @param {*} source An annotation object (added by a transpiler or otherwise) + * indicating filename, line number, and/or other information. + * @internal + */ + + +var ReactElement = function (type, key, ref, self, source, owner, props) { + var element = { + // This tag allows us to uniquely identify this as a React Element + $$typeof: REACT_ELEMENT_TYPE, + // Built-in properties that belong on the element + type: type, + key: key, + ref: ref, + props: props, + // Record the component responsible for creating this element. + _owner: owner + }; + + { + // The validation flag is currently mutative. We put it on + // an external backing store so that we can freeze the whole object. + // This can be replaced with a WeakMap once they are implemented in + // commonly used development environments. + element._store = {}; // To make comparing ReactElements easier for testing purposes, we make + // the validation flag non-enumerable (where possible, which should + // include every environment we run tests in), so the test framework + // ignores it. + + Object.defineProperty(element._store, 'validated', { + configurable: false, + enumerable: false, + writable: true, + value: false + }); // self and source are DEV only properties. + + Object.defineProperty(element, '_self', { + configurable: false, + enumerable: false, + writable: false, + value: self + }); // Two elements created in two different places should be considered + // equal for testing purposes and therefore we hide it from enumeration. + + Object.defineProperty(element, '_source', { + configurable: false, + enumerable: false, + writable: false, + value: source + }); + + if (Object.freeze) { + Object.freeze(element.props); + Object.freeze(element); + } + } + + return element; +}; +/** + * https://github.com/reactjs/rfcs/pull/107 + * @param {*} type + * @param {object} props + * @param {string} key + */ + +function jsxDEV(type, config, maybeKey, source, self) { + { + var propName; // Reserved names are extracted + + var props = {}; + var key = null; + var ref = null; // Currently, key can be spread in as a prop. This causes a potential + // issue if key is also explicitly declared (ie.
+ // or
). We want to deprecate key spread, + // but as an intermediary step, we will use jsxDEV for everything except + //
, because we aren't currently able to tell if + // key is explicitly declared to be undefined or not. + + if (maybeKey !== undefined) { + { + checkKeyStringCoercion(maybeKey); + } + + key = '' + maybeKey; + } + + if (hasValidKey(config)) { + { + checkKeyStringCoercion(config.key); + } + + key = '' + config.key; + } + + if (hasValidRef(config)) { + ref = config.ref; + warnIfStringRefCannotBeAutoConverted(config, self); + } // Remaining properties are added to a new props object + + + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + props[propName] = config[propName]; + } + } // Resolve default props + + + if (type && type.defaultProps) { + var defaultProps = type.defaultProps; + + for (propName in defaultProps) { + if (props[propName] === undefined) { + props[propName] = defaultProps[propName]; + } + } + } + + if (key || ref) { + var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; + + if (key) { + defineKeyPropWarningGetter(props, displayName); + } + + if (ref) { + defineRefPropWarningGetter(props, displayName); + } + } + + return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props); + } +} + +var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; +var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame; + +function setCurrentlyValidatingElement$1(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + ReactDebugCurrentFrame$1.setExtraStackFrame(stack); + } else { + ReactDebugCurrentFrame$1.setExtraStackFrame(null); + } + } +} + +var propTypesMisspellWarningShown; + +{ + propTypesMisspellWarningShown = false; +} +/** + * Verifies the object is a ReactElement. + * See https://reactjs.org/docs/react-api.html#isvalidelement + * @param {?object} object + * @return {boolean} True if `object` is a ReactElement. + * @final + */ + + +function isValidElement(object) { + { + return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; + } +} + +function getDeclarationErrorAddendum() { + { + if (ReactCurrentOwner$1.current) { + var name = getComponentNameFromType(ReactCurrentOwner$1.current.type); + + if (name) { + return '\n\nCheck the render method of `' + name + '`.'; + } + } + + return ''; + } +} + +function getSourceInfoErrorAddendum(source) { + { + if (source !== undefined) { + var fileName = source.fileName.replace(/^.*[\\\/]/, ''); + var lineNumber = source.lineNumber; + return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.'; + } + + return ''; + } +} +/** + * Warn if there's no key explicitly set on dynamic arrays of children or + * object keys are not valid. This allows us to keep track of children between + * updates. + */ + + +var ownerHasKeyUseWarning = {}; + +function getCurrentComponentErrorInfo(parentType) { + { + var info = getDeclarationErrorAddendum(); + + if (!info) { + var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name; + + if (parentName) { + info = "\n\nCheck the top-level render call using <" + parentName + ">."; + } + } + + return info; + } +} +/** + * Warn if the element doesn't have an explicit key assigned to it. + * This element is in an array. The array could grow and shrink or be + * reordered. All children that haven't already been validated are required to + * have a "key" property assigned to it. Error statuses are cached so a warning + * will only be shown once. + * + * @internal + * @param {ReactElement} element Element that requires a key. + * @param {*} parentType element's parent's type. + */ + + +function validateExplicitKey(element, parentType) { + { + if (!element._store || element._store.validated || element.key != null) { + return; + } + + element._store.validated = true; + var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); + + if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { + return; + } + + ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a + // property, it may be the creator of the child that's responsible for + // assigning it a key. + + var childOwner = ''; + + if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) { + // Give the component that originally created this child. + childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + "."; + } + + setCurrentlyValidatingElement$1(element); + + error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner); + + setCurrentlyValidatingElement$1(null); + } +} +/** + * Ensure that every element either is passed in a static location, in an + * array with an explicit keys property defined, or in an object literal + * with valid key property. + * + * @internal + * @param {ReactNode} node Statically passed child of any type. + * @param {*} parentType node's parent's type. + */ + + +function validateChildKeys(node, parentType) { + { + if (typeof node !== 'object') { + return; + } + + if (isArray(node)) { + for (var i = 0; i < node.length; i++) { + var child = node[i]; + + if (isValidElement(child)) { + validateExplicitKey(child, parentType); + } + } + } else if (isValidElement(node)) { + // This element was passed in a valid location. + if (node._store) { + node._store.validated = true; + } + } else if (node) { + var iteratorFn = getIteratorFn(node); + + if (typeof iteratorFn === 'function') { + // Entry iterators used to provide implicit keys, + // but now we print a separate warning for them later. + if (iteratorFn !== node.entries) { + var iterator = iteratorFn.call(node); + var step; + + while (!(step = iterator.next()).done) { + if (isValidElement(step.value)) { + validateExplicitKey(step.value, parentType); + } + } + } + } + } + } +} +/** + * Given an element, validate that its props follow the propTypes definition, + * provided by the type. + * + * @param {ReactElement} element + */ + + +function validatePropTypes(element) { + { + var type = element.type; + + if (type === null || type === undefined || typeof type === 'string') { + return; + } + + var propTypes; + + if (typeof type === 'function') { + propTypes = type.propTypes; + } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here. + // Inner props are checked in the reconciler. + type.$$typeof === REACT_MEMO_TYPE)) { + propTypes = type.propTypes; + } else { + return; + } + + if (propTypes) { + // Intentionally inside to avoid triggering lazy initializers: + var name = getComponentNameFromType(type); + checkPropTypes(propTypes, element.props, 'prop', name, element); + } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) { + propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers: + + var _name = getComponentNameFromType(type); + + error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown'); + } + + if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) { + error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.'); + } + } +} +/** + * Given a fragment, validate that it can only be provided with fragment props + * @param {ReactElement} fragment + */ + + +function validateFragmentProps(fragment) { + { + var keys = Object.keys(fragment.props); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + + if (key !== 'children' && key !== 'key') { + setCurrentlyValidatingElement$1(fragment); + + error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key); + + setCurrentlyValidatingElement$1(null); + break; + } + } + + if (fragment.ref !== null) { + setCurrentlyValidatingElement$1(fragment); + + error('Invalid attribute `ref` supplied to `React.Fragment`.'); + + setCurrentlyValidatingElement$1(null); + } + } +} + +var didWarnAboutKeySpread = {}; +function jsxWithValidation(type, props, key, isStaticChildren, source, self) { + { + var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to + // succeed and there will likely be errors in render. + + if (!validType) { + var info = ''; + + if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) { + info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports."; + } + + var sourceInfo = getSourceInfoErrorAddendum(source); + + if (sourceInfo) { + info += sourceInfo; + } else { + info += getDeclarationErrorAddendum(); + } + + var typeString; + + if (type === null) { + typeString = 'null'; + } else if (isArray(type)) { + typeString = 'array'; + } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) { + typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />"; + info = ' Did you accidentally export a JSX literal instead of a component?'; + } else { + typeString = typeof type; + } + + error('React.jsx: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info); + } + + var element = jsxDEV(type, props, key, source, self); // The result can be nullish if a mock or a custom function is used. + // TODO: Drop this when these are no longer allowed as the type argument. + + if (element == null) { + return element; + } // Skip key warning if the type isn't valid since our key validation logic + // doesn't expect a non-string/function type and can throw confusing errors. + // We don't want exception behavior to differ between dev and prod. + // (Rendering will throw with a helpful message and as soon as the type is + // fixed, the key warnings will appear.) + + + if (validType) { + var children = props.children; + + if (children !== undefined) { + if (isStaticChildren) { + if (isArray(children)) { + for (var i = 0; i < children.length; i++) { + validateChildKeys(children[i], type); + } + + if (Object.freeze) { + Object.freeze(children); + } + } else { + error('React.jsx: Static children should always be an array. ' + 'You are likely explicitly calling React.jsxs or React.jsxDEV. ' + 'Use the Babel transform instead.'); + } + } else { + validateChildKeys(children, type); + } + } + } + + { + if (hasOwnProperty.call(props, 'key')) { + var componentName = getComponentNameFromType(type); + var keys = Object.keys(props).filter(function (k) { + return k !== 'key'; + }); + var beforeExample = keys.length > 0 ? '{key: someKey, ' + keys.join(': ..., ') + ': ...}' : '{key: someKey}'; + + if (!didWarnAboutKeySpread[componentName + beforeExample]) { + var afterExample = keys.length > 0 ? '{' + keys.join(': ..., ') + ': ...}' : '{}'; + + error('A props object containing a "key" prop is being spread into JSX:\n' + ' let props = %s;\n' + ' <%s {...props} />\n' + 'React keys must be passed directly to JSX without using spread:\n' + ' let props = %s;\n' + ' <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName); + + didWarnAboutKeySpread[componentName + beforeExample] = true; + } + } + } + + if (type === REACT_FRAGMENT_TYPE) { + validateFragmentProps(element); + } else { + validatePropTypes(element); + } + + return element; + } +} // These two functions exist to still get child warnings in dev + +var jsxDEV$1 = jsxWithValidation ; + +exports.Fragment = REACT_FRAGMENT_TYPE; +exports.jsxDEV = jsxDEV$1; + })(); +} diff --git a/node_modules/react/cjs/react-jsx-dev-runtime.production.min.js b/node_modules/react/cjs/react-jsx-dev-runtime.production.min.js new file mode 100644 index 0000000..d117ce3 --- /dev/null +++ b/node_modules/react/cjs/react-jsx-dev-runtime.production.min.js @@ -0,0 +1,10 @@ +/** + * @license React + * react-jsx-dev-runtime.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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 a=Symbol.for("react.fragment");exports.Fragment=a;exports.jsxDEV=void 0; diff --git a/node_modules/react/cjs/react-jsx-dev-runtime.profiling.min.js b/node_modules/react/cjs/react-jsx-dev-runtime.profiling.min.js new file mode 100644 index 0000000..1d8cf15 --- /dev/null +++ b/node_modules/react/cjs/react-jsx-dev-runtime.profiling.min.js @@ -0,0 +1,10 @@ +/** + * @license React + * react-jsx-dev-runtime.profiling.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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 a=Symbol.for("react.fragment");exports.Fragment=a;exports.jsxDEV=void 0; diff --git a/node_modules/react/cjs/react-jsx-runtime.development.js b/node_modules/react/cjs/react-jsx-runtime.development.js new file mode 100644 index 0000000..8827d8b --- /dev/null +++ b/node_modules/react/cjs/react-jsx-runtime.development.js @@ -0,0 +1,1333 @@ +/** + * @license React + * react-jsx-runtime.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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") { + (function() { +'use strict'; + +var React = require('react'); + +// ATTENTION +// When adding new symbols to this file, +// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols' +// The Symbol used to tag the ReactElement-like types. +var REACT_ELEMENT_TYPE = Symbol.for('react.element'); +var REACT_PORTAL_TYPE = Symbol.for('react.portal'); +var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment'); +var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode'); +var REACT_PROFILER_TYPE = Symbol.for('react.profiler'); +var REACT_PROVIDER_TYPE = Symbol.for('react.provider'); +var REACT_CONTEXT_TYPE = Symbol.for('react.context'); +var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref'); +var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense'); +var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list'); +var REACT_MEMO_TYPE = Symbol.for('react.memo'); +var REACT_LAZY_TYPE = Symbol.for('react.lazy'); +var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen'); +var MAYBE_ITERATOR_SYMBOL = Symbol.iterator; +var FAUX_ITERATOR_SYMBOL = '@@iterator'; +function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable !== 'object') { + return null; + } + + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + + if (typeof maybeIterator === 'function') { + return maybeIterator; + } + + return null; +} + +var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; + +function error(format) { + { + { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + + printWarning('error', format, args); + } + } +} + +function printWarning(level, format, args) { + // When changing this logic, you might want to also + // update consoleWithStackDev.www.js as well. + { + var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame.getStackAddendum(); + + if (stack !== '') { + format += '%s'; + args = args.concat([stack]); + } // eslint-disable-next-line react-internal/safe-string-coercion + + + var argsWithFormat = args.map(function (item) { + return String(item); + }); // Careful: RN currently depends on this prefix + + argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it + // breaks IE9: https://github.com/facebook/react/issues/13610 + // eslint-disable-next-line react-internal/no-production-logging + + Function.prototype.apply.call(console[level], console, argsWithFormat); + } +} + +// ----------------------------------------------------------------------------- + +var enableScopeAPI = false; // Experimental Create Event Handle API. +var enableCacheElement = false; +var enableTransitionTracing = false; // No known bugs, but needs performance testing + +var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber +// stuff. Intended to enable React core members to more easily debug scheduling +// issues in DEV builds. + +var enableDebugTracing = false; // Track which Fiber(s) schedule render work. + +var REACT_MODULE_REFERENCE; + +{ + REACT_MODULE_REFERENCE = Symbol.for('react.module.reference'); +} + +function isValidElementType(type) { + if (typeof type === 'string' || typeof type === 'function') { + return true; + } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill). + + + if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing ) { + return true; + } + + if (typeof type === 'object' && type !== null) { + if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object + // types supported by any Flight configuration anywhere since + // we don't know which Flight build this will end up being used + // with. + type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) { + return true; + } + } + + return false; +} + +function getWrappedName(outerType, innerType, wrapperName) { + var displayName = outerType.displayName; + + if (displayName) { + return displayName; + } + + var functionName = innerType.displayName || innerType.name || ''; + return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName; +} // Keep in sync with react-reconciler/getComponentNameFromFiber + + +function getContextName(type) { + return type.displayName || 'Context'; +} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead. + + +function getComponentNameFromType(type) { + if (type == null) { + // Host root, text node or just invalid type. + return null; + } + + { + if (typeof type.tag === 'number') { + error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.'); + } + } + + if (typeof type === 'function') { + return type.displayName || type.name || null; + } + + if (typeof type === 'string') { + return type; + } + + switch (type) { + case REACT_FRAGMENT_TYPE: + return 'Fragment'; + + case REACT_PORTAL_TYPE: + return 'Portal'; + + case REACT_PROFILER_TYPE: + return 'Profiler'; + + case REACT_STRICT_MODE_TYPE: + return 'StrictMode'; + + case REACT_SUSPENSE_TYPE: + return 'Suspense'; + + case REACT_SUSPENSE_LIST_TYPE: + return 'SuspenseList'; + + } + + if (typeof type === 'object') { + switch (type.$$typeof) { + case REACT_CONTEXT_TYPE: + var context = type; + return getContextName(context) + '.Consumer'; + + case REACT_PROVIDER_TYPE: + var provider = type; + return getContextName(provider._context) + '.Provider'; + + case REACT_FORWARD_REF_TYPE: + return getWrappedName(type, type.render, 'ForwardRef'); + + case REACT_MEMO_TYPE: + var outerName = type.displayName || null; + + if (outerName !== null) { + return outerName; + } + + return getComponentNameFromType(type.type) || 'Memo'; + + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + + try { + return getComponentNameFromType(init(payload)); + } catch (x) { + return null; + } + } + + // eslint-disable-next-line no-fallthrough + } + } + + return null; +} + +var assign = Object.assign; + +// Helpers to patch console.logs to avoid logging during side-effect free +// replaying on render function. This currently only patches the object +// lazily which won't cover if the log function was extracted eagerly. +// We could also eagerly patch the method. +var disabledDepth = 0; +var prevLog; +var prevInfo; +var prevWarn; +var prevError; +var prevGroup; +var prevGroupCollapsed; +var prevGroupEnd; + +function disabledLog() {} + +disabledLog.__reactDisabledLog = true; +function disableLogs() { + { + if (disabledDepth === 0) { + /* eslint-disable react-internal/no-production-logging */ + prevLog = console.log; + prevInfo = console.info; + prevWarn = console.warn; + prevError = console.error; + prevGroup = console.group; + prevGroupCollapsed = console.groupCollapsed; + prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099 + + var props = { + configurable: true, + enumerable: true, + value: disabledLog, + writable: true + }; // $FlowFixMe Flow thinks console is immutable. + + Object.defineProperties(console, { + info: props, + log: props, + warn: props, + error: props, + group: props, + groupCollapsed: props, + groupEnd: props + }); + /* eslint-enable react-internal/no-production-logging */ + } + + disabledDepth++; + } +} +function reenableLogs() { + { + disabledDepth--; + + if (disabledDepth === 0) { + /* eslint-disable react-internal/no-production-logging */ + var props = { + configurable: true, + enumerable: true, + writable: true + }; // $FlowFixMe Flow thinks console is immutable. + + Object.defineProperties(console, { + log: assign({}, props, { + value: prevLog + }), + info: assign({}, props, { + value: prevInfo + }), + warn: assign({}, props, { + value: prevWarn + }), + error: assign({}, props, { + value: prevError + }), + group: assign({}, props, { + value: prevGroup + }), + groupCollapsed: assign({}, props, { + value: prevGroupCollapsed + }), + groupEnd: assign({}, props, { + value: prevGroupEnd + }) + }); + /* eslint-enable react-internal/no-production-logging */ + } + + if (disabledDepth < 0) { + error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.'); + } + } +} + +var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher; +var prefix; +function describeBuiltInComponentFrame(name, source, ownerFn) { + { + if (prefix === undefined) { + // Extract the VM specific prefix used by each line. + try { + throw Error(); + } catch (x) { + var match = x.stack.trim().match(/\n( *(at )?)/); + prefix = match && match[1] || ''; + } + } // We use the prefix to ensure our stacks line up with native stack frames. + + + return '\n' + prefix + name; + } +} +var reentry = false; +var componentFrameCache; + +{ + var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; + componentFrameCache = new PossiblyWeakMap(); +} + +function describeNativeComponentFrame(fn, construct) { + // If something asked for a stack inside a fake render, it should get ignored. + if ( !fn || reentry) { + return ''; + } + + { + var frame = componentFrameCache.get(fn); + + if (frame !== undefined) { + return frame; + } + } + + var control; + reentry = true; + var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined. + + Error.prepareStackTrace = undefined; + var previousDispatcher; + + { + previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function + // for warnings. + + ReactCurrentDispatcher.current = null; + disableLogs(); + } + + try { + // This should throw. + if (construct) { + // Something should be setting the props in the constructor. + var Fake = function () { + throw Error(); + }; // $FlowFixMe + + + Object.defineProperty(Fake.prototype, 'props', { + set: function () { + // We use a throwing setter instead of frozen or non-writable props + // because that won't throw in a non-strict mode function. + throw Error(); + } + }); + + if (typeof Reflect === 'object' && Reflect.construct) { + // We construct a different control for this case to include any extra + // frames added by the construct call. + try { + Reflect.construct(Fake, []); + } catch (x) { + control = x; + } + + Reflect.construct(fn, [], Fake); + } else { + try { + Fake.call(); + } catch (x) { + control = x; + } + + fn.call(Fake.prototype); + } + } else { + try { + throw Error(); + } catch (x) { + control = x; + } + + fn(); + } + } catch (sample) { + // This is inlined manually because closure doesn't do it for us. + if (sample && control && typeof sample.stack === 'string') { + // This extracts the first frame from the sample that isn't also in the control. + // Skipping one frame that we assume is the frame that calls the two. + var sampleLines = sample.stack.split('\n'); + var controlLines = control.stack.split('\n'); + var s = sampleLines.length - 1; + var c = controlLines.length - 1; + + while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) { + // We expect at least one stack frame to be shared. + // Typically this will be the root most one. However, stack frames may be + // cut off due to maximum stack limits. In this case, one maybe cut off + // earlier than the other. We assume that the sample is longer or the same + // and there for cut off earlier. So we should find the root most frame in + // the sample somewhere in the control. + c--; + } + + for (; s >= 1 && c >= 0; s--, c--) { + // Next we find the first one that isn't the same which should be the + // frame that called our sample function and the control. + if (sampleLines[s] !== controlLines[c]) { + // In V8, the first line is describing the message but other VMs don't. + // If we're about to return the first line, and the control is also on the same + // line, that's a pretty good indicator that our sample threw at same line as + // the control. I.e. before we entered the sample frame. So we ignore this result. + // This can happen if you passed a class to function component, or non-function. + if (s !== 1 || c !== 1) { + do { + s--; + c--; // We may still have similar intermediate frames from the construct call. + // The next one that isn't the same should be our match though. + + if (c < 0 || sampleLines[s] !== controlLines[c]) { + // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier. + var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "" + // but we have a user-provided "displayName" + // splice it in to make the stack more readable. + + + if (fn.displayName && _frame.includes('')) { + _frame = _frame.replace('', fn.displayName); + } + + { + if (typeof fn === 'function') { + componentFrameCache.set(fn, _frame); + } + } // Return the line we found. + + + return _frame; + } + } while (s >= 1 && c >= 0); + } + + break; + } + } + } + } finally { + reentry = false; + + { + ReactCurrentDispatcher.current = previousDispatcher; + reenableLogs(); + } + + Error.prepareStackTrace = previousPrepareStackTrace; + } // Fallback to just using the name if we couldn't make it throw. + + + var name = fn ? fn.displayName || fn.name : ''; + var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ''; + + { + if (typeof fn === 'function') { + componentFrameCache.set(fn, syntheticFrame); + } + } + + return syntheticFrame; +} +function describeFunctionComponentFrame(fn, source, ownerFn) { + { + return describeNativeComponentFrame(fn, false); + } +} + +function shouldConstruct(Component) { + var prototype = Component.prototype; + return !!(prototype && prototype.isReactComponent); +} + +function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { + + if (type == null) { + return ''; + } + + if (typeof type === 'function') { + { + return describeNativeComponentFrame(type, shouldConstruct(type)); + } + } + + if (typeof type === 'string') { + return describeBuiltInComponentFrame(type); + } + + switch (type) { + case REACT_SUSPENSE_TYPE: + return describeBuiltInComponentFrame('Suspense'); + + case REACT_SUSPENSE_LIST_TYPE: + return describeBuiltInComponentFrame('SuspenseList'); + } + + if (typeof type === 'object') { + switch (type.$$typeof) { + case REACT_FORWARD_REF_TYPE: + return describeFunctionComponentFrame(type.render); + + case REACT_MEMO_TYPE: + // Memo may contain any component type so we recursively resolve it. + return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn); + + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + + try { + // Lazy may contain any component type so we recursively resolve it. + return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn); + } catch (x) {} + } + } + } + + return ''; +} + +var hasOwnProperty = Object.prototype.hasOwnProperty; + +var loggedTypeFailures = {}; +var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; + +function setCurrentlyValidatingElement(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + ReactDebugCurrentFrame.setExtraStackFrame(stack); + } else { + ReactDebugCurrentFrame.setExtraStackFrame(null); + } + } +} + +function checkPropTypes(typeSpecs, values, location, componentName, element) { + { + // $FlowFixMe This is okay but Flow doesn't know it. + var has = Function.call.bind(hasOwnProperty); + + for (var typeSpecName in typeSpecs) { + if (has(typeSpecs, typeSpecName)) { + var error$1 = void 0; // 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. + if (typeof typeSpecs[typeSpecName] !== 'function') { + // eslint-disable-next-line react-internal/prod-error-codes + var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'); + err.name = 'Invariant Violation'; + throw err; + } + + error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'); + } catch (ex) { + error$1 = ex; + } + + if (error$1 && !(error$1 instanceof Error)) { + setCurrentlyValidatingElement(element); + + 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$1); + + setCurrentlyValidatingElement(null); + } + + if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) { + // Only monitor this failure once because there tends to be a lot of the + // same error. + loggedTypeFailures[error$1.message] = true; + setCurrentlyValidatingElement(element); + + error('Failed %s type: %s', location, error$1.message); + + setCurrentlyValidatingElement(null); + } + } + } + } +} + +var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare + +function isArray(a) { + return isArrayImpl(a); +} + +/* + * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol + * and Temporal.* types. See https://github.com/facebook/react/pull/22064. + * + * The functions in this module will throw an easier-to-understand, + * easier-to-debug exception with a clear errors message message explaining the + * problem. (Instead of a confusing exception thrown inside the implementation + * of the `value` object). + */ +// $FlowFixMe only called in DEV, so void return is not possible. +function typeName(value) { + { + // toStringTag is needed for namespaced types like Temporal.Instant + var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag; + var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; + return type; + } +} // $FlowFixMe only called in DEV, so void return is not possible. + + +function willCoercionThrow(value) { + { + try { + testStringCoercion(value); + return false; + } catch (e) { + return true; + } + } +} + +function testStringCoercion(value) { + // If you ended up here by following an exception call stack, here's what's + // happened: you supplied an object or symbol value to React (as a prop, key, + // DOM attribute, CSS property, string ref, etc.) and when React tried to + // coerce it to a string using `'' + value`, an exception was thrown. + // + // The most common types that will cause this exception are `Symbol` instances + // and Temporal objects like `Temporal.Instant`. But any object that has a + // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this + // exception. (Library authors do this to prevent users from using built-in + // numeric operators like `+` or comparison operators like `>=` because custom + // methods are needed to perform accurate arithmetic or comparison.) + // + // To fix the problem, coerce this object or symbol value to a string before + // passing it to React. The most reliable way is usually `String(value)`. + // + // To find which value is throwing, check the browser or debugger console. + // Before this exception was thrown, there should be `console.error` output + // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the + // problem and how that type was used: key, atrribute, input value prop, etc. + // In most cases, this console output also shows the component and its + // ancestor components where the exception happened. + // + // eslint-disable-next-line react-internal/safe-string-coercion + return '' + value; +} +function checkKeyStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value)); + + return testStringCoercion(value); // throw (to help callers find troubleshooting comments) + } + } +} + +var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner; +var RESERVED_PROPS = { + key: true, + ref: true, + __self: true, + __source: true +}; +var specialPropKeyWarningShown; +var specialPropRefWarningShown; +var didWarnAboutStringRefs; + +{ + didWarnAboutStringRefs = {}; +} + +function hasValidRef(config) { + { + if (hasOwnProperty.call(config, 'ref')) { + var getter = Object.getOwnPropertyDescriptor(config, 'ref').get; + + if (getter && getter.isReactWarning) { + return false; + } + } + } + + return config.ref !== undefined; +} + +function hasValidKey(config) { + { + if (hasOwnProperty.call(config, 'key')) { + var getter = Object.getOwnPropertyDescriptor(config, 'key').get; + + if (getter && getter.isReactWarning) { + return false; + } + } + } + + return config.key !== undefined; +} + +function warnIfStringRefCannotBeAutoConverted(config, self) { + { + if (typeof config.ref === 'string' && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) { + var componentName = getComponentNameFromType(ReactCurrentOwner.current.type); + + if (!didWarnAboutStringRefs[componentName]) { + error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', getComponentNameFromType(ReactCurrentOwner.current.type), config.ref); + + didWarnAboutStringRefs[componentName] = true; + } + } + } +} + +function defineKeyPropWarningGetter(props, displayName) { + { + var warnAboutAccessingKey = function () { + if (!specialPropKeyWarningShown) { + specialPropKeyWarningShown = true; + + error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName); + } + }; + + warnAboutAccessingKey.isReactWarning = true; + Object.defineProperty(props, 'key', { + get: warnAboutAccessingKey, + configurable: true + }); + } +} + +function defineRefPropWarningGetter(props, displayName) { + { + var warnAboutAccessingRef = function () { + if (!specialPropRefWarningShown) { + specialPropRefWarningShown = true; + + error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName); + } + }; + + warnAboutAccessingRef.isReactWarning = true; + Object.defineProperty(props, 'ref', { + get: warnAboutAccessingRef, + configurable: true + }); + } +} +/** + * Factory method to create a new React element. This no longer adheres to + * the class pattern, so do not use new to call it. Also, instanceof check + * will not work. Instead test $$typeof field against Symbol.for('react.element') to check + * if something is a React Element. + * + * @param {*} type + * @param {*} props + * @param {*} key + * @param {string|object} ref + * @param {*} owner + * @param {*} self A *temporary* helper to detect places where `this` is + * different from the `owner` when React.createElement is called, so that we + * can warn. We want to get rid of owner and replace string `ref`s with arrow + * functions, and as long as `this` and owner are the same, there will be no + * change in behavior. + * @param {*} source An annotation object (added by a transpiler or otherwise) + * indicating filename, line number, and/or other information. + * @internal + */ + + +var ReactElement = function (type, key, ref, self, source, owner, props) { + var element = { + // This tag allows us to uniquely identify this as a React Element + $$typeof: REACT_ELEMENT_TYPE, + // Built-in properties that belong on the element + type: type, + key: key, + ref: ref, + props: props, + // Record the component responsible for creating this element. + _owner: owner + }; + + { + // The validation flag is currently mutative. We put it on + // an external backing store so that we can freeze the whole object. + // This can be replaced with a WeakMap once they are implemented in + // commonly used development environments. + element._store = {}; // To make comparing ReactElements easier for testing purposes, we make + // the validation flag non-enumerable (where possible, which should + // include every environment we run tests in), so the test framework + // ignores it. + + Object.defineProperty(element._store, 'validated', { + configurable: false, + enumerable: false, + writable: true, + value: false + }); // self and source are DEV only properties. + + Object.defineProperty(element, '_self', { + configurable: false, + enumerable: false, + writable: false, + value: self + }); // Two elements created in two different places should be considered + // equal for testing purposes and therefore we hide it from enumeration. + + Object.defineProperty(element, '_source', { + configurable: false, + enumerable: false, + writable: false, + value: source + }); + + if (Object.freeze) { + Object.freeze(element.props); + Object.freeze(element); + } + } + + return element; +}; +/** + * https://github.com/reactjs/rfcs/pull/107 + * @param {*} type + * @param {object} props + * @param {string} key + */ + +function jsxDEV(type, config, maybeKey, source, self) { + { + var propName; // Reserved names are extracted + + var props = {}; + var key = null; + var ref = null; // Currently, key can be spread in as a prop. This causes a potential + // issue if key is also explicitly declared (ie.
+ // or
). We want to deprecate key spread, + // but as an intermediary step, we will use jsxDEV for everything except + //
, because we aren't currently able to tell if + // key is explicitly declared to be undefined or not. + + if (maybeKey !== undefined) { + { + checkKeyStringCoercion(maybeKey); + } + + key = '' + maybeKey; + } + + if (hasValidKey(config)) { + { + checkKeyStringCoercion(config.key); + } + + key = '' + config.key; + } + + if (hasValidRef(config)) { + ref = config.ref; + warnIfStringRefCannotBeAutoConverted(config, self); + } // Remaining properties are added to a new props object + + + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + props[propName] = config[propName]; + } + } // Resolve default props + + + if (type && type.defaultProps) { + var defaultProps = type.defaultProps; + + for (propName in defaultProps) { + if (props[propName] === undefined) { + props[propName] = defaultProps[propName]; + } + } + } + + if (key || ref) { + var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; + + if (key) { + defineKeyPropWarningGetter(props, displayName); + } + + if (ref) { + defineRefPropWarningGetter(props, displayName); + } + } + + return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props); + } +} + +var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; +var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame; + +function setCurrentlyValidatingElement$1(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + ReactDebugCurrentFrame$1.setExtraStackFrame(stack); + } else { + ReactDebugCurrentFrame$1.setExtraStackFrame(null); + } + } +} + +var propTypesMisspellWarningShown; + +{ + propTypesMisspellWarningShown = false; +} +/** + * Verifies the object is a ReactElement. + * See https://reactjs.org/docs/react-api.html#isvalidelement + * @param {?object} object + * @return {boolean} True if `object` is a ReactElement. + * @final + */ + + +function isValidElement(object) { + { + return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; + } +} + +function getDeclarationErrorAddendum() { + { + if (ReactCurrentOwner$1.current) { + var name = getComponentNameFromType(ReactCurrentOwner$1.current.type); + + if (name) { + return '\n\nCheck the render method of `' + name + '`.'; + } + } + + return ''; + } +} + +function getSourceInfoErrorAddendum(source) { + { + if (source !== undefined) { + var fileName = source.fileName.replace(/^.*[\\\/]/, ''); + var lineNumber = source.lineNumber; + return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.'; + } + + return ''; + } +} +/** + * Warn if there's no key explicitly set on dynamic arrays of children or + * object keys are not valid. This allows us to keep track of children between + * updates. + */ + + +var ownerHasKeyUseWarning = {}; + +function getCurrentComponentErrorInfo(parentType) { + { + var info = getDeclarationErrorAddendum(); + + if (!info) { + var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name; + + if (parentName) { + info = "\n\nCheck the top-level render call using <" + parentName + ">."; + } + } + + return info; + } +} +/** + * Warn if the element doesn't have an explicit key assigned to it. + * This element is in an array. The array could grow and shrink or be + * reordered. All children that haven't already been validated are required to + * have a "key" property assigned to it. Error statuses are cached so a warning + * will only be shown once. + * + * @internal + * @param {ReactElement} element Element that requires a key. + * @param {*} parentType element's parent's type. + */ + + +function validateExplicitKey(element, parentType) { + { + if (!element._store || element._store.validated || element.key != null) { + return; + } + + element._store.validated = true; + var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); + + if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { + return; + } + + ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a + // property, it may be the creator of the child that's responsible for + // assigning it a key. + + var childOwner = ''; + + if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) { + // Give the component that originally created this child. + childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + "."; + } + + setCurrentlyValidatingElement$1(element); + + error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner); + + setCurrentlyValidatingElement$1(null); + } +} +/** + * Ensure that every element either is passed in a static location, in an + * array with an explicit keys property defined, or in an object literal + * with valid key property. + * + * @internal + * @param {ReactNode} node Statically passed child of any type. + * @param {*} parentType node's parent's type. + */ + + +function validateChildKeys(node, parentType) { + { + if (typeof node !== 'object') { + return; + } + + if (isArray(node)) { + for (var i = 0; i < node.length; i++) { + var child = node[i]; + + if (isValidElement(child)) { + validateExplicitKey(child, parentType); + } + } + } else if (isValidElement(node)) { + // This element was passed in a valid location. + if (node._store) { + node._store.validated = true; + } + } else if (node) { + var iteratorFn = getIteratorFn(node); + + if (typeof iteratorFn === 'function') { + // Entry iterators used to provide implicit keys, + // but now we print a separate warning for them later. + if (iteratorFn !== node.entries) { + var iterator = iteratorFn.call(node); + var step; + + while (!(step = iterator.next()).done) { + if (isValidElement(step.value)) { + validateExplicitKey(step.value, parentType); + } + } + } + } + } + } +} +/** + * Given an element, validate that its props follow the propTypes definition, + * provided by the type. + * + * @param {ReactElement} element + */ + + +function validatePropTypes(element) { + { + var type = element.type; + + if (type === null || type === undefined || typeof type === 'string') { + return; + } + + var propTypes; + + if (typeof type === 'function') { + propTypes = type.propTypes; + } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here. + // Inner props are checked in the reconciler. + type.$$typeof === REACT_MEMO_TYPE)) { + propTypes = type.propTypes; + } else { + return; + } + + if (propTypes) { + // Intentionally inside to avoid triggering lazy initializers: + var name = getComponentNameFromType(type); + checkPropTypes(propTypes, element.props, 'prop', name, element); + } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) { + propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers: + + var _name = getComponentNameFromType(type); + + error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown'); + } + + if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) { + error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.'); + } + } +} +/** + * Given a fragment, validate that it can only be provided with fragment props + * @param {ReactElement} fragment + */ + + +function validateFragmentProps(fragment) { + { + var keys = Object.keys(fragment.props); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + + if (key !== 'children' && key !== 'key') { + setCurrentlyValidatingElement$1(fragment); + + error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key); + + setCurrentlyValidatingElement$1(null); + break; + } + } + + if (fragment.ref !== null) { + setCurrentlyValidatingElement$1(fragment); + + error('Invalid attribute `ref` supplied to `React.Fragment`.'); + + setCurrentlyValidatingElement$1(null); + } + } +} + +var didWarnAboutKeySpread = {}; +function jsxWithValidation(type, props, key, isStaticChildren, source, self) { + { + var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to + // succeed and there will likely be errors in render. + + if (!validType) { + var info = ''; + + if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) { + info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports."; + } + + var sourceInfo = getSourceInfoErrorAddendum(source); + + if (sourceInfo) { + info += sourceInfo; + } else { + info += getDeclarationErrorAddendum(); + } + + var typeString; + + if (type === null) { + typeString = 'null'; + } else if (isArray(type)) { + typeString = 'array'; + } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) { + typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />"; + info = ' Did you accidentally export a JSX literal instead of a component?'; + } else { + typeString = typeof type; + } + + error('React.jsx: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info); + } + + var element = jsxDEV(type, props, key, source, self); // The result can be nullish if a mock or a custom function is used. + // TODO: Drop this when these are no longer allowed as the type argument. + + if (element == null) { + return element; + } // Skip key warning if the type isn't valid since our key validation logic + // doesn't expect a non-string/function type and can throw confusing errors. + // We don't want exception behavior to differ between dev and prod. + // (Rendering will throw with a helpful message and as soon as the type is + // fixed, the key warnings will appear.) + + + if (validType) { + var children = props.children; + + if (children !== undefined) { + if (isStaticChildren) { + if (isArray(children)) { + for (var i = 0; i < children.length; i++) { + validateChildKeys(children[i], type); + } + + if (Object.freeze) { + Object.freeze(children); + } + } else { + error('React.jsx: Static children should always be an array. ' + 'You are likely explicitly calling React.jsxs or React.jsxDEV. ' + 'Use the Babel transform instead.'); + } + } else { + validateChildKeys(children, type); + } + } + } + + { + if (hasOwnProperty.call(props, 'key')) { + var componentName = getComponentNameFromType(type); + var keys = Object.keys(props).filter(function (k) { + return k !== 'key'; + }); + var beforeExample = keys.length > 0 ? '{key: someKey, ' + keys.join(': ..., ') + ': ...}' : '{key: someKey}'; + + if (!didWarnAboutKeySpread[componentName + beforeExample]) { + var afterExample = keys.length > 0 ? '{' + keys.join(': ..., ') + ': ...}' : '{}'; + + error('A props object containing a "key" prop is being spread into JSX:\n' + ' let props = %s;\n' + ' <%s {...props} />\n' + 'React keys must be passed directly to JSX without using spread:\n' + ' let props = %s;\n' + ' <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName); + + didWarnAboutKeySpread[componentName + beforeExample] = true; + } + } + } + + if (type === REACT_FRAGMENT_TYPE) { + validateFragmentProps(element); + } else { + validatePropTypes(element); + } + + return element; + } +} // These two functions exist to still get child warnings in dev +// even with the prod transform. This means that jsxDEV is purely +// opt-in behavior for better messages but that we won't stop +// giving you warnings if you use production apis. + +function jsxWithValidationStatic(type, props, key) { + { + return jsxWithValidation(type, props, key, true); + } +} +function jsxWithValidationDynamic(type, props, key) { + { + return jsxWithValidation(type, props, key, false); + } +} + +var jsx = jsxWithValidationDynamic ; // we may want to special case jsxs internally to take advantage of static children. +// for now we can ship identical prod functions + +var jsxs = jsxWithValidationStatic ; + +exports.Fragment = REACT_FRAGMENT_TYPE; +exports.jsx = jsx; +exports.jsxs = jsxs; + })(); +} diff --git a/node_modules/react/cjs/react-jsx-runtime.production.min.js b/node_modules/react/cjs/react-jsx-runtime.production.min.js new file mode 100644 index 0000000..6d1e3a3 --- /dev/null +++ b/node_modules/react/cjs/react-jsx-runtime.production.min.js @@ -0,0 +1,11 @@ +/** + * @license React + * react-jsx-runtime.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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 f=require("react"),k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0}; +function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q; diff --git a/node_modules/react/cjs/react-jsx-runtime.profiling.min.js b/node_modules/react/cjs/react-jsx-runtime.profiling.min.js new file mode 100644 index 0000000..a392b06 --- /dev/null +++ b/node_modules/react/cjs/react-jsx-runtime.profiling.min.js @@ -0,0 +1,11 @@ +/** + * @license React + * react-jsx-runtime.profiling.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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 f=require("react"),k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0}; +function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q; diff --git a/node_modules/react/cjs/react.development.js b/node_modules/react/cjs/react.development.js new file mode 100644 index 0000000..8735990 --- /dev/null +++ b/node_modules/react/cjs/react.development.js @@ -0,0 +1,2740 @@ +/** + * @license React + * react.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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") { + (function() { + + 'use strict'; + +/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */ +if ( + typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && + typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === + 'function' +) { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); +} + var ReactVersion = '18.3.1'; + +// ATTENTION +// When adding new symbols to this file, +// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols' +// The Symbol used to tag the ReactElement-like types. +var REACT_ELEMENT_TYPE = Symbol.for('react.element'); +var REACT_PORTAL_TYPE = Symbol.for('react.portal'); +var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment'); +var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode'); +var REACT_PROFILER_TYPE = Symbol.for('react.profiler'); +var REACT_PROVIDER_TYPE = Symbol.for('react.provider'); +var REACT_CONTEXT_TYPE = Symbol.for('react.context'); +var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref'); +var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense'); +var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list'); +var REACT_MEMO_TYPE = Symbol.for('react.memo'); +var REACT_LAZY_TYPE = Symbol.for('react.lazy'); +var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen'); +var MAYBE_ITERATOR_SYMBOL = Symbol.iterator; +var FAUX_ITERATOR_SYMBOL = '@@iterator'; +function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable !== 'object') { + return null; + } + + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + + if (typeof maybeIterator === 'function') { + return maybeIterator; + } + + return null; +} + +/** + * Keeps track of the current dispatcher. + */ +var ReactCurrentDispatcher = { + /** + * @internal + * @type {ReactComponent} + */ + current: null +}; + +/** + * Keeps track of the current batch's configuration such as how long an update + * should suspend for if it needs to. + */ +var ReactCurrentBatchConfig = { + transition: null +}; + +var ReactCurrentActQueue = { + current: null, + // Used to reproduce behavior of `batchedUpdates` in legacy mode. + isBatchingLegacy: false, + didScheduleLegacyUpdate: false +}; + +/** + * Keeps track of the current owner. + * + * The current owner is the component who should own any components that are + * currently being constructed. + */ +var ReactCurrentOwner = { + /** + * @internal + * @type {ReactComponent} + */ + current: null +}; + +var ReactDebugCurrentFrame = {}; +var currentExtraStackFrame = null; +function setExtraStackFrame(stack) { + { + currentExtraStackFrame = stack; + } +} + +{ + ReactDebugCurrentFrame.setExtraStackFrame = function (stack) { + { + currentExtraStackFrame = stack; + } + }; // Stack implementation injected by the current renderer. + + + ReactDebugCurrentFrame.getCurrentStack = null; + + ReactDebugCurrentFrame.getStackAddendum = function () { + var stack = ''; // Add an extra top frame while an element is being validated + + if (currentExtraStackFrame) { + stack += currentExtraStackFrame; + } // Delegate to the injected renderer-specific implementation + + + var impl = ReactDebugCurrentFrame.getCurrentStack; + + if (impl) { + stack += impl() || ''; + } + + return stack; + }; +} + +// ----------------------------------------------------------------------------- + +var enableScopeAPI = false; // Experimental Create Event Handle API. +var enableCacheElement = false; +var enableTransitionTracing = false; // No known bugs, but needs performance testing + +var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber +// stuff. Intended to enable React core members to more easily debug scheduling +// issues in DEV builds. + +var enableDebugTracing = false; // Track which Fiber(s) schedule render work. + +var ReactSharedInternals = { + ReactCurrentDispatcher: ReactCurrentDispatcher, + ReactCurrentBatchConfig: ReactCurrentBatchConfig, + ReactCurrentOwner: ReactCurrentOwner +}; + +{ + ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame; + ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue; +} + +// by calls to these methods by a Babel plugin. +// +// In PROD (or in packages without access to React internals), +// they are left as they are instead. + +function warn(format) { + { + { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + printWarning('warn', format, args); + } + } +} +function error(format) { + { + { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + + printWarning('error', format, args); + } + } +} + +function printWarning(level, format, args) { + // When changing this logic, you might want to also + // update consoleWithStackDev.www.js as well. + { + var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame.getStackAddendum(); + + if (stack !== '') { + format += '%s'; + args = args.concat([stack]); + } // eslint-disable-next-line react-internal/safe-string-coercion + + + var argsWithFormat = args.map(function (item) { + return String(item); + }); // Careful: RN currently depends on this prefix + + argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it + // breaks IE9: https://github.com/facebook/react/issues/13610 + // eslint-disable-next-line react-internal/no-production-logging + + Function.prototype.apply.call(console[level], console, argsWithFormat); + } +} + +var didWarnStateUpdateForUnmountedComponent = {}; + +function warnNoop(publicInstance, callerName) { + { + var _constructor = publicInstance.constructor; + var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass'; + var warningKey = componentName + "." + callerName; + + if (didWarnStateUpdateForUnmountedComponent[warningKey]) { + return; + } + + error("Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName); + + didWarnStateUpdateForUnmountedComponent[warningKey] = true; + } +} +/** + * This is the abstract API for an update queue. + */ + + +var ReactNoopUpdateQueue = { + /** + * Checks whether or not this composite component is mounted. + * @param {ReactClass} publicInstance The instance we want to test. + * @return {boolean} True if mounted, false otherwise. + * @protected + * @final + */ + isMounted: function (publicInstance) { + return false; + }, + + /** + * Forces an update. This should only be invoked when it is known with + * certainty that we are **not** in a DOM transaction. + * + * You may want to call this when you know that some deeper aspect of the + * component's state has changed but `setState` was not called. + * + * This will not invoke `shouldComponentUpdate`, but it will invoke + * `componentWillUpdate` and `componentDidUpdate`. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ + enqueueForceUpdate: function (publicInstance, callback, callerName) { + warnNoop(publicInstance, 'forceUpdate'); + }, + + /** + * Replaces all of the state. Always use this or `setState` to mutate state. + * You should treat `this.state` as immutable. + * + * There is no guarantee that `this.state` will be immediately updated, so + * accessing `this.state` after calling this method may return the old value. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} completeState Next state. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ + enqueueReplaceState: function (publicInstance, completeState, callback, callerName) { + warnNoop(publicInstance, 'replaceState'); + }, + + /** + * Sets a subset of the state. This only exists because _pendingState is + * internal. This provides a merging strategy that is not available to deep + * properties which is confusing. TODO: Expose pendingState or don't use it + * during the merge. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} partialState Next partial state to be merged with state. + * @param {?function} callback Called after component is updated. + * @param {?string} Name of the calling function in the public API. + * @internal + */ + enqueueSetState: function (publicInstance, partialState, callback, callerName) { + warnNoop(publicInstance, 'setState'); + } +}; + +var assign = Object.assign; + +var emptyObject = {}; + +{ + Object.freeze(emptyObject); +} +/** + * Base class helpers for the updating state of a component. + */ + + +function Component(props, context, updater) { + this.props = props; + this.context = context; // If a component has string refs, we will assign a different object later. + + this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the + // renderer. + + this.updater = updater || ReactNoopUpdateQueue; +} + +Component.prototype.isReactComponent = {}; +/** + * Sets a subset of the state. Always use this to mutate + * state. You should treat `this.state` as immutable. + * + * There is no guarantee that `this.state` will be immediately updated, so + * accessing `this.state` after calling this method may return the old value. + * + * There is no guarantee that calls to `setState` will run synchronously, + * as they may eventually be batched together. You can provide an optional + * callback that will be executed when the call to setState is actually + * completed. + * + * When a function is provided to setState, it will be called at some point in + * the future (not synchronously). It will be called with the up to date + * component arguments (state, props, context). These values can be different + * from this.* because your function may be called after receiveProps but before + * shouldComponentUpdate, and this new state, props, and context will not yet be + * assigned to this. + * + * @param {object|function} partialState Next partial state or function to + * produce next partial state to be merged with current state. + * @param {?function} callback Called after state is updated. + * @final + * @protected + */ + +Component.prototype.setState = function (partialState, callback) { + if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) { + throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.'); + } + + this.updater.enqueueSetState(this, partialState, callback, 'setState'); +}; +/** + * Forces an update. This should only be invoked when it is known with + * certainty that we are **not** in a DOM transaction. + * + * You may want to call this when you know that some deeper aspect of the + * component's state has changed but `setState` was not called. + * + * This will not invoke `shouldComponentUpdate`, but it will invoke + * `componentWillUpdate` and `componentDidUpdate`. + * + * @param {?function} callback Called after update is complete. + * @final + * @protected + */ + + +Component.prototype.forceUpdate = function (callback) { + this.updater.enqueueForceUpdate(this, callback, 'forceUpdate'); +}; +/** + * Deprecated APIs. These APIs used to exist on classic React classes but since + * we would like to deprecate them, we're not going to move them over to this + * modern base class. Instead, we define a getter that warns if it's accessed. + */ + + +{ + var deprecatedAPIs = { + isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'], + replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).'] + }; + + var defineDeprecationWarning = function (methodName, info) { + Object.defineProperty(Component.prototype, methodName, { + get: function () { + warn('%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]); + + return undefined; + } + }); + }; + + for (var fnName in deprecatedAPIs) { + if (deprecatedAPIs.hasOwnProperty(fnName)) { + defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); + } + } +} + +function ComponentDummy() {} + +ComponentDummy.prototype = Component.prototype; +/** + * Convenience component with default shallow equality check for sCU. + */ + +function PureComponent(props, context, updater) { + this.props = props; + this.context = context; // If a component has string refs, we will assign a different object later. + + this.refs = emptyObject; + this.updater = updater || ReactNoopUpdateQueue; +} + +var pureComponentPrototype = PureComponent.prototype = new ComponentDummy(); +pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods. + +assign(pureComponentPrototype, Component.prototype); +pureComponentPrototype.isPureReactComponent = true; + +// an immutable object with a single mutable value +function createRef() { + var refObject = { + current: null + }; + + { + Object.seal(refObject); + } + + return refObject; +} + +var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare + +function isArray(a) { + return isArrayImpl(a); +} + +/* + * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol + * and Temporal.* types. See https://github.com/facebook/react/pull/22064. + * + * The functions in this module will throw an easier-to-understand, + * easier-to-debug exception with a clear errors message message explaining the + * problem. (Instead of a confusing exception thrown inside the implementation + * of the `value` object). + */ +// $FlowFixMe only called in DEV, so void return is not possible. +function typeName(value) { + { + // toStringTag is needed for namespaced types like Temporal.Instant + var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag; + var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; + return type; + } +} // $FlowFixMe only called in DEV, so void return is not possible. + + +function willCoercionThrow(value) { + { + try { + testStringCoercion(value); + return false; + } catch (e) { + return true; + } + } +} + +function testStringCoercion(value) { + // If you ended up here by following an exception call stack, here's what's + // happened: you supplied an object or symbol value to React (as a prop, key, + // DOM attribute, CSS property, string ref, etc.) and when React tried to + // coerce it to a string using `'' + value`, an exception was thrown. + // + // The most common types that will cause this exception are `Symbol` instances + // and Temporal objects like `Temporal.Instant`. But any object that has a + // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this + // exception. (Library authors do this to prevent users from using built-in + // numeric operators like `+` or comparison operators like `>=` because custom + // methods are needed to perform accurate arithmetic or comparison.) + // + // To fix the problem, coerce this object or symbol value to a string before + // passing it to React. The most reliable way is usually `String(value)`. + // + // To find which value is throwing, check the browser or debugger console. + // Before this exception was thrown, there should be `console.error` output + // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the + // problem and how that type was used: key, atrribute, input value prop, etc. + // In most cases, this console output also shows the component and its + // ancestor components where the exception happened. + // + // eslint-disable-next-line react-internal/safe-string-coercion + return '' + value; +} +function checkKeyStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value)); + + return testStringCoercion(value); // throw (to help callers find troubleshooting comments) + } + } +} + +function getWrappedName(outerType, innerType, wrapperName) { + var displayName = outerType.displayName; + + if (displayName) { + return displayName; + } + + var functionName = innerType.displayName || innerType.name || ''; + return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName; +} // Keep in sync with react-reconciler/getComponentNameFromFiber + + +function getContextName(type) { + return type.displayName || 'Context'; +} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead. + + +function getComponentNameFromType(type) { + if (type == null) { + // Host root, text node or just invalid type. + return null; + } + + { + if (typeof type.tag === 'number') { + error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.'); + } + } + + if (typeof type === 'function') { + return type.displayName || type.name || null; + } + + if (typeof type === 'string') { + return type; + } + + switch (type) { + case REACT_FRAGMENT_TYPE: + return 'Fragment'; + + case REACT_PORTAL_TYPE: + return 'Portal'; + + case REACT_PROFILER_TYPE: + return 'Profiler'; + + case REACT_STRICT_MODE_TYPE: + return 'StrictMode'; + + case REACT_SUSPENSE_TYPE: + return 'Suspense'; + + case REACT_SUSPENSE_LIST_TYPE: + return 'SuspenseList'; + + } + + if (typeof type === 'object') { + switch (type.$$typeof) { + case REACT_CONTEXT_TYPE: + var context = type; + return getContextName(context) + '.Consumer'; + + case REACT_PROVIDER_TYPE: + var provider = type; + return getContextName(provider._context) + '.Provider'; + + case REACT_FORWARD_REF_TYPE: + return getWrappedName(type, type.render, 'ForwardRef'); + + case REACT_MEMO_TYPE: + var outerName = type.displayName || null; + + if (outerName !== null) { + return outerName; + } + + return getComponentNameFromType(type.type) || 'Memo'; + + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + + try { + return getComponentNameFromType(init(payload)); + } catch (x) { + return null; + } + } + + // eslint-disable-next-line no-fallthrough + } + } + + return null; +} + +var hasOwnProperty = Object.prototype.hasOwnProperty; + +var RESERVED_PROPS = { + key: true, + ref: true, + __self: true, + __source: true +}; +var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs; + +{ + didWarnAboutStringRefs = {}; +} + +function hasValidRef(config) { + { + if (hasOwnProperty.call(config, 'ref')) { + var getter = Object.getOwnPropertyDescriptor(config, 'ref').get; + + if (getter && getter.isReactWarning) { + return false; + } + } + } + + return config.ref !== undefined; +} + +function hasValidKey(config) { + { + if (hasOwnProperty.call(config, 'key')) { + var getter = Object.getOwnPropertyDescriptor(config, 'key').get; + + if (getter && getter.isReactWarning) { + return false; + } + } + } + + return config.key !== undefined; +} + +function defineKeyPropWarningGetter(props, displayName) { + var warnAboutAccessingKey = function () { + { + if (!specialPropKeyWarningShown) { + specialPropKeyWarningShown = true; + + error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName); + } + } + }; + + warnAboutAccessingKey.isReactWarning = true; + Object.defineProperty(props, 'key', { + get: warnAboutAccessingKey, + configurable: true + }); +} + +function defineRefPropWarningGetter(props, displayName) { + var warnAboutAccessingRef = function () { + { + if (!specialPropRefWarningShown) { + specialPropRefWarningShown = true; + + error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName); + } + } + }; + + warnAboutAccessingRef.isReactWarning = true; + Object.defineProperty(props, 'ref', { + get: warnAboutAccessingRef, + configurable: true + }); +} + +function warnIfStringRefCannotBeAutoConverted(config) { + { + if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) { + var componentName = getComponentNameFromType(ReactCurrentOwner.current.type); + + if (!didWarnAboutStringRefs[componentName]) { + error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref); + + didWarnAboutStringRefs[componentName] = true; + } + } + } +} +/** + * Factory method to create a new React element. This no longer adheres to + * the class pattern, so do not use new to call it. Also, instanceof check + * will not work. Instead test $$typeof field against Symbol.for('react.element') to check + * if something is a React Element. + * + * @param {*} type + * @param {*} props + * @param {*} key + * @param {string|object} ref + * @param {*} owner + * @param {*} self A *temporary* helper to detect places where `this` is + * different from the `owner` when React.createElement is called, so that we + * can warn. We want to get rid of owner and replace string `ref`s with arrow + * functions, and as long as `this` and owner are the same, there will be no + * change in behavior. + * @param {*} source An annotation object (added by a transpiler or otherwise) + * indicating filename, line number, and/or other information. + * @internal + */ + + +var ReactElement = function (type, key, ref, self, source, owner, props) { + var element = { + // This tag allows us to uniquely identify this as a React Element + $$typeof: REACT_ELEMENT_TYPE, + // Built-in properties that belong on the element + type: type, + key: key, + ref: ref, + props: props, + // Record the component responsible for creating this element. + _owner: owner + }; + + { + // The validation flag is currently mutative. We put it on + // an external backing store so that we can freeze the whole object. + // This can be replaced with a WeakMap once they are implemented in + // commonly used development environments. + element._store = {}; // To make comparing ReactElements easier for testing purposes, we make + // the validation flag non-enumerable (where possible, which should + // include every environment we run tests in), so the test framework + // ignores it. + + Object.defineProperty(element._store, 'validated', { + configurable: false, + enumerable: false, + writable: true, + value: false + }); // self and source are DEV only properties. + + Object.defineProperty(element, '_self', { + configurable: false, + enumerable: false, + writable: false, + value: self + }); // Two elements created in two different places should be considered + // equal for testing purposes and therefore we hide it from enumeration. + + Object.defineProperty(element, '_source', { + configurable: false, + enumerable: false, + writable: false, + value: source + }); + + if (Object.freeze) { + Object.freeze(element.props); + Object.freeze(element); + } + } + + return element; +}; +/** + * Create and return a new ReactElement of the given type. + * See https://reactjs.org/docs/react-api.html#createelement + */ + +function createElement(type, config, children) { + var propName; // Reserved names are extracted + + var props = {}; + var key = null; + var ref = null; + var self = null; + var source = null; + + if (config != null) { + if (hasValidRef(config)) { + ref = config.ref; + + { + warnIfStringRefCannotBeAutoConverted(config); + } + } + + if (hasValidKey(config)) { + { + checkKeyStringCoercion(config.key); + } + + key = '' + config.key; + } + + self = config.__self === undefined ? null : config.__self; + source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object + + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + props[propName] = config[propName]; + } + } + } // Children can be more than one argument, and those are transferred onto + // the newly allocated props object. + + + var childrenLength = arguments.length - 2; + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 2]; + } + + { + if (Object.freeze) { + Object.freeze(childArray); + } + } + + props.children = childArray; + } // Resolve default props + + + if (type && type.defaultProps) { + var defaultProps = type.defaultProps; + + for (propName in defaultProps) { + if (props[propName] === undefined) { + props[propName] = defaultProps[propName]; + } + } + } + + { + if (key || ref) { + var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; + + if (key) { + defineKeyPropWarningGetter(props, displayName); + } + + if (ref) { + defineRefPropWarningGetter(props, displayName); + } + } + } + + return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props); +} +function cloneAndReplaceKey(oldElement, newKey) { + var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props); + return newElement; +} +/** + * Clone and return a new ReactElement using element as the starting point. + * See https://reactjs.org/docs/react-api.html#cloneelement + */ + +function cloneElement(element, config, children) { + if (element === null || element === undefined) { + throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + "."); + } + + var propName; // Original props are copied + + var props = assign({}, element.props); // Reserved names are extracted + + var key = element.key; + var ref = element.ref; // Self is preserved since the owner is preserved. + + var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a + // transpiler, and the original source is probably a better indicator of the + // true owner. + + var source = element._source; // Owner will be preserved, unless ref is overridden + + var owner = element._owner; + + if (config != null) { + if (hasValidRef(config)) { + // Silently steal the ref from the parent. + ref = config.ref; + owner = ReactCurrentOwner.current; + } + + if (hasValidKey(config)) { + { + checkKeyStringCoercion(config.key); + } + + key = '' + config.key; + } // Remaining properties override existing props + + + var defaultProps; + + if (element.type && element.type.defaultProps) { + defaultProps = element.type.defaultProps; + } + + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + if (config[propName] === undefined && defaultProps !== undefined) { + // Resolve default props + props[propName] = defaultProps[propName]; + } else { + props[propName] = config[propName]; + } + } + } + } // Children can be more than one argument, and those are transferred onto + // the newly allocated props object. + + + var childrenLength = arguments.length - 2; + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 2]; + } + + props.children = childArray; + } + + return ReactElement(element.type, key, ref, self, source, owner, props); +} +/** + * Verifies the object is a ReactElement. + * See https://reactjs.org/docs/react-api.html#isvalidelement + * @param {?object} object + * @return {boolean} True if `object` is a ReactElement. + * @final + */ + +function isValidElement(object) { + return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; +} + +var SEPARATOR = '.'; +var SUBSEPARATOR = ':'; +/** + * Escape and wrap key so it is safe to use as a reactid + * + * @param {string} key to be escaped. + * @return {string} the escaped key. + */ + +function escape(key) { + var escapeRegex = /[=:]/g; + var escaperLookup = { + '=': '=0', + ':': '=2' + }; + var escapedString = key.replace(escapeRegex, function (match) { + return escaperLookup[match]; + }); + return '$' + escapedString; +} +/** + * TODO: Test that a single child and an array with one item have the same key + * pattern. + */ + + +var didWarnAboutMaps = false; +var userProvidedKeyEscapeRegex = /\/+/g; + +function escapeUserProvidedKey(text) { + return text.replace(userProvidedKeyEscapeRegex, '$&/'); +} +/** + * Generate a key string that identifies a element within a set. + * + * @param {*} element A element that could contain a manual key. + * @param {number} index Index that is used if a manual key is not provided. + * @return {string} + */ + + +function getElementKey(element, index) { + // Do some typechecking here since we call this blindly. We want to ensure + // that we don't block potential future ES APIs. + if (typeof element === 'object' && element !== null && element.key != null) { + // Explicit key + { + checkKeyStringCoercion(element.key); + } + + return escape('' + element.key); + } // Implicit key determined by the index in the set + + + return index.toString(36); +} + +function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) { + var type = typeof children; + + if (type === 'undefined' || type === 'boolean') { + // All of the above are perceived as null. + children = null; + } + + var invokeCallback = false; + + if (children === null) { + invokeCallback = true; + } else { + switch (type) { + case 'string': + case 'number': + invokeCallback = true; + break; + + case 'object': + switch (children.$$typeof) { + case REACT_ELEMENT_TYPE: + case REACT_PORTAL_TYPE: + invokeCallback = true; + } + + } + } + + if (invokeCallback) { + var _child = children; + var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array + // so that it's consistent if the number of children grows: + + var childKey = nameSoFar === '' ? SEPARATOR + getElementKey(_child, 0) : nameSoFar; + + if (isArray(mappedChild)) { + var escapedChildKey = ''; + + if (childKey != null) { + escapedChildKey = escapeUserProvidedKey(childKey) + '/'; + } + + mapIntoArray(mappedChild, array, escapedChildKey, '', function (c) { + return c; + }); + } else if (mappedChild != null) { + if (isValidElement(mappedChild)) { + { + // The `if` statement here prevents auto-disabling of the safe + // coercion ESLint rule, so we must manually disable it below. + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key + if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) { + checkKeyStringCoercion(mappedChild.key); + } + } + + mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as + // traverseAllChildren used to do for objects as children + escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key + mappedChild.key && (!_child || _child.key !== mappedChild.key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number + // eslint-disable-next-line react-internal/safe-string-coercion + escapeUserProvidedKey('' + mappedChild.key) + '/' : '') + childKey); + } + + array.push(mappedChild); + } + + return 1; + } + + var child; + var nextName; + var subtreeCount = 0; // Count of children found in the current subtree. + + var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR; + + if (isArray(children)) { + for (var i = 0; i < children.length; i++) { + child = children[i]; + nextName = nextNamePrefix + getElementKey(child, i); + subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); + } + } else { + var iteratorFn = getIteratorFn(children); + + if (typeof iteratorFn === 'function') { + var iterableChildren = children; + + { + // Warn about using Maps as children + if (iteratorFn === iterableChildren.entries) { + if (!didWarnAboutMaps) { + warn('Using Maps as children is not supported. ' + 'Use an array of keyed ReactElements instead.'); + } + + didWarnAboutMaps = true; + } + } + + var iterator = iteratorFn.call(iterableChildren); + var step; + var ii = 0; + + while (!(step = iterator.next()).done) { + child = step.value; + nextName = nextNamePrefix + getElementKey(child, ii++); + subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); + } + } else if (type === 'object') { + // eslint-disable-next-line react-internal/safe-string-coercion + var childrenString = String(children); + throw new Error("Objects are not valid as a React child (found: " + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.'); + } + } + + return subtreeCount; +} + +/** + * Maps children that are typically specified as `props.children`. + * + * See https://reactjs.org/docs/react-api.html#reactchildrenmap + * + * The provided mapFunction(child, index) will be called for each + * leaf child. + * + * @param {?*} children Children tree container. + * @param {function(*, int)} func The map function. + * @param {*} context Context for mapFunction. + * @return {object} Object containing the ordered map of results. + */ +function mapChildren(children, func, context) { + if (children == null) { + return children; + } + + var result = []; + var count = 0; + mapIntoArray(children, result, '', '', function (child) { + return func.call(context, child, count++); + }); + return result; +} +/** + * Count the number of children that are typically specified as + * `props.children`. + * + * See https://reactjs.org/docs/react-api.html#reactchildrencount + * + * @param {?*} children Children tree container. + * @return {number} The number of children. + */ + + +function countChildren(children) { + var n = 0; + mapChildren(children, function () { + n++; // Don't return anything + }); + return n; +} + +/** + * Iterates through children that are typically specified as `props.children`. + * + * See https://reactjs.org/docs/react-api.html#reactchildrenforeach + * + * The provided forEachFunc(child, index) will be called for each + * leaf child. + * + * @param {?*} children Children tree container. + * @param {function(*, int)} forEachFunc + * @param {*} forEachContext Context for forEachContext. + */ +function forEachChildren(children, forEachFunc, forEachContext) { + mapChildren(children, function () { + forEachFunc.apply(this, arguments); // Don't return anything. + }, forEachContext); +} +/** + * Flatten a children object (typically specified as `props.children`) and + * return an array with appropriately re-keyed children. + * + * See https://reactjs.org/docs/react-api.html#reactchildrentoarray + */ + + +function toArray(children) { + return mapChildren(children, function (child) { + return child; + }) || []; +} +/** + * Returns the first child in a collection of children and verifies that there + * is only one child in the collection. + * + * See https://reactjs.org/docs/react-api.html#reactchildrenonly + * + * The current implementation of this function assumes that a single child gets + * passed without a wrapper, but the purpose of this helper function is to + * abstract away the particular structure of children. + * + * @param {?object} children Child collection structure. + * @return {ReactElement} The first and only `ReactElement` contained in the + * structure. + */ + + +function onlyChild(children) { + if (!isValidElement(children)) { + throw new Error('React.Children.only expected to receive a single React element child.'); + } + + return children; +} + +function createContext(defaultValue) { + // TODO: Second argument used to be an optional `calculateChangedBits` + // function. Warn to reserve for future use? + var context = { + $$typeof: REACT_CONTEXT_TYPE, + // As a workaround to support multiple concurrent renderers, we categorize + // some renderers as primary and others as secondary. We only expect + // there to be two concurrent renderers at most: React Native (primary) and + // Fabric (secondary); React DOM (primary) and React ART (secondary). + // Secondary renderers store their context values on separate fields. + _currentValue: defaultValue, + _currentValue2: defaultValue, + // Used to track how many concurrent renderers this context currently + // supports within in a single renderer. Such as parallel server rendering. + _threadCount: 0, + // These are circular + Provider: null, + Consumer: null, + // Add these to use same hidden class in VM as ServerContext + _defaultValue: null, + _globalName: null + }; + context.Provider = { + $$typeof: REACT_PROVIDER_TYPE, + _context: context + }; + var hasWarnedAboutUsingNestedContextConsumers = false; + var hasWarnedAboutUsingConsumerProvider = false; + var hasWarnedAboutDisplayNameOnConsumer = false; + + { + // A separate object, but proxies back to the original context object for + // backwards compatibility. It has a different $$typeof, so we can properly + // warn for the incorrect usage of Context as a Consumer. + var Consumer = { + $$typeof: REACT_CONTEXT_TYPE, + _context: context + }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here + + Object.defineProperties(Consumer, { + Provider: { + get: function () { + if (!hasWarnedAboutUsingConsumerProvider) { + hasWarnedAboutUsingConsumerProvider = true; + + error('Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?'); + } + + return context.Provider; + }, + set: function (_Provider) { + context.Provider = _Provider; + } + }, + _currentValue: { + get: function () { + return context._currentValue; + }, + set: function (_currentValue) { + context._currentValue = _currentValue; + } + }, + _currentValue2: { + get: function () { + return context._currentValue2; + }, + set: function (_currentValue2) { + context._currentValue2 = _currentValue2; + } + }, + _threadCount: { + get: function () { + return context._threadCount; + }, + set: function (_threadCount) { + context._threadCount = _threadCount; + } + }, + Consumer: { + get: function () { + if (!hasWarnedAboutUsingNestedContextConsumers) { + hasWarnedAboutUsingNestedContextConsumers = true; + + error('Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?'); + } + + return context.Consumer; + } + }, + displayName: { + get: function () { + return context.displayName; + }, + set: function (displayName) { + if (!hasWarnedAboutDisplayNameOnConsumer) { + warn('Setting `displayName` on Context.Consumer has no effect. ' + "You should set it directly on the context with Context.displayName = '%s'.", displayName); + + hasWarnedAboutDisplayNameOnConsumer = true; + } + } + } + }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty + + context.Consumer = Consumer; + } + + { + context._currentRenderer = null; + context._currentRenderer2 = null; + } + + return context; +} + +var Uninitialized = -1; +var Pending = 0; +var Resolved = 1; +var Rejected = 2; + +function lazyInitializer(payload) { + if (payload._status === Uninitialized) { + var ctor = payload._result; + var thenable = ctor(); // Transition to the next state. + // This might throw either because it's missing or throws. If so, we treat it + // as still uninitialized and try again next time. Which is the same as what + // happens if the ctor or any wrappers processing the ctor throws. This might + // end up fixing it if the resolution was a concurrency bug. + + thenable.then(function (moduleObject) { + if (payload._status === Pending || payload._status === Uninitialized) { + // Transition to the next state. + var resolved = payload; + resolved._status = Resolved; + resolved._result = moduleObject; + } + }, function (error) { + if (payload._status === Pending || payload._status === Uninitialized) { + // Transition to the next state. + var rejected = payload; + rejected._status = Rejected; + rejected._result = error; + } + }); + + if (payload._status === Uninitialized) { + // In case, we're still uninitialized, then we're waiting for the thenable + // to resolve. Set it as pending in the meantime. + var pending = payload; + pending._status = Pending; + pending._result = thenable; + } + } + + if (payload._status === Resolved) { + var moduleObject = payload._result; + + { + if (moduleObject === undefined) { + error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n ' + // Break up imports to avoid accidentally parsing them as dependencies. + 'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))\n\n" + 'Did you accidentally put curly braces around the import?', moduleObject); + } + } + + { + if (!('default' in moduleObject)) { + error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n ' + // Break up imports to avoid accidentally parsing them as dependencies. + 'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))", moduleObject); + } + } + + return moduleObject.default; + } else { + throw payload._result; + } +} + +function lazy(ctor) { + var payload = { + // We use these fields to store the result. + _status: Uninitialized, + _result: ctor + }; + var lazyType = { + $$typeof: REACT_LAZY_TYPE, + _payload: payload, + _init: lazyInitializer + }; + + { + // In production, this would just set it on the object. + var defaultProps; + var propTypes; // $FlowFixMe + + Object.defineProperties(lazyType, { + defaultProps: { + configurable: true, + get: function () { + return defaultProps; + }, + set: function (newDefaultProps) { + error('React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.'); + + defaultProps = newDefaultProps; // Match production behavior more closely: + // $FlowFixMe + + Object.defineProperty(lazyType, 'defaultProps', { + enumerable: true + }); + } + }, + propTypes: { + configurable: true, + get: function () { + return propTypes; + }, + set: function (newPropTypes) { + error('React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.'); + + propTypes = newPropTypes; // Match production behavior more closely: + // $FlowFixMe + + Object.defineProperty(lazyType, 'propTypes', { + enumerable: true + }); + } + } + }); + } + + return lazyType; +} + +function forwardRef(render) { + { + if (render != null && render.$$typeof === REACT_MEMO_TYPE) { + error('forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).'); + } else if (typeof render !== 'function') { + error('forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render); + } else { + if (render.length !== 0 && render.length !== 2) { + error('forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.'); + } + } + + if (render != null) { + if (render.defaultProps != null || render.propTypes != null) { + error('forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?'); + } + } + } + + var elementType = { + $$typeof: REACT_FORWARD_REF_TYPE, + render: render + }; + + { + var ownName; + Object.defineProperty(elementType, 'displayName', { + enumerable: false, + configurable: true, + get: function () { + return ownName; + }, + set: function (name) { + ownName = name; // The inner component shouldn't inherit this display name in most cases, + // because the component may be used elsewhere. + // But it's nice for anonymous functions to inherit the name, + // so that our component-stack generation logic will display their frames. + // An anonymous function generally suggests a pattern like: + // React.forwardRef((props, ref) => {...}); + // This kind of inner function is not used elsewhere so the side effect is okay. + + if (!render.name && !render.displayName) { + render.displayName = name; + } + } + }); + } + + return elementType; +} + +var REACT_MODULE_REFERENCE; + +{ + REACT_MODULE_REFERENCE = Symbol.for('react.module.reference'); +} + +function isValidElementType(type) { + if (typeof type === 'string' || typeof type === 'function') { + return true; + } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill). + + + if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing ) { + return true; + } + + if (typeof type === 'object' && type !== null) { + if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object + // types supported by any Flight configuration anywhere since + // we don't know which Flight build this will end up being used + // with. + type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) { + return true; + } + } + + return false; +} + +function memo(type, compare) { + { + if (!isValidElementType(type)) { + error('memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type); + } + } + + var elementType = { + $$typeof: REACT_MEMO_TYPE, + type: type, + compare: compare === undefined ? null : compare + }; + + { + var ownName; + Object.defineProperty(elementType, 'displayName', { + enumerable: false, + configurable: true, + get: function () { + return ownName; + }, + set: function (name) { + ownName = name; // The inner component shouldn't inherit this display name in most cases, + // because the component may be used elsewhere. + // But it's nice for anonymous functions to inherit the name, + // so that our component-stack generation logic will display their frames. + // An anonymous function generally suggests a pattern like: + // React.memo((props) => {...}); + // This kind of inner function is not used elsewhere so the side effect is okay. + + if (!type.name && !type.displayName) { + type.displayName = name; + } + } + }); + } + + return elementType; +} + +function resolveDispatcher() { + var dispatcher = ReactCurrentDispatcher.current; + + { + if (dispatcher === null) { + error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.'); + } + } // Will result in a null access error if accessed outside render phase. We + // intentionally don't throw our own error because this is in a hot path. + // Also helps ensure this is inlined. + + + return dispatcher; +} +function useContext(Context) { + var dispatcher = resolveDispatcher(); + + { + // TODO: add a more generic warning for invalid values. + if (Context._context !== undefined) { + var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs + // and nobody should be using this in existing code. + + if (realContext.Consumer === Context) { + error('Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?'); + } else if (realContext.Provider === Context) { + error('Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?'); + } + } + } + + return dispatcher.useContext(Context); +} +function useState(initialState) { + var dispatcher = resolveDispatcher(); + return dispatcher.useState(initialState); +} +function useReducer(reducer, initialArg, init) { + var dispatcher = resolveDispatcher(); + return dispatcher.useReducer(reducer, initialArg, init); +} +function useRef(initialValue) { + var dispatcher = resolveDispatcher(); + return dispatcher.useRef(initialValue); +} +function useEffect(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useEffect(create, deps); +} +function useInsertionEffect(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useInsertionEffect(create, deps); +} +function useLayoutEffect(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useLayoutEffect(create, deps); +} +function useCallback(callback, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useCallback(callback, deps); +} +function useMemo(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useMemo(create, deps); +} +function useImperativeHandle(ref, create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useImperativeHandle(ref, create, deps); +} +function useDebugValue(value, formatterFn) { + { + var dispatcher = resolveDispatcher(); + return dispatcher.useDebugValue(value, formatterFn); + } +} +function useTransition() { + var dispatcher = resolveDispatcher(); + return dispatcher.useTransition(); +} +function useDeferredValue(value) { + var dispatcher = resolveDispatcher(); + return dispatcher.useDeferredValue(value); +} +function useId() { + var dispatcher = resolveDispatcher(); + return dispatcher.useId(); +} +function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) { + var dispatcher = resolveDispatcher(); + return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot); +} + +// Helpers to patch console.logs to avoid logging during side-effect free +// replaying on render function. This currently only patches the object +// lazily which won't cover if the log function was extracted eagerly. +// We could also eagerly patch the method. +var disabledDepth = 0; +var prevLog; +var prevInfo; +var prevWarn; +var prevError; +var prevGroup; +var prevGroupCollapsed; +var prevGroupEnd; + +function disabledLog() {} + +disabledLog.__reactDisabledLog = true; +function disableLogs() { + { + if (disabledDepth === 0) { + /* eslint-disable react-internal/no-production-logging */ + prevLog = console.log; + prevInfo = console.info; + prevWarn = console.warn; + prevError = console.error; + prevGroup = console.group; + prevGroupCollapsed = console.groupCollapsed; + prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099 + + var props = { + configurable: true, + enumerable: true, + value: disabledLog, + writable: true + }; // $FlowFixMe Flow thinks console is immutable. + + Object.defineProperties(console, { + info: props, + log: props, + warn: props, + error: props, + group: props, + groupCollapsed: props, + groupEnd: props + }); + /* eslint-enable react-internal/no-production-logging */ + } + + disabledDepth++; + } +} +function reenableLogs() { + { + disabledDepth--; + + if (disabledDepth === 0) { + /* eslint-disable react-internal/no-production-logging */ + var props = { + configurable: true, + enumerable: true, + writable: true + }; // $FlowFixMe Flow thinks console is immutable. + + Object.defineProperties(console, { + log: assign({}, props, { + value: prevLog + }), + info: assign({}, props, { + value: prevInfo + }), + warn: assign({}, props, { + value: prevWarn + }), + error: assign({}, props, { + value: prevError + }), + group: assign({}, props, { + value: prevGroup + }), + groupCollapsed: assign({}, props, { + value: prevGroupCollapsed + }), + groupEnd: assign({}, props, { + value: prevGroupEnd + }) + }); + /* eslint-enable react-internal/no-production-logging */ + } + + if (disabledDepth < 0) { + error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.'); + } + } +} + +var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher; +var prefix; +function describeBuiltInComponentFrame(name, source, ownerFn) { + { + if (prefix === undefined) { + // Extract the VM specific prefix used by each line. + try { + throw Error(); + } catch (x) { + var match = x.stack.trim().match(/\n( *(at )?)/); + prefix = match && match[1] || ''; + } + } // We use the prefix to ensure our stacks line up with native stack frames. + + + return '\n' + prefix + name; + } +} +var reentry = false; +var componentFrameCache; + +{ + var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; + componentFrameCache = new PossiblyWeakMap(); +} + +function describeNativeComponentFrame(fn, construct) { + // If something asked for a stack inside a fake render, it should get ignored. + if ( !fn || reentry) { + return ''; + } + + { + var frame = componentFrameCache.get(fn); + + if (frame !== undefined) { + return frame; + } + } + + var control; + reentry = true; + var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined. + + Error.prepareStackTrace = undefined; + var previousDispatcher; + + { + previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function + // for warnings. + + ReactCurrentDispatcher$1.current = null; + disableLogs(); + } + + try { + // This should throw. + if (construct) { + // Something should be setting the props in the constructor. + var Fake = function () { + throw Error(); + }; // $FlowFixMe + + + Object.defineProperty(Fake.prototype, 'props', { + set: function () { + // We use a throwing setter instead of frozen or non-writable props + // because that won't throw in a non-strict mode function. + throw Error(); + } + }); + + if (typeof Reflect === 'object' && Reflect.construct) { + // We construct a different control for this case to include any extra + // frames added by the construct call. + try { + Reflect.construct(Fake, []); + } catch (x) { + control = x; + } + + Reflect.construct(fn, [], Fake); + } else { + try { + Fake.call(); + } catch (x) { + control = x; + } + + fn.call(Fake.prototype); + } + } else { + try { + throw Error(); + } catch (x) { + control = x; + } + + fn(); + } + } catch (sample) { + // This is inlined manually because closure doesn't do it for us. + if (sample && control && typeof sample.stack === 'string') { + // This extracts the first frame from the sample that isn't also in the control. + // Skipping one frame that we assume is the frame that calls the two. + var sampleLines = sample.stack.split('\n'); + var controlLines = control.stack.split('\n'); + var s = sampleLines.length - 1; + var c = controlLines.length - 1; + + while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) { + // We expect at least one stack frame to be shared. + // Typically this will be the root most one. However, stack frames may be + // cut off due to maximum stack limits. In this case, one maybe cut off + // earlier than the other. We assume that the sample is longer or the same + // and there for cut off earlier. So we should find the root most frame in + // the sample somewhere in the control. + c--; + } + + for (; s >= 1 && c >= 0; s--, c--) { + // Next we find the first one that isn't the same which should be the + // frame that called our sample function and the control. + if (sampleLines[s] !== controlLines[c]) { + // In V8, the first line is describing the message but other VMs don't. + // If we're about to return the first line, and the control is also on the same + // line, that's a pretty good indicator that our sample threw at same line as + // the control. I.e. before we entered the sample frame. So we ignore this result. + // This can happen if you passed a class to function component, or non-function. + if (s !== 1 || c !== 1) { + do { + s--; + c--; // We may still have similar intermediate frames from the construct call. + // The next one that isn't the same should be our match though. + + if (c < 0 || sampleLines[s] !== controlLines[c]) { + // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier. + var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "" + // but we have a user-provided "displayName" + // splice it in to make the stack more readable. + + + if (fn.displayName && _frame.includes('')) { + _frame = _frame.replace('', fn.displayName); + } + + { + if (typeof fn === 'function') { + componentFrameCache.set(fn, _frame); + } + } // Return the line we found. + + + return _frame; + } + } while (s >= 1 && c >= 0); + } + + break; + } + } + } + } finally { + reentry = false; + + { + ReactCurrentDispatcher$1.current = previousDispatcher; + reenableLogs(); + } + + Error.prepareStackTrace = previousPrepareStackTrace; + } // Fallback to just using the name if we couldn't make it throw. + + + var name = fn ? fn.displayName || fn.name : ''; + var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ''; + + { + if (typeof fn === 'function') { + componentFrameCache.set(fn, syntheticFrame); + } + } + + return syntheticFrame; +} +function describeFunctionComponentFrame(fn, source, ownerFn) { + { + return describeNativeComponentFrame(fn, false); + } +} + +function shouldConstruct(Component) { + var prototype = Component.prototype; + return !!(prototype && prototype.isReactComponent); +} + +function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { + + if (type == null) { + return ''; + } + + if (typeof type === 'function') { + { + return describeNativeComponentFrame(type, shouldConstruct(type)); + } + } + + if (typeof type === 'string') { + return describeBuiltInComponentFrame(type); + } + + switch (type) { + case REACT_SUSPENSE_TYPE: + return describeBuiltInComponentFrame('Suspense'); + + case REACT_SUSPENSE_LIST_TYPE: + return describeBuiltInComponentFrame('SuspenseList'); + } + + if (typeof type === 'object') { + switch (type.$$typeof) { + case REACT_FORWARD_REF_TYPE: + return describeFunctionComponentFrame(type.render); + + case REACT_MEMO_TYPE: + // Memo may contain any component type so we recursively resolve it. + return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn); + + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + + try { + // Lazy may contain any component type so we recursively resolve it. + return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn); + } catch (x) {} + } + } + } + + return ''; +} + +var loggedTypeFailures = {}; +var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame; + +function setCurrentlyValidatingElement(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + ReactDebugCurrentFrame$1.setExtraStackFrame(stack); + } else { + ReactDebugCurrentFrame$1.setExtraStackFrame(null); + } + } +} + +function checkPropTypes(typeSpecs, values, location, componentName, element) { + { + // $FlowFixMe This is okay but Flow doesn't know it. + var has = Function.call.bind(hasOwnProperty); + + for (var typeSpecName in typeSpecs) { + if (has(typeSpecs, typeSpecName)) { + var error$1 = void 0; // 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. + if (typeof typeSpecs[typeSpecName] !== 'function') { + // eslint-disable-next-line react-internal/prod-error-codes + var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'); + err.name = 'Invariant Violation'; + throw err; + } + + error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'); + } catch (ex) { + error$1 = ex; + } + + if (error$1 && !(error$1 instanceof Error)) { + setCurrentlyValidatingElement(element); + + 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$1); + + setCurrentlyValidatingElement(null); + } + + if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) { + // Only monitor this failure once because there tends to be a lot of the + // same error. + loggedTypeFailures[error$1.message] = true; + setCurrentlyValidatingElement(element); + + error('Failed %s type: %s', location, error$1.message); + + setCurrentlyValidatingElement(null); + } + } + } + } +} + +function setCurrentlyValidatingElement$1(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + setExtraStackFrame(stack); + } else { + setExtraStackFrame(null); + } + } +} + +var propTypesMisspellWarningShown; + +{ + propTypesMisspellWarningShown = false; +} + +function getDeclarationErrorAddendum() { + if (ReactCurrentOwner.current) { + var name = getComponentNameFromType(ReactCurrentOwner.current.type); + + if (name) { + return '\n\nCheck the render method of `' + name + '`.'; + } + } + + return ''; +} + +function getSourceInfoErrorAddendum(source) { + if (source !== undefined) { + var fileName = source.fileName.replace(/^.*[\\\/]/, ''); + var lineNumber = source.lineNumber; + return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.'; + } + + return ''; +} + +function getSourceInfoErrorAddendumForProps(elementProps) { + if (elementProps !== null && elementProps !== undefined) { + return getSourceInfoErrorAddendum(elementProps.__source); + } + + return ''; +} +/** + * Warn if there's no key explicitly set on dynamic arrays of children or + * object keys are not valid. This allows us to keep track of children between + * updates. + */ + + +var ownerHasKeyUseWarning = {}; + +function getCurrentComponentErrorInfo(parentType) { + var info = getDeclarationErrorAddendum(); + + if (!info) { + var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name; + + if (parentName) { + info = "\n\nCheck the top-level render call using <" + parentName + ">."; + } + } + + return info; +} +/** + * Warn if the element doesn't have an explicit key assigned to it. + * This element is in an array. The array could grow and shrink or be + * reordered. All children that haven't already been validated are required to + * have a "key" property assigned to it. Error statuses are cached so a warning + * will only be shown once. + * + * @internal + * @param {ReactElement} element Element that requires a key. + * @param {*} parentType element's parent's type. + */ + + +function validateExplicitKey(element, parentType) { + if (!element._store || element._store.validated || element.key != null) { + return; + } + + element._store.validated = true; + var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); + + if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { + return; + } + + ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a + // property, it may be the creator of the child that's responsible for + // assigning it a key. + + var childOwner = ''; + + if (element && element._owner && element._owner !== ReactCurrentOwner.current) { + // Give the component that originally created this child. + childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + "."; + } + + { + setCurrentlyValidatingElement$1(element); + + error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner); + + setCurrentlyValidatingElement$1(null); + } +} +/** + * Ensure that every element either is passed in a static location, in an + * array with an explicit keys property defined, or in an object literal + * with valid key property. + * + * @internal + * @param {ReactNode} node Statically passed child of any type. + * @param {*} parentType node's parent's type. + */ + + +function validateChildKeys(node, parentType) { + if (typeof node !== 'object') { + return; + } + + if (isArray(node)) { + for (var i = 0; i < node.length; i++) { + var child = node[i]; + + if (isValidElement(child)) { + validateExplicitKey(child, parentType); + } + } + } else if (isValidElement(node)) { + // This element was passed in a valid location. + if (node._store) { + node._store.validated = true; + } + } else if (node) { + var iteratorFn = getIteratorFn(node); + + if (typeof iteratorFn === 'function') { + // Entry iterators used to provide implicit keys, + // but now we print a separate warning for them later. + if (iteratorFn !== node.entries) { + var iterator = iteratorFn.call(node); + var step; + + while (!(step = iterator.next()).done) { + if (isValidElement(step.value)) { + validateExplicitKey(step.value, parentType); + } + } + } + } + } +} +/** + * Given an element, validate that its props follow the propTypes definition, + * provided by the type. + * + * @param {ReactElement} element + */ + + +function validatePropTypes(element) { + { + var type = element.type; + + if (type === null || type === undefined || typeof type === 'string') { + return; + } + + var propTypes; + + if (typeof type === 'function') { + propTypes = type.propTypes; + } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here. + // Inner props are checked in the reconciler. + type.$$typeof === REACT_MEMO_TYPE)) { + propTypes = type.propTypes; + } else { + return; + } + + if (propTypes) { + // Intentionally inside to avoid triggering lazy initializers: + var name = getComponentNameFromType(type); + checkPropTypes(propTypes, element.props, 'prop', name, element); + } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) { + propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers: + + var _name = getComponentNameFromType(type); + + error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown'); + } + + if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) { + error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.'); + } + } +} +/** + * Given a fragment, validate that it can only be provided with fragment props + * @param {ReactElement} fragment + */ + + +function validateFragmentProps(fragment) { + { + var keys = Object.keys(fragment.props); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + + if (key !== 'children' && key !== 'key') { + setCurrentlyValidatingElement$1(fragment); + + error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key); + + setCurrentlyValidatingElement$1(null); + break; + } + } + + if (fragment.ref !== null) { + setCurrentlyValidatingElement$1(fragment); + + error('Invalid attribute `ref` supplied to `React.Fragment`.'); + + setCurrentlyValidatingElement$1(null); + } + } +} +function createElementWithValidation(type, props, children) { + var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to + // succeed and there will likely be errors in render. + + if (!validType) { + var info = ''; + + if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) { + info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports."; + } + + var sourceInfo = getSourceInfoErrorAddendumForProps(props); + + if (sourceInfo) { + info += sourceInfo; + } else { + info += getDeclarationErrorAddendum(); + } + + var typeString; + + if (type === null) { + typeString = 'null'; + } else if (isArray(type)) { + typeString = 'array'; + } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) { + typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />"; + info = ' Did you accidentally export a JSX literal instead of a component?'; + } else { + typeString = typeof type; + } + + { + error('React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info); + } + } + + var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used. + // TODO: Drop this when these are no longer allowed as the type argument. + + if (element == null) { + return element; + } // Skip key warning if the type isn't valid since our key validation logic + // doesn't expect a non-string/function type and can throw confusing errors. + // We don't want exception behavior to differ between dev and prod. + // (Rendering will throw with a helpful message and as soon as the type is + // fixed, the key warnings will appear.) + + + if (validType) { + for (var i = 2; i < arguments.length; i++) { + validateChildKeys(arguments[i], type); + } + } + + if (type === REACT_FRAGMENT_TYPE) { + validateFragmentProps(element); + } else { + validatePropTypes(element); + } + + return element; +} +var didWarnAboutDeprecatedCreateFactory = false; +function createFactoryWithValidation(type) { + var validatedFactory = createElementWithValidation.bind(null, type); + validatedFactory.type = type; + + { + if (!didWarnAboutDeprecatedCreateFactory) { + didWarnAboutDeprecatedCreateFactory = true; + + warn('React.createFactory() is deprecated and will be removed in ' + 'a future major release. Consider using JSX ' + 'or use React.createElement() directly instead.'); + } // Legacy hook: remove it + + + Object.defineProperty(validatedFactory, 'type', { + enumerable: false, + get: function () { + warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.'); + + Object.defineProperty(this, 'type', { + value: type + }); + return type; + } + }); + } + + return validatedFactory; +} +function cloneElementWithValidation(element, props, children) { + var newElement = cloneElement.apply(this, arguments); + + for (var i = 2; i < arguments.length; i++) { + validateChildKeys(arguments[i], newElement.type); + } + + validatePropTypes(newElement); + return newElement; +} + +function startTransition(scope, options) { + var prevTransition = ReactCurrentBatchConfig.transition; + ReactCurrentBatchConfig.transition = {}; + var currentTransition = ReactCurrentBatchConfig.transition; + + { + ReactCurrentBatchConfig.transition._updatedFibers = new Set(); + } + + try { + scope(); + } finally { + ReactCurrentBatchConfig.transition = prevTransition; + + { + if (prevTransition === null && currentTransition._updatedFibers) { + var updatedFibersCount = currentTransition._updatedFibers.size; + + if (updatedFibersCount > 10) { + warn('Detected a large number of updates inside startTransition. ' + 'If this is due to a subscription please re-write it to use React provided hooks. ' + 'Otherwise concurrent mode guarantees are off the table.'); + } + + currentTransition._updatedFibers.clear(); + } + } + } +} + +var didWarnAboutMessageChannel = false; +var enqueueTaskImpl = null; +function enqueueTask(task) { + if (enqueueTaskImpl === null) { + try { + // read require off the module object to get around the bundlers. + // we don't want them to detect a require and bundle a Node polyfill. + var requireString = ('require' + Math.random()).slice(0, 7); + var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's + // version of setImmediate, bypassing fake timers if any. + + enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate; + } catch (_err) { + // we're in a browser + // we can't use regular timers because they may still be faked + // so we try MessageChannel+postMessage instead + enqueueTaskImpl = function (callback) { + { + if (didWarnAboutMessageChannel === false) { + didWarnAboutMessageChannel = true; + + if (typeof MessageChannel === 'undefined') { + error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.'); + } + } + } + + var channel = new MessageChannel(); + channel.port1.onmessage = callback; + channel.port2.postMessage(undefined); + }; + } + } + + return enqueueTaskImpl(task); +} + +var actScopeDepth = 0; +var didWarnNoAwaitAct = false; +function act(callback) { + { + // `act` calls can be nested, so we track the depth. This represents the + // number of `act` scopes on the stack. + var prevActScopeDepth = actScopeDepth; + actScopeDepth++; + + if (ReactCurrentActQueue.current === null) { + // This is the outermost `act` scope. Initialize the queue. The reconciler + // will detect the queue and use it instead of Scheduler. + ReactCurrentActQueue.current = []; + } + + var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy; + var result; + + try { + // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only + // set to `true` while the given callback is executed, not for updates + // triggered during an async event, because this is how the legacy + // implementation of `act` behaved. + ReactCurrentActQueue.isBatchingLegacy = true; + result = callback(); // Replicate behavior of original `act` implementation in legacy mode, + // which flushed updates immediately after the scope function exits, even + // if it's an async function. + + if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) { + var queue = ReactCurrentActQueue.current; + + if (queue !== null) { + ReactCurrentActQueue.didScheduleLegacyUpdate = false; + flushActQueue(queue); + } + } + } catch (error) { + popActScope(prevActScopeDepth); + throw error; + } finally { + ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy; + } + + if (result !== null && typeof result === 'object' && typeof result.then === 'function') { + var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait + // for it to resolve before exiting the current scope. + + var wasAwaited = false; + var thenable = { + then: function (resolve, reject) { + wasAwaited = true; + thenableResult.then(function (returnValue) { + popActScope(prevActScopeDepth); + + if (actScopeDepth === 0) { + // We've exited the outermost act scope. Recursively flush the + // queue until there's no remaining work. + recursivelyFlushAsyncActWork(returnValue, resolve, reject); + } else { + resolve(returnValue); + } + }, function (error) { + // The callback threw an error. + popActScope(prevActScopeDepth); + reject(error); + }); + } + }; + + { + if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') { + // eslint-disable-next-line no-undef + Promise.resolve().then(function () {}).then(function () { + if (!wasAwaited) { + didWarnNoAwaitAct = true; + + error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);'); + } + }); + } + } + + return thenable; + } else { + var returnValue = result; // The callback is not an async function. Exit the current scope + // immediately, without awaiting. + + popActScope(prevActScopeDepth); + + if (actScopeDepth === 0) { + // Exiting the outermost act scope. Flush the queue. + var _queue = ReactCurrentActQueue.current; + + if (_queue !== null) { + flushActQueue(_queue); + ReactCurrentActQueue.current = null; + } // Return a thenable. If the user awaits it, we'll flush again in + // case additional work was scheduled by a microtask. + + + var _thenable = { + then: function (resolve, reject) { + // Confirm we haven't re-entered another `act` scope, in case + // the user does something weird like await the thenable + // multiple times. + if (ReactCurrentActQueue.current === null) { + // Recursively flush the queue until there's no remaining work. + ReactCurrentActQueue.current = []; + recursivelyFlushAsyncActWork(returnValue, resolve, reject); + } else { + resolve(returnValue); + } + } + }; + return _thenable; + } else { + // Since we're inside a nested `act` scope, the returned thenable + // immediately resolves. The outer scope will flush the queue. + var _thenable2 = { + then: function (resolve, reject) { + resolve(returnValue); + } + }; + return _thenable2; + } + } + } +} + +function popActScope(prevActScopeDepth) { + { + if (prevActScopeDepth !== actScopeDepth - 1) { + error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. '); + } + + actScopeDepth = prevActScopeDepth; + } +} + +function recursivelyFlushAsyncActWork(returnValue, resolve, reject) { + { + var queue = ReactCurrentActQueue.current; + + if (queue !== null) { + try { + flushActQueue(queue); + enqueueTask(function () { + if (queue.length === 0) { + // No additional work was scheduled. Finish. + ReactCurrentActQueue.current = null; + resolve(returnValue); + } else { + // Keep flushing work until there's none left. + recursivelyFlushAsyncActWork(returnValue, resolve, reject); + } + }); + } catch (error) { + reject(error); + } + } else { + resolve(returnValue); + } + } +} + +var isFlushing = false; + +function flushActQueue(queue) { + { + if (!isFlushing) { + // Prevent re-entrance. + isFlushing = true; + var i = 0; + + try { + for (; i < queue.length; i++) { + var callback = queue[i]; + + do { + callback = callback(true); + } while (callback !== null); + } + + queue.length = 0; + } catch (error) { + // If something throws, leave the remaining callbacks on the queue. + queue = queue.slice(i + 1); + throw error; + } finally { + isFlushing = false; + } + } + } +} + +var createElement$1 = createElementWithValidation ; +var cloneElement$1 = cloneElementWithValidation ; +var createFactory = createFactoryWithValidation ; +var Children = { + map: mapChildren, + forEach: forEachChildren, + count: countChildren, + toArray: toArray, + only: onlyChild +}; + +exports.Children = Children; +exports.Component = Component; +exports.Fragment = REACT_FRAGMENT_TYPE; +exports.Profiler = REACT_PROFILER_TYPE; +exports.PureComponent = PureComponent; +exports.StrictMode = REACT_STRICT_MODE_TYPE; +exports.Suspense = REACT_SUSPENSE_TYPE; +exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals; +exports.act = act; +exports.cloneElement = cloneElement$1; +exports.createContext = createContext; +exports.createElement = createElement$1; +exports.createFactory = createFactory; +exports.createRef = createRef; +exports.forwardRef = forwardRef; +exports.isValidElement = isValidElement; +exports.lazy = lazy; +exports.memo = memo; +exports.startTransition = startTransition; +exports.unstable_act = act; +exports.useCallback = useCallback; +exports.useContext = useContext; +exports.useDebugValue = useDebugValue; +exports.useDeferredValue = useDeferredValue; +exports.useEffect = useEffect; +exports.useId = useId; +exports.useImperativeHandle = useImperativeHandle; +exports.useInsertionEffect = useInsertionEffect; +exports.useLayoutEffect = useLayoutEffect; +exports.useMemo = useMemo; +exports.useReducer = useReducer; +exports.useRef = useRef; +exports.useState = useState; +exports.useSyncExternalStore = useSyncExternalStore; +exports.useTransition = useTransition; +exports.version = ReactVersion; + /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */ +if ( + typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && + typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === + 'function' +) { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error()); +} + + })(); +} diff --git a/node_modules/react/cjs/react.production.min.js b/node_modules/react/cjs/react.production.min.js new file mode 100644 index 0000000..c2b2f77 --- /dev/null +++ b/node_modules/react/cjs/react.production.min.js @@ -0,0 +1,26 @@ +/** + * @license React + * react.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * 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 l=Symbol.for("react.element"),n=Symbol.for("react.portal"),p=Symbol.for("react.fragment"),q=Symbol.for("react.strict_mode"),r=Symbol.for("react.profiler"),t=Symbol.for("react.provider"),u=Symbol.for("react.context"),v=Symbol.for("react.forward_ref"),w=Symbol.for("react.suspense"),x=Symbol.for("react.memo"),y=Symbol.for("react.lazy"),z=Symbol.iterator;function A(a){if(null===a||"object"!==typeof a)return null;a=z&&a[z]||a["@@iterator"];return"function"===typeof a?a:null} +var B={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,D={};function E(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}E.prototype.isReactComponent={}; +E.prototype.setState=function(a,b){if("object"!==typeof a&&"function"!==typeof a&&null!=a)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,a,b,"setState")};E.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate")};function F(){}F.prototype=E.prototype;function G(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}var H=G.prototype=new F; +H.constructor=G;C(H,E.prototype);H.isPureReactComponent=!0;var I=Array.isArray,J=Object.prototype.hasOwnProperty,K={current:null},L={key:!0,ref:!0,__self:!0,__source:!0}; +function M(a,b,e){var d,c={},k=null,h=null;if(null!=b)for(d in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=""+b.key),b)J.call(b,d)&&!L.hasOwnProperty(d)&&(c[d]=b[d]);var g=arguments.length-2;if(1===g)c.children=e;else if(1=0.10.0" + }, + "dependencies": { + "loose-envify": "^1.1.0" + }, + "browserify": { + "transform": [ + "loose-envify" + ] + } +} \ No newline at end of file diff --git a/node_modules/react/react.shared-subset.js b/node_modules/react/react.shared-subset.js new file mode 100644 index 0000000..694e966 --- /dev/null +++ b/node_modules/react/react.shared-subset.js @@ -0,0 +1,7 @@ +'use strict'; + +if (process.env.NODE_ENV === 'production') { + module.exports = require('./cjs/react.shared-subset.production.min.js'); +} else { + module.exports = require('./cjs/react.shared-subset.development.js'); +} diff --git a/node_modules/react/umd/react.development.js b/node_modules/react/umd/react.development.js new file mode 100644 index 0000000..37b38b3 --- /dev/null +++ b/node_modules/react/umd/react.development.js @@ -0,0 +1,3343 @@ +/** + * @license React + * react.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = global || self, factory(global.React = {})); +}(this, (function (exports) { 'use strict'; + + var ReactVersion = '18.3.1'; + + // ATTENTION + // When adding new symbols to this file, + // Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols' + // The Symbol used to tag the ReactElement-like types. + var REACT_ELEMENT_TYPE = Symbol.for('react.element'); + var REACT_PORTAL_TYPE = Symbol.for('react.portal'); + var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment'); + var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode'); + var REACT_PROFILER_TYPE = Symbol.for('react.profiler'); + var REACT_PROVIDER_TYPE = Symbol.for('react.provider'); + var REACT_CONTEXT_TYPE = Symbol.for('react.context'); + var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref'); + var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense'); + var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list'); + var REACT_MEMO_TYPE = Symbol.for('react.memo'); + var REACT_LAZY_TYPE = Symbol.for('react.lazy'); + var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen'); + var MAYBE_ITERATOR_SYMBOL = Symbol.iterator; + var FAUX_ITERATOR_SYMBOL = '@@iterator'; + function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable !== 'object') { + return null; + } + + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + + if (typeof maybeIterator === 'function') { + return maybeIterator; + } + + return null; + } + + /** + * Keeps track of the current dispatcher. + */ + var ReactCurrentDispatcher = { + /** + * @internal + * @type {ReactComponent} + */ + current: null + }; + + /** + * Keeps track of the current batch's configuration such as how long an update + * should suspend for if it needs to. + */ + var ReactCurrentBatchConfig = { + transition: null + }; + + var ReactCurrentActQueue = { + current: null, + // Used to reproduce behavior of `batchedUpdates` in legacy mode. + isBatchingLegacy: false, + didScheduleLegacyUpdate: false + }; + + /** + * Keeps track of the current owner. + * + * The current owner is the component who should own any components that are + * currently being constructed. + */ + var ReactCurrentOwner = { + /** + * @internal + * @type {ReactComponent} + */ + current: null + }; + + var ReactDebugCurrentFrame = {}; + var currentExtraStackFrame = null; + function setExtraStackFrame(stack) { + { + currentExtraStackFrame = stack; + } + } + + { + ReactDebugCurrentFrame.setExtraStackFrame = function (stack) { + { + currentExtraStackFrame = stack; + } + }; // Stack implementation injected by the current renderer. + + + ReactDebugCurrentFrame.getCurrentStack = null; + + ReactDebugCurrentFrame.getStackAddendum = function () { + var stack = ''; // Add an extra top frame while an element is being validated + + if (currentExtraStackFrame) { + stack += currentExtraStackFrame; + } // Delegate to the injected renderer-specific implementation + + + var impl = ReactDebugCurrentFrame.getCurrentStack; + + if (impl) { + stack += impl() || ''; + } + + return stack; + }; + } + + // ----------------------------------------------------------------------------- + + var enableScopeAPI = false; // Experimental Create Event Handle API. + var enableCacheElement = false; + var enableTransitionTracing = false; // No known bugs, but needs performance testing + + var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber + // stuff. Intended to enable React core members to more easily debug scheduling + // issues in DEV builds. + + var enableDebugTracing = false; // Track which Fiber(s) schedule render work. + + var ReactSharedInternals = { + ReactCurrentDispatcher: ReactCurrentDispatcher, + ReactCurrentBatchConfig: ReactCurrentBatchConfig, + ReactCurrentOwner: ReactCurrentOwner + }; + + { + ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame; + ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue; + } + + // by calls to these methods by a Babel plugin. + // + // In PROD (or in packages without access to React internals), + // they are left as they are instead. + + function warn(format) { + { + { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + printWarning('warn', format, args); + } + } + } + function error(format) { + { + { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + + printWarning('error', format, args); + } + } + } + + function printWarning(level, format, args) { + // When changing this logic, you might want to also + // update consoleWithStackDev.www.js as well. + { + var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame.getStackAddendum(); + + if (stack !== '') { + format += '%s'; + args = args.concat([stack]); + } // eslint-disable-next-line react-internal/safe-string-coercion + + + var argsWithFormat = args.map(function (item) { + return String(item); + }); // Careful: RN currently depends on this prefix + + argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it + // breaks IE9: https://github.com/facebook/react/issues/13610 + // eslint-disable-next-line react-internal/no-production-logging + + Function.prototype.apply.call(console[level], console, argsWithFormat); + } + } + + var didWarnStateUpdateForUnmountedComponent = {}; + + function warnNoop(publicInstance, callerName) { + { + var _constructor = publicInstance.constructor; + var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass'; + var warningKey = componentName + "." + callerName; + + if (didWarnStateUpdateForUnmountedComponent[warningKey]) { + return; + } + + error("Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName); + + didWarnStateUpdateForUnmountedComponent[warningKey] = true; + } + } + /** + * This is the abstract API for an update queue. + */ + + + var ReactNoopUpdateQueue = { + /** + * Checks whether or not this composite component is mounted. + * @param {ReactClass} publicInstance The instance we want to test. + * @return {boolean} True if mounted, false otherwise. + * @protected + * @final + */ + isMounted: function (publicInstance) { + return false; + }, + + /** + * Forces an update. This should only be invoked when it is known with + * certainty that we are **not** in a DOM transaction. + * + * You may want to call this when you know that some deeper aspect of the + * component's state has changed but `setState` was not called. + * + * This will not invoke `shouldComponentUpdate`, but it will invoke + * `componentWillUpdate` and `componentDidUpdate`. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ + enqueueForceUpdate: function (publicInstance, callback, callerName) { + warnNoop(publicInstance, 'forceUpdate'); + }, + + /** + * Replaces all of the state. Always use this or `setState` to mutate state. + * You should treat `this.state` as immutable. + * + * There is no guarantee that `this.state` will be immediately updated, so + * accessing `this.state` after calling this method may return the old value. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} completeState Next state. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ + enqueueReplaceState: function (publicInstance, completeState, callback, callerName) { + warnNoop(publicInstance, 'replaceState'); + }, + + /** + * Sets a subset of the state. This only exists because _pendingState is + * internal. This provides a merging strategy that is not available to deep + * properties which is confusing. TODO: Expose pendingState or don't use it + * during the merge. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} partialState Next partial state to be merged with state. + * @param {?function} callback Called after component is updated. + * @param {?string} Name of the calling function in the public API. + * @internal + */ + enqueueSetState: function (publicInstance, partialState, callback, callerName) { + warnNoop(publicInstance, 'setState'); + } + }; + + var assign = Object.assign; + + var emptyObject = {}; + + { + Object.freeze(emptyObject); + } + /** + * Base class helpers for the updating state of a component. + */ + + + function Component(props, context, updater) { + this.props = props; + this.context = context; // If a component has string refs, we will assign a different object later. + + this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the + // renderer. + + this.updater = updater || ReactNoopUpdateQueue; + } + + Component.prototype.isReactComponent = {}; + /** + * Sets a subset of the state. Always use this to mutate + * state. You should treat `this.state` as immutable. + * + * There is no guarantee that `this.state` will be immediately updated, so + * accessing `this.state` after calling this method may return the old value. + * + * There is no guarantee that calls to `setState` will run synchronously, + * as they may eventually be batched together. You can provide an optional + * callback that will be executed when the call to setState is actually + * completed. + * + * When a function is provided to setState, it will be called at some point in + * the future (not synchronously). It will be called with the up to date + * component arguments (state, props, context). These values can be different + * from this.* because your function may be called after receiveProps but before + * shouldComponentUpdate, and this new state, props, and context will not yet be + * assigned to this. + * + * @param {object|function} partialState Next partial state or function to + * produce next partial state to be merged with current state. + * @param {?function} callback Called after state is updated. + * @final + * @protected + */ + + Component.prototype.setState = function (partialState, callback) { + if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) { + throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.'); + } + + this.updater.enqueueSetState(this, partialState, callback, 'setState'); + }; + /** + * Forces an update. This should only be invoked when it is known with + * certainty that we are **not** in a DOM transaction. + * + * You may want to call this when you know that some deeper aspect of the + * component's state has changed but `setState` was not called. + * + * This will not invoke `shouldComponentUpdate`, but it will invoke + * `componentWillUpdate` and `componentDidUpdate`. + * + * @param {?function} callback Called after update is complete. + * @final + * @protected + */ + + + Component.prototype.forceUpdate = function (callback) { + this.updater.enqueueForceUpdate(this, callback, 'forceUpdate'); + }; + /** + * Deprecated APIs. These APIs used to exist on classic React classes but since + * we would like to deprecate them, we're not going to move them over to this + * modern base class. Instead, we define a getter that warns if it's accessed. + */ + + + { + var deprecatedAPIs = { + isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'], + replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).'] + }; + + var defineDeprecationWarning = function (methodName, info) { + Object.defineProperty(Component.prototype, methodName, { + get: function () { + warn('%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]); + + return undefined; + } + }); + }; + + for (var fnName in deprecatedAPIs) { + if (deprecatedAPIs.hasOwnProperty(fnName)) { + defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); + } + } + } + + function ComponentDummy() {} + + ComponentDummy.prototype = Component.prototype; + /** + * Convenience component with default shallow equality check for sCU. + */ + + function PureComponent(props, context, updater) { + this.props = props; + this.context = context; // If a component has string refs, we will assign a different object later. + + this.refs = emptyObject; + this.updater = updater || ReactNoopUpdateQueue; + } + + var pureComponentPrototype = PureComponent.prototype = new ComponentDummy(); + pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods. + + assign(pureComponentPrototype, Component.prototype); + pureComponentPrototype.isPureReactComponent = true; + + // an immutable object with a single mutable value + function createRef() { + var refObject = { + current: null + }; + + { + Object.seal(refObject); + } + + return refObject; + } + + var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare + + function isArray(a) { + return isArrayImpl(a); + } + + /* + * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol + * and Temporal.* types. See https://github.com/facebook/react/pull/22064. + * + * The functions in this module will throw an easier-to-understand, + * easier-to-debug exception with a clear errors message message explaining the + * problem. (Instead of a confusing exception thrown inside the implementation + * of the `value` object). + */ + // $FlowFixMe only called in DEV, so void return is not possible. + function typeName(value) { + { + // toStringTag is needed for namespaced types like Temporal.Instant + var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag; + var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; + return type; + } + } // $FlowFixMe only called in DEV, so void return is not possible. + + + function willCoercionThrow(value) { + { + try { + testStringCoercion(value); + return false; + } catch (e) { + return true; + } + } + } + + function testStringCoercion(value) { + // If you ended up here by following an exception call stack, here's what's + // happened: you supplied an object or symbol value to React (as a prop, key, + // DOM attribute, CSS property, string ref, etc.) and when React tried to + // coerce it to a string using `'' + value`, an exception was thrown. + // + // The most common types that will cause this exception are `Symbol` instances + // and Temporal objects like `Temporal.Instant`. But any object that has a + // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this + // exception. (Library authors do this to prevent users from using built-in + // numeric operators like `+` or comparison operators like `>=` because custom + // methods are needed to perform accurate arithmetic or comparison.) + // + // To fix the problem, coerce this object or symbol value to a string before + // passing it to React. The most reliable way is usually `String(value)`. + // + // To find which value is throwing, check the browser or debugger console. + // Before this exception was thrown, there should be `console.error` output + // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the + // problem and how that type was used: key, atrribute, input value prop, etc. + // In most cases, this console output also shows the component and its + // ancestor components where the exception happened. + // + // eslint-disable-next-line react-internal/safe-string-coercion + return '' + value; + } + function checkKeyStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value)); + + return testStringCoercion(value); // throw (to help callers find troubleshooting comments) + } + } + } + + function getWrappedName(outerType, innerType, wrapperName) { + var displayName = outerType.displayName; + + if (displayName) { + return displayName; + } + + var functionName = innerType.displayName || innerType.name || ''; + return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName; + } // Keep in sync with react-reconciler/getComponentNameFromFiber + + + function getContextName(type) { + return type.displayName || 'Context'; + } // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead. + + + function getComponentNameFromType(type) { + if (type == null) { + // Host root, text node or just invalid type. + return null; + } + + { + if (typeof type.tag === 'number') { + error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.'); + } + } + + if (typeof type === 'function') { + return type.displayName || type.name || null; + } + + if (typeof type === 'string') { + return type; + } + + switch (type) { + case REACT_FRAGMENT_TYPE: + return 'Fragment'; + + case REACT_PORTAL_TYPE: + return 'Portal'; + + case REACT_PROFILER_TYPE: + return 'Profiler'; + + case REACT_STRICT_MODE_TYPE: + return 'StrictMode'; + + case REACT_SUSPENSE_TYPE: + return 'Suspense'; + + case REACT_SUSPENSE_LIST_TYPE: + return 'SuspenseList'; + + } + + if (typeof type === 'object') { + switch (type.$$typeof) { + case REACT_CONTEXT_TYPE: + var context = type; + return getContextName(context) + '.Consumer'; + + case REACT_PROVIDER_TYPE: + var provider = type; + return getContextName(provider._context) + '.Provider'; + + case REACT_FORWARD_REF_TYPE: + return getWrappedName(type, type.render, 'ForwardRef'); + + case REACT_MEMO_TYPE: + var outerName = type.displayName || null; + + if (outerName !== null) { + return outerName; + } + + return getComponentNameFromType(type.type) || 'Memo'; + + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + + try { + return getComponentNameFromType(init(payload)); + } catch (x) { + return null; + } + } + + // eslint-disable-next-line no-fallthrough + } + } + + return null; + } + + var hasOwnProperty = Object.prototype.hasOwnProperty; + + var RESERVED_PROPS = { + key: true, + ref: true, + __self: true, + __source: true + }; + var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs; + + { + didWarnAboutStringRefs = {}; + } + + function hasValidRef(config) { + { + if (hasOwnProperty.call(config, 'ref')) { + var getter = Object.getOwnPropertyDescriptor(config, 'ref').get; + + if (getter && getter.isReactWarning) { + return false; + } + } + } + + return config.ref !== undefined; + } + + function hasValidKey(config) { + { + if (hasOwnProperty.call(config, 'key')) { + var getter = Object.getOwnPropertyDescriptor(config, 'key').get; + + if (getter && getter.isReactWarning) { + return false; + } + } + } + + return config.key !== undefined; + } + + function defineKeyPropWarningGetter(props, displayName) { + var warnAboutAccessingKey = function () { + { + if (!specialPropKeyWarningShown) { + specialPropKeyWarningShown = true; + + error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName); + } + } + }; + + warnAboutAccessingKey.isReactWarning = true; + Object.defineProperty(props, 'key', { + get: warnAboutAccessingKey, + configurable: true + }); + } + + function defineRefPropWarningGetter(props, displayName) { + var warnAboutAccessingRef = function () { + { + if (!specialPropRefWarningShown) { + specialPropRefWarningShown = true; + + error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName); + } + } + }; + + warnAboutAccessingRef.isReactWarning = true; + Object.defineProperty(props, 'ref', { + get: warnAboutAccessingRef, + configurable: true + }); + } + + function warnIfStringRefCannotBeAutoConverted(config) { + { + if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) { + var componentName = getComponentNameFromType(ReactCurrentOwner.current.type); + + if (!didWarnAboutStringRefs[componentName]) { + error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref); + + didWarnAboutStringRefs[componentName] = true; + } + } + } + } + /** + * Factory method to create a new React element. This no longer adheres to + * the class pattern, so do not use new to call it. Also, instanceof check + * will not work. Instead test $$typeof field against Symbol.for('react.element') to check + * if something is a React Element. + * + * @param {*} type + * @param {*} props + * @param {*} key + * @param {string|object} ref + * @param {*} owner + * @param {*} self A *temporary* helper to detect places where `this` is + * different from the `owner` when React.createElement is called, so that we + * can warn. We want to get rid of owner and replace string `ref`s with arrow + * functions, and as long as `this` and owner are the same, there will be no + * change in behavior. + * @param {*} source An annotation object (added by a transpiler or otherwise) + * indicating filename, line number, and/or other information. + * @internal + */ + + + var ReactElement = function (type, key, ref, self, source, owner, props) { + var element = { + // This tag allows us to uniquely identify this as a React Element + $$typeof: REACT_ELEMENT_TYPE, + // Built-in properties that belong on the element + type: type, + key: key, + ref: ref, + props: props, + // Record the component responsible for creating this element. + _owner: owner + }; + + { + // The validation flag is currently mutative. We put it on + // an external backing store so that we can freeze the whole object. + // This can be replaced with a WeakMap once they are implemented in + // commonly used development environments. + element._store = {}; // To make comparing ReactElements easier for testing purposes, we make + // the validation flag non-enumerable (where possible, which should + // include every environment we run tests in), so the test framework + // ignores it. + + Object.defineProperty(element._store, 'validated', { + configurable: false, + enumerable: false, + writable: true, + value: false + }); // self and source are DEV only properties. + + Object.defineProperty(element, '_self', { + configurable: false, + enumerable: false, + writable: false, + value: self + }); // Two elements created in two different places should be considered + // equal for testing purposes and therefore we hide it from enumeration. + + Object.defineProperty(element, '_source', { + configurable: false, + enumerable: false, + writable: false, + value: source + }); + + if (Object.freeze) { + Object.freeze(element.props); + Object.freeze(element); + } + } + + return element; + }; + /** + * Create and return a new ReactElement of the given type. + * See https://reactjs.org/docs/react-api.html#createelement + */ + + function createElement(type, config, children) { + var propName; // Reserved names are extracted + + var props = {}; + var key = null; + var ref = null; + var self = null; + var source = null; + + if (config != null) { + if (hasValidRef(config)) { + ref = config.ref; + + { + warnIfStringRefCannotBeAutoConverted(config); + } + } + + if (hasValidKey(config)) { + { + checkKeyStringCoercion(config.key); + } + + key = '' + config.key; + } + + self = config.__self === undefined ? null : config.__self; + source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object + + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + props[propName] = config[propName]; + } + } + } // Children can be more than one argument, and those are transferred onto + // the newly allocated props object. + + + var childrenLength = arguments.length - 2; + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 2]; + } + + { + if (Object.freeze) { + Object.freeze(childArray); + } + } + + props.children = childArray; + } // Resolve default props + + + if (type && type.defaultProps) { + var defaultProps = type.defaultProps; + + for (propName in defaultProps) { + if (props[propName] === undefined) { + props[propName] = defaultProps[propName]; + } + } + } + + { + if (key || ref) { + var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; + + if (key) { + defineKeyPropWarningGetter(props, displayName); + } + + if (ref) { + defineRefPropWarningGetter(props, displayName); + } + } + } + + return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props); + } + function cloneAndReplaceKey(oldElement, newKey) { + var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props); + return newElement; + } + /** + * Clone and return a new ReactElement using element as the starting point. + * See https://reactjs.org/docs/react-api.html#cloneelement + */ + + function cloneElement(element, config, children) { + if (element === null || element === undefined) { + throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + "."); + } + + var propName; // Original props are copied + + var props = assign({}, element.props); // Reserved names are extracted + + var key = element.key; + var ref = element.ref; // Self is preserved since the owner is preserved. + + var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a + // transpiler, and the original source is probably a better indicator of the + // true owner. + + var source = element._source; // Owner will be preserved, unless ref is overridden + + var owner = element._owner; + + if (config != null) { + if (hasValidRef(config)) { + // Silently steal the ref from the parent. + ref = config.ref; + owner = ReactCurrentOwner.current; + } + + if (hasValidKey(config)) { + { + checkKeyStringCoercion(config.key); + } + + key = '' + config.key; + } // Remaining properties override existing props + + + var defaultProps; + + if (element.type && element.type.defaultProps) { + defaultProps = element.type.defaultProps; + } + + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + if (config[propName] === undefined && defaultProps !== undefined) { + // Resolve default props + props[propName] = defaultProps[propName]; + } else { + props[propName] = config[propName]; + } + } + } + } // Children can be more than one argument, and those are transferred onto + // the newly allocated props object. + + + var childrenLength = arguments.length - 2; + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 2]; + } + + props.children = childArray; + } + + return ReactElement(element.type, key, ref, self, source, owner, props); + } + /** + * Verifies the object is a ReactElement. + * See https://reactjs.org/docs/react-api.html#isvalidelement + * @param {?object} object + * @return {boolean} True if `object` is a ReactElement. + * @final + */ + + function isValidElement(object) { + return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; + } + + var SEPARATOR = '.'; + var SUBSEPARATOR = ':'; + /** + * Escape and wrap key so it is safe to use as a reactid + * + * @param {string} key to be escaped. + * @return {string} the escaped key. + */ + + function escape(key) { + var escapeRegex = /[=:]/g; + var escaperLookup = { + '=': '=0', + ':': '=2' + }; + var escapedString = key.replace(escapeRegex, function (match) { + return escaperLookup[match]; + }); + return '$' + escapedString; + } + /** + * TODO: Test that a single child and an array with one item have the same key + * pattern. + */ + + + var didWarnAboutMaps = false; + var userProvidedKeyEscapeRegex = /\/+/g; + + function escapeUserProvidedKey(text) { + return text.replace(userProvidedKeyEscapeRegex, '$&/'); + } + /** + * Generate a key string that identifies a element within a set. + * + * @param {*} element A element that could contain a manual key. + * @param {number} index Index that is used if a manual key is not provided. + * @return {string} + */ + + + function getElementKey(element, index) { + // Do some typechecking here since we call this blindly. We want to ensure + // that we don't block potential future ES APIs. + if (typeof element === 'object' && element !== null && element.key != null) { + // Explicit key + { + checkKeyStringCoercion(element.key); + } + + return escape('' + element.key); + } // Implicit key determined by the index in the set + + + return index.toString(36); + } + + function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) { + var type = typeof children; + + if (type === 'undefined' || type === 'boolean') { + // All of the above are perceived as null. + children = null; + } + + var invokeCallback = false; + + if (children === null) { + invokeCallback = true; + } else { + switch (type) { + case 'string': + case 'number': + invokeCallback = true; + break; + + case 'object': + switch (children.$$typeof) { + case REACT_ELEMENT_TYPE: + case REACT_PORTAL_TYPE: + invokeCallback = true; + } + + } + } + + if (invokeCallback) { + var _child = children; + var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array + // so that it's consistent if the number of children grows: + + var childKey = nameSoFar === '' ? SEPARATOR + getElementKey(_child, 0) : nameSoFar; + + if (isArray(mappedChild)) { + var escapedChildKey = ''; + + if (childKey != null) { + escapedChildKey = escapeUserProvidedKey(childKey) + '/'; + } + + mapIntoArray(mappedChild, array, escapedChildKey, '', function (c) { + return c; + }); + } else if (mappedChild != null) { + if (isValidElement(mappedChild)) { + { + // The `if` statement here prevents auto-disabling of the safe + // coercion ESLint rule, so we must manually disable it below. + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key + if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) { + checkKeyStringCoercion(mappedChild.key); + } + } + + mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as + // traverseAllChildren used to do for objects as children + escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key + mappedChild.key && (!_child || _child.key !== mappedChild.key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number + // eslint-disable-next-line react-internal/safe-string-coercion + escapeUserProvidedKey('' + mappedChild.key) + '/' : '') + childKey); + } + + array.push(mappedChild); + } + + return 1; + } + + var child; + var nextName; + var subtreeCount = 0; // Count of children found in the current subtree. + + var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR; + + if (isArray(children)) { + for (var i = 0; i < children.length; i++) { + child = children[i]; + nextName = nextNamePrefix + getElementKey(child, i); + subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); + } + } else { + var iteratorFn = getIteratorFn(children); + + if (typeof iteratorFn === 'function') { + var iterableChildren = children; + + { + // Warn about using Maps as children + if (iteratorFn === iterableChildren.entries) { + if (!didWarnAboutMaps) { + warn('Using Maps as children is not supported. ' + 'Use an array of keyed ReactElements instead.'); + } + + didWarnAboutMaps = true; + } + } + + var iterator = iteratorFn.call(iterableChildren); + var step; + var ii = 0; + + while (!(step = iterator.next()).done) { + child = step.value; + nextName = nextNamePrefix + getElementKey(child, ii++); + subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); + } + } else if (type === 'object') { + // eslint-disable-next-line react-internal/safe-string-coercion + var childrenString = String(children); + throw new Error("Objects are not valid as a React child (found: " + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.'); + } + } + + return subtreeCount; + } + + /** + * Maps children that are typically specified as `props.children`. + * + * See https://reactjs.org/docs/react-api.html#reactchildrenmap + * + * The provided mapFunction(child, index) will be called for each + * leaf child. + * + * @param {?*} children Children tree container. + * @param {function(*, int)} func The map function. + * @param {*} context Context for mapFunction. + * @return {object} Object containing the ordered map of results. + */ + function mapChildren(children, func, context) { + if (children == null) { + return children; + } + + var result = []; + var count = 0; + mapIntoArray(children, result, '', '', function (child) { + return func.call(context, child, count++); + }); + return result; + } + /** + * Count the number of children that are typically specified as + * `props.children`. + * + * See https://reactjs.org/docs/react-api.html#reactchildrencount + * + * @param {?*} children Children tree container. + * @return {number} The number of children. + */ + + + function countChildren(children) { + var n = 0; + mapChildren(children, function () { + n++; // Don't return anything + }); + return n; + } + + /** + * Iterates through children that are typically specified as `props.children`. + * + * See https://reactjs.org/docs/react-api.html#reactchildrenforeach + * + * The provided forEachFunc(child, index) will be called for each + * leaf child. + * + * @param {?*} children Children tree container. + * @param {function(*, int)} forEachFunc + * @param {*} forEachContext Context for forEachContext. + */ + function forEachChildren(children, forEachFunc, forEachContext) { + mapChildren(children, function () { + forEachFunc.apply(this, arguments); // Don't return anything. + }, forEachContext); + } + /** + * Flatten a children object (typically specified as `props.children`) and + * return an array with appropriately re-keyed children. + * + * See https://reactjs.org/docs/react-api.html#reactchildrentoarray + */ + + + function toArray(children) { + return mapChildren(children, function (child) { + return child; + }) || []; + } + /** + * Returns the first child in a collection of children and verifies that there + * is only one child in the collection. + * + * See https://reactjs.org/docs/react-api.html#reactchildrenonly + * + * The current implementation of this function assumes that a single child gets + * passed without a wrapper, but the purpose of this helper function is to + * abstract away the particular structure of children. + * + * @param {?object} children Child collection structure. + * @return {ReactElement} The first and only `ReactElement` contained in the + * structure. + */ + + + function onlyChild(children) { + if (!isValidElement(children)) { + throw new Error('React.Children.only expected to receive a single React element child.'); + } + + return children; + } + + function createContext(defaultValue) { + // TODO: Second argument used to be an optional `calculateChangedBits` + // function. Warn to reserve for future use? + var context = { + $$typeof: REACT_CONTEXT_TYPE, + // As a workaround to support multiple concurrent renderers, we categorize + // some renderers as primary and others as secondary. We only expect + // there to be two concurrent renderers at most: React Native (primary) and + // Fabric (secondary); React DOM (primary) and React ART (secondary). + // Secondary renderers store their context values on separate fields. + _currentValue: defaultValue, + _currentValue2: defaultValue, + // Used to track how many concurrent renderers this context currently + // supports within in a single renderer. Such as parallel server rendering. + _threadCount: 0, + // These are circular + Provider: null, + Consumer: null, + // Add these to use same hidden class in VM as ServerContext + _defaultValue: null, + _globalName: null + }; + context.Provider = { + $$typeof: REACT_PROVIDER_TYPE, + _context: context + }; + var hasWarnedAboutUsingNestedContextConsumers = false; + var hasWarnedAboutUsingConsumerProvider = false; + var hasWarnedAboutDisplayNameOnConsumer = false; + + { + // A separate object, but proxies back to the original context object for + // backwards compatibility. It has a different $$typeof, so we can properly + // warn for the incorrect usage of Context as a Consumer. + var Consumer = { + $$typeof: REACT_CONTEXT_TYPE, + _context: context + }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here + + Object.defineProperties(Consumer, { + Provider: { + get: function () { + if (!hasWarnedAboutUsingConsumerProvider) { + hasWarnedAboutUsingConsumerProvider = true; + + error('Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?'); + } + + return context.Provider; + }, + set: function (_Provider) { + context.Provider = _Provider; + } + }, + _currentValue: { + get: function () { + return context._currentValue; + }, + set: function (_currentValue) { + context._currentValue = _currentValue; + } + }, + _currentValue2: { + get: function () { + return context._currentValue2; + }, + set: function (_currentValue2) { + context._currentValue2 = _currentValue2; + } + }, + _threadCount: { + get: function () { + return context._threadCount; + }, + set: function (_threadCount) { + context._threadCount = _threadCount; + } + }, + Consumer: { + get: function () { + if (!hasWarnedAboutUsingNestedContextConsumers) { + hasWarnedAboutUsingNestedContextConsumers = true; + + error('Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?'); + } + + return context.Consumer; + } + }, + displayName: { + get: function () { + return context.displayName; + }, + set: function (displayName) { + if (!hasWarnedAboutDisplayNameOnConsumer) { + warn('Setting `displayName` on Context.Consumer has no effect. ' + "You should set it directly on the context with Context.displayName = '%s'.", displayName); + + hasWarnedAboutDisplayNameOnConsumer = true; + } + } + } + }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty + + context.Consumer = Consumer; + } + + { + context._currentRenderer = null; + context._currentRenderer2 = null; + } + + return context; + } + + var Uninitialized = -1; + var Pending = 0; + var Resolved = 1; + var Rejected = 2; + + function lazyInitializer(payload) { + if (payload._status === Uninitialized) { + var ctor = payload._result; + var thenable = ctor(); // Transition to the next state. + // This might throw either because it's missing or throws. If so, we treat it + // as still uninitialized and try again next time. Which is the same as what + // happens if the ctor or any wrappers processing the ctor throws. This might + // end up fixing it if the resolution was a concurrency bug. + + thenable.then(function (moduleObject) { + if (payload._status === Pending || payload._status === Uninitialized) { + // Transition to the next state. + var resolved = payload; + resolved._status = Resolved; + resolved._result = moduleObject; + } + }, function (error) { + if (payload._status === Pending || payload._status === Uninitialized) { + // Transition to the next state. + var rejected = payload; + rejected._status = Rejected; + rejected._result = error; + } + }); + + if (payload._status === Uninitialized) { + // In case, we're still uninitialized, then we're waiting for the thenable + // to resolve. Set it as pending in the meantime. + var pending = payload; + pending._status = Pending; + pending._result = thenable; + } + } + + if (payload._status === Resolved) { + var moduleObject = payload._result; + + { + if (moduleObject === undefined) { + error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n ' + // Break up imports to avoid accidentally parsing them as dependencies. + 'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))\n\n" + 'Did you accidentally put curly braces around the import?', moduleObject); + } + } + + { + if (!('default' in moduleObject)) { + error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n ' + // Break up imports to avoid accidentally parsing them as dependencies. + 'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))", moduleObject); + } + } + + return moduleObject.default; + } else { + throw payload._result; + } + } + + function lazy(ctor) { + var payload = { + // We use these fields to store the result. + _status: Uninitialized, + _result: ctor + }; + var lazyType = { + $$typeof: REACT_LAZY_TYPE, + _payload: payload, + _init: lazyInitializer + }; + + { + // In production, this would just set it on the object. + var defaultProps; + var propTypes; // $FlowFixMe + + Object.defineProperties(lazyType, { + defaultProps: { + configurable: true, + get: function () { + return defaultProps; + }, + set: function (newDefaultProps) { + error('React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.'); + + defaultProps = newDefaultProps; // Match production behavior more closely: + // $FlowFixMe + + Object.defineProperty(lazyType, 'defaultProps', { + enumerable: true + }); + } + }, + propTypes: { + configurable: true, + get: function () { + return propTypes; + }, + set: function (newPropTypes) { + error('React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.'); + + propTypes = newPropTypes; // Match production behavior more closely: + // $FlowFixMe + + Object.defineProperty(lazyType, 'propTypes', { + enumerable: true + }); + } + } + }); + } + + return lazyType; + } + + function forwardRef(render) { + { + if (render != null && render.$$typeof === REACT_MEMO_TYPE) { + error('forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).'); + } else if (typeof render !== 'function') { + error('forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render); + } else { + if (render.length !== 0 && render.length !== 2) { + error('forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.'); + } + } + + if (render != null) { + if (render.defaultProps != null || render.propTypes != null) { + error('forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?'); + } + } + } + + var elementType = { + $$typeof: REACT_FORWARD_REF_TYPE, + render: render + }; + + { + var ownName; + Object.defineProperty(elementType, 'displayName', { + enumerable: false, + configurable: true, + get: function () { + return ownName; + }, + set: function (name) { + ownName = name; // The inner component shouldn't inherit this display name in most cases, + // because the component may be used elsewhere. + // But it's nice for anonymous functions to inherit the name, + // so that our component-stack generation logic will display their frames. + // An anonymous function generally suggests a pattern like: + // React.forwardRef((props, ref) => {...}); + // This kind of inner function is not used elsewhere so the side effect is okay. + + if (!render.name && !render.displayName) { + render.displayName = name; + } + } + }); + } + + return elementType; + } + + var REACT_MODULE_REFERENCE; + + { + REACT_MODULE_REFERENCE = Symbol.for('react.module.reference'); + } + + function isValidElementType(type) { + if (typeof type === 'string' || typeof type === 'function') { + return true; + } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill). + + + if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing ) { + return true; + } + + if (typeof type === 'object' && type !== null) { + if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object + // types supported by any Flight configuration anywhere since + // we don't know which Flight build this will end up being used + // with. + type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) { + return true; + } + } + + return false; + } + + function memo(type, compare) { + { + if (!isValidElementType(type)) { + error('memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type); + } + } + + var elementType = { + $$typeof: REACT_MEMO_TYPE, + type: type, + compare: compare === undefined ? null : compare + }; + + { + var ownName; + Object.defineProperty(elementType, 'displayName', { + enumerable: false, + configurable: true, + get: function () { + return ownName; + }, + set: function (name) { + ownName = name; // The inner component shouldn't inherit this display name in most cases, + // because the component may be used elsewhere. + // But it's nice for anonymous functions to inherit the name, + // so that our component-stack generation logic will display their frames. + // An anonymous function generally suggests a pattern like: + // React.memo((props) => {...}); + // This kind of inner function is not used elsewhere so the side effect is okay. + + if (!type.name && !type.displayName) { + type.displayName = name; + } + } + }); + } + + return elementType; + } + + function resolveDispatcher() { + var dispatcher = ReactCurrentDispatcher.current; + + { + if (dispatcher === null) { + error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.'); + } + } // Will result in a null access error if accessed outside render phase. We + // intentionally don't throw our own error because this is in a hot path. + // Also helps ensure this is inlined. + + + return dispatcher; + } + function useContext(Context) { + var dispatcher = resolveDispatcher(); + + { + // TODO: add a more generic warning for invalid values. + if (Context._context !== undefined) { + var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs + // and nobody should be using this in existing code. + + if (realContext.Consumer === Context) { + error('Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?'); + } else if (realContext.Provider === Context) { + error('Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?'); + } + } + } + + return dispatcher.useContext(Context); + } + function useState(initialState) { + var dispatcher = resolveDispatcher(); + return dispatcher.useState(initialState); + } + function useReducer(reducer, initialArg, init) { + var dispatcher = resolveDispatcher(); + return dispatcher.useReducer(reducer, initialArg, init); + } + function useRef(initialValue) { + var dispatcher = resolveDispatcher(); + return dispatcher.useRef(initialValue); + } + function useEffect(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useEffect(create, deps); + } + function useInsertionEffect(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useInsertionEffect(create, deps); + } + function useLayoutEffect(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useLayoutEffect(create, deps); + } + function useCallback(callback, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useCallback(callback, deps); + } + function useMemo(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useMemo(create, deps); + } + function useImperativeHandle(ref, create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useImperativeHandle(ref, create, deps); + } + function useDebugValue(value, formatterFn) { + { + var dispatcher = resolveDispatcher(); + return dispatcher.useDebugValue(value, formatterFn); + } + } + function useTransition() { + var dispatcher = resolveDispatcher(); + return dispatcher.useTransition(); + } + function useDeferredValue(value) { + var dispatcher = resolveDispatcher(); + return dispatcher.useDeferredValue(value); + } + function useId() { + var dispatcher = resolveDispatcher(); + return dispatcher.useId(); + } + function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) { + var dispatcher = resolveDispatcher(); + return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot); + } + + // Helpers to patch console.logs to avoid logging during side-effect free + // replaying on render function. This currently only patches the object + // lazily which won't cover if the log function was extracted eagerly. + // We could also eagerly patch the method. + var disabledDepth = 0; + var prevLog; + var prevInfo; + var prevWarn; + var prevError; + var prevGroup; + var prevGroupCollapsed; + var prevGroupEnd; + + function disabledLog() {} + + disabledLog.__reactDisabledLog = true; + function disableLogs() { + { + if (disabledDepth === 0) { + /* eslint-disable react-internal/no-production-logging */ + prevLog = console.log; + prevInfo = console.info; + prevWarn = console.warn; + prevError = console.error; + prevGroup = console.group; + prevGroupCollapsed = console.groupCollapsed; + prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099 + + var props = { + configurable: true, + enumerable: true, + value: disabledLog, + writable: true + }; // $FlowFixMe Flow thinks console is immutable. + + Object.defineProperties(console, { + info: props, + log: props, + warn: props, + error: props, + group: props, + groupCollapsed: props, + groupEnd: props + }); + /* eslint-enable react-internal/no-production-logging */ + } + + disabledDepth++; + } + } + function reenableLogs() { + { + disabledDepth--; + + if (disabledDepth === 0) { + /* eslint-disable react-internal/no-production-logging */ + var props = { + configurable: true, + enumerable: true, + writable: true + }; // $FlowFixMe Flow thinks console is immutable. + + Object.defineProperties(console, { + log: assign({}, props, { + value: prevLog + }), + info: assign({}, props, { + value: prevInfo + }), + warn: assign({}, props, { + value: prevWarn + }), + error: assign({}, props, { + value: prevError + }), + group: assign({}, props, { + value: prevGroup + }), + groupCollapsed: assign({}, props, { + value: prevGroupCollapsed + }), + groupEnd: assign({}, props, { + value: prevGroupEnd + }) + }); + /* eslint-enable react-internal/no-production-logging */ + } + + if (disabledDepth < 0) { + error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.'); + } + } + } + + var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher; + var prefix; + function describeBuiltInComponentFrame(name, source, ownerFn) { + { + if (prefix === undefined) { + // Extract the VM specific prefix used by each line. + try { + throw Error(); + } catch (x) { + var match = x.stack.trim().match(/\n( *(at )?)/); + prefix = match && match[1] || ''; + } + } // We use the prefix to ensure our stacks line up with native stack frames. + + + return '\n' + prefix + name; + } + } + var reentry = false; + var componentFrameCache; + + { + var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; + componentFrameCache = new PossiblyWeakMap(); + } + + function describeNativeComponentFrame(fn, construct) { + // If something asked for a stack inside a fake render, it should get ignored. + if ( !fn || reentry) { + return ''; + } + + { + var frame = componentFrameCache.get(fn); + + if (frame !== undefined) { + return frame; + } + } + + var control; + reentry = true; + var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined. + + Error.prepareStackTrace = undefined; + var previousDispatcher; + + { + previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function + // for warnings. + + ReactCurrentDispatcher$1.current = null; + disableLogs(); + } + + try { + // This should throw. + if (construct) { + // Something should be setting the props in the constructor. + var Fake = function () { + throw Error(); + }; // $FlowFixMe + + + Object.defineProperty(Fake.prototype, 'props', { + set: function () { + // We use a throwing setter instead of frozen or non-writable props + // because that won't throw in a non-strict mode function. + throw Error(); + } + }); + + if (typeof Reflect === 'object' && Reflect.construct) { + // We construct a different control for this case to include any extra + // frames added by the construct call. + try { + Reflect.construct(Fake, []); + } catch (x) { + control = x; + } + + Reflect.construct(fn, [], Fake); + } else { + try { + Fake.call(); + } catch (x) { + control = x; + } + + fn.call(Fake.prototype); + } + } else { + try { + throw Error(); + } catch (x) { + control = x; + } + + fn(); + } + } catch (sample) { + // This is inlined manually because closure doesn't do it for us. + if (sample && control && typeof sample.stack === 'string') { + // This extracts the first frame from the sample that isn't also in the control. + // Skipping one frame that we assume is the frame that calls the two. + var sampleLines = sample.stack.split('\n'); + var controlLines = control.stack.split('\n'); + var s = sampleLines.length - 1; + var c = controlLines.length - 1; + + while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) { + // We expect at least one stack frame to be shared. + // Typically this will be the root most one. However, stack frames may be + // cut off due to maximum stack limits. In this case, one maybe cut off + // earlier than the other. We assume that the sample is longer or the same + // and there for cut off earlier. So we should find the root most frame in + // the sample somewhere in the control. + c--; + } + + for (; s >= 1 && c >= 0; s--, c--) { + // Next we find the first one that isn't the same which should be the + // frame that called our sample function and the control. + if (sampleLines[s] !== controlLines[c]) { + // In V8, the first line is describing the message but other VMs don't. + // If we're about to return the first line, and the control is also on the same + // line, that's a pretty good indicator that our sample threw at same line as + // the control. I.e. before we entered the sample frame. So we ignore this result. + // This can happen if you passed a class to function component, or non-function. + if (s !== 1 || c !== 1) { + do { + s--; + c--; // We may still have similar intermediate frames from the construct call. + // The next one that isn't the same should be our match though. + + if (c < 0 || sampleLines[s] !== controlLines[c]) { + // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier. + var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "" + // but we have a user-provided "displayName" + // splice it in to make the stack more readable. + + + if (fn.displayName && _frame.includes('')) { + _frame = _frame.replace('', fn.displayName); + } + + { + if (typeof fn === 'function') { + componentFrameCache.set(fn, _frame); + } + } // Return the line we found. + + + return _frame; + } + } while (s >= 1 && c >= 0); + } + + break; + } + } + } + } finally { + reentry = false; + + { + ReactCurrentDispatcher$1.current = previousDispatcher; + reenableLogs(); + } + + Error.prepareStackTrace = previousPrepareStackTrace; + } // Fallback to just using the name if we couldn't make it throw. + + + var name = fn ? fn.displayName || fn.name : ''; + var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ''; + + { + if (typeof fn === 'function') { + componentFrameCache.set(fn, syntheticFrame); + } + } + + return syntheticFrame; + } + function describeFunctionComponentFrame(fn, source, ownerFn) { + { + return describeNativeComponentFrame(fn, false); + } + } + + function shouldConstruct(Component) { + var prototype = Component.prototype; + return !!(prototype && prototype.isReactComponent); + } + + function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { + + if (type == null) { + return ''; + } + + if (typeof type === 'function') { + { + return describeNativeComponentFrame(type, shouldConstruct(type)); + } + } + + if (typeof type === 'string') { + return describeBuiltInComponentFrame(type); + } + + switch (type) { + case REACT_SUSPENSE_TYPE: + return describeBuiltInComponentFrame('Suspense'); + + case REACT_SUSPENSE_LIST_TYPE: + return describeBuiltInComponentFrame('SuspenseList'); + } + + if (typeof type === 'object') { + switch (type.$$typeof) { + case REACT_FORWARD_REF_TYPE: + return describeFunctionComponentFrame(type.render); + + case REACT_MEMO_TYPE: + // Memo may contain any component type so we recursively resolve it. + return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn); + + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + + try { + // Lazy may contain any component type so we recursively resolve it. + return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn); + } catch (x) {} + } + } + } + + return ''; + } + + var loggedTypeFailures = {}; + var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame; + + function setCurrentlyValidatingElement(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + ReactDebugCurrentFrame$1.setExtraStackFrame(stack); + } else { + ReactDebugCurrentFrame$1.setExtraStackFrame(null); + } + } + } + + function checkPropTypes(typeSpecs, values, location, componentName, element) { + { + // $FlowFixMe This is okay but Flow doesn't know it. + var has = Function.call.bind(hasOwnProperty); + + for (var typeSpecName in typeSpecs) { + if (has(typeSpecs, typeSpecName)) { + var error$1 = void 0; // 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. + if (typeof typeSpecs[typeSpecName] !== 'function') { + // eslint-disable-next-line react-internal/prod-error-codes + var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'); + err.name = 'Invariant Violation'; + throw err; + } + + error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'); + } catch (ex) { + error$1 = ex; + } + + if (error$1 && !(error$1 instanceof Error)) { + setCurrentlyValidatingElement(element); + + 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$1); + + setCurrentlyValidatingElement(null); + } + + if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) { + // Only monitor this failure once because there tends to be a lot of the + // same error. + loggedTypeFailures[error$1.message] = true; + setCurrentlyValidatingElement(element); + + error('Failed %s type: %s', location, error$1.message); + + setCurrentlyValidatingElement(null); + } + } + } + } + } + + function setCurrentlyValidatingElement$1(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + setExtraStackFrame(stack); + } else { + setExtraStackFrame(null); + } + } + } + + var propTypesMisspellWarningShown; + + { + propTypesMisspellWarningShown = false; + } + + function getDeclarationErrorAddendum() { + if (ReactCurrentOwner.current) { + var name = getComponentNameFromType(ReactCurrentOwner.current.type); + + if (name) { + return '\n\nCheck the render method of `' + name + '`.'; + } + } + + return ''; + } + + function getSourceInfoErrorAddendum(source) { + if (source !== undefined) { + var fileName = source.fileName.replace(/^.*[\\\/]/, ''); + var lineNumber = source.lineNumber; + return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.'; + } + + return ''; + } + + function getSourceInfoErrorAddendumForProps(elementProps) { + if (elementProps !== null && elementProps !== undefined) { + return getSourceInfoErrorAddendum(elementProps.__source); + } + + return ''; + } + /** + * Warn if there's no key explicitly set on dynamic arrays of children or + * object keys are not valid. This allows us to keep track of children between + * updates. + */ + + + var ownerHasKeyUseWarning = {}; + + function getCurrentComponentErrorInfo(parentType) { + var info = getDeclarationErrorAddendum(); + + if (!info) { + var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name; + + if (parentName) { + info = "\n\nCheck the top-level render call using <" + parentName + ">."; + } + } + + return info; + } + /** + * Warn if the element doesn't have an explicit key assigned to it. + * This element is in an array. The array could grow and shrink or be + * reordered. All children that haven't already been validated are required to + * have a "key" property assigned to it. Error statuses are cached so a warning + * will only be shown once. + * + * @internal + * @param {ReactElement} element Element that requires a key. + * @param {*} parentType element's parent's type. + */ + + + function validateExplicitKey(element, parentType) { + if (!element._store || element._store.validated || element.key != null) { + return; + } + + element._store.validated = true; + var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); + + if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { + return; + } + + ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a + // property, it may be the creator of the child that's responsible for + // assigning it a key. + + var childOwner = ''; + + if (element && element._owner && element._owner !== ReactCurrentOwner.current) { + // Give the component that originally created this child. + childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + "."; + } + + { + setCurrentlyValidatingElement$1(element); + + error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner); + + setCurrentlyValidatingElement$1(null); + } + } + /** + * Ensure that every element either is passed in a static location, in an + * array with an explicit keys property defined, or in an object literal + * with valid key property. + * + * @internal + * @param {ReactNode} node Statically passed child of any type. + * @param {*} parentType node's parent's type. + */ + + + function validateChildKeys(node, parentType) { + if (typeof node !== 'object') { + return; + } + + if (isArray(node)) { + for (var i = 0; i < node.length; i++) { + var child = node[i]; + + if (isValidElement(child)) { + validateExplicitKey(child, parentType); + } + } + } else if (isValidElement(node)) { + // This element was passed in a valid location. + if (node._store) { + node._store.validated = true; + } + } else if (node) { + var iteratorFn = getIteratorFn(node); + + if (typeof iteratorFn === 'function') { + // Entry iterators used to provide implicit keys, + // but now we print a separate warning for them later. + if (iteratorFn !== node.entries) { + var iterator = iteratorFn.call(node); + var step; + + while (!(step = iterator.next()).done) { + if (isValidElement(step.value)) { + validateExplicitKey(step.value, parentType); + } + } + } + } + } + } + /** + * Given an element, validate that its props follow the propTypes definition, + * provided by the type. + * + * @param {ReactElement} element + */ + + + function validatePropTypes(element) { + { + var type = element.type; + + if (type === null || type === undefined || typeof type === 'string') { + return; + } + + var propTypes; + + if (typeof type === 'function') { + propTypes = type.propTypes; + } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here. + // Inner props are checked in the reconciler. + type.$$typeof === REACT_MEMO_TYPE)) { + propTypes = type.propTypes; + } else { + return; + } + + if (propTypes) { + // Intentionally inside to avoid triggering lazy initializers: + var name = getComponentNameFromType(type); + checkPropTypes(propTypes, element.props, 'prop', name, element); + } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) { + propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers: + + var _name = getComponentNameFromType(type); + + error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown'); + } + + if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) { + error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.'); + } + } + } + /** + * Given a fragment, validate that it can only be provided with fragment props + * @param {ReactElement} fragment + */ + + + function validateFragmentProps(fragment) { + { + var keys = Object.keys(fragment.props); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + + if (key !== 'children' && key !== 'key') { + setCurrentlyValidatingElement$1(fragment); + + error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key); + + setCurrentlyValidatingElement$1(null); + break; + } + } + + if (fragment.ref !== null) { + setCurrentlyValidatingElement$1(fragment); + + error('Invalid attribute `ref` supplied to `React.Fragment`.'); + + setCurrentlyValidatingElement$1(null); + } + } + } + function createElementWithValidation(type, props, children) { + var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to + // succeed and there will likely be errors in render. + + if (!validType) { + var info = ''; + + if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) { + info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports."; + } + + var sourceInfo = getSourceInfoErrorAddendumForProps(props); + + if (sourceInfo) { + info += sourceInfo; + } else { + info += getDeclarationErrorAddendum(); + } + + var typeString; + + if (type === null) { + typeString = 'null'; + } else if (isArray(type)) { + typeString = 'array'; + } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) { + typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />"; + info = ' Did you accidentally export a JSX literal instead of a component?'; + } else { + typeString = typeof type; + } + + { + error('React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info); + } + } + + var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used. + // TODO: Drop this when these are no longer allowed as the type argument. + + if (element == null) { + return element; + } // Skip key warning if the type isn't valid since our key validation logic + // doesn't expect a non-string/function type and can throw confusing errors. + // We don't want exception behavior to differ between dev and prod. + // (Rendering will throw with a helpful message and as soon as the type is + // fixed, the key warnings will appear.) + + + if (validType) { + for (var i = 2; i < arguments.length; i++) { + validateChildKeys(arguments[i], type); + } + } + + if (type === REACT_FRAGMENT_TYPE) { + validateFragmentProps(element); + } else { + validatePropTypes(element); + } + + return element; + } + var didWarnAboutDeprecatedCreateFactory = false; + function createFactoryWithValidation(type) { + var validatedFactory = createElementWithValidation.bind(null, type); + validatedFactory.type = type; + + { + if (!didWarnAboutDeprecatedCreateFactory) { + didWarnAboutDeprecatedCreateFactory = true; + + warn('React.createFactory() is deprecated and will be removed in ' + 'a future major release. Consider using JSX ' + 'or use React.createElement() directly instead.'); + } // Legacy hook: remove it + + + Object.defineProperty(validatedFactory, 'type', { + enumerable: false, + get: function () { + warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.'); + + Object.defineProperty(this, 'type', { + value: type + }); + return type; + } + }); + } + + return validatedFactory; + } + function cloneElementWithValidation(element, props, children) { + var newElement = cloneElement.apply(this, arguments); + + for (var i = 2; i < arguments.length; i++) { + validateChildKeys(arguments[i], newElement.type); + } + + validatePropTypes(newElement); + return newElement; + } + + var enableSchedulerDebugging = false; + var enableProfiling = false; + var frameYieldMs = 5; + + function push(heap, node) { + var index = heap.length; + heap.push(node); + siftUp(heap, node, index); + } + function peek(heap) { + return heap.length === 0 ? null : heap[0]; + } + function pop(heap) { + if (heap.length === 0) { + return null; + } + + var first = heap[0]; + var last = heap.pop(); + + if (last !== first) { + heap[0] = last; + siftDown(heap, last, 0); + } + + return first; + } + + function siftUp(heap, node, i) { + var index = i; + + while (index > 0) { + var parentIndex = index - 1 >>> 1; + var parent = heap[parentIndex]; + + if (compare(parent, node) > 0) { + // The parent is larger. Swap positions. + heap[parentIndex] = node; + heap[index] = parent; + index = parentIndex; + } else { + // The parent is smaller. Exit. + return; + } + } + } + + function siftDown(heap, node, i) { + var index = i; + var length = heap.length; + var halfLength = length >>> 1; + + while (index < halfLength) { + var leftIndex = (index + 1) * 2 - 1; + var left = heap[leftIndex]; + var rightIndex = leftIndex + 1; + var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those. + + if (compare(left, node) < 0) { + if (rightIndex < length && compare(right, left) < 0) { + heap[index] = right; + heap[rightIndex] = node; + index = rightIndex; + } else { + heap[index] = left; + heap[leftIndex] = node; + index = leftIndex; + } + } else if (rightIndex < length && compare(right, node) < 0) { + heap[index] = right; + heap[rightIndex] = node; + index = rightIndex; + } else { + // Neither child is smaller. Exit. + return; + } + } + } + + function compare(a, b) { + // Compare sort index first, then task id. + var diff = a.sortIndex - b.sortIndex; + return diff !== 0 ? diff : a.id - b.id; + } + + // TODO: Use symbols? + var ImmediatePriority = 1; + var UserBlockingPriority = 2; + var NormalPriority = 3; + var LowPriority = 4; + var IdlePriority = 5; + + function markTaskErrored(task, ms) { + } + + /* eslint-disable no-var */ + var getCurrentTime; + var hasPerformanceNow = typeof performance === 'object' && typeof performance.now === 'function'; + + if (hasPerformanceNow) { + var localPerformance = performance; + + getCurrentTime = function () { + return localPerformance.now(); + }; + } else { + var localDate = Date; + var initialTime = localDate.now(); + + getCurrentTime = function () { + return localDate.now() - initialTime; + }; + } // Max 31 bit integer. The max integer size in V8 for 32-bit systems. + // Math.pow(2, 30) - 1 + // 0b111111111111111111111111111111 + + + var maxSigned31BitInt = 1073741823; // Times out immediately + + var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out + + var USER_BLOCKING_PRIORITY_TIMEOUT = 250; + var NORMAL_PRIORITY_TIMEOUT = 5000; + var LOW_PRIORITY_TIMEOUT = 10000; // Never times out + + var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap + + var taskQueue = []; + var timerQueue = []; // Incrementing id counter. Used to maintain insertion order. + + var taskIdCounter = 1; // Pausing the scheduler is useful for debugging. + var currentTask = null; + var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance. + + var isPerformingWork = false; + var isHostCallbackScheduled = false; + var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them. + + var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null; + var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null; + var localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom + + var isInputPending = typeof navigator !== 'undefined' && navigator.scheduling !== undefined && navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null; + + function advanceTimers(currentTime) { + // Check for tasks that are no longer delayed and add them to the queue. + var timer = peek(timerQueue); + + while (timer !== null) { + if (timer.callback === null) { + // Timer was cancelled. + pop(timerQueue); + } else if (timer.startTime <= currentTime) { + // Timer fired. Transfer to the task queue. + pop(timerQueue); + timer.sortIndex = timer.expirationTime; + push(taskQueue, timer); + } else { + // Remaining timers are pending. + return; + } + + timer = peek(timerQueue); + } + } + + function handleTimeout(currentTime) { + isHostTimeoutScheduled = false; + advanceTimers(currentTime); + + if (!isHostCallbackScheduled) { + if (peek(taskQueue) !== null) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } else { + var firstTimer = peek(timerQueue); + + if (firstTimer !== null) { + requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); + } + } + } + } + + function flushWork(hasTimeRemaining, initialTime) { + + + isHostCallbackScheduled = false; + + if (isHostTimeoutScheduled) { + // We scheduled a timeout but it's no longer needed. Cancel it. + isHostTimeoutScheduled = false; + cancelHostTimeout(); + } + + isPerformingWork = true; + var previousPriorityLevel = currentPriorityLevel; + + try { + if (enableProfiling) { + try { + return workLoop(hasTimeRemaining, initialTime); + } catch (error) { + if (currentTask !== null) { + var currentTime = getCurrentTime(); + markTaskErrored(currentTask, currentTime); + currentTask.isQueued = false; + } + + throw error; + } + } else { + // No catch in prod code path. + return workLoop(hasTimeRemaining, initialTime); + } + } finally { + currentTask = null; + currentPriorityLevel = previousPriorityLevel; + isPerformingWork = false; + } + } + + function workLoop(hasTimeRemaining, initialTime) { + var currentTime = initialTime; + advanceTimers(currentTime); + currentTask = peek(taskQueue); + + while (currentTask !== null && !(enableSchedulerDebugging )) { + if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) { + // This currentTask hasn't expired, and we've reached the deadline. + break; + } + + var callback = currentTask.callback; + + if (typeof callback === 'function') { + currentTask.callback = null; + currentPriorityLevel = currentTask.priorityLevel; + var didUserCallbackTimeout = currentTask.expirationTime <= currentTime; + + var continuationCallback = callback(didUserCallbackTimeout); + currentTime = getCurrentTime(); + + if (typeof continuationCallback === 'function') { + currentTask.callback = continuationCallback; + } else { + + if (currentTask === peek(taskQueue)) { + pop(taskQueue); + } + } + + advanceTimers(currentTime); + } else { + pop(taskQueue); + } + + currentTask = peek(taskQueue); + } // Return whether there's additional work + + + if (currentTask !== null) { + return true; + } else { + var firstTimer = peek(timerQueue); + + if (firstTimer !== null) { + requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); + } + + return false; + } + } + + function unstable_runWithPriority(priorityLevel, eventHandler) { + switch (priorityLevel) { + case ImmediatePriority: + case UserBlockingPriority: + case NormalPriority: + case LowPriority: + case IdlePriority: + break; + + default: + priorityLevel = NormalPriority; + } + + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = priorityLevel; + + try { + return eventHandler(); + } finally { + currentPriorityLevel = previousPriorityLevel; + } + } + + function unstable_next(eventHandler) { + var priorityLevel; + + switch (currentPriorityLevel) { + case ImmediatePriority: + case UserBlockingPriority: + case NormalPriority: + // Shift down to normal priority + priorityLevel = NormalPriority; + break; + + default: + // Anything lower than normal priority should remain at the current level. + priorityLevel = currentPriorityLevel; + break; + } + + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = priorityLevel; + + try { + return eventHandler(); + } finally { + currentPriorityLevel = previousPriorityLevel; + } + } + + function unstable_wrapCallback(callback) { + var parentPriorityLevel = currentPriorityLevel; + return function () { + // This is a fork of runWithPriority, inlined for performance. + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = parentPriorityLevel; + + try { + return callback.apply(this, arguments); + } finally { + currentPriorityLevel = previousPriorityLevel; + } + }; + } + + function unstable_scheduleCallback(priorityLevel, callback, options) { + var currentTime = getCurrentTime(); + var startTime; + + if (typeof options === 'object' && options !== null) { + var delay = options.delay; + + if (typeof delay === 'number' && delay > 0) { + startTime = currentTime + delay; + } else { + startTime = currentTime; + } + } else { + startTime = currentTime; + } + + var timeout; + + switch (priorityLevel) { + case ImmediatePriority: + timeout = IMMEDIATE_PRIORITY_TIMEOUT; + break; + + case UserBlockingPriority: + timeout = USER_BLOCKING_PRIORITY_TIMEOUT; + break; + + case IdlePriority: + timeout = IDLE_PRIORITY_TIMEOUT; + break; + + case LowPriority: + timeout = LOW_PRIORITY_TIMEOUT; + break; + + case NormalPriority: + default: + timeout = NORMAL_PRIORITY_TIMEOUT; + break; + } + + var expirationTime = startTime + timeout; + var newTask = { + id: taskIdCounter++, + callback: callback, + priorityLevel: priorityLevel, + startTime: startTime, + expirationTime: expirationTime, + sortIndex: -1 + }; + + if (startTime > currentTime) { + // This is a delayed task. + newTask.sortIndex = startTime; + push(timerQueue, newTask); + + if (peek(taskQueue) === null && newTask === peek(timerQueue)) { + // All tasks are delayed, and this is the task with the earliest delay. + if (isHostTimeoutScheduled) { + // Cancel an existing timeout. + cancelHostTimeout(); + } else { + isHostTimeoutScheduled = true; + } // Schedule a timeout. + + + requestHostTimeout(handleTimeout, startTime - currentTime); + } + } else { + newTask.sortIndex = expirationTime; + push(taskQueue, newTask); + // wait until the next time we yield. + + + if (!isHostCallbackScheduled && !isPerformingWork) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } + } + + return newTask; + } + + function unstable_pauseExecution() { + } + + function unstable_continueExecution() { + + if (!isHostCallbackScheduled && !isPerformingWork) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } + } + + function unstable_getFirstCallbackNode() { + return peek(taskQueue); + } + + function unstable_cancelCallback(task) { + // remove from the queue because you can't remove arbitrary nodes from an + // array based heap, only the first one.) + + + task.callback = null; + } + + function unstable_getCurrentPriorityLevel() { + return currentPriorityLevel; + } + + var isMessageLoopRunning = false; + var scheduledHostCallback = null; + var taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main + // thread, like user events. By default, it yields multiple times per frame. + // It does not attempt to align with frame boundaries, since most tasks don't + // need to be frame aligned; for those that do, use requestAnimationFrame. + + var frameInterval = frameYieldMs; + var startTime = -1; + + function shouldYieldToHost() { + var timeElapsed = getCurrentTime() - startTime; + + if (timeElapsed < frameInterval) { + // The main thread has only been blocked for a really short amount of time; + // smaller than a single frame. Don't yield yet. + return false; + } // The main thread has been blocked for a non-negligible amount of time. We + + + return true; + } + + function requestPaint() { + + } + + function forceFrameRate(fps) { + if (fps < 0 || fps > 125) { + // Using console['error'] to evade Babel and ESLint + console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported'); + return; + } + + if (fps > 0) { + frameInterval = Math.floor(1000 / fps); + } else { + // reset the framerate + frameInterval = frameYieldMs; + } + } + + var performWorkUntilDeadline = function () { + if (scheduledHostCallback !== null) { + var currentTime = getCurrentTime(); // Keep track of the start time so we can measure how long the main thread + // has been blocked. + + startTime = currentTime; + var hasTimeRemaining = true; // If a scheduler task throws, exit the current browser task so the + // error can be observed. + // + // Intentionally not using a try-catch, since that makes some debugging + // techniques harder. Instead, if `scheduledHostCallback` errors, then + // `hasMoreWork` will remain true, and we'll continue the work loop. + + var hasMoreWork = true; + + try { + hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime); + } finally { + if (hasMoreWork) { + // If there's more work, schedule the next message event at the end + // of the preceding one. + schedulePerformWorkUntilDeadline(); + } else { + isMessageLoopRunning = false; + scheduledHostCallback = null; + } + } + } else { + isMessageLoopRunning = false; + } // Yielding to the browser will give it a chance to paint, so we can + }; + + var schedulePerformWorkUntilDeadline; + + if (typeof localSetImmediate === 'function') { + // Node.js and old IE. + // There's a few reasons for why we prefer setImmediate. + // + // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting. + // (Even though this is a DOM fork of the Scheduler, you could get here + // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.) + // https://github.com/facebook/react/issues/20756 + // + // But also, it runs earlier which is the semantic we want. + // If other browsers ever implement it, it's better to use it. + // Although both of these would be inferior to native scheduling. + schedulePerformWorkUntilDeadline = function () { + localSetImmediate(performWorkUntilDeadline); + }; + } else if (typeof MessageChannel !== 'undefined') { + // DOM and Worker environments. + // We prefer MessageChannel because of the 4ms setTimeout clamping. + var channel = new MessageChannel(); + var port = channel.port2; + channel.port1.onmessage = performWorkUntilDeadline; + + schedulePerformWorkUntilDeadline = function () { + port.postMessage(null); + }; + } else { + // We should only fallback here in non-browser environments. + schedulePerformWorkUntilDeadline = function () { + localSetTimeout(performWorkUntilDeadline, 0); + }; + } + + function requestHostCallback(callback) { + scheduledHostCallback = callback; + + if (!isMessageLoopRunning) { + isMessageLoopRunning = true; + schedulePerformWorkUntilDeadline(); + } + } + + function requestHostTimeout(callback, ms) { + taskTimeoutID = localSetTimeout(function () { + callback(getCurrentTime()); + }, ms); + } + + function cancelHostTimeout() { + localClearTimeout(taskTimeoutID); + taskTimeoutID = -1; + } + + var unstable_requestPaint = requestPaint; + var unstable_Profiling = null; + + + + var Scheduler = /*#__PURE__*/Object.freeze({ + __proto__: null, + unstable_ImmediatePriority: ImmediatePriority, + unstable_UserBlockingPriority: UserBlockingPriority, + unstable_NormalPriority: NormalPriority, + unstable_IdlePriority: IdlePriority, + unstable_LowPriority: LowPriority, + unstable_runWithPriority: unstable_runWithPriority, + unstable_next: unstable_next, + unstable_scheduleCallback: unstable_scheduleCallback, + unstable_cancelCallback: unstable_cancelCallback, + unstable_wrapCallback: unstable_wrapCallback, + unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel, + unstable_shouldYield: shouldYieldToHost, + unstable_requestPaint: unstable_requestPaint, + unstable_continueExecution: unstable_continueExecution, + unstable_pauseExecution: unstable_pauseExecution, + unstable_getFirstCallbackNode: unstable_getFirstCallbackNode, + get unstable_now () { return getCurrentTime; }, + unstable_forceFrameRate: forceFrameRate, + unstable_Profiling: unstable_Profiling + }); + + var ReactSharedInternals$1 = { + ReactCurrentDispatcher: ReactCurrentDispatcher, + ReactCurrentOwner: ReactCurrentOwner, + ReactCurrentBatchConfig: ReactCurrentBatchConfig, + // Re-export the schedule API(s) for UMD bundles. + // This avoids introducing a dependency on a new UMD global in a minor update, + // Since that would be a breaking change (e.g. for all existing CodeSandboxes). + // This re-export is only required for UMD bundles; + // CJS bundles use the shared NPM package. + Scheduler: Scheduler + }; + + { + ReactSharedInternals$1.ReactCurrentActQueue = ReactCurrentActQueue; + ReactSharedInternals$1.ReactDebugCurrentFrame = ReactDebugCurrentFrame; + } + + function startTransition(scope, options) { + var prevTransition = ReactCurrentBatchConfig.transition; + ReactCurrentBatchConfig.transition = {}; + var currentTransition = ReactCurrentBatchConfig.transition; + + { + ReactCurrentBatchConfig.transition._updatedFibers = new Set(); + } + + try { + scope(); + } finally { + ReactCurrentBatchConfig.transition = prevTransition; + + { + if (prevTransition === null && currentTransition._updatedFibers) { + var updatedFibersCount = currentTransition._updatedFibers.size; + + if (updatedFibersCount > 10) { + warn('Detected a large number of updates inside startTransition. ' + 'If this is due to a subscription please re-write it to use React provided hooks. ' + 'Otherwise concurrent mode guarantees are off the table.'); + } + + currentTransition._updatedFibers.clear(); + } + } + } + } + + var didWarnAboutMessageChannel = false; + var enqueueTaskImpl = null; + function enqueueTask(task) { + if (enqueueTaskImpl === null) { + try { + // read require off the module object to get around the bundlers. + // we don't want them to detect a require and bundle a Node polyfill. + var requireString = ('require' + Math.random()).slice(0, 7); + var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's + // version of setImmediate, bypassing fake timers if any. + + enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate; + } catch (_err) { + // we're in a browser + // we can't use regular timers because they may still be faked + // so we try MessageChannel+postMessage instead + enqueueTaskImpl = function (callback) { + { + if (didWarnAboutMessageChannel === false) { + didWarnAboutMessageChannel = true; + + if (typeof MessageChannel === 'undefined') { + error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.'); + } + } + } + + var channel = new MessageChannel(); + channel.port1.onmessage = callback; + channel.port2.postMessage(undefined); + }; + } + } + + return enqueueTaskImpl(task); + } + + var actScopeDepth = 0; + var didWarnNoAwaitAct = false; + function act(callback) { + { + // `act` calls can be nested, so we track the depth. This represents the + // number of `act` scopes on the stack. + var prevActScopeDepth = actScopeDepth; + actScopeDepth++; + + if (ReactCurrentActQueue.current === null) { + // This is the outermost `act` scope. Initialize the queue. The reconciler + // will detect the queue and use it instead of Scheduler. + ReactCurrentActQueue.current = []; + } + + var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy; + var result; + + try { + // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only + // set to `true` while the given callback is executed, not for updates + // triggered during an async event, because this is how the legacy + // implementation of `act` behaved. + ReactCurrentActQueue.isBatchingLegacy = true; + result = callback(); // Replicate behavior of original `act` implementation in legacy mode, + // which flushed updates immediately after the scope function exits, even + // if it's an async function. + + if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) { + var queue = ReactCurrentActQueue.current; + + if (queue !== null) { + ReactCurrentActQueue.didScheduleLegacyUpdate = false; + flushActQueue(queue); + } + } + } catch (error) { + popActScope(prevActScopeDepth); + throw error; + } finally { + ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy; + } + + if (result !== null && typeof result === 'object' && typeof result.then === 'function') { + var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait + // for it to resolve before exiting the current scope. + + var wasAwaited = false; + var thenable = { + then: function (resolve, reject) { + wasAwaited = true; + thenableResult.then(function (returnValue) { + popActScope(prevActScopeDepth); + + if (actScopeDepth === 0) { + // We've exited the outermost act scope. Recursively flush the + // queue until there's no remaining work. + recursivelyFlushAsyncActWork(returnValue, resolve, reject); + } else { + resolve(returnValue); + } + }, function (error) { + // The callback threw an error. + popActScope(prevActScopeDepth); + reject(error); + }); + } + }; + + { + if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') { + // eslint-disable-next-line no-undef + Promise.resolve().then(function () {}).then(function () { + if (!wasAwaited) { + didWarnNoAwaitAct = true; + + error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);'); + } + }); + } + } + + return thenable; + } else { + var returnValue = result; // The callback is not an async function. Exit the current scope + // immediately, without awaiting. + + popActScope(prevActScopeDepth); + + if (actScopeDepth === 0) { + // Exiting the outermost act scope. Flush the queue. + var _queue = ReactCurrentActQueue.current; + + if (_queue !== null) { + flushActQueue(_queue); + ReactCurrentActQueue.current = null; + } // Return a thenable. If the user awaits it, we'll flush again in + // case additional work was scheduled by a microtask. + + + var _thenable = { + then: function (resolve, reject) { + // Confirm we haven't re-entered another `act` scope, in case + // the user does something weird like await the thenable + // multiple times. + if (ReactCurrentActQueue.current === null) { + // Recursively flush the queue until there's no remaining work. + ReactCurrentActQueue.current = []; + recursivelyFlushAsyncActWork(returnValue, resolve, reject); + } else { + resolve(returnValue); + } + } + }; + return _thenable; + } else { + // Since we're inside a nested `act` scope, the returned thenable + // immediately resolves. The outer scope will flush the queue. + var _thenable2 = { + then: function (resolve, reject) { + resolve(returnValue); + } + }; + return _thenable2; + } + } + } + } + + function popActScope(prevActScopeDepth) { + { + if (prevActScopeDepth !== actScopeDepth - 1) { + error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. '); + } + + actScopeDepth = prevActScopeDepth; + } + } + + function recursivelyFlushAsyncActWork(returnValue, resolve, reject) { + { + var queue = ReactCurrentActQueue.current; + + if (queue !== null) { + try { + flushActQueue(queue); + enqueueTask(function () { + if (queue.length === 0) { + // No additional work was scheduled. Finish. + ReactCurrentActQueue.current = null; + resolve(returnValue); + } else { + // Keep flushing work until there's none left. + recursivelyFlushAsyncActWork(returnValue, resolve, reject); + } + }); + } catch (error) { + reject(error); + } + } else { + resolve(returnValue); + } + } + } + + var isFlushing = false; + + function flushActQueue(queue) { + { + if (!isFlushing) { + // Prevent re-entrance. + isFlushing = true; + var i = 0; + + try { + for (; i < queue.length; i++) { + var callback = queue[i]; + + do { + callback = callback(true); + } while (callback !== null); + } + + queue.length = 0; + } catch (error) { + // If something throws, leave the remaining callbacks on the queue. + queue = queue.slice(i + 1); + throw error; + } finally { + isFlushing = false; + } + } + } + } + + var createElement$1 = createElementWithValidation ; + var cloneElement$1 = cloneElementWithValidation ; + var createFactory = createFactoryWithValidation ; + var Children = { + map: mapChildren, + forEach: forEachChildren, + count: countChildren, + toArray: toArray, + only: onlyChild + }; + + exports.Children = Children; + exports.Component = Component; + exports.Fragment = REACT_FRAGMENT_TYPE; + exports.Profiler = REACT_PROFILER_TYPE; + exports.PureComponent = PureComponent; + exports.StrictMode = REACT_STRICT_MODE_TYPE; + exports.Suspense = REACT_SUSPENSE_TYPE; + exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals$1; + exports.act = act; + exports.cloneElement = cloneElement$1; + exports.createContext = createContext; + exports.createElement = createElement$1; + exports.createFactory = createFactory; + exports.createRef = createRef; + exports.forwardRef = forwardRef; + exports.isValidElement = isValidElement; + exports.lazy = lazy; + exports.memo = memo; + exports.startTransition = startTransition; + exports.unstable_act = act; + exports.useCallback = useCallback; + exports.useContext = useContext; + exports.useDebugValue = useDebugValue; + exports.useDeferredValue = useDeferredValue; + exports.useEffect = useEffect; + exports.useId = useId; + exports.useImperativeHandle = useImperativeHandle; + exports.useInsertionEffect = useInsertionEffect; + exports.useLayoutEffect = useLayoutEffect; + exports.useMemo = useMemo; + exports.useReducer = useReducer; + exports.useRef = useRef; + exports.useState = useState; + exports.useSyncExternalStore = useSyncExternalStore; + exports.useTransition = useTransition; + exports.version = ReactVersion; + +}))); diff --git a/node_modules/react/umd/react.production.min.js b/node_modules/react/umd/react.production.min.js new file mode 100644 index 0000000..9f467ca --- /dev/null +++ b/node_modules/react/umd/react.production.min.js @@ -0,0 +1,31 @@ +/** + * @license React + * react.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +(function(){'use strict';(function(c,x){"object"===typeof exports&&"undefined"!==typeof module?x(exports):"function"===typeof define&&define.amd?define(["exports"],x):(c=c||self,x(c.React={}))})(this,function(c){function x(a){if(null===a||"object"!==typeof a)return null;a=V&&a[V]||a["@@iterator"];return"function"===typeof a?a:null}function w(a,b,e){this.props=a;this.context=b;this.refs=W;this.updater=e||X}function Y(){}function K(a,b,e){this.props=a;this.context=b;this.refs=W;this.updater=e||X}function Z(a,b, +e){var m,d={},c=null,h=null;if(null!=b)for(m in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(c=""+b.key),b)aa.call(b,m)&&!ba.hasOwnProperty(m)&&(d[m]=b[m]);var l=arguments.length-2;if(1===l)d.children=e;else if(1>>1,d=a[c];if(0>>1;cD(l,e))fD(g,l)?(a[c]=g,a[f]=e,c=f):(a[c]=l,a[h]=e,c=h);else if(fD(g,e))a[c]=g,a[f]=e,c=f;else break a}}return b} +function D(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}function P(a){for(var b=p(r);null!==b;){if(null===b.callback)E(r);else if(b.startTime<=a)E(r),b.sortIndex=b.expirationTime,O(q,b);else break;b=p(r)}}function Q(a){z=!1;P(a);if(!u)if(null!==p(q))u=!0,R(S);else{var b=p(r);null!==b&&T(Q,b.startTime-a)}}function S(a,b){u=!1;z&&(z=!1,ea(A),A=-1);F=!0;var c=k;try{P(b);for(n=p(q);null!==n&&(!(n.expirationTime>b)||a&&!fa());){var m=n.callback;if("function"===typeof m){n.callback=null; +k=n.priorityLevel;var d=m(n.expirationTime<=b);b=v();"function"===typeof d?n.callback=d:n===p(q)&&E(q);P(b)}else E(q);n=p(q)}if(null!==n)var g=!0;else{var h=p(r);null!==h&&T(Q,h.startTime-b);g=!1}return g}finally{n=null,k=c,F=!1}}function fa(){return v()-hae?(a.sortIndex=c,O(r,a),null===p(q)&&a===p(r)&&(z?(ea(A),A=-1):z=!0,T(Q,c-e))):(a.sortIndex=d,O(q,a),u||F||(u=!0,R(S)));return a},unstable_cancelCallback:function(a){a.callback=null},unstable_wrapCallback:function(a){var b= +k;return function(){var c=k;k=b;try{return a.apply(this,arguments)}finally{k=c}}},unstable_getCurrentPriorityLevel:function(){return k},unstable_shouldYield:fa,unstable_requestPaint:function(){},unstable_continueExecution:function(){u||F||(u=!0,R(S))},unstable_pauseExecution:function(){},unstable_getFirstCallbackNode:function(){return p(q)},get unstable_now(){return v},unstable_forceFrameRate:function(a){0>a||125>>1,d=a[c];if(0>>1;cD(l,e))fD(g,l)?(a[c]=g,a[f]=e,c=f):(a[c]=l,a[h]=e,c=h);else if(fD(g,e))a[c]=g,a[f]=e,c=f;else break a}}return b} +function D(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}function P(a){for(var b=p(r);null!==b;){if(null===b.callback)E(r);else if(b.startTime<=a)E(r),b.sortIndex=b.expirationTime,O(q,b);else break;b=p(r)}}function Q(a){z=!1;P(a);if(!u)if(null!==p(q))u=!0,R(S);else{var b=p(r);null!==b&&T(Q,b.startTime-a)}}function S(a,b){u=!1;z&&(z=!1,ea(A),A=-1);F=!0;var c=k;try{P(b);for(n=p(q);null!==n&&(!(n.expirationTime>b)||a&&!fa());){var m=n.callback;if("function"===typeof m){n.callback=null; +k=n.priorityLevel;var d=m(n.expirationTime<=b);b=v();"function"===typeof d?n.callback=d:n===p(q)&&E(q);P(b)}else E(q);n=p(q)}if(null!==n)var g=!0;else{var h=p(r);null!==h&&T(Q,h.startTime-b);g=!1}return g}finally{n=null,k=c,F=!1}}function fa(){return v()-hae?(a.sortIndex=c,O(r,a),null===p(q)&&a===p(r)&&(z?(ea(A),A=-1):z=!0,T(Q,c-e))):(a.sortIndex=d,O(q,a),u||F||(u=!0,R(S)));return a},unstable_cancelCallback:function(a){a.callback=null},unstable_wrapCallback:function(a){var b= +k;return function(){var c=k;k=b;try{return a.apply(this,arguments)}finally{k=c}}},unstable_getCurrentPriorityLevel:function(){return k},unstable_shouldYield:fa,unstable_requestPaint:function(){},unstable_continueExecution:function(){u||F||(u=!0,R(S))},unstable_pauseExecution:function(){},unstable_getFirstCallbackNode:function(){return p(q)},get unstable_now(){return v},unstable_forceFrameRate:function(a){0>a||125=0.10.0" + } + }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/react": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz", + "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==", + "peer": true, + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-feather": { + "version": "2.0.10", + "resolved": "https://registry.npmjs.org/react-feather/-/react-feather-2.0.10.tgz", + "integrity": "sha512-BLhukwJ+Z92Nmdcs+EMw6dy1Z/VLiJTzEQACDUEnWMClhYnFykJCGWQx+NmwP/qQHGX/5CzQ+TGi8ofg2+HzVQ==", + "dependencies": { + "prop-types": "^15.7.2" + }, + "peerDependencies": { + "react": ">=16.8.6" + } + }, + "node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==" + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..1299033 --- /dev/null +++ b/package.json @@ -0,0 +1,5 @@ +{ + "dependencies": { + "react-feather": "^2.0.10" + } +}