@epilot360/icons 0.0.2 → 1.0.0

package/iac/node_modules/pretty-format/README.md

@@ -1,458 +0,0 @@
-# pretty-format
-
-Stringify any JavaScript value.
-
-- Serialize built-in JavaScript types.
-- Serialize application-specific data types with built-in or user-defined plugins.
-
-## Installation
-
-```sh
-$ yarn add pretty-format
-```
-
-## Usage
-
-```js
-const {format: prettyFormat} = require('pretty-format'); // CommonJS
-```
-
-```js
-import {format as prettyFormat} from 'pretty-format'; // ES2015 modules
-```
-
-```js
-const val = {object: {}};
-val.circularReference = val;
-val[Symbol('foo')] = 'foo';
-val.map = new Map([['prop', 'value']]);
-val.array = [-0, Infinity, NaN];
-
-console.log(prettyFormat(val));
-/*
-Object {
-  "array": Array [
-    -0,
-    Infinity,
-    NaN,
-  ],
-  "circularReference": [Circular],
-  "map": Map {
-    "prop" => "value",
-  },
-  "object": Object {},
-  Symbol(foo): "foo",
-}
-*/
-```
-
-## Usage with options
-
-```js
-function onClick() {}
-
-console.log(prettyFormat(onClick));
-/*
-[Function onClick]
-*/
-
-const options = {
-  printFunctionName: false,
-};
-console.log(prettyFormat(onClick, options));
-/*
-[Function]
-*/
-```
-
-<!-- prettier-ignore -->
-| key                   | type      | default    | description                                             |
-| :-------------------- | :-------- | :--------- | :------------------------------------------------------ |
-| `callToJSON`          | `boolean` | `true`     | call `toJSON` method (if it exists) on objects          |
-| `compareKeys`         | `function`| `undefined`| compare function used when sorting object keys          |
-| `escapeRegex`         | `boolean` | `false`    | escape special characters in regular expressions        |
-| `escapeString`        | `boolean` | `true`     | escape special characters in strings                    |
-| `highlight`           | `boolean` | `false`    | highlight syntax with colors in terminal (some plugins) |
-| `indent`              | `number`  | `2`        | spaces in each level of indentation                     |
-| `maxDepth`            | `number`  | `Infinity` | levels to print in arrays, objects, elements, and so on |
-| `min`                 | `boolean` | `false`    | minimize added space: no indentation nor line breaks    |
-| `plugins`             | `array`   | `[]`       | plugins to serialize application-specific data types    |
-| `printBasicPrototype` | `boolean` | `false`    | print the prototype for plain objects and arrays        |
-| `printFunctionName`   | `boolean` | `true`     | include or omit the name of a function                  |
-| `theme`               | `object`  |            | colors to highlight syntax in terminal                  |
-
-Property values of `theme` are from [ansi-styles colors](https://github.com/chalk/ansi-styles#colors)
-
-```js
-const DEFAULT_THEME = {
-  comment: 'gray',
-  content: 'reset',
-  prop: 'yellow',
-  tag: 'cyan',
-  value: 'green',
-};
-```
-
-## Usage with plugins
-
-The `pretty-format` package provides some built-in plugins, including:
-
-- `ReactElement` for elements from `react`
-- `ReactTestComponent` for test objects from `react-test-renderer`
-
-```js
-// CommonJS
-const React = require('react');
-const renderer = require('react-test-renderer');
-const {format: prettyFormat, plugins} = require('pretty-format');
-
-const {ReactElement, ReactTestComponent} = plugins;
-```
-
-```js
-// ES2015 modules and destructuring assignment
-import React from 'react';
-import renderer from 'react-test-renderer';
-import {plugins, format as prettyFormat} from 'pretty-format';
-
-const {ReactElement, ReactTestComponent} = plugins;
-```
-
-```js
-const onClick = () => {};
-const element = React.createElement('button', {onClick}, 'Hello World');
-
-const formatted1 = prettyFormat(element, {
-  plugins: [ReactElement],
-  printFunctionName: false,
-});
-const formatted2 = prettyFormat(renderer.create(element).toJSON(), {
-  plugins: [ReactTestComponent],
-  printFunctionName: false,
-});
-/*
-<button
-  onClick=[Function]
->
-  Hello World
-</button>
-*/
-```
-
-## Usage in Jest
-
-For snapshot tests, Jest uses `pretty-format` with options that include some of its built-in plugins. For this purpose, plugins are also known as **snapshot serializers**.
-
-To serialize application-specific data types, you can add modules to `devDependencies` of a project, and then:
-
-In an **individual** test file, you can add a module as follows. It precedes any modules from Jest configuration.
-
-```js
-import serializer from 'my-serializer-module';
-expect.addSnapshotSerializer(serializer);
-
-// tests which have `expect(value).toMatchSnapshot()` assertions
-```
-
-For **all** test files, you can specify modules in Jest configuration. They precede built-in plugins for React, HTML, and Immutable.js data types. For example, in a `package.json` file:
-
-```json
-{
-  "jest": {
-    "snapshotSerializers": ["my-serializer-module"]
-  }
-}
-```
-
-## Writing plugins
-
-A plugin is a JavaScript object.
-
-If `options` has a `plugins` array: for the first plugin whose `test(val)` method returns a truthy value, then `prettyFormat(val, options)` returns the result from either:
-
-- `serialize(val, …)` method of the **improved** interface (available in **version 21** or later)
-- `print(val, …)` method of the **original** interface (if plugin does not have `serialize` method)
-
-### test
-
-Write `test` so it can receive `val` argument of any type. To serialize **objects** which have certain properties, then a guarded expression like `val != null && …` or more concise `val && …` prevents the following errors:
-
-- `TypeError: Cannot read property 'whatever' of null`
-- `TypeError: Cannot read property 'whatever' of undefined`
-
-For example, `test` method of built-in `ReactElement` plugin:
-
-```js
-const elementSymbol = Symbol.for('react.element');
-const test = val => val && val.$$typeof === elementSymbol;
-```
-
-Pay attention to efficiency in `test` because `pretty-format` calls it often.
-
-### serialize
-
-The **improved** interface is available in **version 21** or later.
-
-Write `serialize` to return a string, given the arguments:
-
-- `val` which “passed the test”
-- unchanging `config` object: derived from `options`
-- current `indentation` string: concatenate to `indent` from `config`
-- current `depth` number: compare to `maxDepth` from `config`
-- current `refs` array: find circular references in objects
-- `printer` callback function: serialize children
-
-### config
-
-<!-- prettier-ignore -->
-| key                 | type      | description                                             |
-| :------------------ | :-------- | :------------------------------------------------------ |
-| `callToJSON`        | `boolean` | call `toJSON` method (if it exists) on objects          |
-| `compareKeys`       | `function`| compare function used when sorting object keys          |
-| `colors`            | `Object`  | escape codes for colors to highlight syntax             |
-| `escapeRegex`       | `boolean` | escape special characters in regular expressions        |
-| `escapeString`      | `boolean` | escape special characters in strings                    |
-| `indent`            | `string`  | spaces in each level of indentation                     |
-| `maxDepth`          | `number`  | levels to print in arrays, objects, elements, and so on |
-| `min`               | `boolean` | minimize added space: no indentation nor line breaks    |
-| `plugins`           | `array`   | plugins to serialize application-specific data types    |
-| `printFunctionName` | `boolean` | include or omit the name of a function                  |
-| `spacingInner`      | `strong`  | spacing to separate items in a list                     |
-| `spacingOuter`      | `strong`  | spacing to enclose a list of items                      |
-
-Each property of `colors` in `config` corresponds to a property of `theme` in `options`:
-
-- the key is the same (for example, `tag`)
-- the value in `colors` is a object with `open` and `close` properties whose values are escape codes from [ansi-styles](https://github.com/chalk/ansi-styles) for the color value in `theme` (for example, `'cyan'`)
-
-Some properties in `config` are derived from `min` in `options`:
-
-- `spacingInner` and `spacingOuter` are **newline** if `min` is `false`
-- `spacingInner` is **space** and `spacingOuter` is **empty string** if `min` is `true`
-
-### Example of serialize and test
-
-This plugin is a pattern you can apply to serialize composite data types. Side note: `pretty-format` does not need a plugin to serialize arrays.
-
-```js
-// We reused more code when we factored out a function for child items
-// that is independent of depth, name, and enclosing punctuation (see below).
-const SEPARATOR = ',';
-function serializeItems(items, config, indentation, depth, refs, printer) {
-  if (items.length === 0) {
-    return '';
-  }
-  const indentationItems = indentation + config.indent;
-  return (
-    config.spacingOuter +
-    items
-      .map(
-        item =>
-          indentationItems +
-          printer(item, config, indentationItems, depth, refs), // callback
-      )
-      .join(SEPARATOR + config.spacingInner) +
-    (config.min ? '' : SEPARATOR) + // following the last item
-    config.spacingOuter +
-    indentation
-  );
-}
-
-const plugin = {
-  test(val) {
-    return Array.isArray(val);
-  },
-  serialize(array, config, indentation, depth, refs, printer) {
-    const name = array.constructor.name;
-    return ++depth > config.maxDepth
-      ? '[' + name + ']'
-      : (config.min ? '' : name + ' ') +
-          '[' +
-          serializeItems(array, config, indentation, depth, refs, printer) +
-          ']';
-  },
-};
-```
-
-```js
-const val = {
-  filter: 'completed',
-  items: [
-    {
-      text: 'Write test',
-      completed: true,
-    },
-    {
-      text: 'Write serialize',
-      completed: true,
-    },
-  ],
-};
-```
-
-```js
-console.log(
-  prettyFormat(val, {
-    plugins: [plugin],
-  }),
-);
-/*
-Object {
-  "filter": "completed",
-  "items": Array [
-    Object {
-      "completed": true,
-      "text": "Write test",
-    },
-    Object {
-      "completed": true,
-      "text": "Write serialize",
-    },
-  ],
-}
-*/
-```
-
-```js
-console.log(
-  prettyFormat(val, {
-    indent: 4,
-    plugins: [plugin],
-  }),
-);
-/*
-Object {
-    "filter": "completed",
-    "items": Array [
-        Object {
-            "completed": true,
-            "text": "Write test",
-        },
-        Object {
-            "completed": true,
-            "text": "Write serialize",
-        },
-    ],
-}
-*/
-```
-
-```js
-console.log(
-  prettyFormat(val, {
-    maxDepth: 1,
-    plugins: [plugin],
-  }),
-);
-/*
-Object {
-  "filter": "completed",
-  "items": [Array],
-}
-*/
-```
-
-```js
-console.log(
-  prettyFormat(val, {
-    min: true,
-    plugins: [plugin],
-  }),
-);
-/*
-{"filter": "completed", "items": [{"completed": true, "text": "Write test"}, {"completed": true, "text": "Write serialize"}]}
-*/
-```
-
-### print
-
-The **original** interface is adequate for plugins:
-
-- that **do not** depend on options other than `highlight` or `min`
-- that **do not** depend on `depth` or `refs` in recursive traversal, and
-- if values either
-  - do **not** require indentation, or
-  - do **not** occur as children of JavaScript data structures (for example, array)
-
-Write `print` to return a string, given the arguments:
-
-- `val` which “passed the test”
-- current `printer(valChild)` callback function: serialize children
-- current `indenter(lines)` callback function: indent lines at the next level
-- unchanging `config` object: derived from `options`
-- unchanging `colors` object: derived from `options`
-
-The 3 properties of `config` are `min` in `options` and:
-
-- `spacing` and `edgeSpacing` are **newline** if `min` is `false`
-- `spacing` is **space** and `edgeSpacing` is **empty string** if `min` is `true`
-
-Each property of `colors` corresponds to a property of `theme` in `options`:
-
-- the key is the same (for example, `tag`)
-- the value in `colors` is a object with `open` and `close` properties whose values are escape codes from [ansi-styles](https://github.com/chalk/ansi-styles) for the color value in `theme` (for example, `'cyan'`)
-
-### Example of print and test
-
-This plugin prints functions with the **number of named arguments** excluding rest argument.
-
-```js
-const plugin = {
-  print(val) {
-    return `[Function ${val.name || 'anonymous'} ${val.length}]`;
-  },
-  test(val) {
-    return typeof val === 'function';
-  },
-};
-```
-
-```js
-const val = {
-  onClick(event) {},
-  render() {},
-};
-
-prettyFormat(val, {
-  plugins: [plugin],
-});
-/*
-Object {
-  "onClick": [Function onClick 1],
-  "render": [Function render 0],
-}
-*/
-
-prettyFormat(val);
-/*
-Object {
-  "onClick": [Function onClick],
-  "render": [Function render],
-}
-*/
-```
-
-This plugin **ignores** the `printFunctionName` option. That limitation of the original `print` interface is a reason to use the improved `serialize` interface, described above.
-
-```js
-prettyFormat(val, {
-  plugins: [pluginOld],
-  printFunctionName: false,
-});
-/*
-Object {
-  "onClick": [Function onClick 1],
-  "render": [Function render 0],
-}
-*/
-
-prettyFormat(val, {
-  printFunctionName: false,
-});
-/*
-Object {
-  "onClick": [Function],
-  "render": [Function],
-}
-*/
-```

package/iac/node_modules/punycode/README.md

@@ -1,122 +0,0 @@
-# Punycode.js [![Build status](https://travis-ci.org/bestiejs/punycode.js.svg?branch=master)](https://travis-ci.org/bestiejs/punycode.js) [![Code coverage status](http://img.shields.io/codecov/c/github/bestiejs/punycode.js.svg)](https://codecov.io/gh/bestiejs/punycode.js) [![Dependency status](https://gemnasium.com/bestiejs/punycode.js.svg)](https://gemnasium.com/bestiejs/punycode.js)
-
-Punycode.js is a robust Punycode converter that fully complies to [RFC 3492](https://tools.ietf.org/html/rfc3492) and [RFC 5891](https://tools.ietf.org/html/rfc5891).
-
-This JavaScript library is the result of comparing, optimizing and documenting different open-source implementations of the Punycode algorithm:
-
-* [The C example code from RFC 3492](https://tools.ietf.org/html/rfc3492#appendix-C)
-* [`punycode.c` by _Markus W. Scherer_ (IBM)](http://opensource.apple.com/source/ICU/ICU-400.42/icuSources/common/punycode.c)
-* [`punycode.c` by _Ben Noordhuis_](https://github.com/bnoordhuis/punycode/blob/master/punycode.c)
-* [JavaScript implementation by _some_](http://stackoverflow.com/questions/183485/can-anyone-recommend-a-good-free-javascript-for-punycode-to-unicode-conversion/301287#301287)
-* [`punycode.js` by _Ben Noordhuis_](https://github.com/joyent/node/blob/426298c8c1c0d5b5224ac3658c41e7c2a3fe9377/lib/punycode.js) (note: [not fully compliant](https://github.com/joyent/node/issues/2072))
-
-This project was [bundled](https://github.com/joyent/node/blob/master/lib/punycode.js) with Node.js from [v0.6.2+](https://github.com/joyent/node/compare/975f1930b1...61e796decc) until [v7](https://github.com/nodejs/node/pull/7941) (soft-deprecated).
-
-The current version supports recent versions of Node.js only. It provides a CommonJS module and an ES6 module. For the old version that offers the same functionality with broader support, including Rhino, Ringo, Narwhal, and web browsers, see [v1.4.1](https://github.com/bestiejs/punycode.js/releases/tag/v1.4.1).
-
-## Installation
-
-Via [npm](https://www.npmjs.com/):
-
-```bash
-npm install punycode --save
-```
-
-In [Node.js](https://nodejs.org/):
-
-```js
-const punycode = require('punycode');
-```
-
-## API
-
-### `punycode.decode(string)`
-
-Converts a Punycode string of ASCII symbols to a string of Unicode symbols.
-
-```js
-// decode domain name parts
-punycode.decode('maana-pta'); // 'mañana'
-punycode.decode('--dqo34k'); // '☃-⌘'
-```
-
-### `punycode.encode(string)`
-
-Converts a string of Unicode symbols to a Punycode string of ASCII symbols.
-
-```js
-// encode domain name parts
-punycode.encode('mañana'); // 'maana-pta'
-punycode.encode('☃-⌘'); // '--dqo34k'
-```
-
-### `punycode.toUnicode(input)`
-
-Converts a Punycode string representing a domain name or an email address to Unicode. Only the Punycoded parts of the input will be converted, i.e. it doesn’t matter if you call it on a string that has already been converted to Unicode.
-
-```js
-// decode domain names
-punycode.toUnicode('xn--maana-pta.com');
-// → 'mañana.com'
-punycode.toUnicode('xn----dqo34k.com');
-// → '☃-⌘.com'
-
-// decode email addresses
-punycode.toUnicode('джумла@xn--p-8sbkgc5ag7bhce.xn--ba-lmcq');
-// → 'джумла@джpумлатест.bрфa'
-```
-
-### `punycode.toASCII(input)`
-
-Converts a lowercased Unicode string representing a domain name or an email address to Punycode. Only the non-ASCII parts of the input will be converted, i.e. it doesn’t matter if you call it with a domain that’s already in ASCII.
-
-```js
-// encode domain names
-punycode.toASCII('mañana.com');
-// → 'xn--maana-pta.com'
-punycode.toASCII('☃-⌘.com');
-// → 'xn----dqo34k.com'
-
-// encode email addresses
-punycode.toASCII('джумла@джpумлатест.bрфa');
-// → 'джумла@xn--p-8sbkgc5ag7bhce.xn--ba-lmcq'
-```
-
-### `punycode.ucs2`
-
-#### `punycode.ucs2.decode(string)`
-
-Creates an array containing the numeric code point values of each Unicode symbol in the string. While [JavaScript uses UCS-2 internally](https://mathiasbynens.be/notes/javascript-encoding), this function will convert a pair of surrogate halves (each of which UCS-2 exposes as separate characters) into a single code point, matching UTF-16.
-
-```js
-punycode.ucs2.decode('abc');
-// → [0x61, 0x62, 0x63]
-// surrogate pair for U+1D306 TETRAGRAM FOR CENTRE:
-punycode.ucs2.decode('\uD834\uDF06');
-// → [0x1D306]
-```
-
-#### `punycode.ucs2.encode(codePoints)`
-
-Creates a string based on an array of numeric code point values.
-
-```js
-punycode.ucs2.encode([0x61, 0x62, 0x63]);
-// → 'abc'
-punycode.ucs2.encode([0x1D306]);
-// → '\uD834\uDF06'
-```
-
-### `punycode.version`
-
-A string representing the current Punycode.js version number.
-
-## Author
-
-| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
-|---|
-| [Mathias Bynens](https://mathiasbynens.be/) |
-
-## License
-
-Punycode.js is available under the [MIT](https://mths.be/mit) license.

package/iac/node_modules/react-is/LICENSE

@@ -1,21 +0,0 @@
-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.

package/iac/node_modules/react-is/README.md

@@ -1,104 +0,0 @@
-# `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(<ThemeContext.Consumer />); // true
-ReactIs.isContextProvider(<ThemeContext.Provider />); // true
-ReactIs.typeOf(<ThemeContext.Provider />) === ReactIs.ContextProvider; // true
-ReactIs.typeOf(<ThemeContext.Consumer />) === ReactIs.ContextConsumer; // true
-```
-
-#### Element
-
-```js
-import React from "react";
-import * as ReactIs from 'react-is';
-
-ReactIs.isElement(<div />); // true
-ReactIs.typeOf(<div />) === 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 />, 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(<React.StrictMode />); // true
-ReactIs.typeOf(<React.StrictMode />) === ReactIs.StrictMode; // true
-```