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

node_modules/regenerate/README.md

@@ -0,0 +1,338 @@
+# Regenerate [![Build status](https://travis-ci.org/mathiasbynens/regenerate.svg?branch=master)](https://travis-ci.org/mathiasbynens/regenerate) [![Code coverage status](https://img.shields.io/codecov/c/github/mathiasbynens/regenerate.svg)](https://codecov.io/gh/mathiasbynens/regenerate)
+
+_Regenerate_ is a Unicode-aware regex generator for JavaScript. It allows you to easily generate ES5-compatible regular expressions based on a given set of Unicode symbols or code points. (This is trickier than you might think, because of [how JavaScript deals with astral symbols](https://mathiasbynens.be/notes/javascript-unicode).)
+
+## Installation
+
+Via [npm](https://npmjs.org/):
+
+```bash
+npm install regenerate
+```
+
+Via [Bower](http://bower.io/):
+
+```bash
+bower install regenerate
+```
+
+In a browser:
+
+```html
+<script src="regenerate.js"></script>
+```
+
+In [Node.js](https://nodejs.org/), [io.js](https://iojs.org/), and [RingoJS ≥ v0.8.0](http://ringojs.org/):
+
+```js
+var regenerate = require('regenerate');
+```
+
+In [Narwhal](http://narwhaljs.org/) and [RingoJS ≤ v0.7.0](http://ringojs.org/):
+
+```js
+var regenerate = require('regenerate').regenerate;
+```
+
+In [Rhino](http://www.mozilla.org/rhino/):
+
+```js
+load('regenerate.js');
+```
+
+Using an AMD loader like [RequireJS](http://requirejs.org/):
+
+```js
+require(
+  {
+    'paths': {
+      'regenerate': 'path/to/regenerate'
+    }
+  },
+  ['regenerate'],
+  function(regenerate) {
+    console.log(regenerate);
+  }
+);
+```
+
+## API
+
+### `regenerate(value1, value2, value3, ...)`
+
+The main Regenerate function. Calling this function creates a new set that gets a chainable API.
+
+```js
+var set = regenerate()
+  .addRange(0x60, 0x69) // add U+0060 to U+0069
+  .remove(0x62, 0x64) // remove U+0062 and U+0064
+  .add(0x1D306); // add U+1D306
+set.valueOf();
+// → [0x60, 0x61, 0x63, 0x65, 0x66, 0x67, 0x68, 0x69, 0x1D306]
+set.toString();
+// → '[`ace-i]|\\uD834\\uDF06'
+set.toRegExp();
+// → /[`ace-i]|\uD834\uDF06/
+```
+
+Any arguments passed to `regenerate()` will be added to the set right away. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted, as well as arrays containing values of these types.
+
+```js
+regenerate(0x1D306, 'A', '©', 0x2603).toString();
+// → '[A\\xA9\\u2603]|\\uD834\\uDF06'
+
+var items = [0x1D306, 'A', '©', 0x2603];
+regenerate(items).toString();
+// → '[A\\xA9\\u2603]|\\uD834\\uDF06'
+```
+
+### `regenerate.prototype.add(value1, value2, value3, ...)`
+
+Any arguments passed to `add()` are added to the set. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted, as well as arrays containing values of these types.
+
+```js
+regenerate().add(0x1D306, 'A', '©', 0x2603).toString();
+// → '[A\\xA9\\u2603]|\\uD834\\uDF06'
+
+var items = [0x1D306, 'A', '©', 0x2603];
+regenerate().add(items).toString();
+// → '[A\\xA9\\u2603]|\\uD834\\uDF06'
+```
+
+It’s also possible to pass in a Regenerate instance. Doing so adds all code points in that instance to the current set.
+
+```js
+var set = regenerate(0x1D306, 'A');
+regenerate().add('©', 0x2603).add(set).toString();
+// → '[A\\xA9\\u2603]|\\uD834\\uDF06'
+```
+
+Note that the initial call to `regenerate()` acts like `add()`. This allows you to create a new Regenerate instance and add some code points to it in one go:
+
+```js
+regenerate(0x1D306, 'A', '©', 0x2603).toString();
+// → '[A\\xA9\\u2603]|\\uD834\\uDF06'
+```
+
+### `regenerate.prototype.remove(value1, value2, value3, ...)`
+
+Any arguments passed to `remove()` are removed from the set. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted, as well as arrays containing values of these types.
+
+```js
+regenerate(0x1D306, 'A', '©', 0x2603).remove('☃').toString();
+// → '[A\\xA9]|\\uD834\\uDF06'
+```
+
+It’s also possible to pass in a Regenerate instance. Doing so removes all code points in that instance from the current set.
+
+```js
+var set = regenerate('☃');
+regenerate(0x1D306, 'A', '©', 0x2603).remove(set).toString();
+// → '[A\\xA9]|\\uD834\\uDF06'
+```
+
+### `regenerate.prototype.addRange(start, end)`
+
+Adds a range of code points from `start` to `end` (inclusive) to the set. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted.
+
+```js
+regenerate(0x1D306).addRange(0x00, 0xFF).toString(16);
+// → '[\\0-\\xFF]|\\uD834\\uDF06'
+
+regenerate().addRange('A', 'z').toString();
+// → '[A-z]'
+```
+
+### `regenerate.prototype.removeRange(start, end)`
+
+Removes a range of code points from `start` to `end` (inclusive) from the set. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted.
+
+```js
+regenerate()
+  .addRange(0x000000, 0x10FFFF) // add all Unicode code points
+  .removeRange('A', 'z') // remove all symbols from `A` to `z`
+  .toString();
+// → '[\\0-@\\{-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]'
+
+regenerate()
+  .addRange(0x000000, 0x10FFFF) // add all Unicode code points
+  .removeRange(0x0041, 0x007A) // remove all code points from U+0041 to U+007A
+  .toString();
+// → '[\\0-@\\{-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]'
+```
+
+### `regenerate.prototype.intersection(codePoints)`
+
+Removes any code points from the set that are not present in both the set and the given `codePoints` array. `codePoints` must be an array of numeric code point values, i.e. numbers.
+
+```js
+regenerate()
+  .addRange(0x00, 0xFF) // add extended ASCII code points
+  .intersection([0x61, 0x69]) // remove all code points from the set except for these
+  .toString();
+// → '[ai]'
+```
+
+Instead of the `codePoints` array, it’s also possible to pass in a Regenerate instance.
+
+```js
+var whitelist = regenerate(0x61, 0x69);
+
+regenerate()
+  .addRange(0x00, 0xFF) // add extended ASCII code points
+  .intersection(whitelist) // remove all code points from the set except for those in the `whitelist` set
+  .toString();
+// → '[ai]'
+```
+
+### `regenerate.prototype.contains(value)`
+
+Returns `true` if the given value is part of the set, and `false` otherwise. Both code points (numbers) and symbols (strings consisting of a single Unicode symbol) are accepted.
+
+```js
+var set = regenerate().addRange(0x00, 0xFF);
+set.contains('A');
+// → true
+set.contains(0x1D306);
+// → false
+```
+
+### `regenerate.prototype.clone()`
+
+Returns a clone of the current code point set. Any actions performed on the clone won’t mutate the original set.
+
+```js
+var setA = regenerate(0x1D306);
+var setB = setA.clone().add(0x1F4A9);
+setA.toArray();
+// → [0x1D306]
+setB.toArray();
+// → [0x1D306, 0x1F4A9]
+```
+
+### `regenerate.prototype.toString(options)`
+
+Returns a string representing (part of) a regular expression that matches all the symbols mapped to the code points within the set.
+
+```js
+regenerate(0x1D306, 0x1F4A9).toString();
+// → '\\uD834\\uDF06|\\uD83D\\uDCA9'
+```
+
+If the `bmpOnly` property of the optional `options` object is set to `true`, the output matches surrogates individually, regardless of whether they’re lone surrogates or just part of a surrogate pair. This simplifies the output, but it can only be used in case you’re certain the strings it will be used on don’t contain any astral symbols.
+
+```js
+var highSurrogates = regenerate().addRange(0xD800, 0xDBFF);
+highSurrogates.toString();
+// → '[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])'
+highSurrogates.toString({ 'bmpOnly': true });
+// → '[\\uD800-\\uDBFF]'
+
+var lowSurrogates = regenerate().addRange(0xDC00, 0xDFFF);
+lowSurrogates.toString();
+// → '(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]'
+lowSurrogates.toString({ 'bmpOnly': true });
+// → '[\\uDC00-\\uDFFF]'
+```
+
+Note that lone low surrogates cannot be matched accurately using regular expressions in JavaScript without the use of [lookbehind assertions](https://mathiasbynens.be/notes/es-regexp-proposals#lookbehinds), which aren't yet widely supported. Regenerate’s output makes a best-effort approach but [there can be false negatives in this regard](https://github.com/mathiasbynens/regenerate/issues/28#issuecomment-72224808).
+
+If the `hasUnicodeFlag` property of the optional `options` object is set to `true`, the output makes use of Unicode code point escapes (`\u{…}`) where applicable. This simplifies the output at the cost of compatibility and portability, since it means the output can only be used as a pattern in a regular expression with [the ES6 `u` flag](https://mathiasbynens.be/notes/es6-unicode-regex) enabled.
+
+```js
+var set = regenerate().addRange(0x0, 0x10FFFF);
+
+set.toString();
+// → '[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]''
+
+set.toString({ 'hasUnicodeFlag': true });
+// → '[\\0-\\u{10FFFF}]'
+```
+
+### `regenerate.prototype.toRegExp(flags = '')`
+
+Returns a regular expression that matches all the symbols mapped to the code points within the set. Optionally, you can pass [flags](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#Parameters) to be added to the regular expression.
+
+```js
+var regex = regenerate(0x1D306, 0x1F4A9).toRegExp();
+// → /\uD834\uDF06|\uD83D\uDCA9/
+regex.test('𝌆');
+// → true
+regex.test('A');
+// → false
+
+// With flags:
+var regex = regenerate(0x1D306, 0x1F4A9).toRegExp('g');
+// → /\uD834\uDF06|\uD83D\uDCA9/g
+```
+
+**Note:** This probably shouldn’t be used. Regenerate is intended as a tool that is used as part of a build process, not at runtime.
+
+### `regenerate.prototype.valueOf()` or `regenerate.prototype.toArray()`
+
+Returns a sorted array of unique code points in the set.
+
+```js
+regenerate(0x1D306)
+  .addRange(0x60, 0x65)
+  .add(0x59, 0x60) // note: 0x59 is added after 0x65, and 0x60 is a duplicate
+  .valueOf();
+// → [0x59, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x1D306]
+```
+
+### `regenerate.version`
+
+A string representing the semantic version number.
+
+## Combine Regenerate with other libraries
+
+Regenerate gets even better when combined with other libraries such as [Punycode.js](https://mths.be/punycode). Here’s an example where [Punycode.js](https://mths.be/punycode) is used to convert a string into an array of code points, that is then passed on to Regenerate:
+
+```js
+var regenerate = require('regenerate');
+var punycode = require('punycode');
+
+var string = 'Lorem ipsum dolor sit amet.';
+// Get an array of all code points used in the string:
+var codePoints = punycode.ucs2.decode(string);
+
+// Generate a regular expression that matches any of the symbols used in the string:
+regenerate(codePoints).toString();
+// → '[ \\.Ladeilmopr-u]'
+```
+
+In ES6 you can do something similar with [`Array.from`](https://mths.be/array-from) which uses [the string’s iterator](https://mathiasbynens.be/notes/javascript-unicode#iterating-over-symbols) to split the given string into an array of strings that each contain a single symbol. [`regenerate()`](#regenerateprototypeaddvalue1-value2-value3-) accepts both strings and code points, remember?
+
+```js
+var regenerate = require('regenerate');
+
+var string = 'Lorem ipsum dolor sit amet.';
+// Get an array of all symbols used in the string:
+var symbols = Array.from(string);
+
+// Generate a regular expression that matches any of the symbols used in the string:
+regenerate(symbols).toString();
+// → '[ \\.Ladeilmopr-u]'
+```
+
+## Support
+
+Regenerate supports at least Chrome 27+, Firefox 3+, Safari 4+, Opera 10+, IE 6+, Node.js v0.10.0+, io.js v1.0.0+, Narwhal 0.3.2+, RingoJS 0.8+, PhantomJS 1.9.0+, and Rhino 1.7RC4+.
+
+## Unit tests & code coverage
+
+After cloning this repository, run `npm install` to install the dependencies needed for Regenerate development and testing. You may want to install Istanbul _globally_ using `npm install istanbul -g`.
+
+Once that’s done, you can run the unit tests in Node using `npm test` or `node tests/tests.js`. To run the tests in Rhino, Ringo, Narwhal, and web browsers as well, use `grunt test`.
+
+To generate the code coverage report, use `grunt cover`.
+
+## Author
+
+| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](https://mathiasbynens.be/) |
+
+## License
+
+Regenerate is available under the [MIT](https://mths.be/mit) license.

node_modules/regenerate-unicode-properties/README.md

@@ -0,0 +1,70 @@
+# regenerate-unicode-properties [![regenerate-unicode-properties on npm](https://img.shields.io/npm/v/regenerate-unicode-properties)](https://www.npmjs.com/package/regenerate-unicode-properties)
+
+_regenerate-unicode-properties_ is a collection of [Regenerate](https://github.com/mathiasbynens/regenerate) sets for [various Unicode properties](https://github.com/tc39/proposal-regexp-unicode-property-escapes).
+
+## Installation
+
+To use _regenerate-unicode-properties_ programmatically, install it as a dependency via [npm](https://www.npmjs.com/):
+
+```bash
+$ npm install regenerate-unicode-properties
+```
+
+## Usage
+
+To get a map of supported properties and their values:
+
+```js
+const properties = require('regenerate-unicode-properties');
+```
+
+To get a specific Regenerate set:
+
+```js
+// Examples:
+const Lu = require('regenerate-unicode-properties/General_Category/Uppercase_Letter.js').characters;
+const Greek = require('regenerate-unicode-properties/Script_Extensions/Greek.js').characters;
+```
+
+Some properties can also refer to strings rather than single characters:
+```js
+const { characters, strings } = require('regenerate-unicode-properties/Property_of_Strings/Basic_Emoji.js');
+```
+
+To get the Unicode version the data was based on:
+
+```js
+const unicodeVersion = require('regenerate-unicode-properties/unicode-version.js');
+```
+
+## For maintainers
+
+### How to publish a new release
+
+1. On the `main` branch, bump the version number in `package.json`:
+
+    ```sh
+    npm version patch -m 'Release v%s'
+    ```
+
+    Instead of `patch`, use `minor` or `major` [as needed](https://semver.org/).
+
+    Note that this produces a Git commit + tag.
+
+1. Push the release commit and tag:
+
+    ```sh
+    git push && git push --tags
+    ```
+
+    Our CI then automatically publishes the new release to npm.
+
+## Author
+
+| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](https://mathiasbynens.be/) |
+
+## License
+
+_regenerate-unicode-properties_ is available under the [MIT](https://mths.be/mit) license.

node_modules/regenerator-runtime/README.md

@@ -0,0 +1,31 @@
+# regenerator-runtime
+
+Standalone runtime for
+[Regenerator](https://github.com/facebook/regenerator)-compiled generator
+and `async` functions.
+
+To import the runtime as a module (recommended), either of the following
+import styles will work:
+```js
+// CommonJS
+const regeneratorRuntime = require("regenerator-runtime");
+
+// ECMAScript 2015
+import regeneratorRuntime from "regenerator-runtime";
+```
+
+To ensure that `regeneratorRuntime` is defined globally, either of the
+following styles will work:
+```js
+// CommonJS
+require("regenerator-runtime/runtime");
+
+// ECMAScript 2015
+import "regenerator-runtime/runtime.js";
+```
+
+To get the absolute file system path of `runtime.js`, evaluate the
+following expression:
+```js
+require("regenerator-runtime/path").path
+```

node_modules/regenerator-transform/README.md

@@ -0,0 +1,46 @@
+# regenerator-transform
+
+Transform async/generator functions with [regenerator](https://github.com/facebook/regenerator)
+
+## Installation
+
+```sh
+$ npm install regenerator-transform
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```js
+// without options
+{
+  "plugins": ["regenerator-transform"]
+}
+// with options
+{
+  "plugins": [
+    ["regenerator-transform", {
+      asyncGenerators: false, // true by default
+      generators: false, // true by default
+      async: false // true by default
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+$ babel --plugins regenerator-transform script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transformSync("code", {
+  plugins: ["regenerator-transform"]
+});
+```

node_modules/regexp.prototype.flags/README.md

@@ -0,0 +1,55 @@
+RegExp.prototype.flags <sup>[![Version Badge][npm-version-svg]][package-url]</sup>
+
+[![Build Status][travis-svg]][travis-url]
+[![dependency status][deps-svg]][deps-url]
+[![dev dependency status][dev-deps-svg]][dev-deps-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][npm-badge-png]][package-url]
+
+[![browser support][testling-svg]][testling-url]
+
+An ES6 spec-compliant `RegExp.prototype.flags` shim. Invoke its "shim" method to shim RegExp.prototype.flags if it is unavailable.
+*Note*: `RegExp#flags` requires a true ES5 environment - specifically, one with ES5 getters.
+
+This package implements the [es-shim API](https://github.com/es-shims/api) interface. It works in an ES5-supported environment and complies with the [spec](http://www.ecma-international.org/ecma-262/6.0/#sec-get-regexp.prototype.flags).
+
+Most common usage:
+```js
+var flags = require('regexp.prototype.flags');
+var assert = require('assert');
+
+assert(flags(/a/) === '');
+assert(flags(new RegExp('a')) === '');
+assert(flags(/a/mig) === 'gim');
+assert(flags(new RegExp('a', 'mig')) === 'gim');
+
+if (!RegExp.prototype.flags) {
+	flags.shim();
+}
+
+assert(flags(/a/) === /a/.flags);
+assert(flags(new RegExp('a')) === new RegExp('a').flags);
+assert(flags(/a/mig) === /a/mig.flags);
+assert(flags(new RegExp('a', 'mig')) === new RegExp('a', 'mig').flags);
+```
+
+## Tests
+Simply clone the repo, `npm install`, and run `npm test`
+
+[package-url]: https://npmjs.com/package/regexp.prototype.flags
+[npm-version-svg]: http://versionbadg.es/es-shims/RegExp.prototype.flags.svg
+[travis-svg]: https://travis-ci.org/es-shims/RegExp.prototype.flags.svg
+[travis-url]: https://travis-ci.org/es-shims/RegExp.prototype.flags
+[deps-svg]: https://david-dm.org/es-shims/RegExp.prototype.flags.svg
+[deps-url]: https://david-dm.org/es-shims/RegExp.prototype.flags
+[dev-deps-svg]: https://david-dm.org/es-shims/RegExp.prototype.flags/dev-status.svg
+[dev-deps-url]: https://david-dm.org/es-shims/RegExp.prototype.flags#info=devDependencies
+[testling-svg]: https://ci.testling.com/es-shims/RegExp.prototype.flags.png
+[testling-url]: https://ci.testling.com/es-shims/RegExp.prototype.flags
+[npm-badge-png]: https://nodei.co/npm/regexp.prototype.flags.png?downloads=true&stars=true
+[license-image]: http://img.shields.io/npm/l/regexp.prototype.flags.svg
+[license-url]: LICENSE
+[downloads-image]: http://img.shields.io/npm/dm/regexp.prototype.flags.svg
+[downloads-url]: http://npm-stat.com/charts.html?package=regexp.prototype.flags