picata 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

node_modules/@csstools/postcss-trigonometric-functions/README.md

@@ -0,0 +1,149 @@
+# PostCSS Trigonometric Functions [<img src="https://postcss.github.io/postcss/logo.svg" alt="PostCSS Logo" width="90" height="90" align="right">][PostCSS]
+
+`npm install @csstools/postcss-trigonometric-functions --save-dev`
+
+[PostCSS Trigonometric Functions] lets you use `sin`, `cos`, `tan`, `asin`, `acos`, `atan` and `atan2` to be able to compute trigonometric relationships following the [CSS Values 4] specification.
+
+```css
+.trigonometry {
+	line-height: sin(pi / 4);
+	line-height: cos(.125turn);
+	line-height: tan(50grad);
+	transform: rotate(asin(-1));
+	transform: rotate(asin(sin(30deg + 1.0471967rad)));
+	transform: rotate(acos(-1));
+	transform: rotate(acos(cos(0 / 2 + 1 - 1)));
+	transform: rotate(atan(infinity));
+	transform: rotate(atan(e - 2.7182818284590452354));
+	transform: rotate(atan2(-infinity,-infinity));
+	transform: rotate(atan2(-infinity,infinity));
+	transform: rotate(atan2(-infinity,infinity));
+	transform: rotate(atan2(90, 15));
+}
+
+/* becomes */
+
+.trigonometry {
+	line-height: 0.70711;
+	line-height: 0.70711;
+	line-height: 1;
+	transform: rotate(-90deg);
+	transform: rotate(89.99995deg);
+	transform: rotate(180deg);
+	transform: rotate(0deg);
+	transform: rotate(90deg);
+	transform: rotate(0deg);
+	transform: rotate(-135deg);
+	transform: rotate(-45deg);
+	transform: rotate(-45deg);
+	transform: rotate(80.53768deg);
+}
+```
+
+## Usage
+
+Add [PostCSS Trigonometric Functions] to your project:
+
+```bash
+npm install postcss @csstools/postcss-trigonometric-functions --save-dev
+```
+
+Use it as a [PostCSS] plugin:
+
+```js
+const postcss = require('postcss');
+const postcssTrigonometricFunctions = require('@csstools/postcss-trigonometric-functions');
+
+postcss([
+	postcssTrigonometricFunctions(/* pluginOptions */)
+]).process(YOUR_CSS /*, processOptions */);
+```
+
+
+
+## ⚠️ About custom properties
+
+Given the dynamic nature of custom properties it's impossible to know what the variable value is, which means the plugin can't compute a final value for the stylesheet.
+
+Because of that, any usage that contains a `var` is skipped.
+
+## Units
+
+[PostCSS Trigonometric Functions] lets you use different special units that are within the spec and computed at run time to be able to calculate the result of the trigonometric function.
+
+The following units are supported:
+
+* `pi`: Computes to `Math.PI` which is `3.141592653589793`
+* `e`: Computes to `Math.E` which is `2.718281828459045`
+* `infinity`, `-infinity`: Compute to `Infinity` and `-Infinity` respectively. Note that the usage is case insensitive so `InFiNiTy` is a valid value.
+
+Some calculations (such as `sin(-infinity)`) might return `NaN` as per the spec. Given that `NaN` can't be replaced with a value that's useful to CSS it is left as is, as the result will be effectively ignored by the browser.
+
+## Options
+
+### preserve
+
+The `preserve` option determines whether the original notation
+is preserved. By default, it is not preserved.
+
+```js
+postcssTrigonometricFunctions({ preserve: true })
+```
+
+```css
+.trigonometry {
+	line-height: sin(pi / 4);
+	line-height: cos(.125turn);
+	line-height: tan(50grad);
+	transform: rotate(asin(-1));
+	transform: rotate(asin(sin(30deg + 1.0471967rad)));
+	transform: rotate(acos(-1));
+	transform: rotate(acos(cos(0 / 2 + 1 - 1)));
+	transform: rotate(atan(infinity));
+	transform: rotate(atan(e - 2.7182818284590452354));
+	transform: rotate(atan2(-infinity,-infinity));
+	transform: rotate(atan2(-infinity,infinity));
+	transform: rotate(atan2(-infinity,infinity));
+	transform: rotate(atan2(90, 15));
+}
+
+/* becomes */
+
+.trigonometry {
+	line-height: 0.70711;
+	line-height: sin(pi / 4);
+	line-height: 0.70711;
+	line-height: cos(.125turn);
+	line-height: 1;
+	line-height: tan(50grad);
+	transform: rotate(-90deg);
+	transform: rotate(asin(-1));
+	transform: rotate(89.99995deg);
+	transform: rotate(asin(sin(30deg + 1.0471967rad)));
+	transform: rotate(180deg);
+	transform: rotate(acos(-1));
+	transform: rotate(0deg);
+	transform: rotate(acos(cos(0 / 2 + 1 - 1)));
+	transform: rotate(90deg);
+	transform: rotate(atan(infinity));
+	transform: rotate(0deg);
+	transform: rotate(atan(e - 2.7182818284590452354));
+	transform: rotate(-135deg);
+	transform: rotate(atan2(-infinity,-infinity));
+	transform: rotate(-45deg);
+	transform: rotate(atan2(-infinity,infinity));
+	transform: rotate(-45deg);
+	transform: rotate(atan2(-infinity,infinity));
+	transform: rotate(80.53768deg);
+	transform: rotate(atan2(90, 15));
+}
+```
+
+[cli-url]: https://github.com/csstools/postcss-plugins/actions/workflows/test.yml?query=workflow/test
+[css-url]: https://cssdb.org/#trigonometric-functions
+[discord]: https://discord.gg/bUadyRwkJS
+[npm-url]: https://www.npmjs.com/package/@csstools/postcss-trigonometric-functions
+
+[PostCSS]: https://github.com/postcss/postcss
+[PostCSS Trigonometric Functions]: https://github.com/csstools/postcss-plugins/tree/main/plugins/postcss-trigonometric-functions
+[CSS Values 4]: https://www.w3.org/TR/css-values-4/#trig-funcs

