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

node_modules/webpack-merge/README.md

@@ -0,0 +1,314 @@
+[![Financial Contributors on Open Collective](https://opencollective.com/webpack-merge/all/badge.svg?label=financial+contributors)](https://opencollective.com/webpack-merge) [![Test](https://github.com/survivejs/webpack-merge/actions/workflows/test.yml/badge.svg?branch=develop&event=push)](https://github.com/survivejs/webpack-merge/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/survivejs/webpack-merge/branch/master/graph/badge.svg)](https://codecov.io/gh/survivejs/webpack-merge)
+
+# webpack-merge - Merge designed for Webpack
+
+**webpack-merge** provides a `merge` function that concatenates arrays and merges objects creating a new object. If functions are encountered, it will execute them, run the results through the algorithm, and then wrap the returned values within a function again.
+
+This behavior is particularly useful in configuring webpack although it has uses beyond it. Whenever you need to merge configuration objects, **webpack-merge** can come in handy.
+
+## **`merge(...configuration | [...configuration])`**
+
+`merge` is the core, and the most important idea, of the API. Often this is all you need unless you want further customization.
+
+```javascript
+const { merge } = require('webpack-merge');
+
+// Default API
+const output = merge(object1, object2, object3, ...);
+
+// You can pass an array of objects directly.
+// This works with all available functions.
+const output = merge([object1, object2, object3]);
+
+// Keys matching to the right take precedence:
+const output = merge(
+  { fruit: "apple", color: "red" },
+  { fruit: "strawberries" }
+);
+console.log(output);
+// { color: "red", fruit: "strawberries"}
+```
+
+### Limitations
+
+Note that `Promise`s are not supported! If you want to return a configuration wrapped within a `Promise`, `merge` inside one. Example: `Promise.resolve(merge({ ... }, { ... }))`.
+
+The same goes for configuration level functions as in the example below:
+
+**webpack.config.js**
+
+```javascript
+const commonConfig = { ... };
+
+const productionConfig = { ... };
+
+const developmentConfig = { ... };
+
+module.exports = (env, args) => {
+  switch(args.mode) {
+    case 'development':
+      return merge(commonConfig, developmentConfig);
+    case 'production':
+      return merge(commonConfig, productionConfig);
+    default:
+      throw new Error('No matching configuration was found!');
+  }
+}
+```
+
+You can choose the configuration you want by using `webpack --mode development` assuming you are using _webpack-cli_.
+
+## **`mergeWithCustomize({ customizeArray, customizeObject })(...configuration | [...configuration])`**
+
+In case you need more flexibility, `merge` behavior can be customized per field as below:
+
+```javascript
+const { mergeWithCustomize } = require('webpack-merge');
+
+const output = mergeWithCustomize(
+  {
+    customizeArray(a, b, key) {
+      if (key === 'extensions') {
+        return _.uniq([...a, ...b]);
+      }
+
+      // Fall back to default merging
+      return undefined;
+    },
+    customizeObject(a, b, key) {
+      if (key === 'module') {
+        // Custom merging
+        return _.merge({}, a, b);
+      }
+
+      // Fall back to default merging
+      return undefined;
+    }
+  }
+)(object1, object2, object3, ...);
+```
+
+For example, if the previous code was invoked with only `object1` and `object2`
+with `object1` as:
+
+```javascript
+{
+    foo1: ['object1'],
+    foo2: ['object1'],
+    bar1: { object1: {} },
+    bar2: { object1: {} },
+}
+```
+
+and `object2` as:
+
+```javascript
+{
+    foo1: ['object2'],
+    foo2: ['object2'],
+    bar1: { object2: {} },
+    bar2: { object2: {} },
+}
+```
+
+then `customizeArray` will be invoked for each property of `Array` type, i.e:
+
+```javascript
+customizeArray(["object1"], ["object2"], "foo1");
+customizeArray(["object1"], ["object2"], "foo2");
+```
+
+and `customizeObject` will be invoked for each property of `Object` type, i.e:
+
+```javascript
+customizeObject({ object1: {} }, { object2: {} }, bar1);
+customizeObject({ object1: {} }, { object2: {} }, bar2);
+```
+
+## **`customizeArray`** and **`customizeObject`**
+
+`customizeArray` and `customizeObject` provide small strategies to for `mergeWithCustomize`. They support `append`, `prepend`, `replace`, and wildcards for field names.
+
+```javascript
+const { mergeWithCustomize, customizeArray, customizeObject } = require('webpack-merge');
+
+const output = mergeWithCustomize({
+  customizeArray: customizeArray({
+    'entry.*': 'prepend'
+  }),
+  customizeObject: customizeObject({
+    entry: 'prepend'
+  })
+})(object1, object2, object3, ...);
+```
+
+## **`unique(<field>, <fields>, field => field)`**
+
+`unique` is a strategy used for forcing uniqueness within configuration. It's most useful with plugins when you want to make sure there's only one in place.
+
+The first `<field>` is the config property to look through for duplicates.
+
+`<fields>` represents the values that should be unique when you run the field => field function on each duplicate.
+
+When the order of elements of the `<field>` in the first configuration differs from the order in the second configuration, the latter is preserved.
+
+```javascript
+const { mergeWithCustomize, unique } = require("webpack-merge");
+
+const output = mergeWithCustomize({
+  customizeArray: unique(
+    "plugins",
+    ["HotModuleReplacementPlugin"],
+    (plugin) => plugin.constructor && plugin.constructor.name
+  ),
+})(
+  {
+    plugins: [new webpack.HotModuleReplacementPlugin()],
+  },
+  {
+    plugins: [new webpack.HotModuleReplacementPlugin()],
+  }
+);
+
+// Output contains only single HotModuleReplacementPlugin now and it's
+// going to be the last plugin instance.
+```
+
+## **`mergeWithRules`**
+
+To support advanced merging needs (i.e. merging within loaders), `mergeWithRules` includes additional syntax that allows you to match fields and apply strategies to match. Consider the full example below:
+
+```javascript
+const a = {
+  module: {
+    rules: [
+      {
+        test: /\.css$/,
+        use: [{ loader: "style-loader" }, { loader: "sass-loader" }],
+      },
+    ],
+  },
+};
+const b = {
+  module: {
+    rules: [
+      {
+        test: /\.css$/,
+        use: [
+          {
+            loader: "style-loader",
+            options: {
+              modules: true,
+            },
+          },
+        ],
+      },
+    ],
+  },
+};
+const result = {
+  module: {
+    rules: [
+      {
+        test: /\.css$/,
+        use: [
+          {
+            loader: "style-loader",
+            options: {
+              modules: true,
+            },
+          },
+          { loader: "sass-loader" },
+        ],
+      },
+    ],
+  },
+};
+
+assert.deepStrictEqual(
+  mergeWithRules({
+    module: {
+      rules: {
+        test: "match",
+        use: {
+          loader: "match",
+          options: "replace",
+        },
+      },
+    },
+  })(a, b),
+  result
+);
+```
+
+The way it works is that you should annotate fields to match using `match` (or `CustomizeRule.Match` if you are using TypeScript) matching your configuration structure and then use specific strategies to define how particular fields should be transformed. If a match doesn't exist above a rule, then it will apply the rule automatically.
+
+**Supported annotations:**
+
+- `match` (`CustomizeRule.Match`) - Optional matcher that scopes merging behavior to a specific part based on similarity (think DOM or jQuery selectors)
+- `append` (`CustomizeRule.Append`) - Appends items
+- `prepend` (`CustomizeRule.Prepend`) - Prepends items
+- `replace` (`CustomizeRule.Replace`) - Replaces items
+- `merge` (`CustomizeRule.Merge`) - Merges objects (shallow merge)
+
+## Using with TypeScript
+
+**webpack-merge** supports TypeScript out of the box. You should pass `Configuration` type from webpack to it as follows:
+
+```typescript
+import { Configuration } from "webpack";
+import { merge } from "webpack-merge";
+
+const config = merge<Configuration>({...}, {...});
+
+...
+```
+
+## Development
+
+1. `nvm use`
+1. `npm i`
+1. `npm run build -- --watch` in one terminal
+1. `npm t -- --watch` in another one
+
+Before contributing, please [open an issue](https://github.com/survivejs/webpack-merge/issues/new) where to discuss.
+
+## Further Information and Support
+
+Check out [SurviveJS - Webpack 5](http://survivejs.com/) to dig deeper into webpack. The free book uses **webpack-merge** extensively and shows you how to compose your configuration to keep it maintainable.
+
+I am also available as a consultant in case you require specific assistance. I can contribute particularly in terms of improving maintainability of the setup while speeding it up and pointing out better practices. In addition to improving developer productivity, the work has impact on the end users of the product in terms of reduced application size and loading times.
+
+## Contributors
+
+### Code Contributors
+
+This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
+<a href="https://github.com/survivejs/webpack-merge/graphs/contributors"><img src="https://opencollective.com/webpack-merge/contributors.svg?width=890&button=false" /></a>
+
+### Financial Contributors
+
+Become a financial contributor and help us sustain our community. [[Contribute](https://opencollective.com/webpack-merge/contribute)]
+
+#### Individuals
+
+<a href="https://opencollective.com/webpack-merge"><img src="https://opencollective.com/webpack-merge/individuals.svg?width=890"></a>
+
+#### Organizations
+
+Support this project with your organization. Your logo will show up here with a link to your website. [[Contribute](https://opencollective.com/webpack-merge/contribute)]
+
+<a href="https://opencollective.com/webpack-merge/organization/0/website"><img src="https://opencollective.com/webpack-merge/organization/0/avatar.svg"></a>
+<a href="https://opencollective.com/webpack-merge/organization/1/website"><img src="https://opencollective.com/webpack-merge/organization/1/avatar.svg"></a>
+<a href="https://opencollective.com/webpack-merge/organization/2/website"><img src="https://opencollective.com/webpack-merge/organization/2/avatar.svg"></a>
+<a href="https://opencollective.com/webpack-merge/organization/3/website"><img src="https://opencollective.com/webpack-merge/organization/3/avatar.svg"></a>
+<a href="https://opencollective.com/webpack-merge/organization/4/website"><img src="https://opencollective.com/webpack-merge/organization/4/avatar.svg"></a>
+<a href="https://opencollective.com/webpack-merge/organization/5/website"><img src="https://opencollective.com/webpack-merge/organization/5/avatar.svg"></a>
+<a href="https://opencollective.com/webpack-merge/organization/6/website"><img src="https://opencollective.com/webpack-merge/organization/6/avatar.svg"></a>
+<a href="https://opencollective.com/webpack-merge/organization/7/website"><img src="https://opencollective.com/webpack-merge/organization/7/avatar.svg"></a>
+<a href="https://opencollective.com/webpack-merge/organization/8/website"><img src="https://opencollective.com/webpack-merge/organization/8/avatar.svg"></a>
+<a href="https://opencollective.com/webpack-merge/organization/9/website"><img src="https://opencollective.com/webpack-merge/organization/9/avatar.svg"></a>
+
+## License
+
+**webpack-merge** is available under MIT. See LICENSE for more details.

node_modules/webpack-sources/README.md

@@ -0,0 +1,228 @@
+# webpack-sources
+
+Contains multiple classes which represent a `Source`. A `Source` can be asked for source code, size, source map and hash.
+
+## `Source`
+
+Base class for all sources.
+
+### Public methods
+
+All methods should be considered as expensive as they may need to do computations.
+
+#### `source`
+
+```typescript
+Source.prototype.source() -> String | Buffer
+```
+
+Returns the represented source code as string or Buffer (for binary Sources).
+
+#### `buffer`
+
+```typescript
+Source.prototype.buffer() -> Buffer
+```
+
+Returns the represented source code as Buffer. Strings are converted to utf-8.
+
+#### `size`
+
+```typescript
+Source.prototype.size() -> Number
+```
+
+Returns the size in bytes of the represented source code.
+
+#### `map`
+
+```typescript
+Source.prototype.map(options?: Object) -> Object | null
+```
+
+Returns the SourceMap of the represented source code as JSON. May return `null` if no SourceMap is available.
+
+The `options` object can contain the following keys:
+
+- `columns: Boolean` (default `true`): If set to false the implementation may omit mappings for columns.
+
+#### `sourceAndMap`
+
+```typescript
+Source.prototype.sourceAndMap(options?: Object) -> {
+	source: String | Buffer,
+	map: Object | null
+}
+```
+
+Returns both, source code (like `Source.prototype.source()` and SourceMap (like `Source.prototype.map()`). This method could have better performance than calling `source()` and `map()` separately.
+
+See `map()` for `options`.
+
+#### `updateHash`
+
+```typescript
+Source.prototype.updateHash(hash: Hash) -> void
+```
+
+Updates the provided `Hash` object with the content of the represented source code. (`Hash` is an object with an `update` method, which is called with string values)
+
+## `RawSource`
+
+Represents source code without SourceMap.
+
+```typescript
+new RawSource(sourceCode: String | Buffer)
+```
+
+## `OriginalSource`
+
+Represents source code, which is a copy of the original file.
+
+```typescript
+new OriginalSource(
+	sourceCode: String | Buffer,
+	name: String
+)
+```
+
+- `sourceCode`: The source code.
+- `name`: The filename of the original source code.
+
+OriginalSource tries to create column mappings if requested, by splitting the source code at typical statement borders (`;`, `{`, `}`).
+
+## `SourceMapSource`
+
+Represents source code with SourceMap, optionally having an additional SourceMap for the original source.
+
+```typescript
+new SourceMapSource(
+	sourceCode: String | Buffer,
+	name: String,
+	sourceMap: Object | String | Buffer,
+	originalSource?: String | Buffer,
+	innerSourceMap?: Object | String | Buffer,
+	removeOriginalSource?: boolean
+)
+```
+
+- `sourceCode`: The source code.
+- `name`: The filename of the original source code.
+- `sourceMap`: The SourceMap for the source code.
+- `originalSource`: The source code of the original file. Can be omitted if the `sourceMap` already contains the original source code.
+- `innerSourceMap`: The SourceMap for the `originalSource`/`name`.
+- `removeOriginalSource`: Removes the source code for `name` from the final map, keeping only the deeper mappings for that file.
+
+The `SourceMapSource` supports "identity" mappings for the `innerSourceMap`.
+When original source matches generated source for a mapping it's assumed to be mapped char by char allowing to keep finer mappings from `sourceMap`.
+
+## `CachedSource`
+
+Decorates a `Source` and caches returned results of `map`, `source`, `buffer`, `size` and `sourceAndMap` in memory. `updateHash` is not cached.
+It tries to reused cached results from other methods to avoid calculations, i. e. when `source` is already cached, calling `size` will get the size from the cached source, calling `sourceAndMap` will only call `map` on the wrapped Source.
+
+```typescript
+new CachedSource(source: Source)
+new CachedSource(source: Source | () => Source, cachedData?: CachedData)
+```
+
+Instead of passing a `Source` object directly one can pass an function that returns a `Source` object. The function is only called when needed and once.
+
+### Public methods
+
+#### `getCachedData()`
+
+Returns the cached data for passing to the constructor. All cached entries are converted to Buffers and strings are avoided.
+
+#### `original()`
+
+Returns the original `Source` object.
+
+#### `originalLazy()`
+
+Returns the original `Source` object or a function returning these.
+
+## `PrefixSource`
+
+Prefix every line of the decorated `Source` with a provided string.
+
+```typescript
+new PrefixSource(
+	prefix: String,
+	source: Source | String | Buffer
+)
+```
+
+## `ConcatSource`
+
+Concatenate multiple `Source`s or strings to a single source.
+
+```typescript
+new ConcatSource(
+	...items?: Source | String
+)
+```
+
+### Public methods
+
+#### `add`
+
+```typescript
+ConcatSource.prototype.add(item: Source | String)
+```
+
+Adds an item to the source.
+
+## `ReplaceSource`
+
+Decorates a `Source` with replacements and insertions of source code.
+
+The `ReplaceSource` supports "identity" mappings for child source.
+When original source matches generated source for a mapping it's assumed to be mapped char by char allowing to split mappings at replacements/insertions.
+
+### Public methods
+
+#### `replace`
+
+```typescript
+ReplaceSource.prototype.replace(
+	start: Number,
+	end: Number,
+	replacement: String
+)
+```
+
+Replaces chars from `start` (0-indexed, inclusive) to `end` (0-indexed, inclusive) with `replacement`.
+
+Locations represents locations in the original source and are not influenced by other replacements or insertions.
+
+#### `insert`
+
+```typescript
+ReplaceSource.prototype.insert(
+	pos: Number,
+	insertion: String
+)
+```
+
+Inserts the `insertion` before char `pos` (0-indexed).
+
+Location represents location in the original source and is not influenced by other replacements or insertions.
+
+#### `original`
+
+Get decorated `Source`.
+
+## `CompatSource`
+
+Converts a Source-like object into a real Source object.
+
+### Public methods
+
+#### static `from`
+
+```typescript
+CompatSource.from(sourceLike: any | Source)
+```
+
+If `sourceLike` is a real Source it returns it unmodified. Otherwise it returns it wrapped in a CompatSource.

node_modules/which/README.md

@@ -0,0 +1,54 @@
+# which
+
+Like the unix `which` utility.
+
+Finds the first instance of a specified executable in the PATH
+environment variable.  Does not cache the results, so `hash -r` is not
+needed when the PATH changes.
+
+## USAGE
+
+```javascript
+var which = require('which')
+
+// async usage
+which('node', function (er, resolvedPath) {
+  // er is returned if no "node" is found on the PATH
+  // if it is found, then the absolute path to the exec is returned
+})
+
+// or promise
+which('node').then(resolvedPath => { ... }).catch(er => { ... not found ... })
+
+// sync usage
+// throws if not found
+var resolved = which.sync('node')
+
+// if nothrow option is used, returns null if not found
+resolved = which.sync('node', {nothrow: true})
+
+// Pass options to override the PATH and PATHEXT environment vars.
+which('node', { path: someOtherPath }, function (er, resolved) {
+  if (er)
+    throw er
+  console.log('found at %j', resolved)
+})
+```
+
+## CLI USAGE
+
+Same as the BSD `which(1)` binary.
+
+```
+usage: which [-as] program ...
+```
+
+## OPTIONS
+
+You may pass an options object as the second argument.
+
+- `path`: Use instead of the `PATH` environment variable.
+- `pathExt`: Use instead of the `PATHEXT` environment variable.
+- `all`: Return all matches, instead of just the first one.  Note that
+  this means the function returns an array of strings instead of a
+  single string.

node_modules/which-boxed-primitive/README.md

@@ -0,0 +1,73 @@
+# which-boxed-primitive <sup>[![Version Badge][2]][1]</sup>
+
+[![dependency status][5]][6]
+[![dev dependency status][7]][8]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][11]][1]
+
+Which kind of boxed JS primitive is this? This module works cross-realm/iframe, does not depend on `instanceof` or mutable properties, and works despite ES6 Symbol.toStringTag.
+
+## Example
+
+```js
+var whichBoxedPrimitive = require('which-boxed-primitive');
+var assert = require('assert');
+
+// unboxed primitives return `null`
+// boxed primitives return the builtin constructor name
+
+assert.equal(whichBoxedPrimitive(undefined), null);
+assert.equal(whichBoxedPrimitive(null), null);
+
+assert.equal(whichBoxedPrimitive(false), null);
+assert.equal(whichBoxedPrimitive(true), null);
+assert.equal(whichBoxedPrimitive(new Boolean(false)), 'Boolean');
+assert.equal(whichBoxedPrimitive(new Boolean(true)), 'Boolean');
+
+assert.equal(whichBoxedPrimitive(42), null);
+assert.equal(whichBoxedPrimitive(NaN), null);
+assert.equal(whichBoxedPrimitive(Infinity), null);
+assert.equal(whichBoxedPrimitive(new Number(42)), 'Number');
+assert.equal(whichBoxedPrimitive(new Number(NaN)), 'Number');
+assert.equal(whichBoxedPrimitive(new Number(Infinity)), 'Number');
+
+assert.equal(whichBoxedPrimitive(''), null);
+assert.equal(whichBoxedPrimitive('foo'), null);
+assert.equal(whichBoxedPrimitive(new String('')), 'String');
+assert.equal(whichBoxedPrimitive(new String('foo')), 'String');
+
+assert.equal(whichBoxedPrimitive(Symbol()), null);
+assert.equal(whichBoxedPrimitive(Object(Symbol()), 'Symbol');
+
+assert.equal(whichBoxedPrimitive(42n), null);
+assert.equal(whichBoxedPrimitive(Object(42n), 'BigInt');
+
+// non-boxed-primitive objects return `undefined`
+assert.equal(whichBoxedPrimitive([]), undefined);
+assert.equal(whichBoxedPrimitive({}), undefined);
+assert.equal(whichBoxedPrimitive(/a/g), undefined);
+assert.equal(whichBoxedPrimitive(new RegExp('a', 'g')), undefined);
+assert.equal(whichBoxedPrimitive(new Date()), undefined);
+assert.equal(whichBoxedPrimitive(function () {}), undefined);
+assert.equal(whichBoxedPrimitive(function* () {}), undefined);
+assert.equal(whichBoxedPrimitive(x => x * x), undefined);
+assert.equal(whichBoxedPrimitive([]), undefined);
+
+```
+
+## Tests
+Simply clone the repo, `npm install`, and run `npm test`
+
+[1]: https://npmjs.org/package/which-boxed-primitive
+[2]: https://versionbadg.es/inspect-js/which-boxed-primitive.svg
+[5]: https://david-dm.org/inspect-js/which-boxed-primitive.svg
+[6]: https://david-dm.org/inspect-js/which-boxed-primitive
+[7]: https://david-dm.org/inspect-js/which-boxed-primitive/dev-status.svg
+[8]: https://david-dm.org/inspect-js/which-boxed-primitive#info=devDependencies
+[11]: https://nodei.co/npm/which-boxed-primitive.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/which-boxed-primitive.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/which-boxed-primitive.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=which-boxed-primitive