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

node_modules/electron-to-chromium/README.md

@@ -0,0 +1,186 @@
+### Made by [@kilianvalkhof](https://twitter.com/kilianvalkhof)
+
+#### Other projects:
+
+- 💻 [Polypane](https://polypane.app) - Develop responsive websites and apps twice as fast on multiple screens at once
+- 🖌️ [Superposition](https://superposition.design) - Kickstart your design system by extracting design tokens from your website
+- 🗒️ [FromScratch](https://fromscratch.rocks) - A smart but simple autosaving scratchpad
+
+---
+
+# Electron-to-Chromium [![npm](https://img.shields.io/npm/v/electron-to-chromium.svg)](https://www.npmjs.com/package/electron-to-chromium) [![travis](https://img.shields.io/travis/Kilian/electron-to-chromium/master.svg)](https://travis-ci.org/Kilian/electron-to-chromium) [![npm-downloads](https://img.shields.io/npm/dm/electron-to-chromium.svg)](https://www.npmjs.com/package/electron-to-chromium) [![codecov](https://codecov.io/gh/Kilian/electron-to-chromium/branch/master/graph/badge.svg)](https://codecov.io/gh/Kilian/electron-to-chromium)[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2FKilian%2Felectron-to-chromium.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2FKilian%2Felectron-to-chromium?ref=badge_shield)
+
+This repository provides a mapping of Electron versions to the Chromium version that it uses.
+
+This package is used in [Browserslist](https://github.com/ai/browserslist), so you can use e.g. `electron >= 1.4` in [Autoprefixer](https://github.com/postcss/autoprefixer), [Stylelint](https://github.com/stylelint/stylelint), [babel-preset-env](https://github.com/babel/babel-preset-env) and [eslint-plugin-compat](https://github.com/amilajack/eslint-plugin-compat).
+
+**Supported by:**
+
+  <a href="https://m.do.co/c/bb22ea58e765">
+    <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg" width="201px">
+  </a>
+
+
+## Install
+Install using `npm install electron-to-chromium`.
+
+## Usage
+To include Electron-to-Chromium, require it:
+
+```js
+var e2c = require('electron-to-chromium');
+```
+
+### Properties
+The Electron-to-Chromium object has 4 properties to use:
+
+#### `versions`
+An object of key-value pairs with a _major_ Electron version as the key, and the corresponding major Chromium version as the value.
+
+```js
+var versions = e2c.versions;
+console.log(versions['1.4']);
+// returns "53"
+```
+
+#### `fullVersions`
+An object of key-value pairs with a Electron version as the key, and the corresponding full Chromium version as the value.
+
+```js
+var versions = e2c.fullVersions;
+console.log(versions['1.4.11']);
+// returns "53.0.2785.143"
+```
+
+#### `chromiumVersions`
+An object of key-value pairs with a _major_ Chromium version as the key, and the corresponding major Electron version as the value.
+
+```js
+var versions = e2c.chromiumVersions;
+console.log(versions['54']);
+// returns "1.4"
+```
+
+#### `fullChromiumVersions`
+An object of key-value pairs with a Chromium version as the key, and an array of the corresponding major Electron versions as the value.
+
+```js
+var versions = e2c.fullChromiumVersions;
+console.log(versions['54.0.2840.101']);
+// returns ["1.5.1", "1.5.0"]
+```
+### Functions
+
+#### `electronToChromium(query)`
+Arguments:
+* Query: string or number, required. A major or full Electron version.
+
+A function that returns the corresponding Chromium version for a given Electron function. Returns a string.
+
+If you provide it with a major Electron version, it will return a major Chromium version:
+
+```js
+var chromeVersion = e2c.electronToChromium('1.4');
+// chromeVersion is "53"
+```
+
+If you provide it with a full Electron version, it will return the full Chromium version.
+
+```js
+var chromeVersion = e2c.electronToChromium('1.4.11');
+// chromeVersion is "53.0.2785.143"
+```
+
+If a query does not match a Chromium version, it will return `undefined`.
+
+```js
+var chromeVersion = e2c.electronToChromium('9000');
+// chromeVersion is undefined
+```
+
+#### `chromiumToElectron(query)`
+Arguments:
+* Query: string or number, required. A major or full Chromium version.
+
+Returns a string with the corresponding Electron version for a given Chromium query.
+
+If you provide it with a major Chromium version, it will return a major Electron version:
+
+```js
+var electronVersion = e2c.chromiumToElectron('54');
+// electronVersion is "1.4"
+```
+
+If you provide it with a full Chrome version, it will return an array of full Electron versions.
+
+```js
+var electronVersions = e2c.chromiumToElectron('56.0.2924.87');
+// electronVersions is ["1.6.3", "1.6.2", "1.6.1", "1.6.0"]
+```
+
+If a query does not match an Electron version, it will return `undefined`.
+
+```js
+var electronVersion = e2c.chromiumToElectron('10');
+// electronVersion is undefined
+```
+
+#### `electronToBrowserList(query)` **DEPRECATED**
+Arguments:
+* Query: string or number, required. A major Electron version.
+
+_**Deprecated**: Browserlist already includes electron-to-chromium._
+
+A function that returns a [Browserslist](https://github.com/ai/browserslist) query that matches the given major Electron version. Returns a string.
+
+If you provide it with a major Electron version, it will return a Browserlist query string that matches the Chromium capabilities:
+
+```js
+var query = e2c.electronToBrowserList('1.4');
+// query is "Chrome >= 53"
+```
+
+If a query does not match a Chromium version, it will return `undefined`.
+
+```js
+var query = e2c.electronToBrowserList('9000');
+// query is undefined
+```
+
+### Importing just versions, fullVersions, chromiumVersions and fullChromiumVersions
+All lists can be imported on their own, if file size is a concern.
+
+#### `versions`
+
+```js
+var versions = require('electron-to-chromium/versions');
+```
+
+#### `fullVersions`
+
+```js
+var fullVersions = require('electron-to-chromium/full-versions');
+```
+
+#### `chromiumVersions`
+
+```js
+var chromiumVersions = require('electron-to-chromium/chromium-versions');
+```
+
+#### `fullChromiumVersions`
+
+```js
+var fullChromiumVersions = require('electron-to-chromium/full-chromium-versions');
+```
+
+## Updating
+This package will be updated with each new Electron release.
+
+To update the list, run `npm run build.js`. Requires internet access as it downloads from the canonical list of Electron versions.
+
+To verify correct behaviour, run `npm test`.
+
+
+## License
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2FKilian%2Felectron-to-chromium.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2FKilian%2Felectron-to-chromium?ref=badge_large)

node_modules/emoji-regex/README.md

@@ -0,0 +1,137 @@
+# emoji-regex [![Build status](https://travis-ci.org/mathiasbynens/emoji-regex.svg?branch=main)](https://travis-ci.org/mathiasbynens/emoji-regex)
+
+_emoji-regex_ offers a regular expression to match all emoji symbols and sequences (including textual representations of emoji) as per the Unicode Standard.
+
+This repository contains a script that generates this regular expression based on [Unicode data](https://github.com/node-unicode/node-unicode-data). Because of this, the regular expression can easily be updated whenever new emoji are added to the Unicode standard.
+
+## Installation
+
+Via [npm](https://www.npmjs.com/):
+
+```bash
+npm install emoji-regex
+```
+
+In [Node.js](https://nodejs.org/):
+
+```js
+const emojiRegex = require('emoji-regex/RGI_Emoji.js');
+// Note: because the regular expression has the global flag set, this module
+// exports a function that returns the regex rather than exporting the regular
+// expression itself, to make it impossible to (accidentally) mutate the
+// original regular expression.
+
+const text = `
+\u{231A}: ⌚ default emoji presentation character (Emoji_Presentation)
+\u{2194}\u{FE0F}: ↔️ default text presentation character rendered as emoji
+\u{1F469}: 👩 emoji modifier base (Emoji_Modifier_Base)
+\u{1F469}\u{1F3FF}: 👩🏿 emoji modifier base followed by a modifier
+`;
+
+const regex = emojiRegex();
+let match;
+while (match = regex.exec(text)) {
+  const emoji = match[0];
+  console.log(`Matched sequence ${ emoji } — code points: ${ [...emoji].length }`);
+}
+```
+
+Console output:
+
+```
+Matched sequence ⌚ — code points: 1
+Matched sequence ⌚ — code points: 1
+Matched sequence ↔️ — code points: 2
+Matched sequence ↔️ — code points: 2
+Matched sequence 👩 — code points: 1
+Matched sequence 👩 — code points: 1
+Matched sequence 👩🏿 — code points: 2
+Matched sequence 👩🏿 — code points: 2
+```
+
+## Regular expression flavors
+
+The package comes with three distinct regular expressions:
+
+```js
+// This is the recommended regular expression to use. It matches all
+// emoji recommended for general interchange, as defined via the
+// `RGI_Emoji` property in the Unicode Standard.
+// https://unicode.org/reports/tr51/#def_rgi_set
+// When in doubt, use this!
+const emojiRegexRGI = require('emoji-regex/RGI_Emoji.js');
+
+// This is the old regular expression, prior to `RGI_Emoji` being
+// standardized. In addition to all `RGI_Emoji` sequences, it matches
+// some emoji you probably don’t want to match (such as emoji component
+// symbols that are not meant to be used separately).
+const emojiRegex = require('emoji-regex/index.js');
+
+// This regular expression matches even more emoji than the previous
+// one, including emoji that render as text instead of icons (i.e.
+// emoji that are not `Emoji_Presentation` symbols and that aren’t
+// forced to render as emoji by a variation selector).
+const emojiRegexText = require('emoji-regex/text.js');
+```
+
+Additionally, in environments which support ES2015 Unicode escapes, you may `require` ES2015-style versions of the regexes:
+
+```js
+const emojiRegexRGI = require('emoji-regex/es2015/RGI_Emoji.js');
+const emojiRegex = require('emoji-regex/es2015/index.js');
+const emojiRegexText = require('emoji-regex/es2015/text.js');
+```
+
+## For maintainers
+
+### How to update emoji-regex after new Unicode Standard releases
+
+1. Update the Unicode data dependency in `package.json` by running the following commands:
+
+    ```sh
+    # Example: updating from Unicode v12 to Unicode v13.
+    npm uninstall @unicode/unicode-12.0.0
+    npm install @unicode/unicode-13.0.0 --save-dev
+    ````
+
+1. Generate the new output:
+
+    ```sh
+    npm run build
+    ```
+
+1. Verify that tests still pass:
+
+    ```sh
+    npm test
+    ```
+
+1. Send a pull request with the changes, and get it reviewed & merged.
+
+1. On the `main` branch, bump the emoji-regex 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
+    ```
+
+    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
+
+_emoji-regex_ is available under the [MIT](https://mths.be/mit) license.

node_modules/enhanced-resolve/README.md

@@ -0,0 +1,183 @@
+# enhanced-resolve
+
+[![npm][npm]][npm-url]
+[![Build Status][build-status]][build-status-url]
+[![codecov][codecov-badge]][codecov-url]
+[![Install Size][size]][size-url]
+[![GitHub Discussions][discussion]][discussion-url]
+
+Offers an async require.resolve function. It's highly configurable.
+
+## Features
+
+- plugin system
+- provide a custom filesystem
+- sync and async node.js filesystems included
+
+## Getting Started
+
+### Install
+
+```sh
+# npm
+npm install enhanced-resolve
+# or Yarn
+yarn add enhanced-resolve
+```
+
+### Resolve
+
+There is a Node.js API which allows to resolve requests according to the Node.js resolving rules.
+Sync and async APIs are offered. A `create` method allows to create a custom resolve function.
+
+```js
+const resolve = require("enhanced-resolve");
+
+resolve("/some/path/to/folder", "module/dir", (err, result) => {
+	result; // === "/some/path/node_modules/module/dir/index.js"
+});
+
+resolve.sync("/some/path/to/folder", "../../dir");
+// === "/some/path/dir/index.js"
+
+const myResolve = resolve.create({
+	// or resolve.create.sync
+	extensions: [".ts", ".js"]
+	// see more options below
+});
+
+myResolve("/some/path/to/folder", "ts-module", (err, result) => {
+	result; // === "/some/node_modules/ts-module/index.ts"
+});
+```
+
+### Creating a Resolver
+
+The easiest way to create a resolver is to use the `createResolver` function on `ResolveFactory`, along with one of the supplied File System implementations.
+
+```js
+const fs = require("fs");
+const { CachedInputFileSystem, ResolverFactory } = require("enhanced-resolve");
+
+// create a resolver
+const myResolver = ResolverFactory.createResolver({
+	// Typical usage will consume the `fs` + `CachedInputFileSystem`, which wraps Node.js `fs` to add caching.
+	fileSystem: new CachedInputFileSystem(fs, 4000),
+	extensions: [".js", ".json"]
+	/* any other resolver options here. Options/defaults can be seen below */
+});
+
+// resolve a file with the new resolver
+const context = {};
+const lookupStartPath = "/Users/webpack/some/root/dir";
+const request = "./path/to-look-up.js";
+const resolveContext = {};
+myResolver.resolve(context, lookupStartPath, request, resolveContext, (
+	err /*Error*/,
+	filepath /*string*/
+) => {
+	// Do something with the path
+});
+```
+
+#### Resolver Options
+
+| Field            | Default                     | Description                                                                                                                                               |
+|------------------|-----------------------------| --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| alias            | []                          | A list of module alias configurations or an object which maps key to value                                                                                |
+| aliasFields      | []                          | A list of alias fields in description files                                                                                                               |
+| extensionAlias   | {}                          | An object which maps extension to extension aliases                                                                                                       |
+| cachePredicate   | function() { return true }; | A function which decides whether a request should be cached or not. An object is passed to the function with `path` and `request` properties.             |
+| cacheWithContext | true                        | If unsafe cache is enabled, includes `request.context` in the cache key                                                                                   |
+| conditionNames   | []                          | A list of exports field condition names                                                                                                                   |
+| descriptionFiles | ["package.json"]            | A list of description files to read from                                                                                                                  |
+| enforceExtension | false                       | Enforce that a extension from extensions must be used                                                                                                     |
+| exportsFields    | ["exports"]                 | A list of exports fields in description files                                                                                                             |
+| extensions       | [".js", ".json", ".node"]   | A list of extensions which should be tried for files                                                                                                      |
+| fallback         | []                          | Same as `alias`, but only used if default resolving fails                                                                                                |                                                                                                                                                                                         
+| fileSystem       |                             | The file system which should be used                                                                                                                      |
+| fullySpecified   | false                       | Request passed to resolve is already fully specified and extensions or main files are not resolved for it (they are still resolved for internal requests) |
+| mainFields       | ["main"]                    | A list of main fields in description files                                                                                                                |
+| mainFiles        | ["index"]                   | A list of main files in directories                                                                                                                       |
+| modules          | ["node_modules"]            | A list of directories to resolve modules from, can be absolute path or folder name                                                                        |
+| plugins          | []                          | A list of additional resolve plugins which should be applied                                                                                              |
+| resolver         | undefined                   | A prepared Resolver to which the plugins are attached                                                                                                     |
+| resolveToContext | false                       | Resolve to a context instead of a file                                                                                                                    |
+| preferRelative   | false                       | Prefer to resolve module requests as relative request and fallback to resolving as module                                                                 |
+| preferAbsolute   | false                       | Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots                                                          |
+| restrictions     | []                          | A list of resolve restrictions                                                                                                                            |
+| roots            | []                          | A list of root paths                                                                                                                                      |
+| symlinks         | true                        | Whether to resolve symlinks to their symlinked location                                                                                                   |
+| unsafeCache      | false                       | Use this cache object to unsafely cache the successful requests                                                                                           |
+
+## Plugins
+
+Similar to `webpack`, the core of `enhanced-resolve` functionality is implemented as individual plugins that are executed using [`tapable`](https://github.com/webpack/tapable).
+These plugins can extend the functionality of the library, adding other ways for files/contexts to be resolved.
+
+A plugin should be a `class` (or its ES5 equivalent) with an `apply` method. The `apply` method will receive a `resolver` instance, that can be used to hook in to the event system.
+
+### Plugin Boilerplate
+
+```js
+class MyResolverPlugin {
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
+
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("MyResolverPlugin", (request, resolveContext, callback) => {
+				// Any logic you need to create a new `request` can go here
+				resolver.doResolve(target, request, null, resolveContext, callback);
+			});
+	}
+}
+```
+
+Plugins are executed in a pipeline, and register which event they should be executed before/after. In the example above, `source` is the name of the event that starts the pipeline, and `target` is what event this plugin should fire, which is what continues the execution of the pipeline. For an example of how these different plugin events create a chain, see `lib/ResolverFactory.js`, in the `//// pipeline ////` section.
+
+## Escaping
+
+It's allowed to escape `#` as `\0#` to avoid parsing it as fragment.
+
+enhanced-resolve will try to resolve requests containing `#` as path and as fragment, so it will automatically figure out if `./some#thing` means `.../some.js#thing` or `.../some#thing.js`. When a `#` is resolved as path it will be escaped in the result. Here: `.../some\0#thing.js`.
+
+## Tests
+
+```javascript
+yarn test
+```
+
+## Passing options from webpack
+
+If you are using `webpack`, and you want to pass custom options to `enhanced-resolve`, the options are passed from the `resolve` key of your webpack configuration e.g.:
+
+```
+resolve: {
+  extensions: ['.js', '.jsx'],
+  modules: [path.resolve(__dirname, 'src'), 'node_modules'],
+  plugins: [new DirectoryNamedWebpackPlugin()]
+  ...
+},
+```
+
+## License
+
+Copyright (c) 2012-2019 JS Foundation and other contributors
+
+MIT (http://www.opensource.org/licenses/mit-license.php)
+
+[npm]: https://img.shields.io/npm/v/enhanced-resolve.svg
+[npm-url]: https://www.npmjs.com/package/enhanced-resolve
+[build-status]: https://github.com/webpack/enhanced-resolve/actions/workflows/test.yml/badge.svg?branch=master
+[build-status-url]: https://github.com/webpack/enhanced-resolve/actions
+[codecov-badge]: https://codecov.io/gh/webpack/enhanced-resolve/branch/main/graph/badge.svg?token=6B6NxtsZc3
+[codecov-url]: https://codecov.io/gh/webpack/enhanced-resolve
+[size]: https://packagephobia.com/badge?p=enhanced-resolve
+[size-url]: https://packagephobia.com/result?p=enhanced-resolve
+[discussion]: https://img.shields.io/github/discussions/webpack/webpack
+[discussion-url]: https://github.com/webpack/webpack/discussions