node_modules/@csstools/postcss-unset-value/LICENSE.md

@@ -0,0 +1,18 @@
+MIT No Attribution (MIT-0)
+
+Copyright © CSSTools Contributors
+
+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.
+
+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.

node_modules/@csstools/postcss-unset-value/README.md

@@ -0,0 +1,120 @@
+# PostCSS Unset Value [<img src="https://postcss.github.io/postcss/logo.svg" alt="PostCSS Logo" width="90" height="90" align="right">][postcss]
+
+
+[<img alt="npm version" src="https://img.shields.io/npm/v/@csstools/postcss-unset-value.svg" height="20">][npm-url]
+[<img alt="Build Status" src="https://github.com/csstools/postcss-plugins/workflows/test/badge.svg" height="20">][cli-url]
+[<img alt="Discord" src="https://shields.io/badge/Discord-5865F2?logo=discord&logoColor=white">][discord]
+<br><br>
+[<img alt="Baseline Status" src="https://cssdb.org/images/badges-baseline/unset-value.svg" height="20">][css-url]
+[<img alt="CSS Standard Status" src="https://cssdb.org/images/badges/unset-value.svg" height="20">][css-url]
+
+[PostCSS Unset Value] lets you use the unset keyword, following the [CSS Cascading and Inheritance] specification.
+
+```pcss
+.color {
+	color: unset;
+}
+
+.border-color {
+	border-color: unset;
+}
+
+.margin {
+	margin: unset;
+}
+
+
+/* becomes */
+.color {
+	color: inherit;
+}
+
+.border-color {
+	border-color: initial;
+}
+
+.margin {
+	margin: initial;
+}
+```
+
+## Usage
+
+Add [PostCSS Unset Value] to your project:
+
+```bash
+npm install postcss @csstools/postcss-unset-value --save-dev
+```
+
+Use it as a [PostCSS] plugin:
+
+```js
+const postcss = require('postcss');
+const postcssUnsetValue = require('@csstools/postcss-unset-value');
+
+postcss([
+  postcssUnsetValue(/* pluginOptions */)
+]).process(YOUR_CSS /*, processOptions */);
+```
+
+[PostCSS Unset Value] runs in all Node environments, with special
+instructions for:
+
+| [Node](INSTALL.md#node) | [PostCSS CLI](INSTALL.md#postcss-cli) | [Webpack](INSTALL.md#webpack) | [Gulp](INSTALL.md#gulp) | [Grunt](INSTALL.md#grunt) |
+| --- | --- | --- | --- | --- |
+
+## Options
+
+### preserve
+
+The `preserve` option determines whether the original source
+is preserved. By default, it is not preserved.
+
+```js
+postcssUnsetValue({ preserve: true })
+```
+
+```pcss
+.color {
+	color: unset;
+}
+
+.border-color {
+	border-color: unset;
+}
+
+.margin {
+	margin: unset;
+}
+
+/* becomes */
+
+.color {
+	color: inherit;
+	color: unset;
+}
+
+.border-color {
+	border-color: initial;
+	border-color: unset;
+}
+
+.margin {
+	margin: initial;
+	margin: unset;
+}
+```
+
+[postcss]: https://github.com/postcss/postcss
+
+[cli-url]: https://github.com/csstools/postcss-plugins/actions/workflows/test.yml?query=workflow/test
+[css-url]: https://cssdb.org/#unset-value
+[discord]: https://discord.gg/bUadyRwkJS
+[npm-url]: https://www.npmjs.com/package/@csstools/postcss-unset-value
+
+[Gulp PostCSS]: https://github.com/postcss/gulp-postcss
+[Grunt PostCSS]: https://github.com/nDmitry/grunt-postcss
+[PostCSS]: https://github.com/postcss/postcss
+[PostCSS Loader]: https://github.com/postcss/postcss-loader
+[CSS Cascading and Inheritance]: https://www.w3.org/TR/css-cascade-4/#inherit-initial
+[PostCSS Unset Value]: https://github.com/csstools/postcss-plugins/tree/main/plugins/postcss-unset-value

node_modules/@csstools/utilities/LICENSE.md

@@ -0,0 +1,18 @@
+MIT No Attribution (MIT-0)
+
+Copyright © CSSTools Contributors
+
+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.
+
+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.

node_modules/@csstools/utilities/README.md

@@ -0,0 +1,25 @@
+# Utilities
+
+[<img alt="npm version" src="https://img.shields.io/npm/v/@csstools/utilities.svg" height="20">][npm-url]
+[<img alt="Build Status" src="https://github.com/csstools/postcss-plugins/workflows/test/badge.svg" height="20">][cli-url]
+[<img alt="Discord" src="https://shields.io/badge/Discord-5865F2?logo=discord&logoColor=white">][discord]
+
+Helpers that we use in many PostCSS plugins.
+
+## API
+
+[Read the API docs](./docs/utilities.md)
+
+## Usage
+
+Add [Utilities] to your project:
+
+```bash
+npm install @csstools/utilities --save-dev
+```
+
+[cli-url]: https://github.com/csstools/postcss-plugins/actions/workflows/test.yml?query=workflow/test
+[discord]: https://discord.gg/bUadyRwkJS
+[npm-url]: https://www.npmjs.com/package/@csstools/utilities
+
+[Utilities]: https://github.com/csstools/postcss-plugins/tree/main/packages/utilities

node_modules/@discoveryjs/json-ext/README.md

@@ -0,0 +1,256 @@
+# json-ext
+
+[![NPM version](https://img.shields.io/npm/v/@discoveryjs/json-ext.svg)](https://www.npmjs.com/package/@discoveryjs/json-ext)
+[![Build Status](https://github.com/discoveryjs/json-ext/actions/workflows/ci.yml/badge.svg)](https://github.com/discoveryjs/json-ext/actions/workflows/ci.yml)
+[![Coverage Status](https://coveralls.io/repos/github/discoveryjs/json-ext/badge.svg?branch=master)](https://coveralls.io/github/discoveryjs/json-ext?)
+[![NPM Downloads](https://img.shields.io/npm/dm/@discoveryjs/json-ext.svg)](https://www.npmjs.com/package/@discoveryjs/json-ext)
+
+A set of utilities that extend the use of JSON. Designed to be fast and memory efficient
+
+Features:
+
+- [x] `parseChunked()` – Parse JSON that comes by chunks (e.g. FS readable stream or fetch response stream)
+- [x] `stringifyStream()` – Stringify stream (Node.js)
+- [x] `stringifyInfo()` – Get estimated size and other facts of JSON.stringify() without converting a value to string
+- [ ] **TBD** Support for circular references
+- [ ] **TBD** Binary representation [branch](https://github.com/discoveryjs/json-ext/tree/binary)
+- [ ] **TBD** WHATWG [Streams](https://streams.spec.whatwg.org/) support
+
+## Install
+
+```bash
+npm install @discoveryjs/json-ext
+```
+
+## API
+
+- [parseChunked(chunkEmitter)](#parsechunkedchunkemitter)
+- [stringifyStream(value[, replacer[, space]])](#stringifystreamvalue-replacer-space)
+- [stringifyInfo(value[, replacer[, space[, options]]])](#stringifyinfovalue-replacer-space-options)
+    - [Options](#options)
+        - [async](#async)
+        - [continueOnCircular](#continueoncircular)
+- [version](#version)
+
+### parseChunked(chunkEmitter)
+
+Works the same as [`JSON.parse()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse) but takes `chunkEmitter` instead of string and returns [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
+
+> NOTE: `reviver` parameter is not supported yet, but will be added in next releases.
+> NOTE: WHATWG streams aren't supported yet
+
+When to use:
+- It's required to avoid freezing the main thread during big JSON parsing, since this process can be distributed in time
+- Huge JSON needs to be parsed (e.g. >500MB on Node.js)
+- Needed to reduce memory pressure. `JSON.parse()` needs to receive the entire JSON before parsing it. With `parseChunked()` you may parse JSON as first bytes of it comes. This approach helps to avoid storing a huge string in the memory at a single time point and following GC.
+
+[Benchmark](https://github.com/discoveryjs/json-ext/tree/master/benchmarks#parse-chunked)
+
+Usage:
+
+```js
+const { parseChunked } = require('@discoveryjs/json-ext');
+
+// as a regular Promise
+parseChunked(chunkEmitter)
+    .then(data => {
+        /* data is parsed JSON */
+    });
+
+// using await (keep in mind that not every runtime has a support for top level await)
+const data = await parseChunked(chunkEmitter);
+```
+
+Parameter `chunkEmitter` can be:
+- [`ReadableStream`](https://nodejs.org/dist/latest-v14.x/docs/api/stream.html#stream_readable_streams) (Node.js only)
+```js
+const fs = require('fs');
+const { parseChunked } = require('@discoveryjs/json-ext');
+
+parseChunked(fs.createReadStream('path/to/file.json'))
+```
+- Generator, async generator or function that returns iterable (chunks). Chunk might be a `string`, `Uint8Array` or `Buffer` (Node.js only):
+```js
+const { parseChunked } = require('@discoveryjs/json-ext');
+const encoder = new TextEncoder();
+
+// generator
+parseChunked(function*() {
+    yield '{ "hello":';
+    yield Buffer.from(' "wor');    // Node.js only
+    yield encoder.encode('ld" }'); // returns Uint8Array(5) [ 108, 100, 34, 32, 125 ]
+});
+
+// async generator
+parseChunked(async function*() {
+    for await (const chunk of someAsyncSource) {
+        yield chunk;
+    }
+});
+
+// function that returns iterable
+parseChunked(() => ['{ "hello":', ' "world"}'])
+```
+
+Using with [fetch()](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API):
+
+```js
+async function loadData(url) {
+    const response = await fetch(url);
+    const reader = response.body.getReader();
+
+    return parseChunked(async function*() {
+        while (true) {
+            const { done, value } = await reader.read();
+
+            if (done) {
+                break;
+            }
+
+            yield value;
+        }
+    });
+}
+
+loadData('https://example.com/data.json')
+    .then(data => {
+        /* data is parsed JSON */
+    })
+```
+
+### stringifyStream(value[, replacer[, space]])
+
+Works the same as [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify), but returns an instance of [`ReadableStream`](https://nodejs.org/dist/latest-v14.x/docs/api/stream.html#stream_readable_streams) instead of string.
+
+> NOTE: WHATWG Streams aren't supported yet, so function available for Node.js only for now
+
+Departs from JSON.stringify():
+- Outputs `null` when `JSON.stringify()` returns `undefined` (since streams may not emit `undefined`)
+- A promise is resolving and the resulting value is stringifying as a regular one
+- A stream in non-object mode is piping to output as is
+- A stream in object mode is piping to output as an array of objects
+
+When to use:
+- Huge JSON needs to be generated (e.g. >500MB on Node.js)
+- Needed to reduce memory pressure. `JSON.stringify()` needs to generate the entire JSON before send or write it to somewhere. With `stringifyStream()` you may send a result to somewhere as first bytes of the result appears. This approach helps to avoid storing a huge string in the memory at a single time point.
+- The object being serialized contains Promises or Streams (see Usage for examples)
+
+[Benchmark](https://github.com/discoveryjs/json-ext/tree/master/benchmarks#stream-stringifying)
+
+Usage:
+
+```js
+const { stringifyStream } = require('@discoveryjs/json-ext');
+
+// handle events
+stringifyStream(data)
+    .on('data', chunk => console.log(chunk))
+    .on('error', error => consold.error(error))
+    .on('finish', () => console.log('DONE!'));
+
+// pipe into a stream
+stringifyStream(data)
+    .pipe(writableStream);
+```
+
+Using Promise or ReadableStream in serializing object:
+
+```js
+const fs = require('fs');
+const { stringifyStream } = require('@discoveryjs/json-ext');
+
+// output will be
+// {"name":"example","willSerializeResolvedValue":42,"fromFile":[1, 2, 3],"at":{"any":{"level":"promise!"}}}
+stringifyStream({
+    name: 'example',
+    willSerializeResolvedValue: Promise.resolve(42),
+    fromFile: fs.createReadStream('path/to/file.json'), // support file content is "[1, 2, 3]", it'll be inserted as it
+    at: {
+        any: {
+            level: new Promise(resolve => setTimeout(() => resolve('promise!'), 100))
+        }
+    }
+})
+
+// in case several async requests are used in object, it's prefered
+// to put fastest requests first, because in this case
+stringifyStream({
+    foo: fetch('http://example.com/request_takes_2s').then(req => req.json()),
+    bar: fetch('http://example.com/request_takes_5s').then(req => req.json())
+});
+```
+
+Using with [`WritableStream`](https://nodejs.org/dist/latest-v14.x/docs/api/stream.html#stream_writable_streams) (Node.js only):
+
+```js
+const fs = require('fs');
+const { stringifyStream } = require('@discoveryjs/json-ext');
+
+// pipe into a console
+stringifyStream(data)
+    .pipe(process.stdout);
+
+// pipe into a file
+stringifyStream(data)
+    .pipe(fs.createWriteStream('path/to/file.json'));
+
+// wrapping into a Promise
+new Promise((resolve, reject) => {
+    stringifyStream(data)
+        .on('error', reject)
+        .pipe(stream)
+        .on('error', reject)
+        .on('finish', resolve);
+});
+```
+
+### stringifyInfo(value[, replacer[, space[, options]]])
+
+`value`, `replacer` and `space` arguments are the same as for `JSON.stringify()`.
+
+Result is an object:
+
+```js
+{
+    minLength: Number,  // minimal bytes when values is stringified
+    circular: [...],    // list of circular references
+    duplicate: [...],   // list of objects that occur more than once
+    async: [...]        // list of async values, i.e. promises and streams
+}
+```
+
+Example:
+
+```js
+const { stringifyInfo } = require('@discoveryjs/json-ext');
+
+console.log(
+    stringifyInfo({ test: true }).minLength
+);
+// > 13
+// that equals '{"test":true}'.length
+```
+
+#### Options
+
+##### async
+
+Type: `Boolean`  
+Default: `false`
+
+Collect async values (promises and streams) or not.
+
+##### continueOnCircular
+
+Type: `Boolean`  
+Default: `false`
+
+Stop collecting info for a value or not whenever circular reference is found. Setting option to `true` allows to find all circular references.
+
+### version
+
+The version of library, e.g. `"0.3.1"`.
+
+## License
+
+MIT